]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - arch/cris/arch-v10/lib/string.c
15d6662b03b17212e2f57fb2588a93e0ae247859
[linux-3.10.git] / arch / cris / arch-v10 / lib / string.c
1 /*#************************************************************************#*/
2 /*#-------------------------------------------------------------------------*/
3 /*#                                                                         */
4 /*# FUNCTION NAME: memcpy()                                                 */
5 /*#                                                                         */
6 /*# PARAMETERS:  void* dst;   Destination address.                          */
7 /*#              void* src;   Source address.                               */
8 /*#              int   len;   Number of bytes to copy.                      */
9 /*#                                                                         */
10 /*# RETURNS:     dst.                                                       */
11 /*#                                                                         */
12 /*# DESCRIPTION: Copies len bytes of memory from src to dst.  No guarantees */
13 /*#              about copying of overlapping memory areas. This routine is */
14 /*#              very sensitive to compiler changes in register allocation. */
15 /*#              Should really be rewritten to avoid this problem.          */
16 /*#                                                                         */
17 /*#-------------------------------------------------------------------------*/
18 /*#                                                                         */
19 /*# HISTORY                                                                 */
20 /*#                                                                         */
21 /*# DATE      NAME            CHANGES                                       */
22 /*# ----      ----            -------                                       */
23 /*# 941007    Kenny R         Creation                                      */
24 /*# 941011    Kenny R         Lots of optimizations and inlining.           */
25 /*# 941129    Ulf A           Adapted for use in libc.                      */
26 /*# 950216    HP              N==0 forgotten if non-aligned src/dst.        */
27 /*#                           Added some optimizations.                     */
28 /*# 001025    HP              Make src and dst char *.  Align dst to        */
29 /*#                           dword, not just word-if-both-src-and-dst-     */
30 /*#                           are-misaligned.                               */
31 /*#                                                                         */
32 /*#-------------------------------------------------------------------------*/
33
34 #include <linux/types.h>
35
36 void *memcpy(void *pdst,
37              const void *psrc,
38              size_t pn)
39 {
40   /* Ok.  Now we want the parameters put in special registers.
41      Make sure the compiler is able to make something useful of this.
42       As it is now: r10 -> r13; r11 -> r11 (nop); r12 -> r12 (nop).
43
44      If gcc was alright, it really would need no temporaries, and no
45      stack space to save stuff on. */
46
47   register void *return_dst __asm__ ("r10") = pdst;
48   register char *dst __asm__ ("r13") = pdst;
49   register const char *src __asm__ ("r11") = psrc;
50   register int n __asm__ ("r12") = pn;
51   
52  
53   /* When src is aligned but not dst, this makes a few extra needless
54      cycles.  I believe it would take as many to check that the
55      re-alignment was unnecessary.  */
56   if (((unsigned long) dst & 3) != 0
57       /* Don't align if we wouldn't copy more than a few bytes; so we
58          don't have to check further for overflows.  */
59       && n >= 3)
60   {
61     if ((unsigned long) dst & 1)
62     {
63       n--;
64       *(char*)dst = *(char*)src;
65       src++;
66       dst++;
67     }
68
69     if ((unsigned long) dst & 2)
70     {
71       n -= 2;
72       *(short*)dst = *(short*)src;
73       src += 2;
74       dst += 2;
75     }
76   }
77
78   /* Decide which copying method to use. */
79   if (n >= 44*2)                /* Break even between movem and
80                                    move16 is at 38.7*2, but modulo 44. */
81   {
82     /* For large copies we use 'movem' */
83
84   /* It is not optimal to tell the compiler about clobbering any
85      registers; that will move the saving/restoring of those registers
86      to the function prologue/epilogue, and make non-movem sizes
87      suboptimal.
88
89       This method is not foolproof; it assumes that the "asm reg"
90      declarations at the beginning of the function really are used
91      here (beware: they may be moved to temporary registers).
92       This way, we do not have to save/move the registers around into
93      temporaries; we can safely use them straight away.
94
95       If you want to check that the allocation was right; then
96       check the equalities in the first comment.  It should say
97       "r13=r13, r11=r11, r12=r12" */
98     __asm__ volatile ("
99         ;; Check that the following is true (same register names on
100         ;; both sides of equal sign, as in r8=r8):
101         ;; %0=r13, %1=r11, %2=r12
102         ;;
103         ;; Save the registers we'll use in the movem process
104         ;; on the stack.
105         subq    11*4,$sp
106         movem   $r10,[$sp]
107
108         ;; Now we've got this:
109         ;; r11 - src
110         ;; r13 - dst
111         ;; r12 - n
112         
113         ;; Update n for the first loop
114         subq    44,$r12
115 0:
116         movem   [$r11+],$r10
117         subq   44,$r12
118         bge     0b
119         movem   $r10,[$r13+]
120
121         addq   44,$r12  ;; compensate for last loop underflowing n
122
123         ;; Restore registers from stack
124         movem [$sp+],$r10" 
125
126      /* Outputs */ : "=r" (dst), "=r" (src), "=r" (n) 
127      /* Inputs */ : "0" (dst), "1" (src), "2" (n));
128     
129   }
130
131   /* Either we directly starts copying, using dword copying
132      in a loop, or we copy as much as possible with 'movem' 
133      and then the last block (<44 bytes) is copied here.
134      This will work since 'movem' will have updated src,dst,n. */
135
136   while ( n >= 16 )
137   {
138     *((long*)dst)++ = *((long*)src)++;
139     *((long*)dst)++ = *((long*)src)++;
140     *((long*)dst)++ = *((long*)src)++;
141     *((long*)dst)++ = *((long*)src)++;
142     n -= 16;
143   }
144
145   /* A switch() is definitely the fastest although it takes a LOT of code.
146    * Particularly if you inline code this.
147    */
148   switch (n)
149   {
150     case 0:
151       break;
152     case 1:
153       *(char*)dst = *(char*)src;
154       break;
155     case 2:
156       *(short*)dst = *(short*)src;
157       break;
158     case 3:
159       *((short*)dst)++ = *((short*)src)++;
160       *(char*)dst = *(char*)src;
161       break;
162     case 4:
163       *((long*)dst)++ = *((long*)src)++;
164       break;
165     case 5:
166       *((long*)dst)++ = *((long*)src)++;
167       *(char*)dst = *(char*)src;
168       break;
169     case 6:
170       *((long*)dst)++ = *((long*)src)++;
171       *(short*)dst = *(short*)src;
172       break;
173     case 7:
174       *((long*)dst)++ = *((long*)src)++;
175       *((short*)dst)++ = *((short*)src)++;
176       *(char*)dst = *(char*)src;
177       break;
178     case 8:
179       *((long*)dst)++ = *((long*)src)++;
180       *((long*)dst)++ = *((long*)src)++;
181       break;
182     case 9:
183       *((long*)dst)++ = *((long*)src)++;
184       *((long*)dst)++ = *((long*)src)++;
185       *(char*)dst = *(char*)src;
186       break;
187     case 10:
188       *((long*)dst)++ = *((long*)src)++;
189       *((long*)dst)++ = *((long*)src)++;
190       *(short*)dst = *(short*)src;
191       break;
192     case 11:
193       *((long*)dst)++ = *((long*)src)++;
194       *((long*)dst)++ = *((long*)src)++;
195       *((short*)dst)++ = *((short*)src)++;
196       *(char*)dst = *(char*)src;
197       break;
198     case 12:
199       *((long*)dst)++ = *((long*)src)++;
200       *((long*)dst)++ = *((long*)src)++;
201       *((long*)dst)++ = *((long*)src)++;
202       break;
203     case 13:
204       *((long*)dst)++ = *((long*)src)++;
205       *((long*)dst)++ = *((long*)src)++;
206       *((long*)dst)++ = *((long*)src)++;
207       *(char*)dst = *(char*)src;
208       break;
209     case 14:
210       *((long*)dst)++ = *((long*)src)++;
211       *((long*)dst)++ = *((long*)src)++;
212       *((long*)dst)++ = *((long*)src)++;
213       *(short*)dst = *(short*)src;
214       break;
215     case 15:
216       *((long*)dst)++ = *((long*)src)++;
217       *((long*)dst)++ = *((long*)src)++;
218       *((long*)dst)++ = *((long*)src)++;
219       *((short*)dst)++ = *((short*)src)++;
220       *(char*)dst = *(char*)src;
221       break;
222   }
223
224   return return_dst; /* destination pointer. */
225 } /* memcpy() */