1 files changed, 23 insertions, 49 deletions
diff --git a/arch/cris/arch-v32/lib/checksum.S b/arch/cris/arch-v32/lib/checksum.S
index 32e66181b826..87f3fd71ab10 100644
--- a/arch/cris/arch-v32/lib/checksum.S
+++ b/arch/cris/arch-v32/lib/checksum.S
@@ -1,6 +1,6 @@
 /*
 * A fast checksum routine using movem
- * Copyright (c) 1998-2001, 2003 Axis Communications AB
+ * Copyright (c) 1998-2007 Axis Communications AB
 *
 * csum_partial(const unsigned char * buff, int len, unsigned int sum)
 */
@@ -12,30 +12,23 @@ csum_partial:
        ;; r11 - length
        ;; r12 - checksum
-        ;; check for breakeven length between movem and normal word looping versions
+        ;; Optimized for large packets
-        ;; we also do _NOT_ want to compute a checksum over more than the
+        subq    10*4, $r11
-        ;; actual length when length < 40
+        blt     _word_loop
+        move.d  $r11, $acr
-        cmpu.w  80,$r11
-        blo     _word_loop
-        nop
-        ;; need to save the registers we use below in the movem loop
-        ;; this overhead is why we have a check above for breakeven length
-        ;; only r0 - r8 have to be saved, the other ones are clobber-able
-        ;; according to the ABI
        subq    9*4,$sp
-        subq    10*4,$r11       ; update length for the first loop
+        clearf  c
        movem   $r8,[$sp]
        ;; do a movem checksum
 _mloop: movem   [$r10+],$r9     ; read 10 longwords
+        ;; Loop count without touching the c flag.
+        addoq   -10*4, $acr, $acr
        ;; perform dword checksumming on the 10 longwords
-        add.d   $r0,$r12
+        addc    $r0,$r12
        addc    $r1,$r12
        addc    $r2,$r12
        addc    $r3,$r12
@@ -46,60 +39,41 @@ _mloop:	movem	[$r10+],$r9	; read 10 longwords
        addc    $r8,$r12
        addc    $r9,$r12
-        ;; fold the carry into the checksum, to avoid having to loop the carry
+        ;; test $acr without trashing carry.
-        ;; back into the top
+        move.d  $acr, $acr
+        bpl     _mloop
-        addc    0,$r12
+        ;; r11 <= acr  is not really needed in the mloop, just using the dslot
-        addc    0,$r12          ; do it again, since we might have generated a carry
+        ;; to prepare for what is needed after mloop.
+        move.d  $acr, $r11
-        subq    10*4,$r11
-        bge     _mloop
-        nop
-        addq    10*4,$r11       ; compensate for last loop underflowing length
+        ;; fold the last carry into r13
+        addc    0, $r12
        movem   [$sp+],$r8      ; restore regs
 _word_loop:
-        ;; only fold if there is anything to fold.
+        addq    10*4,$r11       ; compensate for last loop underflowing length
-        cmpq    0,$r12
-        beq     _no_fold
-        ;; fold 32-bit checksum into a 16-bit checksum, to avoid carries below.
-        ;; r9 and r13 can be used as temporaries.
        moveq   -1,$r9          ; put 0xffff in r9, faster than move.d 0xffff,r9
        lsrq    16,$r9
        move.d  $r12,$r13
        lsrq    16,$r13         ; r13 = checksum >> 16
-        and.d   $r9,$r12                ; checksum = checksum & 0xffff
+        and.d   $r9,$r12        ; checksum = checksum & 0xffff
-        add.d   $r13,$r12               ; checksum += r13
-        move.d  $r12,$r13               ; do the same again, maybe we got a carry last add
-        lsrq    16,$r13
-        and.d   $r9,$r12
-        add.d   $r13,$r12
 _no_fold:
-        cmpq    2,$r11
+        subq    2,$r11
        blt     _no_words
-        nop
+        add.d   $r13,$r12       ; checksum += r13
        ;; checksum the rest of the words
-        subq    2,$r11
 _wloop: subq    2,$r11
        bge     _wloop
        addu.w  [$r10+],$r12
-        addq    2,$r11
 _no_words:
+        addq    2,$r11
        ;; see if we have one odd byte more
-        cmpq    1,$r11
+        bne     _do_byte
-        beq     _do_byte
        nop
        ret
        move.d  $r12,$r10

