x86: Use {push,pop}_cfi in more places
[linux-3.10.git] / arch / x86 / lib / checksum_32.S
1 /*
2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
3  *              operating system.  INET is implemented using the  BSD Socket
4  *              interface as the means of communication with the user level.
5  *
6  *              IP/TCP/UDP checksumming routines
7  *
8  * Authors:     Jorge Cwik, <jorge@laser.satlink.net>
9  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
10  *              Tom May, <ftom@netcom.com>
11  *              Pentium Pro/II routines:
12  *              Alexander Kjeldaas <astor@guardian.no>
13  *              Finn Arne Gangstad <finnag@guardian.no>
14  *              Lots of code moved from tcp.c and ip.c; see those files
15  *              for more names.
16  *
17  * Changes:     Ingo Molnar, converted csum_partial_copy() to 2.1 exception
18  *                           handling.
19  *              Andi Kleen,  add zeroing on error
20  *                   converted to pure assembler
21  *
22  *              This program is free software; you can redistribute it and/or
23  *              modify it under the terms of the GNU General Public License
24  *              as published by the Free Software Foundation; either version
25  *              2 of the License, or (at your option) any later version.
26  */
27
28 #include <linux/linkage.h>
29 #include <asm/dwarf2.h>
30 #include <asm/errno.h>
31                                 
32 /*
33  * computes a partial checksum, e.g. for TCP/UDP fragments
34  */
35
36 /*      
37 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
38  */
39                 
40 .text
41                 
42 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
43
44           /*            
45            * Experiments with Ethernet and SLIP connections show that buff
46            * is aligned on either a 2-byte or 4-byte boundary.  We get at
47            * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
48            * Fortunately, it is easy to convert 2-byte alignment to 4-byte
49            * alignment for the unrolled loop.
50            */           
51 ENTRY(csum_partial)
52         CFI_STARTPROC
53         pushl_cfi %esi
54         CFI_REL_OFFSET esi, 0
55         pushl_cfi %ebx
56         CFI_REL_OFFSET ebx, 0
57         movl 20(%esp),%eax      # Function arg: unsigned int sum
58         movl 16(%esp),%ecx      # Function arg: int len
59         movl 12(%esp),%esi      # Function arg: unsigned char *buff
60         testl $3, %esi          # Check alignment.
61         jz 2f                   # Jump if alignment is ok.
62         testl $1, %esi          # Check alignment.
63         jz 10f                  # Jump if alignment is boundary of 2bytes.
64
65         # buf is odd
66         dec %ecx
67         jl 8f
68         movzbl (%esi), %ebx
69         adcl %ebx, %eax
70         roll $8, %eax
71         inc %esi
72         testl $2, %esi
73         jz 2f
74 10:
75         subl $2, %ecx           # Alignment uses up two bytes.
76         jae 1f                  # Jump if we had at least two bytes.
77         addl $2, %ecx           # ecx was < 2.  Deal with it.
78         jmp 4f
79 1:      movw (%esi), %bx
80         addl $2, %esi
81         addw %bx, %ax
82         adcl $0, %eax
83 2:
84         movl %ecx, %edx
85         shrl $5, %ecx
86         jz 2f
87         testl %esi, %esi
88 1:      movl (%esi), %ebx
89         adcl %ebx, %eax
90         movl 4(%esi), %ebx
91         adcl %ebx, %eax
92         movl 8(%esi), %ebx
93         adcl %ebx, %eax
94         movl 12(%esi), %ebx
95         adcl %ebx, %eax
96         movl 16(%esi), %ebx
97         adcl %ebx, %eax
98         movl 20(%esi), %ebx
99         adcl %ebx, %eax
100         movl 24(%esi), %ebx
101         adcl %ebx, %eax
102         movl 28(%esi), %ebx
103         adcl %ebx, %eax
104         lea 32(%esi), %esi
105         dec %ecx
106         jne 1b
107         adcl $0, %eax
108 2:      movl %edx, %ecx
109         andl $0x1c, %edx
110         je 4f
111         shrl $2, %edx           # This clears CF
112 3:      adcl (%esi), %eax
113         lea 4(%esi), %esi
114         dec %edx
115         jne 3b
116         adcl $0, %eax
117 4:      andl $3, %ecx
118         jz 7f
119         cmpl $2, %ecx
120         jb 5f
121         movw (%esi),%cx
122         leal 2(%esi),%esi
123         je 6f
124         shll $16,%ecx
125 5:      movb (%esi),%cl
126 6:      addl %ecx,%eax
127         adcl $0, %eax 
128 7:      
129         testl $1, 12(%esp)
130         jz 8f
131         roll $8, %eax
132 8:
133         popl_cfi %ebx
134         CFI_RESTORE ebx
135         popl_cfi %esi
136         CFI_RESTORE esi
137         ret
138         CFI_ENDPROC
139 ENDPROC(csum_partial)
140
141 #else
142
143 /* Version for PentiumII/PPro */
144
145 ENTRY(csum_partial)
146         CFI_STARTPROC
147         pushl_cfi %esi
148         CFI_REL_OFFSET esi, 0
149         pushl_cfi %ebx
150         CFI_REL_OFFSET ebx, 0
151         movl 20(%esp),%eax      # Function arg: unsigned int sum
152         movl 16(%esp),%ecx      # Function arg: int len
153         movl 12(%esp),%esi      # Function arg: const unsigned char *buf
154
155         testl $3, %esi         
156         jnz 25f                 
157 10:
158         movl %ecx, %edx
159         movl %ecx, %ebx
160         andl $0x7c, %ebx
161         shrl $7, %ecx
162         addl %ebx,%esi
163         shrl $2, %ebx  
164         negl %ebx
165         lea 45f(%ebx,%ebx,2), %ebx
166         testl %esi, %esi
167         jmp *%ebx
168
169         # Handle 2-byte-aligned regions
170 20:     addw (%esi), %ax
171         lea 2(%esi), %esi
172         adcl $0, %eax
173         jmp 10b
174 25:
175         testl $1, %esi         
176         jz 30f                 
177         # buf is odd
178         dec %ecx
179         jl 90f
180         movzbl (%esi), %ebx
181         addl %ebx, %eax
182         adcl $0, %eax
183         roll $8, %eax
184         inc %esi
185         testl $2, %esi
186         jz 10b
187
188 30:     subl $2, %ecx          
189         ja 20b                 
190         je 32f
191         addl $2, %ecx
192         jz 80f
193         movzbl (%esi),%ebx      # csumming 1 byte, 2-aligned
194         addl %ebx, %eax
195         adcl $0, %eax
196         jmp 80f
197 32:
198         addw (%esi), %ax        # csumming 2 bytes, 2-aligned
199         adcl $0, %eax
200         jmp 80f
201
202 40: 
203         addl -128(%esi), %eax
204         adcl -124(%esi), %eax
205         adcl -120(%esi), %eax
206         adcl -116(%esi), %eax   
207         adcl -112(%esi), %eax   
208         adcl -108(%esi), %eax
209         adcl -104(%esi), %eax
210         adcl -100(%esi), %eax
211         adcl -96(%esi), %eax
212         adcl -92(%esi), %eax
213         adcl -88(%esi), %eax
214         adcl -84(%esi), %eax
215         adcl -80(%esi), %eax
216         adcl -76(%esi), %eax
217         adcl -72(%esi), %eax
218         adcl -68(%esi), %eax
219         adcl -64(%esi), %eax     
220         adcl -60(%esi), %eax     
221         adcl -56(%esi), %eax     
222         adcl -52(%esi), %eax   
223         adcl -48(%esi), %eax   
224         adcl -44(%esi), %eax
225         adcl -40(%esi), %eax
226         adcl -36(%esi), %eax
227         adcl -32(%esi), %eax
228         adcl -28(%esi), %eax
229         adcl -24(%esi), %eax
230         adcl -20(%esi), %eax
231         adcl -16(%esi), %eax
232         adcl -12(%esi), %eax
233         adcl -8(%esi), %eax
234         adcl -4(%esi), %eax
235 45:
236         lea 128(%esi), %esi
237         adcl $0, %eax
238         dec %ecx
239         jge 40b
240         movl %edx, %ecx
241 50:     andl $3, %ecx
242         jz 80f
243
244         # Handle the last 1-3 bytes without jumping
245         notl %ecx               # 1->2, 2->1, 3->0, higher bits are masked
246         movl $0xffffff,%ebx     # by the shll and shrl instructions
247         shll $3,%ecx
248         shrl %cl,%ebx
249         andl -128(%esi),%ebx    # esi is 4-aligned so should be ok
250         addl %ebx,%eax
251         adcl $0,%eax
252 80: 
253         testl $1, 12(%esp)
254         jz 90f
255         roll $8, %eax
256 90: 
257         popl_cfi %ebx
258         CFI_RESTORE ebx
259         popl_cfi %esi
260         CFI_RESTORE esi
261         ret
262         CFI_ENDPROC
263 ENDPROC(csum_partial)
264                                 
265 #endif
266
267 /*
268 unsigned int csum_partial_copy_generic (const char *src, char *dst,
269                                   int len, int sum, int *src_err_ptr, int *dst_err_ptr)
270  */ 
271
272 /*
273  * Copy from ds while checksumming, otherwise like csum_partial
274  *
275  * The macros SRC and DST specify the type of access for the instruction.
276  * thus we can call a custom exception handler for all access types.
277  *
278  * FIXME: could someone double-check whether I haven't mixed up some SRC and
279  *        DST definitions? It's damn hard to trigger all cases.  I hope I got
280  *        them all but there's no guarantee.
281  */
282
283 #define SRC(y...)                       \
284         9999: y;                        \
285         .section __ex_table, "a";       \
286         .long 9999b, 6001f      ;       \
287         .previous
288
289 #define DST(y...)                       \
290         9999: y;                        \
291         .section __ex_table, "a";       \
292         .long 9999b, 6002f      ;       \
293         .previous
294
295 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
296
297 #define ARGBASE 16              
298 #define FP              12
299                 
300 ENTRY(csum_partial_copy_generic)
301         CFI_STARTPROC
302         subl  $4,%esp   
303         CFI_ADJUST_CFA_OFFSET 4
304         pushl_cfi %edi
305         CFI_REL_OFFSET edi, 0
306         pushl_cfi %esi
307         CFI_REL_OFFSET esi, 0
308         pushl_cfi %ebx
309         CFI_REL_OFFSET ebx, 0
310         movl ARGBASE+16(%esp),%eax      # sum
311         movl ARGBASE+12(%esp),%ecx      # len
312         movl ARGBASE+4(%esp),%esi       # src
313         movl ARGBASE+8(%esp),%edi       # dst
314
315         testl $2, %edi                  # Check alignment. 
316         jz 2f                           # Jump if alignment is ok.
317         subl $2, %ecx                   # Alignment uses up two bytes.
318         jae 1f                          # Jump if we had at least two bytes.
319         addl $2, %ecx                   # ecx was < 2.  Deal with it.
320         jmp 4f
321 SRC(1:  movw (%esi), %bx        )
322         addl $2, %esi
323 DST(    movw %bx, (%edi)        )
324         addl $2, %edi
325         addw %bx, %ax   
326         adcl $0, %eax
327 2:
328         movl %ecx, FP(%esp)
329         shrl $5, %ecx
330         jz 2f
331         testl %esi, %esi
332 SRC(1:  movl (%esi), %ebx       )
333 SRC(    movl 4(%esi), %edx      )
334         adcl %ebx, %eax
335 DST(    movl %ebx, (%edi)       )
336         adcl %edx, %eax
337 DST(    movl %edx, 4(%edi)      )
338
339 SRC(    movl 8(%esi), %ebx      )
340 SRC(    movl 12(%esi), %edx     )
341         adcl %ebx, %eax
342 DST(    movl %ebx, 8(%edi)      )
343         adcl %edx, %eax
344 DST(    movl %edx, 12(%edi)     )
345
346 SRC(    movl 16(%esi), %ebx     )
347 SRC(    movl 20(%esi), %edx     )
348         adcl %ebx, %eax
349 DST(    movl %ebx, 16(%edi)     )
350         adcl %edx, %eax
351 DST(    movl %edx, 20(%edi)     )
352
353 SRC(    movl 24(%esi), %ebx     )
354 SRC(    movl 28(%esi), %edx     )
355         adcl %ebx, %eax
356 DST(    movl %ebx, 24(%edi)     )
357         adcl %edx, %eax
358 DST(    movl %edx, 28(%edi)     )
359
360         lea 32(%esi), %esi
361         lea 32(%edi), %edi
362         dec %ecx
363         jne 1b
364         adcl $0, %eax
365 2:      movl FP(%esp), %edx
366         movl %edx, %ecx
367         andl $0x1c, %edx
368         je 4f
369         shrl $2, %edx                   # This clears CF
370 SRC(3:  movl (%esi), %ebx       )
371         adcl %ebx, %eax
372 DST(    movl %ebx, (%edi)       )
373         lea 4(%esi), %esi
374         lea 4(%edi), %edi
375         dec %edx
376         jne 3b
377         adcl $0, %eax
378 4:      andl $3, %ecx
379         jz 7f
380         cmpl $2, %ecx
381         jb 5f
382 SRC(    movw (%esi), %cx        )
383         leal 2(%esi), %esi
384 DST(    movw %cx, (%edi)        )
385         leal 2(%edi), %edi
386         je 6f
387         shll $16,%ecx
388 SRC(5:  movb (%esi), %cl        )
389 DST(    movb %cl, (%edi)        )
390 6:      addl %ecx, %eax
391         adcl $0, %eax
392 7:
393 5000:
394
395 # Exception handler:
396 .section .fixup, "ax"                                                   
397
398 6001:
399         movl ARGBASE+20(%esp), %ebx     # src_err_ptr
400         movl $-EFAULT, (%ebx)
401
402         # zero the complete destination - computing the rest
403         # is too much work 
404         movl ARGBASE+8(%esp), %edi      # dst
405         movl ARGBASE+12(%esp), %ecx     # len
406         xorl %eax,%eax
407         rep ; stosb
408
409         jmp 5000b
410
411 6002:
412         movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
413         movl $-EFAULT,(%ebx)
414         jmp 5000b
415
416 .previous
417
418         popl_cfi %ebx
419         CFI_RESTORE ebx
420         popl_cfi %esi
421         CFI_RESTORE esi
422         popl_cfi %edi
423         CFI_RESTORE edi
424         popl_cfi %ecx                   # equivalent to addl $4,%esp
425         ret     
426         CFI_ENDPROC
427 ENDPROC(csum_partial_copy_generic)
428
429 #else
430
431 /* Version for PentiumII/PPro */
432
433 #define ROUND1(x) \
434         SRC(movl x(%esi), %ebx  )       ;       \
435         addl %ebx, %eax                 ;       \
436         DST(movl %ebx, x(%edi)  )       ; 
437
438 #define ROUND(x) \
439         SRC(movl x(%esi), %ebx  )       ;       \
440         adcl %ebx, %eax                 ;       \
441         DST(movl %ebx, x(%edi)  )       ;
442
443 #define ARGBASE 12
444                 
445 ENTRY(csum_partial_copy_generic)
446         CFI_STARTPROC
447         pushl_cfi %ebx
448         CFI_REL_OFFSET ebx, 0
449         pushl_cfi %edi
450         CFI_REL_OFFSET edi, 0
451         pushl_cfi %esi
452         CFI_REL_OFFSET esi, 0
453         movl ARGBASE+4(%esp),%esi       #src
454         movl ARGBASE+8(%esp),%edi       #dst    
455         movl ARGBASE+12(%esp),%ecx      #len
456         movl ARGBASE+16(%esp),%eax      #sum
457 #       movl %ecx, %edx  
458         movl %ecx, %ebx  
459         movl %esi, %edx
460         shrl $6, %ecx     
461         andl $0x3c, %ebx  
462         negl %ebx
463         subl %ebx, %esi  
464         subl %ebx, %edi  
465         lea  -1(%esi),%edx
466         andl $-32,%edx
467         lea 3f(%ebx,%ebx), %ebx
468         testl %esi, %esi 
469         jmp *%ebx
470 1:      addl $64,%esi
471         addl $64,%edi 
472         SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
473         ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52)    
474         ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36)    
475         ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20)    
476         ROUND (-16) ROUND(-12) ROUND(-8)  ROUND(-4)     
477 3:      adcl $0,%eax
478         addl $64, %edx
479         dec %ecx
480         jge 1b
481 4:      movl ARGBASE+12(%esp),%edx      #len
482         andl $3, %edx
483         jz 7f
484         cmpl $2, %edx
485         jb 5f
486 SRC(    movw (%esi), %dx         )
487         leal 2(%esi), %esi
488 DST(    movw %dx, (%edi)         )
489         leal 2(%edi), %edi
490         je 6f
491         shll $16,%edx
492 5:
493 SRC(    movb (%esi), %dl         )
494 DST(    movb %dl, (%edi)         )
495 6:      addl %edx, %eax
496         adcl $0, %eax
497 7:
498 .section .fixup, "ax"
499 6001:   movl    ARGBASE+20(%esp), %ebx  # src_err_ptr   
500         movl $-EFAULT, (%ebx)
501         # zero the complete destination (computing the rest is too much work)
502         movl ARGBASE+8(%esp),%edi       # dst
503         movl ARGBASE+12(%esp),%ecx      # len
504         xorl %eax,%eax
505         rep; stosb
506         jmp 7b
507 6002:   movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
508         movl $-EFAULT, (%ebx)
509         jmp  7b                 
510 .previous                               
511
512         popl_cfi %esi
513         CFI_RESTORE esi
514         popl_cfi %edi
515         CFI_RESTORE edi
516         popl_cfi %ebx
517         CFI_RESTORE ebx
518         ret
519         CFI_ENDPROC
520 ENDPROC(csum_partial_copy_generic)
521                                 
522 #undef ROUND
523 #undef ROUND1           
524                 
525 #endif