![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memcpy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / qemu-palcode|
Return to memcpy.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / qemu-palcode |
1.1 root 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: #include <string.h>
12:
13: /*
14: * Note that the C code is written to be optimized into good assembly. However,
15: * at this point gcc is unable to sanely compile "if (n >= 0)", resulting in a
16: * explicit compare against 0 (instead of just using the proper "blt reg, xx" or
17: * "bge reg, xx"). I hope alpha-gcc will be fixed to notice this eventually..
18: */
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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.