From 77fb132a1dc3780a57d8a1e889b366f0492963a5 Mon Sep 17 00:00:00 2001

From: Blue Swirl <blauwirbel@gmail.com>

Date: Sun, 2 Sep 2012 07:33:40 +0000

Subject: [PATCH] target-s390x: switch to AREG0 free mode

Add an explicit CPUState parameter instead of relying on AREG0.

Remove temporary wrappers and switch to AREG0 free mode.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

[agraf: fix conflicts]

Signed-off-by: Alexander Graf <agraf@suse.de>

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>

---

 configure                  |   2 +-

 target-s390x/Makefile.objs |   2 -

 target-s390x/cpu.h         |  10 --

 target-s390x/fpu_helper.c  |   3 +-

 target-s390x/helper.c      |   6 +-

 target-s390x/helper.h      |  78 +++++------

 target-s390x/mem_helper.c  | 338 ++++++++++++++++++++-------------------------

 target-s390x/misc_helper.c |   3 -

 target-s390x/translate.c   |  88 ++++++------

 9 files changed, 239 insertions(+), 291 deletions(-)

diff --git a/configure b/configure

index bf3acc8..3ad6f74 100755

--- a/configure

+++ b/configure

@@ -3839,7 +3839,7 @@ symlink "$source_path/Makefile.target" "$target_dir/Makefile"

 case "$target_arch2" in

-  alpha | i386 | or32 | sparc* | x86_64 | xtensa* | ppc*)

+  alpha | i386 | or32 | s390x | sparc* | x86_64 | xtensa* | ppc*)

     echo "CONFIG_TCG_PASS_AREG0=y" >> $config_target_mak

   ;;

 esac

diff --git a/target-s390x/Makefile.objs b/target-s390x/Makefile.objs

index 156d946..e728abf 100644

--- a/target-s390x/Makefile.objs

+++ b/target-s390x/Makefile.objs

@@ -2,5 +2,3 @@ obj-y += translate.o helper.o cpu.o interrupt.o

 obj-y += int_helper.o fpu_helper.o cc_helper.o mem_helper.o misc_helper.o

 obj-$(CONFIG_SOFTMMU) += machine.o

 obj-$(CONFIG_KVM) += kvm.o

-

-$(obj)/mem_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)

diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h

index 9b7a2e3..ed81af3 100644

--- a/target-s390x/cpu.h

+++ b/target-s390x/cpu.h

@@ -1008,14 +1008,4 @@ uint32_t set_cc_nz_f64(float64 v);

 /* misc_helper.c */

 void program_interrupt(CPUS390XState *env, uint32_t code, int ilc);

-/* temporary wrappers */

-uint32_t cpu_ldub_data(CPUS390XState *env, target_ulong ptr);

-uint32_t cpu_lduw_data(CPUS390XState *env, target_ulong ptr);

-uint32_t cpu_ldl_data(CPUS390XState *env, target_ulong ptr);

-uint64_t cpu_ldq_data(CPUS390XState *env, target_ulong ptr);

-

-void cpu_stb_data(CPUS390XState *env, target_ulong ptr, uint32_t data);

-void cpu_stw_data(CPUS390XState *env, target_ulong ptr, uint32_t data);

-void cpu_stl_data(CPUS390XState *env, target_ulong ptr, uint32_t data);

-void cpu_stq_data(CPUS390XState *env, target_ulong ptr, uint64_t data);

 #endif

diff --git a/target-s390x/fpu_helper.c b/target-s390x/fpu_helper.c

index e235419..ee9420d 100644

--- a/target-s390x/fpu_helper.c

+++ b/target-s390x/fpu_helper.c

@@ -21,8 +21,7 @@

 #include "cpu.h"

 #include "helper.h"

-/* temporarily disabled due to wrapper use */

-#if 0 && !defined(CONFIG_USER_ONLY)

+#if !defined(CONFIG_USER_ONLY)

 #include "softmmu_exec.h"

 #endif

diff --git a/target-s390x/helper.c b/target-s390x/helper.c

index d98e6d9..a5741ec 100644

--- a/target-s390x/helper.c

