Messages in this thread | | | Date | Thu, 19 Nov 1998 17:23:32 +0100 (CET) | From | Mike Galbraith <> | Subject | Re: 2.1.128 / current EGCS |
| |
Hi,
On 14 Nov 1998, Andi Kleen wrote:
> In article <Pine.GSO.4.02A.9811132159510.2863-100000@jennifer.informatik.rwth-aachen.de>, > Bernd Schmidt <crux@pool.informatik.rwth-aachen.de> writes: > >> > >> There's still a problem (last time I had forgotten to change the compiler > >> in the arch/i386/Makefile... Guess I should stop trying stuff after being > >> at the computer for 18 hours continually ;) ): > >> > >> gcc -D__KERNEL__ -I/usr/src/linux-AC/include -Wall -Wstrict-prototypes -O2 > >> -fomit-frame-pointer -pipe -s -fno-exceptions -pipe -s > >> -fomit-frame-pointer -mk6 -march=k6 -DCPU=686 -c -o checksum.o > >> checksum.c > >> checksum.c: In function `csum_partial': > >> checksum.c:200: Invalid `asm' statement: > >> checksum.c:200: fixed or forbidden register 2 (cx) was spilled for class > >> CREG. > >> checksum.c: In function `csum_partial_copy_generic': > >> checksum.c:538: Invalid `asm' statement: > >> checksum.c:538: fixed or forbidden register 4 (si) was spilled for class > >> SIREG. > > > That's a known problem; I didn't fix it yet in the patch I sent to Alan. The > > asms in checksum.c are rather hard to convert as they'd need too many > > operands if they were done properly. IMO the whole file should be replaced > > with a new file checksum.S which is entirely in assembler - the only C code > > in that file has a comment saying "old compatibility stuff, will be removed > > soon". > > I did the conversion work, unfortunately it is not tested because the > resulting kernel crashes during boot. Tabs might be messed up a bit. >
Thanks Andi!
I had to tinker a little, but she works now. (I also reformatted a bit, and can only hope I didn't screw up the ppro part.. can't test that)
I have one question. I used egcs-2.91.54 to show me what was wrong, but don't understand why it adds the popl %ecx to to the bottom of csum_partial_copy_generic(). It works with it and doesn't without.. and I'm too blind to see why. (The only other thing was (%esp) missing from movl ARGBASE+8,%edi in non 686 csum_partial_copy_generic).
It's attached in case anyone cares to further test.
-Mike
Linux 2.1.128 (root@putz) (gcc egcs-2.92.21) #17 [putz.weiden.de] /* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * IP/TCP/UDP checksumming routines * * Authors: Jorge Cwik, <jorge@laser.satlink.net> * Arnt Gulbrandsen, <agulbra@nvg.unit.no> * Tom May, <ftom@netcom.com> * Pentium Pro/II routines: * Alexander Kjeldaas <astor@guardian.no> * Finn Arne Gangstad <finnag@guardian.no> * Lots of code moved from tcp.c and ip.c; see those files * for more names. * * Changes: Ingo Molnar, converted csum_partial_copy() to 2.1 exception * handling. * Andi Kleen, add zeroing on error * converted to pure assembler * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */
#include <asm/errno.h> /* * computes a partial checksum, e.g. for TCP/UDP fragments */
/* unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum) */ .text .align 4 .globl csum_partial #if CPU!=686
/* * Experiments with Ethernet and SLIP connections show that buff * is aligned on either a 2-byte or 4-byte boundary. We get at * least a twofold speedup on 486 and Pentium if it is 4-byte aligned. * Fortunately, it is easy to convert 2-byte alignment to 4-byte * alignment for the unrolled loop. */ csum_partial: pushl %esi pushl %ebx movl 20(%esp),%eax movl 16(%esp),%ecx movl 12(%esp),%esi testl $2, %esi # Check alignment. jz 2f # Jump if alignment is ok. subl $2, %ecx # Alignment uses up two bytes. jae 1f # Jump if we had at least two bytes. addl $2, %ecx # ecx was < 2. Deal with it. jmp 4f 1: movw (%esi), %bx addl $2, %esi addw %bx, %ax adcl $0, %eax 2: movl %ecx, %edx shrl $5, %ecx jz 2f testl %esi, %esi 1: movl (%esi), %ebx adcl %ebx, %eax movl 4(%esi), %ebx adcl %ebx, %eax movl 8(%esi), %ebx adcl %ebx, %eax movl 12(%esi), %ebx adcl %ebx, %eax movl 16(%esi), %ebx adcl %ebx, %eax movl 20(%esi), %ebx adcl %ebx, %eax movl 24(%esi), %ebx adcl %ebx, %eax movl 28(%esi), %ebx adcl %ebx, %eax lea 32(%esi), %esi dec %ecx jne 1b adcl $0, %eax 2: movl %edx, %ecx andl $0x1c, %edx je 4f shrl $2, %edx # This clears CF 3: adcl (%esi), %eax lea 4(%esi), %esi dec %edx jne 3b adcl $0, %eax 4: andl $3, %ecx jz 7f cmpl $2, %ecx jb 5f movw (%esi),%cx leal 2(%esi),%esi je 6f shll $16,%ecx 5: movb (%esi),%cl 6: addl %ecx,%eax adcl $0, %eax 7: popl %ebx popl %esi ret
#else /* CPU==686 */
csum_partial: movl 12(%esp),%eax #sum movl 8(%esp),%ecx #len movl 4(%esp),%esi #buff
testl $2, %esi jnz 30f 10: movl %ecx, %edx movl %ecx, %ebx andl $0x7c, %ebx shrl $7, %ecx addl %ebx,%esi shrl $2, %ebx negl %ebx lea 45f(%ebx,%ebx,2), %ebx testl %esi, %esi jmp *%ebx
# Handle 2-byte-aligned regions 20: addw (%esi), %ax lea 2(%esi), %esi adcl $0, %eax jmp 10b
30: subl $2, %ecx ja 20b je 32f movzbl (%esi),%ebx # csumming 1 byte, 2-aligned addl %ebx, %eax adcl $0, %eax jmp 80f 32: addw (%esi), %ax # csumming 2 bytes, 2-aligned adcl $0, %eax jmp 80f
40: addl -128(%esi), %eax adcl -124(%esi), %eax adcl -120(%esi), %eax adcl -116(%esi), %eax adcl -112(%esi), %eax adcl -108(%esi), %eax adcl -104(%esi), %eax adcl -100(%esi), %eax adcl -96(%esi), %eax adcl -92(%esi), %eax adcl -88(%esi), %eax adcl -84(%esi), %eax adcl -80(%esi), %eax adcl -76(%esi), %eax adcl -72(%esi), %eax adcl -68(%esi), %eax adcl -64(%esi), %eax adcl -60(%esi), %eax adcl -56(%esi), %eax adcl -52(%esi), %eax adcl -48(%esi), %eax adcl -44(%esi), %eax adcl -40(%esi), %eax adcl -36(%esi), %eax adcl -32(%esi), %eax adcl -28(%esi), %eax adcl -24(%esi), %eax adcl -20(%esi), %eax adcl -16(%esi), %eax adcl -12(%esi), %eax adcl -8(%esi), %eax adcl -4(%esi), %eax 45: lea 128(%esi), %esi adcl $0, %eax dec %ecx jge 40b movl %edx, %ecx 50: andl $3, %ecx jz 80f
# Handle the last 1-3 bytes without jumping notl %ecx # 1->2, 2->1, 3->0, higher bits are masked movl $0xffffff,%ebx # by the shll and shrl instructions shll $3,%ecx shrl %cl,%ebx andl -128(%esi),%ebx # esi is 4-aligned so should be ok addl %ebx,%eax adcl $0,%eax 80: ret #endif /* CPU==686 */
/* unsigned int csum_partial_copy_generic (const char *src, char *dst, int len, int sum, int *src_err_ptr, int *dst_err_ptr) */
/* * Copy from ds while checksumming, otherwise like csum_partial * * The macros SRC and DST specify the type of access for the instruction. * thus we can call a custom exception handler for all access types. * * FIXME: could someone double-check whether I haven't mixed up some SRC and * DST definitions? It's damn hard to trigger all cases. I hope I got * them all but there's no guarantee. */
#define SRC(y...) \ 9999: y; \ .section __ex_table, "a"; \ .long 9999b, 6001f ; \ .previous
#define DST(y...) \ 9999: y; \ .section __ex_table, "a"; \ .long 9999b, 6002f ; \ .previous
.align 4 .globl csum_partial_copy_generic #if CPU!=686
#define ARGBASE 16 #define FP 12 csum_partial_copy_generic: subl $4,%esp pushl %edi pushl %esi pushl %ebx movl ARGBASE+16(%esp),%eax # sum movl ARGBASE+12(%esp),%ecx # len movl ARGBASE+4(%esp),%esi # src movl ARGBASE+8(%esp),%edi # dst
testl $2, %edi # Check alignment. jz 2f # Jump if alignment is ok. subl $2, %ecx # Alignment uses up two bytes. jae 1f # Jump if we had at least two bytes. addl $2, %ecx # ecx was < 2. Deal with it. jmp 4f SRC(1: movw (%esi), %bx ) addl $2, %esi DST( movw %bx, (%edi) ) addl $2, %edi addw %bx, %ax adcl $0, %eax 2: movl %ecx, FP(%esp) shrl $5, %ecx jz 2f testl %esi, %esi SRC(1: movl (%esi), %ebx ) SRC( movl 4(%esi), %edx ) adcl %ebx, %eax DST( movl %ebx, (%edi) ) adcl %edx, %eax DST( movl %edx, 4(%edi) )
SRC( movl 8(%esi), %ebx ) SRC( movl 12(%esi), %edx ) adcl %ebx, %eax DST( movl %ebx, 8(%edi) ) adcl %edx, %eax DST( movl %edx, 12(%edi) )
SRC( movl 16(%esi), %ebx ) SRC( movl 20(%esi), %edx ) adcl %ebx, %eax DST( movl %ebx, 16(%edi) ) adcl %edx, %eax DST( movl %edx, 20(%edi) )
SRC( movl 24(%esi), %ebx ) SRC( movl 28(%esi), %edx ) adcl %ebx, %eax DST( movl %ebx, 24(%edi) ) adcl %edx, %eax DST( movl %edx, 28(%edi) )
SRC( lea 32(%esi), %esi ) DST( lea 32(%edi), %edi ) dec %ecx jne 1b adcl $0, %eax 2: movl FP(%esp), %edx movl %edx, %ecx andl $0x1c, %edx je 4f shrl $2, %edx # This clears CF SRC(3: movl (%esi), %ebx ) adcl %ebx, %eax DST( movl %ebx, (%edi) ) SRC( lea 4(%esi), %esi ) DST( lea 4(%edi), %edi ) dec %edx jne 3b adcl $0, %eax 4: andl $3, %ecx jz 7f cmpl $2, %ecx jb 5f SRC( movw (%esi), %cx ) SRC( leal 2(%esi), %esi ) DST( movw %cx, (%edi) ) DST( leal 2(%edi), %edi ) je 6f shll $16,%ecx SRC(5: movb (%esi), %cl ) DST( movb %cl, (%edi) ) 6: addl %ecx, %eax adcl $0, %eax 7: 5000:
# Exception handler: .section .fixup, "ax"
6000:
movl $-EFAULT, (%ebx)
# zero the complete destination - computing the rest # is too much work movl ARGBASE+8(%esp), %edi # dst movl ARGBASE+12(%esp), %ecx xorl %eax,%eax rep ; stosb
jmp 5000b
6001: movl ARGBASE+20(%esp), %ebx # src_err_ptr jmp 6000b
6002: movl ARGBASE+24(%esp), %ebx # dst_err_ptr jmp 6000b
.previous
popl %ebx popl %esi popl %edi popl %ecx ret
#else
/* Version for PentiumII/PPro */
#define ROUND1(x) \ SRC(movl x(%esi), %ebx ) ; \ addl %ebx, %eax\n ; \ DST(movl %ebx, x(%edi) ) ;
#define ROUND(x) \ SRC(movl x(%esi), %ebx ) ; \ adcl %ebx, %eax ; \ DST(movl %ebx, x(%edi) ) ;
#define ARGBASE 16 csum_partial_copy_generic: pushl %ebx pushl %edi pushl %esi movl ARGBASE+4(%esp),%esi #len movl ARGBASE+8(%esp),%edi #dst movl ARGBASE+12(%esp),%ecx #len movl ARGBASE+16(%esp),%eax #sum movl %ecx, %edx movl %ecx, %ebx shrl $6, %ecx andl $0x3c, %ebx negl %ebx subl %ebx, %esi subl %ebx, %edi lea 3f(%ebx,%ebx), %ebx testl %esi, %esi jmp *%ebx 1: addl $64,%esi addl $64,%edi ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52) ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36) ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20) ROUND (-16) ROUND(-12) ROUND(-8) ROUND(-4) 3: adcl $0,%eax dec %ecx jge 1b 4: andl $3, %edx jz 7f cmpl $2, %edx jb 5f SRC( movw (%esi), %dx ) leal 2(%esi), %esi DST( movw %dx, (%edi) ) leal 2(%edi), %edi je 6f shll $16,%edx 5: SRC( movb (%esi), %dl ) DST( movb %dl, (%edi) ) 6: addl %edx, %eax adcl $0, %eax 7: .section .fixup, "ax" 6000: movl $-EFAULT, (%ebx) # zero the complete destination (computing the rest is too much work) movl ARGBASE+8(%esp),%edi movl ARGBASE+12(%esp),%ecx xorl %eax,%eax rep; stosb jmp 7b 6001: movl ARGBASE+20(%esp), %ebx jmp 6000b 6002: movl ARGBASE+24(%esp), %ebx jmp 6000b .previous
popl %esi popl %edi popl %ebx ret #undef ROUND #undef ROUND1 #endif /* CPU==i686 */
| |