[PATCH] cris: "extern inline" -> "static inline"
[linux-3.10.git] / include / asm-cris / arch-v32 / uaccess.h
1 /*
2  * Authors:    Hans-Peter Nilsson (hp@axis.com)
3  *
4  */
5 #ifndef _CRIS_ARCH_UACCESS_H
6 #define _CRIS_ARCH_UACCESS_H
7
8 /*
9  * We don't tell gcc that we are accessing memory, but this is OK
10  * because we do not write to any memory gcc knows about, so there
11  * are no aliasing issues.
12  *
13  * Note that PC at a fault is the address *at* the faulting
14  * instruction for CRISv32.
15  */
16 #define __put_user_asm(x, addr, err, op)                        \
17         __asm__ __volatile__(                                   \
18                 "2:     "op" %1,[%2]\n"                         \
19                 "4:\n"                                          \
20                 "       .section .fixup,\"ax\"\n"               \
21                 "3:     move.d %3,%0\n"                         \
22                 "       jump 4b\n"                              \
23                 "       nop\n"                                  \
24                 "       .previous\n"                            \
25                 "       .section __ex_table,\"a\"\n"            \
26                 "       .dword 2b,3b\n"                         \
27                 "       .previous\n"                            \
28                 : "=r" (err)                                    \
29                 : "r" (x), "r" (addr), "g" (-EFAULT), "0" (err))
30
31 #define __put_user_asm_64(x, addr, err) do {                    \
32         int dummy_for_put_user_asm_64_;                         \
33         __asm__ __volatile__(                                   \
34                 "2:     move.d %M2,[%1+]\n"                     \
35                 "4:     move.d %H2,[%1]\n"                      \
36                 "5:\n"                                          \
37                 "       .section .fixup,\"ax\"\n"               \
38                 "3:     move.d %4,%0\n"                         \
39                 "       jump 5b\n"                              \
40                 "       .previous\n"                            \
41                 "       .section __ex_table,\"a\"\n"            \
42                 "       .dword 2b,3b\n"                         \
43                 "       .dword 4b,3b\n"                         \
44                 "       .previous\n"                            \
45                 : "=r" (err), "=b" (dummy_for_put_user_asm_64_) \
46                 : "r" (x), "1" (addr), "g" (-EFAULT),           \
47                   "0" (err));                                   \
48         } while (0)
49
50 /* See comment before __put_user_asm.  */
51
52 #define __get_user_asm(x, addr, err, op)                \
53         __asm__ __volatile__(                           \
54                 "2:     "op" [%2],%1\n"                 \
55                 "4:\n"                                  \
56                 "       .section .fixup,\"ax\"\n"       \
57                 "3:     move.d %3,%0\n"                 \
58                 "       jump 4b\n"                      \
59                 "       moveq 0,%1\n"                   \
60                 "       .previous\n"                    \
61                 "       .section __ex_table,\"a\"\n"    \
62                 "       .dword 2b,3b\n"                 \
63                 "       .previous\n"                    \
64                 : "=r" (err), "=r" (x)                  \
65                 : "r" (addr), "g" (-EFAULT), "0" (err))
66
67 #define __get_user_asm_64(x, addr, err) do {            \
68         int dummy_for_get_user_asm_64_;                 \
69         __asm__ __volatile__(                           \
70                 "2:     move.d [%2+],%M1\n"             \
71                 "4:     move.d [%2],%H1\n"              \
72                 "5:\n"                                  \
73                 "       .section .fixup,\"ax\"\n"       \
74                 "3:     move.d %4,%0\n"                 \
75                 "       jump 5b\n"                      \
76                 "       moveq 0,%1\n"                   \
77                 "       .previous\n"                    \
78                 "       .section __ex_table,\"a\"\n"    \
79                 "       .dword 2b,3b\n"                 \
80                 "       .dword 4b,3b\n"                 \
81                 "       .previous\n"                    \
82                 : "=r" (err), "=r" (x),                 \
83                   "=b" (dummy_for_get_user_asm_64_)     \
84                 : "2" (addr), "g" (-EFAULT), "0" (err));\
85         } while (0)
86
87 /*
88  * Copy a null terminated string from userspace.
89  *
90  * Must return:
91  * -EFAULT              for an exception
92  * count                if we hit the buffer limit
93  * bytes copied         if we hit a null byte
94  * (without the null byte)
95  */
96 static inline long
97 __do_strncpy_from_user(char *dst, const char *src, long count)
98 {
99         long res;
100
101         if (count == 0)
102                 return 0;
103
104         /*
105          * Currently, in 2.4.0-test9, most ports use a simple byte-copy loop.
106          *  So do we.
107          *
108          *  This code is deduced from:
109          *
110          *      char tmp2;
111          *      long tmp1, tmp3;
112          *      tmp1 = count;
113          *      while ((*dst++ = (tmp2 = *src++)) != 0
114          *             && --tmp1)
115          *        ;
116          *
117          *      res = count - tmp1;
118          *
119          *  with tweaks.
120          */
121
122         __asm__ __volatile__ (
123                 "       move.d %3,%0\n"
124                 "5:     move.b [%2+],$acr\n"
125                 "1:     beq 2f\n"
126                 "       move.b $acr,[%1+]\n"
127
128                 "       subq 1,%0\n"
129                 "2:     bne 1b\n"
130                 "       move.b [%2+],$acr\n"
131
132                 "       sub.d %3,%0\n"
133                 "       neg.d %0,%0\n"
134                 "3:\n"
135                 "       .section .fixup,\"ax\"\n"
136                 "4:     move.d %7,%0\n"
137                 "       jump 3b\n"
138                 "       nop\n"
139
140                 /* The address for a fault at the first move is trivial.
141                    The address for a fault at the second move is that of
142                    the preceding branch insn, since the move insn is in
143                    its delay-slot.  That address is also a branch
144                    target.  Just so you don't get confused...  */
145                 "       .previous\n"
146                 "       .section __ex_table,\"a\"\n"
147                 "       .dword 5b,4b\n"
148                 "       .dword 2b,4b\n"
149                 "       .previous"
150                 : "=r" (res), "=b" (dst), "=b" (src), "=r" (count)
151                 : "3" (count), "1" (dst), "2" (src), "g" (-EFAULT)
152                 : "acr");
153
154         return res;
155 }
156
157 /* A few copy asms to build up the more complex ones from.
158
159    Note again, a post-increment is performed regardless of whether a bus
160    fault occurred in that instruction, and PC for a faulted insn is the
161    address for the insn, or for the preceding branch when in a delay-slot.  */
162
163 #define __asm_copy_user_cont(to, from, ret, COPY, FIXUP, TENTRY) \
164         __asm__ __volatile__ (                          \
165                         COPY                            \
166                 "1:\n"                                  \
167                 "       .section .fixup,\"ax\"\n"       \
168                         FIXUP                           \
169                 "       .previous\n"                    \
170                 "       .section __ex_table,\"a\"\n"    \
171                         TENTRY                          \
172                 "       .previous\n"                    \
173                 : "=b" (to), "=b" (from), "=r" (ret)    \
174                 : "0" (to), "1" (from), "2" (ret)       \
175                 : "acr", "memory")
176
177 #define __asm_copy_from_user_1(to, from, ret) \
178         __asm_copy_user_cont(to, from, ret,     \
179                 "2:     move.b [%1+],$acr\n"    \
180                 "       move.b $acr,[%0+]\n",   \
181                 "3:     addq 1,%2\n"            \
182                 "       jump 1b\n"              \
183                 "       clear.b [%0+]\n",       \
184                 "       .dword 2b,3b\n")
185
186 #define __asm_copy_from_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
187         __asm_copy_user_cont(to, from, ret,             \
188                         COPY                            \
189                 "2:     move.w [%1+],$acr\n"            \
190                 "       move.w $acr,[%0+]\n",           \
191                         FIXUP                           \
192                 "3:     addq 2,%2\n"                    \
193                 "       jump 1b\n"                      \
194                 "       clear.w [%0+]\n",               \
195                         TENTRY                          \
196                 "       .dword 2b,3b\n")
197
198 #define __asm_copy_from_user_2(to, from, ret) \
199         __asm_copy_from_user_2x_cont(to, from, ret, "", "", "")
200
201 #define __asm_copy_from_user_3(to, from, ret)           \
202         __asm_copy_from_user_2x_cont(to, from, ret,     \
203                 "4:     move.b [%1+],$acr\n"            \
204                 "       move.b $acr,[%0+]\n",           \
205                 "5:     addq 1,%2\n"                    \
206                 "       clear.b [%0+]\n",               \
207                 "       .dword 4b,5b\n")
208
209 #define __asm_copy_from_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
210         __asm_copy_user_cont(to, from, ret,             \
211                         COPY                            \
212                 "2:     move.d [%1+],$acr\n"            \
213                 "       move.d $acr,[%0+]\n",           \
214                         FIXUP                           \
215                 "3:     addq 4,%2\n"                    \
216                 "       jump 1b\n"                      \
217                 "       clear.d [%0+]\n",               \
218                         TENTRY                          \
219                 "       .dword 2b,3b\n")
220
221 #define __asm_copy_from_user_4(to, from, ret) \
222         __asm_copy_from_user_4x_cont(to, from, ret, "", "", "")
223
224 #define __asm_copy_from_user_5(to, from, ret) \
225         __asm_copy_from_user_4x_cont(to, from, ret,     \
226                 "4:     move.b [%1+],$acr\n"            \
227                 "       move.b $acr,[%0+]\n",           \
228                 "5:     addq 1,%2\n"                    \
229                 "       clear.b [%0+]\n",               \
230                 "       .dword 4b,5b\n")
231
232 #define __asm_copy_from_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
233         __asm_copy_from_user_4x_cont(to, from, ret,     \
234                         COPY                            \
235                 "4:     move.w [%1+],$acr\n"            \
236                 "       move.w $acr,[%0+]\n",           \
237                         FIXUP                           \
238                 "5:     addq 2,%2\n"                    \
239                 "       clear.w [%0+]\n",               \
240                         TENTRY                          \
241                 "       .dword 4b,5b\n")
242
243 #define __asm_copy_from_user_6(to, from, ret) \
244         __asm_copy_from_user_6x_cont(to, from, ret, "", "", "")
245
246 #define __asm_copy_from_user_7(to, from, ret) \
247         __asm_copy_from_user_6x_cont(to, from, ret,     \
248                 "6:     move.b [%1+],$acr\n"            \
249                 "       move.b $acr,[%0+]\n",           \
250                 "7:     addq 1,%2\n"                    \
251                 "       clear.b [%0+]\n",               \
252                 "       .dword 6b,7b\n")
253
254 #define __asm_copy_from_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
255         __asm_copy_from_user_4x_cont(to, from, ret,     \
256                         COPY                            \
257                 "4:     move.d [%1+],$acr\n"            \
258                 "       move.d $acr,[%0+]\n",           \
259                         FIXUP                           \
260                 "5:     addq 4,%2\n"                    \
261                 "       clear.d [%0+]\n",               \
262                         TENTRY                          \
263                 "       .dword 4b,5b\n")
264
265 #define __asm_copy_from_user_8(to, from, ret) \
266         __asm_copy_from_user_8x_cont(to, from, ret, "", "", "")
267
268 #define __asm_copy_from_user_9(to, from, ret) \
269         __asm_copy_from_user_8x_cont(to, from, ret,     \
270                 "6:     move.b [%1+],$acr\n"            \
271                 "       move.b $acr,[%0+]\n",           \
272                 "7:     addq 1,%2\n"                    \
273                 "       clear.b [%0+]\n",               \
274                 "       .dword 6b,7b\n")
275
276 #define __asm_copy_from_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
277         __asm_copy_from_user_8x_cont(to, from, ret,     \
278                         COPY                            \
279                 "6:     move.w [%1+],$acr\n"            \
280                 "       move.w $acr,[%0+]\n",           \
281                         FIXUP                           \
282                 "7:     addq 2,%2\n"                    \
283                 "       clear.w [%0+]\n",               \
284                         TENTRY                          \
285                 "       .dword 6b,7b\n")
286
287 #define __asm_copy_from_user_10(to, from, ret) \
288         __asm_copy_from_user_10x_cont(to, from, ret, "", "", "")
289
290 #define __asm_copy_from_user_11(to, from, ret)          \
291         __asm_copy_from_user_10x_cont(to, from, ret,    \
292                 "8:     move.b [%1+],$acr\n"            \
293                 "       move.b $acr,[%0+]\n",           \
294                 "9:     addq 1,%2\n"                    \
295                 "       clear.b [%0+]\n",               \
296                 "       .dword 8b,9b\n")
297
298 #define __asm_copy_from_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
299         __asm_copy_from_user_8x_cont(to, from, ret,     \
300                         COPY                            \
301                 "6:     move.d [%1+],$acr\n"            \
302                 "       move.d $acr,[%0+]\n",           \
303                         FIXUP                           \
304                 "7:     addq 4,%2\n"                    \
305                 "       clear.d [%0+]\n",               \
306                         TENTRY                          \
307                 "       .dword 6b,7b\n")
308
309 #define __asm_copy_from_user_12(to, from, ret) \
310         __asm_copy_from_user_12x_cont(to, from, ret, "", "", "")
311
312 #define __asm_copy_from_user_13(to, from, ret) \
313         __asm_copy_from_user_12x_cont(to, from, ret,    \
314                 "8:     move.b [%1+],$acr\n"            \
315                 "       move.b $acr,[%0+]\n",           \
316                 "9:     addq 1,%2\n"                    \
317                 "       clear.b [%0+]\n",               \
318                 "       .dword 8b,9b\n")
319
320 #define __asm_copy_from_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
321         __asm_copy_from_user_12x_cont(to, from, ret,    \
322                         COPY                            \
323                 "8:     move.w [%1+],$acr\n"            \
324                 "       move.w $acr,[%0+]\n",           \
325                         FIXUP                           \
326                 "9:     addq 2,%2\n"                    \
327                 "       clear.w [%0+]\n",               \
328                         TENTRY                          \
329                 "       .dword 8b,9b\n")
330
331 #define __asm_copy_from_user_14(to, from, ret) \
332         __asm_copy_from_user_14x_cont(to, from, ret, "", "", "")
333
334 #define __asm_copy_from_user_15(to, from, ret) \
335         __asm_copy_from_user_14x_cont(to, from, ret,    \
336                 "10:    move.b [%1+],$acr\n"            \
337                 "       move.b $acr,[%0+]\n",           \
338                 "11:    addq 1,%2\n"                    \
339                 "       clear.b [%0+]\n",               \
340                 "       .dword 10b,11b\n")
341
342 #define __asm_copy_from_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
343         __asm_copy_from_user_12x_cont(to, from, ret,    \
344                         COPY                            \
345                 "8:     move.d [%1+],$acr\n"            \
346                 "       move.d $acr,[%0+]\n",           \
347                         FIXUP                           \
348                 "9:     addq 4,%2\n"                    \
349                 "       clear.d [%0+]\n",               \
350                         TENTRY                          \
351                 "       .dword 8b,9b\n")
352
353 #define __asm_copy_from_user_16(to, from, ret) \
354         __asm_copy_from_user_16x_cont(to, from, ret, "", "", "")
355
356 #define __asm_copy_from_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
357         __asm_copy_from_user_16x_cont(to, from, ret,    \
358                         COPY                            \
359                 "10:    move.d [%1+],$acr\n"            \
360                 "       move.d $acr,[%0+]\n",           \
361                         FIXUP                           \
362                 "11:    addq 4,%2\n"                    \
363                 "       clear.d [%0+]\n",               \
364                         TENTRY                          \
365                 "       .dword 10b,11b\n")
366
367 #define __asm_copy_from_user_20(to, from, ret) \
368         __asm_copy_from_user_20x_cont(to, from, ret, "", "", "")
369
370 #define __asm_copy_from_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
371         __asm_copy_from_user_20x_cont(to, from, ret,    \
372                         COPY                            \
373                 "12:    move.d [%1+],$acr\n"            \
374                 "       move.d $acr,[%0+]\n",           \
375                         FIXUP                           \
376                 "13:    addq 4,%2\n"                    \
377                 "       clear.d [%0+]\n",               \
378                         TENTRY                          \
379                 "       .dword 12b,13b\n")
380
381 #define __asm_copy_from_user_24(to, from, ret) \
382         __asm_copy_from_user_24x_cont(to, from, ret, "", "", "")
383
384 /* And now, the to-user ones.  */
385
386 #define __asm_copy_to_user_1(to, from, ret)     \
387         __asm_copy_user_cont(to, from, ret,     \
388                 "       move.b [%1+],$acr\n"    \
389                 "2:     move.b $acr,[%0+]\n",   \
390                 "3:     jump 1b\n"              \
391                 "       addq 1,%2\n",           \
392                 "       .dword 2b,3b\n")
393
394 #define __asm_copy_to_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
395         __asm_copy_user_cont(to, from, ret,             \
396                         COPY                            \
397                 "       move.w [%1+],$acr\n"            \
398                 "2:     move.w $acr,[%0+]\n",           \
399                         FIXUP                           \
400                 "3:     jump 1b\n"                      \
401                 "       addq 2,%2\n",                   \
402                         TENTRY                          \
403                 "       .dword 2b,3b\n")
404
405 #define __asm_copy_to_user_2(to, from, ret) \
406         __asm_copy_to_user_2x_cont(to, from, ret, "", "", "")
407
408 #define __asm_copy_to_user_3(to, from, ret) \
409         __asm_copy_to_user_2x_cont(to, from, ret,       \
410                 "       move.b [%1+],$acr\n"            \
411                 "4:     move.b $acr,[%0+]\n",           \
412                 "5:     addq 1,%2\n",                   \
413                 "       .dword 4b,5b\n")
414
415 #define __asm_copy_to_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
416         __asm_copy_user_cont(to, from, ret,             \
417                         COPY                            \
418                 "       move.d [%1+],$acr\n"            \
419                 "2:     move.d $acr,[%0+]\n",           \
420                         FIXUP                           \
421                 "3:     jump 1b\n"                      \
422                 "       addq 4,%2\n",                   \
423                         TENTRY                          \
424                 "       .dword 2b,3b\n")
425
426 #define __asm_copy_to_user_4(to, from, ret) \
427         __asm_copy_to_user_4x_cont(to, from, ret, "", "", "")
428
429 #define __asm_copy_to_user_5(to, from, ret) \
430         __asm_copy_to_user_4x_cont(to, from, ret,       \
431                 "       move.b [%1+],$acr\n"            \
432                 "4:     move.b $acr,[%0+]\n",           \
433                 "5:     addq 1,%2\n",                   \
434                 "       .dword 4b,5b\n")
435
436 #define __asm_copy_to_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
437         __asm_copy_to_user_4x_cont(to, from, ret,       \
438                         COPY                            \
439                 "       move.w [%1+],$acr\n"            \
440                 "4:     move.w $acr,[%0+]\n",           \
441                         FIXUP                           \
442                 "5:     addq 2,%2\n",                   \
443                         TENTRY                          \
444                 "       .dword 4b,5b\n")
445
446 #define __asm_copy_to_user_6(to, from, ret) \
447         __asm_copy_to_user_6x_cont(to, from, ret, "", "", "")
448
449 #define __asm_copy_to_user_7(to, from, ret) \
450         __asm_copy_to_user_6x_cont(to, from, ret,       \
451                 "       move.b [%1+],$acr\n"            \
452                 "6:     move.b $acr,[%0+]\n",           \
453                 "7:     addq 1,%2\n",                   \
454                 "       .dword 6b,7b\n")
455
456 #define __asm_copy_to_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
457         __asm_copy_to_user_4x_cont(to, from, ret,       \
458                         COPY                            \
459                 "       move.d [%1+],$acr\n"            \
460                 "4:     move.d $acr,[%0+]\n",           \
461                         FIXUP                           \
462                 "5:     addq 4,%2\n",                   \
463                         TENTRY                          \
464                 "       .dword 4b,5b\n")
465
466 #define __asm_copy_to_user_8(to, from, ret) \
467         __asm_copy_to_user_8x_cont(to, from, ret, "", "", "")
468
469 #define __asm_copy_to_user_9(to, from, ret) \
470         __asm_copy_to_user_8x_cont(to, from, ret,       \
471                 "       move.b [%1+],$acr\n"            \
472                 "6:     move.b $acr,[%0+]\n",           \
473                 "7:     addq 1,%2\n",                   \
474                 "       .dword 6b,7b\n")
475
476 #define __asm_copy_to_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
477         __asm_copy_to_user_8x_cont(to, from, ret,       \
478                         COPY                            \
479                 "       move.w [%1+],$acr\n"            \
480                 "6:     move.w $acr,[%0+]\n",           \
481                         FIXUP                           \
482                 "7:     addq 2,%2\n",                   \
483                         TENTRY                          \
484                 "       .dword 6b,7b\n")
485
486 #define __asm_copy_to_user_10(to, from, ret) \
487         __asm_copy_to_user_10x_cont(to, from, ret, "", "", "")
488
489 #define __asm_copy_to_user_11(to, from, ret) \
490         __asm_copy_to_user_10x_cont(to, from, ret,      \
491                 "       move.b [%1+],$acr\n"            \
492                 "8:     move.b $acr,[%0+]\n",           \
493                 "9:     addq 1,%2\n",                   \
494                 "       .dword 8b,9b\n")
495
496 #define __asm_copy_to_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
497         __asm_copy_to_user_8x_cont(to, from, ret,       \
498                         COPY                            \
499                 "       move.d [%1+],$acr\n"            \
500                 "6:     move.d $acr,[%0+]\n",           \
501                         FIXUP                           \
502                 "7:     addq 4,%2\n",                   \
503                         TENTRY                          \
504                 "       .dword 6b,7b\n")
505
506 #define __asm_copy_to_user_12(to, from, ret) \
507         __asm_copy_to_user_12x_cont(to, from, ret, "", "", "")
508
509 #define __asm_copy_to_user_13(to, from, ret) \
510         __asm_copy_to_user_12x_cont(to, from, ret,      \
511                 "       move.b [%1+],$acr\n"            \
512                 "8:     move.b $acr,[%0+]\n",           \
513                 "9:     addq 1,%2\n",                   \
514                 "       .dword 8b,9b\n")
515
516 #define __asm_copy_to_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
517         __asm_copy_to_user_12x_cont(to, from, ret,      \
518                         COPY                            \
519                 "       move.w [%1+],$acr\n"            \
520                 "8:     move.w $acr,[%0+]\n",           \
521                         FIXUP                           \
522                 "9:     addq 2,%2\n",                   \
523                         TENTRY                          \
524                 "       .dword 8b,9b\n")
525
526 #define __asm_copy_to_user_14(to, from, ret)    \
527         __asm_copy_to_user_14x_cont(to, from, ret, "", "", "")
528
529 #define __asm_copy_to_user_15(to, from, ret) \
530         __asm_copy_to_user_14x_cont(to, from, ret,      \
531                 "       move.b [%1+],$acr\n"            \
532                 "10:    move.b $acr,[%0+]\n",           \
533                 "11:    addq 1,%2\n",                   \
534                 "       .dword 10b,11b\n")
535
536 #define __asm_copy_to_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
537         __asm_copy_to_user_12x_cont(to, from, ret,      \
538                         COPY                            \
539                 "       move.d [%1+],$acr\n"            \
540                 "8:     move.d $acr,[%0+]\n",           \
541                         FIXUP                           \
542                 "9:     addq 4,%2\n",                   \
543                         TENTRY                          \
544                 "       .dword 8b,9b\n")
545
546 #define __asm_copy_to_user_16(to, from, ret) \
547         __asm_copy_to_user_16x_cont(to, from, ret, "", "", "")
548
549 #define __asm_copy_to_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
550         __asm_copy_to_user_16x_cont(to, from, ret,      \
551                         COPY                            \
552                 "       move.d [%1+],$acr\n"            \
553                 "10:    move.d $acr,[%0+]\n",           \
554                         FIXUP                           \
555                 "11:    addq 4,%2\n",                   \
556                         TENTRY                          \
557                 "       .dword 10b,11b\n")
558
559 #define __asm_copy_to_user_20(to, from, ret) \
560         __asm_copy_to_user_20x_cont(to, from, ret, "", "", "")
561
562 #define __asm_copy_to_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY) \
563         __asm_copy_to_user_20x_cont(to, from, ret,      \
564                         COPY                            \
565                 "       move.d [%1+],$acr\n"            \
566                 "12:    move.d $acr,[%0+]\n",           \
567                         FIXUP                           \
568                 "13:    addq 4,%2\n",                   \
569                         TENTRY                          \
570                 "       .dword 12b,13b\n")
571
572 #define __asm_copy_to_user_24(to, from, ret)    \
573         __asm_copy_to_user_24x_cont(to, from, ret, "", "", "")
574
575 /* Define a few clearing asms with exception handlers.  */
576
577 /* This frame-asm is like the __asm_copy_user_cont one, but has one less
578    input.  */
579
580 #define __asm_clear(to, ret, CLEAR, FIXUP, TENTRY) \
581         __asm__ __volatile__ (                          \
582                         CLEAR                           \
583                 "1:\n"                                  \
584                 "       .section .fixup,\"ax\"\n"       \
585                         FIXUP                           \
586                 "       .previous\n"                    \
587                 "       .section __ex_table,\"a\"\n"    \
588                         TENTRY                          \
589                 "       .previous"                      \
590                 : "=b" (to), "=r" (ret)                 \
591                 : "0" (to), "1" (ret)                   \
592                 : "memory")
593
594 #define __asm_clear_1(to, ret) \
595         __asm_clear(to, ret,                    \
596                 "2:     clear.b [%0+]\n",       \
597                 "3:     jump 1b\n"              \
598                 "       addq 1,%1\n",           \
599                 "       .dword 2b,3b\n")
600
601 #define __asm_clear_2(to, ret) \
602         __asm_clear(to, ret,                    \
603                 "2:     clear.w [%0+]\n",       \
604                 "3:     jump 1b\n"              \
605                 "       addq 2,%1\n",           \
606                 "       .dword 2b,3b\n")
607
608 #define __asm_clear_3(to, ret) \
609      __asm_clear(to, ret,                       \
610                  "2:    clear.w [%0+]\n"        \
611                  "3:    clear.b [%0+]\n",       \
612                  "4:    addq 2,%1\n"            \
613                  "5:    jump 1b\n"              \
614                  "      addq 1,%1\n",           \
615                  "      .dword 2b,4b\n"         \
616                  "      .dword 3b,5b\n")
617
618 #define __asm_clear_4x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
619         __asm_clear(to, ret,                            \
620                         CLEAR                           \
621                 "2:     clear.d [%0+]\n",               \
622                         FIXUP                           \
623                 "3:     jump 1b\n"                      \
624                 "       addq 4,%1\n",                   \
625                         TENTRY                          \
626                 "       .dword 2b,3b\n")
627
628 #define __asm_clear_4(to, ret) \
629         __asm_clear_4x_cont(to, ret, "", "", "")
630
631 #define __asm_clear_8x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
632         __asm_clear_4x_cont(to, ret,                    \
633                         CLEAR                           \
634                 "4:     clear.d [%0+]\n",               \
635                         FIXUP                           \
636                 "5:     addq 4,%1\n",                   \
637                         TENTRY                          \
638                 "       .dword 4b,5b\n")
639
640 #define __asm_clear_8(to, ret) \
641         __asm_clear_8x_cont(to, ret, "", "", "")
642
643 #define __asm_clear_12x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
644         __asm_clear_8x_cont(to, ret,                    \
645                         CLEAR                           \
646                 "6:     clear.d [%0+]\n",               \
647                         FIXUP                           \
648                 "7:     addq 4,%1\n",                   \
649                         TENTRY                          \
650                 "       .dword 6b,7b\n")
651
652 #define __asm_clear_12(to, ret) \
653         __asm_clear_12x_cont(to, ret, "", "", "")
654
655 #define __asm_clear_16x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
656         __asm_clear_12x_cont(to, ret,                   \
657                         CLEAR                           \
658                 "8:     clear.d [%0+]\n",               \
659                         FIXUP                           \
660                 "9:     addq 4,%1\n",                   \
661                         TENTRY                          \
662                 "       .dword 8b,9b\n")
663
664 #define __asm_clear_16(to, ret) \
665         __asm_clear_16x_cont(to, ret, "", "", "")
666
667 #define __asm_clear_20x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
668         __asm_clear_16x_cont(to, ret,                   \
669                         CLEAR                           \
670                 "10:    clear.d [%0+]\n",               \
671                         FIXUP                           \
672                 "11:    addq 4,%1\n",                   \
673                         TENTRY                          \
674                 "       .dword 10b,11b\n")
675
676 #define __asm_clear_20(to, ret) \
677         __asm_clear_20x_cont(to, ret, "", "", "")
678
679 #define __asm_clear_24x_cont(to, ret, CLEAR, FIXUP, TENTRY) \
680         __asm_clear_20x_cont(to, ret,                   \
681                         CLEAR                           \
682                 "12:    clear.d [%0+]\n",               \
683                         FIXUP                           \
684                 "13:    addq 4,%1\n",                   \
685                         TENTRY                          \
686                 "       .dword 12b,13b\n")
687
688 #define __asm_clear_24(to, ret) \
689         __asm_clear_24x_cont(to, ret, "", "", "")
690
691 /*
692  * Return the size of a string (including the ending 0)
693  *
694  * Return length of string in userspace including terminating 0
695  * or 0 for error.  Return a value greater than N if too long.
696  */
697
698 static inline long
699 strnlen_user(const char *s, long n)
700 {
701         long res, tmp1;
702
703         if (!access_ok(VERIFY_READ, s, 0))
704                 return 0;
705
706         /*
707          * This code is deduced from:
708          *
709          *      tmp1 = n;
710          *      while (tmp1-- > 0 && *s++)
711          *        ;
712          *
713          *      res = n - tmp1;
714          *
715          *  (with tweaks).
716          */
717
718         __asm__ __volatile__ (
719                 "       move.d %1,$acr\n"
720                 "       cmpq 0,$acr\n"
721                 "0:\n"
722                 "       ble 1f\n"
723                 "       subq 1,$acr\n"
724
725                 "4:     test.b [%0+]\n"
726                 "       bne 0b\n"
727                 "       cmpq 0,$acr\n"
728                 "1:\n"
729                 "       move.d %1,%0\n"
730                 "       sub.d $acr,%0\n"
731                 "2:\n"
732                 "       .section .fixup,\"ax\"\n"
733
734                 "3:     jump 2b\n"
735                 "       clear.d %0\n"
736
737                 "       .previous\n"
738                 "       .section __ex_table,\"a\"\n"
739                 "       .dword 4b,3b\n"
740                 "       .previous\n"
741                 : "=r" (res), "=r" (tmp1)
742                 : "0" (s), "1" (n)
743                 : "acr");
744
745         return res;
746 }
747
748 #endif