+++ b/target-s390x/helper.c

@@ -499,14 +499,14 @@ static void do_program_interrupt(CPUS390XState *env)

     switch (ilc) {

     case ILC_LATER:

-        ilc = get_ilc(ldub_code(env->psw.addr));

+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr));

         break;

     case ILC_LATER_INC:

-        ilc = get_ilc(ldub_code(env->psw.addr));

+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr));

         env->psw.addr += ilc * 2;

         break;

     case ILC_LATER_INC_2:

-        ilc = get_ilc(ldub_code(env->psw.addr)) * 2;

+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr)) * 2;

         env->psw.addr += ilc;

         break;

     }

diff --git a/target-s390x/helper.h b/target-s390x/helper.h

index f4e0b37..5419f37 100644

--- a/target-s390x/helper.h

+++ b/target-s390x/helper.h

@@ -1,17 +1,17 @@

 #include "def-helper.h"

 DEF_HELPER_2(exception, void, env, i32)

-DEF_HELPER_3(nc, i32, i32, i64, i64)

-DEF_HELPER_3(oc, i32, i32, i64, i64)

-DEF_HELPER_3(xc, i32, i32, i64, i64)

-DEF_HELPER_3(mvc, void, i32, i64, i64)

-DEF_HELPER_3(clc, i32, i32, i64, i64)

-DEF_HELPER_2(mvcl, i32, i32, i32)

+DEF_HELPER_4(nc, i32, env, i32, i64, i64)

+DEF_HELPER_4(oc, i32, env, i32, i64, i64)

+DEF_HELPER_4(xc, i32, env, i32, i64, i64)

+DEF_HELPER_4(mvc, void, env, i32, i64, i64)

+DEF_HELPER_4(clc, i32, env, i32, i64, i64)

+DEF_HELPER_3(mvcl, i32, env, i32, i32)

 DEF_HELPER_FLAGS_1(set_cc_comp_s32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32)

 DEF_HELPER_FLAGS_1(set_cc_comp_s64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64)

 DEF_HELPER_FLAGS_2(set_cc_icm, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32)

-DEF_HELPER_3(clm, i32, i32, i32, i64)

-DEF_HELPER_3(stcm, void, i32, i32, i64)

+DEF_HELPER_4(clm, i32, env, i32, i32, i64)

+DEF_HELPER_4(stcm, void, env, i32, i32, i64)

 DEF_HELPER_3(mlg, void, env, i32, i64)

 DEF_HELPER_3(dlg, void, env, i32, i64)

 DEF_HELPER_FLAGS_3(set_cc_add64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64, s64, s64)

