Blame 0015-target-s390x-switch-to-AREG0-free-mode.patch

5544c1
From 77fb132a1dc3780a57d8a1e889b366f0492963a5 Mon Sep 17 00:00:00 2001
5544c1
From: Blue Swirl <blauwirbel@gmail.com>
5544c1
Date: Sun, 2 Sep 2012 07:33:40 +0000
5544c1
Subject: [PATCH] target-s390x: switch to AREG0 free mode
5544c1
5544c1
Add an explicit CPUState parameter instead of relying on AREG0.
5544c1
5544c1
Remove temporary wrappers and switch to AREG0 free mode.
5544c1
5544c1
Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
5544c1
[agraf: fix conflicts]
5544c1
Signed-off-by: Alexander Graf <agraf@suse.de>
5544c1
5544c1
Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
5544c1
---
5544c1
 configure                  |   2 +-
5544c1
 target-s390x/Makefile.objs |   2 -
5544c1
 target-s390x/cpu.h         |  10 --
5544c1
 target-s390x/fpu_helper.c  |   3 +-
5544c1
 target-s390x/helper.c      |   6 +-
5544c1
 target-s390x/helper.h      |  78 +++++------
5544c1
 target-s390x/mem_helper.c  | 338 ++++++++++++++++++++-------------------------
5544c1
 target-s390x/misc_helper.c |   3 -
5544c1
 target-s390x/translate.c   |  88 ++++++------
5544c1
 9 files changed, 239 insertions(+), 291 deletions(-)
5544c1
5544c1
diff --git a/configure b/configure
5544c1
index bf3acc8..3ad6f74 100755
5544c1
--- a/configure
5544c1
+++ b/configure
5544c1
@@ -3839,7 +3839,7 @@ symlink "$source_path/Makefile.target" "$target_dir/Makefile"
5544c1
 
5544c1
 
5544c1
 case "$target_arch2" in
5544c1
-  alpha | i386 | or32 | sparc* | x86_64 | xtensa* | ppc*)
5544c1
+  alpha | i386 | or32 | s390x | sparc* | x86_64 | xtensa* | ppc*)
5544c1
     echo "CONFIG_TCG_PASS_AREG0=y" >> $config_target_mak
5544c1
   ;;
5544c1
 esac
5544c1
diff --git a/target-s390x/Makefile.objs b/target-s390x/Makefile.objs
5544c1
index 156d946..e728abf 100644
5544c1
--- a/target-s390x/Makefile.objs
5544c1
+++ b/target-s390x/Makefile.objs
5544c1
@@ -2,5 +2,3 @@ obj-y += translate.o helper.o cpu.o interrupt.o
5544c1
 obj-y += int_helper.o fpu_helper.o cc_helper.o mem_helper.o misc_helper.o
5544c1
 obj-$(CONFIG_SOFTMMU) += machine.o
5544c1
 obj-$(CONFIG_KVM) += kvm.o
5544c1
-
5544c1
-$(obj)/mem_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
5544c1
diff --git a/target-s390x/cpu.h b/target-s390x/cpu.h
5544c1
index 9b7a2e3..ed81af3 100644
5544c1
--- a/target-s390x/cpu.h
5544c1
+++ b/target-s390x/cpu.h
5544c1
@@ -1008,14 +1008,4 @@ uint32_t set_cc_nz_f64(float64 v);
5544c1
 /* misc_helper.c */
5544c1
 void program_interrupt(CPUS390XState *env, uint32_t code, int ilc);
5544c1
 
5544c1
-/* temporary wrappers */
5544c1
-uint32_t cpu_ldub_data(CPUS390XState *env, target_ulong ptr);
5544c1
-uint32_t cpu_lduw_data(CPUS390XState *env, target_ulong ptr);
5544c1
-uint32_t cpu_ldl_data(CPUS390XState *env, target_ulong ptr);
5544c1
-uint64_t cpu_ldq_data(CPUS390XState *env, target_ulong ptr);
5544c1
-
5544c1
-void cpu_stb_data(CPUS390XState *env, target_ulong ptr, uint32_t data);
5544c1
-void cpu_stw_data(CPUS390XState *env, target_ulong ptr, uint32_t data);
5544c1
-void cpu_stl_data(CPUS390XState *env, target_ulong ptr, uint32_t data);
5544c1
-void cpu_stq_data(CPUS390XState *env, target_ulong ptr, uint64_t data);
5544c1
 #endif
5544c1
diff --git a/target-s390x/fpu_helper.c b/target-s390x/fpu_helper.c
5544c1
index e235419..ee9420d 100644
5544c1
--- a/target-s390x/fpu_helper.c
5544c1
+++ b/target-s390x/fpu_helper.c
5544c1
@@ -21,8 +21,7 @@
5544c1
 #include "cpu.h"
5544c1
 #include "helper.h"
5544c1
 
5544c1
-/* temporarily disabled due to wrapper use */
5544c1
-#if 0 && !defined(CONFIG_USER_ONLY)
5544c1
+#if !defined(CONFIG_USER_ONLY)
5544c1
 #include "softmmu_exec.h"
5544c1
 #endif
5544c1
 
5544c1
diff --git a/target-s390x/helper.c b/target-s390x/helper.c
5544c1
index d98e6d9..a5741ec 100644
5544c1
--- a/target-s390x/helper.c
5544c1
+++ b/target-s390x/helper.c
5544c1
@@ -499,14 +499,14 @@ static void do_program_interrupt(CPUS390XState *env)
5544c1
 
5544c1
     switch (ilc) {
5544c1
     case ILC_LATER:
5544c1
-        ilc = get_ilc(ldub_code(env->psw.addr));
5544c1
+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr));
5544c1
         break;
5544c1
     case ILC_LATER_INC:
5544c1
-        ilc = get_ilc(ldub_code(env->psw.addr));
5544c1
+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr));
5544c1
         env->psw.addr += ilc * 2;
5544c1
         break;
5544c1
     case ILC_LATER_INC_2:
5544c1
-        ilc = get_ilc(ldub_code(env->psw.addr)) * 2;
5544c1
+        ilc = get_ilc(cpu_ldub_code(env, env->psw.addr)) * 2;
5544c1
         env->psw.addr += ilc;
5544c1
         break;
5544c1
     }
5544c1
diff --git a/target-s390x/helper.h b/target-s390x/helper.h
5544c1
index f4e0b37..5419f37 100644
5544c1
--- a/target-s390x/helper.h
5544c1
+++ b/target-s390x/helper.h
5544c1
@@ -1,17 +1,17 @@
5544c1
 #include "def-helper.h"
5544c1
 
5544c1
 DEF_HELPER_2(exception, void, env, i32)
5544c1
-DEF_HELPER_3(nc, i32, i32, i64, i64)
5544c1
-DEF_HELPER_3(oc, i32, i32, i64, i64)
5544c1
-DEF_HELPER_3(xc, i32, i32, i64, i64)
5544c1
-DEF_HELPER_3(mvc, void, i32, i64, i64)
5544c1
-DEF_HELPER_3(clc, i32, i32, i64, i64)
5544c1
-DEF_HELPER_2(mvcl, i32, i32, i32)
5544c1
+DEF_HELPER_4(nc, i32, env, i32, i64, i64)
5544c1
+DEF_HELPER_4(oc, i32, env, i32, i64, i64)
5544c1
+DEF_HELPER_4(xc, i32, env, i32, i64, i64)
5544c1
+DEF_HELPER_4(mvc, void, env, i32, i64, i64)
5544c1
+DEF_HELPER_4(clc, i32, env, i32, i64, i64)
5544c1
+DEF_HELPER_3(mvcl, i32, env, i32, i32)
5544c1
 DEF_HELPER_FLAGS_1(set_cc_comp_s32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32)
5544c1
 DEF_HELPER_FLAGS_1(set_cc_comp_s64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64)
5544c1
 DEF_HELPER_FLAGS_2(set_cc_icm, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32)
5544c1
-DEF_HELPER_3(clm, i32, i32, i32, i64)
5544c1
-DEF_HELPER_3(stcm, void, i32, i32, i64)
5544c1
+DEF_HELPER_4(clm, i32, env, i32, i32, i64)
5544c1
+DEF_HELPER_4(stcm, void, env, i32, i32, i64)
5544c1
 DEF_HELPER_3(mlg, void, env, i32, i64)
5544c1
 DEF_HELPER_3(dlg, void, env, i32, i64)
5544c1
 DEF_HELPER_FLAGS_3(set_cc_add64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64, s64, s64)
