1 files changed, 85 insertions, 83 deletions

diff --git a/arch/s390/include/asm/system.h b/arch/s390/include/asm/system.h
index 379661d2f81a..67ee6c3c6bb3 100644
--- a/arch/s390/include/asm/system.h
+++ b/arch/s390/include/asm/system.h
@@ -24,65 +24,65 @@ extern struct task_struct *__switch_to(void *, void *);
 static inline void save_fp_regs(s390_fp_regs *fpregs)
 {
         asm volatile(
-                "       std     0,8(%1)\n"
-                "       std     2,24(%1)\n"
-                "       std     4,40(%1)\n"
-                "       std     6,56(%1)"
-                : "=m" (*fpregs) : "a" (fpregs), "m" (*fpregs) : "memory");
+                "       std     0,%O0+8(%R0)\n"
+                "       std     2,%O0+24(%R0)\n"
+                "       std     4,%O0+40(%R0)\n"
+                "       std     6,%O0+56(%R0)"
+                : "=Q" (*fpregs) : "Q" (*fpregs));
         if (!MACHINE_HAS_IEEE)
                 return;
         asm volatile(
-                "       stfpc   0(%1)\n"
-                "       std     1,16(%1)\n"
-                "       std     3,32(%1)\n"
-                "       std     5,48(%1)\n"
-                "       std     7,64(%1)\n"
-                "       std     8,72(%1)\n"
-                "       std     9,80(%1)\n"
-                "       std     10,88(%1)\n"
-                "       std     11,96(%1)\n"
-                "       std     12,104(%1)\n"
-                "       std     13,112(%1)\n"
-                "       std     14,120(%1)\n"
-                "       std     15,128(%1)\n"
-                : "=m" (*fpregs) : "a" (fpregs), "m" (*fpregs) : "memory");
+                "       stfpc   %0\n"
+                "       std     1,%O0+16(%R0)\n"
+                "       std     3,%O0+32(%R0)\n"
+                "       std     5,%O0+48(%R0)\n"
+                "       std     7,%O0+64(%R0)\n"
+                "       std     8,%O0+72(%R0)\n"
+                "       std     9,%O0+80(%R0)\n"
+                "       std     10,%O0+88(%R0)\n"
+                "       std     11,%O0+96(%R0)\n"
+                "       std     12,%O0+104(%R0)\n"
+                "       std     13,%O0+112(%R0)\n"
+                "       std     14,%O0+120(%R0)\n"
+                "       std     15,%O0+128(%R0)\n"
+                : "=Q" (*fpregs) : "Q" (*fpregs));
 }
 
 static inline void restore_fp_regs(s390_fp_regs *fpregs)
 {
         asm volatile(
-                "       ld      0,8(%0)\n"
-                "       ld      2,24(%0)\n"
-                "       ld      4,40(%0)\n"
-                "       ld      6,56(%0)"
-                : : "a" (fpregs), "m" (*fpregs));
+                "       ld      0,%O0+8(%R0)\n"
+                "       ld      2,%O0+24(%R0)\n"
+                "       ld      4,%O0+40(%R0)\n"
+                "       ld      6,%O0+56(%R0)"
+                : : "Q" (*fpregs));
         if (!MACHINE_HAS_IEEE)
                 return;
         asm volatile(
-                "       lfpc    0(%0)\n"
-                "       ld      1,16(%0)\n"
-                "       ld      3,32(%0)\n"
-                "       ld      5,48(%0)\n"
-                "       ld      7,64(%0)\n"
-                "       ld      8,72(%0)\n"
-                "       ld      9,80(%0)\n"
-                "       ld      10,88(%0)\n"
-                "       ld      11,96(%0)\n"
-                "       ld      12,104(%0)\n"
-                "       ld      13,112(%0)\n"
-                "       ld      14,120(%0)\n"
-                "       ld      15,128(%0)\n"
-                : : "a" (fpregs), "m" (*fpregs));
+                "       lfpc    %0\n"
+                "       ld      1,%O0+16(%R0)\n"
+                "       ld      3,%O0+32(%R0)\n"
+                "       ld      5,%O0+48(%R0)\n"
+                "       ld      7,%O0+64(%R0)\n"
+                "       ld      8,%O0+72(%R0)\n"
+                "       ld      9,%O0+80(%R0)\n"
+                "       ld      10,%O0+88(%R0)\n"
+                "       ld      11,%O0+96(%R0)\n"
+                "       ld      12,%O0+104(%R0)\n"
+                "       ld      13,%O0+112(%R0)\n"
+                "       ld      14,%O0+120(%R0)\n"
+                "       ld      15,%O0+128(%R0)\n"
+                : : "Q" (*fpregs));
 }
 
 static inline void save_access_regs(unsigned int *acrs)
 {
-        asm volatile("stam 0,15,0(%0)" : : "a" (acrs) : "memory");
+        asm volatile("stam 0,15,%0" : "=Q" (*acrs));
 }
 
 static inline void restore_access_regs(unsigned int *acrs)
 {
-        asm volatile("lam 0,15,0(%0)" : : "a" (acrs));
+        asm volatile("lam 0,15,%0" : : "Q" (*acrs));
 }
 
 #define switch_to(prev,next,last) do {                                       \