@@ -22,27 +22,27 @@ DEF_HELPER_FLAGS_3(set_cc_sub64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64, s64, s6

 DEF_HELPER_FLAGS_3(set_cc_subu64, TCG_CALL_PURE|TCG_CALL_CONST, i32, i64, i64, i64)

 DEF_HELPER_FLAGS_3(set_cc_sub32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32, s32, s32)

 DEF_HELPER_FLAGS_3(set_cc_subu32, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32, i32)

-DEF_HELPER_3(srst, i32, i32, i32, i32)

-DEF_HELPER_3(clst, i32, i32, i32, i32)

-DEF_HELPER_3(mvpg, void, i64, i64, i64)

-DEF_HELPER_3(mvst, void, i32, i32, i32)

-DEF_HELPER_3(csg, i32, i32, i64, i32)

-DEF_HELPER_3(cdsg, i32, i32, i64, i32)

-DEF_HELPER_3(cs, i32, i32, i64, i32)

-DEF_HELPER_4(ex, i32, i32, i64, i64, i64)

+DEF_HELPER_4(srst, i32, env, i32, i32, i32)

+DEF_HELPER_4(clst, i32, env, i32, i32, i32)

+DEF_HELPER_4(mvpg, void, env, i64, i64, i64)

+DEF_HELPER_4(mvst, void, env, i32, i32, i32)

+DEF_HELPER_4(csg, i32, env, i32, i64, i32)

+DEF_HELPER_4(cdsg, i32, env, i32, i64, i32)

+DEF_HELPER_4(cs, i32, env, i32, i64, i32)

+DEF_HELPER_5(ex, i32, env, i32, i64, i64, i64)

 DEF_HELPER_FLAGS_1(abs_i32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32)

 DEF_HELPER_FLAGS_1(nabs_i32, TCG_CALL_PURE|TCG_CALL_CONST, s32, s32)

 DEF_HELPER_FLAGS_1(abs_i64, TCG_CALL_PURE|TCG_CALL_CONST, i64, s64)

 DEF_HELPER_FLAGS_1(nabs_i64, TCG_CALL_PURE|TCG_CALL_CONST, s64, s64)

-DEF_HELPER_3(stcmh, void, i32, i64, i32)

-DEF_HELPER_3(icmh, i32, i32, i64, i32)

+DEF_HELPER_4(stcmh, void, env, i32, i64, i32)

+DEF_HELPER_4(icmh, i32, env, i32, i64, i32)

 DEF_HELPER_3(ipm, void, env, i32, i32)

 DEF_HELPER_FLAGS_3(addc_u32, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32, i32)

 DEF_HELPER_FLAGS_3(set_cc_addc_u64, TCG_CALL_PURE|TCG_CALL_CONST, i32, i64, i64, i64)

-DEF_HELPER_3(stam, void, i32, i64, i32)

-DEF_HELPER_3(lam, void, i32, i64, i32)

-DEF_HELPER_3(mvcle, i32, i32, i64, i32)

-DEF_HELPER_3(clcle, i32, i32, i64, i32)

+DEF_HELPER_4(stam, void, env, i32, i64, i32)

+DEF_HELPER_4(lam, void, env, i32, i64, i32)

+DEF_HELPER_4(mvcle, i32, env, i32, i64, i32)

+DEF_HELPER_4(clcle, i32, env, i32, i64, i32)

 DEF_HELPER_4(slb, i32, env, i32, i32, i32)

 DEF_HELPER_5(slbg, i32, env, i32, i32, i64, i64)

 DEF_HELPER_3(cefbr, void, env, i32, s32)

@@ -110,8 +110,8 @@ DEF_HELPER_FLAGS_3(tcxb, TCG_CALL_PURE, i32, env, i32, i64)

 DEF_HELPER_3(flogr, i32, env, i32, i64)

 DEF_HELPER_3(sqdbr, void, env, i32, i32)

 DEF_HELPER_FLAGS_1(cvd, TCG_CALL_PURE|TCG_CALL_CONST, i64, s32)

-DEF_HELPER_3(unpk, void, i32, i64, i64)

-DEF_HELPER_3(tr, void, i32, i64, i64)

+DEF_HELPER_4(unpk, void, env, i32, i64, i64)

+DEF_HELPER_4(tr, void, env, i32, i64, i64)

 DEF_HELPER_3(servc, i32, env, i32, i64)

 DEF_HELPER_4(diag, i64, env, i32, i64, i64)

@@ -127,24 +127,24 @@ DEF_HELPER_FLAGS_2(stckc, TCG_CALL_CONST, void, env, i64)

 DEF_HELPER_FLAGS_2(spt, TCG_CALL_CONST, void, env, i64)

 DEF_HELPER_FLAGS_2(stpt, TCG_CALL_CONST, void, env, i64)

 DEF_HELPER_4(stsi, i32, env, i64, i32, i32)

-DEF_HELPER_3(lctl, void, i32, i64, i32)

-DEF_HELPER_3(lctlg, void, i32, i64, i32)

-DEF_HELPER_3(stctl, void, i32, i64, i32)

-DEF_HELPER_3(stctg, void, i32, i64, i32)

+DEF_HELPER_4(lctl, void, env, i32, i64, i32)

+DEF_HELPER_4(lctlg, void, env, i32, i64, i32)

+DEF_HELPER_4(stctl, void, env, i32, i64, i32)

+DEF_HELPER_4(stctg, void, env, i32, i64, i32)

 DEF_HELPER_FLAGS_2(tprot, TCG_CALL_CONST, i32, i64, i64)

-DEF_HELPER_FLAGS_1(iske, TCG_CALL_PURE|TCG_CALL_CONST, i64, i64)

-DEF_HELPER_FLAGS_2(sske, TCG_CALL_CONST, void, i32, i64)

-DEF_HELPER_FLAGS_2(rrbe, TCG_CALL_CONST, i32, i32, i64)

-DEF_HELPER_2(csp, i32, i32, i32)

-DEF_HELPER_3(mvcs, i32, i64, i64, i64)

-DEF_HELPER_3(mvcp, i32, i64, i64, i64)

+DEF_HELPER_FLAGS_2(iske, TCG_CALL_PURE|TCG_CALL_CONST, i64, env, i64)

+DEF_HELPER_FLAGS_3(sske, TCG_CALL_CONST, void, env, i32, i64)

+DEF_HELPER_FLAGS_3(rrbe, TCG_CALL_CONST, i32, env, i32, i64)

+DEF_HELPER_3(csp, i32, env, i32, i32)

+DEF_HELPER_4(mvcs, i32, env, i64, i64, i64)

+DEF_HELPER_4(mvcp, i32, env, i64, i64, i64)

 DEF_HELPER_4(sigp, i32, env, i64, i32, i64)

 DEF_HELPER_2(sacf, void, env, i64)

-DEF_HELPER_FLAGS_2(ipte, TCG_CALL_CONST, void, i64, i64)

-DEF_HELPER_FLAGS_0(ptlb, TCG_CALL_CONST, void)

-DEF_HELPER_2(lra, i32, i64, i32)

-DEF_HELPER_2(stura, void, i64, i32)

-DEF_HELPER_2(cksm, void, i32, i32)

+DEF_HELPER_FLAGS_3(ipte, TCG_CALL_CONST, void, env, i64, i64)

+DEF_HELPER_FLAGS_1(ptlb, TCG_CALL_CONST, void, env)

+DEF_HELPER_3(lra, i32, env, i64, i32)

+DEF_HELPER_3(stura, void, env, i64, i32)

+DEF_HELPER_3(cksm, void, env, i32, i32)

 DEF_HELPER_FLAGS_5(calc_cc, TCG_CALL_PURE|TCG_CALL_CONST,

                    i32, env, i32, i64, i64, i64)

diff --git a/target-s390x/mem_helper.c b/target-s390x/mem_helper.c

index 52f2602..b21b37c 100644

--- a/target-s390x/mem_helper.c

+++ b/target-s390x/mem_helper.c

@@ -19,7 +19,6 @@

  */

 #include "cpu.h"

-#include "dyngen-exec.h"

 #include "helper.h"

 /*****************************************************************************/

@@ -45,15 +44,12 @@

    NULL, it means that the function was called in C code (i.e. not

    from generated code or from helper.c) */

 /* XXX: fix it to restore all registers */

-void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,

+void tlb_fill(CPUS390XState *env, target_ulong addr, int is_write, int mmu_idx,

               uintptr_t retaddr)

 {

     TranslationBlock *tb;

-    CPUS390XState *saved_env;

     int ret;

-    saved_env = env;

-    env = env1;

     ret = cpu_s390x_handle_mmu_fault(env, addr, is_write, mmu_idx);

     if (unlikely(ret != 0)) {

         if (likely(retaddr)) {

@@ -67,7 +63,6 @@ void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,

         }

         cpu_loop_exit(env);

     }

-    env = saved_env;

 }

 #endif

@@ -90,7 +85,7 @@ static void mvc_fast_memset(CPUS390XState *env, uint32_t l, uint64_t dest,

     int flags;

     if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {

-        stb(dest, byte);

+        cpu_stb_data(env, dest, byte);

         cpu_abort(env, "should never reach here");

     }

     dest_phys |= dest & ~TARGET_PAGE_MASK;

@@ -114,13 +109,13 @@ static void mvc_fast_memmove(CPUS390XState *env, uint32_t l, uint64_t dest,

     int flags;

     if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {

-        stb(dest, 0);

+        cpu_stb_data(env, dest, 0);

         cpu_abort(env, "should never reach here");

     }

     dest_phys |= dest & ~TARGET_PAGE_MASK;

     if (mmu_translate(env, src, 0, asc, &src_phys, &flags)) {

-        ldub(src);

+        cpu_ldub_data(env, src);

         cpu_abort(env, "should never reach here");

     }

     src_phys |= src & ~TARGET_PAGE_MASK;

@@ -136,7 +131,8 @@ static void mvc_fast_memmove(CPUS390XState *env, uint32_t l, uint64_t dest,

 #endif

 /* and on array */

-uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)

+uint32_t HELPER(nc)(CPUS390XState *env, uint32_t l, uint64_t dest,

+                    uint64_t src)

 {

     int i;

     unsigned char x;

@@ -145,17 +141,18 @@ uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

                __func__, l, dest, src);

     for (i = 0; i <= l; i++) {

-        x = ldub(dest + i) & ldub(src + i);

+        x = cpu_ldub_data(env, dest + i) & cpu_ldub_data(env, src + i);

         if (x) {

             cc = 1;

         }

-        stb(dest + i, x);

+        cpu_stb_data(env, dest + i, x);

     }

     return cc;

 }

 /* xor on array */

-uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)

+uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest,

+                    uint64_t src)

 {

     int i;

     unsigned char x;

@@ -179,17 +176,18 @@ uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)

 #endif

     for (i = 0; i <= l; i++) {

-        x = ldub(dest + i) ^ ldub(src + i);

+        x = cpu_ldub_data(env, dest + i) ^ cpu_ldub_data(env, src + i);

         if (x) {

             cc = 1;

         }

-        stb(dest + i, x);

+        cpu_stb_data(env, dest + i, x);

     }

     return cc;

 }

 /* or on array */

-uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)

+uint32_t HELPER(oc)(CPUS390XState *env, uint32_t l, uint64_t dest,

+                    uint64_t src)

 {

     int i;

     unsigned char x;

@@ -198,17 +196,17 @@ uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)

     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",

                __func__, l, dest, src);

     for (i = 0; i <= l; i++) {

-        x = ldub(dest + i) | ldub(src + i);

+        x = cpu_ldub_data(env, dest + i) | cpu_ldub_data(env, src + i);

         if (x) {

             cc = 1;

         }

-        stb(dest + i, x);

+        cpu_stb_data(env, dest + i, x);

     }

     return cc;

 }

 /* memmove */

-void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

+void HELPER(mvc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)

 {

     int i = 0;

     int x = 0;

@@ -222,7 +220,7 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

         (src & TARGET_PAGE_MASK) == ((src + l) & TARGET_PAGE_MASK) &&

         (dest & TARGET_PAGE_MASK) == ((dest + l) & TARGET_PAGE_MASK)) {

         if (dest == (src + 1)) {

-            mvc_fast_memset(env, l + 1, dest, ldub(src));

+            mvc_fast_memset(env, l + 1, dest, cpu_ldub_data(env, src));

             return;

         } else if ((src & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) {

             mvc_fast_memmove(env, l + 1, dest, src);

@@ -231,7 +229,7 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

     }

 #else

     if (dest == (src + 1)) {

-        memset(g2h(dest), ldub(src), l + 1);

+        memset(g2h(dest), cpu_ldub_data(env, src), l + 1);

         return;

     } else {

         memmove(g2h(dest), g2h(src), l + 1);

@@ -242,19 +240,19 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)

     /* handle the parts that fit into 8-byte loads/stores */

     if (dest != (src + 1)) {

         for (i = 0; i < l_64; i++) {

-            stq(dest + x, ldq(src + x));

+            cpu_stq_data(env, dest + x, cpu_ldq_data(env, src + x));

             x += 8;

         }

     }

     /* slow version crossing pages with byte accesses */

     for (i = x; i <= l; i++) {

-        stb(dest + i, ldub(src + i));

+        cpu_stb_data(env, dest + i, cpu_ldub_data(env, src + i));

     }

 }

 /* compare unsigned byte arrays */

-uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

+uint32_t HELPER(clc)(CPUS390XState *env, uint32_t l, uint64_t s1, uint64_t s2)

 {

     int i;

     unsigned char x, y;

@@ -263,8 +261,8 @@ uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

     HELPER_LOG("%s l %d s1 %" PRIx64 " s2 %" PRIx64 "\n",

                __func__, l, s1, s2);

     for (i = 0; i <= l; i++) {

-        x = ldub(s1 + i);

-        y = ldub(s2 + i);

+        x = cpu_ldub_data(env, s1 + i);

+        y = cpu_ldub_data(env, s2 + i);

         HELPER_LOG("%02x (%c)/%02x (%c) ", x, x, y, y);

         if (x < y) {

             cc = 1;

@@ -281,7 +279,8 @@ uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)

 }

 /* compare logical under mask */

-uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

+uint32_t HELPER(clm)(CPUS390XState *env, uint32_t r1, uint32_t mask,

+                     uint64_t addr)

 {

     uint8_t r, d;

     uint32_t cc;

@@ -291,7 +290,7 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

     cc = 0;

     while (mask) {

         if (mask & 8) {

-            d = ldub(addr);

+            d = cpu_ldub_data(env, addr);

             r = (r1 & 0xff000000UL) >> 24;

             HELPER_LOG("mask 0x%x %02x/%02x (0x%" PRIx64 ") ", mask, r, d,

                        addr);

@@ -312,7 +311,8 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)

 }

 /* store character under mask */

-void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)

+void HELPER(stcm)(CPUS390XState *env, uint32_t r1, uint32_t mask,

+                  uint64_t addr)

 {

     uint8_t r;

@@ -321,7 +321,7 @@ void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)

     while (mask) {

         if (mask & 8) {

             r = (r1 & 0xff000000UL) >> 24;

-            stb(addr, r);

+            cpu_stb_data(env, addr, r);

             HELPER_LOG("mask 0x%x %02x (0x%lx) ", mask, r, addr);

             addr++;

         }

@@ -331,7 +331,7 @@ void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)

     HELPER_LOG("\n");

 }

-static inline uint64_t get_address(int x2, int b2, int d2)

+static inline uint64_t get_address(CPUS390XState *env, int x2, int b2, int d2)

 {

     uint64_t r = d2;

@@ -351,7 +351,7 @@ static inline uint64_t get_address(int x2, int b2, int d2)

     return r;

 }

-static inline uint64_t get_address_31fix(int reg)

+static inline uint64_t get_address_31fix(CPUS390XState *env, int reg)

 {

     uint64_t r = env->regs[reg];

@@ -364,18 +364,18 @@ static inline uint64_t get_address_31fix(int reg)

 }

 /* search string (c is byte to search, r2 is string, r1 end of string) */

-uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)

