[ros-diffs] [tkreuzer] 50545: [IP] Convert checksum.S to new ML compatible syntax. Resulting obj was compared and is identical to trunk (both GAS and ML)

Author: tkreuzer
Date: Fri Jan 28 20:35:22 2011
New Revision: 50545
URL: http://svn.reactos.org/svn/reactos?rev=50545&view=rev
Log:
[IP]
Convert checksum.S to new ML compatible syntax. Resulting obj was compared and is
identical to trunk (both GAS and ML)
Modified:
    branches/cmake-bringup/lib/drivers/ip/network/i386/checksum.S
Modified: branches/cmake-bringup/lib/drivers/ip/network/i386/checksum.S
URL:
http://svn.reactos.org/svn/reactos/branches/cmake-bringup/lib/drivers/ip/ne…
==============================================================================
--- branches/cmake-bringup/lib/drivers/ip/network/i386/checksum.S [iso-8859-1] (original)
+++ branches/cmake-bringup/lib/drivers/ip/network/i386/checksum.S [iso-8859-1] Fri Jan 28
20:35:22 2011
@@ -24,109 +24,111 @@
  *             as published by the Free Software Foundation; either version
  *             2 of the License, or (at your option) any later version.
  */
-
+
 /*
  * computes a partial checksum, e.g. for TCP/UDP fragments
  */
-/*
+/*
 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
  */
-
-.text
+
+#include <asm.inc>
+
+.code
 .align 4
-.globl _csum_partial
-
+PUBLIC _csum_partial
+
 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
-         /*
+         /*
           * 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      # Function arg: unsigned int sum
-       movl 16(%esp),%ecx      # Function arg: int len
-       movl 12(%esp),%esi      # Function arg: unsigned char *buff
-       testl $3, %esi          # Check alignment.
-       jz 2f                   # Jump if alignment is ok.
-       testl $1, %esi          # Check alignment.
-       jz 10f                  # Jump if alignment is boundary of 2bytes.
+          */
+_csum_partial:
+       push esi
+       push ebx
+       mov eax, [esp + 20]     // Function arg: unsigned int sum
+       mov ecx, [esp + 16]     // Function arg: int len
+       mov esi, [esp + 12]     // Function arg: unsigned char *buff
+       test esi, 3             // Check alignment.
+       jz m2                   // Jump if alignment is ok.
+       test esi, 1             // Check alignment.
+       jz l10                  // Jump if alignment is boundary of 2bytes.
        // buf is odd
-       dec %ecx
-       jl 8f
-       movzbl (%esi), %ebx
-       adcl %ebx, %eax
-       roll $8, %eax
-       inc %esi
-       testl $2, %esi
-       jz 2f
-10:
-       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:
-       testl $1, 12(%esp)
-       jz 8f
-       roll $8, %eax
-8:
-       popl %ebx
-       popl %esi
+       dec ecx
+       jl l8
+       movzx ebx, byte ptr [esi]
+       adc eax, ebx
+       rol eax, 8
+       inc esi
+       test esi, 2
+       jz m2
+l10:
+       sub ecx, 2              // Alignment uses up two bytes.
+       jae m1                  // Jump if we had at least two bytes.
+       add ecx, 2              // ecx was < 2.  Deal with it.
+       jmp l4
+m1:    mov bx, [esi]
+       add esi, 2
+       add ax, bx
+       adc eax, 0
+m2:
+       mov edx, ecx
+       shr ecx, 5
+       jz l2
+       test esi, esi
+l1:    mov ebx, [esi]
+       adc eax, ebx
+       mov ebx, [esi + 4]
+       adc eax, ebx
+       mov ebx, [esi + 8]
+       adc eax, ebx
+       mov ebx, [esi + 12]
+       adc eax, ebx
+       mov ebx, [esi + 16]
+       adc eax, ebx
+       mov ebx, [esi + 20]
+       adc eax, ebx
+       mov ebx, [esi + 24]
+       adc eax, ebx
+       mov ebx, [esi + 28]
+       adc eax, ebx
+       lea esi, [esi + 32]
+       dec ecx
+       jne l1
+       adc eax, 0
+l2:    mov ecx, edx
+       and edx, HEX(1c)
+       je l4
+       shr edx, 2              // This clears CF
+l3:    adc eax, [esi]
+       lea esi, [esi + 4]
+       dec edx
+       jne l3
+       adc eax, 0
+l4:    and ecx, 3
+       jz l7
+       cmp ecx, 2
+       jb l5
+       mov cx, [esi]
+       lea esi, [esi + 2]
+       je l6
+       shl ecx, 16
+l5:    mov cl, [esi]
+l6:    add eax, ecx
+       adc eax, 0
+l7:
+       test dword ptr [esp + 12], 1
+       jz l8
+       rol eax, 8
+l8:
+       pop ebx
+       pop esi
        ret
 #else
