Linux-2.6.12-rc2
[linux-3.10.git] / arch / alpha / lib / memcpy.c
1 /*
2  *  linux/arch/alpha/lib/memcpy.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  */
6
7 /*
8  * This is a reasonably optimized memcpy() routine.
9  */
10
11 /*
12  * Note that the C code is written to be optimized into good assembly. However,
13  * at this point gcc is unable to sanely compile "if (n >= 0)", resulting in a
14  * explicit compare against 0 (instead of just using the proper "blt reg, xx" or
15  * "bge reg, xx"). I hope alpha-gcc will be fixed to notice this eventually..
16  */
17
18 #include <linux/types.h>
19
20 /*
21  * This should be done in one go with ldq_u*2/mask/stq_u. Do it
22  * with a macro so that we can fix it up later..
23  */
24 #define ALIGN_DEST_TO8_UP(d,s,n) \
25         while (d & 7) { \
26                 if (n <= 0) return; \
27                 n--; \
28                 *(char *) d = *(char *) s; \
29                 d++; s++; \
30         }
31 #define ALIGN_DEST_TO8_DN(d,s,n) \
32         while (d & 7) { \
33                 if (n <= 0) return; \
34                 n--; \
35                 d--; s--; \
36                 *(char *) d = *(char *) s; \
37         }
38
39 /*
40  * This should similarly be done with ldq_u*2/mask/stq. The destination
41  * is aligned, but we don't fill in a full quad-word
42  */
43 #define DO_REST_UP(d,s,n) \
44         while (n > 0) { \
45                 n--; \
46                 *(char *) d = *(char *) s; \
47                 d++; s++; \
48         }
49 #define DO_REST_DN(d,s,n) \
50         while (n > 0) { \
51                 n--; \
52                 d--; s--; \
53                 *(char *) d = *(char *) s; \
54         }
55
56 /*
57  * This should be done with ldq/mask/stq. The source and destination are
58  * aligned, but we don't fill in a full quad-word
59  */
60 #define DO_REST_ALIGNED_UP(d,s,n) DO_REST_UP(d,s,n)
61 #define DO_REST_ALIGNED_DN(d,s,n) DO_REST_DN(d,s,n)
62
63 /*
64  * This does unaligned memory copies. We want to avoid storing to
65  * an unaligned address, as that would do a read-modify-write cycle.
66  * We also want to avoid double-reading the unaligned reads.
67  *
68  * Note the ordering to try to avoid load (and address generation) latencies.
69  */
70 static inline void __memcpy_unaligned_up (unsigned long d, unsigned long s,
71                                           long n)
72 {
73         ALIGN_DEST_TO8_UP(d,s,n);
74         n -= 8;                 /* to avoid compare against 8 in the loop */
75         if (n >= 0) {
76                 unsigned long low_word, high_word;
77                 __asm__("ldq_u %0,%1":"=r" (low_word):"m" (*(unsigned long *) s));
78                 do {
79                         unsigned long tmp;
80                         __asm__("ldq_u %0,%1":"=r" (high_word):"m" (*(unsigned long *)(s+8)));
81                         n -= 8;
82                         __asm__("extql %1,%2,%0"
83                                 :"=r" (low_word)
84                                 :"r" (low_word), "r" (s));
85                         __asm__("extqh %1,%2,%0"
86                                 :"=r" (tmp)
87                                 :"r" (high_word), "r" (s));
88                         s += 8;
89                         *(unsigned long *) d = low_word | tmp;
90                         d += 8;
91                         low_word = high_word;
92                 } while (n >= 0);
93         }
94         n += 8;
95         DO_REST_UP(d,s,n);
96 }
97
98 static inline void __memcpy_unaligned_dn (unsigned long d, unsigned long s,
99                                           long n)
100 {
101         /* I don't understand AXP assembler well enough for this. -Tim */
102         s += n;
103         d += n;
104         while (n--)
105                 * (char *) --d = * (char *) --s;
106 }
107
108 /*
109  * Hmm.. Strange. The __asm__ here is there to make gcc use an integer register
110  * for the load-store. I don't know why, but it would seem that using a floating
111  * point register for the move seems to slow things down (very small difference,
112  * though).
113  *
114  * Note the ordering to try to avoid load (and address generation) latencies.
115  */
116 static inline void __memcpy_aligned_up (unsigned long d, unsigned long s,
117                                         long n)
118 {
119         ALIGN_DEST_TO8_UP(d,s,n);
120         n -= 8;
121         while (n >= 0) {
122                 unsigned long tmp;
123                 __asm__("ldq %0,%1":"=r" (tmp):"m" (*(unsigned long *) s));
124                 n -= 8;
125                 s += 8;
126                 *(unsigned long *) d = tmp;
127                 d += 8;
128         }
129         n += 8;
130         DO_REST_ALIGNED_UP(d,s,n);
131 }
132 static inline void __memcpy_aligned_dn (unsigned long d, unsigned long s,
133                                         long n)
134 {
135         s += n;
136         d += n;
137         ALIGN_DEST_TO8_DN(d,s,n);
138         n -= 8;
139         while (n >= 0) {
140                 unsigned long tmp;
141                 s -= 8;
142                 __asm__("ldq %0,%1":"=r" (tmp):"m" (*(unsigned long *) s));
143                 n -= 8;
144                 d -= 8;
145                 *(unsigned long *) d = tmp;
146         }
147         n += 8;
148         DO_REST_ALIGNED_DN(d,s,n);
149 }
150
151 void * memcpy(void * dest, const void *src, size_t n)
152 {
153         if (!(((unsigned long) dest ^ (unsigned long) src) & 7)) {
154                 __memcpy_aligned_up ((unsigned long) dest, (unsigned long) src,
155                                      n);
156                 return dest;
157         }
158         __memcpy_unaligned_up ((unsigned long) dest, (unsigned long) src, n);
159         return dest;
160 }
161
162 /* For backward modules compatibility, define __memcpy.  */
163 asm("__memcpy = memcpy; .globl __memcpy");