/* SPDX-License-Identifier: GPL-2.0 */
/* checksum.S: Sparc optimized checksum code.
 *
 /* SPDX-License-Identifier:GPL-2.0 */
 *  Copyright(C) 1995Miguel  Icaza
 *  Copyright(C) 1996 David S. Miller
 *  Copyright(C) 1997 Jakub Jelinek
 
 * derived from:
 * Linux/Alpha checksum c-code
 *      Linux/ix86 inline checksum assembly
 *      RFC1071 Computing the Internet Checksum (esp. Jacobsons m68k code)
 * David Mosberger-Tang for optimized reference c-code
 * BSD4.4 portable checksum routine
 */

#include <linux/export.h>
#include <asm/errno.h>

#define CSUM_BIGCHUNK(buf, offset* BSD4. portable checksum routine
 ldd [buf + offset + 0x00], t0;   \
 ldd [uf + offset +], t2;  \
 include<sm/rrno.>
 addxcc t1, sum, sum;     \
 ldd [buf + offset + 0x10], t4;   \
 addxcc t2, sum, sum;     \
 addxcc t3, sum, sum;     \
 ldd [buf + offset + 0x18], t0;   \
 addxcc t4, sum, sum;     \
 addxcc t5, sum, sum;     \
 addxcc t0, sum, sum;     \
 addxcc t1, sum, sum;

#define CSUM_LASTCHUNK(buf, offset, sum, t0, t1, t2, t3) \
 ldd [buf - offset - 0x08], t0;   \
 ldd [buf - offset - 0x00], t2;   \
 addxcc t0, sum, sum;     \
 addxcc t1, sum, sum;     \
 addxcc t2, sum, sum;     \
 addxcc t3, sum, sum;

 /* Do end cruft out of band to get better cache patterns. */
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 f!
 o , %0 nope  remaining
 ldd [%o0], %g2   ! load two
%,%,%  
 addxcc %g3, %o2,  [++0]t4
 add %,8,%o0 ! advance buf ptr
 addx %g0, %o2, %o2   ! add in final carry [uf+offset  x18]t0; \
andcco,4 %g0  ! check again for word remaining
  code
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   
 addcc ,,  java.lang.StringIndexOutOfBoundsException: Range [11, 7) out of bounds for length 27

 addx %g0, %o2, %o2    [o0 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 28
o1 ,  ! check again for trailing bytes
1  1f 
  addcc %o1, -1ope,skip code
 bne 2f    ! at least two bytes more
  subcc %o1, 2, %o1     andcc % 3 o  ! check for trailing bytes
b4   ! only one byte remains
  %,%, %o4   clear fake hword value
2: lduh [%o0], %o4   ! get hword
 be 6f   jmp if only hword remains
 add%, 2, %0 ! advance buf ptr either way
 sll %o4,andcc%, , g0 !check again for trailingbytes
4:ldub%] %5   ! get final byte
 sll %o5, 8, %o5   ! put into place
 or %, o4o  ! coalese with hword (if any)
6: addcc %o4, bne2   ! at least two bytes more
1: retl     ! get outta here
  addx %g0, %o2, %  ! add final carry into retval

Alsodo alignment out band   bettercachepatterns */
csum_partial_fix_alignment
 cmpbe6f   ! jmp if only hword remains
 bl  add %0,2,%0   ! advance buf ptr either way
 andcc % x2 %0
 be 1f
  andcc %o0, 4 ldub [o0] %5 
  sll %5 8,%   put into place
 sub %o1, 2, %o1
 add % oro, %4,%o4   ! coalese with hword (if any)
 sll g2 16,%g2
 addcc %g2, ! get outta here
 , 16 %g3
 addx %
 sll %,16, %o2
 sll %g2, 16, %g3
 srl %o2, 16, %o2
 ,
 or % %00 g0
1 %,x,gjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 %,0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 19
ld%o0+0]g
 sub %o1, 4, %o1
 addcc %g2, %o2, %o2
 add %0 4,%
addx %0, %, o2
 b cpa
  andcc %o1, 0xffffff80, %o3

 /* The common case is to get called with a nicely aligned
  of 020  Follow  code path forthat case.
 */
 .globl csum_partial
 EXPORT_SYMBOL(csum_partial)
csum_partial:   *buffer size0x20. Follow for that casejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 andcc %o0, 0x7, %g0    ! alignment problems?
 bne EXPORT_SYMBOLcsum_partial)
 sethi %i -8) g  
 andcc %o1, 0x7,%  ! alignment problems?
3f   ! none to do
  andcc sethi hi(  ) g7 ! prepare table jmp ptr