@@ -134,116 +136,118 @@
 /* Version for PentiumII/PPro */
 csum_partial:
-       pushl %esi
-       pushl %ebx
-       movl 20(%esp),%eax      # Function arg: unsigned int sum
-       movl 16(%esp),%ecx      # Function arg: int len
-       movl 12(%esp),%esi      # Function arg: const unsigned char *buf
-
-       testl $3, %esi
-       jnz 25f
-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
-25:
-       testl $1, %esi
-       jz 30f
-       # buf is odd
-       dec %ecx
-       jl 90f
-       movzbl (%esi), %ebx
-       addl %ebx, %eax
-       adcl $0, %eax
-       roll $8, %eax
-       inc %esi
-       testl $2, %esi
-       jz 10b
-
-30:    subl $2, %ecx
-       ja 20b
-       je 32f
-       addl $2, %ecx
-       jz 80f
-       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:
-       testl $1, 12(%esp)
-       jz 90f
-       roll $8, %eax
-90:
-       popl %ebx
-       popl %esi
+       push esi
+       push ebx
+       mov eax, [esp + 20]     # Function arg: unsigned int sum
+       mov ecx, [esp + 16]     # Function arg: int len
+       mov esi, [esp + 12]     # Function arg: const unsigned char *buf
+
+       test esi, 3
+       jnz l25f
+l10:
+       mov edx, ecx
+       mov ebx, ecx
+       and ebx, HEX(7c)
+       shr ecx, 7
+       add esi, ebx
+       shr ebx, 2
+       neg ebx
+       lea ebx, l45[ebx + ebx * 2]
+       test esi, esi
+       jmp dword ptr [ebx]
+
+       // Handle 2-byte-aligned regions
+l20: add ax, [esi]
+       lea esi, [esi + 2]
+       adc eax, 0
+       jmp l10b
+l25:
+       test esi, 1
+       jz l30f
+       // buf is odd
+       dec ecx
+       jl l90
+       movzb ebx, [esi]
+       add eax, ebx
+       adc eax, 0
+       rol eax, 8
+       inc esi
+       test esi, 2
+       jz l10b
+
+l30: sub ecx, 2
+       ja l20
+       je l32
+       add ecx, 2
+       jz l80
+       movzb ebx, [esi]        // csumming 1 byte, 2-aligned
+       add eax, ebx
+       adc eax, 0
+       jmp l80
+l32:
+       add ax, [esi]   // csumming 2 bytes, 2-aligned
+       adc eax, 0
+       jmp l80
+
+l40:
+       add eax, [esi -128]
+       adc eax, [esi -124]
+       adc eax, [esi -120]
+       adc eax, [esi -116]
+       adc eax, [esi -112]
+       adc eax, [esi -108]
+       adc eax, [esi -104]
+       adc eax, [esi -100]
+       adc eax, [esi -96]
+       adc eax, [esi -92]
+       adc eax, [esi -88]
+       adc eax, [esi -84]
+       adc eax, [esi -80]
+       adc eax, [esi -76]
+       adc eax, [esi -72]
+       adc eax, [esi -68]
+       adc eax, [esi -64]
+       adc eax, [esi -60]
+       adc eax, [esi -56]
+       adc eax, [esi -52]
+       adc eax, [esi -48]
+       adc eax, [esi -44]
+       adc eax, [esi -40]
+       adc eax, [esi -36]
+       adc eax, [esi -32]
+       adc eax, [esi -28]
+       adc eax, [esi -24]
+       adc eax, [esi -20]
+       adc eax, [esi -16]
+       adc eax, [esi -12]
+       adc eax, [esi -8]
+       adc eax, [esi -4]
+l45:
+       lea esi, [esi + 128]
+       adc eax, 0
+       dec ecx
+       jge l40
+       mov ecx, edx
+l50:   and ecx, 3
+       jz l80
+
+       // Handle the last 1-3 bytes without jumping
+       not ecx         // 1->2, 2->1, 3->0, higher bits are masked
+       mov ebx, HEX(ffffff)    // by the shll and shrl instructions
+       shl ecx, 3
+       shr ebx, cl
+       and ebx, [esi -128]     // esi is 4-aligned so should be ok
+       add eax, ebx
+       adc eax, 0
+l80:
+       test dword ptr [esp + 12], 1
+       jz l90
+       rol eax, 8
+l90:
+       pop ebx
+       pop esi
        ret
-
+
 #endif
+
+END