+uint32_t HELPER(srst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)

 {

     uint64_t i;

     uint32_t cc = 2;

-    uint64_t str = get_address_31fix(r2);

-    uint64_t end = get_address_31fix(r1);

+    uint64_t str = get_address_31fix(env, r2);

+    uint64_t end = get_address_31fix(env, r1);

     HELPER_LOG("%s: c %d *r1 0x%" PRIx64 " *r2 0x%" PRIx64 "\n", __func__,

                c, env->regs[r1], env->regs[r2]);

     for (i = str; i != end; i++) {

-        if (ldub(i) == c) {

+        if (cpu_ldub_data(env, i) == c) {

             env->regs[r1] = i;

             cc = 1;

             break;

@@ -386,10 +386,10 @@ uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)

 }

 /* unsigned string compare (c is string terminator) */

-uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)

+uint32_t HELPER(clst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)

 {

-    uint64_t s1 = get_address_31fix(r1);

-    uint64_t s2 = get_address_31fix(r2);

+    uint64_t s1 = get_address_31fix(env, r1);

+    uint64_t s2 = get_address_31fix(env, r2);

     uint8_t v1, v2;

     uint32_t cc;

@@ -401,8 +401,8 @@ uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)

     }

 #endif

     for (;;) {

-        v1 = ldub(s1);

-        v2 = ldub(s2);

+        v1 = cpu_ldub_data(env, s1);

+        v2 = cpu_ldub_data(env, s2);

         if ((v1 == c || v2 == c) || (v1 != v2)) {

             break;

         }

@@ -422,14 +422,14 @@ uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)

 }

 /* move page */

