← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/alpha/lib/memcpy.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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");