Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/rzhang/linux
[linux-2.6-microblaze.git] / arch / sparc / lib / M7memcpy.S
1 /*
2  * M7memcpy: Optimized SPARC M7 memcpy
3  *
4  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
5  */
6
7         .file   "M7memcpy.S"
8
9 /*
10  * memcpy(s1, s2, len)
11  *
12  * Copy s2 to s1, always copy n bytes.
13  * Note: this C code does not work for overlapped copies.
14  *
15  * Fast assembler language version of the following C-program for memcpy
16  * which represents the `standard' for the C-library.
17  *
18  *      void *
19  *      memcpy(void *s, const void *s0, size_t n)
20  *      {
21  *              if (n != 0) {
22  *                  char *s1 = s;
23  *                  const char *s2 = s0;
24  *                  do {
25  *                      *s1++ = *s2++;
26  *                  } while (--n != 0);
27  *              }
28  *              return (s);
29  *      }
30  *
31  *
32  * SPARC T7/M7 Flow :
33  *
34  * if (count < SMALL_MAX) {
35  *   if count < SHORTCOPY              (SHORTCOPY=3)
36  *      copy bytes; exit with dst addr
37  *   if src & dst aligned on word boundary but not long word boundary,
38  *     copy with ldw/stw; branch to finish_up
39  *   if src & dst aligned on long word boundary
40  *     copy with ldx/stx; branch to finish_up
41  *   if src & dst not aligned and length <= SHORTCHECK   (SHORTCHECK=14)
42  *     copy bytes; exit with dst addr
43  *   move enough bytes to get src to word boundary
44  *   if dst now on word boundary
45  * move_words:
46  *     copy words; branch to finish_up
47  *   if dst now on half word boundary
48  *     load words, shift half words, store words; branch to finish_up
49  *   if dst on byte 1
50  *     load words, shift 3 bytes, store words; branch to finish_up
51  *   if dst on byte 3
52  *     load words, shift 1 byte, store words; branch to finish_up
53  * finish_up:
54  *     copy bytes; exit with dst addr
55  * } else {                                         More than SMALL_MAX bytes
56  *   move bytes until dst is on long word boundary
57  *   if( src is on long word boundary ) {
58  *     if (count < MED_MAX) {
59  * finish_long:                                    src/dst aligned on 8 bytes
60  *       copy with ldx/stx in 8-way unrolled loop;
61  *       copy final 0-63 bytes; exit with dst addr
62  *     } else {                              src/dst aligned; count > MED_MAX
63  *       align dst on 64 byte boundary; for main data movement:
64  *       prefetch src data to L2 cache; let HW prefetch move data to L1 cache
65  *       Use BIS (block initializing store) to avoid copying store cache
66  *       lines from memory. But pre-store first element of each cache line
67  *       ST_CHUNK lines in advance of the rest of that cache line. That
68  *       gives time for replacement cache lines to be written back without
69  *       excess STQ and Miss Buffer filling. Repeat until near the end,
70  *       then finish up storing before going to finish_long.
71  *     }
72  *   } else {                                   src/dst not aligned on 8 bytes
73  *     if src is word aligned and count < MED_WMAX
74  *       move words in 8-way unrolled loop
75  *       move final 0-31 bytes; exit with dst addr
76  *     if count < MED_UMAX
77  *       use alignaddr/faligndata combined with ldd/std in 8-way
78  *       unrolled loop to move data.
79  *       go to unalign_done
80  *     else
81  *       setup alignaddr for faligndata instructions
82  *       align dst on 64 byte boundary; prefetch src data to L1 cache
83  *       loadx8, falign, block-store, prefetch loop
84  *       (only use block-init-store when src/dst on 8 byte boundaries.)
85  * unalign_done:
86  *       move remaining bytes for unaligned cases. exit with dst addr.
87  * }
88  *
89  */
90
91 #include <asm/visasm.h>
92 #include <asm/asi.h>
93
94 #if !defined(EX_LD) && !defined(EX_ST)
95 #define NON_USER_COPY
96 #endif
97
98 #ifndef EX_LD
99 #define EX_LD(x,y)      x
100 #endif
101 #ifndef EX_LD_FP
102 #define EX_LD_FP(x,y)   x
103 #endif
104
105 #ifndef EX_ST
106 #define EX_ST(x,y)      x
107 #endif
108 #ifndef EX_ST_FP
109 #define EX_ST_FP(x,y)   x
110 #endif
111
112 #ifndef EX_RETVAL
113 #define EX_RETVAL(x)    x
114 #endif
115
116 #ifndef LOAD
117 #define LOAD(type,addr,dest)    type [addr], dest
118 #endif
119
120 #ifndef STORE
121 #define STORE(type,src,addr)    type src, [addr]
122 #endif
123
124 /*
125  * ASI_BLK_INIT_QUAD_LDD_P/ASI_BLK_INIT_QUAD_LDD_S marks the cache
126  * line as "least recently used" which means if many threads are
127  * active, it has a high probability of being pushed out of the cache
128  * between the first initializing store and the final stores.
129  * Thus, we use ASI_ST_BLKINIT_MRU_P/ASI_ST_BLKINIT_MRU_S which
130  * marks the cache line as "most recently used" for all
131  * but the last cache line
132  */
133 #ifndef STORE_ASI
134 #ifndef SIMULATE_NIAGARA_ON_NON_NIAGARA
135 #define STORE_ASI       ASI_BLK_INIT_QUAD_LDD_P
136 #else
137 #define STORE_ASI       0x80            /* ASI_P */
138 #endif
139 #endif
140
141 #ifndef STORE_MRU_ASI
142 #ifndef SIMULATE_NIAGARA_ON_NON_NIAGARA
143 #define STORE_MRU_ASI   ASI_ST_BLKINIT_MRU_P
144 #else
145 #define STORE_MRU_ASI   0x80            /* ASI_P */
146 #endif
147 #endif
148
149 #ifndef STORE_INIT
150 #define STORE_INIT(src,addr)    stxa src, [addr] STORE_ASI
151 #endif
152
153 #ifndef STORE_INIT_MRU
154 #define STORE_INIT_MRU(src,addr)        stxa src, [addr] STORE_MRU_ASI
155 #endif
156
157 #ifndef FUNC_NAME
158 #define FUNC_NAME       M7memcpy
159 #endif
160
161 #ifndef PREAMBLE
162 #define PREAMBLE
163 #endif
164
165 #define BLOCK_SIZE      64
166 #define SHORTCOPY       3
167 #define SHORTCHECK      14
168 #define SHORT_LONG      64      /* max copy for short longword-aligned case */
169                                 /* must be at least 64 */
170 #define SMALL_MAX       128
171 #define MED_UMAX        1024    /* max copy for medium un-aligned case */
172 #define MED_WMAX        1024    /* max copy for medium word-aligned case */
173 #define MED_MAX         1024    /* max copy for medium longword-aligned case */
174 #define ST_CHUNK        24      /* ST_CHUNK - block of values for BIS Store */
175 #define ALIGN_PRE       24      /* distance for aligned prefetch loop */
176
177         .register       %g2,#scratch
178
179         .section        ".text"
180         .global         FUNC_NAME
181         .type           FUNC_NAME, #function
182         .align          16
183 FUNC_NAME:
184         srlx            %o2, 31, %g2
185         cmp             %g2, 0
186         tne             %xcc, 5
187         PREAMBLE
188         mov             %o0, %g1        ! save %o0
189         brz,pn          %o2, .Lsmallx
190          cmp            %o2, 3
191         ble,pn          %icc, .Ltiny_cp
192          cmp            %o2, 19
193         ble,pn          %icc, .Lsmall_cp
194          or             %o0, %o1, %g2
195         cmp             %o2, SMALL_MAX
196         bl,pn           %icc, .Lmedium_cp
197          nop
198
199 .Lmedium:
200         neg     %o0, %o5
201         andcc   %o5, 7, %o5             ! bytes till DST 8 byte aligned
202         brz,pt  %o5, .Ldst_aligned_on_8
203
204         ! %o5 has the bytes to be written in partial store.
205          sub    %o2, %o5, %o2
206         sub     %o1, %o0, %o1           ! %o1 gets the difference
207 7:                                      ! dst aligning loop
208         add     %o1, %o0, %o4
209         EX_LD(LOAD(ldub, %o4, %o4), memcpy_retl_o2_plus_o5)     ! load one byte
210         subcc   %o5, 1, %o5
211         EX_ST(STORE(stb, %o4, %o0), memcpy_retl_o2_plus_o5_plus_1)
212         bgu,pt  %xcc, 7b
213          add    %o0, 1, %o0             ! advance dst
214         add     %o1, %o0, %o1           ! restore %o1
215 .Ldst_aligned_on_8:
216         andcc   %o1, 7, %o5
217         brnz,pt %o5, .Lsrc_dst_unaligned_on_8
218          nop
219
220 .Lsrc_dst_aligned_on_8:
221         ! check if we are copying MED_MAX or more bytes
222         set MED_MAX, %o3
223         cmp %o2, %o3                    ! limit to store buffer size
224         bgu,pn  %xcc, .Llarge_align8_copy
225          nop
226
227 /*
228  * Special case for handling when src and dest are both long word aligned
229  * and total data to move is less than MED_MAX bytes
230  */
231 .Lmedlong:
232         subcc   %o2, 63, %o2            ! adjust length to allow cc test
233         ble,pn  %xcc, .Lmedl63          ! skip big loop if less than 64 bytes
234          nop
235 .Lmedl64:
236         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_63)      ! load
237         subcc   %o2, 64, %o2            ! decrement length count
238         EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_63_64)  ! and store
239         EX_LD(LOAD(ldx, %o1+8, %o3), memcpy_retl_o2_plus_63_56) ! a block of 64
240         EX_ST(STORE(stx, %o3, %o0+8), memcpy_retl_o2_plus_63_56)
241         EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_63_48)
242         EX_ST(STORE(stx, %o4, %o0+16), memcpy_retl_o2_plus_63_48)
243         EX_LD(LOAD(ldx, %o1+24, %o3), memcpy_retl_o2_plus_63_40)
244         EX_ST(STORE(stx, %o3, %o0+24), memcpy_retl_o2_plus_63_40)
245         EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_63_32)! load and store
246         EX_ST(STORE(stx, %o4, %o0+32), memcpy_retl_o2_plus_63_32)
247         EX_LD(LOAD(ldx, %o1+40, %o3), memcpy_retl_o2_plus_63_24)! a block of 64
248         add     %o1, 64, %o1            ! increase src ptr by 64
249         EX_ST(STORE(stx, %o3, %o0+40), memcpy_retl_o2_plus_63_24)
250         EX_LD(LOAD(ldx, %o1-16, %o4), memcpy_retl_o2_plus_63_16)
251         add     %o0, 64, %o0            ! increase dst ptr by 64
252         EX_ST(STORE(stx, %o4, %o0-16), memcpy_retl_o2_plus_63_16)
253         EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_63_8)
254         bgu,pt  %xcc, .Lmedl64          ! repeat if at least 64 bytes left
255          EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_63_8)
256 .Lmedl63:
257         addcc   %o2, 32, %o2            ! adjust remaining count
258         ble,pt  %xcc, .Lmedl31          ! to skip if 31 or fewer bytes left
259          nop
260         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_31)      ! load
261         sub     %o2, 32, %o2            ! decrement length count
262         EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_31_32)  ! and store
263         EX_LD(LOAD(ldx, %o1+8, %o3), memcpy_retl_o2_plus_31_24) ! a block of 32
264         add     %o1, 32, %o1            ! increase src ptr by 32
265         EX_ST(STORE(stx, %o3, %o0+8), memcpy_retl_o2_plus_31_24)
266         EX_LD(LOAD(ldx, %o1-16, %o4), memcpy_retl_o2_plus_31_16)
267         add     %o0, 32, %o0            ! increase dst ptr by 32
268         EX_ST(STORE(stx, %o4, %o0-16), memcpy_retl_o2_plus_31_16)
269         EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_31_8)
270         EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_31_8)
271 .Lmedl31:
272         addcc   %o2, 16, %o2            ! adjust remaining count
273         ble,pt  %xcc, .Lmedl15          ! skip if 15 or fewer bytes left
274          nop                            !
275         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_15)
276         add     %o1, 16, %o1            ! increase src ptr by 16
277         EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_15)
278         sub     %o2, 16, %o2            ! decrease count by 16
279         EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_15_8)
280         add     %o0, 16, %o0            ! increase dst ptr by 16
281         EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_15_8)
282 .Lmedl15:
283         addcc   %o2, 15, %o2            ! restore count
284         bz,pt   %xcc, .Lsmallx  ! exit if finished
285          cmp    %o2, 8
286         blt,pt  %xcc, .Lmedw7           ! skip if 7 or fewer bytes left
287          tst    %o2
288         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)      ! load 8 bytes
289         add     %o1, 8, %o1             ! increase src ptr by 8
290         add     %o0, 8, %o0             ! increase dst ptr by 8
291         subcc   %o2, 8, %o2             ! decrease count by 8
292         bnz,pn  %xcc, .Lmedw7
293          EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)   ! and store 8
294         retl
295          mov    EX_RETVAL(%g1), %o0     ! restore %o0
296
297         .align 16
298 .Lsrc_dst_unaligned_on_8:
299         ! DST is 8-byte aligned, src is not
300 2:
301         andcc   %o1, 0x3, %o5           ! test word alignment
302         bnz,pt  %xcc, .Lunalignsetup    ! branch to skip if not word aligned
303          nop
304
305 /*
306  * Handle all cases where src and dest are aligned on word
307  * boundaries. Use unrolled loops for better performance.
308  * This option wins over standard large data move when
309  * source and destination is in cache for.Lmedium
310  * to short data moves.
311  */
312         set MED_WMAX, %o3
313         cmp %o2, %o3                    ! limit to store buffer size
314         bge,pt  %xcc, .Lunalignrejoin   ! otherwise rejoin main loop
315          nop
316
317         subcc   %o2, 31, %o2            ! adjust length to allow cc test
318                                         ! for end of loop
319         ble,pt  %xcc, .Lmedw31          ! skip big loop if less than 16
320 .Lmedw32:
321         EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2_plus_31)! move a block of 32
322         sllx    %o4, 32, %o5
323         EX_LD(LOAD(ld, %o1+4, %o4), memcpy_retl_o2_plus_31)
324         or      %o4, %o5, %o5
325         EX_ST(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_31)
326         subcc   %o2, 32, %o2            ! decrement length count
327         EX_LD(LOAD(ld, %o1+8, %o4), memcpy_retl_o2_plus_31_24)
328         sllx    %o4, 32, %o5
329         EX_LD(LOAD(ld, %o1+12, %o4), memcpy_retl_o2_plus_31_24)
330         or      %o4, %o5, %o5
331         EX_ST(STORE(stx, %o5, %o0+8), memcpy_retl_o2_plus_31_24)
332         add     %o1, 32, %o1            ! increase src ptr by 32
333         EX_LD(LOAD(ld, %o1-16, %o4), memcpy_retl_o2_plus_31_16)
334         sllx    %o4, 32, %o5
335         EX_LD(LOAD(ld, %o1-12, %o4), memcpy_retl_o2_plus_31_16)
336         or      %o4, %o5, %o5
337         EX_ST(STORE(stx, %o5, %o0+16), memcpy_retl_o2_plus_31_16)
338         add     %o0, 32, %o0            ! increase dst ptr by 32
339         EX_LD(LOAD(ld, %o1-8, %o4), memcpy_retl_o2_plus_31_8)
340         sllx    %o4, 32, %o5
341         EX_LD(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_31_8)
342         or      %o4, %o5, %o5
343         bgu,pt  %xcc, .Lmedw32          ! repeat if at least 32 bytes left
344          EX_ST(STORE(stx, %o5, %o0-8), memcpy_retl_o2_plus_31_8)
345 .Lmedw31:
346         addcc   %o2, 31, %o2            ! restore count
347
348         bz,pt   %xcc, .Lsmallx  ! exit if finished
349          nop
350         cmp     %o2, 16
351         blt,pt  %xcc, .Lmedw15
352          nop
353         EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)! move a block of 16 bytes
354         sllx    %o4, 32, %o5
355         subcc   %o2, 16, %o2            ! decrement length count
356         EX_LD(LOAD(ld, %o1+4, %o4), memcpy_retl_o2_plus_16)
357         or      %o4, %o5, %o5
358         EX_ST(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_16)
359         add     %o1, 16, %o1            ! increase src ptr by 16
360         EX_LD(LOAD(ld, %o1-8, %o4), memcpy_retl_o2_plus_8)
361         add     %o0, 16, %o0            ! increase dst ptr by 16
362         sllx    %o4, 32, %o5
363         EX_LD(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_8)
364         or      %o4, %o5, %o5
365         EX_ST(STORE(stx, %o5, %o0-8), memcpy_retl_o2_plus_8)
366 .Lmedw15:
367         bz,pt   %xcc, .Lsmallx  ! exit if finished
368          cmp    %o2, 8
369         blt,pn  %xcc, .Lmedw7           ! skip if 7 or fewer bytes left
370          tst    %o2
371         EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)       ! load 4 bytes
372         subcc   %o2, 8, %o2             ! decrease count by 8
373         EX_ST(STORE(stw, %o4, %o0), memcpy_retl_o2_plus_8)! and store 4 bytes
374         add     %o1, 8, %o1             ! increase src ptr by 8
375         EX_LD(LOAD(ld, %o1-4, %o3), memcpy_retl_o2_plus_4)      ! load 4 bytes
376         add     %o0, 8, %o0             ! increase dst ptr by 8
377         EX_ST(STORE(stw, %o3, %o0-4), memcpy_retl_o2_plus_4)! and store 4 bytes
378         bz,pt   %xcc, .Lsmallx  ! exit if finished
379 .Lmedw7:                                ! count is ge 1, less than 8
380         cmp     %o2, 4                  ! check for 4 bytes left
381         blt,pn  %xcc, .Lsmallleft3      ! skip if 3 or fewer bytes left
382          nop                            !
383         EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)       ! load 4 bytes
384         add     %o1, 4, %o1             ! increase src ptr by 4
385         add     %o0, 4, %o0             ! increase dst ptr by 4
386         subcc   %o2, 4, %o2             ! decrease count by 4
387         bnz     .Lsmallleft3
388          EX_ST(STORE(stw, %o4, %o0-4), memcpy_retl_o2_plus_4)! and store 4 bytes
389         retl
390          mov    EX_RETVAL(%g1), %o0
391
392         .align 16
393 .Llarge_align8_copy:                    ! Src and dst share 8 byte alignment
394         ! align dst to 64 byte boundary
395         andcc   %o0, 0x3f, %o3          ! %o3 == 0 means dst is 64 byte aligned
396         brz,pn  %o3, .Laligned_to_64
397          andcc  %o0, 8, %o3             ! odd long words to move?
398         brz,pt  %o3, .Laligned_to_16
399          nop
400         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
401         sub     %o2, 8, %o2
402         add     %o1, 8, %o1             ! increment src ptr
403         add     %o0, 8, %o0             ! increment dst ptr
404         EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
405 .Laligned_to_16:
406         andcc   %o0, 16, %o3            ! pair of long words to move?
407         brz,pt  %o3, .Laligned_to_32
408          nop
409         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
410         sub     %o2, 16, %o2
411         EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_16)
412         add     %o1, 16, %o1            ! increment src ptr
413         EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_8)
414         add     %o0, 16, %o0            ! increment dst ptr
415         EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
416 .Laligned_to_32:
417         andcc   %o0, 32, %o3            ! four long words to move?
418         brz,pt  %o3, .Laligned_to_64
419          nop
420         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
421         sub     %o2, 32, %o2
422         EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_32)
423         EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_24)
424         EX_ST(STORE(stx, %o4, %o0+8), memcpy_retl_o2_plus_24)
425         EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_16)
426         EX_ST(STORE(stx, %o4, %o0+16), memcpy_retl_o2_plus_16)
427         add     %o1, 32, %o1            ! increment src ptr
428         EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_8)
429         add     %o0, 32, %o0            ! increment dst ptr
430         EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
431 .Laligned_to_64:
432 !
433 !       Using block init store (BIS) instructions to avoid fetching cache
434 !       lines from memory. Use ST_CHUNK stores to first element of each cache
435 !       line (similar to prefetching) to avoid overfilling STQ or miss buffers.
436 !       Gives existing cache lines time to be moved out of L1/L2/L3 cache.
437 !       Initial stores using MRU version of BIS to keep cache line in
438 !       cache until we are ready to store final element of cache line.
439 !       Then store last element using the LRU version of BIS.
440 !
441         andn    %o2, 0x3f, %o5          ! %o5 is multiple of block size
442         and     %o2, 0x3f, %o2          ! residue bytes in %o2
443 !
444 !       We use STORE_MRU_ASI for the first seven stores to each cache line
445 !       followed by STORE_ASI (mark as LRU) for the last store. That
446 !       mixed approach reduces the probability that the cache line is removed
447 !       before we finish setting it, while minimizing the effects on
448 !       other cached values during a large memcpy
449 !
450 !       ST_CHUNK batches up initial BIS operations for several cache lines
451 !       to allow multiple requests to not be blocked by overflowing the
452 !       the store miss buffer. Then the matching stores for all those
453 !       BIS operations are executed.
454 !
455
456         sub     %o0, 8, %o0             ! adjust %o0 for ASI alignment
457 .Lalign_loop:
458         cmp     %o5, ST_CHUNK*64
459         blu,pt  %xcc, .Lalign_loop_fin
460          mov    ST_CHUNK,%o3
461 .Lalign_loop_start:
462         prefetch [%o1 + (ALIGN_PRE * BLOCK_SIZE)], 21
463         subcc   %o3, 1, %o3
464         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_o5)
465         add     %o1, 64, %o1
466         add     %o0, 8, %o0
467         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
468         bgu     %xcc,.Lalign_loop_start
469          add    %o0, 56, %o0
470
471         mov     ST_CHUNK,%o3
472         sllx    %o3, 6, %o4             ! ST_CHUNK*64
473         sub     %o1, %o4, %o1           ! reset %o1
474         sub     %o0, %o4, %o0           ! reset %o0
475
476 .Lalign_loop_rest:
477         EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_o5)
478         add     %o0, 16, %o0
479         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
480         EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_o5)
481         add     %o0, 8, %o0
482         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
483         subcc   %o3, 1, %o3
484         EX_LD(LOAD(ldx, %o1+24, %o4), memcpy_retl_o2_plus_o5)
485         add     %o0, 8, %o0
486         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
487         EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_o5)
488         add     %o0, 8, %o0
489         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
490         EX_LD(LOAD(ldx, %o1+40, %o4), memcpy_retl_o2_plus_o5)
491         add     %o0, 8, %o0
492         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
493         EX_LD(LOAD(ldx, %o1+48, %o4), memcpy_retl_o2_plus_o5)
494         add     %o1, 64, %o1
495         add     %o0, 8, %o0
496         EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
497         add     %o0, 8, %o0
498         EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_o5)
499         sub     %o5, 64, %o5
500         bgu     %xcc,.Lalign_loop_rest
501         ! mark cache line as LRU
502          EX_ST(STORE_INIT(%o4, %o0), memcpy_retl_o2_plus_o5_plus_64)
503
504         cmp     %o5, ST_CHUNK*64
505         bgu,pt  %xcc, .Lalign_loop_start
506          mov    ST_CHUNK,%o3
507
508         cmp     %o5, 0
509         beq     .Lalign_done
510          nop
511 .Lalign_loop_fin:
512         EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_o5)
513         EX_ST(STORE(stx, %o4, %o0+8), memcpy_retl_o2_plus_o5)
514         EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_o5)
515         EX_ST(STORE(stx, %o4, %o0+8+8), memcpy_retl_o2_plus_o5)
516         EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_o5)
517         EX_ST(STORE(stx, %o4, %o0+8+16), memcpy_retl_o2_plus_o5)
518         subcc   %o5, 64, %o5
519         EX_LD(LOAD(ldx, %o1+24, %o4), memcpy_retl_o2_plus_o5_64)
520         EX_ST(STORE(stx, %o4, %o0+8+24), memcpy_retl_o2_plus_o5_64)
521         EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_o5_64)
522         EX_ST(STORE(stx, %o4, %o0+8+32), memcpy_retl_o2_plus_o5_64)
523         EX_LD(LOAD(ldx, %o1+40, %o4), memcpy_retl_o2_plus_o5_64)
524         EX_ST(STORE(stx, %o4, %o0+8+40), memcpy_retl_o2_plus_o5_64)
525         EX_LD(LOAD(ldx, %o1+48, %o4), memcpy_retl_o2_plus_o5_64)
526         add     %o1, 64, %o1
527         EX_ST(STORE(stx, %o4, %o0+8+48), memcpy_retl_o2_plus_o5_64)
528         add     %o0, 64, %o0
529         EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_o5_64)
530         bgu     %xcc,.Lalign_loop_fin
531          EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_o5_64)
532
533 .Lalign_done:
534         add     %o0, 8, %o0             ! restore %o0 from ASI alignment
535         membar  #StoreStore
536         sub     %o2, 63, %o2            ! adjust length to allow cc test
537         ba      .Lmedl63                ! in .Lmedl63
538          nop
539
540         .align 16
541         ! Dst is on 8 byte boundary; src is not; remaining count > SMALL_MAX
542 .Lunalignsetup:
543 .Lunalignrejoin:
544         mov     %g1, %o3        ! save %g1 as VISEntryHalf clobbers it
545 #ifdef NON_USER_COPY
546         VISEntryHalfFast(.Lmedium_vis_entry_fail_cp)
547 #else
548         VISEntryHalf
549 #endif
550         mov     %o3, %g1        ! restore %g1
551
552         set MED_UMAX, %o3
553         cmp %o2, %o3            ! check for.Lmedium unaligned limit
554         bge,pt  %xcc,.Lunalign_large
555          prefetch [%o1 + (4 * BLOCK_SIZE)], 20
556         andn    %o2, 0x3f, %o5          ! %o5 is multiple of block size
557         and     %o2, 0x3f, %o2          ! residue bytes in %o2
558         cmp     %o2, 8                  ! Insure we do not load beyond
559         bgt     .Lunalign_adjust        ! end of source buffer
560          andn   %o1, 0x7, %o4           ! %o4 has long word aligned src address
561         add     %o2, 64, %o2            ! adjust to leave loop
562         sub     %o5, 64, %o5            ! early if necessary
563 .Lunalign_adjust:
564         alignaddr %o1, %g0, %g0         ! generate %gsr
565         add     %o1, %o5, %o1           ! advance %o1 to after blocks
566         EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5)
567 .Lunalign_loop:
568         EX_LD_FP(LOAD(ldd, %o4+8, %f2), memcpy_retl_o2_plus_o5)
569         faligndata %f0, %f2, %f16
570         EX_LD_FP(LOAD(ldd, %o4+16, %f4), memcpy_retl_o2_plus_o5)
571         subcc   %o5, BLOCK_SIZE, %o5
572         EX_ST_FP(STORE(std, %f16, %o0), memcpy_retl_o2_plus_o5_plus_64)
573         faligndata %f2, %f4, %f18
574         EX_LD_FP(LOAD(ldd, %o4+24, %f6), memcpy_retl_o2_plus_o5_plus_56)
575         EX_ST_FP(STORE(std, %f18, %o0+8), memcpy_retl_o2_plus_o5_plus_56)
576         faligndata %f4, %f6, %f20
577         EX_LD_FP(LOAD(ldd, %o4+32, %f8), memcpy_retl_o2_plus_o5_plus_48)
578         EX_ST_FP(STORE(std, %f20, %o0+16), memcpy_retl_o2_plus_o5_plus_48)
579         faligndata %f6, %f8, %f22
580         EX_LD_FP(LOAD(ldd, %o4+40, %f10), memcpy_retl_o2_plus_o5_plus_40)
581         EX_ST_FP(STORE(std, %f22, %o0+24), memcpy_retl_o2_plus_o5_plus_40)
582         faligndata %f8, %f10, %f24
583         EX_LD_FP(LOAD(ldd, %o4+48, %f12), memcpy_retl_o2_plus_o5_plus_32)
584         EX_ST_FP(STORE(std, %f24, %o0+32), memcpy_retl_o2_plus_o5_plus_32)
585         faligndata %f10, %f12, %f26
586         EX_LD_FP(LOAD(ldd, %o4+56, %f14), memcpy_retl_o2_plus_o5_plus_24)
587         add     %o4, BLOCK_SIZE, %o4
588         EX_ST_FP(STORE(std, %f26, %o0+40), memcpy_retl_o2_plus_o5_plus_24)
589         faligndata %f12, %f14, %f28
590         EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5_plus_16)
591         EX_ST_FP(STORE(std, %f28, %o0+48), memcpy_retl_o2_plus_o5_plus_16)
592         faligndata %f14, %f0, %f30
593         EX_ST_FP(STORE(std, %f30, %o0+56), memcpy_retl_o2_plus_o5_plus_8)
594         add     %o0, BLOCK_SIZE, %o0
595         bgu,pt  %xcc, .Lunalign_loop
596          prefetch [%o4 + (5 * BLOCK_SIZE)], 20
597         ba      .Lunalign_done
598          nop
599
600 .Lunalign_large:
601         andcc   %o0, 0x3f, %o3          ! is dst 64-byte block aligned?
602         bz      %xcc, .Lunalignsrc
603          sub    %o3, 64, %o3            ! %o3 will be multiple of 8
604         neg     %o3                     ! bytes until dest is 64 byte aligned
605         sub     %o2, %o3, %o2           ! update cnt with bytes to be moved
606         ! Move bytes according to source alignment
607         andcc   %o1, 0x1, %o5
608         bnz     %xcc, .Lunalignbyte     ! check for byte alignment
609          nop
610         andcc   %o1, 2, %o5             ! check for half word alignment
611         bnz     %xcc, .Lunalignhalf
612          nop
613         ! Src is word aligned
614 .Lunalignword:
615         EX_LD_FP(LOAD(ld, %o1, %o4), memcpy_retl_o2_plus_o3)    ! load 4 bytes
616         add     %o1, 8, %o1             ! increase src ptr by 8
617         EX_ST_FP(STORE(stw, %o4, %o0), memcpy_retl_o2_plus_o3)  ! and store 4
618         subcc   %o3, 8, %o3             ! decrease count by 8
619         EX_LD_FP(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_o3_plus_4)! load 4
620         add     %o0, 8, %o0             ! increase dst ptr by 8
621         bnz     %xcc, .Lunalignword
622          EX_ST_FP(STORE(stw, %o4, %o0-4), memcpy_retl_o2_plus_o3_plus_4)
623         ba      .Lunalignsrc
624          nop
625
626         ! Src is half-word aligned
627 .Lunalignhalf:
628         EX_LD_FP(LOAD(lduh, %o1, %o4), memcpy_retl_o2_plus_o3)  ! load 2 bytes
629         sllx    %o4, 32, %o5            ! shift left
630         EX_LD_FP(LOAD(lduw, %o1+2, %o4), memcpy_retl_o2_plus_o3)
631         or      %o4, %o5, %o5
632         sllx    %o5, 16, %o5
633         EX_LD_FP(LOAD(lduh, %o1+6, %o4), memcpy_retl_o2_plus_o3)
634         or      %o4, %o5, %o5
635         EX_ST_FP(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_o3)
636         add     %o1, 8, %o1
637         subcc   %o3, 8, %o3
638         bnz     %xcc, .Lunalignhalf
639          add    %o0, 8, %o0
640         ba      .Lunalignsrc
641          nop
642
643         ! Src is Byte aligned
644 .Lunalignbyte:
645         sub     %o0, %o1, %o0           ! share pointer advance
646 .Lunalignbyte_loop:
647         EX_LD_FP(LOAD(ldub, %o1, %o4), memcpy_retl_o2_plus_o3)
648         sllx    %o4, 56, %o5
649         EX_LD_FP(LOAD(lduh, %o1+1, %o4), memcpy_retl_o2_plus_o3)
650         sllx    %o4, 40, %o4
651         or      %o4, %o5, %o5
652         EX_LD_FP(LOAD(lduh, %o1+3, %o4), memcpy_retl_o2_plus_o3)
653         sllx    %o4, 24, %o4
654         or      %o4, %o5, %o5
655         EX_LD_FP(LOAD(lduh, %o1+5, %o4), memcpy_retl_o2_plus_o3)
656         sllx    %o4,  8, %o4
657         or      %o4, %o5, %o5
658         EX_LD_FP(LOAD(ldub, %o1+7, %o4), memcpy_retl_o2_plus_o3)
659         or      %o4, %o5, %o5
660         add     %o0, %o1, %o0
661         EX_ST_FP(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_o3)
662         sub     %o0, %o1, %o0
663         subcc   %o3, 8, %o3
664         bnz     %xcc, .Lunalignbyte_loop
665          add    %o1, 8, %o1
666         add     %o0,%o1, %o0            ! restore pointer
667
668         ! Destination is now block (64 byte aligned)
669 .Lunalignsrc:
670         andn    %o2, 0x3f, %o5          ! %o5 is multiple of block size
671         and     %o2, 0x3f, %o2          ! residue bytes in %o2
672         add     %o2, 64, %o2            ! Insure we do not load beyond
673         sub     %o5, 64, %o5            ! end of source buffer
674
675         andn    %o1, 0x7, %o4           ! %o4 has long word aligned src address
676         alignaddr %o1, %g0, %g0         ! generate %gsr
677         add     %o1, %o5, %o1           ! advance %o1 to after blocks
678
679         EX_LD_FP(LOAD(ldd, %o4, %f14), memcpy_retl_o2_plus_o5)
680         add     %o4, 8, %o4
681 .Lunalign_sloop:
682         EX_LD_FP(LOAD(ldd, %o4, %f16), memcpy_retl_o2_plus_o5)
683         faligndata %f14, %f16, %f0
684         EX_LD_FP(LOAD(ldd, %o4+8, %f18), memcpy_retl_o2_plus_o5)
685         faligndata %f16, %f18, %f2
686         EX_LD_FP(LOAD(ldd, %o4+16, %f20), memcpy_retl_o2_plus_o5)
687         faligndata %f18, %f20, %f4
688         EX_ST_FP(STORE(std, %f0, %o0), memcpy_retl_o2_plus_o5)
689         subcc   %o5, 64, %o5
690         EX_LD_FP(LOAD(ldd, %o4+24, %f22), memcpy_retl_o2_plus_o5_plus_56)
691         faligndata %f20, %f22, %f6
692         EX_ST_FP(STORE(std, %f2, %o0+8), memcpy_retl_o2_plus_o5_plus_56)
693         EX_LD_FP(LOAD(ldd, %o4+32, %f24), memcpy_retl_o2_plus_o5_plus_48)
694         faligndata %f22, %f24, %f8
695         EX_ST_FP(STORE(std, %f4, %o0+16), memcpy_retl_o2_plus_o5_plus_48)
696         EX_LD_FP(LOAD(ldd, %o4+40, %f26), memcpy_retl_o2_plus_o5_plus_40)
697         faligndata %f24, %f26, %f10
698         EX_ST_FP(STORE(std, %f6, %o0+24), memcpy_retl_o2_plus_o5_plus_40)
699         EX_LD_FP(LOAD(ldd, %o4+48, %f28), memcpy_retl_o2_plus_o5_plus_40)
700         faligndata %f26, %f28, %f12
701         EX_ST_FP(STORE(std, %f8, %o0+32), memcpy_retl_o2_plus_o5_plus_40)
702         add     %o4, 64, %o4
703         EX_LD_FP(LOAD(ldd, %o4-8, %f30), memcpy_retl_o2_plus_o5_plus_40)
704         faligndata %f28, %f30, %f14
705         EX_ST_FP(STORE(std, %f10, %o0+40), memcpy_retl_o2_plus_o5_plus_40)
706         EX_ST_FP(STORE(std, %f12, %o0+48), memcpy_retl_o2_plus_o5_plus_40)
707         add     %o0, 64, %o0
708         EX_ST_FP(STORE(std, %f14, %o0-8), memcpy_retl_o2_plus_o5_plus_40)
709         fsrc2   %f30, %f14
710         bgu,pt  %xcc, .Lunalign_sloop
711          prefetch [%o4 + (8 * BLOCK_SIZE)], 20
712
713 .Lunalign_done:
714         ! Handle trailing bytes, 64 to 127
715         ! Dest long word aligned, Src not long word aligned
716         cmp     %o2, 15
717         bleu    %xcc, .Lunalign_short
718
719          andn   %o2, 0x7, %o5           ! %o5 is multiple of 8
720         and     %o2, 0x7, %o2           ! residue bytes in %o2
721         add     %o2, 8, %o2
722         sub     %o5, 8, %o5             ! insure we do not load past end of src
723         andn    %o1, 0x7, %o4           ! %o4 has long word aligned src address
724         add     %o1, %o5, %o1           ! advance %o1 to after multiple of 8
725         EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5)! fetch partialword
726 .Lunalign_by8:
727         EX_LD_FP(LOAD(ldd, %o4+8, %f2), memcpy_retl_o2_plus_o5)
728         add     %o4, 8, %o4
729         faligndata %f0, %f2, %f16
730         subcc   %o5, 8, %o5
731         EX_ST_FP(STORE(std, %f16, %o0), memcpy_retl_o2_plus_o5)
732         fsrc2   %f2, %f0
733         bgu,pt  %xcc, .Lunalign_by8
734          add    %o0, 8, %o0
735
736 .Lunalign_short:
737 #ifdef NON_USER_COPY
738         VISExitHalfFast
739 #else
740         VISExitHalf
741 #endif
742         ba      .Lsmallrest
743          nop
744
745 /*
746  * This is a special case of nested memcpy. This can happen when kernel
747  * calls unaligned memcpy back to back without saving FP registers. We need
748  * traps(context switch) to save/restore FP registers. If the kernel calls
749  * memcpy without this trap sequence we will hit FP corruption. Let's use
750  * the normal integer load/store method in this case.
751  */
752
753 #ifdef NON_USER_COPY
754 .Lmedium_vis_entry_fail_cp:
755         or      %o0, %o1, %g2
756 #endif
757 .Lmedium_cp:
758         LOAD(prefetch, %o1 + 0x40, #n_reads_strong)
759         andcc   %g2, 0x7, %g0
760         bne,pn  %xcc, .Lmedium_unaligned_cp
761          nop
762
763 .Lmedium_noprefetch_cp:
764         andncc  %o2, 0x20 - 1, %o5
765         be,pn   %xcc, 2f
766          sub    %o2, %o5, %o2
767 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
768         EX_LD(LOAD(ldx, %o1 + 0x08, %g2), memcpy_retl_o2_plus_o5)
769         EX_LD(LOAD(ldx, %o1 + 0x10, %g7), memcpy_retl_o2_plus_o5)
770         EX_LD(LOAD(ldx, %o1 + 0x18, %o4), memcpy_retl_o2_plus_o5)
771         add     %o1, 0x20, %o1
772         subcc   %o5, 0x20, %o5
773         EX_ST(STORE(stx, %o3, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_32)
774         EX_ST(STORE(stx, %g2, %o0 + 0x08), memcpy_retl_o2_plus_o5_plus_24)
775         EX_ST(STORE(stx, %g7, %o0 + 0x10), memcpy_retl_o2_plus_o5_plus_24)
776         EX_ST(STORE(stx, %o4, %o0 + 0x18), memcpy_retl_o2_plus_o5_plus_8)
777         bne,pt  %xcc, 1b
778          add    %o0, 0x20, %o0
779 2:      andcc   %o2, 0x18, %o5
780         be,pt   %xcc, 3f
781          sub    %o2, %o5, %o2
782 1:      EX_LD(LOAD(ldx, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
783         add     %o1, 0x08, %o1
784         add     %o0, 0x08, %o0
785         subcc   %o5, 0x08, %o5
786         bne,pt  %xcc, 1b
787          EX_ST(STORE(stx, %o3, %o0 - 0x08), memcpy_retl_o2_plus_o5_plus_8)
788 3:      brz,pt  %o2, .Lexit_cp
789          cmp    %o2, 0x04
790         bl,pn   %xcc, .Ltiny_cp
791          nop
792         EX_LD(LOAD(lduw, %o1 + 0x00, %o3), memcpy_retl_o2)
793         add     %o1, 0x04, %o1
794         add     %o0, 0x04, %o0
795         subcc   %o2, 0x04, %o2
796         bne,pn  %xcc, .Ltiny_cp
797          EX_ST(STORE(stw, %o3, %o0 - 0x04), memcpy_retl_o2_plus_4)
798         ba,a,pt %xcc, .Lexit_cp
799
800 .Lmedium_unaligned_cp:
801         /* First get dest 8 byte aligned.  */
802         sub     %g0, %o0, %o3
803         and     %o3, 0x7, %o3
804         brz,pt  %o3, 2f
805          sub    %o2, %o3, %o2
806
807 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
808         add     %o1, 1, %o1
809         subcc   %o3, 1, %o3
810         add     %o0, 1, %o0
811         bne,pt  %xcc, 1b
812          EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
813 2:
814         and     %o1, 0x7, %o3
815         brz,pn  %o3, .Lmedium_noprefetch_cp
816          sll    %o3, 3, %o3
817         mov     64, %g2
818         sub     %g2, %o3, %g2
819         andn    %o1, 0x7, %o1
820         EX_LD(LOAD(ldx, %o1 + 0x00, %o4), memcpy_retl_o2)
821         sllx    %o4, %o3, %o4
822         andn    %o2, 0x08 - 1, %o5
823         sub     %o2, %o5, %o2
824
825 1:      EX_LD(LOAD(ldx, %o1 + 0x08, %g3), memcpy_retl_o2_plus_o5)
826         add     %o1, 0x08, %o1
827         subcc   %o5, 0x08, %o5
828         srlx    %g3, %g2, %g7
829         or      %g7, %o4, %g7
830         EX_ST(STORE(stx, %g7, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_8)
831         add     %o0, 0x08, %o0
832         bne,pt  %xcc, 1b
833          sllx   %g3, %o3, %o4
834         srl     %o3, 3, %o3
835         add     %o1, %o3, %o1
836         brz,pn  %o2, .Lexit_cp
837          nop
838         ba,pt   %xcc, .Lsmall_unaligned_cp
839
840 .Ltiny_cp:
841         EX_LD(LOAD(ldub, %o1 + 0x00, %o3), memcpy_retl_o2)
842         subcc   %o2, 1, %o2
843         be,pn   %xcc, .Lexit_cp
844          EX_ST(STORE(stb, %o3, %o0 + 0x00), memcpy_retl_o2_plus_1)
845         EX_LD(LOAD(ldub, %o1 + 0x01, %o3), memcpy_retl_o2)
846         subcc   %o2, 1, %o2
847         be,pn   %xcc, .Lexit_cp
848          EX_ST(STORE(stb, %o3, %o0 + 0x01), memcpy_retl_o2_plus_1)
849         EX_LD(LOAD(ldub, %o1 + 0x02, %o3), memcpy_retl_o2)
850         ba,pt   %xcc, .Lexit_cp
851          EX_ST(STORE(stb, %o3, %o0 + 0x02), memcpy_retl_o2)
852
853 .Lsmall_cp:
854         andcc   %g2, 0x3, %g0
855         bne,pn  %xcc, .Lsmall_unaligned_cp
856          andn   %o2, 0x4 - 1, %o5
857         sub     %o2, %o5, %o2
858 1:
859         EX_LD(LOAD(lduw, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
860         add     %o1, 0x04, %o1
861         subcc   %o5, 0x04, %o5
862         add     %o0, 0x04, %o0
863         bne,pt  %xcc, 1b
864          EX_ST(STORE(stw, %o3, %o0 - 0x04), memcpy_retl_o2_plus_o5_plus_4)
865         brz,pt  %o2, .Lexit_cp
866          nop
867         ba,a,pt %xcc, .Ltiny_cp
868
869 .Lsmall_unaligned_cp:
870 1:      EX_LD(LOAD(ldub, %o1 + 0x00, %o3), memcpy_retl_o2)
871         add     %o1, 1, %o1
872         add     %o0, 1, %o0
873         subcc   %o2, 1, %o2
874         bne,pt  %xcc, 1b
875          EX_ST(STORE(stb, %o3, %o0 - 0x01), memcpy_retl_o2_plus_1)
876         ba,a,pt %xcc, .Lexit_cp
877
878 .Lsmallrest:
879         tst     %o2
880         bz,pt   %xcc, .Lsmallx
881          cmp    %o2, 4
882         blt,pn  %xcc, .Lsmallleft3
883          nop
884         sub     %o2, 3, %o2
885 .Lsmallnotalign4:
886         EX_LD(LOAD(ldub, %o1, %o3), memcpy_retl_o2_plus_3)! read byte
887         subcc   %o2, 4, %o2             ! reduce count by 4
888         EX_ST(STORE(stb, %o3, %o0), memcpy_retl_o2_plus_7)! write byte & repeat
889         EX_LD(LOAD(ldub, %o1+1, %o3), memcpy_retl_o2_plus_6)! for total of 4
890         add     %o1, 4, %o1             ! advance SRC by 4
891         EX_ST(STORE(stb, %o3, %o0+1), memcpy_retl_o2_plus_6)
892         EX_LD(LOAD(ldub, %o1-2, %o3), memcpy_retl_o2_plus_5)
893         add     %o0, 4, %o0             ! advance DST by 4
894         EX_ST(STORE(stb, %o3, %o0-2), memcpy_retl_o2_plus_5)
895         EX_LD(LOAD(ldub, %o1-1, %o3), memcpy_retl_o2_plus_4)
896         bgu,pt  %xcc, .Lsmallnotalign4  ! loop til 3 or fewer bytes remain
897         EX_ST(STORE(stb, %o3, %o0-1), memcpy_retl_o2_plus_4)
898         addcc   %o2, 3, %o2             ! restore count
899         bz,pt   %xcc, .Lsmallx
900 .Lsmallleft3:                           ! 1, 2, or 3 bytes remain
901         subcc   %o2, 1, %o2
902         EX_LD(LOAD(ldub, %o1, %o3), memcpy_retl_o2_plus_1)      ! load one byte
903         bz,pt   %xcc, .Lsmallx
904         EX_ST(STORE(stb, %o3, %o0), memcpy_retl_o2_plus_1)      ! store one byte
905         EX_LD(LOAD(ldub, %o1+1, %o3), memcpy_retl_o2)   ! load second byte
906         subcc   %o2, 1, %o2
907         bz,pt   %xcc, .Lsmallx
908         EX_ST(STORE(stb, %o3, %o0+1), memcpy_retl_o2_plus_1)! store second byte
909         EX_LD(LOAD(ldub, %o1+2, %o3), memcpy_retl_o2)   ! load third byte
910         EX_ST(STORE(stb, %o3, %o0+2), memcpy_retl_o2)   ! store third byte
911 .Lsmallx:
912         retl
913          mov    EX_RETVAL(%g1), %o0
914 .Lsmallfin:
915         tst     %o2
916         bnz,pn  %xcc, .Lsmallleft3
917          nop
918         retl
919          mov    EX_RETVAL(%g1), %o0     ! restore %o0
920 .Lexit_cp:
921         retl
922          mov    EX_RETVAL(%g1), %o0
923         .size  FUNC_NAME, .-FUNC_NAME