5544c1
@@ -22,27 +22,27 @@ DEF_HELPER_FLAGS_3(set_cc_sub64, TCG_CALL_PURE|TCG_CALL_CONST, i32, s64, s64, s6
5544c1
 DEF_HELPER_FLAGS_3(set_cc_subu64, TCG_CALL_PURE|TCG_CALL_CONST, i32, i64, i64, i64)
5544c1
 DEF_HELPER_FLAGS_3(set_cc_sub32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32, s32, s32)
5544c1
 DEF_HELPER_FLAGS_3(set_cc_subu32, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32, i32)
5544c1
-DEF_HELPER_3(srst, i32, i32, i32, i32)
5544c1
-DEF_HELPER_3(clst, i32, i32, i32, i32)
5544c1
-DEF_HELPER_3(mvpg, void, i64, i64, i64)
5544c1
-DEF_HELPER_3(mvst, void, i32, i32, i32)
5544c1
-DEF_HELPER_3(csg, i32, i32, i64, i32)
5544c1
-DEF_HELPER_3(cdsg, i32, i32, i64, i32)
5544c1
-DEF_HELPER_3(cs, i32, i32, i64, i32)
5544c1
-DEF_HELPER_4(ex, i32, i32, i64, i64, i64)
5544c1
+DEF_HELPER_4(srst, i32, env, i32, i32, i32)
5544c1
+DEF_HELPER_4(clst, i32, env, i32, i32, i32)
5544c1
+DEF_HELPER_4(mvpg, void, env, i64, i64, i64)
5544c1
+DEF_HELPER_4(mvst, void, env, i32, i32, i32)
5544c1
+DEF_HELPER_4(csg, i32, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(cdsg, i32, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(cs, i32, env, i32, i64, i32)
5544c1
+DEF_HELPER_5(ex, i32, env, i32, i64, i64, i64)
5544c1
 DEF_HELPER_FLAGS_1(abs_i32, TCG_CALL_PURE|TCG_CALL_CONST, i32, s32)
5544c1
 DEF_HELPER_FLAGS_1(nabs_i32, TCG_CALL_PURE|TCG_CALL_CONST, s32, s32)
5544c1
 DEF_HELPER_FLAGS_1(abs_i64, TCG_CALL_PURE|TCG_CALL_CONST, i64, s64)
5544c1
 DEF_HELPER_FLAGS_1(nabs_i64, TCG_CALL_PURE|TCG_CALL_CONST, s64, s64)
5544c1
-DEF_HELPER_3(stcmh, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(icmh, i32, i32, i64, i32)
5544c1
+DEF_HELPER_4(stcmh, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(icmh, i32, env, i32, i64, i32)
5544c1
 DEF_HELPER_3(ipm, void, env, i32, i32)
5544c1
 DEF_HELPER_FLAGS_3(addc_u32, TCG_CALL_PURE|TCG_CALL_CONST, i32, i32, i32, i32)
5544c1
 DEF_HELPER_FLAGS_3(set_cc_addc_u64, TCG_CALL_PURE|TCG_CALL_CONST, i32, i64, i64, i64)
5544c1
-DEF_HELPER_3(stam, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(lam, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(mvcle, i32, i32, i64, i32)
5544c1
-DEF_HELPER_3(clcle, i32, i32, i64, i32)
5544c1
+DEF_HELPER_4(stam, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(lam, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(mvcle, i32, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(clcle, i32, env, i32, i64, i32)
5544c1
 DEF_HELPER_4(slb, i32, env, i32, i32, i32)
5544c1
 DEF_HELPER_5(slbg, i32, env, i32, i32, i64, i64)
5544c1
 DEF_HELPER_3(cefbr, void, env, i32, s32)
5544c1
@@ -110,8 +110,8 @@ DEF_HELPER_FLAGS_3(tcxb, TCG_CALL_PURE, i32, env, i32, i64)
5544c1
 DEF_HELPER_3(flogr, i32, env, i32, i64)
5544c1
 DEF_HELPER_3(sqdbr, void, env, i32, i32)
5544c1
 DEF_HELPER_FLAGS_1(cvd, TCG_CALL_PURE|TCG_CALL_CONST, i64, s32)
5544c1
-DEF_HELPER_3(unpk, void, i32, i64, i64)
5544c1
-DEF_HELPER_3(tr, void, i32, i64, i64)
5544c1
+DEF_HELPER_4(unpk, void, env, i32, i64, i64)
5544c1
+DEF_HELPER_4(tr, void, env, i32, i64, i64)
5544c1
 
5544c1
 DEF_HELPER_3(servc, i32, env, i32, i64)
5544c1
 DEF_HELPER_4(diag, i64, env, i32, i64, i64)
5544c1
@@ -127,24 +127,24 @@ DEF_HELPER_FLAGS_2(stckc, TCG_CALL_CONST, void, env, i64)
5544c1
 DEF_HELPER_FLAGS_2(spt, TCG_CALL_CONST, void, env, i64)
5544c1
 DEF_HELPER_FLAGS_2(stpt, TCG_CALL_CONST, void, env, i64)
5544c1
 DEF_HELPER_4(stsi, i32, env, i64, i32, i32)
5544c1
-DEF_HELPER_3(lctl, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(lctlg, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(stctl, void, i32, i64, i32)
5544c1
-DEF_HELPER_3(stctg, void, i32, i64, i32)
5544c1
+DEF_HELPER_4(lctl, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(lctlg, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(stctl, void, env, i32, i64, i32)
5544c1
+DEF_HELPER_4(stctg, void, env, i32, i64, i32)
5544c1
 DEF_HELPER_FLAGS_2(tprot, TCG_CALL_CONST, i32, i64, i64)
5544c1
-DEF_HELPER_FLAGS_1(iske, TCG_CALL_PURE|TCG_CALL_CONST, i64, i64)
5544c1
-DEF_HELPER_FLAGS_2(sske, TCG_CALL_CONST, void, i32, i64)
5544c1
-DEF_HELPER_FLAGS_2(rrbe, TCG_CALL_CONST, i32, i32, i64)
5544c1
-DEF_HELPER_2(csp, i32, i32, i32)
5544c1
-DEF_HELPER_3(mvcs, i32, i64, i64, i64)
5544c1
-DEF_HELPER_3(mvcp, i32, i64, i64, i64)
5544c1
+DEF_HELPER_FLAGS_2(iske, TCG_CALL_PURE|TCG_CALL_CONST, i64, env, i64)
5544c1
+DEF_HELPER_FLAGS_3(sske, TCG_CALL_CONST, void, env, i32, i64)
5544c1
+DEF_HELPER_FLAGS_3(rrbe, TCG_CALL_CONST, i32, env, i32, i64)
5544c1
+DEF_HELPER_3(csp, i32, env, i32, i32)
5544c1
+DEF_HELPER_4(mvcs, i32, env, i64, i64, i64)
5544c1
+DEF_HELPER_4(mvcp, i32, env, i64, i64, i64)
5544c1
 DEF_HELPER_4(sigp, i32, env, i64, i32, i64)
5544c1
 DEF_HELPER_2(sacf, void, env, i64)
5544c1
-DEF_HELPER_FLAGS_2(ipte, TCG_CALL_CONST, void, i64, i64)
5544c1
-DEF_HELPER_FLAGS_0(ptlb, TCG_CALL_CONST, void)
5544c1
-DEF_HELPER_2(lra, i32, i64, i32)
5544c1
-DEF_HELPER_2(stura, void, i64, i32)
5544c1
-DEF_HELPER_2(cksm, void, i32, i32)
5544c1
+DEF_HELPER_FLAGS_3(ipte, TCG_CALL_CONST, void, env, i64, i64)
5544c1
+DEF_HELPER_FLAGS_1(ptlb, TCG_CALL_CONST, void, env)
5544c1
+DEF_HELPER_3(lra, i32, env, i64, i32)
5544c1
+DEF_HELPER_3(stura, void, env, i64, i32)
5544c1
+DEF_HELPER_3(cksm, void, env, i32, i32)
5544c1
 
5544c1
 DEF_HELPER_FLAGS_5(calc_cc, TCG_CALL_PURE|TCG_CALL_CONST,
5544c1
                    i32, env, i32, i64, i64, i64)
5544c1
diff --git a/target-s390x/mem_helper.c b/target-s390x/mem_helper.c
5544c1
index 52f2602..b21b37c 100644
5544c1
--- a/target-s390x/mem_helper.c
5544c1
+++ b/target-s390x/mem_helper.c
5544c1
@@ -19,7 +19,6 @@
5544c1
  */
5544c1
 
5544c1
 #include "cpu.h"
5544c1
-#include "dyngen-exec.h"
5544c1
 #include "helper.h"
5544c1
 
5544c1
 /*****************************************************************************/
5544c1
@@ -45,15 +44,12 @@
5544c1
    NULL, it means that the function was called in C code (i.e. not
5544c1
    from generated code or from helper.c) */
5544c1
 /* XXX: fix it to restore all registers */
5544c1
-void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,
5544c1
+void tlb_fill(CPUS390XState *env, target_ulong addr, int is_write, int mmu_idx,
5544c1
               uintptr_t retaddr)
5544c1
 {
5544c1
     TranslationBlock *tb;
5544c1
-    CPUS390XState *saved_env;
5544c1
     int ret;
5544c1
 
5544c1
-    saved_env = env;
5544c1
-    env = env1;
5544c1
     ret = cpu_s390x_handle_mmu_fault(env, addr, is_write, mmu_idx);
5544c1
     if (unlikely(ret != 0)) {
5544c1
         if (likely(retaddr)) {
5544c1
@@ -67,7 +63,6 @@ void tlb_fill(CPUS390XState *env1, target_ulong addr, int is_write, int mmu_idx,
5544c1
         }
5544c1
         cpu_loop_exit(env);
5544c1
     }
5544c1
-    env = saved_env;
5544c1
 }
5544c1
 
5544c1
 #endif
5544c1
@@ -90,7 +85,7 @@ static void mvc_fast_memset(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
     int flags;
5544c1
 
5544c1
     if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {
5544c1
-        stb(dest, byte);
5544c1
+        cpu_stb_data(env, dest, byte);
5544c1
         cpu_abort(env, "should never reach here");
5544c1
     }
5544c1
     dest_phys |= dest & ~TARGET_PAGE_MASK;
5544c1
@@ -114,13 +109,13 @@ static void mvc_fast_memmove(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
     int flags;
5544c1
 
5544c1
     if (mmu_translate(env, dest, 1, asc, &dest_phys, &flags)) {
5544c1
-        stb(dest, 0);
5544c1
+        cpu_stb_data(env, dest, 0);
5544c1
         cpu_abort(env, "should never reach here");
5544c1
     }
5544c1
     dest_phys |= dest & ~TARGET_PAGE_MASK;
5544c1
 
5544c1
     if (mmu_translate(env, src, 0, asc, &src_phys, &flags)) {
5544c1
-        ldub(src);
5544c1
+        cpu_ldub_data(env, src);
5544c1
         cpu_abort(env, "should never reach here");
5544c1
     }
5544c1
     src_phys |= src & ~TARGET_PAGE_MASK;
5544c1
@@ -136,7 +131,8 @@ static void mvc_fast_memmove(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
 #endif
5544c1
 
5544c1
 /* and on array */
5544c1
-uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
+uint32_t HELPER(nc)(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
+                    uint64_t src)
5544c1
 {
5544c1
     int i;
5544c1
     unsigned char x;
5544c1
@@ -145,17 +141,18 @@ uint32_t HELPER(nc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
5544c1
                __func__, l, dest, src);
5544c1
     for (i = 0; i <= l; i++) {
5544c1
-        x = ldub(dest + i) & ldub(src + i);
5544c1
+        x = cpu_ldub_data(env, dest + i) & cpu_ldub_data(env, src + i);
5544c1
         if (x) {
5544c1
             cc = 1;
5544c1
         }
5544c1
-        stb(dest + i, x);
5544c1
+        cpu_stb_data(env, dest + i, x);
5544c1
     }
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
 /* xor on array */
5544c1
-uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
+uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
+                    uint64_t src)
5544c1
 {
5544c1
     int i;
5544c1
     unsigned char x;
5544c1
@@ -179,17 +176,18 @@ uint32_t HELPER(xc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
 #endif
5544c1
 
5544c1
     for (i = 0; i <= l; i++) {
5544c1
-        x = ldub(dest + i) ^ ldub(src + i);
5544c1
+        x = cpu_ldub_data(env, dest + i) ^ cpu_ldub_data(env, src + i);
5544c1
         if (x) {
5544c1
             cc = 1;
5544c1
         }
5544c1
-        stb(dest + i, x);
5544c1
+        cpu_stb_data(env, dest + i, x);
5544c1
     }
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
 /* or on array */
5544c1
-uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
+uint32_t HELPER(oc)(CPUS390XState *env, uint32_t l, uint64_t dest,
5544c1
+                    uint64_t src)
5544c1
 {
5544c1
     int i;
5544c1
     unsigned char x;
5544c1
@@ -198,17 +196,17 @@ uint32_t HELPER(oc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
5544c1
                __func__, l, dest, src);
5544c1
     for (i = 0; i <= l; i++) {
5544c1
-        x = ldub(dest + i) | ldub(src + i);
5544c1
+        x = cpu_ldub_data(env, dest + i) | cpu_ldub_data(env, src + i);
5544c1
         if (x) {
5544c1
             cc = 1;
5544c1
         }
5544c1
-        stb(dest + i, x);
5544c1
+        cpu_stb_data(env, dest + i, x);
5544c1
     }
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
 /* memmove */
5544c1
-void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
+void HELPER(mvc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
5544c1
 {
5544c1
     int i = 0;
5544c1
     int x = 0;
5544c1
@@ -222,7 +220,7 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
         (src & TARGET_PAGE_MASK) == ((src + l) & TARGET_PAGE_MASK) &&
5544c1
         (dest & TARGET_PAGE_MASK) == ((dest + l) & TARGET_PAGE_MASK)) {
5544c1
         if (dest == (src + 1)) {
5544c1
-            mvc_fast_memset(env, l + 1, dest, ldub(src));
5544c1
+            mvc_fast_memset(env, l + 1, dest, cpu_ldub_data(env, src));
5544c1
             return;
5544c1
         } else if ((src & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) {
5544c1
             mvc_fast_memmove(env, l + 1, dest, src);
5544c1
@@ -231,7 +229,7 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
     }
5544c1
 #else
5544c1
     if (dest == (src + 1)) {
5544c1
-        memset(g2h(dest), ldub(src), l + 1);
5544c1
+        memset(g2h(dest), cpu_ldub_data(env, src), l + 1);
5544c1
         return;
5544c1
     } else {
5544c1
         memmove(g2h(dest), g2h(src), l + 1);
5544c1
@@ -242,19 +240,19 @@ void HELPER(mvc)(uint32_t l, uint64_t dest, uint64_t src)
5544c1
     /* handle the parts that fit into 8-byte loads/stores */
5544c1
     if (dest != (src + 1)) {
5544c1
         for (i = 0; i < l_64; i++) {
5544c1
-            stq(dest + x, ldq(src + x));
5544c1
+            cpu_stq_data(env, dest + x, cpu_ldq_data(env, src + x));
5544c1
             x += 8;
5544c1
         }
5544c1
     }
5544c1
 
5544c1
     /* slow version crossing pages with byte accesses */
5544c1
     for (i = x; i <= l; i++) {
5544c1
-        stb(dest + i, ldub(src + i));
5544c1
+        cpu_stb_data(env, dest + i, cpu_ldub_data(env, src + i));
5544c1
     }
5544c1
 }
5544c1
 
5544c1
 /* compare unsigned byte arrays */
5544c1
-uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)
5544c1
+uint32_t HELPER(clc)(CPUS390XState *env, uint32_t l, uint64_t s1, uint64_t s2)
5544c1
 {
5544c1
     int i;
5544c1
     unsigned char x, y;
5544c1
@@ -263,8 +261,8 @@ uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)
5544c1
     HELPER_LOG("%s l %d s1 %" PRIx64 " s2 %" PRIx64 "\n",
5544c1
                __func__, l, s1, s2);
5544c1
     for (i = 0; i <= l; i++) {
5544c1
-        x = ldub(s1 + i);
5544c1
-        y = ldub(s2 + i);
5544c1
+        x = cpu_ldub_data(env, s1 + i);
5544c1
+        y = cpu_ldub_data(env, s2 + i);
5544c1
         HELPER_LOG("%02x (%c)/%02x (%c) ", x, x, y, y);
5544c1
         if (x < y) {
5544c1
             cc = 1;
5544c1
@@ -281,7 +279,8 @@ uint32_t HELPER(clc)(uint32_t l, uint64_t s1, uint64_t s2)
5544c1
 }
5544c1
 
5544c1
 /* compare logical under mask */
5544c1
-uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
+uint32_t HELPER(clm)(CPUS390XState *env, uint32_t r1, uint32_t mask,
5544c1
+                     uint64_t addr)
5544c1
 {
5544c1
     uint8_t r, d;
5544c1
     uint32_t cc;
5544c1
@@ -291,7 +290,7 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
     cc = 0;
5544c1
     while (mask) {
5544c1
         if (mask & 8) {
5544c1
-            d = ldub(addr);
5544c1
+            d = cpu_ldub_data(env, addr);
5544c1
             r = (r1 & 0xff000000UL) >> 24;
5544c1
             HELPER_LOG("mask 0x%x %02x/%02x (0x%" PRIx64 ") ", mask, r, d,
5544c1
                        addr);
5544c1
@@ -312,7 +311,8 @@ uint32_t HELPER(clm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
 }
5544c1
 
5544c1
 /* store character under mask */
5544c1
-void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
+void HELPER(stcm)(CPUS390XState *env, uint32_t r1, uint32_t mask,
5544c1
+                  uint64_t addr)
5544c1
 {
5544c1
     uint8_t r;
5544c1
 
5544c1
@@ -321,7 +321,7 @@ void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
     while (mask) {
5544c1
         if (mask & 8) {
5544c1
             r = (r1 & 0xff000000UL) >> 24;
5544c1
-            stb(addr, r);
5544c1
+            cpu_stb_data(env, addr, r);
5544c1
             HELPER_LOG("mask 0x%x %02x (0x%lx) ", mask, r, addr);
5544c1
             addr++;
5544c1
         }
5544c1
@@ -331,7 +331,7 @@ void HELPER(stcm)(uint32_t r1, uint32_t mask, uint64_t addr)
5544c1
     HELPER_LOG("\n");
5544c1
 }
5544c1
 
5544c1
-static inline uint64_t get_address(int x2, int b2, int d2)
5544c1
+static inline uint64_t get_address(CPUS390XState *env, int x2, int b2, int d2)
5544c1
 {
5544c1
     uint64_t r = d2;
5544c1
 
5544c1
@@ -351,7 +351,7 @@ static inline uint64_t get_address(int x2, int b2, int d2)
5544c1
     return r;
5544c1
 }
5544c1
 
5544c1
-static inline uint64_t get_address_31fix(int reg)
5544c1
+static inline uint64_t get_address_31fix(CPUS390XState *env, int reg)
5544c1
 {
5544c1
     uint64_t r = env->regs[reg];
5544c1
 
5544c1
@@ -364,18 +364,18 @@ static inline uint64_t get_address_31fix(int reg)
5544c1
 }
5544c1
 
5544c1
 /* search string (c is byte to search, r2 is string, r1 end of string) */
5544c1
-uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
+uint32_t HELPER(srst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
     uint64_t i;
5544c1
     uint32_t cc = 2;
5544c1
-    uint64_t str = get_address_31fix(r2);
5544c1
-    uint64_t end = get_address_31fix(r1);
5544c1
+    uint64_t str = get_address_31fix(env, r2);
5544c1
+    uint64_t end = get_address_31fix(env, r1);
5544c1
 
5544c1
     HELPER_LOG("%s: c %d *r1 0x%" PRIx64 " *r2 0x%" PRIx64 "\n", __func__,
5544c1
                c, env->regs[r1], env->regs[r2]);
5544c1
 
5544c1
     for (i = str; i != end; i++) {
5544c1
-        if (ldub(i) == c) {
5544c1
+        if (cpu_ldub_data(env, i) == c) {
5544c1
             env->regs[r1] = i;
5544c1
             cc = 1;
5544c1
             break;
5544c1
@@ -386,10 +386,10 @@ uint32_t HELPER(srst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 }
5544c1
 
5544c1
 /* unsigned string compare (c is string terminator) */
5544c1
-uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
+uint32_t HELPER(clst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
-    uint64_t s1 = get_address_31fix(r1);
5544c1
-    uint64_t s2 = get_address_31fix(r2);
5544c1
+    uint64_t s1 = get_address_31fix(env, r1);
5544c1
+    uint64_t s2 = get_address_31fix(env, r2);
5544c1
     uint8_t v1, v2;
5544c1
     uint32_t cc;
5544c1
 
5544c1
@@ -401,8 +401,8 @@ uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
     }
5544c1
 #endif
5544c1
     for (;;) {
5544c1
-        v1 = ldub(s1);
5544c1
-        v2 = ldub(s2);
5544c1
+        v1 = cpu_ldub_data(env, s1);
5544c1
+        v2 = cpu_ldub_data(env, s2);
5544c1
         if ((v1 == c || v2 == c) || (v1 != v2)) {
5544c1
             break;
5544c1
         }
5544c1
@@ -422,14 +422,14 @@ uint32_t HELPER(clst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 }
5544c1
 
5544c1
 /* move page */
5544c1
-void HELPER(mvpg)(uint64_t r0, uint64_t r1, uint64_t r2)
5544c1
+void HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
5544c1
 {
5544c1
     /* XXX missing r0 handling */
5544c1
 #ifdef CONFIG_USER_ONLY
5544c1
     int i;
5544c1
 
5544c1
     for (i = 0; i < TARGET_PAGE_SIZE; i++) {
5544c1
-        stb(r1 + i, ldub(r2 + i));
5544c1
+        cpu_stb_data(env, r1 + i, cpu_ldub_data(env, r2 + i));
5544c1
     }
5544c1
 #else
5544c1
     mvc_fast_memmove(env, TARGET_PAGE_SIZE, r1, r2);
5544c1
@@ -437,10 +437,10 @@ void HELPER(mvpg)(uint64_t r0, uint64_t r1, uint64_t r2)
5544c1
 }
5544c1
 
5544c1
 /* string copy (c is string terminator) */
5544c1
-void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
+void HELPER(mvst)(CPUS390XState *env, uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
-    uint64_t dest = get_address_31fix(r1);
5544c1
-    uint64_t src = get_address_31fix(r2);
5544c1
+    uint64_t dest = get_address_31fix(env, r1);
5544c1
+    uint64_t src = get_address_31fix(env, r2);
5544c1
     uint8_t v;
5544c1
 
5544c1
     c = c & 0xff;
5544c1
@@ -451,8 +451,8 @@ void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
     }
5544c1
 #endif
5544c1
     for (;;) {
5544c1
-        v = ldub(src);
5544c1
-        stb(dest, v);
5544c1
+        v = cpu_ldub_data(env, src);
5544c1
+        cpu_stb_data(env, dest, v);
5544c1
         if (v == c) {
5544c1
             break;
5544c1
         }
5544c1
@@ -463,15 +463,15 @@ void HELPER(mvst)(uint32_t c, uint32_t r1, uint32_t r2)
5544c1
 }
5544c1
 
5544c1
 /* compare and swap 64-bit */
5544c1
-uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+uint32_t HELPER(csg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     /* FIXME: locking? */
5544c1
     uint32_t cc;
5544c1
-    uint64_t v2 = ldq(a2);
5544c1
+    uint64_t v2 = cpu_ldq_data(env, a2);
5544c1
 
5544c1
     if (env->regs[r1] == v2) {
5544c1
         cc = 0;
5544c1
-        stq(a2, env->regs[r3]);
5544c1
+        cpu_stq_data(env, a2, env->regs[r3]);
5544c1
     } else {
5544c1
         cc = 1;
5544c1
         env->regs[r1] = v2;
5544c1
@@ -480,19 +480,19 @@ uint32_t HELPER(csg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* compare double and swap 64-bit */
5544c1
-uint32_t HELPER(cdsg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+uint32_t HELPER(cdsg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     /* FIXME: locking? */
5544c1
     uint32_t cc;
5544c1
-    uint64_t v2_hi = ldq(a2);
5544c1
-    uint64_t v2_lo = ldq(a2 + 8);
5544c1
+    uint64_t v2_hi = cpu_ldq_data(env, a2);
5544c1
+    uint64_t v2_lo = cpu_ldq_data(env, a2 + 8);
5544c1
     uint64_t v1_hi = env->regs[r1];
5544c1
     uint64_t v1_lo = env->regs[r1 + 1];
5544c1
 
5544c1
     if ((v1_hi == v2_hi) && (v1_lo == v2_lo)) {
5544c1
         cc = 0;
5544c1
-        stq(a2, env->regs[r3]);
5544c1
-        stq(a2 + 8, env->regs[r3 + 1]);
5544c1
+        cpu_stq_data(env, a2, env->regs[r3]);
5544c1
+        cpu_stq_data(env, a2 + 8, env->regs[r3 + 1]);
5544c1
     } else {
5544c1
         cc = 1;
5544c1
         env->regs[r1] = v2_hi;
5544c1
@@ -503,16 +503,16 @@ uint32_t HELPER(cdsg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* compare and swap 32-bit */
5544c1
-uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+uint32_t HELPER(cs)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     /* FIXME: locking? */
5544c1
     uint32_t cc;
5544c1
-    uint32_t v2 = ldl(a2);
5544c1
+    uint32_t v2 = cpu_ldl_data(env, a2);
5544c1
 
5544c1
     HELPER_LOG("%s: r1 %d a2 0x%lx r3 %d\n", __func__, r1, a2, r3);
5544c1
     if (((uint32_t)env->regs[r1]) == v2) {
5544c1
         cc = 0;
5544c1
-        stl(a2, (uint32_t)env->regs[r3]);
5544c1
+        cpu_stl_data(env, a2, (uint32_t)env->regs[r3]);
5544c1
     } else {
5544c1
         cc = 1;
5544c1
         env->regs[r1] = (env->regs[r1] & 0xffffffff00000000ULL) | v2;
5544c1
@@ -520,7 +520,8 @@ uint32_t HELPER(cs)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
-static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
+static uint32_t helper_icm(CPUS390XState *env, uint32_t r1, uint64_t address,
5544c1
+                           uint32_t mask)
5544c1
 {
5544c1
     int pos = 24; /* top of the lower half of r1 */
5544c1
     uint64_t rmask = 0xff000000ULL;
5544c1
@@ -531,7 +532,7 @@ static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
     while (mask) {
5544c1
         if (mask & 8) {
5544c1
             env->regs[r1] &= ~rmask;
5544c1
-            val = ldub(address);
5544c1
+            val = cpu_ldub_data(env, address);
5544c1
             if ((val & 0x80) && !ccd) {
5544c1
                 cc = 1;
5544c1
             }
5544c1
@@ -557,9 +558,10 @@ static uint32_t helper_icm(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
    in other words: tricky...
5544c1
    currently implemented by interpreting the cases it is most commonly used in
5544c1
 */
5544c1
-uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)
5544c1
+uint32_t HELPER(ex)(CPUS390XState *env, uint32_t cc, uint64_t v1,
5544c1
+                    uint64_t addr, uint64_t ret)
5544c1
 {
5544c1
-    uint16_t insn = lduw_code(addr);
5544c1
+    uint16_t insn = cpu_lduw_code(env, addr);
5544c1
 
5544c1
     HELPER_LOG("%s: v1 0x%lx addr 0x%lx insn 0x%x\n", __func__, v1, addr,
5544c1
                insn);
5544c1
@@ -567,23 +569,27 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)
5544c1
         uint32_t l, insn2, b1, b2, d1, d2;
5544c1
 
5544c1
         l = v1 & 0xff;
5544c1
-        insn2 = ldl_code(addr + 2);
5544c1
+        insn2 = cpu_ldl_code(env, addr + 2);
5544c1
         b1 = (insn2 >> 28) & 0xf;
5544c1
         b2 = (insn2 >> 12) & 0xf;
5544c1
         d1 = (insn2 >> 16) & 0xfff;
5544c1
         d2 = insn2 & 0xfff;
5544c1
         switch (insn & 0xf00) {
5544c1
         case 0x200:
5544c1
-            helper_mvc(l, get_address(0, b1, d1), get_address(0, b2, d2));
5544c1
+            helper_mvc(env, l, get_address(env, 0, b1, d1),
5544c1
+                       get_address(env, 0, b2, d2));
5544c1
             break;
5544c1
         case 0x500:
5544c1
-            cc = helper_clc(l, get_address(0, b1, d1), get_address(0, b2, d2));
5544c1
+            cc = helper_clc(env, l, get_address(env, 0, b1, d1),
5544c1
+                            get_address(env, 0, b2, d2));
5544c1
             break;
5544c1
         case 0x700:
5544c1
-            cc = helper_xc(l, get_address(0, b1, d1), get_address(0, b2, d2));
5544c1
+            cc = helper_xc(env, l, get_address(env, 0, b1, d1),
5544c1
+                           get_address(env, 0, b2, d2));
5544c1
             break;
5544c1
         case 0xc00:
5544c1
-            helper_tr(l, get_address(0, b1, d1), get_address(0, b2, d2));
5544c1
+            helper_tr(env, l, get_address(env, 0, b1, d1),
5544c1
+                      get_address(env, 0, b2, d2));
5544c1
             break;
5544c1
         default:
5544c1
             goto abort;
5544c1
@@ -599,12 +605,12 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)
5544c1
     } else if ((insn & 0xff00) == 0xbf00) {
5544c1
         uint32_t insn2, r1, r3, b2, d2;
5544c1
 
5544c1
-        insn2 = ldl_code(addr + 2);
5544c1
+        insn2 = cpu_ldl_code(env, addr + 2);
5544c1
         r1 = (insn2 >> 20) & 0xf;
5544c1
         r3 = (insn2 >> 16) & 0xf;
5544c1
         b2 = (insn2 >> 12) & 0xf;
5544c1
         d2 = insn2 & 0xfff;
5544c1
-        cc = helper_icm(r1, get_address(0, b2, d2), r3);
5544c1
+        cc = helper_icm(env, r1, get_address(env, 0, b2, d2), r3);
5544c1
     } else {
5544c1
     abort:
5544c1
         cpu_abort(env, "EXECUTE on instruction prefix 0x%x not implemented\n",
5544c1
@@ -614,13 +620,14 @@ uint32_t HELPER(ex)(uint32_t cc, uint64_t v1, uint64_t addr, uint64_t ret)
5544c1
 }
5544c1
 
5544c1
 /* store character under mask high operates on the upper half of r1 */
5544c1
-void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
+void HELPER(stcmh)(CPUS390XState *env, uint32_t r1, uint64_t address,
5544c1
+                   uint32_t mask)
5544c1
 {
5544c1
     int pos = 56; /* top of the upper half of r1 */
5544c1
 
5544c1
     while (mask) {
5544c1
         if (mask & 8) {
5544c1
-            stb(address, (env->regs[r1] >> pos) & 0xff);
5544c1
+            cpu_stb_data(env, address, (env->regs[r1] >> pos) & 0xff);
5544c1
             address++;
5544c1
         }
5544c1
         mask = (mask << 1) & 0xf;
5544c1
@@ -630,7 +637,8 @@ void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
 
5544c1
 /* insert character under mask high; same as icm, but operates on the
5544c1
    upper half of r1 */
5544c1
-uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
+uint32_t HELPER(icmh)(CPUS390XState *env, uint32_t r1, uint64_t address,
5544c1
+                      uint32_t mask)
5544c1
 {
5544c1
     int pos = 56; /* top of the upper half of r1 */
5544c1
     uint64_t rmask = 0xff00000000000000ULL;
5544c1
@@ -641,7 +649,7 @@ uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
     while (mask) {
5544c1
         if (mask & 8) {
5544c1
             env->regs[r1] &= ~rmask;
5544c1
-            val = ldub(address);
5544c1
+            val = cpu_ldub_data(env, address);
5544c1
             if ((val & 0x80) && !ccd) {
5544c1
                 cc = 1;
5544c1
             }
5544c1
@@ -661,12 +669,12 @@ uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
5544c1
 }
5544c1
 
5544c1
 /* load access registers r1 to r3 from memory at a2 */
5544c1
-void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(lam)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        env->aregs[i] = ldl(a2);
5544c1
+        env->aregs[i] = cpu_ldl_data(env, a2);
5544c1
         a2 += 4;
5544c1
 
5544c1
         if (i == r3) {
5544c1
@@ -676,12 +684,12 @@ void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* store access registers r1 to r3 in memory at a2 */
5544c1
-void HELPER(stam)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(stam)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        stl(a2, env->aregs[i]);
5544c1
+        cpu_stl_data(env, a2, env->aregs[i]);
5544c1
         a2 += 4;
5544c1
 
5544c1
         if (i == r3) {
5544c1
@@ -691,12 +699,12 @@ void HELPER(stam)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* move long */
5544c1
-uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
5544c1
+uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
     uint64_t destlen = env->regs[r1 + 1] & 0xffffff;
5544c1
-    uint64_t dest = get_address_31fix(r1);
5544c1
+    uint64_t dest = get_address_31fix(env, r1);
5544c1
     uint64_t srclen = env->regs[r2 + 1] & 0xffffff;
5544c1
-    uint64_t src = get_address_31fix(r2);
5544c1
+    uint64_t src = get_address_31fix(env, r2);
5544c1
     uint8_t pad = src >> 24;
5544c1
     uint8_t v;
5544c1
     uint32_t cc;
5544c1
@@ -714,12 +722,12 @@ uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
5544c1
     }
5544c1
 
5544c1
     for (; destlen && srclen; src++, dest++, destlen--, srclen--) {
5544c1
-        v = ldub(src);
5544c1
-        stb(dest, v);
5544c1
+        v = cpu_ldub_data(env, src);
5544c1
+        cpu_stb_data(env, dest, v);
5544c1
     }
5544c1
 
5544c1
     for (; destlen; dest++, destlen--) {
5544c1
-        stb(dest, pad);
5544c1
+        cpu_stb_data(env, dest, pad);
5544c1
     }
5544c1
 
5544c1
     env->regs[r1 + 1] = destlen;
5544c1
@@ -732,7 +740,8 @@ uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
5544c1
 }
5544c1
 
5544c1
 /* move long extended another memcopy insn with more bells and whistles */
5544c1
-uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+uint32_t HELPER(mvcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
5544c1
+                       uint32_t r3)
5544c1
 {
5544c1
     uint64_t destlen = env->regs[r1 + 1];
5544c1
     uint64_t dest = env->regs[r1];
5544c1
@@ -762,12 +771,12 @@ uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     }
5544c1
 
5544c1
     for (; destlen && srclen; src++, dest++, destlen--, srclen--) {
5544c1
-        v = ldub(src);
5544c1
-        stb(dest, v);
5544c1
+        v = cpu_ldub_data(env, src);
5544c1
+        cpu_stb_data(env, dest, v);
5544c1
     }
5544c1
 
5544c1
     for (; destlen; dest++, destlen--) {
5544c1
-        stb(dest, pad);
5544c1
+        cpu_stb_data(env, dest, pad);
5544c1
     }
5544c1
 
5544c1
     env->regs[r1 + 1] = destlen;
5544c1
@@ -781,12 +790,13 @@ uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* compare logical long extended memcompare insn with padding */
5544c1
-uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+uint32_t HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
5544c1
+                       uint32_t r3)
5544c1
 {
5544c1
     uint64_t destlen = env->regs[r1 + 1];
5544c1
-    uint64_t dest = get_address_31fix(r1);
5544c1
+    uint64_t dest = get_address_31fix(env, r1);
5544c1
     uint64_t srclen = env->regs[r3 + 1];
5544c1
-    uint64_t src = get_address_31fix(r3);
5544c1
+    uint64_t src = get_address_31fix(env, r3);
5544c1
     uint8_t pad = a2 & 0xff;
5544c1
     uint8_t v1 = 0, v2 = 0;
5544c1
     uint32_t cc = 0;
5544c1
@@ -800,8 +810,8 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     }
5544c1
 
5544c1
     for (; destlen || srclen; src++, dest++, destlen--, srclen--) {
5544c1
-        v1 = srclen ? ldub(src) : pad;
5544c1
-        v2 = destlen ? ldub(dest) : pad;
5544c1
+        v1 = srclen ? cpu_ldub_data(env, src) : pad;
5544c1
+        v2 = destlen ? cpu_ldub_data(env, dest) : pad;
5544c1
         if (v1 != v2) {
5544c1
             cc = (v1 < v2) ? 1 : 2;
5544c1
             break;
5544c1
@@ -818,14 +828,14 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 }
5544c1
 
5544c1
 /* checksum */
5544c1
-void HELPER(cksm)(uint32_t r1, uint32_t r2)
5544c1
+void HELPER(cksm)(CPUS390XState *env, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
-    uint64_t src = get_address_31fix(r2);
5544c1
+    uint64_t src = get_address_31fix(env, r2);
5544c1
     uint64_t src_len = env->regs[(r2 + 1) & 15];
5544c1
     uint64_t cksm = (uint32_t)env->regs[r1];
5544c1
 
5544c1
     while (src_len >= 4) {
5544c1
-        cksm += ldl(src);
5544c1
+        cksm += cpu_ldl_data(env, src);
5544c1
 
5544c1
         /* move to next word */
5544c1
         src_len -= 4;
5544c1
@@ -836,14 +846,14 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
5544c1
     case 0:
5544c1
         break;
5544c1
     case 1:
5544c1
-        cksm += ldub(src) << 24;
5544c1
+        cksm += cpu_ldub_data(env, src) << 24;
5544c1
         break;
5544c1
     case 2:
5544c1
-        cksm += lduw(src) << 16;
5544c1
+        cksm += cpu_lduw_data(env, src) << 16;
5544c1
         break;
5544c1
     case 3:
5544c1
-        cksm += lduw(src) << 16;
5544c1
-        cksm += ldub(src + 2) << 8;
5544c1
+        cksm += cpu_lduw_data(env, src) << 16;
5544c1
+        cksm += cpu_ldub_data(env, src + 2) << 8;
5544c1
         break;
5544c1
     }
5544c1
 
5544c1
@@ -856,7 +866,8 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
5544c1
         ((uint32_t)cksm + (cksm >> 32));
5544c1
 }
5544c1
 
5544c1
-void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
5544c1
+void HELPER(unpk)(CPUS390XState *env, uint32_t len, uint64_t dest,
5544c1
+                  uint64_t src)
5544c1
 {
5544c1
     int len_dest = len >> 4;
5544c1
     int len_src = len & 0xf;
5544c1
@@ -867,8 +878,8 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
5544c1
     src += len_src;
5544c1
 
5544c1
     /* last byte is special, it only flips the nibbles */
5544c1
-    b = ldub(src);
5544c1
-    stb(dest, (b << 4) | (b >> 4));
5544c1
+    b = cpu_ldub_data(env, src);
5544c1
+    cpu_stb_data(env, dest, (b << 4) | (b >> 4));
5544c1
     src--;
5544c1
     len_src--;
5544c1
 
5544c1
@@ -878,7 +889,7 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
5544c1
         uint8_t cur_byte = 0;
5544c1
 
5544c1
         if (len_src > 0) {
5544c1
-            cur_byte = ldub(src);
5544c1
+            cur_byte = cpu_ldub_data(env, src);
5544c1
         }
5544c1
 
5544c1
         len_dest--;
5544c1
@@ -897,30 +908,31 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
5544c1
         /* zone bits */
5544c1
         cur_byte |= 0xf0;
5544c1
 
5544c1
-        stb(dest, cur_byte);
5544c1
+        cpu_stb_data(env, dest, cur_byte);
5544c1
     }
5544c1
 }
5544c1
 
5544c1
-void HELPER(tr)(uint32_t len, uint64_t array, uint64_t trans)
5544c1
+void HELPER(tr)(CPUS390XState *env, uint32_t len, uint64_t array,
5544c1
+                uint64_t trans)
5544c1
 {
5544c1
     int i;
5544c1
 
5544c1
     for (i = 0; i <= len; i++) {
5544c1
-        uint8_t byte = ldub(array + i);
5544c1
-        uint8_t new_byte = ldub(trans + byte);
5544c1
+        uint8_t byte = cpu_ldub_data(env, array + i);
5544c1
+        uint8_t new_byte = cpu_ldub_data(env, trans + byte);
5544c1
 
5544c1
-        stb(array + i, new_byte);
5544c1
+        cpu_stb_data(env, array + i, new_byte);
5544c1
     }
5544c1
 }
5544c1
 
5544c1
 #if !defined(CONFIG_USER_ONLY)
5544c1
-void HELPER(lctlg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(lctlg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
     uint64_t src = a2;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        env->cregs[i] = ldq(src);
5544c1
+        env->cregs[i] = cpu_ldq_data(env, src);
5544c1
         HELPER_LOG("load ctl %d from 0x%" PRIx64 " == 0x%" PRIx64 "\n",
5544c1
                    i, src, env->cregs[i]);
5544c1
         src += sizeof(uint64_t);
5544c1
@@ -933,13 +945,14 @@ void HELPER(lctlg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     tlb_flush(env, 1);
5544c1
 }
5544c1
 
5544c1
-void HELPER(lctl)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(lctl)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
     uint64_t src = a2;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        env->cregs[i] = (env->cregs[i] & 0xFFFFFFFF00000000ULL) | ldl(src);
5544c1
+        env->cregs[i] = (env->cregs[i] & 0xFFFFFFFF00000000ULL) |
5544c1
+            cpu_ldl_data(env, src);
5544c1
         src += sizeof(uint32_t);
5544c1
 
5544c1
         if (i == r3) {
5544c1
@@ -950,13 +963,13 @@ void HELPER(lctl)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     tlb_flush(env, 1);
5544c1
 }
5544c1
 
5544c1
-void HELPER(stctg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(stctg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
     uint64_t dest = a2;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        stq(dest, env->cregs[i]);
5544c1
+        cpu_stq_data(env, dest, env->cregs[i]);
5544c1
         dest += sizeof(uint64_t);
5544c1
 
5544c1
         if (i == r3) {
5544c1
@@ -965,13 +978,13 @@ void HELPER(stctg)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
     }
5544c1
 }
5544c1
 
5544c1
-void HELPER(stctl)(uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
+void HELPER(stctl)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
5544c1
 {
5544c1
     int i;
5544c1
     uint64_t dest = a2;
5544c1
 
5544c1
     for (i = r1;; i = (i + 1) % 16) {
5544c1
-        stl(dest, env->cregs[i]);
5544c1
+        cpu_stl_data(env, dest, env->cregs[i]);
5544c1
         dest += sizeof(uint32_t);
5544c1
 
5544c1
         if (i == r3) {
5544c1
@@ -988,9 +1001,9 @@ uint32_t HELPER(tprot)(uint64_t a1, uint64_t a2)
5544c1
 }
5544c1
 
5544c1
 /* insert storage key extended */
5544c1
-uint64_t HELPER(iske)(uint64_t r2)
5544c1
+uint64_t HELPER(iske)(CPUS390XState *env, uint64_t r2)
5544c1
 {
5544c1
-    uint64_t addr = get_address(0, 0, r2);
5544c1
+    uint64_t addr = get_address(env, 0, 0, r2);
5544c1
 
5544c1
     if (addr > ram_size) {
5544c1
         return 0;
5544c1
@@ -1000,9 +1013,9 @@ uint64_t HELPER(iske)(uint64_t r2)
5544c1
 }
5544c1
 
5544c1
 /* set storage key extended */
5544c1
-void HELPER(sske)(uint32_t r1, uint64_t r2)
5544c1
+void HELPER(sske)(CPUS390XState *env, uint32_t r1, uint64_t r2)
5544c1
 {
5544c1
-    uint64_t addr = get_address(0, 0, r2);
5544c1
+    uint64_t addr = get_address(env, 0, 0, r2);
5544c1
 
5544c1
     if (addr > ram_size) {
5544c1
         return;
5544c1
@@ -1012,7 +1025,7 @@ void HELPER(sske)(uint32_t r1, uint64_t r2)
5544c1
 }
5544c1
 
5544c1
 /* reset reference bit extended */
5544c1
-uint32_t HELPER(rrbe)(uint32_t r1, uint64_t r2)
5544c1
+uint32_t HELPER(rrbe)(CPUS390XState *env, uint32_t r1, uint64_t r2)
5544c1
 {
5544c1
     uint8_t re;
5544c1
     uint8_t key;
5544c1
@@ -1038,15 +1051,15 @@ uint32_t HELPER(rrbe)(uint32_t r1, uint64_t r2)
5544c1
 }
5544c1
 
5544c1
 /* compare and swap and purge */
5544c1
-uint32_t HELPER(csp)(uint32_t r1, uint32_t r2)
5544c1
+uint32_t HELPER(csp)(CPUS390XState *env, uint32_t r1, uint32_t r2)
5544c1
 {
5544c1
     uint32_t cc;
5544c1
     uint32_t o1 = env->regs[r1];
5544c1
-    uint64_t a2 = get_address_31fix(r2) & ~3ULL;
5544c1
-    uint32_t o2 = ldl(a2);
5544c1
+    uint64_t a2 = get_address_31fix(env, r2) & ~3ULL;
5544c1
+    uint32_t o2 = cpu_ldl_data(env, a2);
5544c1
 
5544c1
     if (o1 == o2) {
5544c1
-        stl(a2, env->regs[(r1 + 1) & 15]);
5544c1
+        cpu_stl_data(env, a2, env->regs[(r1 + 1) & 15]);
5544c1
         if (env->regs[r2] & 0x3) {
5544c1
             /* flush TLB / ALB */
5544c1
             tlb_flush(env, 1);
5544c1
@@ -1060,8 +1073,8 @@ uint32_t HELPER(csp)(uint32_t r1, uint32_t r2)
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
-static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
5544c1
-                        uint64_t mode2)
5544c1
+static uint32_t mvc_asc(CPUS390XState *env, int64_t l, uint64_t a1,
5544c1
+                        uint64_t mode1, uint64_t a2, uint64_t mode2)
5544c1
 {
5544c1
     target_ulong src, dest;
5544c1
     int flags, cc = 0, i;
5544c1
@@ -1089,7 +1102,7 @@ static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
5544c1
         /* XXX be more clever */
5544c1
         if ((((dest + i) & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) ||
5544c1
             (((src + i) & TARGET_PAGE_MASK) != (src & TARGET_PAGE_MASK))) {
5544c1
-            mvc_asc(l - i, a1 + i, mode1, a2 + i, mode2);
5544c1
+            mvc_asc(env, l - i, a1 + i, mode1, a2 + i, mode2);
5544c1
             break;
5544c1
         }
5544c1
         stb_phys(dest + i, ldub_phys(src + i));
5544c1
@@ -1098,24 +1111,24 @@ static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
5544c1
     return cc;
5544c1
 }
5544c1
 
5544c1
-uint32_t HELPER(mvcs)(uint64_t l, uint64_t a1, uint64_t a2)
5544c1
+uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
5544c1
 {
5544c1
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
5544c1
                __func__, l, a1, a2);
5544c1
 
5544c1
-    return mvc_asc(l, a1, PSW_ASC_SECONDARY, a2, PSW_ASC_PRIMARY);
5544c1
+    return mvc_asc(env, l, a1, PSW_ASC_SECONDARY, a2, PSW_ASC_PRIMARY);
5544c1
 }
5544c1
 
5544c1
-uint32_t HELPER(mvcp)(uint64_t l, uint64_t a1, uint64_t a2)
5544c1
+uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
5544c1
 {
5544c1
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
5544c1
                __func__, l, a1, a2);
5544c1
 
5544c1
-    return mvc_asc(l, a1, PSW_ASC_PRIMARY, a2, PSW_ASC_SECONDARY);
5544c1
+    return mvc_asc(env, l, a1, PSW_ASC_PRIMARY, a2, PSW_ASC_SECONDARY);
5544c1
 }
5544c1
 
5544c1
 /* invalidate pte */
5544c1
-void HELPER(ipte)(uint64_t pte_addr, uint64_t vaddr)
5544c1
+void HELPER(ipte)(CPUS390XState *env, uint64_t pte_addr, uint64_t vaddr)
5544c1
 {
5544c1
     uint64_t page = vaddr & TARGET_PAGE_MASK;
5544c1
     uint64_t pte = 0;
5544c1
@@ -1141,19 +1154,19 @@ void HELPER(ipte)(uint64_t pte_addr, uint64_t vaddr)
5544c1
 }
5544c1
 
5544c1
 /* flush local tlb */
5544c1
-void HELPER(ptlb)(void)
5544c1
+void HELPER(ptlb)(CPUS390XState *env)
5544c1
 {
5544c1
     tlb_flush(env, 1);
5544c1
 }
5544c1
 
5544c1
 /* store using real address */
5544c1
-void HELPER(stura)(uint64_t addr, uint32_t v1)
5544c1
+void HELPER(stura)(CPUS390XState *env, uint64_t addr, uint32_t v1)
5544c1
 {
5544c1
-    stw_phys(get_address(0, 0, addr), v1);
5544c1
+    stw_phys(get_address(env, 0, 0, addr), v1);
5544c1
 }
5544c1
 
5544c1
 /* load real address */
5544c1
-uint32_t HELPER(lra)(uint64_t addr, uint32_t r1)
5544c1
+uint32_t HELPER(lra)(CPUS390XState *env, uint64_t addr, uint32_t r1)
5544c1
 {
5544c1
     uint32_t cc = 0;
5544c1
     int old_exc = env->exception_index;
5544c1
@@ -1188,52 +1201,3 @@ uint32_t HELPER(lra)(uint64_t addr, uint32_t r1)
5544c1
 }
5544c1
 
5544c1
 #endif
5544c1
-
5544c1
-/* temporary wrappers */
5544c1
-#if defined(CONFIG_USER_ONLY)
5544c1
-#define ldub_data(addr) ldub_raw(addr)
5544c1
-#define lduw_data(addr) lduw_raw(addr)
5544c1
-#define ldl_data(addr) ldl_raw(addr)
5544c1
-#define ldq_data(addr) ldq_raw(addr)
5544c1
-
5544c1
-#define stb_data(addr, data) stb_raw(addr, data)
5544c1
-#define stw_data(addr, data) stw_raw(addr, data)
5544c1
-#define stl_data(addr, data) stl_raw(addr, data)
5544c1
-#define stq_data(addr, data) stq_raw(addr, data)
5544c1
-#endif
5544c1
-
5544c1
-#define WRAP_LD(rettype, fn)                                    \
5544c1
-    rettype cpu_ ## fn(CPUS390XState *env1, target_ulong addr)  \
5544c1
-    {                                                           \
5544c1
-        CPUS390XState *saved_env;                               \
5544c1
-        rettype ret;                                            \
5544c1
-                                                                \
5544c1
-        saved_env = env;                                        \
5544c1
-        env = env1;                                             \
5544c1
-        ret = fn(addr);                                         \
5544c1
-        env = saved_env;                                        \
5544c1
-        return ret;                                             \
5544c1
-    }
5544c1
-
5544c1
-WRAP_LD(uint32_t, ldub_data)
5544c1
-WRAP_LD(uint32_t, lduw_data)
5544c1
-WRAP_LD(uint32_t, ldl_data)
5544c1
-WRAP_LD(uint64_t, ldq_data)
5544c1
-#undef WRAP_LD
5544c1
-
5544c1
-#define WRAP_ST(datatype, fn)                                           \
5544c1
-    void cpu_ ## fn(CPUS390XState *env1, target_ulong addr, datatype val) \
5544c1
-    {                                                                   \
5544c1
-        CPUS390XState *saved_env;                                       \
5544c1
-                                                                        \
5544c1
-        saved_env = env;                                                \
5544c1
-        env = env1;                                                     \
5544c1
-        fn(addr, val);                                                  \
5544c1
-        env = saved_env;                                                \
5544c1
-    }
5544c1
-
5544c1
-WRAP_ST(uint32_t, stb_data)
5544c1
-WRAP_ST(uint32_t, stw_data)
5544c1
-WRAP_ST(uint32_t, stl_data)
5544c1
-WRAP_ST(uint64_t, stq_data)
5544c1
-#undef WRAP_ST
5544c1
diff --git a/target-s390x/misc_helper.c b/target-s390x/misc_helper.c
5544c1
index ced26c6..2938ac9 100644
5544c1
--- a/target-s390x/misc_helper.c
5544c1
+++ b/target-s390x/misc_helper.c
5544c1
@@ -31,10 +31,7 @@
5544c1
 #endif
5544c1
 
5544c1
 #if !defined(CONFIG_USER_ONLY)
5544c1
-/* temporarily disabled due to wrapper use */
5544c1
-#if 0
5544c1
 #include "softmmu_exec.h"
5544c1
-#endif
5544c1
 #include "sysemu.h"
5544c1
 #endif
5544c1
 
5544c1
diff --git a/target-s390x/translate.c b/target-s390x/translate.c
5544c1
index 0c61e63..66119cd 100644
5544c1
--- a/target-s390x/translate.c
5544c1
+++ b/target-s390x/translate.c
5544c1
@@ -276,19 +276,19 @@ static inline void potential_page_fault(DisasContext *s)
5544c1
 
5544c1
 static inline uint64_t ld_code2(uint64_t pc)
5544c1
 {
5544c1
-    return (uint64_t)lduw_code(pc);
5544c1
+    return (uint64_t)cpu_lduw_code(cpu_single_env, pc);
5544c1
 }
5544c1
 
5544c1
 static inline uint64_t ld_code4(uint64_t pc)
5544c1
 {
5544c1
-    return (uint64_t)ldl_code(pc);
5544c1
+    return (uint64_t)cpu_ldl_code(cpu_single_env, pc);
5544c1
 }
5544c1
 
5544c1
 static inline uint64_t ld_code6(uint64_t pc)
5544c1
 {
5544c1
     uint64_t opc;
5544c1
-    opc = (uint64_t)lduw_code(pc) << 32;
5544c1
-    opc |= (uint64_t)(uint32_t)ldl_code(pc+2);
5544c1
+    opc = (uint64_t)cpu_lduw_code(cpu_single_env, pc) << 32;
5544c1
+    opc |= (uint64_t)(uint32_t)cpu_ldl_code(cpu_single_env, pc + 2);
5544c1
     return opc;
5544c1
 }
5544c1
 
5544c1
@@ -1263,7 +1263,7 @@ static void gen_op_mvc(DisasContext *s, int l, TCGv_i64 s1, TCGv_i64 s2)
5544c1
         /* Fall back to helper */
5544c1
         vl = tcg_const_i32(l);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_mvc(vl, s1, s2);
5544c1
+        gen_helper_mvc(cpu_env, vl, s1, s2);
5544c1
         tcg_temp_free_i32(vl);
5544c1
         return;
5544c1
     }
5544c1
@@ -1455,7 +1455,7 @@ static void gen_op_clc(DisasContext *s, int l, TCGv_i64 s1, TCGv_i64 s2)
5544c1
 
5544c1
     potential_page_fault(s);
5544c1
     vl = tcg_const_i32(l);
5544c1
-    gen_helper_clc(cc_op, vl, s1, s2);
5544c1
+    gen_helper_clc(cc_op, cpu_env, vl, s1, s2);
5544c1
     tcg_temp_free_i32(vl);
5544c1
     set_cc_static(s);
5544c1
 }
5544c1
@@ -2094,7 +2094,7 @@ do_mh:
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stcmh(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_stcmh(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -2107,7 +2107,7 @@ do_mh:
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_lctlg(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_lctlg(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -2119,7 +2119,7 @@ do_mh:
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stctg(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_stctg(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -2131,7 +2131,7 @@ do_mh:
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
         /* XXX rewrite in tcg */
5544c1
-        gen_helper_csg(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_csg(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -2143,7 +2143,7 @@ do_mh:
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
         /* XXX rewrite in tcg */
5544c1
-        gen_helper_cdsg(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_cdsg(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -2183,7 +2183,7 @@ do_mh:
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
         /* XXX split CC calculation out */
5544c1
-        gen_helper_icmh(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_icmh(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -2635,7 +2635,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_cksm(tmp32_1, tmp32_2);
5544c1
+        gen_helper_cksm(cpu_env, tmp32_1, tmp32_2);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
         gen_op_movi_cc(s, 0);
5544c1
@@ -2664,7 +2664,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp2 = load_reg(r1);
5544c1
         tmp3 = load_reg(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_mvpg(tmp, tmp2, tmp3);
5544c1
+        gen_helper_mvpg(cpu_env, tmp, tmp2, tmp3);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i64(tmp2);
5544c1
         tcg_temp_free_i64(tmp3);
5544c1
@@ -2676,7 +2676,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp32_2 = tcg_const_i32(r1);
5544c1
         tmp32_3 = tcg_const_i32(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_mvst(tmp32_1, tmp32_2, tmp32_3);
5544c1
+        gen_helper_mvst(cpu_env, tmp32_1, tmp32_2, tmp32_3);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
         tcg_temp_free_i32(tmp32_3);
5544c1
@@ -2687,7 +2687,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp32_2 = tcg_const_i32(r1);
5544c1
         tmp32_3 = tcg_const_i32(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_clst(cc_op, tmp32_1, tmp32_2, tmp32_3);
5544c1
+        gen_helper_clst(cc_op, cpu_env, tmp32_1, tmp32_2, tmp32_3);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -2698,7 +2698,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp32_2 = tcg_const_i32(r1);
5544c1
         tmp32_3 = tcg_const_i32(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_srst(cc_op, tmp32_1, tmp32_2, tmp32_3);
5544c1
+        gen_helper_srst(cc_op, cpu_env, tmp32_1, tmp32_2, tmp32_3);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -2785,7 +2785,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
     case 0x0d: /* PTLB                [S] */
5544c1
         /* Purge TLB */
5544c1
         check_privileged(s, ilc);
5544c1
-        gen_helper_ptlb();
5544c1
+        gen_helper_ptlb(cpu_env);
5544c1
         break;
5544c1
     case 0x10: /* SPX      D2(B2)     [S] */
5544c1
         /* Set Prefix Register */
5544c1
@@ -2828,7 +2828,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         r2 = insn & 0xf;
5544c1
         tmp = load_reg(r1);
5544c1
         tmp2 = load_reg(r2);
5544c1
-        gen_helper_ipte(tmp, tmp2);
5544c1
+        gen_helper_ipte(cpu_env, tmp, tmp2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i64(tmp2);
5544c1
         break;
5544c1
@@ -2839,7 +2839,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         r2 = insn & 0xf;
5544c1
         tmp = load_reg(r2);
5544c1
         tmp2 = tcg_temp_new_i64();
5544c1
-        gen_helper_iske(tmp2, tmp);
5544c1
+        gen_helper_iske(tmp2, cpu_env, tmp);
5544c1
         store_reg(r1, tmp2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i64(tmp2);
5544c1
@@ -2851,7 +2851,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         r2 = insn & 0xf;
5544c1
         tmp32_1 = load_reg32(r1);
5544c1
         tmp = load_reg(r2);
5544c1
-        gen_helper_rrbe(cc_op, tmp32_1, tmp);
5544c1
+        gen_helper_rrbe(cc_op, cpu_env, tmp32_1, tmp);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
@@ -2863,7 +2863,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         r2 = insn & 0xf;
5544c1
         tmp32_1 = load_reg32(r1);
5544c1
         tmp = load_reg(r2);
5544c1
-        gen_helper_sske(tmp32_1, tmp);
5544c1
+        gen_helper_sske(cpu_env, tmp32_1, tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         break;
5544c1
@@ -2880,7 +2880,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         tmp32_1 = load_reg32(r1);
5544c1
         tmp = load_reg(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stura(tmp, tmp32_1);
5544c1
+        gen_helper_stura(cpu_env, tmp, tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         break;
5544c1
@@ -2891,7 +2891,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
5544c1
         r2 = insn & 0xf;
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r2);
5544c1
-        gen_helper_csp(cc_op, tmp32_1, tmp32_2);
5544c1
+        gen_helper_csp(cc_op, cpu_env, tmp32_1, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -3865,7 +3865,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
     int ilc;
5544c1
     int l1;
5544c1
 
5544c1
-    opc = ldub_code(s->pc);
5544c1
+    opc = cpu_ldub_code(cpu_single_env, s->pc);
5544c1
     LOG_DISAS("opc 0x%x\n", opc);
5544c1
 
5544c1
     ilc = get_ilc(opc);
5544c1
@@ -3951,7 +3951,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r2);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_mvcl(cc_op, tmp32_1, tmp32_2);
5544c1
+        gen_helper_mvcl(cc_op, cpu_env, tmp32_1, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4165,7 +4165,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp3 = tcg_const_i64(s->pc + 4);
5544c1
         update_psw_addr(s);
5544c1
         gen_op_calc_cc(s);
5544c1
-        gen_helper_ex(cc_op, cc_op, tmp2, tmp, tmp3);
5544c1
+        gen_helper_ex(cc_op, cpu_env, cc_op, tmp2, tmp, tmp3);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i64(tmp2);
5544c1
@@ -4694,7 +4694,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_lam(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_lam(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4706,7 +4706,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stam(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_stam(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4732,7 +4732,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_mvcle(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_mvcle(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -4745,7 +4745,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_clcle(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_clcle(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -4789,7 +4789,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp = decode_rx(s, insn, &r1, &x2, &b2, &d2;;
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_lra(cc_op, tmp, tmp32_1);
5544c1
+        gen_helper_lra(cc_op, cpu_env, tmp, tmp32_1);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -4835,7 +4835,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stctl(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_stctl(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4849,7 +4849,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_lctl(tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_lctl(cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4869,7 +4869,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = tcg_const_i32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_cs(cc_op, tmp32_1, tmp, tmp32_2);
5544c1
+        gen_helper_cs(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -4882,7 +4882,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = load_reg32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_clm(cc_op, tmp32_1, tmp32_2, tmp);
5544c1
+        gen_helper_clm(cc_op, cpu_env, tmp32_1, tmp32_2, tmp);
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
@@ -4895,7 +4895,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp32_1 = load_reg32(r1);
5544c1
         tmp32_2 = tcg_const_i32(r3);
5544c1
         potential_page_fault(s);
5544c1
-        gen_helper_stcm(tmp32_1, tmp32_2, tmp);
5544c1
+        gen_helper_stcm(cpu_env, tmp32_1, tmp32_2, tmp);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
         tcg_temp_free_i32(tmp32_1);
5544c1
         tcg_temp_free_i32(tmp32_2);
5544c1
@@ -4992,7 +4992,7 @@ static void disas_s390_insn(DisasContext *s)
5544c1
             break;
5544c1
         case 0xd4:
5544c1
             potential_page_fault(s);
5544c1
-            gen_helper_nc(cc_op, vl, tmp, tmp2);
5544c1
+            gen_helper_nc(cc_op, cpu_env, vl, tmp, tmp2);
5544c1
             set_cc_static(s);
5544c1
             break;
5544c1
         case 0xd5:
5544c1
@@ -5000,22 +5000,22 @@ static void disas_s390_insn(DisasContext *s)
5544c1
             break;
5544c1
         case 0xd6:
5544c1
             potential_page_fault(s);
5544c1
-            gen_helper_oc(cc_op, vl, tmp, tmp2);
5544c1
+            gen_helper_oc(cc_op, cpu_env, vl, tmp, tmp2);
5544c1
             set_cc_static(s);
5544c1
             break;
5544c1
         case 0xd7:
5544c1
             potential_page_fault(s);
5544c1
-            gen_helper_xc(cc_op, vl, tmp, tmp2);
5544c1
+            gen_helper_xc(cc_op, cpu_env, vl, tmp, tmp2);
5544c1
             set_cc_static(s);
5544c1
             break;
5544c1
         case 0xdc:
5544c1
             potential_page_fault(s);
5544c1
-            gen_helper_tr(vl, tmp, tmp2);
5544c1
+            gen_helper_tr(cpu_env, vl, tmp, tmp2);
5544c1
             set_cc_static(s);
5544c1
             break;
5544c1
         case 0xf3:
5544c1
             potential_page_fault(s);
5544c1
-            gen_helper_unpk(vl, tmp, tmp2);
5544c1
+            gen_helper_unpk(cpu_env, vl, tmp, tmp2);
5544c1
             break;
5544c1
         default:
5544c1
             tcg_abort();
5544c1
@@ -5040,9 +5040,9 @@ static void disas_s390_insn(DisasContext *s)
5544c1
         tmp2 = get_address(s, 0, b1, d1);
5544c1
         tmp3 = get_address(s, 0, b2, d2);
5544c1
         if (opc == 0xda) {
5544c1
-            gen_helper_mvcp(cc_op, tmp, tmp2, tmp3);
5544c1
+            gen_helper_mvcp(cc_op, cpu_env, tmp, tmp2, tmp3);
5544c1
         } else {
5544c1
-            gen_helper_mvcs(cc_op, tmp, tmp2, tmp3);
5544c1
+            gen_helper_mvcs(cc_op, cpu_env, tmp, tmp2, tmp3);
5544c1
         }
5544c1
         set_cc_static(s);
5544c1
         tcg_temp_free_i64(tmp);
5544c1
-- 
5544c1
1.7.12.1
5544c1