URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [sh/] [lib/] [checksum.S] - Blame information for rev 1275

Go to most recent revision | Details | Compare with Previous | View Log


/* $Id: checksum.S,v 1.1.1.1 2004-04-15 01:17:17 phoenix Exp $
 *
 * 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, 
 *              Arnt Gulbrandsen, 
 *              Tom May, 
 *              Pentium Pro/II routines:
 *              Alexander Kjeldaas 
 *              Finn Arne Gangstad 
 *              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
 *
 * SuperH version:  Copyright (C) 1999  Niibe Yutaka
 *
 *              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 
#include 
 
/*
 * computes a partial checksum, e.g. for TCP/UDP fragments
 */
 
/*
 * unsigned int csum_partial(const unsigned char *buf, int len,
 *                           unsigned int sum);
 */
 
.text
ENTRY(csum_partial)
          /*
           * 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.
           */
        mov     r5, r1
        mov     r4, r0
        tst     #2, r0          ! Check alignment.
        bt      2f              ! Jump if alignment is ok.
        !
        add     #-2, r5         ! Alignment uses up two bytes.
        cmp/pz  r5              !
        bt/s    1f              ! Jump if we had at least two bytes.
         clrt
        bra     6f
         add    #2, r5          ! r5 was < 2.  Deal with it.
1:
        mov     r5, r1          ! Save new len for later use.
        mov.w   @r4+, r0
        extu.w  r0, r0
        addc    r0, r6
        bf      2f
        add     #1, r6
2:
        mov     #-5, r0
        shld    r0, r5
        tst     r5, r5
        bt/s    4f              ! if it's =0, go to 4f
         clrt
        .align  2
3:
        mov.l   @r4+, r0
        mov.l   @r4+, r2
        mov.l   @r4+, r3
        addc    r0, r6
        mov.l   @r4+, r0
        addc    r2, r6
        mov.l   @r4+, r2
        addc    r3, r6
        mov.l   @r4+, r3
        addc    r0, r6
        mov.l   @r4+, r0
        addc    r2, r6
        mov.l   @r4+, r2
        addc    r3, r6
        addc    r0, r6
        addc    r2, r6
        movt    r0
        dt      r5
        bf/s    3b
         cmp/eq #1, r0
        ! here, we know r5==0
        addc    r5, r6                  ! add carry to r6
4:
        mov     r1, r0
        and     #0x1c, r0
        tst     r0, r0
        bt/s    6f
         mov    r0, r5
        shlr2   r5
        mov     #0, r2
5:
        addc    r2, r6
        mov.l   @r4+, r2
        movt    r0
        dt      r5
        bf/s    5b
         cmp/eq #1, r0
        addc    r2, r6
        addc    r5, r6          ! r5==0 here, so it means add carry-bit
6:
        mov     r1, r5
        mov     #3, r0
        and     r0, r5
        tst     r5, r5
        bt      9f              ! if it's =0 go to 9f
        mov     #2, r1
        cmp/hs  r1, r5
        bf      7f
        mov.w   @r4+, r0
        extu.w  r0, r0
        cmp/eq  r1, r5
        bt/s    8f
         clrt
        shll16  r0
        addc    r0, r6
7:
        mov.b   @r4+, r0
        extu.b  r0, r0
#ifndef __LITTLE_ENDIAN__
        shll8   r0
#endif
8:
        addc    r0, r6
        mov     #0, r0
        addc    r0, r6
9:
        rts
         mov    r6, r0
 
