x86: get rid of 'rtype' argument to __put_user_goto() macro

The 'rtype' argument goes back to pre-git (and pre-BK) times, and comes
from the fact that we used to not necessarily have the same type sizes
for the arguments of the inline asm as we did for the actual accesses we
did.

So 'rtype' is the 'register type' - the override of the register size in
the inline asm when it doesn't match the actual size of the variable we
use as the output argument (for when you used "put_user()" on an "int"
value that was assigned to a byte-sized user space access etc).

That mismatch doesn't actually exist any more, and should probably never
have existed in the first place.  It's a horrid bug just waiting to
happen (using more - or less - of the variable that the compiler
expected us to use).

I think we had some odd casting going on to hide the effects of that
oddity after-the-fact, but those are long gone, and these days we should
always have the right size value in the first place, using things like

        __typeof__(*(ptr)) __pu_val = (x);

and gcc should thus have the right register size without any manual
'rtype' games.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
index bd924d6b4e6814a92b4892c8a5abb21c8651ace3..6957fdc4855bfacb5c6decc715420972af28b45e 100644 (file)
--- a/arch/x86/include/asm/uaccess.h
+++ b/arch/x86/include/asm/uaccess.h
@@ -198,7 +198,7 @@ __typeof__(__builtin_choose_expr(sizeof(x) > sizeof(0UL), 0ULL, 0UL))
                     : "A" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx")
 #else
 #define __put_user_goto_u64(x, ptr, label) \
-       __put_user_goto(x, ptr, "q", "", "er", label)
+       __put_user_goto(x, ptr, "q", "er", label)
 #define __put_user_x8(x, ptr, __ret_pu) __put_user_x(8, x, ptr, __ret_pu)
 #endif
 
@@ -262,13 +262,13 @@ do {                                                                      \
        __chk_user_ptr(ptr);                                            \
        switch (size) {                                                 \
        case 1:                                                         \
-               __put_user_goto(x, ptr, "b", "b", "iq", label); \
+               __put_user_goto(x, ptr, "b", "iq", label);              \
                break;                                                  \
        case 2:                                                         \
-               __put_user_goto(x, ptr, "w", "w", "ir", label);         \
+               __put_user_goto(x, ptr, "w", "ir", label);              \
                break;                                                  \
        case 4:                                                         \
-               __put_user_goto(x, ptr, "l", "k", "ir", label);         \
+               __put_user_goto(x, ptr, "l", "ir", label);              \
                break;                                                  \
        case 8:                                                         \
                __put_user_goto_u64(x, ptr, label);                     \
@@ -376,10 +376,10 @@ struct __large_struct { unsigned long buf[100]; };
  * we do not write to any memory gcc knows about, so there are no
  * aliasing issues.
  */
-#define __put_user_goto(x, addr, itype, rtype, ltype, label)   \
+#define __put_user_goto(x, addr, itype, ltype, label)                  \
        asm_volatile_goto("\n"                                          \
-               "1:     mov"itype" %"rtype"0,%1\n"                      \
-               _ASM_EXTABLE_UA(1b, %l2)                                        \
+               "1:     mov"itype" %0,%1\n"                             \
+               _ASM_EXTABLE_UA(1b, %l2)                                \
                : : ltype(x), "m" (__m(addr))                           \
                : : label)