ia64/linux-2.6.18-xen.hg

view arch/um/sys-i386/checksum.S @ 647:a5bb490065f6

Fix the build after public header sync.
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Wed Aug 13 14:01:49 2008 +0100 (2008-08-13)
parents 831230e53067
children
line source
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 */
28 #include <asm/errno.h>
30 /*
31 * computes a partial checksum, e.g. for TCP/UDP fragments
32 */
34 /*
35 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
36 */
38 .text
39 .align 4
40 .globl csum_partial
42 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
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 csum_partial:
52 pushl %esi
53 pushl %ebx
54 movl 20(%esp),%eax # Function arg: unsigned int sum
55 movl 16(%esp),%ecx # Function arg: int len
56 movl 12(%esp),%esi # Function arg: unsigned char *buff
57 testl $2, %esi # Check alignment.
58 jz 2f # Jump if alignment is ok.
59 subl $2, %ecx # Alignment uses up two bytes.
60 jae 1f # Jump if we had at least two bytes.
61 addl $2, %ecx # ecx was < 2. Deal with it.
62 jmp 4f
63 1: movw (%esi), %bx
64 addl $2, %esi
65 addw %bx, %ax
66 adcl $0, %eax
67 2:
68 movl %ecx, %edx
69 shrl $5, %ecx
70 jz 2f
71 testl %esi, %esi
72 1: movl (%esi), %ebx
73 adcl %ebx, %eax
74 movl 4(%esi), %ebx
75 adcl %ebx, %eax
76 movl 8(%esi), %ebx
77 adcl %ebx, %eax
78 movl 12(%esi), %ebx
79 adcl %ebx, %eax
80 movl 16(%esi), %ebx
81 adcl %ebx, %eax
82 movl 20(%esi), %ebx
83 adcl %ebx, %eax
84 movl 24(%esi), %ebx
85 adcl %ebx, %eax
86 movl 28(%esi), %ebx
87 adcl %ebx, %eax
88 lea 32(%esi), %esi
89 dec %ecx
90 jne 1b
91 adcl $0, %eax
92 2: movl %edx, %ecx
93 andl $0x1c, %edx
94 je 4f
95 shrl $2, %edx # This clears CF
96 3: adcl (%esi), %eax
97 lea 4(%esi), %esi
98 dec %edx
99 jne 3b
100 adcl $0, %eax
101 4: andl $3, %ecx
102 jz 7f
103 cmpl $2, %ecx
104 jb 5f
105 movw (%esi),%cx
106 leal 2(%esi),%esi
107 je 6f
108 shll $16,%ecx
109 5: movb (%esi),%cl
110 6: addl %ecx,%eax
111 adcl $0, %eax
112 7:
113 popl %ebx
114 popl %esi
115 ret
117 #else
119 /* Version for PentiumII/PPro */
121 csum_partial:
122 pushl %esi
123 pushl %ebx
124 movl 20(%esp),%eax # Function arg: unsigned int sum
125 movl 16(%esp),%ecx # Function arg: int len
126 movl 12(%esp),%esi # Function arg: const unsigned char *buf
128 testl $2, %esi
129 jnz 30f
130 10:
131 movl %ecx, %edx
132 movl %ecx, %ebx
133 andl $0x7c, %ebx
134 shrl $7, %ecx
135 addl %ebx,%esi
136 shrl $2, %ebx
137 negl %ebx
138 lea 45f(%ebx,%ebx,2), %ebx
139 testl %esi, %esi
140 jmp *%ebx
142 # Handle 2-byte-aligned regions
143 20: addw (%esi), %ax
144 lea 2(%esi), %esi
145 adcl $0, %eax
146 jmp 10b
148 30: subl $2, %ecx
149 ja 20b
150 je 32f
151 movzbl (%esi),%ebx # csumming 1 byte, 2-aligned
152 addl %ebx, %eax
153 adcl $0, %eax
154 jmp 80f
155 32:
156 addw (%esi), %ax # csumming 2 bytes, 2-aligned
157 adcl $0, %eax
158 jmp 80f
160 40:
161 addl -128(%esi), %eax
162 adcl -124(%esi), %eax
163 adcl -120(%esi), %eax
164 adcl -116(%esi), %eax
165 adcl -112(%esi), %eax
166 adcl -108(%esi), %eax
167 adcl -104(%esi), %eax
168 adcl -100(%esi), %eax
169 adcl -96(%esi), %eax
170 adcl -92(%esi), %eax
171 adcl -88(%esi), %eax
172 adcl -84(%esi), %eax
173 adcl -80(%esi), %eax
174 adcl -76(%esi), %eax
175 adcl -72(%esi), %eax
176 adcl -68(%esi), %eax
177 adcl -64(%esi), %eax
178 adcl -60(%esi), %eax
179 adcl -56(%esi), %eax
180 adcl -52(%esi), %eax
181 adcl -48(%esi), %eax
182 adcl -44(%esi), %eax
183 adcl -40(%esi), %eax
184 adcl -36(%esi), %eax
185 adcl -32(%esi), %eax
186 adcl -28(%esi), %eax
187 adcl -24(%esi), %eax
188 adcl -20(%esi), %eax
189 adcl -16(%esi), %eax
190 adcl -12(%esi), %eax
191 adcl -8(%esi), %eax
192 adcl -4(%esi), %eax
193 45:
194 lea 128(%esi), %esi
195 adcl $0, %eax
196 dec %ecx
197 jge 40b
198 movl %edx, %ecx
199 50: andl $3, %ecx
200 jz 80f
202 # Handle the last 1-3 bytes without jumping
203 notl %ecx # 1->2, 2->1, 3->0, higher bits are masked
204 movl $0xffffff,%ebx # by the shll and shrl instructions
205 shll $3,%ecx
206 shrl %cl,%ebx
207 andl -128(%esi),%ebx # esi is 4-aligned so should be ok
208 addl %ebx,%eax
209 adcl $0,%eax
210 80:
211 popl %ebx
212 popl %esi
213 ret
215 #endif
217 /*
218 unsigned int csum_partial_copy_generic (const char *src, char *dst,
219 int len, int sum, int *src_err_ptr, int *dst_err_ptr)
220 */
222 /*
223 * Copy from ds while checksumming, otherwise like csum_partial
224 *
225 * The macros SRC and DST specify the type of access for the instruction.
226 * thus we can call a custom exception handler for all access types.
227 *
228 * FIXME: could someone double-check whether I haven't mixed up some SRC and
229 * DST definitions? It's damn hard to trigger all cases. I hope I got
230 * them all but there's no guarantee.
231 */
233 #define SRC(y...) \
234 9999: y; \
235 .section __ex_table, "a"; \
236 .long 9999b, 6001f ; \
237 .previous
239 #define DST(y...) \
240 9999: y; \
241 .section __ex_table, "a"; \
242 .long 9999b, 6002f ; \
243 .previous
245 .align 4
246 .globl csum_partial_copy_generic_i386
248 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
250 #define ARGBASE 16
251 #define FP 12
253 csum_partial_copy_generic_i386:
254 subl $4,%esp
255 pushl %edi
256 pushl %esi
257 pushl %ebx
258 movl ARGBASE+16(%esp),%eax # sum
259 movl ARGBASE+12(%esp),%ecx # len
260 movl ARGBASE+4(%esp),%esi # src
261 movl ARGBASE+8(%esp),%edi # dst
263 testl $2, %edi # Check alignment.
264 jz 2f # Jump if alignment is ok.
265 subl $2, %ecx # Alignment uses up two bytes.
266 jae 1f # Jump if we had at least two bytes.
267 addl $2, %ecx # ecx was < 2. Deal with it.
268 jmp 4f
269 SRC(1: movw (%esi), %bx )
270 addl $2, %esi
271 DST( movw %bx, (%edi) )
272 addl $2, %edi
273 addw %bx, %ax
274 adcl $0, %eax
275 2:
276 movl %ecx, FP(%esp)
277 shrl $5, %ecx
278 jz 2f
279 testl %esi, %esi
280 SRC(1: movl (%esi), %ebx )
281 SRC( movl 4(%esi), %edx )
282 adcl %ebx, %eax
283 DST( movl %ebx, (%edi) )
284 adcl %edx, %eax
285 DST( movl %edx, 4(%edi) )
287 SRC( movl 8(%esi), %ebx )
288 SRC( movl 12(%esi), %edx )
289 adcl %ebx, %eax
290 DST( movl %ebx, 8(%edi) )
291 adcl %edx, %eax
292 DST( movl %edx, 12(%edi) )
294 SRC( movl 16(%esi), %ebx )
295 SRC( movl 20(%esi), %edx )
296 adcl %ebx, %eax
297 DST( movl %ebx, 16(%edi) )
298 adcl %edx, %eax
299 DST( movl %edx, 20(%edi) )
301 SRC( movl 24(%esi), %ebx )
302 SRC( movl 28(%esi), %edx )
303 adcl %ebx, %eax
304 DST( movl %ebx, 24(%edi) )
305 adcl %edx, %eax
306 DST( movl %edx, 28(%edi) )
308 lea 32(%esi), %esi
309 lea 32(%edi), %edi
310 dec %ecx
311 jne 1b
312 adcl $0, %eax
313 2: movl FP(%esp), %edx
314 movl %edx, %ecx
315 andl $0x1c, %edx
316 je 4f
317 shrl $2, %edx # This clears CF
318 SRC(3: movl (%esi), %ebx )
319 adcl %ebx, %eax
320 DST( movl %ebx, (%edi) )
321 lea 4(%esi), %esi
322 lea 4(%edi), %edi
323 dec %edx
324 jne 3b
325 adcl $0, %eax
326 4: andl $3, %ecx
327 jz 7f
328 cmpl $2, %ecx
329 jb 5f
330 SRC( movw (%esi), %cx )
331 leal 2(%esi), %esi
332 DST( movw %cx, (%edi) )
333 leal 2(%edi), %edi
334 je 6f
335 shll $16,%ecx
336 SRC(5: movb (%esi), %cl )
337 DST( movb %cl, (%edi) )
338 6: addl %ecx, %eax
339 adcl $0, %eax
340 7:
341 5000:
343 # Exception handler:
344 .section .fixup, "ax"
346 6001:
347 movl ARGBASE+20(%esp), %ebx # src_err_ptr
348 movl $-EFAULT, (%ebx)
350 # zero the complete destination - computing the rest
351 # is too much work
352 movl ARGBASE+8(%esp), %edi # dst
353 movl ARGBASE+12(%esp), %ecx # len
354 xorl %eax,%eax
355 rep ; stosb
357 jmp 5000b
359 6002:
360 movl ARGBASE+24(%esp), %ebx # dst_err_ptr
361 movl $-EFAULT,(%ebx)
362 jmp 5000b
364 .previous
366 popl %ebx
367 popl %esi
368 popl %edi
369 popl %ecx # equivalent to addl $4,%esp
370 ret
372 #else
374 /* Version for PentiumII/PPro */
376 #define ROUND1(x) \
377 SRC(movl x(%esi), %ebx ) ; \
378 addl %ebx, %eax ; \
379 DST(movl %ebx, x(%edi) ) ;
381 #define ROUND(x) \
382 SRC(movl x(%esi), %ebx ) ; \
383 adcl %ebx, %eax ; \
384 DST(movl %ebx, x(%edi) ) ;
386 #define ARGBASE 12
388 csum_partial_copy_generic_i386:
389 pushl %ebx
390 pushl %edi
391 pushl %esi
392 movl ARGBASE+4(%esp),%esi #src
393 movl ARGBASE+8(%esp),%edi #dst
394 movl ARGBASE+12(%esp),%ecx #len
395 movl ARGBASE+16(%esp),%eax #sum
396 # movl %ecx, %edx
397 movl %ecx, %ebx
398 movl %esi, %edx
399 shrl $6, %ecx
400 andl $0x3c, %ebx
401 negl %ebx
402 subl %ebx, %esi
403 subl %ebx, %edi
404 lea -1(%esi),%edx
405 andl $-32,%edx
406 lea 3f(%ebx,%ebx), %ebx
407 testl %esi, %esi
408 jmp *%ebx
409 1: addl $64,%esi
410 addl $64,%edi
411 SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
412 ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52)
413 ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36)
414 ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20)
415 ROUND (-16) ROUND(-12) ROUND(-8) ROUND(-4)
416 3: adcl $0,%eax
417 addl $64, %edx
418 dec %ecx
419 jge 1b
420 4: movl ARGBASE+12(%esp),%edx #len
421 andl $3, %edx
422 jz 7f
423 cmpl $2, %edx
424 jb 5f
425 SRC( movw (%esi), %dx )
426 leal 2(%esi), %esi
427 DST( movw %dx, (%edi) )
428 leal 2(%edi), %edi
429 je 6f
430 shll $16,%edx
431 5:
432 SRC( movb (%esi), %dl )
433 DST( movb %dl, (%edi) )
434 6: addl %edx, %eax
435 adcl $0, %eax
436 7:
437 .section .fixup, "ax"
438 6001: movl ARGBASE+20(%esp), %ebx # src_err_ptr
439 movl $-EFAULT, (%ebx)
440 # zero the complete destination (computing the rest is too much work)
441 movl ARGBASE+8(%esp),%edi # dst
442 movl ARGBASE+12(%esp),%ecx # len
443 xorl %eax,%eax
444 rep; stosb
445 jmp 7b
446 6002: movl ARGBASE+24(%esp), %ebx # dst_err_ptr
447 movl $-EFAULT, (%ebx)
448 jmp 7b
449 .previous
451 popl %esi
452 popl %edi
453 popl %ebx
454 ret
456 #undef ROUND
457 #undef ROUND1
459 #endif