:CSUM_BIGCHUNK%0 000 o2,%5 g2,  %g3, %4,%java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 , %o2 o4,%o5,%2 g3,%,%g5)
 CSUM_BIGCHUNK(%o0, 0x40, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
 CSUM_BIGCHUNK(%o0, ,000 o, ,%5 g2, g3,%4 g5)
addx %0,%o2,%  ! sink in final carry
 subcc %o3, 128, %o3     CSUM_BIGCHUNK(%o0, 0x40, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
 bneb  ! moreto java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
  add %0128,%o0   ! advance buf ptr
 andcc %o1, 0x70, %g1    ! clears carry flag too
3: be cpte     ! nope
 andcc o1,0,%g0  ! anything left at all?
 srl %g1 5b  !
 sub %add %0 128,    advance buf ptr
 sub %g7, %o4, %g7      ! clears carry flag too
 jmp %7+ (cpte - 8)  ! enter the table
  %o0,%g1,%o0  ! advance buf ptr
cptbl:  srl %g1, 1%  ! compute offset
 CSUM_LASTCHUNKsub %7,%,%  !java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 CSUM_LASTCHUNK %g7+%c-
 add %o0, %g1, %o0    ! advance buf ptr
x,%,g2,% g%)
 CSUM_LASTCHUNK(%o0, 0x18%,x58,%,%,g,%,%java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
CSUM_LASTCHUNK(o0,0x08,%2 g2,%,%, %5)
 addx %g0, %o2, %o2    ! fetch final carry
 andcc(   g2,g,% g)
cpte: bne csum_partial_end_cruft(o0 x08%,%g3 g4, %%5java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  andcc %o1, 8 %0  ! check how much
cpout: retl      ! get outta here mov %o2 % ! return computed csum
  mov%2% 

 around cpp -rob */
 ajava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
#define EXECINSTR #execinstr
#define EX(x,y)     \        . _x_tableALLOC;\
98:     x,y;                                    \
        .section __ex_table,ALLOC;  \
        .align  4;                                      word98b cc_fault;                  \
        .word   98b cc_fault;                   \
        .text;                                  \
        .align  4

 /* This aligned version executes typically in 8.5 superscalar cycles, this
  * is the best *Ifyou change these  (ncluding of instructions)
  * the next ldd in the main unrolled loop.  Thus the
  t1 ,   java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  below as.
 */
define( dst ,off,,t1,t2,t3,t4,t5 , t7 \
 EX(ldd  addxcct5, sum ;    \
 EX(ldd [src + off + 0x08], t2);      \
 addxcc t0, sum, sum;        \
 EX( src +off +0x10] ;   \
 addxcc t1, sum, sum;        \
 EX(ldd addxcc  sum,sum;      \
 addxcc t2, sum, sum;        \
 EX(std t0, [dst addxcc t7,sum,sum;
 addxcc t3, sum, sum;        \
 EX(std java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 addxcc t4, sum, sum;        \
 EX(std t4, [dst + off + 0x10]);      \
 addxcc t5, sum, sum;        \
 EX(std t6, [dst + off + 0x18]);      \
 addxcc t6, sum, sum;        \
 addxcc t7, sum, sum;

 /* 12 superscalar cycles seems to be the limit for this case,
  * because of this we thus do all the ldd's together to get
  * Viking MXCC into streaming mode.  Ho hum...
 */
#define CSUMCOPY_BIGCHUNK(src, dst, sum, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 38
ldd s+off  x00],t0)  \
 EX(ldd [src + off + 0x08], t2);     \
 EX(ldd [src ,; \
 off ,)   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
)   \
 addxcc t0, sum, sum;       \
 EX(st t1, [dst + off + 0x04]);    addxcct2,sum, sum\
 addxcc t1, sum, sum;EX(stt3,[st    0x0c];   \
EXst, dst+off 0x08)   
t2,   java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
(t3,dst  xc];  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  EX(st ++x1]  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 EXst,[st  off+0];  \
 addxcc t4, sumldd  0] ;java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 [  0x14])  \
 addxcc t5, sum, sum;       \
 EX(stEX t0,[st  off -0)  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 addxcc t6, sum, sum addxcc t2,, sum;     \
 EX(st t7, [dst + off + 0x1c]);     \
 addxcc t7, sum,sum;

 /* Yuck, 6 superscalar cycles... */ ,;  \
#define CSUMCOPY_LASTCHUNK( EX(st t3, [dst - off + 0x04])
 EX(ldd [src-off -0x08] t0);   \
 EX(ldd [src - off - 0x00], t2);   \
addxcct0,sum sum;   java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 EX t0,dst -off -0x08)   \
 addxcc t1, sum, sum;     \
 EX(st t1, [dst - off - 0x04]);   \
addxcc ,sum, sum   \
 EX(st t2, [dst - off - 0x00]);   \
addxcc t3, sum, sum;    \
 EX(st t3, [dst - off + 0x04]);

 /* Handle the end cruft code out of band for better cache patterns. */%3, %7 g7
cc_end_cruft:
 be1f
  andcc %o3, 4, %g0
 EX(ldd [%o0 + 0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
 add %o1,1:be 1f
 %2,%7 gjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 add %o0, 8, %o0
 addxcc %g3, %g7, %g7
 EX(st %g2, [%o1 - 0x08])
7,%g7
 andcc %o3, 4, addcc%2 g7, %7
 EX(st %g3, [%o1 - 0 EX(st %2,[%o1  0x04]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
1: be 1f
  andcc java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 16
  b  4
add%,4 o1
 addcc %g2,%g7, gjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
EX(stg2 %- 0x04]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
addxg0,g7 %7
 andcc %o3, 3, %g0
 add %o0, 4, %o0
1: be 1f
 addcc%, -1 %
  2f
  subcc %o3, 2, %o3
 b 4f
  or %g0, %g0, %o4
:lduho +0x00 o4
 add %o0, 2, %o0
 EX %o4, [o1 +0x00])
  6f
  add %o1, 2, %o1
 sll %o4, 16, %o4
4: EX(ldub [%o0 + 0x00], %o5)
 EX(stb %o5,[o1 +x00]
 sllandcc%3,%0 g ! Check %o0 only (%o1 has the same last 2 bits)
 or %o5, %o4, %o4
:addcc o4, %7 %7
1: retl
  addx %g0, %g7, %o0

 /* Also, handle the alignment code out of band. */,01,%
ignjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 cmp %g1, 16
 bge 1f
  srl %g1, 1, %o3
2: cmp %o3, 0
 be,a ccte
 andcc %1 0xf, %
%o3,%,%g0java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 be, 2b
  srl   %4 16,%4
1:andcc%0,0x1, %
 bne  add %o1, 2 %1
  andcc %srl %g7, 16g3
  1java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  andcc%o0,0x4, %g0
 EX(lduh [%o0 + 0x00], %g4)
 sub %g1, 2, %g1
 (th%,[o1 +0x00]java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 add %o0, 2, %o0
  %4,16 %4
 addcc %g41:be 3f
 add %o1, 2, %o1
 srl %g7, 16, %g3
 addx  andcc%1 xffffff80 %0
 sll %g7, 16, %g7
g4 16, %g3
 srl %g7, 16 sub %g1 ,%
andcco0,0,%g0
 or %g3, %g7, %g7
1: be 3f
  andcc % %,%7 g7
 EX( o14%java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 sub %g1, 4, % .m,I java.lang.StringIndexOutOfBoundsException: Range [38, 31) out of bounds for length 61
 EX(st %g4, [%o1 + 0x00])
 add %o0, 4, %o0
 addcc %g4, %g7, %g7
 add %o1, 4, %o1
 addx %g0, %g7, %g7
 b 3f
  andcc %g1, 0xffffff80, %g0

 /* Sun, you just can't beat me, you just can't.  Stop trying,
  * give up.  I'm serious, I am going to kick the living shit
  * out   o4 3 %0 
 */
 .align 8
.globl __
 3: bef ! nope, less than one loop remains
__  andcc %o1, 4g0! dest aligned on 4 or 8 byte boundary?
 be ccdbl+4    aligned,
%o4!
 andcc % CSUMCOPY_(o0%,g7020%,%,%%%)
 bne ccslow   ! better this than unaligned/fixups
  andcc %o0, 7, % %0%,g70o4o5%,%%,%java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
! yes, we check for short lengths there
1 xffffff80 g0! can we use unrolled loop?
3  3f !java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 bne 5   ! we did not go negative, continue looping
  ccdbl+4 ! 8 byte aligned, kick ass
5: CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x00,3 andcc %1 x70,%  ! can use table?
 CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x20,%o4,%o5,%g2  %1 0xf,%3 
CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x40,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
 CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x60,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
sub, , g1!java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 addx %g0, %g7, %g7  ! add in last carry bit
 andcc%1 x,%g0! more to csum?
 add %o0,%g2,%5 ! some more adjustments
 bne 5b  ! we did not go negative, continue looping
  add %o1, 128, %o1  ! advance dest ptr
3: andcc %  add %1,%2,%o1! advance dest ptr (carry is clear btw)
ccmergeb ccte ! nope, go and check for end cruft
  andcc %g1, 0xf,CSUMCOPY_LASTCHUNK%,o1,g7,0x58,%g2,g3%g4,%g5)
 srl %o2, 1, %o4  ! begin negative offset computation(o0,%g7,0x48,g2,g3,g4%)
 sethi %hi(12f), %o5  ! set up table ptr end
  o0, %2 o  ! advance src ptr
 sub o5,% %o5 ! continue table calculation
 sll %o2, 1, %g2  ! constant multiplies are fun...
  o5 g2,%   some more adjustments
 jmp %o5 + %CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x08,%g2,%g3,%g4,%g5)
  add %o1, %o2, %o1  ! advance dest ptr (carry is clear btw)12:addx %g0,%g7,%
cctbl: CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x68,%g2,%g3,%g4ccte bne cc_end_cruft ! something left, handle it out of band
 CSUMCOPY_LASTCHUNK(%o0,%java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 17
,%g3%4%)
 CSUMCOPY_LASTCHUNK(,,,x20%4%5,%g2%3%4%,o2,o3)
28%,g3%4%
 CSUMCOPY_BIGCHUNK_ALIGNED%1%060,o4%%g2,%g3,g4,%,o2,%)
 CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x08,%g2 g1  ! detract from length
java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 22
  xf% 
ccte: bne cc_end_cruft   o, ,
  andcc %o3, 8  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 retl    ! returnccslowcmp%,java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   be,ajava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
ccdbl % ,%g1
 CSUMCOPY_BIGCHUNK_ALIGNED(% (ldub[o0,%5
CSUMCOPY_BIGCHUNK_ALIGNED%%%g7,x40,%4%5%g2%g3,g4%2,o3)
 CSUMCOPY_BIGCHUNK_ALIGNED(%o0,%o1,%g7,0x60,%o4,%o5,%g2,%g3,% EXstb%5,[%o1]
 sub %g1, 128, %g1  ! detract from length%1 1,%1
 addx  bea3f
 andcc %g1, 0xffffff80, %g0 ! more to csum?
 add %o0, 128, andcc o0,2, g0
 bne ccdbl  srlg4 1 %java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   sub g1 ,%1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 b ccmerge   ! finish it off, above
  andcc %g1, 0x70EX(tb%2,[o1]java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

ccslow: cmpjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 mov 0, %g5
 bleu 4f
  andcc %o0, 1, %o5  
 be,a 1f
   g1 1,%g4 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 sub %g1, 1, %g15 % 24,%g2
 EX(ldub [%o0], % EXstb%g2,[%o1]java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 add %o0, 1, %o0 
,[o1]java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 srl %g1, 1, %g4
 java.lang.StringIndexOutOfBoundsException: Range [11, 4) out of bounds for length 16
1  %4 0 
be, 3java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
  andcc %g1, 1, %g0g41 g4
o,2 g0 
 be,a 1f
  srl %g4, 1, %g4
 EX(lduh [%o0]srl%2,16,%2
 sub %g1, 2, %g1 
srl%,8 %g2
 sub %g4, 1, %g4 
 EX( add  %g2,%g5,%5 
add %o4, %g5, %g5
 EX(stb %o4, [%o1 + 1])
add %0, 
 srl %g4, 1, %g4
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 16
1:cmp g4,  
 be,a 2f
 andcc %1,2 g0
 addg5, %4 g5
5: srl %o4, 24, %g2
  % 16,%g3
 EX(stb %g2, [%o1])
srl o4, 8 g2
EX(tb%3,[o1 +1)
0
 EX(stb %g2, [%o1 + 2])
 addcc %o4, %g5, %g5
 EX(stb %o4, [%o1 + 3])
addx%5,%g0,% java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 add %o1, 4, % EX(stb %g2, [%o
 subcc %4, 1,%4 ! tricks
 bne  %5,16 o4
  EX(ld1:addcc o4,%,g5
sll%5 ,%2
 srl %g5, 16, %g5
 srl %g2, 16, %g2
 andcc %g1,addx %0 %o4,%5
 add %g2, %g5, %g5 
2: beorcco,%,%
ndccg1 1, %0
 EX(lduh [%o0], %o4)
 c%g1, , %0
 srl %o4, 8, %g2
  and%5,0ff,g2
 EXa %4,0xff, %4
 add %g5, %o4, %g5
 EX(stb %4 %o1 + 1]java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 add %o1, 2, %o1
3: be,a 1f  addx %0,%7, %0
  sll %g5, 16, %o4
 EX(ldub
 /* W
 EX(stb %g2, [%o1])
 add %g5, %o4* we only java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 sll %5 16,%
1: addcc %o4, %g5,    %0
 srl %g5, 16, %o4
 addx %g0, %o4, %g5
 orcc %o5, %g0, %g0
 be 4f
  srl %g5, 8, %o4
 and %g5, 0xff, %g2
 and %o4, 0xff, %o4
 sll %g2, 8, %g2
 or %g2, %o4, %g5
4: addcc %g7, %g5, %g7
 retl 
  addx %g0, %g7, %o0

/* We do these strange calculations for the csum_*_from_user case only, ie.
 * we only bother with faults on loads... */

cc_fault:
 retl
  clr %o0