2012-10-28 18:05:07 +00:00
|
|
|
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);
|
|
|
|
address++;
|
|
|
|
}
|
|
|
|
mask = (mask << 1) & 0xf;
|
|
|
|
@@ -630,7 +637,8 @@ void HELPER(stcmh)(uint32_t r1, uint64_t address, uint32_t mask)
|
|
|
|
|
|
|
|
/* insert character under mask high; same as icm, but operates on the
|
|
|
|
upper half of r1 */
|
|
|
|
-uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
|
|
|
|
+uint32_t HELPER(icmh)(CPUS390XState *env, uint32_t r1, uint64_t address,
|
|
|
|
+ uint32_t mask)
|
|
|
|
{
|
|
|
|
int pos = 56; /* top of the upper half of r1 */
|
|
|
|
uint64_t rmask = 0xff00000000000000ULL;
|
|
|
|
@@ -641,7 +649,7 @@ uint32_t HELPER(icmh)(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;
|
|
|
|
}
|
|
|
|
@@ -661,12 +669,12 @@ uint32_t HELPER(icmh)(uint32_t r1, uint64_t address, uint32_t mask)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* load access registers r1 to r3 from memory at a2 */
|
|
|
|
-void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(lam)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- env->aregs[i] = ldl(a2);
|
|
|
|
+ env->aregs[i] = cpu_ldl_data(env, a2);
|
|
|
|
a2 += 4;
|
|
|
|
|
|
|
|
if (i == r3) {
|
|
|
|
@@ -676,12 +684,12 @@ void HELPER(lam)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* store access registers r1 to r3 in memory at a2 */
|
|
|
|
-void HELPER(stam)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(stam)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- stl(a2, env->aregs[i]);
|
|
|
|
+ cpu_stl_data(env, a2, env->aregs[i]);
|
|
|
|
a2 += 4;
|
|
|
|
|
|
|
|
if (i == r3) {
|
|
|
|
@@ -691,12 +699,12 @@ void HELPER(stam)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* move long */
|
|
|
|
-uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
|
|
|
|
+uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
|
|
|
|
{
|
|
|
|
uint64_t destlen = env->regs[r1 + 1] & 0xffffff;
|
|
|
|
- uint64_t dest = get_address_31fix(r1);
|
|
|
|
+ uint64_t dest = get_address_31fix(env, r1);
|
|
|
|
uint64_t srclen = env->regs[r2 + 1] & 0xffffff;
|
|
|
|
- uint64_t src = get_address_31fix(r2);
|
|
|
|
+ uint64_t src = get_address_31fix(env, r2);
|
|
|
|
uint8_t pad = src >> 24;
|
|
|
|
uint8_t v;
|
|
|
|
uint32_t cc;
|
|
|
|
@@ -714,12 +722,12 @@ uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; destlen && srclen; src++, dest++, destlen--, srclen--) {
|
|
|
|
- v = ldub(src);
|
|
|
|
- stb(dest, v);
|
|
|
|
+ v = cpu_ldub_data(env, src);
|
|
|
|
+ cpu_stb_data(env, dest, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; destlen; dest++, destlen--) {
|
|
|
|
- stb(dest, pad);
|
|
|
|
+ cpu_stb_data(env, dest, pad);
|
|
|
|
}
|
|
|
|
|
|
|
|
env->regs[r1 + 1] = destlen;
|
|
|
|
@@ -732,7 +740,8 @@ uint32_t HELPER(mvcl)(uint32_t r1, uint32_t r2)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* move long extended another memcopy insn with more bells and whistles */
|
|
|
|
-uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+uint32_t HELPER(mvcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
|
|
|
|
+ uint32_t r3)
|
|
|
|
{
|
|
|
|
uint64_t destlen = env->regs[r1 + 1];
|
|
|
|
uint64_t dest = env->regs[r1];
|
|
|
|
@@ -762,12 +771,12 @@ uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; destlen && srclen; src++, dest++, destlen--, srclen--) {
|
|
|
|
- v = ldub(src);
|
|
|
|
- stb(dest, v);
|
|
|
|
+ v = cpu_ldub_data(env, src);
|
|
|
|
+ cpu_stb_data(env, dest, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; destlen; dest++, destlen--) {
|
|
|
|
- stb(dest, pad);
|
|
|
|
+ cpu_stb_data(env, dest, pad);
|
|
|
|
}
|
|
|
|
|
|
|
|
env->regs[r1 + 1] = destlen;
|
|
|
|
@@ -781,12 +790,13 @@ uint32_t HELPER(mvcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* compare logical long extended memcompare insn with padding */
|
|
|
|
-uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+uint32_t HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
|
|
|
|
+ uint32_t r3)
|
|
|
|
{
|
|
|
|
uint64_t destlen = env->regs[r1 + 1];
|
|
|
|
- uint64_t dest = get_address_31fix(r1);
|
|
|
|
+ uint64_t dest = get_address_31fix(env, r1);
|
|
|
|
uint64_t srclen = env->regs[r3 + 1];
|
|
|
|
- uint64_t src = get_address_31fix(r3);
|
|
|
|
+ uint64_t src = get_address_31fix(env, r3);
|
|
|
|
uint8_t pad = a2 & 0xff;
|
|
|
|
uint8_t v1 = 0, v2 = 0;
|
|
|
|
uint32_t cc = 0;
|
|
|
|
@@ -800,8 +810,8 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; destlen || srclen; src++, dest++, destlen--, srclen--) {
|
|
|
|
- v1 = srclen ? ldub(src) : pad;
|
|
|
|
- v2 = destlen ? ldub(dest) : pad;
|
|
|
|
+ v1 = srclen ? cpu_ldub_data(env, src) : pad;
|
|
|
|
+ v2 = destlen ? cpu_ldub_data(env, dest) : pad;
|
|
|
|
if (v1 != v2) {
|
|
|
|
cc = (v1 < v2) ? 1 : 2;
|
|
|
|
break;
|
|
|
|
@@ -818,14 +828,14 @@ uint32_t HELPER(clcle)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* checksum */
|
|
|
|
-void HELPER(cksm)(uint32_t r1, uint32_t r2)
|
|
|
|
+void HELPER(cksm)(CPUS390XState *env, uint32_t r1, uint32_t r2)
|
|
|
|
{
|
|
|
|
- uint64_t src = get_address_31fix(r2);
|
|
|
|
+ uint64_t src = get_address_31fix(env, r2);
|
|
|
|
uint64_t src_len = env->regs[(r2 + 1) & 15];
|
|
|
|
uint64_t cksm = (uint32_t)env->regs[r1];
|
|
|
|
|
|
|
|
while (src_len >= 4) {
|
|
|
|
- cksm += ldl(src);
|
|
|
|
+ cksm += cpu_ldl_data(env, src);
|
|
|
|
|
|
|
|
/* move to next word */
|
|
|
|
src_len -= 4;
|
|
|
|
@@ -836,14 +846,14 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
- cksm += ldub(src) << 24;
|
|
|
|
+ cksm += cpu_ldub_data(env, src) << 24;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
- cksm += lduw(src) << 16;
|
|
|
|
+ cksm += cpu_lduw_data(env, src) << 16;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
- cksm += lduw(src) << 16;
|
|
|
|
- cksm += ldub(src + 2) << 8;
|
|
|
|
+ cksm += cpu_lduw_data(env, src) << 16;
|
|
|
|
+ cksm += cpu_ldub_data(env, src + 2) << 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -856,7 +866,8 @@ void HELPER(cksm)(uint32_t r1, uint32_t r2)
|
|
|
|
((uint32_t)cksm + (cksm >> 32));
|
|
|
|
}
|
|
|
|
|
|
|
|
-void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
|
|
|
|
+void HELPER(unpk)(CPUS390XState *env, uint32_t len, uint64_t dest,
|
|
|
|
+ uint64_t src)
|
|
|
|
{
|
|
|
|
int len_dest = len >> 4;
|
|
|
|
int len_src = len & 0xf;
|
|
|
|
@@ -867,8 +878,8 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
|
|
|
|
src += len_src;
|
|
|
|
|
|
|
|
/* last byte is special, it only flips the nibbles */
|
|
|
|
- b = ldub(src);
|
|
|
|
- stb(dest, (b << 4) | (b >> 4));
|
|
|
|
+ b = cpu_ldub_data(env, src);
|
|
|
|
+ cpu_stb_data(env, dest, (b << 4) | (b >> 4));
|
|
|
|
src--;
|
|
|
|
len_src--;
|
|
|
|
|
|
|
|
@@ -878,7 +889,7 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
|
|
|
|
uint8_t cur_byte = 0;
|
|
|
|
|
|
|
|
if (len_src > 0) {
|
|
|
|
- cur_byte = ldub(src);
|
|
|
|
+ cur_byte = cpu_ldub_data(env, src);
|
|
|
|
}
|
|
|
|
|
|
|
|
len_dest--;
|
|
|
|
@@ -897,30 +908,31 @@ void HELPER(unpk)(uint32_t len, uint64_t dest, uint64_t src)
|
|
|
|
/* zone bits */
|
|
|
|
cur_byte |= 0xf0;
|
|
|
|
|
|
|
|
- stb(dest, cur_byte);
|
|
|
|
+ cpu_stb_data(env, dest, cur_byte);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
-void HELPER(tr)(uint32_t len, uint64_t array, uint64_t trans)
|
|
|
|
+void HELPER(tr)(CPUS390XState *env, uint32_t len, uint64_t array,
|
|
|
|
+ uint64_t trans)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i <= len; i++) {
|
|
|
|
- uint8_t byte = ldub(array + i);
|
|
|
|
- uint8_t new_byte = ldub(trans + byte);
|
|
|
|
+ uint8_t byte = cpu_ldub_data(env, array + i);
|
|
|
|
+ uint8_t new_byte = cpu_ldub_data(env, trans + byte);
|
|
|
|
|
|
|
|
- stb(array + i, new_byte);
|
|
|
|
+ cpu_stb_data(env, array + i, new_byte);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
-void HELPER(lctlg)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(lctlg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint64_t src = a2;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- env->cregs[i] = ldq(src);
|
|
|
|
+ env->cregs[i] = cpu_ldq_data(env, src);
|
|
|
|
HELPER_LOG("load ctl %d from 0x%" PRIx64 " == 0x%" PRIx64 "\n",
|
|
|
|
i, src, env->cregs[i]);
|
|
|
|
src += sizeof(uint64_t);
|
|
|
|
@@ -933,13 +945,14 @@ void HELPER(lctlg)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
tlb_flush(env, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
-void HELPER(lctl)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(lctl)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint64_t src = a2;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- env->cregs[i] = (env->cregs[i] & 0xFFFFFFFF00000000ULL) | ldl(src);
|
|
|
|
+ env->cregs[i] = (env->cregs[i] & 0xFFFFFFFF00000000ULL) |
|
|
|
|
+ cpu_ldl_data(env, src);
|
|
|
|
src += sizeof(uint32_t);
|
|
|
|
|
|
|
|
if (i == r3) {
|
|
|
|
@@ -950,13 +963,13 @@ void HELPER(lctl)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
tlb_flush(env, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
-void HELPER(stctg)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(stctg)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint64_t dest = a2;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- stq(dest, env->cregs[i]);
|
|
|
|
+ cpu_stq_data(env, dest, env->cregs[i]);
|
|
|
|
dest += sizeof(uint64_t);
|
|
|
|
|
|
|
|
if (i == r3) {
|
|
|
|
@@ -965,13 +978,13 @@ void HELPER(stctg)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
-void HELPER(stctl)(uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
+void HELPER(stctl)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint64_t dest = a2;
|
|
|
|
|
|
|
|
for (i = r1;; i = (i + 1) % 16) {
|
|
|
|
- stl(dest, env->cregs[i]);
|
|
|
|
+ cpu_stl_data(env, dest, env->cregs[i]);
|
|
|
|
dest += sizeof(uint32_t);
|
|
|
|
|
|
|
|
if (i == r3) {
|
|
|
|
@@ -988,9 +1001,9 @@ uint32_t HELPER(tprot)(uint64_t a1, uint64_t a2)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* insert storage key extended */
|
|
|
|
-uint64_t HELPER(iske)(uint64_t r2)
|
|
|
|
+uint64_t HELPER(iske)(CPUS390XState *env, uint64_t r2)
|
|
|
|
{
|
|
|
|
- uint64_t addr = get_address(0, 0, r2);
|
|
|
|
+ uint64_t addr = get_address(env, 0, 0, r2);
|
|
|
|
|
|
|
|
if (addr > ram_size) {
|
|
|
|
return 0;
|
|
|
|
@@ -1000,9 +1013,9 @@ uint64_t HELPER(iske)(uint64_t r2)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set storage key extended */
|
|
|
|
-void HELPER(sske)(uint32_t r1, uint64_t r2)
|
|
|
|
+void HELPER(sske)(CPUS390XState *env, uint32_t r1, uint64_t r2)
|
|
|
|
{
|
|
|
|
- uint64_t addr = get_address(0, 0, r2);
|
|
|
|
+ uint64_t addr = get_address(env, 0, 0, r2);
|
|
|
|
|
|
|
|
if (addr > ram_size) {
|
|
|
|
return;
|
|
|
|
@@ -1012,7 +1025,7 @@ void HELPER(sske)(uint32_t r1, uint64_t r2)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reset reference bit extended */
|
|
|
|
-uint32_t HELPER(rrbe)(uint32_t r1, uint64_t r2)
|
|
|
|
+uint32_t HELPER(rrbe)(CPUS390XState *env, uint32_t r1, uint64_t r2)
|
|
|
|
{
|
|
|
|
uint8_t re;
|
|
|
|
uint8_t key;
|
|
|
|
@@ -1038,15 +1051,15 @@ uint32_t HELPER(rrbe)(uint32_t r1, uint64_t r2)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* compare and swap and purge */
|
|
|
|
-uint32_t HELPER(csp)(uint32_t r1, uint32_t r2)
|
|
|
|
+uint32_t HELPER(csp)(CPUS390XState *env, uint32_t r1, uint32_t r2)
|
|
|
|
{
|
|
|
|
uint32_t cc;
|
|
|
|
uint32_t o1 = env->regs[r1];
|
|
|
|
- uint64_t a2 = get_address_31fix(r2) & ~3ULL;
|
|
|
|
- uint32_t o2 = ldl(a2);
|
|
|
|
+ uint64_t a2 = get_address_31fix(env, r2) & ~3ULL;
|
|
|
|
+ uint32_t o2 = cpu_ldl_data(env, a2);
|
|
|
|
|
|
|
|
if (o1 == o2) {
|
|
|
|
- stl(a2, env->regs[(r1 + 1) & 15]);
|
|
|
|
+ cpu_stl_data(env, a2, env->regs[(r1 + 1) & 15]);
|
|
|
|
if (env->regs[r2] & 0x3) {
|
|
|
|
/* flush TLB / ALB */
|
|
|
|
tlb_flush(env, 1);
|
|
|
|
@@ -1060,8 +1073,8 @@ uint32_t HELPER(csp)(uint32_t r1, uint32_t r2)
|
|
|
|
return cc;
|
|
|
|
}
|
|
|
|
|
|
|
|
-static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
|
|
|
|
- uint64_t mode2)
|
|
|
|
+static uint32_t mvc_asc(CPUS390XState *env, int64_t l, uint64_t a1,
|
|
|
|
+ uint64_t mode1, uint64_t a2, uint64_t mode2)
|
|
|
|
{
|
|
|
|
target_ulong src, dest;
|
|
|
|
int flags, cc = 0, i;
|
|
|
|
@@ -1089,7 +1102,7 @@ static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
|
|
|
|
/* XXX be more clever */
|
|
|
|
if ((((dest + i) & TARGET_PAGE_MASK) != (dest & TARGET_PAGE_MASK)) ||
|
|
|
|
(((src + i) & TARGET_PAGE_MASK) != (src & TARGET_PAGE_MASK))) {
|
|
|
|
- mvc_asc(l - i, a1 + i, mode1, a2 + i, mode2);
|
|
|
|
+ mvc_asc(env, l - i, a1 + i, mode1, a2 + i, mode2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
stb_phys(dest + i, ldub_phys(src + i));
|
|
|
|
@@ -1098,24 +1111,24 @@ static uint32_t mvc_asc(int64_t l, uint64_t a1, uint64_t mode1, uint64_t a2,
|
|
|
|
return cc;
|
|
|
|
}
|
|
|
|
|
|
|
|
-uint32_t HELPER(mvcs)(uint64_t l, uint64_t a1, uint64_t a2)
|
|
|
|
+uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
|
|
|
|
{
|
|
|
|
HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
|
|
|
|
__func__, l, a1, a2);
|
|
|
|
|
|
|
|
- return mvc_asc(l, a1, PSW_ASC_SECONDARY, a2, PSW_ASC_PRIMARY);
|
|
|
|
+ return mvc_asc(env, l, a1, PSW_ASC_SECONDARY, a2, PSW_ASC_PRIMARY);
|
|
|
|
}
|
|
|
|
|
|
|
|
-uint32_t HELPER(mvcp)(uint64_t l, uint64_t a1, uint64_t a2)
|
|
|
|
+uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
|
|
|
|
{
|
|
|
|
HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
|
|
|
|
__func__, l, a1, a2);
|
|
|
|
|
|
|
|
- return mvc_asc(l, a1, PSW_ASC_PRIMARY, a2, PSW_ASC_SECONDARY);
|
|
|
|
+ return mvc_asc(env, l, a1, PSW_ASC_PRIMARY, a2, PSW_ASC_SECONDARY);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* invalidate pte */
|
|
|
|
-void HELPER(ipte)(uint64_t pte_addr, uint64_t vaddr)
|
|
|
|
+void HELPER(ipte)(CPUS390XState *env, uint64_t pte_addr, uint64_t vaddr)
|
|
|
|
{
|
|
|
|
uint64_t page = vaddr & TARGET_PAGE_MASK;
|
|
|
|
uint64_t pte = 0;
|
|
|
|
@@ -1141,19 +1154,19 @@ void HELPER(ipte)(uint64_t pte_addr, uint64_t vaddr)
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flush local tlb */
|
|
|
|
-void HELPER(ptlb)(void)
|
|
|
|
+void HELPER(ptlb)(CPUS390XState *env)
|
|
|
|
{
|
|
|
|
tlb_flush(env, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* store using real address */
|
|
|
|
-void HELPER(stura)(uint64_t addr, uint32_t v1)
|
|
|
|
+void HELPER(stura)(CPUS390XState *env, uint64_t addr, uint32_t v1)
|
|
|
|
{
|
|
|
|
- stw_phys(get_address(0, 0, addr), v1);
|
|
|
|
+ stw_phys(get_address(env, 0, 0, addr), v1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* load real address */
|
|
|
|
-uint32_t HELPER(lra)(uint64_t addr, uint32_t r1)
|
|
|
|
+uint32_t HELPER(lra)(CPUS390XState *env, uint64_t addr, uint32_t r1)
|
|
|
|
{
|
|
|
|
uint32_t cc = 0;
|
|
|
|
int old_exc = env->exception_index;
|
|
|
|
@@ -1188,52 +1201,3 @@ uint32_t HELPER(lra)(uint64_t addr, uint32_t r1)
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
-
|
|
|
|
-/* temporary wrappers */
|
|
|
|
-#if defined(CONFIG_USER_ONLY)
|
|
|
|
-#define ldub_data(addr) ldub_raw(addr)
|
|
|
|
-#define lduw_data(addr) lduw_raw(addr)
|
|
|
|
-#define ldl_data(addr) ldl_raw(addr)
|
|
|
|
-#define ldq_data(addr) ldq_raw(addr)
|
|
|
|
-
|
|
|
|
-#define stb_data(addr, data) stb_raw(addr, data)
|
|
|
|
-#define stw_data(addr, data) stw_raw(addr, data)
|
|
|
|
-#define stl_data(addr, data) stl_raw(addr, data)
|
|
|
|
-#define stq_data(addr, data) stq_raw(addr, data)
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#define WRAP_LD(rettype, fn) \
|
|
|
|
- rettype cpu_ ## fn(CPUS390XState *env1, target_ulong addr) \
|
|
|
|
- { \
|
|
|
|
- CPUS390XState *saved_env; \
|
|
|
|
- rettype ret; \
|
|
|
|
- \
|
|
|
|
- saved_env = env; \
|
|
|
|
- env = env1; \
|
|
|
|
- ret = fn(addr); \
|
|
|
|
- env = saved_env; \
|
|
|
|
- return ret; \
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
-WRAP_LD(uint32_t, ldub_data)
|
|
|
|
-WRAP_LD(uint32_t, lduw_data)
|
|
|
|
-WRAP_LD(uint32_t, ldl_data)
|
|
|
|
-WRAP_LD(uint64_t, ldq_data)
|
|
|
|
-#undef WRAP_LD
|
|
|
|
-
|
|
|
|
-#define WRAP_ST(datatype, fn) \
|
|
|
|
- void cpu_ ## fn(CPUS390XState *env1, target_ulong addr, datatype val) \
|
|
|
|
- { \
|
|
|
|
- CPUS390XState *saved_env; \
|
|
|
|
- \
|
|
|
|
- saved_env = env; \
|
|
|
|
- env = env1; \
|
|
|
|
- fn(addr, val); \
|
|
|
|
- env = saved_env; \
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
-WRAP_ST(uint32_t, stb_data)
|
|
|
|
-WRAP_ST(uint32_t, stw_data)
|
|
|
|
-WRAP_ST(uint32_t, stl_data)
|
|
|
|
-WRAP_ST(uint64_t, stq_data)
|
|
|
|
-#undef WRAP_ST
|
|
|
|
diff --git a/target-s390x/misc_helper.c b/target-s390x/misc_helper.c
|
|
|
|
index ced26c6..2938ac9 100644
|
|
|
|
--- a/target-s390x/misc_helper.c
|
|
|
|
+++ b/target-s390x/misc_helper.c
|
|
|
|
@@ -31,10 +31,7 @@
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
-/* temporarily disabled due to wrapper use */
|
|
|
|
-#if 0
|
|
|
|
#include "softmmu_exec.h"
|
|
|
|
-#endif
|
|
|
|
#include "sysemu.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
diff --git a/target-s390x/translate.c b/target-s390x/translate.c
|
|
|
|
index 0c61e63..66119cd 100644
|
|
|
|
--- a/target-s390x/translate.c
|
|
|
|
+++ b/target-s390x/translate.c
|
|
|
|
@@ -276,19 +276,19 @@ static inline void potential_page_fault(DisasContext *s)
|
|
|
|
|
|
|
|
static inline uint64_t ld_code2(uint64_t pc)
|
|
|
|
{
|
|
|
|
- return (uint64_t)lduw_code(pc);
|
|
|
|
+ return (uint64_t)cpu_lduw_code(cpu_single_env, pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint64_t ld_code4(uint64_t pc)
|
|
|
|
{
|
|
|
|
- return (uint64_t)ldl_code(pc);
|
|
|
|
+ return (uint64_t)cpu_ldl_code(cpu_single_env, pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint64_t ld_code6(uint64_t pc)
|
|
|
|
{
|
|
|
|
uint64_t opc;
|
|
|
|
- opc = (uint64_t)lduw_code(pc) << 32;
|
|
|
|
- opc |= (uint64_t)(uint32_t)ldl_code(pc+2);
|
|
|
|
+ opc = (uint64_t)cpu_lduw_code(cpu_single_env, pc) << 32;
|
|
|
|
+ opc |= (uint64_t)(uint32_t)cpu_ldl_code(cpu_single_env, pc + 2);
|
|
|
|
return opc;
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -1263,7 +1263,7 @@ static void gen_op_mvc(DisasContext *s, int l, TCGv_i64 s1, TCGv_i64 s2)
|
|
|
|
/* Fall back to helper */
|
|
|
|
vl = tcg_const_i32(l);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_mvc(vl, s1, s2);
|
|
|
|
+ gen_helper_mvc(cpu_env, vl, s1, s2);
|
|
|
|
tcg_temp_free_i32(vl);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
@@ -1455,7 +1455,7 @@ static void gen_op_clc(DisasContext *s, int l, TCGv_i64 s1, TCGv_i64 s2)
|
|
|
|
|
|
|
|
potential_page_fault(s);
|
|
|
|
vl = tcg_const_i32(l);
|
|
|
|
- gen_helper_clc(cc_op, vl, s1, s2);
|
|
|
|
+ gen_helper_clc(cc_op, cpu_env, vl, s1, s2);
|
|
|
|
tcg_temp_free_i32(vl);
|
|
|
|
set_cc_static(s);
|
|
|
|
}
|
|
|
|
@@ -2094,7 +2094,7 @@ do_mh:
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stcmh(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_stcmh(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -2107,7 +2107,7 @@ do_mh:
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_lctlg(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_lctlg(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -2119,7 +2119,7 @@ do_mh:
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stctg(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_stctg(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -2131,7 +2131,7 @@ do_mh:
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
/* XXX rewrite in tcg */
|
|
|
|
- gen_helper_csg(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_csg(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -2143,7 +2143,7 @@ do_mh:
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
/* XXX rewrite in tcg */
|
|
|
|
- gen_helper_cdsg(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_cdsg(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -2183,7 +2183,7 @@ do_mh:
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
/* XXX split CC calculation out */
|
|
|
|
- gen_helper_icmh(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_icmh(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -2635,7 +2635,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_cksm(tmp32_1, tmp32_2);
|
|
|
|
+ gen_helper_cksm(cpu_env, tmp32_1, tmp32_2);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
gen_op_movi_cc(s, 0);
|
|
|
|
@@ -2664,7 +2664,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp2 = load_reg(r1);
|
|
|
|
tmp3 = load_reg(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_mvpg(tmp, tmp2, tmp3);
|
|
|
|
+ gen_helper_mvpg(cpu_env, tmp, tmp2, tmp3);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i64(tmp2);
|
|
|
|
tcg_temp_free_i64(tmp3);
|
|
|
|
@@ -2676,7 +2676,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp32_2 = tcg_const_i32(r1);
|
|
|
|
tmp32_3 = tcg_const_i32(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_mvst(tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
+ gen_helper_mvst(cpu_env, tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
tcg_temp_free_i32(tmp32_3);
|
|
|
|
@@ -2687,7 +2687,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp32_2 = tcg_const_i32(r1);
|
|
|
|
tmp32_3 = tcg_const_i32(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_clst(cc_op, tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
+ gen_helper_clst(cc_op, cpu_env, tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -2698,7 +2698,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp32_2 = tcg_const_i32(r1);
|
|
|
|
tmp32_3 = tcg_const_i32(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_srst(cc_op, tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
+ gen_helper_srst(cc_op, cpu_env, tmp32_1, tmp32_2, tmp32_3);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -2785,7 +2785,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
case 0x0d: /* PTLB [S] */
|
|
|
|
/* Purge TLB */
|
|
|
|
check_privileged(s, ilc);
|
|
|
|
- gen_helper_ptlb();
|
|
|
|
+ gen_helper_ptlb(cpu_env);
|
|
|
|
break;
|
|
|
|
case 0x10: /* SPX D2(B2) [S] */
|
|
|
|
/* Set Prefix Register */
|
|
|
|
@@ -2828,7 +2828,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
r2 = insn & 0xf;
|
|
|
|
tmp = load_reg(r1);
|
|
|
|
tmp2 = load_reg(r2);
|
|
|
|
- gen_helper_ipte(tmp, tmp2);
|
|
|
|
+ gen_helper_ipte(cpu_env, tmp, tmp2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i64(tmp2);
|
|
|
|
break;
|
|
|
|
@@ -2839,7 +2839,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
r2 = insn & 0xf;
|
|
|
|
tmp = load_reg(r2);
|
|
|
|
tmp2 = tcg_temp_new_i64();
|
|
|
|
- gen_helper_iske(tmp2, tmp);
|
|
|
|
+ gen_helper_iske(tmp2, cpu_env, tmp);
|
|
|
|
store_reg(r1, tmp2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i64(tmp2);
|
|
|
|
@@ -2851,7 +2851,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
r2 = insn & 0xf;
|
|
|
|
tmp32_1 = load_reg32(r1);
|
|
|
|
tmp = load_reg(r2);
|
|
|
|
- gen_helper_rrbe(cc_op, tmp32_1, tmp);
|
|
|
|
+ gen_helper_rrbe(cc_op, cpu_env, tmp32_1, tmp);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
@@ -2863,7 +2863,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
r2 = insn & 0xf;
|
|
|
|
tmp32_1 = load_reg32(r1);
|
|
|
|
tmp = load_reg(r2);
|
|
|
|
- gen_helper_sske(tmp32_1, tmp);
|
|
|
|
+ gen_helper_sske(cpu_env, tmp32_1, tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
break;
|
|
|
|
@@ -2880,7 +2880,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
tmp32_1 = load_reg32(r1);
|
|
|
|
tmp = load_reg(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stura(tmp, tmp32_1);
|
|
|
|
+ gen_helper_stura(cpu_env, tmp, tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
break;
|
|
|
|
@@ -2891,7 +2891,7 @@ static void disas_b2(DisasContext *s, int op, uint32_t insn)
|
|
|
|
r2 = insn & 0xf;
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r2);
|
|
|
|
- gen_helper_csp(cc_op, tmp32_1, tmp32_2);
|
|
|
|
+ gen_helper_csp(cc_op, cpu_env, tmp32_1, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -3865,7 +3865,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
int ilc;
|
|
|
|
int l1;
|
|
|
|
|
|
|
|
- opc = ldub_code(s->pc);
|
|
|
|
+ opc = cpu_ldub_code(cpu_single_env, s->pc);
|
|
|
|
LOG_DISAS("opc 0x%x\n", opc);
|
|
|
|
|
|
|
|
ilc = get_ilc(opc);
|
|
|
|
@@ -3951,7 +3951,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r2);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_mvcl(cc_op, tmp32_1, tmp32_2);
|
|
|
|
+ gen_helper_mvcl(cc_op, cpu_env, tmp32_1, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4165,7 +4165,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp3 = tcg_const_i64(s->pc + 4);
|
|
|
|
update_psw_addr(s);
|
|
|
|
gen_op_calc_cc(s);
|
|
|
|
- gen_helper_ex(cc_op, cc_op, tmp2, tmp, tmp3);
|
|
|
|
+ gen_helper_ex(cc_op, cpu_env, cc_op, tmp2, tmp, tmp3);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i64(tmp2);
|
|
|
|
@@ -4694,7 +4694,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_lam(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_lam(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4706,7 +4706,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stam(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_stam(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4732,7 +4732,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_mvcle(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_mvcle(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -4745,7 +4745,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_clcle(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_clcle(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -4789,7 +4789,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp = decode_rx(s, insn, &r1, &x2, &b2, &d2);
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_lra(cc_op, tmp, tmp32_1);
|
|
|
|
+ gen_helper_lra(cc_op, cpu_env, tmp, tmp32_1);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -4835,7 +4835,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stctl(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_stctl(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4849,7 +4849,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_lctl(tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_lctl(cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4869,7 +4869,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = tcg_const_i32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_cs(cc_op, tmp32_1, tmp, tmp32_2);
|
|
|
|
+ gen_helper_cs(cc_op, cpu_env, tmp32_1, tmp, tmp32_2);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -4882,7 +4882,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = load_reg32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_clm(cc_op, tmp32_1, tmp32_2, tmp);
|
|
|
|
+ gen_helper_clm(cc_op, cpu_env, tmp32_1, tmp32_2, tmp);
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
@@ -4895,7 +4895,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp32_1 = load_reg32(r1);
|
|
|
|
tmp32_2 = tcg_const_i32(r3);
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_stcm(tmp32_1, tmp32_2, tmp);
|
|
|
|
+ gen_helper_stcm(cpu_env, tmp32_1, tmp32_2, tmp);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
tcg_temp_free_i32(tmp32_1);
|
|
|
|
tcg_temp_free_i32(tmp32_2);
|
|
|
|
@@ -4992,7 +4992,7 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
break;
|
|
|
|
case 0xd4:
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_nc(cc_op, vl, tmp, tmp2);
|
|
|
|
+ gen_helper_nc(cc_op, cpu_env, vl, tmp, tmp2);
|
|
|
|
set_cc_static(s);
|
|
|
|
break;
|
|
|
|
case 0xd5:
|
|
|
|
@@ -5000,22 +5000,22 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
break;
|
|
|
|
case 0xd6:
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_oc(cc_op, vl, tmp, tmp2);
|
|
|
|
+ gen_helper_oc(cc_op, cpu_env, vl, tmp, tmp2);
|
|
|
|
set_cc_static(s);
|
|
|
|
break;
|
|
|
|
case 0xd7:
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_xc(cc_op, vl, tmp, tmp2);
|
|
|
|
+ gen_helper_xc(cc_op, cpu_env, vl, tmp, tmp2);
|
|
|
|
set_cc_static(s);
|
|
|
|
break;
|
|
|
|
case 0xdc:
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_tr(vl, tmp, tmp2);
|
|
|
|
+ gen_helper_tr(cpu_env, vl, tmp, tmp2);
|
|
|
|
set_cc_static(s);
|
|
|
|
break;
|
|
|
|
case 0xf3:
|
|
|
|
potential_page_fault(s);
|
|
|
|
- gen_helper_unpk(vl, tmp, tmp2);
|
|
|
|
+ gen_helper_unpk(cpu_env, vl, tmp, tmp2);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
tcg_abort();
|
|
|
|
@@ -5040,9 +5040,9 @@ static void disas_s390_insn(DisasContext *s)
|
|
|
|
tmp2 = get_address(s, 0, b1, d1);
|
|
|
|
tmp3 = get_address(s, 0, b2, d2);
|
|
|
|
if (opc == 0xda) {
|
|
|
|
- gen_helper_mvcp(cc_op, tmp, tmp2, tmp3);
|
|
|
|
+ gen_helper_mvcp(cc_op, cpu_env, tmp, tmp2, tmp3);
|
|
|
|
} else {
|
|
|
|
- gen_helper_mvcs(cc_op, tmp, tmp2, tmp3);
|
|
|
|
+ gen_helper_mvcs(cc_op, cpu_env, tmp, tmp2, tmp3);
|
|
|
|
}
|
|
|
|
set_cc_static(s);
|
|
|
|
tcg_temp_free_i64(tmp);
|
|
|
|
--
|
2012-12-16 23:27:22 +00:00
|
|
|
1.8.0.2
|
2012-10-28 18:05:07 +00:00
|
|
|
|