/*
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(...)                        \
        9999: __VA_ARGS__ ;             \
        .section __ex_table, "a";       \
        .long 9999b, 6001f      ;       \
        .previous
 
#define DST(...)                        \
        9999: __VA_ARGS__ ;             \
        .section __ex_table, "a";       \
        .long 9999b, 6002f      ;       \
        .previous
 
!
! r4:   const char *SRC
! r5:   char *DST
! r6:   int LEN
! r7:   int SUM
!
! on stack:
! int *SRC_ERR_PTR
! int *DST_ERR_PTR
!
ENTRY(csum_partial_copy_generic)
        mov.l   r5,@-r15
        mov.l   r6,@-r15
 
        mov     #3,r0           ! Check src and dest are equally aligned
        mov     r4,r1
        and     r0,r1
        and     r5,r0
        cmp/eq  r1,r0
        bf      3f              ! Different alignments, use slow version
        tst     #1,r0           ! Check dest word aligned
        bf      3f              ! If not, do it the slow way
 
        mov     #2,r0
        tst     r0,r5           ! Check dest alignment.
        bt      2f              ! Jump if alignment is ok.
        add     #-2,r6          ! Alignment uses up two bytes.
        cmp/pz  r6              ! Jump if we had at least two bytes.
        bt/s    1f
         clrt
        bra     4f
         add    #2,r6           ! r6 was < 2.   Deal with it.
 
3:      ! Handle different src and dest alignments.
        ! This is not common, so simple byte by byte copy will do.
        mov     r6,r2
        shlr    r6
        tst     r6,r6
        bt      4f
        clrt
        .align  2
5:
SRC(    mov.b   @r4+,r1         )
SRC(    mov.b   @r4+,r0         )
        extu.b  r1,r1
DST(    mov.b   r1,@r5          )
DST(    mov.b   r0,@(1,r5)      )
        extu.b  r0,r0
        add     #2,r5
 
#ifdef  __LITTLE_ENDIAN__
        shll8   r0
#else
        shll8   r1
#endif
        or      r1,r0
 
        addc    r0,r7
        movt    r0
        dt      r6
        bf/s    5b
         cmp/eq #1,r0
        mov     #0,r0
        addc    r0, r7
 
        mov     r2, r0
        tst     #1, r0
        bt      7f
        bra     5f
         clrt
 
        ! src and dest equally aligned, but to a two byte boundary.
        ! Handle first two bytes as a special case
        .align  2
1:
SRC(    mov.w   @r4+,r0         )
DST(    mov.w   r0,@r5          )
        add     #2,r5
        extu.w  r0,r0
        addc    r0,r7
        mov     #0,r0
        addc    r0,r7
2:
        mov     r6,r2
        mov     #-5,r0
        shld    r0,r6
        tst     r6,r6
        bt/s    2f
         clrt
        .align  2
1:
SRC(    mov.l   @r4+,r0         )
SRC(    mov.l   @r4+,r1         )
        addc    r0,r7
DST(    mov.l   r0,@r5          )
DST(    mov.l   r1,@(4,r5)      )
        addc    r1,r7
 
SRC(    mov.l   @r4+,r0         )
SRC(    mov.l   @r4+,r1         )
        addc    r0,r7
DST(    mov.l   r0,@(8,r5)      )
DST(    mov.l   r1,@(12,r5)     )
        addc    r1,r7
 
SRC(    mov.l   @r4+,r0         )
SRC(    mov.l   @r4+,r1         )
        addc    r0,r7
DST(    mov.l   r0,@(16,r5)     )
DST(    mov.l   r1,@(20,r5)     )
        addc    r1,r7
 
SRC(    mov.l   @r4+,r0         )
SRC(    mov.l   @r4+,r1         )
        addc    r0,r7
DST(    mov.l   r0,@(24,r5)     )
DST(    mov.l   r1,@(28,r5)     )
        addc    r1,r7
        add     #32,r5
        movt    r0
        dt      r6
        bf/s    1b
         cmp/eq #1,r0
        mov     #0,r0
        addc    r0,r7
 
2:      mov     r2,r6
        mov     #0x1c,r0
        and     r0,r6
        cmp/pl  r6
        bf/s    4f
         clrt
        shlr2   r6
3:
SRC(    mov.l   @r4+,r0 )
        addc    r0,r7
DST(    mov.l   r0,@r5  )
        add     #4,r5
        movt    r0
        dt      r6
        bf/s    3b
         cmp/eq #1,r0
        mov     #0,r0
        addc    r0,r7
4:      mov     r2,r6
        mov     #3,r0
        and     r0,r6
        cmp/pl  r6
        bf      7f
        mov     #2,r1
        cmp/hs  r1,r6
        bf      5f
SRC(    mov.w   @r4+,r0 )
DST(    mov.w   r0,@r5  )
        extu.w  r0,r0
        add     #2,r5
        cmp/eq  r1,r6
        bt/s    6f
         clrt
        shll16  r0
        addc    r0,r7
5:
SRC(    mov.b   @r4+,r0 )
DST(    mov.b   r0,@r5  )
        extu.b  r0,r0
#ifndef __LITTLE_ENDIAN__
        shll8   r0
#endif
6:      addc    r0,r7
        mov     #0,r0
        addc    r0,r7
7:
5000:
 
# Exception handler:
.section .fixup, "ax"
 
6001:
        mov.l   @(8,r15),r0                     ! src_err_ptr
        mov     #-EFAULT,r1
        mov.l   r1,@r0
 
        ! zero the complete destination - computing the rest
        ! is too much work
        mov.l   @(4,r15),r5             ! dst
        mov.l   @r15,r6                 ! len
        mov     #0,r7
1:      mov.b   r7,@r5
        dt      r6
        bf/s    1b
         add    #1,r5
        mov.l   8000f,r0
        jmp     @r0
         nop
        .align  2
8000:   .long   5000b
 
6002:
        mov.l   @(12,r15),r0                    ! dst_err_ptr
        mov     #-EFAULT,r1
        mov.l   r1,@r0
        mov.l   8001f,r0
        jmp     @r0
         nop
        .align  2
8001:   .long   5000b
 
.previous
        add     #8,r15
        rts
         mov    r7,r0

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [sh/] [lib/] [checksum.S] - Blame information for rev 1275

Line No.	Rev	Author	Line
1	1275	phoenix	`/* $Id: checksum.S,v 1.1.1.1 2004-04-15 01:17:17 phoenix Exp $`
2			`*`
3			`* INET An implementation of the TCP/IP protocol suite for the LINUX`
4			`* operating system. INET is implemented using the BSD Socket`
5			`* interface as the means of communication with the user level.`
6			`*`
7			`* IP/TCP/UDP checksumming routines`
8			`*`
9			`* Authors: Jorge Cwik,`
10			`* Arnt Gulbrandsen,`
11			`* Tom May,`
12			`* Pentium Pro/II routines:`
13			`* Alexander Kjeldaas`
14			`* Finn Arne Gangstad`
15			`* Lots of code moved from tcp.c and ip.c; see those files`
16			`* for more names.`
17			`*`
18			`* Changes: Ingo Molnar, converted csum_partial_copy() to 2.1 exception`
19			`* handling.`
20			`* Andi Kleen, add zeroing on error`
21			`* converted to pure assembler`
22			`*`
23			`* SuperH version: Copyright (C) 1999 Niibe Yutaka`
24			`*`
25			`* This program is free software; you can redistribute it and/or`
26			`* modify it under the terms of the GNU General Public License`
27			`* as published by the Free Software Foundation; either version`
28			`* 2 of the License, or (at your option) any later version.`
29			`*/`
30
31			`#include`
32			`#include`
33
34			`/*`
35			`* computes a partial checksum, e.g. for TCP/UDP fragments`
36			`*/`
37
38			`/*`
39			`* unsigned int csum_partial(const unsigned char *buf, int len,`
40			`* unsigned int sum);`
41			`*/`
42
43			`.text`
44			`ENTRY(csum_partial)`
45			`/*`
46			`* Experiments with Ethernet and SLIP connections show that buff`
47			`* is aligned on either a 2-byte or 4-byte boundary. We get at`
48			`* least a twofold speedup on 486 and Pentium if it is 4-byte aligned.`
49			`* Fortunately, it is easy to convert 2-byte alignment to 4-byte`
50			`* alignment for the unrolled loop.`
51			`*/`
52			`mov r5, r1`
53			`mov r4, r0`
54			`tst #2, r0 ! Check alignment.`
55			`bt 2f ! Jump if alignment is ok.`
56			`!`
57			`add #-2, r5 ! Alignment uses up two bytes.`
58			`cmp/pz r5 !`
59			`bt/s 1f ! Jump if we had at least two bytes.`
60			`clrt`
61			`bra 6f`
62			`add #2, r5 ! r5 was < 2. Deal with it.`
63			`1:`
64			`mov r5, r1 ! Save new len for later use.`
65			`mov.w @r4+, r0`
66			`extu.w r0, r0`
67			`addc r0, r6`
68			`bf 2f`
69			`add #1, r6`
70			`2:`
71			`mov #-5, r0`
72			`shld r0, r5`
73			`tst r5, r5`
74			`bt/s 4f ! if it's =0, go to 4f`
75			`clrt`
76			`.align 2`
77			`3:`
78			`mov.l @r4+, r0`
79			`mov.l @r4+, r2`
80			`mov.l @r4+, r3`
81			`addc r0, r6`
82			`mov.l @r4+, r0`
83			`addc r2, r6`
84			`mov.l @r4+, r2`
85			`addc r3, r6`
86			`mov.l @r4+, r3`
87			`addc r0, r6`
88			`mov.l @r4+, r0`
89			`addc r2, r6`
90			`mov.l @r4+, r2`
91			`addc r3, r6`
92			`addc r0, r6`
93			`addc r2, r6`
94			`movt r0`
95			`dt r5`
96			`bf/s 3b`
97			`cmp/eq #1, r0`
98			`! here, we know r5==0`
99			`addc r5, r6 ! add carry to r6`
100			`4:`
101			`mov r1, r0`
102			`and #0x1c, r0`
103			`tst r0, r0`
104			`bt/s 6f`
105			`mov r0, r5`
106			`shlr2 r5`
107			`mov #0, r2`
108			`5:`
109			`addc r2, r6`
110			`mov.l @r4+, r2`
111			`movt r0`
112			`dt r5`
113			`bf/s 5b`
114			`cmp/eq #1, r0`
115			`addc r2, r6`
116			`addc r5, r6 ! r5==0 here, so it means add carry-bit`
117			`6:`
118			`mov r1, r5`
119			`mov #3, r0`
120			`and r0, r5`
121			`tst r5, r5`
122			`bt 9f ! if it's =0 go to 9f`
123			`mov #2, r1`
124			`cmp/hs r1, r5`
125			`bf 7f`
126			`mov.w @r4+, r0`
127			`extu.w r0, r0`
128			`cmp/eq r1, r5`
129			`bt/s 8f`
130			`clrt`
131			`shll16 r0`
132			`addc r0, r6`
133			`7:`
134			`mov.b @r4+, r0`
135			`extu.b r0, r0`
136			`#ifndef __LITTLE_ENDIAN__`
137			`shll8 r0`
138			`#endif`
139			`8:`
140			`addc r0, r6`
141			`mov #0, r0`
142			`addc r0, r6`
143			`9:`
144			`rts`
145			`mov r6, r0`
146
147			`/*`
148			`unsigned int csum_partial_copy_generic (const char src, char dst, int len,`
149			`int sum, int src_err_ptr, int dst_err_ptr)`
150			`*/`
151
152			`/*`
153			`* Copy from ds while checksumming, otherwise like csum_partial`
154			`*`
155			`* The macros SRC and DST specify the type of access for the instruction.`
156			`* thus we can call a custom exception handler for all access types.`
157			`*`
158			`* FIXME: could someone double-check whether I haven't mixed up some SRC and`
159			`* DST definitions? It's damn hard to trigger all cases. I hope I got`
160			`* them all but there's no guarantee.`
161			`*/`
162
163			`#define SRC(...) \`
164			`9999: __VA_ARGS__ ; \`
165			`.section __ex_table, "a"; \`
166			`.long 9999b, 6001f ; \`
167			`.previous`
168
169			`#define DST(...) \`
170			`9999: __VA_ARGS__ ; \`
171			`.section __ex_table, "a"; \`
172			`.long 9999b, 6002f ; \`
173			`.previous`
174
175			`!`
176			`! r4: const char *SRC`
177			`! r5: char *DST`
178			`! r6: int LEN`
179			`! r7: int SUM`
180			`!`
181			`! on stack:`
182			`! int *SRC_ERR_PTR`
183			`! int *DST_ERR_PTR`
184			`!`
185			`ENTRY(csum_partial_copy_generic)`
186			`mov.l r5,@-r15`
187			`mov.l r6,@-r15`
188
189			`mov #3,r0 ! Check src and dest are equally aligned`
190			`mov r4,r1`
191			`and r0,r1`
192			`and r5,r0`
193			`cmp/eq r1,r0`
194			`bf 3f ! Different alignments, use slow version`
195			`tst #1,r0 ! Check dest word aligned`
196			`bf 3f ! If not, do it the slow way`
197
198			`mov #2,r0`
199			`tst r0,r5 ! Check dest alignment.`
200			`bt 2f ! Jump if alignment is ok.`
201			`add #-2,r6 ! Alignment uses up two bytes.`
202			`cmp/pz r6 ! Jump if we had at least two bytes.`
203			`bt/s 1f`
204			`clrt`
205			`bra 4f`
206			`add #2,r6 ! r6 was < 2. Deal with it.`
207
208			`3: ! Handle different src and dest alignments.`
209			`! This is not common, so simple byte by byte copy will do.`
210			`mov r6,r2`
211			`shlr r6`
212			`tst r6,r6`
213			`bt 4f`
214			`clrt`
215			`.align 2`
216			`5:`
217			`SRC( mov.b @r4+,r1 )`
218			`SRC( mov.b @r4+,r0 )`
219			`extu.b r1,r1`
220			`DST( mov.b r1,@r5 )`
221			`DST( mov.b r0,@(1,r5) )`
222			`extu.b r0,r0`
223			`add #2,r5`
224
225			`#ifdef __LITTLE_ENDIAN__`
226			`shll8 r0`
227			`#else`
228			`shll8 r1`
229			`#endif`
230			`or r1,r0`
231
232			`addc r0,r7`
233			`movt r0`
234			`dt r6`
235			`bf/s 5b`
236			`cmp/eq #1,r0`
237			`mov #0,r0`
238			`addc r0, r7`
239
240			`mov r2, r0`
241			`tst #1, r0`
242			`bt 7f`
243			`bra 5f`
244			`clrt`
245
246			`! src and dest equally aligned, but to a two byte boundary.`
247			`! Handle first two bytes as a special case`
248			`.align 2`
249			`1:`
250			`SRC( mov.w @r4+,r0 )`
251			`DST( mov.w r0,@r5 )`
252			`add #2,r5`
253			`extu.w r0,r0`
254			`addc r0,r7`
255			`mov #0,r0`
256			`addc r0,r7`
257			`2:`
258			`mov r6,r2`
259			`mov #-5,r0`
260			`shld r0,r6`
261			`tst r6,r6`
262			`bt/s 2f`
263			`clrt`
264			`.align 2`
265			`1:`
266			`SRC( mov.l @r4+,r0 )`
267			`SRC( mov.l @r4+,r1 )`
268			`addc r0,r7`
269			`DST( mov.l r0,@r5 )`
270			`DST( mov.l r1,@(4,r5) )`
271			`addc r1,r7`
272
273			`SRC( mov.l @r4+,r0 )`
274			`SRC( mov.l @r4+,r1 )`
275			`addc r0,r7`
276			`DST( mov.l r0,@(8,r5) )`
277			`DST( mov.l r1,@(12,r5) )`
278			`addc r1,r7`
279
280			`SRC( mov.l @r4+,r0 )`
281			`SRC( mov.l @r4+,r1 )`
282			`addc r0,r7`
283			`DST( mov.l r0,@(16,r5) )`
284			`DST( mov.l r1,@(20,r5) )`
285			`addc r1,r7`
286
287			`SRC( mov.l @r4+,r0 )`
288			`SRC( mov.l @r4+,r1 )`
289			`addc r0,r7`
290			`DST( mov.l r0,@(24,r5) )`
291			`DST( mov.l r1,@(28,r5) )`
292			`addc r1,r7`
293			`add #32,r5`
294			`movt r0`
295			`dt r6`
296			`bf/s 1b`
297			`cmp/eq #1,r0`
298			`mov #0,r0`
299			`addc r0,r7`
300
301			`2: mov r2,r6`
302			`mov #0x1c,r0`
303			`and r0,r6`
304			`cmp/pl r6`
305			`bf/s 4f`
306			`clrt`
307			`shlr2 r6`
308			`3:`
309			`SRC( mov.l @r4+,r0 )`
310			`addc r0,r7`
311			`DST( mov.l r0,@r5 )`
312			`add #4,r5`
313			`movt r0`
314			`dt r6`
315			`bf/s 3b`
316			`cmp/eq #1,r0`
317			`mov #0,r0`
318			`addc r0,r7`
319			`4: mov r2,r6`
320			`mov #3,r0`
321			`and r0,r6`
322			`cmp/pl r6`
323			`bf 7f`
324			`mov #2,r1`
325			`cmp/hs r1,r6`
326			`bf 5f`
327			`SRC( mov.w @r4+,r0 )`
328			`DST( mov.w r0,@r5 )`
329			`extu.w r0,r0`
330			`add #2,r5`
331			`cmp/eq r1,r6`
332			`bt/s 6f`
333			`clrt`
334			`shll16 r0`
335			`addc r0,r7`
336			`5:`
337			`SRC( mov.b @r4+,r0 )`
338			`DST( mov.b r0,@r5 )`
339			`extu.b r0,r0`
340			`#ifndef __LITTLE_ENDIAN__`
341			`shll8 r0`
342			`#endif`
343			`6: addc r0,r7`
344			`mov #0,r0`
345			`addc r0,r7`
346			`7:`
347			`5000:`
348
349			`# Exception handler:`
350			`.section .fixup, "ax"`
351
352			`6001:`
353			`mov.l @(8,r15),r0 ! src_err_ptr`
354			`mov #-EFAULT,r1`
355			`mov.l r1,@r0`
356
357			`! zero the complete destination - computing the rest`
358			`! is too much work`
359			`mov.l @(4,r15),r5 ! dst`
360			`mov.l @r15,r6 ! len`
361			`mov #0,r7`
362			`1: mov.b r7,@r5`
363			`dt r6`
364			`bf/s 1b`
365			`add #1,r5`
366			`mov.l 8000f,r0`
367			`jmp @r0`
368			`nop`
369			`.align 2`
370			`8000: .long 5000b`
371
372			`6002:`
373			`mov.l @(12,r15),r0 ! dst_err_ptr`
374			`mov #-EFAULT,r1`
375			`mov.l r1,@r0`
376			`mov.l 8001f,r0`
377			`jmp @r0`
378			`nop`
379			`.align 2`
380			`8001: .long 5000b`
381
382			`.previous`
383			`add #8,r15`
384			`rts`
385			`mov r7,r0`