-void HELPER(mvpg)(uint64_t r0, uint64_t r1, uint64_t r2)

+void HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)

 {

     /* XXX missing r0 handling */

 #ifdef CONFIG_USER_ONLY

     int i;

     for (i = 0; i < TARGET_PAGE_SIZE; i++) {

-        stb(r1 + i, ldub(r2 + i));

+        cpu_stb_data(env, r1 + i, cpu_ldub_data(env, r2 + i));

     }

 #else

     mvc_fast_memmove(env, TARGET_PAGE_SIZE, r1, r2);

@@ -437,10 +437,10 @@ void HELPER(mvpg)(uint64_t r0, uint64_t r1, uint64_t r2)

 }

 /* string copy (c is string terminator) */

-void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)

+void HELPER(mvst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)

 {

-    uint64_t dest = get_address_31fix(r1);

-    uint64_t src = get_address_31fix(r2);

+    uint64_t dest = get_address_31fix(env, r1);

+    uint64_t src = get_address_31fix(env, r2);

     uint8_t v;

     c = c & 0xff;

@@ -451,8 +451,8 @@ void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)

     }

 #endif

     for (;;) {

-        v = ldub(src);

-        stb(dest, v);

+        v = cpu_ldub_data(env, src);

+        cpu_stb_data(env, dest, v);

         if (v == c) {

             break;

         }

@@ -463,15 +463,15 @@ void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)

 }

 /* compare and swap 64-bit */

-uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)

+uint32_t HELPER(csg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)

 {

     /* FIXME: locking? */

     uint32_t cc;

-    uint64_t v2 = ldq(a2);

+    uint64_t v2 = cpu_ldq_data(env, a2);

     if (env->regs[r1] == v2) {

         cc = 0;

-        stq(a2, env->regs[r3]);

+        cpu_stq_data(env, a2, env->regs[r3]);

     } else {

         cc = 1;

         env->regs[r1] = v2;

@@ -480,19 +480,19 @@ uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)

 }

 /* compare double and swap 64-bit */

-uint32_t HELPER(cdsg)(uint32_t r1, uint64_t a2, uint32_t r3)

+uint32_t HELPER(cdsg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)

 {

     /* FIXME: locking? */

     uint32_t cc;

-    uint64_t v2_hi = ldq(a2);

-    uint64_t v2_lo = ldq(a2 + 8);

+    uint64_t v2_hi = cpu_ldq_data(env, a2);

+    uint64_t v2_lo = cpu_ldq_data(env, a2 + 8);

     uint64_t v1_hi = env->regs[r1];

     uint64_t v1_lo = env->regs[r1 + 1];

     if ((v1_hi == v2_hi) && (v1_lo == v2_lo)) {

         cc = 0;

-        stq(a2, env->regs[r3]);

-        stq(a2 + 8, env->regs[r3 + 1]);

+        cpu_stq_data(env, a2, env->regs[r3]);

+        cpu_stq_data(env, a2 + 8, env->regs[r3 + 1]);

     } else {

         cc = 1;

         env->regs[r1] = v2_hi;

@@ -503,16 +503,16 @@ uint32_t HELPER(cdsg)(uint32_t r1, uint64_t a2, uint32_t r3)

 }

 /* compare and swap 32-bit */

-uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)

+uint32_t HELPER(cs)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)

 {

     /* FIXME: locking? */

     uint32_t cc;

-    uint32_t v2 = ldl(a2);

+    uint32_t v2 = cpu_ldl_data(env, a2);

     HELPER_LOG("%s: r1 %d a2 0x%lx r3 %d\n", __func__, r1, a2, r3);

     if (((uint32_t)env->regs[r1]) == v2) {

         cc = 0;

-        stl(a2, (uint32_t)env->regs[r3]);

+        cpu_stl_data(env, a2, (uint32_t)env->regs[r3]);

     } else {

         cc = 1;

         env->regs[r1] = (env->regs[r1] & 0xffffffff00000000ULL) | v2;

@@ -520,7 +520,8 @@ uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)

     return cc;

 }

