Merge branch 'core/iommu' into core/urgent
[linux-2.6] / arch / sparc / lib / checksum_32.S
1 /* checksum.S: Sparc optimized checksum code.
2  *
3  *  Copyright(C) 1995 Linus Torvalds
4  *  Copyright(C) 1995 Miguel de Icaza
5  *  Copyright(C) 1996 David S. Miller
6  *  Copyright(C) 1997 Jakub Jelinek
7  *
8  * derived from:
9  *      Linux/Alpha checksum c-code
10  *      Linux/ix86 inline checksum assembly
11  *      RFC1071 Computing the Internet Checksum (esp. Jacobsons m68k code)
12  *      David Mosberger-Tang for optimized reference c-code
13  *      BSD4.4 portable checksum routine
14  */
15
16 #include <asm/errno.h>
17
18 #define CSUM_BIGCHUNK(buf, offset, sum, t0, t1, t2, t3, t4, t5) \
19         ldd     [buf + offset + 0x00], t0;                      \
20         ldd     [buf + offset + 0x08], t2;                      \
21         addxcc  t0, sum, sum;                                   \
22         addxcc  t1, sum, sum;                                   \
23         ldd     [buf + offset + 0x10], t4;                      \
24         addxcc  t2, sum, sum;                                   \
25         addxcc  t3, sum, sum;                                   \
26         ldd     [buf + offset + 0x18], t0;                      \
27         addxcc  t4, sum, sum;                                   \
28         addxcc  t5, sum, sum;                                   \
29         addxcc  t0, sum, sum;                                   \
30         addxcc  t1, sum, sum;
31
32 #define CSUM_LASTCHUNK(buf, offset, sum, t0, t1, t2, t3)        \
33         ldd     [buf - offset - 0x08], t0;                      \
34         ldd     [buf - offset - 0x00], t2;                      \
35         addxcc  t0, sum, sum;                                   \
36         addxcc  t1, sum, sum;                                   \
37         addxcc  t2, sum, sum;                                   \
38         addxcc  t3, sum, sum;
39
40         /* Do end cruft out of band to get better cache patterns. */
41 csum_partial_end_cruft:
42         be      1f                              ! caller asks %o1 & 0x8
43          andcc  %o1, 4, %g0                     ! nope, check for word remaining
44         ldd     [%o0], %g2                      ! load two
45         addcc   %g2, %o2, %o2                   ! add first word to sum
46         addxcc  %g3, %o2, %o2                   ! add second word as well
47         add     %o0, 8, %o0                     ! advance buf ptr
48         addx    %g0, %o2, %o2                   ! add in final carry
49         andcc   %o1, 4, %g0                     ! check again for word remaining
50 1:      be      1f                              ! nope, skip this code
51          andcc  %o1, 3, %o1                     ! check for trailing bytes
52         ld      [%o0], %g2                      ! load it
53         addcc   %g2, %o2, %o2                   ! add to sum
54         add     %o0, 4, %o0                     ! advance buf ptr
55         addx    %g0, %o2, %o2                   ! add in final carry
56         andcc   %o1, 3, %g0                     ! check again for trailing bytes
57 1:      be      1f                              ! no trailing bytes, return
58          addcc  %o1, -1, %g0                    ! only one byte remains?
59         bne     2f                              ! at least two bytes more
60          subcc  %o1, 2, %o1                     ! only two bytes more?
61         b       4f                              ! only one byte remains
62          or     %g0, %g0, %o4                   ! clear fake hword value
63 2:      lduh    [%o0], %o4                      ! get hword
64         be      6f                              ! jmp if only hword remains
65          add    %o0, 2, %o0                     ! advance buf ptr either way
66         sll     %o4, 16, %o4                    ! create upper hword
67 4:      ldub    [%o0], %o5                      ! get final byte
68         sll     %o5, 8, %o5                     ! put into place
69         or      %o5, %o4, %o4                   ! coalese with hword (if any)
70 6:      addcc   %o4, %o2, %o2                   ! add to sum
71 1:      retl                                    ! get outta here
72          addx   %g0, %o2, %o0                   ! add final carry into retval
73
74         /* Also do alignment out of band to get better cache patterns. */
75 csum_partial_fix_alignment:
76         cmp     %o1, 6
77         bl      cpte - 0x4
78          andcc  %o0, 0x2, %g0
79         be      1f
80          andcc  %o0, 0x4, %g0
81         lduh    [%o0 + 0x00], %g2
82         sub     %o1, 2, %o1
83         add     %o0, 2, %o0
84         sll     %g2, 16, %g2
85         addcc   %g2, %o2, %o2
86         srl     %o2, 16, %g3
87         addx    %g0, %g3, %g2
88         sll     %o2, 16, %o2
89         sll     %g2, 16, %g3
90         srl     %o2, 16, %o2
91         andcc   %o0, 0x4, %g0
92         or      %g3, %o2, %o2
93 1:      be      cpa
94          andcc  %o1, 0xffffff80, %o3
95         ld      [%o0 + 0x00], %g2
96         sub     %o1, 4, %o1
97         addcc   %g2, %o2, %o2
98         add     %o0, 4, %o0
99         addx    %g0, %o2, %o2
100         b       cpa
101          andcc  %o1, 0xffffff80, %o3
102
103         /* The common case is to get called with a nicely aligned
104          * buffer of size 0x20.  Follow the code path for that case.
105          */
106         .globl  csum_partial
107 csum_partial:                   /* %o0=buf, %o1=len, %o2=sum */
108         andcc   %o0, 0x7, %g0                           ! alignment problems?
109         bne     csum_partial_fix_alignment              ! yep, handle it
110          sethi  %hi(cpte - 8), %g7                      ! prepare table jmp ptr
111         andcc   %o1, 0xffffff80, %o3                    ! num loop iterations
112 cpa:    be      3f                                      ! none to do
113          andcc  %o1, 0x70, %g1                          ! clears carry flag too
114 5:      CSUM_BIGCHUNK(%o0, 0x00, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
115         CSUM_BIGCHUNK(%o0, 0x20, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
116         CSUM_BIGCHUNK(%o0, 0x40, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
117         CSUM_BIGCHUNK(%o0, 0x60, %o2, %o4, %o5, %g2, %g3, %g4, %g5)
118         addx    %g0, %o2, %o2                           ! sink in final carry
119         subcc   %o3, 128, %o3                           ! detract from loop iters
120         bne     5b                                      ! more to do
121          add    %o0, 128, %o0                           ! advance buf ptr
122         andcc   %o1, 0x70, %g1                          ! clears carry flag too
123 3:      be      cpte                                    ! nope
124          andcc  %o1, 0xf, %g0                           ! anything left at all?
125         srl     %g1, 1, %o4                             ! compute offset
126         sub     %g7, %g1, %g7                           ! adjust jmp ptr
127         sub     %g7, %o4, %g7                           ! final jmp ptr adjust
128         jmp     %g7 + %lo(cpte - 8)                     ! enter the table
129          add    %o0, %g1, %o0                           ! advance buf ptr
130 cptbl:  CSUM_LASTCHUNK(%o0, 0x68, %o2, %g2, %g3, %g4, %g5)
131         CSUM_LASTCHUNK(%o0, 0x58, %o2, %g2, %g3, %g4, %g5)
132         CSUM_LASTCHUNK(%o0, 0x48, %o2, %g2, %g3, %g4, %g5)
133         CSUM_LASTCHUNK(%o0, 0x38, %o2, %g2, %g3, %g4, %g5)
134         CSUM_LASTCHUNK(%o0, 0x28, %o2, %g2, %g3, %g4, %g5)
135         CSUM_LASTCHUNK(%o0, 0x18, %o2, %g2, %g3, %g4, %g5)
136         CSUM_LASTCHUNK(%o0, 0x08, %o2, %g2, %g3, %g4, %g5)
137         addx    %g0, %o2, %o2                           ! fetch final carry
138         andcc   %o1, 0xf, %g0                           ! anything left at all?
139 cpte:   bne     csum_partial_end_cruft                  ! yep, handle it
140          andcc  %o1, 8, %g0                             ! check how much
141 cpout:  retl                                            ! get outta here
142          mov    %o2, %o0                                ! return computed csum
143
144         .globl __csum_partial_copy_start, __csum_partial_copy_end
145 __csum_partial_copy_start:
146
147 /* Work around cpp -rob */
148 #define ALLOC #alloc
149 #define EXECINSTR #execinstr
150 #define EX(x,y,a,b)                             \
151 98:     x,y;                                    \
152         .section .fixup,ALLOC,EXECINSTR;        \
153         .align  4;                              \
154 99:     ba 30f;                                 \
155          a, b, %o3;                             \
156         .section __ex_table,ALLOC;              \
157         .align  4;                              \
158         .word   98b, 99b;                       \
159         .text;                                  \
160         .align  4
161
162 #define EX2(x,y)                                \
163 98:     x,y;                                    \
164         .section __ex_table,ALLOC;              \
165         .align  4;                              \
166         .word   98b, 30f;                       \
167         .text;                                  \
168         .align  4
169
170 #define EX3(x,y)                                \
171 98:     x,y;                                    \
172         .section __ex_table,ALLOC;              \
173         .align  4;                              \
174         .word   98b, 96f;                       \
175         .text;                                  \
176         .align  4
177
178 #define EXT(start,end,handler)                  \
179         .section __ex_table,ALLOC;              \
180         .align  4;                              \
181         .word   start, 0, end, handler;         \
182         .text;                                  \
183         .align  4
184
185         /* This aligned version executes typically in 8.5 superscalar cycles, this
186          * is the best I can do.  I say 8.5 because the final add will pair with
187          * the next ldd in the main unrolled loop.  Thus the pipe is always full.
188          * If you change these macros (including order of instructions),
189          * please check the fixup code below as well.
190          */
191 #define CSUMCOPY_BIGCHUNK_ALIGNED(src, dst, sum, off, t0, t1, t2, t3, t4, t5, t6, t7)   \
192         ldd     [src + off + 0x00], t0;                                                 \
193         ldd     [src + off + 0x08], t2;                                                 \
194         addxcc  t0, sum, sum;                                                           \
195         ldd     [src + off + 0x10], t4;                                                 \
196         addxcc  t1, sum, sum;                                                           \
197         ldd     [src + off + 0x18], t6;                                                 \
198         addxcc  t2, sum, sum;                                                           \
199         std     t0, [dst + off + 0x00];                                                 \
200         addxcc  t3, sum, sum;                                                           \
201         std     t2, [dst + off + 0x08];                                                 \
202         addxcc  t4, sum, sum;                                                           \
203         std     t4, [dst + off + 0x10];                                                 \
204         addxcc  t5, sum, sum;                                                           \
205         std     t6, [dst + off + 0x18];                                                 \
206         addxcc  t6, sum, sum;                                                           \
207         addxcc  t7, sum, sum;
208
209         /* 12 superscalar cycles seems to be the limit for this case,
210          * because of this we thus do all the ldd's together to get
211          * Viking MXCC into streaming mode.  Ho hum...
212          */
213 #define CSUMCOPY_BIGCHUNK(src, dst, sum, off, t0, t1, t2, t3, t4, t5, t6, t7)   \
214         ldd     [src + off + 0x00], t0;                                         \
215         ldd     [src + off + 0x08], t2;                                         \
216         ldd     [src + off + 0x10], t4;                                         \
217         ldd     [src + off + 0x18], t6;                                         \
218         st      t0, [dst + off + 0x00];                                         \
219         addxcc  t0, sum, sum;                                                   \
220         st      t1, [dst + off + 0x04];                                         \
221         addxcc  t1, sum, sum;                                                   \
222         st      t2, [dst + off + 0x08];                                         \
223         addxcc  t2, sum, sum;                                                   \
224         st      t3, [dst + off + 0x0c];                                         \
225         addxcc  t3, sum, sum;                                                   \
226         st      t4, [dst + off + 0x10];                                         \
227         addxcc  t4, sum, sum;                                                   \
228         st      t5, [dst + off + 0x14];                                         \
229         addxcc  t5, sum, sum;                                                   \
230         st      t6, [dst + off + 0x18];                                         \
231         addxcc  t6, sum, sum;                                                   \
232         st      t7, [dst + off + 0x1c];                                         \
233         addxcc  t7, sum, sum;
234
235         /* Yuck, 6 superscalar cycles... */
236 #define CSUMCOPY_LASTCHUNK(src, dst, sum, off, t0, t1, t2, t3)  \
237         ldd     [src - off - 0x08], t0;                         \
238         ldd     [src - off - 0x00], t2;                         \
239         addxcc  t0, sum, sum;                                   \
240         st      t0, [dst - off - 0x08];                         \
241         addxcc  t1, sum, sum;                                   \
242         st      t1, [dst - off - 0x04];                         \
243         addxcc  t2, sum, sum;                                   \
244         st      t2, [dst - off - 0x00];                         \
245         addxcc  t3, sum, sum;                                   \
246         st      t3, [dst - off + 0x04];
247
248         /* Handle the end cruft code out of band for better cache patterns. */
249 cc_end_cruft:
250         be      1f
251          andcc  %o3, 4, %g0
252         EX(ldd  [%o0 + 0x00], %g2, and %o3, 0xf)
253         add     %o1, 8, %o1
254         addcc   %g2, %g7, %g7
255         add     %o0, 8, %o0
256         addxcc  %g3, %g7, %g7
257         EX2(st  %g2, [%o1 - 0x08])
258         addx    %g0, %g7, %g7
259         andcc   %o3, 4, %g0
260         EX2(st  %g3, [%o1 - 0x04])
261 1:      be      1f
262          andcc  %o3, 3, %o3
263         EX(ld   [%o0 + 0x00], %g2, add %o3, 4)
264         add     %o1, 4, %o1
265         addcc   %g2, %g7, %g7
266         EX2(st  %g2, [%o1 - 0x04])
267         addx    %g0, %g7, %g7
268         andcc   %o3, 3, %g0
269         add     %o0, 4, %o0
270 1:      be      1f
271          addcc  %o3, -1, %g0
272         bne     2f
273          subcc  %o3, 2, %o3
274         b       4f
275          or     %g0, %g0, %o4
276 2:      EX(lduh [%o0 + 0x00], %o4, add %o3, 2)
277         add     %o0, 2, %o0
278         EX2(sth %o4, [%o1 + 0x00])
279         be      6f
280          add    %o1, 2, %o1
281         sll     %o4, 16, %o4
282 4:      EX(ldub [%o0 + 0x00], %o5, add %g0, 1)
283         EX2(stb %o5, [%o1 + 0x00])
284         sll     %o5, 8, %o5
285         or      %o5, %o4, %o4
286 6:      addcc   %o4, %g7, %g7
287 1:      retl
288          addx   %g0, %g7, %o0
289
290         /* Also, handle the alignment code out of band. */
291 cc_dword_align:
292         cmp     %g1, 6
293         bl,a    ccte
294          andcc  %g1, 0xf, %o3
295         andcc   %o0, 0x1, %g0
296         bne     ccslow
297          andcc  %o0, 0x2, %g0
298         be      1f
299          andcc  %o0, 0x4, %g0
300         EX(lduh [%o0 + 0x00], %g4, add %g1, 0)
301         sub     %g1, 2, %g1
302         EX2(sth %g4, [%o1 + 0x00])
303         add     %o0, 2, %o0
304         sll     %g4, 16, %g4
305         addcc   %g4, %g7, %g7
306         add     %o1, 2, %o1
307         srl     %g7, 16, %g3
308         addx    %g0, %g3, %g4
309         sll     %g7, 16, %g7
310         sll     %g4, 16, %g3
311         srl     %g7, 16, %g7
312         andcc   %o0, 0x4, %g0
313         or      %g3, %g7, %g7
314 1:      be      3f
315          andcc  %g1, 0xffffff80, %g0
316         EX(ld   [%o0 + 0x00], %g4, add %g1, 0)
317         sub     %g1, 4, %g1
318         EX2(st  %g4, [%o1 + 0x00])
319         add     %o0, 4, %o0
320         addcc   %g4, %g7, %g7
321         add     %o1, 4, %o1
322         addx    %g0, %g7, %g7
323         b       3f
324          andcc  %g1, 0xffffff80, %g0
325
326         /* Sun, you just can't beat me, you just can't.  Stop trying,
327          * give up.  I'm serious, I am going to kick the living shit
328          * out of you, game over, lights out.
329          */
330         .align  8
331         .globl  __csum_partial_copy_sparc_generic
332 __csum_partial_copy_sparc_generic:
333                                         /* %o0=src, %o1=dest, %g1=len, %g7=sum */
334         xor     %o0, %o1, %o4           ! get changing bits
335         andcc   %o4, 3, %g0             ! check for mismatched alignment
336         bne     ccslow                  ! better this than unaligned/fixups
337          andcc  %o0, 7, %g0             ! need to align things?
338         bne     cc_dword_align          ! yes, we check for short lengths there
339          andcc  %g1, 0xffffff80, %g0    ! can we use unrolled loop?
340 3:      be      3f                      ! nope, less than one loop remains
341          andcc  %o1, 4, %g0             ! dest aligned on 4 or 8 byte boundary?
342         be      ccdbl + 4               ! 8 byte aligned, kick ass
343 5:      CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x00,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
344         CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x20,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
345         CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x40,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
346         CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x60,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
347 10:     EXT(5b, 10b, 20f)               ! note for exception handling
348         sub     %g1, 128, %g1           ! detract from length
349         addx    %g0, %g7, %g7           ! add in last carry bit
350         andcc   %g1, 0xffffff80, %g0    ! more to csum?
351         add     %o0, 128, %o0           ! advance src ptr
352         bne     5b                      ! we did not go negative, continue looping
353          add    %o1, 128, %o1           ! advance dest ptr
354 3:      andcc   %g1, 0x70, %o2          ! can use table?
355 ccmerge:be      ccte                    ! nope, go and check for end cruft
356          andcc  %g1, 0xf, %o3           ! get low bits of length (clears carry btw)
357         srl     %o2, 1, %o4             ! begin negative offset computation
358         sethi   %hi(12f), %o5           ! set up table ptr end
359         add     %o0, %o2, %o0           ! advance src ptr
360         sub     %o5, %o4, %o5           ! continue table calculation
361         sll     %o2, 1, %g2             ! constant multiplies are fun...
362         sub     %o5, %g2, %o5           ! some more adjustments
363         jmp     %o5 + %lo(12f)          ! jump into it, duff style, wheee...
364          add    %o1, %o2, %o1           ! advance dest ptr (carry is clear btw)
365 cctbl:  CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x68,%g2,%g3,%g4,%g5)
366         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x58,%g2,%g3,%g4,%g5)
367         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x48,%g2,%g3,%g4,%g5)
368         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x38,%g2,%g3,%g4,%g5)
369         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x28,%g2,%g3,%g4,%g5)
370         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x18,%g2,%g3,%g4,%g5)
371         CSUMCOPY_LASTCHUNK(%o0,%o1,%g7,0x08,%g2,%g3,%g4,%g5)
372 12:     EXT(cctbl, 12b, 22f)            ! note for exception table handling
373         addx    %g0, %g7, %g7
374         andcc   %o3, 0xf, %g0           ! check for low bits set
375 ccte:   bne     cc_end_cruft            ! something left, handle it out of band
376          andcc  %o3, 8, %g0             ! begin checks for that code
377         retl                            ! return
378          mov    %g7, %o0                ! give em the computed checksum
379 ccdbl:  CSUMCOPY_BIGCHUNK_ALIGNED(%o0,%o1,%g7,0x00,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
380         CSUMCOPY_BIGCHUNK_ALIGNED(%o0,%o1,%g7,0x20,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
381         CSUMCOPY_BIGCHUNK_ALIGNED(%o0,%o1,%g7,0x40,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
382         CSUMCOPY_BIGCHUNK_ALIGNED(%o0,%o1,%g7,0x60,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3)
383 11:     EXT(ccdbl, 11b, 21f)            ! note for exception table handling
384         sub     %g1, 128, %g1           ! detract from length
385         addx    %g0, %g7, %g7           ! add in last carry bit
386         andcc   %g1, 0xffffff80, %g0    ! more to csum?
387         add     %o0, 128, %o0           ! advance src ptr
388         bne     ccdbl                   ! we did not go negative, continue looping
389          add    %o1, 128, %o1           ! advance dest ptr
390         b       ccmerge                 ! finish it off, above
391          andcc  %g1, 0x70, %o2          ! can use table? (clears carry btw)
392
393 ccslow: cmp     %g1, 0
394         mov     0, %g5
395         bleu    4f
396          andcc  %o0, 1, %o5             
397         be,a    1f
398          srl    %g1, 1, %g4             
399         sub     %g1, 1, %g1     
400         EX(ldub [%o0], %g5, add %g1, 1)
401         add     %o0, 1, %o0     
402         EX2(stb %g5, [%o1])
403         srl     %g1, 1, %g4
404         add     %o1, 1, %o1
405 1:      cmp     %g4, 0          
406         be,a    3f
407          andcc  %g1, 1, %g0
408         andcc   %o0, 2, %g0     
409         be,a    1f
410          srl    %g4, 1, %g4
411         EX(lduh [%o0], %o4, add %g1, 0)
412         sub     %g1, 2, %g1     
413         srl     %o4, 8, %g2
414         sub     %g4, 1, %g4     
415         EX2(stb %g2, [%o1])
416         add     %o4, %g5, %g5
417         EX2(stb %o4, [%o1 + 1])
418         add     %o0, 2, %o0     
419         srl     %g4, 1, %g4
420         add     %o1, 2, %o1
421 1:      cmp     %g4, 0          
422         be,a    2f
423          andcc  %g1, 2, %g0
424         EX3(ld  [%o0], %o4)
425 5:      srl     %o4, 24, %g2
426         srl     %o4, 16, %g3
427         EX2(stb %g2, [%o1])
428         srl     %o4, 8, %g2
429         EX2(stb %g3, [%o1 + 1])
430         add     %o0, 4, %o0
431         EX2(stb %g2, [%o1 + 2])
432         addcc   %o4, %g5, %g5
433         EX2(stb %o4, [%o1 + 3])
434         addx    %g5, %g0, %g5   ! I am now to lazy to optimize this (question it
435         add     %o1, 4, %o1     ! is worthy). Maybe some day - with the sll/srl
436         subcc   %g4, 1, %g4     ! tricks
437         bne,a   5b
438          EX3(ld [%o0], %o4)
439         sll     %g5, 16, %g2
440         srl     %g5, 16, %g5
441         srl     %g2, 16, %g2
442         andcc   %g1, 2, %g0
443         add     %g2, %g5, %g5 
444 2:      be,a    3f              
445          andcc  %g1, 1, %g0
446         EX(lduh [%o0], %o4, and %g1, 3)
447         andcc   %g1, 1, %g0
448         srl     %o4, 8, %g2
449         add     %o0, 2, %o0     
450         EX2(stb %g2, [%o1])
451         add     %g5, %o4, %g5
452         EX2(stb %o4, [%o1 + 1])
453         add     %o1, 2, %o1
454 3:      be,a    1f              
455          sll    %g5, 16, %o4
456         EX(ldub [%o0], %g2, add %g0, 1)
457         sll     %g2, 8, %o4     
458         EX2(stb %g2, [%o1])
459         add     %g5, %o4, %g5
460         sll     %g5, 16, %o4
461 1:      addcc   %o4, %g5, %g5
462         srl     %g5, 16, %o4
463         addx    %g0, %o4, %g5
464         orcc    %o5, %g0, %g0
465         be      4f
466          srl    %g5, 8, %o4
467         and     %g5, 0xff, %g2
468         and     %o4, 0xff, %o4
469         sll     %g2, 8, %g2
470         or      %g2, %o4, %g5
471 4:      addcc   %g7, %g5, %g7
472         retl    
473          addx   %g0, %g7, %o0
474 __csum_partial_copy_end:
475
476 /* We do these strange calculations for the csum_*_from_user case only, ie.
477  * we only bother with faults on loads... */
478
479 /* o2 = ((g2%20)&3)*8
480  * o3 = g1 - (g2/20)*32 - o2 */
481 20:
482         cmp     %g2, 20
483         blu,a   1f
484          and    %g2, 3, %o2
485         sub     %g1, 32, %g1
486         b       20b
487          sub    %g2, 20, %g2
488 1:
489         sll     %o2, 3, %o2
490         b       31f
491          sub    %g1, %o2, %o3
492
493 /* o2 = (!(g2 & 15) ? 0 : (((g2 & 15) + 1) & ~1)*8)
494  * o3 = g1 - (g2/16)*32 - o2 */
495 21:
496         andcc   %g2, 15, %o3
497         srl     %g2, 4, %g2
498         be,a    1f
499          clr    %o2
500         add     %o3, 1, %o3
501         and     %o3, 14, %o3
502         sll     %o3, 3, %o2
503 1:
504         sll     %g2, 5, %g2
505         sub     %g1, %g2, %o3
506         b       31f
507          sub    %o3, %o2, %o3
508
509 /* o0 += (g2/10)*16 - 0x70
510  * 01 += (g2/10)*16 - 0x70
511  * o2 = (g2 % 10) ? 8 : 0
512  * o3 += 0x70 - (g2/10)*16 - o2 */
513 22:
514         cmp     %g2, 10
515         blu,a   1f
516          sub    %o0, 0x70, %o0
517         add     %o0, 16, %o0
518         add     %o1, 16, %o1
519         sub     %o3, 16, %o3
520         b       22b
521          sub    %g2, 10, %g2
522 1:
523         sub     %o1, 0x70, %o1
524         add     %o3, 0x70, %o3
525         clr     %o2
526         tst     %g2
527         bne,a   1f
528          mov    8, %o2
529 1:
530         b       31f
531          sub    %o3, %o2, %o3
532 96:
533         and     %g1, 3, %g1
534         sll     %g4, 2, %g4
535         add     %g1, %g4, %o3
536 30:
537 /* %o1 is dst
538  * %o3 is # bytes to zero out
539  * %o4 is faulting address
540  * %o5 is %pc where fault occurred */
541         clr     %o2
542 31:
543 /* %o0 is src
544  * %o1 is dst
545  * %o2 is # of bytes to copy from src to dst
546  * %o3 is # bytes to zero out
547  * %o4 is faulting address
548  * %o5 is %pc where fault occurred */
549         save    %sp, -104, %sp
550         mov     %i5, %o0
551         mov     %i7, %o1
552         mov     %i4, %o2
553         call    lookup_fault
554          mov    %g7, %i4
555         cmp     %o0, 2
556         bne     1f      
557          add    %g0, -EFAULT, %i5
558         tst     %i2
559         be      2f
560          mov    %i0, %o1
561         mov     %i1, %o0
562 5:
563         call    __memcpy
564          mov    %i2, %o2
565         tst     %o0
566         bne,a   2f
567          add    %i3, %i2, %i3
568         add     %i1, %i2, %i1
569 2:
570         mov     %i1, %o0
571 6:
572         call    __bzero
573          mov    %i3, %o1
574 1:
575         ld      [%sp + 168], %o2                ! struct_ptr of parent
576         st      %i5, [%o2]
577         ret
578          restore
579
580         .section __ex_table,#alloc
581         .align 4
582         .word 5b,2
583         .word 6b,2