@@ -139,48 +139,48 @@ static inline unsigned long __xchg(unsigned long x, void * ptr, int size)
                 shift = (3 ^ (addr & 3)) << 3;
                 addr ^= addr & 3;
                 asm volatile(
-                        "       l       %0,0(%4)\n"
+                        "       l       %0,%4\n"
                         "0:     lr      0,%0\n"
                         "       nr      0,%3\n"
                         "       or      0,%2\n"
-                        "       cs      %0,0,0(%4)\n"
+                        "       cs      %0,0,%4\n"
                         "       jl      0b\n"
-                        : "=&d" (old), "=m" (*(int *) addr)
-                        : "d" (x << shift), "d" (~(255 << shift)), "a" (addr),
-                          "m" (*(int *) addr) : "memory", "cc", "0");
+                        : "=&d" (old), "=Q" (*(int *) addr)
+                        : "d" (x << shift), "d" (~(255 << shift)),
+                          "Q" (*(int *) addr) : "memory", "cc", "0");
                 return old >> shift;
         case 2:
                 addr = (unsigned long) ptr;
                 shift = (2 ^ (addr & 2)) << 3;
                 addr ^= addr & 2;
                 asm volatile(
-                        "       l       %0,0(%4)\n"
+                        "       l       %0,%4\n"
                         "0:     lr      0,%0\n"
                         "       nr      0,%3\n"
                         "       or      0,%2\n"
-                        "       cs      %0,0,0(%4)\n"
+                        "       cs      %0,0,%4\n"
                         "       jl      0b\n"
-                        : "=&d" (old), "=m" (*(int *) addr)
-                        : "d" (x << shift), "d" (~(65535 << shift)), "a" (addr),
-                          "m" (*(int *) addr) : "memory", "cc", "0");
+                        : "=&d" (old), "=Q" (*(int *) addr)
+                        : "d" (x << shift), "d" (~(65535 << shift)),
+                          "Q" (*(int *) addr) : "memory", "cc", "0");
                 return old >> shift;
         case 4:
                 asm volatile(
-                        "       l       %0,0(%3)\n"
-                        "0:     cs      %0,%2,0(%3)\n"
+                        "       l       %0,%3\n"
+                        "0:     cs      %0,%2,%3\n"
                         "       jl      0b\n"
-                        : "=&d" (old), "=m" (*(int *) ptr)
-                        : "d" (x), "a" (ptr), "m" (*(int *) ptr)
+                        : "=&d" (old), "=Q" (*(int *) ptr)
+                        : "d" (x), "Q" (*(int *) ptr)
                         : "memory", "cc");
                 return old;
 #ifdef __s390x__
         case 8:
                 asm volatile(
-                        "       lg      %0,0(%3)\n"
-                        "0:     csg     %0,%2,0(%3)\n"
+                        "       lg      %0,%3\n"
+                        "0:     csg     %0,%2,%3\n"
                         "       jl      0b\n"
                         : "=&d" (old), "=m" (*(long *) ptr)
-                        : "d" (x), "a" (ptr), "m" (*(long *) ptr)
+                        : "d" (x), "Q" (*(long *) ptr)
                         : "memory", "cc");
                 return old;
 #endif /* __s390x__ */
@@ -215,20 +215,20 @@ __cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
                 shift = (3 ^ (addr & 3)) << 3;
                 addr ^= addr & 3;
                 asm volatile(
-                        "       l       %0,0(%4)\n"
+                        "       l       %0,%2\n"
                         "0:     nr      %0,%5\n"
                         "       lr      %1,%0\n"
                         "       or      %0,%2\n"
                         "       or      %1,%3\n"
-                        "       cs      %0,%1,0(%4)\n"
+                        "       cs      %0,%1,%2\n"
                         "       jnl     1f\n"
                         "       xr      %1,%0\n"
                         "       nr      %1,%5\n"
                         "       jnz     0b\n"
                         "1:"
-                        : "=&d" (prev), "=&d" (tmp)
-                        : "d" (old << shift), "d" (new << shift), "a" (ptr),
-                          "d" (~(255 << shift))
+                        : "=&d" (prev), "=&d" (tmp), "=Q" (*(int *) ptr)
+                        : "d" (old << shift), "d" (new << shift),
+                          "d" (~(255 << shift)), "Q" (*(int *) ptr)
                         : "memory", "cc");
                 return prev >> shift;
         case 2:
@@ -236,33 +236,35 @@ __cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
                 shift = (2 ^ (addr & 2)) << 3;
                 addr ^= addr & 2;
                 asm volatile(
-                        "       l       %0,0(%4)\n"
+                        "       l       %0,%2\n"
                         "0:     nr      %0,%5\n"
                         "       lr      %1,%0\n"
                         "       or      %0,%2\n"
                         "       or      %1,%3\n"
-                        "       cs      %0,%1,0(%4)\n"
+                        "       cs      %0,%1,%2\n"
                         "       jnl     1f\n"
                         "       xr      %1,%0\n"
                         "       nr      %1,%5\n"
                         "       jnz     0b\n"
                         "1:"
-                        : "=&d" (prev), "=&d" (tmp)
-                        : "d" (old << shift), "d" (new << shift), "a" (ptr),
-                          "d" (~(65535 << shift))
+                        : "=&d" (prev), "=&d" (tmp), "=Q" (*(int *) ptr)
+                        : "d" (old << shift), "d" (new << shift),
+                          "d" (~(65535 << shift)), "Q" (*(int *) ptr)
                         : "memory", "cc");
                 return prev >> shift;
         case 4:
                 asm volatile(
-                        "       cs      %0,%2,0(%3)\n"
-                        : "=&d" (prev) : "0" (old), "d" (new), "a" (ptr)
+                        "       cs      %0,%3,%1\n"
+                        : "=&d" (prev), "=Q" (*(int *) ptr)
+                        : "0" (old), "d" (new), "Q" (*(int *) ptr)
                         : "memory", "cc");
                 return prev;
 #ifdef __s390x__
         case 8:
                 asm volatile(
-                        "       csg     %0,%2,0(%3)\n"
-                        : "=&d" (prev) : "0" (old), "d" (new), "a" (ptr)
+                        "       csg     %0,%3,%1\n"
+                        : "=&d" (prev), "=Q" (*(long *) ptr)
+                        : "0" (old), "d" (new), "Q" (*(long *) ptr)
                         : "memory", "cc");
                 return prev;
 #endif /* __s390x__ */
@@ -302,17 +304,17 @@ __cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
 #define __ctl_load(array, low, high) ({                         \
         typedef struct { char _[sizeof(array)]; } addrtype;     \
         asm volatile(                                           \
-                "       lctlg   %1,%2,0(%0)\n"                  \
-                : : "a" (&array), "i" (low), "i" (high),        \
-                    "m" (*(addrtype *)(&array)));               \
+                "       lctlg   %1,%2,%0\n"                     \
+                : : "Q" (*(addrtype *)(&array)),                \
+                    "i" (low), "i" (high));                     \
         })
 
 #define __ctl_store(array, low, high) ({                        \
         typedef struct { char _[sizeof(array)]; } addrtype;     \
         asm volatile(                                           \
-                "       stctg   %2,%3,0(%1)\n"                  \
-                : "=m" (*(addrtype *)(&array))                  \
-                : "a" (&array), "i" (low), "i" (high));         \
+                "       stctg   %1,%2,%0\n"                     \
+                : "=Q" (*(addrtype *)(&array))                  \
+                : "i" (low), "i" (high));                       \
         })
 
 #else /* __s390x__ */
@@ -320,17 +322,17 @@ __cmpxchg(volatile void *ptr, unsigned long old, unsigned long new, int size)
 #define __ctl_load(array, low, high) ({                         \
         typedef struct { char _[sizeof(array)]; } addrtype;     \
         asm volatile(                                           \
-                "       lctl    %1,%2,0(%0)\n"                  \
-                : : "a" (&array), "i" (low), "i" (high),        \
-                    "m" (*(addrtype *)(&array)));               \
+                "       lctl    %1,%2,%0\n"                     \
+                : : "Q" (*(addrtype *)(&array)),                \
+                    "i" (low), "i" (high));                     \
 })
 
 #define __ctl_store(array, low, high) ({                        \
         typedef struct { char _[sizeof(array)]; } addrtype;     \
         asm volatile(                                           \
-                "       stctl   %2,%3,0(%1)\n"                  \
-                : "=m" (*(addrtype *)(&array))                  \
-                : "a" (&array), "i" (low), "i" (high));         \
+                "       stctl   %1,%2,%0\n"                     \
+                : "=Q" (*(addrtype *)(&array))                  \
+                : "i" (low), "i" (high));                       \
         })
 
 #endif /* __s390x__ */