~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sh/lib/memmove.S

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /arch/sh/lib/memmove.S (Version linux-6.12-rc7) and /arch/sparc/lib/memmove.S (Version linux-5.18.19)


  1 /* SPDX-License-Identifier: GPL-2.0 */              1 /* SPDX-License-Identifier: GPL-2.0 */
  2 /* $Id: memmove.S,v 1.2 2001/07/27 11:51:09 gn !!   2 /* memmove.S: Simple memmove implementation.
  3  *                                                  3  *
  4  * "memmove" implementation of SuperH          !!   4  * Copyright (C) 1997, 2004 David S. Miller (davem@redhat.com)
  5  *                                             !!   5  * Copyright (C) 1996, 1997, 1998, 1999 Jakub Jelinek (jj@ultra.linux.cz)
  6  * Copyright (C) 1999  Niibe Yutaka            << 
  7  *                                             << 
  8  */                                            << 
  9                                                << 
 10 /*                                             << 
 11  * void *memmove(void *dst, const void *src, s << 
 12  * The memory areas may overlap.               << 
 13  */                                                 6  */
 14                                                     7 
 15 #include <linux/linkage.h>                          8 #include <linux/linkage.h>
 16 ENTRY(memmove)                                 !!   9 #include <asm/export.h>
 17         ! if dest > src, call memcpy (it copie !!  10 
 18         cmp/hi  r5,r4                          !!  11         .text
 19         bf      1f                             !!  12 ENTRY(memmove) /* o0=dst o1=src o2=len */
 20         mov.l   2f,r0                          !!  13         brz,pn          %o2, 99f
 21         jmp     @r0                            !!  14          mov            %o0, %g1
                                                   >>  15 
                                                   >>  16         cmp             %o0, %o1
                                                   >>  17         bleu,pt         %xcc, 2f
                                                   >>  18          add            %o1, %o2, %g7
                                                   >>  19         cmp             %g7, %o0
                                                   >>  20         bleu,pt         %xcc, memcpy
                                                   >>  21          add            %o0, %o2, %o5
                                                   >>  22         sub             %g7, 1, %o1
                                                   >>  23 
                                                   >>  24         sub             %o5, 1, %o0
                                                   >>  25 1:      ldub            [%o1], %g7
                                                   >>  26         subcc           %o2, 1, %o2
                                                   >>  27         sub             %o1, 1, %o1
                                                   >>  28         stb             %g7, [%o0]
                                                   >>  29         bne,pt          %icc, 1b
                                                   >>  30          sub            %o0, 1, %o0
                                                   >>  31 99:
                                                   >>  32         retl
                                                   >>  33          mov            %g1, %o0
                                                   >>  34 
                                                   >>  35         /* We can't just call memcpy for these memmove cases.  On some
                                                   >>  36          * chips the memcpy uses cache initializing stores and when dst
                                                   >>  37          * and src are close enough, those can clobber the source data
                                                   >>  38          * before we've loaded it in.
                                                   >>  39          */
                                                   >>  40 2:      or              %o0, %o1, %g7
                                                   >>  41         or              %o2, %g7, %g7
                                                   >>  42         andcc           %g7, 0x7, %g0
                                                   >>  43         bne,pn          %xcc, 4f
 22          nop                                       44          nop
 23         .balign 4                              !!  45 
 24 2:      .long   memcpy                         !!  46 3:      ldx             [%o1], %g7
 25 1:                                             !!  47         add             %o1, 8, %o1
 26         sub     r5,r4           ! From here, r !!  48         subcc           %o2, 8, %o2
 27         tst     r6,r6                          !!  49         add             %o0, 8, %o0
 28         bt/s    9f              ! if n=0, do n !!  50         bne,pt          %icc, 3b
 29          mov    r5,r0                          !!  51          stx            %g7, [%o0 - 0x8]
 30         add     r6,r5                          !!  52         ba,a,pt         %xcc, 99b
 31         mov     #12,r1                         !!  53 
 32         cmp/gt  r6,r1                          !!  54 4:      ldub            [%o1], %g7
 33         bt/s    8f              ! if it's too  !!  55         add             %o1, 1, %o1
 34          add    #-1,r4                         !!  56         subcc           %o2, 1, %o2
 35         add     #1,r4                          !!  57         add             %o0, 1, %o0
 36         !                                      !!  58         bne,pt          %icc, 4b
 37         !                [ ...  ] DST          !!  59          stb            %g7, [%o0 - 0x1]
 38         !                [ ...  ]              !!  60         ba,a,pt         %xcc, 99b
 39         !                  :                   !!  61 ENDPROC(memmove)
 40         !      r0+r4-->  [ ...  ]       r0     !!  62 EXPORT_SYMBOL(memmove)
 41         !                  :                   << 
 42         !                [ ...  ]              << 
 43         !                               r5     << 
 44         !                                      << 
 45         mov     r4,r1                          << 
 46         mov     #3,r2                          << 
 47         and     r2,r1                          << 
 48         shll2   r1                             << 
 49         mov     r0,r3           ! Save the val << 
 50         mova    jmptable,r0                    << 
 51         add     r1,r0                          << 
 52         mov.l   @r0,r1                         << 
 53         jmp     @r1                            << 
 54          mov    r3,r0           ! and back to  << 
 55         .balign 4                              << 
 56 jmptable:                                      << 
 57         .long   case0                          << 
 58         .long   case1                          << 
 59         .long   case2                          << 
 60         .long   case3                          << 
 61                                                << 
 62         ! copy a byte at once                  << 
 63 8:      mov.b   @r0+,r1                        << 
 64         cmp/hs  r5,r0                          << 
 65         bf/s    8b                      ! whil << 
 66          mov.b  r1,@(r0,r4)                    << 
 67         add     #1,r4                          << 
 68 9:                                             << 
 69         add     r4,r0                          << 
 70         rts                                    << 
 71          sub    r6,r0                          << 
 72                                                << 
 73 case_none:                                     << 
 74         bra     8b                             << 
 75          add    #-1,r4                         << 
 76                                                << 
 77 case0:                                         << 
 78         !                                      << 
 79         !       GHIJ KLMN OPQR -->  GHIJ KLMN  << 
 80         !                                      << 
 81         ! First, align to long word boundary   << 
 82         mov     r0,r3                          << 
 83         and     r2,r3                          << 
 84         tst     r3,r3                          << 
 85         bt/s    2f                             << 
 86          add    #-1,r4                         << 
 87         mov     #4,r2                          << 
 88         sub     r3,r2                          << 
 89 1:      dt      r2                             << 
 90         mov.b   @r0+,r1                        << 
 91         bf/s    1b                             << 
 92          mov.b  r1,@(r0,r4)                    << 
 93         !                                      << 
 94 2:      ! Second, copy a long word at once     << 
 95         add     #-3,r4                         << 
 96         add     #-3,r5                         << 
 97 3:      mov.l   @r0+,r1                        << 
 98         cmp/hs  r5,r0                          << 
 99         bf/s    3b                             << 
100          mov.l  r1,@(r0,r4)                    << 
101         add     #3,r5                          << 
102         !                                      << 
103         ! Third, copy a byte at once, if neces << 
104         cmp/eq  r5,r0                          << 
105         bt/s    9b                             << 
106          add    #4,r4                          << 
107         bra     8b                             << 
108          add    #-1,r4                         << 
109                                                << 
110 case3:                                         << 
111         !                                      << 
112         !       GHIJ KLMN OPQR -->  ...G HIJK  << 
113         !                                      << 
114         ! First, align to long word boundary   << 
115         mov     r0,r3                          << 
116         and     r2,r3                          << 
117         tst     r3,r3                          << 
118         bt/s    2f                             << 
119          add    #-1,r4                         << 
120         mov     #4,r2                          << 
121         sub     r3,r2                          << 
122 1:      dt      r2                             << 
123         mov.b   @r0+,r1                        << 
124         bf/s    1b                             << 
125          mov.b  r1,@(r0,r4)                    << 
126         !                                      << 
127 2:      ! Second, read a long word and write a << 
128         add     #-2,r4                         << 
129         mov.l   @(r0,r4),r1                    << 
130         add     #-7,r5                         << 
131         add     #-4,r4                         << 
132         !                                      << 
133 #ifdef __LITTLE_ENDIAN__                       << 
134         shll8   r1                             << 
135 3:      mov     r1,r3           ! JIHG         << 
136         shlr8   r3              ! xJIH         << 
137         mov.l   @r0+,r1         ! NMLK         << 
138         mov     r1,r2                          << 
139         shll16  r2                             << 
140         shll8   r2              ! Kxxx         << 
141         or      r2,r3           ! KJIH         << 
142         cmp/hs  r5,r0                          << 
143         bf/s    3b                             << 
144          mov.l  r3,@(r0,r4)                    << 
145 #else                                          << 
146         shlr8   r1                             << 
147 3:      mov     r1,r3           ! GHIJ         << 
148         shll8   r3              ! HIJx         << 
149         mov.l   @r0+,r1         ! KLMN         << 
150         mov     r1,r2                          << 
151         shlr16  r2                             << 
152         shlr8   r2              ! xxxK         << 
153         or      r2,r3           ! HIJK         << 
154         cmp/hs  r5,r0                          << 
155         bf/s    3b                             << 
156          mov.l  r3,@(r0,r4)                    << 
157 #endif                                         << 
158         add     #7,r5                          << 
159         !                                      << 
160         ! Third, copy a byte at once, if neces << 
161         cmp/eq  r5,r0                          << 
162         bt/s    9b                             << 
163          add    #7,r4                          << 
164         add     #-3,r0                         << 
165         bra     8b                             << 
166          add    #-1,r4                         << 
167                                                << 
168 case2:                                         << 
169         !                                      << 
170         !       GHIJ KLMN OPQR -->  ..GH IJKL  << 
171         !                                      << 
172         ! First, align to word boundary        << 
173         tst     #1,r0                          << 
174         bt/s    2f                             << 
175          add    #-1,r4                         << 
176         mov.b   @r0+,r1                        << 
177         mov.b   r1,@(r0,r4)                    << 
178         !                                      << 
179 2:      ! Second, read a word and write a word << 
180         add     #-1,r4                         << 
181         add     #-1,r5                         << 
182         !                                      << 
183 3:      mov.w   @r0+,r1                        << 
184         cmp/hs  r5,r0                          << 
185         bf/s    3b                             << 
186          mov.w  r1,@(r0,r4)                    << 
187         add     #1,r5                          << 
188         !                                      << 
189         ! Third, copy a byte at once, if neces << 
190         cmp/eq  r5,r0                          << 
191         bt/s    9b                             << 
192          add    #2,r4                          << 
193         mov.b   @r0,r1                         << 
194         mov.b   r1,@(r0,r4)                    << 
195         bra     9b                             << 
196          add    #1,r0                          << 
197                                                << 
198 case1:                                         << 
199         !                                      << 
200         !       GHIJ KLMN OPQR -->  .GHI JKLM  << 
201         !                                      << 
202         ! First, align to long word boundary   << 
203         mov     r0,r3                          << 
204         and     r2,r3                          << 
205         tst     r3,r3                          << 
206         bt/s    2f                             << 
207          add    #-1,r4                         << 
208         mov     #4,r2                          << 
209         sub     r3,r2                          << 
210 1:      dt      r2                             << 
211         mov.b   @r0+,r1                        << 
212         bf/s    1b                             << 
213          mov.b  r1,@(r0,r4)                    << 
214         !                                      << 
215 2:      ! Second, read a long word and write a << 
216         mov.l   @(r0,r4),r1                    << 
217         add     #-7,r5                         << 
218         add     #-4,r4                         << 
219         !                                      << 
220 #ifdef __LITTLE_ENDIAN__                       << 
221         shll16  r1                             << 
222         shll8   r1                             << 
223 3:      mov     r1,r3           ! JIHG         << 
224         shlr16  r3                             << 
225         shlr8   r3              ! xxxJ         << 
226         mov.l   @r0+,r1         ! NMLK         << 
227         mov     r1,r2                          << 
228         shll8   r2              ! MLKx         << 
229         or      r2,r3           ! MLKJ         << 
230         cmp/hs  r5,r0                          << 
231         bf/s    3b                             << 
232          mov.l  r3,@(r0,r4)                    << 
233 #else                                          << 
234         shlr16  r1                             << 
235         shlr8   r1                             << 
236 3:      mov     r1,r3           ! GHIJ         << 
237         shll16  r3                             << 
238         shll8   r3              ! Jxxx         << 
239         mov.l   @r0+,r1         ! KLMN         << 
240         mov     r1,r2                          << 
241         shlr8   r2              ! xKLM         << 
242         or      r2,r3           ! JKLM         << 
243         cmp/hs  r5,r0                          << 
244         bf/s    3b              ! while(r0<r5) << 
245          mov.l  r3,@(r0,r4)                    << 
246 #endif                                         << 
247         add     #7,r5                          << 
248         !                                      << 
249         ! Third, copy a byte at once, if neces << 
250         cmp/eq  r5,r0                          << 
251         bt/s    9b                             << 
252          add    #5,r4                          << 
253         add     #-3,r0                         << 
254         bra     8b                             << 
255          add    #-1,r4                         << 
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php