Linux-2.6.12-rc2
[linux-3.10.git] / arch / alpha / lib / copy_user.S
1 /*
2  * arch/alpha/lib/copy_user.S
3  *
4  * Copy to/from user space, handling exceptions as we go..  This
5  * isn't exactly pretty.
6  *
7  * This is essentially the same as "memcpy()", but with a few twists.
8  * Notably, we have to make sure that $0 is always up-to-date and
9  * contains the right "bytes left to copy" value (and that it is updated
10  * only _after_ a successful copy). There is also some rather minor
11  * exception setup stuff..
12  *
13  * NOTE! This is not directly C-callable, because the calling semantics are
14  * different:
15  *
16  * Inputs:
17  *      length in $0
18  *      destination address in $6
19  *      source address in $7
20  *      return address in $28
21  *
22  * Outputs:
23  *      bytes left to copy in $0
24  *
25  * Clobbers:
26  *      $1,$2,$3,$4,$5,$6,$7
27  */
28
29 /* Allow an exception for an insn; exit if we get one.  */
30 #define EXI(x,y...)                     \
31         99: x,##y;                      \
32         .section __ex_table,"a";        \
33         .long 99b - .;                  \
34         lda $31, $exitin-99b($31);      \
35         .previous
36
37 #define EXO(x,y...)                     \
38         99: x,##y;                      \
39         .section __ex_table,"a";        \
40         .long 99b - .;                  \
41         lda $31, $exitout-99b($31);     \
42         .previous
43
44         .set noat
45         .align 4
46         .globl __copy_user
47         .ent __copy_user
48 __copy_user:
49         .prologue 0
50         and $6,7,$3
51         beq $0,$35
52         beq $3,$36
53         subq $3,8,$3
54         .align 4
55 $37:
56         EXI( ldq_u $1,0($7) )
57         EXO( ldq_u $2,0($6) )
58         extbl $1,$7,$1
59         mskbl $2,$6,$2
60         insbl $1,$6,$1
61         addq $3,1,$3
62         bis $1,$2,$1
63         EXO( stq_u $1,0($6) )
64         subq $0,1,$0
65         addq $6,1,$6
66         addq $7,1,$7
67         beq $0,$41
68         bne $3,$37
69 $36:
70         and $7,7,$1
71         bic $0,7,$4
72         beq $1,$43
73         beq $4,$48
74         EXI( ldq_u $3,0($7) )
75         .align 4
76 $50:
77         EXI( ldq_u $2,8($7) )
78         subq $4,8,$4
79         extql $3,$7,$3
80         extqh $2,$7,$1
81         bis $3,$1,$1
82         EXO( stq $1,0($6) )
83         addq $7,8,$7
84         subq $0,8,$0
85         addq $6,8,$6
86         bis $2,$2,$3
87         bne $4,$50
88 $48:
89         beq $0,$41
90         .align 4
91 $57:
92         EXI( ldq_u $1,0($7) )
93         EXO( ldq_u $2,0($6) )
94         extbl $1,$7,$1
95         mskbl $2,$6,$2
96         insbl $1,$6,$1
97         bis $1,$2,$1
98         EXO( stq_u $1,0($6) )
99         subq $0,1,$0
100         addq $6,1,$6
101         addq $7,1,$7
102         bne $0,$57
103         br $31,$41
104         .align 4
105 $43:
106         beq $4,$65
107         .align 4
108 $66:
109         EXI( ldq $1,0($7) )
110         subq $4,8,$4
111         EXO( stq $1,0($6) )
112         addq $7,8,$7
113         subq $0,8,$0
114         addq $6,8,$6
115         bne $4,$66
116 $65:
117         beq $0,$41
118         EXI( ldq $2,0($7) )
119         EXO( ldq $1,0($6) )
120         mskql $2,$0,$2
121         mskqh $1,$0,$1
122         bis $2,$1,$2
123         EXO( stq $2,0($6) )
124         bis $31,$31,$0
125 $41:
126 $35:
127 $exitout:
128         ret $31,($28),1
129
130 $exitin:
131         /* A stupid byte-by-byte zeroing of the rest of the output
132            buffer.  This cures security holes by never leaving 
133            random kernel data around to be copied elsewhere.  */
134
135         mov $0,$1
136 $101:
137         EXO ( ldq_u $2,0($6) )
138         subq $1,1,$1
139         mskbl $2,$6,$2
140         EXO ( stq_u $2,0($6) )
141         addq $6,1,$6
142         bgt $1,$101
143         ret $31,($28),1
144
145         .end __copy_user