-static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)

+static uint32_t helper_icm(CPUS390XState *env, uint32_t r1, uint64_t address,

+                           uint32_t mask)

 {

     int pos = 24; /* top of the lower half of r1 */

     uint64_t rmask = 0xff000000ULL;

@@ -531,7 +532,7 @@ static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)

     while (mask) {

         if (mask & 8) {

             env->regs[r1] &= ~rmask;

-            val = ldub(address);

+            val = cpu_ldub_data(env, address);

             if ((val & 0x80) && !ccd) {

                 cc = 1;

             }

@@ -557,9 +558,10 @@ static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)

    in other words: tricky...

    currently implemented by interpreting the cases it is most commonly used in

 */

-uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

+uint32_t HELPER(ex)(CPUS390XState *env, uint32_t cc, uint64_t v1,

+                    uint64_t addr, uint64_t ret)

 {

-    uint16_t insn = lduw_code(addr);

+    uint16_t insn = cpu_lduw_code(env, addr);

     HELPER_LOG("%s: v1 0x%lx addr 0x%lx insn 0x%x\n", __func__, v1, addr,

                insn);

@@ -567,23 +569,27 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

         uint32_t l, insn2, b1, b2, d1, d2;

         l = v1 & 0xff;

-        insn2 = ldl_code(addr + 2);

+        insn2 = cpu_ldl_code(env, addr + 2);

         b1 = (insn2 >> 28) & 0xf;

         b2 = (insn2 >> 12) & 0xf;

         d1 = (insn2 >> 16) & 0xfff;

         d2 = insn2 & 0xfff;

         switch (insn & 0xf00) {

         case 0x200:

-            helper_mvc(l, get_address(0, b1, d1), get_address(0, b2, d2));

+            helper_mvc(env, l, get_address(env, 0, b1, d1),

+                       get_address(env, 0, b2, d2));

             break;

         case 0x500:

-            cc = helper_clc(l, get_address(0, b1, d1), get_address(0, b2, d2));

+            cc = helper_clc(env, l, get_address(env, 0, b1, d1),

+                            get_address(env, 0, b2, d2));

             break;

         case 0x700:

-            cc = helper_xc(l, get_address(0, b1, d1), get_address(0, b2, d2));

+            cc = helper_xc(env, l, get_address(env, 0, b1, d1),

+                           get_address(env, 0, b2, d2));

             break;

         case 0xc00:

-            helper_tr(l, get_address(0, b1, d1), get_address(0, b2, d2));

+            helper_tr(env, l, get_address(env, 0, b1, d1),

+                      get_address(env, 0, b2, d2));

             break;

         default:

             goto abort;

@@ -599,12 +605,12 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

     } else if ((insn & 0xff00) == 0xbf00) {

         uint32_t insn2, r1, r3, b2, d2;

-        insn2 = ldl_code(addr + 2);

+        insn2 = cpu_ldl_code(env, addr + 2);

         r1 = (insn2 >> 20) & 0xf;

         r3 = (insn2 >> 16) & 0xf;

         b2 = (insn2 >> 12) & 0xf;

         d2 = insn2 & 0xfff;

-        cc = helper_icm(r1, get_address(0, b2, d2), r3);

+        cc = helper_icm(env, r1, get_address(env, 0, b2, d2), r3);

     } else {

     abort:

         cpu_abort(env, "EXECUTE on instruction prefix 0x%x not implemented\n",

@@ -614,13 +620,14 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)

 }

 /* store character under mask high operates on the upper half of r1 */

-void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)

+void HELPER(stcmh)(CPUS390XState *env, uint32_t r1, uint64_t address,

+                   uint32_t mask)

 {

     int pos = 56; /* top of the upper half of r1 */

     while (mask) {

         if (mask & 8) {

-            stb(address, (env->regs[r1] >> pos) & 0xff);

+            cpu_stb_data(env, address, (env->regs[r1] >> pos) & 0xff);