diff --git a/arch/cris/arch-v32/lib/checksum.S b/arch/cris/arch-v32/lib/checksum.S index 32e66181b826..87f3fd71ab10 100644 --- a/arch/cris/arch-v32/lib/checksum.S +++ b/arch/cris/arch-v32/lib/checksum.S
@@ -1,6 +1,6 @@
1	/*	1	/*
2	* A fast checksum routine using movem	2	* A fast checksum routine using movem
3	* Copyright (c) 1998-2001, 2003 Axis Communications AB	3	* Copyright (c) 1998-2007 Axis Communications AB
4	*	4	*
5	* csum_partial(const unsigned char * buff, int len, unsigned int sum)	5	* csum_partial(const unsigned char * buff, int len, unsigned int sum)
6	*/	6	*/
@@ -12,30 +12,23 @@ csum_partial:
12	;; r11 - length	12	;; r11 - length
13	;; r12 - checksum	13	;; r12 - checksum
14		14
15	;; check for breakeven length between movem and normal word looping versions	15	;; Optimized for large packets
16	;; we also do _NOT_ want to compute a checksum over more than the	16	subq 10*4, $r11
17	;; actual length when length < 40	17	blt _word_loop
18		18	move.d $r11, $acr
19	cmpu.w 80,$r11
20	blo _word_loop
21	nop
22
23	;; need to save the registers we use below in the movem loop
24	;; this overhead is why we have a check above for breakeven length
25	;; only r0 - r8 have to be saved, the other ones are clobber-able
26	;; according to the ABI
27		19
28	subq 9*4,$sp	20	subq 9*4,$sp
29	subq 10*4,$r11 ; update length for the first loop	21	clearf c
30	movem $r8,[$sp]	22	movem $r8,[$sp]
31		23
32	;; do a movem checksum	24	;; do a movem checksum
33		25
34	_mloop: movem [$r10+],$r9 ; read 10 longwords	26	_mloop: movem [$r10+],$r9 ; read 10 longwords
35		27	;; Loop count without touching the c flag.
		28	addoq -10*4, $acr, $acr
36	;; perform dword checksumming on the 10 longwords	29	;; perform dword checksumming on the 10 longwords
37		30
38	add.d $r0,$r12	31	addc $r0,$r12
39	addc $r1,$r12	32	addc $r1,$r12
40	addc $r2,$r12	33	addc $r2,$r12
41	addc $r3,$r12	34	addc $r3,$r12
@@ -46,60 +39,41 @@ _mloop: movem [$r10+],$r9 ; read 10 longwords
46	addc $r8,$r12	39	addc $r8,$r12
47	addc $r9,$r12	40	addc $r9,$r12
48		41
49	;; fold the carry into the checksum, to avoid having to loop the carry	42	;; test $acr without trashing carry.
50	;; back into the top	43	move.d $acr, $acr
51		44	bpl _mloop
52	addc 0,$r12	45	;; r11 <= acr is not really needed in the mloop, just using the dslot
53	addc 0,$r12 ; do it again, since we might have generated a carry	46	;; to prepare for what is needed after mloop.
54		47	move.d $acr, $r11
55	subq 10*4,$r11
56	bge _mloop
57	nop
58
59	addq 10*4,$r11 ; compensate for last loop underflowing length
60		48
		49	;; fold the last carry into r13
		50	addc 0, $r12
61	movem [$sp+],$r8 ; restore regs	51	movem [$sp+],$r8 ; restore regs
62		52
63	_word_loop:	53	_word_loop:
64	;; only fold if there is anything to fold.	54	addq 10*4,$r11 ; compensate for last loop underflowing length
65
66	cmpq 0,$r12
67	beq _no_fold
68
69	;; fold 32-bit checksum into a 16-bit checksum, to avoid carries below.
70	;; r9 and r13 can be used as temporaries.
71		55
72	moveq -1,$r9 ; put 0xffff in r9, faster than move.d 0xffff,r9	56	moveq -1,$r9 ; put 0xffff in r9, faster than move.d 0xffff,r9
73	lsrq 16,$r9	57	lsrq 16,$r9
74		58
75	move.d $r12,$r13	59	move.d $r12,$r13
76	lsrq 16,$r13 ; r13 = checksum >> 16	60	lsrq 16,$r13 ; r13 = checksum >> 16
77	and.d $r9,$r12 ; checksum = checksum & 0xffff	61	and.d $r9,$r12 ; checksum = checksum & 0xffff
78	add.d $r13,$r12 ; checksum += r13
79	move.d $r12,$r13 ; do the same again, maybe we got a carry last add
80	lsrq 16,$r13
81	and.d $r9,$r12
82	add.d $r13,$r12
83		62
84	_no_fold:	63	_no_fold:
85	cmpq 2,$r11	64	subq 2,$r11
86	blt _no_words	65	blt _no_words
87	nop	66	add.d $r13,$r12 ; checksum += r13
88		67
89	;; checksum the rest of the words	68	;; checksum the rest of the words
90
91	subq 2,$r11
92
93	_wloop: subq 2,$r11	69	_wloop: subq 2,$r11
94	bge _wloop	70	bge _wloop
95	addu.w [$r10+],$r12	71	addu.w [$r10+],$r12
96		72
97	addq 2,$r11
98
99	_no_words:	73	_no_words:
		74	addq 2,$r11
100	;; see if we have one odd byte more	75	;; see if we have one odd byte more
101	cmpq 1,$r11	76	bne _do_byte
102	beq _do_byte
103	nop	77	nop
104	ret	78	ret
105	move.d $r12,$r10	79	move.d $r12,$r10