@@ -1,14 +1,14 @@
DEF_HELPER_2(exception, noreturn, env, i32)
DEF_HELPER_2(data_exception, noreturn, env, i32)
-DEF_HELPER_FLAGS_4(nc, TCG_CALL_NO_WG, i32, env, i32, i64, i64)
-DEF_HELPER_FLAGS_4(oc, TCG_CALL_NO_WG, i32, env, i32, i64, i64)
-DEF_HELPER_FLAGS_4(xc, TCG_CALL_NO_WG, i32, env, i32, i64, i64)
+DEF_HELPER_FLAGS_4(nc, TCG_CALL_NO_WG, void, env, i32, i64, i64)
+DEF_HELPER_FLAGS_4(oc, TCG_CALL_NO_WG, void, env, i32, i64, i64)
+DEF_HELPER_FLAGS_4(xc, TCG_CALL_NO_WG, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_4(mvc, TCG_CALL_NO_WG, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_4(mvcin, TCG_CALL_NO_WG, void, env, i32, i64, i64)
-DEF_HELPER_FLAGS_4(clc, TCG_CALL_NO_WG, i32, env, i32, i64, i64)
-DEF_HELPER_3(mvcl, i32, env, i32, i32)
-DEF_HELPER_3(clcl, i32, env, i32, i32)
-DEF_HELPER_FLAGS_4(clm, TCG_CALL_NO_WG, i32, env, i32, i32, i64)
+DEF_HELPER_FLAGS_4(clc, TCG_CALL_NO_WG, void, env, i32, i64, i64)
+DEF_HELPER_3(mvcl, void, env, i32, i32)
+DEF_HELPER_3(clcl, void, env, i32, i32)
+DEF_HELPER_FLAGS_4(clm, TCG_CALL_NO_WG, void, env, i32, i32, i64)
DEF_HELPER_FLAGS_3(divs32, TCG_CALL_NO_WG, s64, env, s64, s64)
DEF_HELPER_FLAGS_3(divu32, TCG_CALL_NO_WG, i64, env, i64, i64)
DEF_HELPER_FLAGS_3(divs64, TCG_CALL_NO_WG, s64, env, s64, s64)
@@ -18,16 +18,16 @@ DEF_HELPER_3(srstu, void, env, i32, i32)
DEF_HELPER_4(clst, i64, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(mvn, TCG_CALL_NO_WG, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_4(mvo, TCG_CALL_NO_WG, void, env, i32, i64, i64)
-DEF_HELPER_FLAGS_4(mvpg, TCG_CALL_NO_WG, i32, env, i64, i32, i32)
+DEF_HELPER_FLAGS_4(mvpg, TCG_CALL_NO_WG, void, env, i64, i32, i32)
DEF_HELPER_FLAGS_4(mvz, TCG_CALL_NO_WG, void, env, i32, i64, i64)
-DEF_HELPER_3(mvst, i32, env, i32, i32)
+DEF_HELPER_3(mvst, void, env, i32, i32)
DEF_HELPER_4(ex, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_4(stam, TCG_CALL_NO_WG, void, env, i32, i64, i32)
DEF_HELPER_FLAGS_4(lam, TCG_CALL_NO_WG, void, env, i32, i64, i32)
-DEF_HELPER_4(mvcle, i32, env, i32, i64, i32)
-DEF_HELPER_4(mvclu, i32, env, i32, i64, i32)
-DEF_HELPER_4(clcle, i32, env, i32, i64, i32)
-DEF_HELPER_4(clclu, i32, env, i32, i64, i32)
+DEF_HELPER_4(mvcle, void, env, i32, i64, i32)
+DEF_HELPER_4(mvclu, void, env, i32, i64, i32)
+DEF_HELPER_4(clcle, void, env, i32, i64, i32)
+DEF_HELPER_4(clclu, void, env, i32, i64, i32)
DEF_HELPER_3(cegb, i64, env, s64, i32)
DEF_HELPER_3(cdgb, i64, env, s64, i32)
DEF_HELPER_3(cxgb, i64, env, s64, i32)
@@ -36,8 +36,8 @@ DEF_HELPER_3(cdlgb, i64, env, i64, i32)
DEF_HELPER_3(cxlgb, i64, env, i64, i32)
DEF_HELPER_4(cdsg, void, env, i64, i32, i32)
DEF_HELPER_4(cdsg_parallel, void, env, i64, i32, i32)
-DEF_HELPER_4(csst, i32, env, i32, i64, i64)
-DEF_HELPER_4(csst_parallel, i32, env, i32, i64, i64)
+DEF_HELPER_4(csst, void, env, i32, i64, i64)
+DEF_HELPER_4(csst_parallel, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_3(aeb, TCG_CALL_NO_WG, i64, env, i64, i64)
DEF_HELPER_FLAGS_3(adb, TCG_CALL_NO_WG, i64, env, i64, i64)
DEF_HELPER_FLAGS_5(axb, TCG_CALL_NO_WG, i64, env, i64, i64, i64, i64)
@@ -58,12 +58,12 @@ DEF_HELPER_FLAGS_2(lxdb, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_2(lxeb, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_3(ledb, TCG_CALL_NO_WG, i64, env, i64, i32)
DEF_HELPER_FLAGS_4(lexb, TCG_CALL_NO_WG, i64, env, i64, i64, i32)
-DEF_HELPER_FLAGS_3(ceb, TCG_CALL_NO_WG_SE, i32, env, i64, i64)
-DEF_HELPER_FLAGS_3(cdb, TCG_CALL_NO_WG_SE, i32, env, i64, i64)
-DEF_HELPER_FLAGS_5(cxb, TCG_CALL_NO_WG_SE, i32, env, i64, i64, i64, i64)
-DEF_HELPER_FLAGS_3(keb, TCG_CALL_NO_WG, i32, env, i64, i64)
-DEF_HELPER_FLAGS_3(kdb, TCG_CALL_NO_WG, i32, env, i64, i64)
-DEF_HELPER_FLAGS_5(kxb, TCG_CALL_NO_WG, i32, env, i64, i64, i64, i64)
+DEF_HELPER_FLAGS_3(ceb, TCG_CALL_NO_WG_SE, void, env, i64, i64)
+DEF_HELPER_FLAGS_3(cdb, TCG_CALL_NO_WG_SE, void, env, i64, i64)
+DEF_HELPER_FLAGS_5(cxb, TCG_CALL_NO_WG_SE, void, env, i64, i64, i64, i64)
+DEF_HELPER_FLAGS_3(keb, TCG_CALL_NO_WG, void, env, i64, i64)
+DEF_HELPER_FLAGS_3(kdb, TCG_CALL_NO_WG, void, env, i64, i64)
+DEF_HELPER_FLAGS_5(kxb, TCG_CALL_NO_WG, void, env, i64, i64, i64, i64)
DEF_HELPER_FLAGS_3(cgeb, TCG_CALL_NO_WG, i64, env, i64, i32)
DEF_HELPER_FLAGS_3(cgdb, TCG_CALL_NO_WG, i64, env, i64, i32)
DEF_HELPER_FLAGS_4(cgxb, TCG_CALL_NO_WG, i64, env, i64, i64, i32)
@@ -83,9 +83,9 @@ DEF_HELPER_FLAGS_4(maeb, TCG_CALL_NO_WG, i64, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(madb, TCG_CALL_NO_WG, i64, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(mseb, TCG_CALL_NO_WG, i64, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(msdb, TCG_CALL_NO_WG, i64, env, i64, i64, i64)
-DEF_HELPER_FLAGS_3(tceb, TCG_CALL_NO_RWG_SE, i32, env, i64, i64)
-DEF_HELPER_FLAGS_3(tcdb, TCG_CALL_NO_RWG_SE, i32, env, i64, i64)
-DEF_HELPER_FLAGS_4(tcxb, TCG_CALL_NO_RWG_SE, i32, env, i64, i64, i64)
+DEF_HELPER_FLAGS_3(tceb, TCG_CALL_NO_RWG_SE, void, env, i64, i64)
+DEF_HELPER_FLAGS_3(tcdb, TCG_CALL_NO_RWG_SE, void, env, i64, i64)
+DEF_HELPER_FLAGS_4(tcxb, TCG_CALL_NO_RWG_SE, void, env, i64, i64, i64)
DEF_HELPER_FLAGS_2(sqeb, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_2(sqdb, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_3(sqxb, TCG_CALL_NO_WG, i64, env, i64, i64)
@@ -94,33 +94,33 @@ DEF_HELPER_FLAGS_4(pack, TCG_CALL_NO_WG, void, env, i32, i64, i64)
DEF_HELPER_FLAGS_4(pka, TCG_CALL_NO_WG, void, env, i64, i64, i32)
DEF_HELPER_FLAGS_4(pku, TCG_CALL_NO_WG, void, env, i64, i64, i32)
DEF_HELPER_FLAGS_4(unpk, TCG_CALL_NO_WG, void, env, i32, i64, i64)
-DEF_HELPER_FLAGS_4(unpka, TCG_CALL_NO_WG, i32, env, i64, i32, i64)
-DEF_HELPER_FLAGS_4(unpku, TCG_CALL_NO_WG, i32, env, i64, i32, i64)
-DEF_HELPER_FLAGS_3(tp, TCG_CALL_NO_WG, i32, env, i64, i32)
+DEF_HELPER_FLAGS_4(unpka, TCG_CALL_NO_WG, void, env, i64, i32, i64)
+DEF_HELPER_FLAGS_4(unpku, TCG_CALL_NO_WG, void, env, i64, i32, i64)
+DEF_HELPER_FLAGS_3(tp, TCG_CALL_NO_WG, void, env, i64, i32)
DEF_HELPER_FLAGS_4(tr, TCG_CALL_NO_WG, void, env, i32, i64, i64)
DEF_HELPER_4(tre, i64, env, i64, i64, i64)
-DEF_HELPER_4(trt, i32, env, i32, i64, i64)
-DEF_HELPER_4(trtr, i32, env, i32, i64, i64)
-DEF_HELPER_5(trXX, i32, env, i32, i32, i32, i32)
+DEF_HELPER_4(trt, void, env, i32, i64, i64)
+DEF_HELPER_4(trtr, void, env, i32, i64, i64)
+DEF_HELPER_5(trXX, void, env, i32, i32, i32, i32)
DEF_HELPER_4(cksm, i64, env, i64, i64, i64)
DEF_HELPER_FLAGS_5(calc_cc, TCG_CALL_NO_RWG_SE, i32, env, i32, i64, i64, i64)
DEF_HELPER_FLAGS_2(sfpc, TCG_CALL_NO_WG, void, env, i64)
DEF_HELPER_FLAGS_2(sfas, TCG_CALL_NO_WG, void, env, i64)
DEF_HELPER_FLAGS_2(srnm, TCG_CALL_NO_WG, void, env, i64)
DEF_HELPER_FLAGS_1(popcnt, TCG_CALL_NO_RWG_SE, i64, i64)
-DEF_HELPER_2(stfle, i32, env, i64)
+DEF_HELPER_2(stfle, void, env, i64)
DEF_HELPER_FLAGS_2(lpq, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_2(lpq_parallel, TCG_CALL_NO_WG, i64, env, i64)
DEF_HELPER_FLAGS_4(stpq, TCG_CALL_NO_WG, void, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(stpq_parallel, TCG_CALL_NO_WG, void, env, i64, i64, i64)
-DEF_HELPER_4(mvcos, i32, env, i64, i64, i64)
-DEF_HELPER_4(cu12, i32, env, i32, i32, i32)
-DEF_HELPER_4(cu14, i32, env, i32, i32, i32)
-DEF_HELPER_4(cu21, i32, env, i32, i32, i32)
-DEF_HELPER_4(cu24, i32, env, i32, i32, i32)
-DEF_HELPER_4(cu41, i32, env, i32, i32, i32)
-DEF_HELPER_4(cu42, i32, env, i32, i32, i32)
-DEF_HELPER_5(msa, i32, env, i32, i32, i32, i32)
+DEF_HELPER_4(mvcos, void, env, i64, i64, i64)
+DEF_HELPER_4(cu12, void, env, i32, i32, i32)
+DEF_HELPER_4(cu14, void, env, i32, i32, i32)
+DEF_HELPER_4(cu21, void, env, i32, i32, i32)
+DEF_HELPER_4(cu24, void, env, i32, i32, i32)
+DEF_HELPER_4(cu41, void, env, i32, i32, i32)
+DEF_HELPER_4(cu42, void, env, i32, i32, i32)
+DEF_HELPER_5(msa, void, env, i32, i32, i32, i32)
DEF_HELPER_FLAGS_1(stpt, TCG_CALL_NO_RWG, i64, env)
DEF_HELPER_FLAGS_1(stck, TCG_CALL_NO_RWG_SE, i64, env)
DEF_HELPER_FLAGS_3(probe_write_access, TCG_CALL_NO_WG, void, env, i64, i64)
@@ -320,28 +320,28 @@ DEF_HELPER_4(gvec_vftci64, void, ptr, cptr, env, i32)
DEF_HELPER_4(gvec_vftci128, void, ptr, cptr, env, i32)
#ifndef CONFIG_USER_ONLY
-DEF_HELPER_3(servc, i32, env, i64, i64)
+DEF_HELPER_3(servc, void, env, i64, i64)
DEF_HELPER_4(diag, void, env, i32, i32, i32)
DEF_HELPER_3(load_psw, noreturn, env, i64, i64)
DEF_HELPER_FLAGS_2(spx, TCG_CALL_NO_RWG, void, env, i64)
-DEF_HELPER_FLAGS_2(sck, TCG_CALL_NO_RWG, i32, env, i64)
+DEF_HELPER_FLAGS_2(sck, TCG_CALL_NO_RWG, void, env, i64)
DEF_HELPER_FLAGS_2(sckc, TCG_CALL_NO_RWG, void, env, i64)
DEF_HELPER_FLAGS_2(sckpf, TCG_CALL_NO_RWG, void, env, i64)
DEF_HELPER_FLAGS_1(stckc, TCG_CALL_NO_RWG, i64, env)
DEF_HELPER_FLAGS_2(spt, TCG_CALL_NO_RWG, void, env, i64)
-DEF_HELPER_4(stsi, i32, env, i64, i64, i64)
+DEF_HELPER_4(stsi, void, env, i64, i64, i64)
DEF_HELPER_FLAGS_4(lctl, TCG_CALL_NO_WG, void, env, i32, i64, i32)
DEF_HELPER_FLAGS_4(lctlg, TCG_CALL_NO_WG, void, env, i32, i64, i32)
DEF_HELPER_FLAGS_4(stctl, TCG_CALL_NO_WG, void, env, i32, i64, i32)
DEF_HELPER_FLAGS_4(stctg, TCG_CALL_NO_WG, void, env, i32, i64, i32)
-DEF_HELPER_FLAGS_2(testblock, TCG_CALL_NO_WG, i32, env, i64)
-DEF_HELPER_FLAGS_3(tprot, TCG_CALL_NO_WG, i32, env, i64, i64)
+DEF_HELPER_FLAGS_2(testblock, TCG_CALL_NO_WG, void, env, i64)
+DEF_HELPER_FLAGS_3(tprot, TCG_CALL_NO_WG, void, env, i64, i64)
DEF_HELPER_FLAGS_2(iske, TCG_CALL_NO_RWG_SE, i64, env, i64)
DEF_HELPER_FLAGS_3(sske, TCG_CALL_NO_RWG, void, env, i64, i64)
-DEF_HELPER_FLAGS_2(rrbe, TCG_CALL_NO_RWG, i32, env, i64)
-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, i32)
+DEF_HELPER_FLAGS_2(rrbe, TCG_CALL_NO_RWG, void, env, i64)
+DEF_HELPER_4(mvcs, void, env, i64, i64, i64)
+DEF_HELPER_4(mvcp, void, env, i64, i64, i64)
+DEF_HELPER_4(sigp, void, env, i64, i32, i32)
DEF_HELPER_FLAGS_2(sacf, TCG_CALL_NO_WG, void, env, i64)
DEF_HELPER_FLAGS_4(idte, TCG_CALL_NO_RWG, void, env, i64, i64, i32)
DEF_HELPER_FLAGS_4(ipte, TCG_CALL_NO_RWG, void, env, i64, i64, i32)
@@ -365,7 +365,7 @@ DEF_HELPER_4(schm, void, env, i64, i64, i64)
DEF_HELPER_3(ssch, void, env, i64, i64)
DEF_HELPER_2(stcrw, void, env, i64)
DEF_HELPER_3(stsch, void, env, i64, i64)
-DEF_HELPER_2(tpi, i32, env, i64)
+DEF_HELPER_2(tpi, void, env, i64)
DEF_HELPER_3(tsch, void, env, i64, i64)
DEF_HELPER_2(chsc, void, env, i64)
@@ -18,8 +18,8 @@
#include "exec/exec-all.h"
#include "exec/cpu_ldst.h"
-uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,
- uint32_t type)
+void HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2,
+ uint32_t r3, uint32_t type)
{
const uintptr_t ra = GETPC();
const uint8_t mod = env->regs[0] & 0x80ULL;
@@ -57,5 +57,5 @@ uint32_t HELPER(msa)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t r3,
g_assert_not_reached();
}
- return 0;
+ env->cc_op = 0;
}
@@ -366,30 +366,30 @@ uint64_t HELPER(lexb)(CPUS390XState *env, uint64_t ah, uint64_t al,
}
/* 32-bit FP compare */
-uint32_t HELPER(ceb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
+void HELPER(ceb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
{
FloatRelation cmp = float32_compare_quiet(f1, f2, &env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
/* 64-bit FP compare */
-uint32_t HELPER(cdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
+void HELPER(cdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
{
FloatRelation cmp = float64_compare_quiet(f1, f2, &env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
/* 128-bit FP compare */
-uint32_t HELPER(cxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
- uint64_t bh, uint64_t bl)
+void HELPER(cxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
+ uint64_t bh, uint64_t bl)
{
FloatRelation cmp = float128_compare_quiet(make_float128(ah, al),
make_float128(bh, bl),
&env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
int s390_swap_bfp_rounding_mode(CPUS390XState *env, int m3)
@@ -706,30 +706,30 @@ uint64_t HELPER(fixb)(CPUS390XState *env, uint64_t ah, uint64_t al,
}
/* 32-bit FP compare and signal */
-uint32_t HELPER(keb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
+void HELPER(keb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
{
FloatRelation cmp = float32_compare(f1, f2, &env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
/* 64-bit FP compare and signal */
-uint32_t HELPER(kdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
+void HELPER(kdb)(CPUS390XState *env, uint64_t f1, uint64_t f2)
{
FloatRelation cmp = float64_compare(f1, f2, &env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
/* 128-bit FP compare and signal */
-uint32_t HELPER(kxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
- uint64_t bh, uint64_t bl)
+void HELPER(kxb)(CPUS390XState *env, uint64_t ah, uint64_t al,
+ uint64_t bh, uint64_t bl)
{
FloatRelation cmp = float128_compare(make_float128(ah, al),
make_float128(bh, bl),
&env->fpu_status);
handle_exceptions(env, false, GETPC());
- return float_comp_to_cc(env, cmp);
+ env->cc_op = float_comp_to_cc(env, cmp);
}
/* 32-bit FP multiply and add */
@@ -801,21 +801,21 @@ DEF_FLOAT_DCMASK(float64)
DEF_FLOAT_DCMASK(float128)
/* test data class 32-bit */
-uint32_t HELPER(tceb)(CPUS390XState *env, uint64_t f1, uint64_t m2)
+void HELPER(tceb)(CPUS390XState *env, uint64_t f1, uint64_t m2)
{
- return (m2 & float32_dcmask(env, f1)) != 0;
+ env->cc_op = (m2 & float32_dcmask(env, f1)) != 0;
}
/* test data class 64-bit */
-uint32_t HELPER(tcdb)(CPUS390XState *env, uint64_t v1, uint64_t m2)
+void HELPER(tcdb)(CPUS390XState *env, uint64_t v1, uint64_t m2)
{
- return (m2 & float64_dcmask(env, v1)) != 0;
+ env->cc_op = (m2 & float64_dcmask(env, v1)) != 0;
}
/* test data class 128-bit */
-uint32_t HELPER(tcxb)(CPUS390XState *env, uint64_t ah, uint64_t al, uint64_t m2)
+void HELPER(tcxb)(CPUS390XState *env, uint64_t ah, uint64_t al, uint64_t m2)
{
- return (m2 & float128_dcmask(env, make_float128(ah, al))) != 0;
+ env->cc_op = (m2 & float128_dcmask(env, make_float128(ah, al))) != 0;
}
/* square root 32-bit */
@@ -431,10 +431,9 @@ static uint32_t do_helper_nc(CPUS390XState *env, uint32_t l, uint64_t dest,
return c != 0;
}
-uint32_t HELPER(nc)(CPUS390XState *env, uint32_t l, uint64_t dest,
- uint64_t src)
+void HELPER(nc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
{
- return do_helper_nc(env, l, dest, src, GETPC());
+ env->cc_op = do_helper_nc(env, l, dest, src, GETPC());
}
/* xor on array */
@@ -472,10 +471,9 @@ static uint32_t do_helper_xc(CPUS390XState *env, uint32_t l, uint64_t dest,
return c != 0;
}
-uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest,
- uint64_t src)
+void HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
{
- return do_helper_xc(env, l, dest, src, GETPC());
+ env->cc_op = do_helper_xc(env, l, dest, src, GETPC());
}
/* or on array */
@@ -506,10 +504,9 @@ static uint32_t do_helper_oc(CPUS390XState *env, uint32_t l, uint64_t dest,
return c != 0;
}
-uint32_t HELPER(oc)(CPUS390XState *env, uint32_t l, uint64_t dest,
- uint64_t src)
+void HELPER(oc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
{
- return do_helper_oc(env, l, dest, src, GETPC());
+ env->cc_op = do_helper_oc(env, l, dest, src, GETPC());
}
/* memmove */
@@ -680,14 +677,13 @@ static uint32_t do_helper_clc(CPUS390XState *env, uint32_t l, uint64_t s1,
return cc;
}
-uint32_t HELPER(clc)(CPUS390XState *env, uint32_t l, uint64_t s1, uint64_t s2)
+void HELPER(clc)(CPUS390XState *env, uint32_t l, uint64_t s1, uint64_t s2)
{
- return do_helper_clc(env, l, s1, s2, GETPC());
+ env->cc_op = do_helper_clc(env, l, s1, s2, GETPC());
}
/* compare logical under mask */
-uint32_t HELPER(clm)(CPUS390XState *env, uint32_t r1, uint32_t mask,
- uint64_t addr)
+void HELPER(clm)(CPUS390XState *env, uint32_t r1, uint32_t mask, uint64_t addr)
{
uintptr_t ra = GETPC();
uint32_t cc = 0;
@@ -715,7 +711,7 @@ uint32_t HELPER(clm)(CPUS390XState *env, uint32_t r1, uint32_t mask,
}
HELPER_LOG("\n");
- return cc;
+ env->cc_op = cc;
}
static inline uint64_t get_address(CPUS390XState *env, int reg)
@@ -915,7 +911,7 @@ uint64_t HELPER(clst)(CPUS390XState *env, uint64_t c, uint64_t s1, uint64_t s2)
}
/* move page */
-uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint32_t r1, uint32_t r2)
+void HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint32_t r1, uint32_t r2)
{
const uint64_t src = get_address(env, r2) & TARGET_PAGE_MASK;
const uint64_t dst = get_address(env, r1) & TARGET_PAGE_MASK;
@@ -941,7 +937,8 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint32_t r1, uint32_t r2)
MMU_DATA_LOAD, mmu_idx, ra);
if (exc) {
if (cco) {
- return 2;
+ env->cc_op = 2;
+ return;
}
goto inject_exc;
}
@@ -949,12 +946,15 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint32_t r1, uint32_t r2)
MMU_DATA_STORE, mmu_idx, ra);
if (exc) {
if (cco && exc != PGM_PROTECTION) {
- return 1;
+ env->cc_op = 1;
+ return;
}
goto inject_exc;
}
access_memmove(env, &desta, &srca, ra);
- return 0; /* data moved */
+ env->cc_op = 0; /* data moved */
+ return;
+
inject_exc:
#if !defined(CONFIG_USER_ONLY)
if (exc != PGM_ADDRESSING) {
@@ -970,7 +970,7 @@ inject_exc:
}
/* string copy */
-uint32_t HELPER(mvst)(CPUS390XState *env, uint32_t r1, uint32_t r2)
+void HELPER(mvst)(CPUS390XState *env, uint32_t r1, uint32_t r2)
{
const int mmu_idx = cpu_mmu_index(env, false);
const uint64_t d = get_address(env, r1);
@@ -999,12 +999,13 @@ uint32_t HELPER(mvst)(CPUS390XState *env, uint32_t r1, uint32_t r2)
access_set_byte(env, &desta, i, v, ra);
if (v == c) {
set_address_zero(env, r1, d + i);
- return 1;
+ env->cc_op = 1;
+ return;
}
}
set_address_zero(env, r1, d + len);
set_address_zero(env, r2, s + len);
- return 3;
+ env->cc_op = 3;
}
/* load access registers r1 to r3 from memory at a2 */
@@ -1108,7 +1109,7 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
}
/* move long */
-uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
+void HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
{
const int mmu_idx = cpu_mmu_index(env, false);
uintptr_t ra = GETPC();
@@ -1135,7 +1136,8 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
if (unlikely(!destlen || cc == 3)) {
set_address_zero(env, r2, src);
set_address_zero(env, r1, dest);
- return cc;
+ env->cc_op = cc;
+ return;
} else if (!srclen) {
set_address_zero(env, r2, src);
}
@@ -1178,12 +1180,11 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
cpu_loop_exit_restore(cs, ra);
}
}
- return cc;
+ env->cc_op = cc;
}
/* move long extended */
-uint32_t HELPER(mvcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
- uint32_t r3)
+void HELPER(mvcle)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
{
uintptr_t ra = GETPC();
uint64_t destlen = get_length(env, r1 + 1);
@@ -1200,12 +1201,11 @@ uint32_t HELPER(mvcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
set_address(env, r1, dest);
set_address(env, r3, src);
- return cc;
+ env->cc_op = cc;
}
/* move long unicode */
-uint32_t HELPER(mvclu)(CPUS390XState *env, uint32_t r1, uint64_t a2,
- uint32_t r3)
+void HELPER(mvclu)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
{
uintptr_t ra = GETPC();
uint64_t destlen = get_length(env, r1 + 1);
@@ -1222,7 +1222,7 @@ uint32_t HELPER(mvclu)(CPUS390XState *env, uint32_t r1, uint64_t a2,
set_address(env, r1, dest);
set_address(env, r3, src);
- return cc;
+ env->cc_op = cc;
}
/* compare logical long helper */
@@ -1279,7 +1279,7 @@ static inline uint32_t do_clcl(CPUS390XState *env,
/* compare logical long */
-uint32_t HELPER(clcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
+void HELPER(clcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
{
uintptr_t ra = GETPC();
uint64_t src1len = extract64(env->regs[r1 + 1], 0, 24);
@@ -1296,12 +1296,11 @@ uint32_t HELPER(clcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
set_address(env, r1, src1);
set_address(env, r2, src3);
- return cc;
+ env->cc_op = cc;
}
/* compare logical long extended memcompare insn with padding */
-uint32_t HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
- uint32_t r3)
+void HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
{
uintptr_t ra = GETPC();
uint64_t src1len = get_length(env, r1 + 1);
@@ -1318,12 +1317,11 @@ uint32_t HELPER(clcle)(CPUS390XState *env, uint32_t r1, uint64_t a2,
set_address(env, r1, src1);
set_address(env, r3, src3);
- return cc;
+ env->cc_op = cc;
}
/* compare logical long unicode memcompare insn with padding */
-uint32_t HELPER(clclu)(CPUS390XState *env, uint32_t r1, uint64_t a2,
- uint32_t r3)
+void HELPER(clclu)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
{
uintptr_t ra = GETPC();
uint64_t src1len = get_length(env, r1 + 1);
@@ -1340,7 +1338,7 @@ uint32_t HELPER(clclu)(CPUS390XState *env, uint32_t r1, uint64_t a2,
set_address(env, r1, src1);
set_address(env, r3, src3);
- return cc;
+ env->cc_op = cc;
}
/* checksum */
@@ -1572,19 +1570,19 @@ static inline uint32_t do_unpkau(CPUS390XState *env, uint64_t dest,
return cc;
}
-uint32_t HELPER(unpka)(CPUS390XState *env, uint64_t dest, uint32_t destlen,
- uint64_t src)
+void HELPER(unpka)(CPUS390XState *env, uint64_t dest, uint32_t destlen,
+ uint64_t src)
{
- return do_unpkau(env, dest, destlen, 1, src, GETPC());
+ env->cc_op = do_unpkau(env, dest, destlen, 1, src, GETPC());
}
-uint32_t HELPER(unpku)(CPUS390XState *env, uint64_t dest, uint32_t destlen,
- uint64_t src)
+void HELPER(unpku)(CPUS390XState *env, uint64_t dest, uint32_t destlen,
+ uint64_t src)
{
- return do_unpkau(env, dest, destlen, 2, src, GETPC());
+ env->cc_op = do_unpkau(env, dest, destlen, 2, src, GETPC());
}
-uint32_t HELPER(tp)(CPUS390XState *env, uint64_t dest, uint32_t destlen)
+void HELPER(tp)(CPUS390XState *env, uint64_t dest, uint32_t destlen)
{
uintptr_t ra = GETPC();
uint32_t cc = 0;
@@ -1604,7 +1602,7 @@ uint32_t HELPER(tp)(CPUS390XState *env, uint64_t dest, uint32_t destlen)
}
}
- return cc;
+ env->cc_op = cc;
}
static uint32_t do_helper_tr(CPUS390XState *env, uint32_t len, uint64_t array,
@@ -1694,10 +1692,10 @@ static uint32_t do_helper_trt_fwd(CPUS390XState *env, uint32_t len,
return do_helper_trt(env, len, array, trans, 1, ra);
}
-uint32_t HELPER(trt)(CPUS390XState *env, uint32_t len, uint64_t array,
+void HELPER(trt)(CPUS390XState *env, uint32_t len, uint64_t array,
uint64_t trans)
{
- return do_helper_trt(env, len, array, trans, 1, GETPC());
+ env->cc_op = do_helper_trt(env, len, array, trans, 1, GETPC());
}
static uint32_t do_helper_trt_bkwd(CPUS390XState *env, uint32_t len,
@@ -1707,15 +1705,15 @@ static uint32_t do_helper_trt_bkwd(CPUS390XState *env, uint32_t len,
return do_helper_trt(env, len, array, trans, -1, ra);
}
-uint32_t HELPER(trtr)(CPUS390XState *env, uint32_t len, uint64_t array,
- uint64_t trans)
+void HELPER(trtr)(CPUS390XState *env, uint32_t len, uint64_t array,
+ uint64_t trans)
{
- return do_helper_trt(env, len, array, trans, -1, GETPC());
+ env->cc_op = do_helper_trt(env, len, array, trans, -1, GETPC());
}
/* Translate one/two to one/two */
-uint32_t HELPER(trXX)(CPUS390XState *env, uint32_t r1, uint32_t r2,
- uint32_t tst, uint32_t sizes)
+void HELPER(trXX)(CPUS390XState *env, uint32_t r1, uint32_t r2,
+ uint32_t tst, uint32_t sizes)
{
uintptr_t ra = GETPC();
int dsize = (sizes & 1) ? 1 : 2;
@@ -1764,7 +1762,7 @@ uint32_t HELPER(trXX)(CPUS390XState *env, uint32_t r1, uint32_t r2,
set_length(env, r1 + 1, len);
set_address(env, r2, src);
- return cc;
+ env->cc_op = cc;
}
void HELPER(cdsg)(CPUS390XState *env, uint64_t addr,
@@ -2002,15 +2000,15 @@ static uint32_t do_csst(CPUS390XState *env, uint32_t r3, uint64_t a1,
tcg_s390_program_interrupt(env, PGM_SPECIFICATION, ra);
}
-uint32_t HELPER(csst)(CPUS390XState *env, uint32_t r3, uint64_t a1, uint64_t a2)
+void HELPER(csst)(CPUS390XState *env, uint32_t r3, uint64_t a1, uint64_t a2)
{
- return do_csst(env, r3, a1, a2, false);
+ env->cc_op = do_csst(env, r3, a1, a2, false);
}
-uint32_t HELPER(csst_parallel)(CPUS390XState *env, uint32_t r3, uint64_t a1,
- uint64_t a2)
+void HELPER(csst_parallel)(CPUS390XState *env, uint32_t r3, uint64_t a1,
+ uint64_t a2)
{
- return do_csst(env, r3, a1, a2, true);
+ env->cc_op = do_csst(env, r3, a1, a2, true);
}
#if !defined(CONFIG_USER_ONLY)
@@ -2119,7 +2117,7 @@ void HELPER(stctl)(CPUS390XState *env, uint32_t r1, uint64_t a2, uint32_t r3)
}
}
-uint32_t HELPER(testblock)(CPUS390XState *env, uint64_t real_addr)
+void HELPER(testblock)(CPUS390XState *env, uint64_t real_addr)
{
uintptr_t ra = GETPC();
int i;
@@ -2130,13 +2128,14 @@ uint32_t HELPER(testblock)(CPUS390XState *env, uint64_t real_addr)
cpu_stq_mmuidx_ra(env, real_addr + i, 0, MMU_REAL_IDX, ra);
}
- return 0;
+ env->cc_op = 0;
}
-uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
+void HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
{
S390CPU *cpu = env_archcpu(env);
CPUState *cs = env_cpu(env);
+ int cc;
/*
* TODO: we currently don't handle all access protection types
@@ -2144,7 +2143,8 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
*/
if (!s390_cpu_virt_mem_check_write(cpu, a1, 0, 1)) {
/* Fetching permitted; storing permitted */
- return 0;
+ env->cc_op = 0;
+ return;
}
if (env->int_pgm_code == PGM_PROTECTION) {
@@ -2152,7 +2152,8 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
cs->exception_index = -1;
if (!s390_cpu_virt_mem_check_read(cpu, a1, 0, 1)) {
/* Fetching permitted; storing not permitted */
- return 1;
+ env->cc_op = 1;
+ return;
}
}
@@ -2160,17 +2161,21 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
case PGM_PROTECTION:
/* Fetching not permitted; storing not permitted */
cs->exception_index = -1;
- return 2;
+ cc = 2;
+ break;
case PGM_ADDRESSING:
case PGM_TRANS_SPEC:
/* exceptions forwarded to the guest */
s390_cpu_virt_mem_handle_exc(cpu, GETPC());
- return 0;
+ cc = 0;
+ break;
+ default:
+ /* Translation not available */
+ cs->exception_index = -1;
+ cc = 3;
+ break;
}
-
- /* Translation not available */
- cs->exception_index = -1;
- return 3;
+ env->cc_op = cc;
}
/* insert storage key extended */
@@ -2225,7 +2230,7 @@ void HELPER(sske)(CPUS390XState *env, uint64_t r1, uint64_t r2)
}
/* reset reference bit extended */
-uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
+void HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
{
MachineState *ms = MACHINE(qdev_get_machine());
static S390SKeysState *ss;
@@ -2233,7 +2238,8 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
uint8_t re, key;
if (r2 > ms->ram_size) {
- return 0;
+ env->cc_op = 0;
+ return;
}
if (unlikely(!ss)) {
@@ -2242,19 +2248,22 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
}
if (skeyclass->get_skeys(ss, r2 / TARGET_PAGE_SIZE, 1, &key)) {
- return 0;
+ env->cc_op = 0;
+ return;
}
re = key & (SK_R | SK_C);
key &= ~SK_R;
if (skeyclass->set_skeys(ss, r2 / TARGET_PAGE_SIZE, 1, &key)) {
- return 0;
+ env->cc_op = 0;
+ return;
}
- /*
- * As we can only flush by virtual address and not all the entries
- * that point to a physical address we have to flush the whole TLB.
- */
+
+ /*
+ * As we can only flush by virtual address and not all the entries
+ * that point to a physical address we have to flush the whole TLB.
+ */
tlb_flush_all_cpus_synced(env_cpu(env));
/*
@@ -2265,11 +2274,10 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
* 2 Reference bit one; change bit zero
* 3 Reference bit one; change bit one
*/
-
- return re >> 1;
+ env->cc_op = re >> 1;
}
-uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
+void HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
{
const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
S390Access srca, desta;
@@ -2285,22 +2293,23 @@ uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
}
l = wrap_length32(env, l);
- if (l > 256) {
- /* max 256 */
- l = 256;
- cc = 3;
- } else if (!l) {
- return cc;
- }
+ if (l != 0) {
+ if (l > 256) {
+ /* max 256 */
+ l = 256;
+ cc = 3;
+ }
- /* TODO: Access key handling */
- srca = access_prepare(env, a2, l, MMU_DATA_LOAD, MMU_PRIMARY_IDX, ra);
- desta = access_prepare(env, a1, l, MMU_DATA_STORE, MMU_SECONDARY_IDX, ra);
- access_memmove(env, &desta, &srca, ra);
- return cc;
+ /* TODO: Access key handling */
+ srca = access_prepare(env, a2, l, MMU_DATA_LOAD, MMU_PRIMARY_IDX, ra);
+ desta = access_prepare(env, a1, l, MMU_DATA_STORE,
+ MMU_SECONDARY_IDX, ra);
+ access_memmove(env, &desta, &srca, ra);
+ }
+ env->cc_op = cc;
}
-uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
+void HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
{
const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
S390Access srca, desta;
@@ -2316,19 +2325,21 @@ uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
}
l = wrap_length32(env, l);
- if (l > 256) {
- /* max 256 */
- l = 256;
- cc = 3;
- } else if (!l) {
- return cc;
- }
+ if (l != 0) {
+ if (l > 256) {
+ /* max 256 */
+ l = 256;
+ cc = 3;
+ }
- /* TODO: Access key handling */
- srca = access_prepare(env, a2, l, MMU_DATA_LOAD, MMU_SECONDARY_IDX, ra);
- desta = access_prepare(env, a1, l, MMU_DATA_STORE, MMU_PRIMARY_IDX, ra);
- access_memmove(env, &desta, &srca, ra);
- return cc;
+ /* TODO: Access key handling */
+ srca = access_prepare(env, a2, l, MMU_DATA_LOAD,
+ MMU_SECONDARY_IDX, ra);
+ desta = access_prepare(env, a1, l, MMU_DATA_STORE,
+ MMU_PRIMARY_IDX, ra);
+ access_memmove(env, &desta, &srca, ra);
+ }
+ env->cc_op = cc;
}
void HELPER(idte)(CPUS390XState *env, uint64_t r1, uint64_t r2, uint32_t m4)
@@ -2594,8 +2605,8 @@ void HELPER(ex)(CPUS390XState *env, uint32_t ilen, uint64_t r1, uint64_t addr)
env->ex_value = insn | ilen;
}
-uint32_t HELPER(mvcos)(CPUS390XState *env, uint64_t dest, uint64_t src,
- uint64_t len)
+void HELPER(mvcos)(CPUS390XState *env, uint64_t dest, uint64_t src,
+ uint64_t len)
{
const uint8_t psw_key = (env->psw.mask & PSW_MASK_KEY) >> PSW_SHIFT_KEY;
const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
@@ -2675,7 +2686,7 @@ uint32_t HELPER(mvcos)(CPUS390XState *env, uint64_t dest, uint64_t src,
access_memmove(env, &desta, &srca, ra);
}
- return cc;
+ env->cc_op = cc;
}
/* Decode a Unicode character. A return value < 0 indicates success, storing
@@ -2952,40 +2963,40 @@ static inline uint32_t convert_unicode(CPUS390XState *env, uint32_t r1,
return cc;
}
-uint32_t HELPER(cu12)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu12)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf8, encode_utf16);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf8, encode_utf16);
}
-uint32_t HELPER(cu14)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu14)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf8, encode_utf32);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf8, encode_utf32);
}
-uint32_t HELPER(cu21)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu21)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf16, encode_utf8);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf16, encode_utf8);
}
-uint32_t HELPER(cu24)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu24)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf16, encode_utf32);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf16, encode_utf32);
}
-uint32_t HELPER(cu41)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu41)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf32, encode_utf8);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf32, encode_utf8);
}
-uint32_t HELPER(cu42)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
+void HELPER(cu42)(CPUS390XState *env, uint32_t r1, uint32_t r2, uint32_t m3)
{
- return convert_unicode(env, r1, r2, m3, GETPC(),
- decode_utf32, encode_utf16);
+ env->cc_op = convert_unicode(env, r1, r2, m3, GETPC(),
+ decode_utf32, encode_utf16);
}
void probe_write_access(CPUS390XState *env, uint64_t addr, uint64_t len,
@@ -101,7 +101,7 @@ uint64_t HELPER(stck)(CPUS390XState *env)
#ifndef CONFIG_USER_ONLY
/* SCLP service call */
-uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
+void HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
{
qemu_mutex_lock_iothread();
int r = sclp_service_call(env, r1, r2);
@@ -109,7 +109,7 @@ uint32_t HELPER(servc)(CPUS390XState *env, uint64_t r1, uint64_t r2)
if (r < 0) {
tcg_s390_program_interrupt(env, -r, GETPC());
}
- return r;
+ env->cc_op = r;
}
void HELPER(diag)(CPUS390XState *env, uint32_t r1, uint32_t r3, uint32_t num)
@@ -202,7 +202,7 @@ void tcg_s390_tod_updated(CPUState *cs, run_on_cpu_data opaque)
}
/* Set Clock */
-uint32_t HELPER(sck)(CPUS390XState *env, uint64_t tod_low)
+void HELPER(sck)(CPUS390XState *env, uint64_t tod_low)
{
S390TODState *td = s390_get_todstate();
S390TODClass *tdc = S390_TOD_GET_CLASS(td);
@@ -214,7 +214,7 @@ uint32_t HELPER(sck)(CPUS390XState *env, uint64_t tod_low)
qemu_mutex_lock_iothread();
tdc->set(td, &tod, &error_abort);
qemu_mutex_unlock_iothread();
- return 0;
+ env->cc_op = 0;
}
/* Set Tod Programmable Field */
@@ -250,7 +250,7 @@ void HELPER(spt)(CPUS390XState *env, uint64_t time)
}
/* Store System Information */
-uint32_t HELPER(stsi)(CPUS390XState *env, uint64_t a0, uint64_t r0, uint64_t r1)
+void HELPER(stsi)(CPUS390XState *env, uint64_t a0, uint64_t r0, uint64_t r1)
{
const uintptr_t ra = GETPC();
const uint32_t sel1 = r0 & STSI_R0_SEL1_MASK;
@@ -263,7 +263,8 @@ uint32_t HELPER(stsi)(CPUS390XState *env, uint64_t a0, uint64_t r0, uint64_t r1)
if ((r0 & STSI_R0_FC_MASK) > STSI_R0_FC_LEVEL_3) {
/* invalid function code: no other checks are performed */
- return 3;
+ env->cc_op = 3;
+ return;
}
if ((r0 & STSI_R0_RESERVED_MASK) || (r1 & STSI_R1_RESERVED_MASK)) {
@@ -273,7 +274,8 @@ uint32_t HELPER(stsi)(CPUS390XState *env, uint64_t a0, uint64_t r0, uint64_t r1)
if ((r0 & STSI_R0_FC_MASK) == STSI_R0_FC_CURRENT) {
/* query the current level: no further checks are performed */
env->regs[0] = STSI_R0_FC_LEVEL_3;
- return 0;
+ env->cc_op = 0;
+ return;
}
if (a0 & ~TARGET_PAGE_MASK) {
@@ -394,11 +396,11 @@ uint32_t HELPER(stsi)(CPUS390XState *env, uint64_t a0, uint64_t r0, uint64_t r1)
}
}
- return cc;
+ env->cc_op = cc;
}
-uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,
- uint32_t r3)
+void HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,
+ uint32_t r3)
{
int cc;
@@ -407,7 +409,7 @@ uint32_t HELPER(sigp)(CPUS390XState *env, uint64_t order_code, uint32_t r1,
cc = handle_sigp(env, order_code & SIGP_ORDER_MASK, r1, r3);
qemu_mutex_unlock_iothread();
- return cc;
+ env->cc_op = cc;
}
#endif
@@ -503,7 +505,7 @@ void HELPER(stsch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
qemu_mutex_unlock_iothread();
}
-uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
+void HELPER(tpi)(CPUS390XState *env, uint64_t addr)
{
const uintptr_t ra = GETPC();
S390CPU *cpu = env_archcpu(env);
@@ -519,7 +521,8 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
io = qemu_s390_flic_dequeue_io(flic, env->cregs[6]);
if (!io) {
qemu_mutex_unlock_iothread();
- return 0;
+ env->cc_op = 0;
+ return;
}
if (addr) {
@@ -539,7 +542,8 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
qemu_mutex_unlock_iothread();
g_free(io);
s390_cpu_virt_mem_handle_exc(cpu, ra);
- return 0;
+ env->cc_op = 0;
+ return;
}
} else {
/* no protection applies */
@@ -553,7 +557,8 @@ uint32_t HELPER(tpi)(CPUS390XState *env, uint64_t addr)
g_free(io);
qemu_mutex_unlock_iothread();
- return 1;
+ env->cc_op = 1;
+ return;
}
void HELPER(tsch)(CPUS390XState *env, uint64_t r1, uint64_t inst)
@@ -669,7 +674,7 @@ void HELPER(stfl)(CPUS390XState *env)
}
#endif
-uint32_t HELPER(stfle)(CPUS390XState *env, uint64_t addr)
+void HELPER(stfle)(CPUS390XState *env, uint64_t addr)
{
const uintptr_t ra = GETPC();
const int count_bytes = ((env->regs[0] & 0xff) + 1) * 8;
@@ -693,7 +698,7 @@ uint32_t HELPER(stfle)(CPUS390XState *env, uint64_t addr)
}
env->regs[0] = deposit64(env->regs[0], 0, 8, (max_bytes / 8) - 1);
- return count_bytes >= max_bytes ? 0 : 3;
+ env->cc_op = count_bytes >= max_bytes ? 0 : 3;
}
#ifndef CONFIG_USER_ONLY
@@ -190,7 +190,6 @@ static TCGv_i64 psw_addr;
static TCGv_i64 psw_mask;
static TCGv_i64 gbea;
-static TCGv_i32 cc_op;
static TCGv_i64 cc_src;
static TCGv_i64 cc_dst;
static TCGv_i64 cc_vr;
@@ -212,8 +211,6 @@ void s390x_translate_init(void)
offsetof(CPUS390XState, gbea),
"gbea");
- cc_op = tcg_global_mem_new_i32(cpu_env, offsetof(CPUS390XState, cc_op),
- "cc_op");
cc_src = tcg_global_mem_new_i64(cpu_env, offsetof(CPUS390XState, cc_src),
"cc_src");
cc_dst = tcg_global_mem_new_i64(cpu_env, offsetof(CPUS390XState, cc_dst),
@@ -385,7 +382,8 @@ static void per_breaking_event(DisasContext *s)
static void update_cc_op(DisasContext *s)
{
if (s->cc_op != CC_OP_DYNAMIC && s->cc_op != CC_OP_STATIC) {
- tcg_gen_movi_i32(cc_op, s->cc_op);
+ tcg_gen_st_i32(tcg_constant_i32(s->cc_op), cpu_env,
+ offsetof(CPUS390XState, cc_op));
}
}
@@ -589,41 +587,46 @@ static void set_cc_static(DisasContext *s)
s->cc_op = CC_OP_STATIC;
}
-/* calculates cc into cc_op */
-static void gen_op_calc_cc(DisasContext *s)
+/* calculates cc into new_op */
+static void gen_op_calc_cc(DisasContext *s, TCGv_i32 new_op)
{
- TCGv_i32 local_cc_op = NULL;
+ TCGv_i32 old_op = NULL;
TCGv_i64 dummy = NULL;
switch (s->cc_op) {
default:
- dummy = tcg_const_i64(0);
+ dummy = tcg_constant_i64(0);
/* FALLTHRU */
case CC_OP_ADD_64:
case CC_OP_SUB_64:
case CC_OP_ADD_32:
case CC_OP_SUB_32:
- local_cc_op = tcg_const_i32(s->cc_op);
- break;
case CC_OP_CONST0:
case CC_OP_CONST1:
case CC_OP_CONST2:
case CC_OP_CONST3:
+ old_op = tcg_constant_i32(s->cc_op);
+ break;
case CC_OP_STATIC:
case CC_OP_DYNAMIC:
+ tcg_gen_ld_i32(new_op, cpu_env, offsetof(CPUS390XState, cc_op));
+ old_op = new_op;
+ break;
break;
}
switch (s->cc_op) {
+ case CC_OP_STATIC:
+ /* We loaded the correct value, and it is saved. */
+ return;
case CC_OP_CONST0:
case CC_OP_CONST1:
case CC_OP_CONST2:
case CC_OP_CONST3:
- /* s->cc_op is the cc value */
- tcg_gen_movi_i32(cc_op, s->cc_op - CC_OP_CONST0);
- break;
- case CC_OP_STATIC:
- /* env->cc_op already is the cc value */
+ {
+ QEMU_BUILD_BUG_ON(CC_OP_CONST0 != 0);
+ tcg_gen_mov_i32(new_op, old_op);
+ }
break;
case CC_OP_NZ:
case CC_OP_ABS_64:
@@ -640,7 +643,7 @@ static void gen_op_calc_cc(DisasContext *s)
case CC_OP_LCBB:
case CC_OP_MULS_32:
/* 1 argument */
- gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, dummy, cc_dst, dummy);
+ gen_helper_calc_cc(new_op, cpu_env, old_op, dummy, cc_dst, dummy);
break;
case CC_OP_ADDU:
case CC_OP_ICM:
@@ -657,29 +660,21 @@ static void gen_op_calc_cc(DisasContext *s)
case CC_OP_VC:
case CC_OP_MULS_64:
/* 2 arguments */
- gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, dummy);
+ gen_helper_calc_cc(new_op, cpu_env, old_op, cc_src, cc_dst, dummy);
break;
case CC_OP_ADD_64:
case CC_OP_SUB_64:
case CC_OP_ADD_32:
case CC_OP_SUB_32:
- /* 3 arguments */
- gen_helper_calc_cc(cc_op, cpu_env, local_cc_op, cc_src, cc_dst, cc_vr);
- break;
case CC_OP_DYNAMIC:
- /* unknown operation - assume 3 arguments and cc_op in env */
- gen_helper_calc_cc(cc_op, cpu_env, cc_op, cc_src, cc_dst, cc_vr);
+ /* 3 arguments */
+ gen_helper_calc_cc(new_op, cpu_env, old_op, cc_src, cc_dst, cc_vr);
break;
default:
- tcg_abort();
+ g_assert_not_reached();
}
- if (local_cc_op) {
- tcg_temp_free_i32(local_cc_op);
- }
- if (dummy) {
- tcg_temp_free_i64(dummy);
- }
+ tcg_gen_st_i32(new_op, cpu_env, offsetof(CPUS390XState, cc_op));
/* We now have cc in cc_op as constant */
set_cc_static(s);
@@ -750,6 +745,7 @@ static const TCGCond nz_cond[16] = {
static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
{
TCGCond cond;
+ TCGv_i32 cc_op = NULL;
enum cc_op old_cc_op = s->cc_op;
if (mask == 15 || mask == 0) {
@@ -856,16 +852,19 @@ static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
account_inline_branch(s, old_cc_op);
break;
+ case CC_OP_STATIC:
+ account_noninline_branch(s, old_cc_op);
+ /* FALLTHRU */
+
default:
do_dynamic:
/* Calculate cc value. */
- gen_op_calc_cc(s);
- /* FALLTHRU */
-
- case CC_OP_STATIC:
- /* Jump based on CC. We'll load up the real cond below;
- the assignment here merely avoids a compiler warning. */
- account_noninline_branch(s, old_cc_op);
+ cc_op = tcg_temp_new_i32();
+ gen_op_calc_cc(s, cc_op);
+ /*
+ * Jump based on CC. We'll load up the real cond below;
+ * the assignment here merely avoids a compiler warning.
+ */
old_cc_op = CC_OP_STATIC;
cond = TCG_COND_NEVER;
break;
@@ -934,7 +933,6 @@ static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
case CC_OP_STATIC:
c->is_64 = false;
c->u.s32.a = cc_op;
- c->g1 = true;
switch (mask) {
case 0x8 | 0x4 | 0x2: /* cc != 3 */
cond = TCG_COND_NE;
@@ -950,10 +948,8 @@ static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
break;
case 0x8 | 0x2: /* cc == 0 || cc == 2 => (cc & 1) == 0 */
cond = TCG_COND_EQ;
- c->g1 = false;
- c->u.s32.a = tcg_temp_new_i32();
c->u.s32.b = tcg_const_i32(0);
- tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
+ tcg_gen_andi_i32(cc_op, cc_op, 1);
break;
case 0x8 | 0x4: /* cc < 2 */
cond = TCG_COND_LTU;
@@ -969,10 +965,8 @@ static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
break;
case 0x4 | 0x1: /* cc == 1 || cc == 3 => (cc & 1) != 0 */
cond = TCG_COND_NE;
- c->g1 = false;
- c->u.s32.a = tcg_temp_new_i32();
c->u.s32.b = tcg_const_i32(0);
- tcg_gen_andi_i32(c->u.s32.a, cc_op, 1);
+ tcg_gen_andi_i32(cc_op, cc_op, 1);
break;
case 0x4: /* cc == 1 */
cond = TCG_COND_EQ;
@@ -993,7 +987,6 @@ static void disas_jcc(DisasContext *s, DisasCompare *c, uint32_t mask)
default:
/* CC is masked by something else: (8 >> cc) & mask. */
cond = TCG_COND_NE;
- c->g1 = false;
c->u.s32.a = tcg_const_i32(8);
c->u.s32.b = tcg_const_i32(0);
tcg_gen_shr_i32(c->u.s32.a, c->u.s32.a, cc_op);
@@ -1413,6 +1406,8 @@ static DisasJumpType op_addu64(DisasContext *s, DisasOps *o)
/* Compute carry into cc_src. */
static void compute_carry(DisasContext *s)
{
+ TCGv_i32 cc_op;
+
switch (s->cc_op) {
case CC_OP_ADDU:
/* The carry value is already in cc_src (1,0). */
@@ -1421,12 +1416,12 @@ static void compute_carry(DisasContext *s)
tcg_gen_addi_i64(cc_src, cc_src, 1);
break;
default:
- gen_op_calc_cc(s);
- /* fall through */
- case CC_OP_STATIC:
+ cc_op = tcg_temp_new_i32();
+ gen_op_calc_cc(s, cc_op);
/* The carry flag is the msb of CC; compute into cc_src. */
tcg_gen_extu_i32_i64(cc_src, cc_op);
tcg_gen_shri_i64(cc_src, cc_src, 1);
+ tcg_temp_free_i32(cc_op);
break;
}
}
@@ -1574,12 +1569,14 @@ static DisasJumpType op_bas(DisasContext *s, DisasOps *o)
static void save_link_info(DisasContext *s, DisasOps *o)
{
TCGv_i64 t;
+ TCGv_i32 cc_op;
if (s->base.tb->flags & (FLAG_MASK_32 | FLAG_MASK_64)) {
pc_to_link_info(o->out, s, s->pc_tmp);
return;
}
- gen_op_calc_cc(s);
+ cc_op = tcg_temp_new_i32();
+ gen_op_calc_cc(s, cc_op);
tcg_gen_andi_i64(o->out, o->out, 0xffffffff00000000ull);
tcg_gen_ori_i64(o->out, o->out, ((s->ilen / 2) << 30) | s->pc_tmp);
t = tcg_temp_new_i64();
@@ -1590,6 +1587,7 @@ static void save_link_info(DisasContext *s, DisasOps *o)
tcg_gen_shli_i64(t, t, 28);
tcg_gen_or_i64(o->out, o->out, t);
tcg_temp_free_i64(t);
+ tcg_temp_free_i32(cc_op);
}
static DisasJumpType op_bal(DisasContext *s, DisasOps *o)
@@ -1783,21 +1781,21 @@ static DisasJumpType op_cj(DisasContext *s, DisasOps *o)
static DisasJumpType op_ceb(DisasContext *s, DisasOps *o)
{
- gen_helper_ceb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_ceb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_cdb(DisasContext *s, DisasOps *o)
{
- gen_helper_cdb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_cdb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_cxb(DisasContext *s, DisasOps *o)
{
- gen_helper_cxb(cc_op, cpu_env, o->out, o->out2, o->in1, o->in2);
+ gen_helper_cxb(cpu_env, o->out, o->out2, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -2097,7 +2095,7 @@ static DisasJumpType op_clc(DisasContext *s, DisasOps *o)
break;
default:
vl = tcg_const_i32(l);
- gen_helper_clc(cc_op, cpu_env, vl, o->addr1, o->in2);
+ gen_helper_clc(cpu_env, vl, o->addr1, o->in2);
tcg_temp_free_i32(vl);
set_cc_static(s);
return DISAS_NEXT;
@@ -2120,7 +2118,7 @@ static DisasJumpType op_clcl(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t2 = tcg_const_i32(r2);
- gen_helper_clcl(cc_op, cpu_env, t1, t2);
+ gen_helper_clcl(cpu_env, t1, t2);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t2);
set_cc_static(s);
@@ -2141,7 +2139,7 @@ static DisasJumpType op_clcle(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t3 = tcg_const_i32(r3);
- gen_helper_clcle(cc_op, cpu_env, t1, o->in2, t3);
+ gen_helper_clcle(cpu_env, t1, o->in2, t3);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t3);
set_cc_static(s);
@@ -2162,7 +2160,7 @@ static DisasJumpType op_clclu(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t3 = tcg_const_i32(r3);
- gen_helper_clclu(cc_op, cpu_env, t1, o->in2, t3);
+ gen_helper_clclu(cpu_env, t1, o->in2, t3);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t3);
set_cc_static(s);
@@ -2174,7 +2172,7 @@ static DisasJumpType op_clm(DisasContext *s, DisasOps *o)
TCGv_i32 m3 = tcg_const_i32(get_field(s, m3));
TCGv_i32 t1 = tcg_temp_new_i32();
tcg_gen_extrl_i64_i32(t1, o->in1);
- gen_helper_clm(cc_op, cpu_env, t1, m3, o->in2);
+ gen_helper_clm(cpu_env, t1, m3, o->in2);
set_cc_static(s);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(m3);
@@ -2217,7 +2215,7 @@ static DisasJumpType op_cs(DisasContext *s, DisasOps *o)
produces the output CC value, thus the NE sense of the test. */
cc = tcg_temp_new_i64();
tcg_gen_setcond_i64(TCG_COND_NE, cc, o->in2, o->out);
- tcg_gen_extrl_i64_i32(cc_op, cc);
+ tcg_gen_st32_i64(cc, cpu_env, offsetof(CPUS390XState, cc_op));
tcg_temp_free_i64(cc);
set_cc_static(s);
@@ -2260,9 +2258,9 @@ static DisasJumpType op_csst(DisasContext *s, DisasOps *o)
TCGv_i32 t_r3 = tcg_const_i32(r3);
if (tb_cflags(s->base.tb) & CF_PARALLEL) {
- gen_helper_csst_parallel(cc_op, cpu_env, t_r3, o->addr1, o->in2);
+ gen_helper_csst_parallel(cpu_env, t_r3, o->addr1, o->in2);
} else {
- gen_helper_csst(cc_op, cpu_env, t_r3, o->addr1, o->in2);
+ gen_helper_csst(cpu_env, t_r3, o->addr1, o->in2);
}
tcg_temp_free_i32(t_r3);
@@ -2290,7 +2288,7 @@ static DisasJumpType op_csp(DisasContext *s, DisasOps *o)
/* Are the memory and expected values (un)equal? */
cc = tcg_temp_new_i64();
tcg_gen_setcond_i64(TCG_COND_NE, cc, o->in1, old);
- tcg_gen_extrl_i64_i32(cc_op, cc);
+ tcg_gen_st32_i64(cc, cpu_env, offsetof(CPUS390XState, cc_op));
/* Write back the output now, so that it happens before the
following branch, so that we don't need local temps. */
@@ -2368,22 +2366,22 @@ static DisasJumpType op_cuXX(DisasContext *s, DisasOps *o)
switch (s->insn->data) {
case 12:
- gen_helper_cu12(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu12(cpu_env, tr1, tr2, chk);
break;
case 14:
- gen_helper_cu14(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu14(cpu_env, tr1, tr2, chk);
break;
case 21:
- gen_helper_cu21(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu21(cpu_env, tr1, tr2, chk);
break;
case 24:
- gen_helper_cu24(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu24(cpu_env, tr1, tr2, chk);
break;
case 41:
- gen_helper_cu41(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu41(cpu_env, tr1, tr2, chk);
break;
case 42:
- gen_helper_cu42(cc_op, cpu_env, tr1, tr2, chk);
+ gen_helper_cu42(cpu_env, tr1, tr2, chk);
break;
default:
g_assert_not_reached();
@@ -2656,9 +2654,10 @@ static DisasJumpType op_insi(DisasContext *s, DisasOps *o)
static DisasJumpType op_ipm(DisasContext *s, DisasOps *o)
{
+ TCGv_i32 cc_op = tcg_temp_new_i32();
TCGv_i64 t1, t2;
- gen_op_calc_cc(s);
+ gen_op_calc_cc(s, cc_op);
t1 = tcg_temp_new_i64();
tcg_gen_extract_i64(t1, psw_mask, 40, 4);
t2 = tcg_temp_new_i64();
@@ -2667,6 +2666,7 @@ static DisasJumpType op_ipm(DisasContext *s, DisasOps *o)
tcg_gen_deposit_i64(o->out, o->out, t1, 24, 8);
tcg_temp_free_i64(t1);
tcg_temp_free_i64(t2);
+ tcg_temp_free_i32(cc_op);
return DISAS_NEXT;
}
@@ -2755,7 +2755,7 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o)
t_r2 = tcg_const_i32(r2);
t_r3 = tcg_const_i32(r3);
type = tcg_const_i32(s->insn->data);
- gen_helper_msa(cc_op, cpu_env, t_r1, t_r2, t_r3, type);
+ gen_helper_msa(cpu_env, t_r1, t_r2, t_r3, type);
set_cc_static(s);
tcg_temp_free_i32(t_r1);
tcg_temp_free_i32(t_r2);
@@ -2766,21 +2766,21 @@ static DisasJumpType op_msa(DisasContext *s, DisasOps *o)
static DisasJumpType op_keb(DisasContext *s, DisasOps *o)
{
- gen_helper_keb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_keb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_kdb(DisasContext *s, DisasOps *o)
{
- gen_helper_kdb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_kdb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_kxb(DisasContext *s, DisasOps *o)
{
- gen_helper_kxb(cc_op, cpu_env, o->out, o->out2, o->in1, o->in2);
+ gen_helper_kxb(cpu_env, o->out, o->out2, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -3420,7 +3420,7 @@ static DisasJumpType op_mvcl(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t2 = tcg_const_i32(r2);
- gen_helper_mvcl(cc_op, cpu_env, t1, t2);
+ gen_helper_mvcl(cpu_env, t1, t2);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t2);
set_cc_static(s);
@@ -3441,7 +3441,7 @@ static DisasJumpType op_mvcle(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t3 = tcg_const_i32(r3);
- gen_helper_mvcle(cc_op, cpu_env, t1, o->in2, t3);
+ gen_helper_mvcle(cpu_env, t1, o->in2, t3);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t3);
set_cc_static(s);
@@ -3462,7 +3462,7 @@ static DisasJumpType op_mvclu(DisasContext *s, DisasOps *o)
t1 = tcg_const_i32(r1);
t3 = tcg_const_i32(r3);
- gen_helper_mvclu(cc_op, cpu_env, t1, o->in2, t3);
+ gen_helper_mvclu(cpu_env, t1, o->in2, t3);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t3);
set_cc_static(s);
@@ -3472,7 +3472,7 @@ static DisasJumpType op_mvclu(DisasContext *s, DisasOps *o)
static DisasJumpType op_mvcos(DisasContext *s, DisasOps *o)
{
int r3 = get_field(s, r3);
- gen_helper_mvcos(cc_op, cpu_env, o->addr1, o->in2, regs[r3]);
+ gen_helper_mvcos(cpu_env, o->addr1, o->in2, regs[r3]);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -3481,7 +3481,7 @@ static DisasJumpType op_mvcos(DisasContext *s, DisasOps *o)
static DisasJumpType op_mvcp(DisasContext *s, DisasOps *o)
{
int r1 = get_field(s, l1);
- gen_helper_mvcp(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
+ gen_helper_mvcp(cpu_env, regs[r1], o->addr1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -3489,7 +3489,7 @@ static DisasJumpType op_mvcp(DisasContext *s, DisasOps *o)
static DisasJumpType op_mvcs(DisasContext *s, DisasOps *o)
{
int r1 = get_field(s, l1);
- gen_helper_mvcs(cc_op, cpu_env, regs[r1], o->addr1, o->in2);
+ gen_helper_mvcs(cpu_env, regs[r1], o->addr1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -3516,7 +3516,7 @@ static DisasJumpType op_mvpg(DisasContext *s, DisasOps *o)
TCGv_i32 t1 = tcg_const_i32(get_field(s, r1));
TCGv_i32 t2 = tcg_const_i32(get_field(s, r2));
- gen_helper_mvpg(cc_op, cpu_env, regs[0], t1, t2);
+ gen_helper_mvpg(cpu_env, regs[0], t1, t2);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t2);
set_cc_static(s);
@@ -3528,7 +3528,7 @@ static DisasJumpType op_mvst(DisasContext *s, DisasOps *o)
TCGv_i32 t1 = tcg_const_i32(get_field(s, r1));
TCGv_i32 t2 = tcg_const_i32(get_field(s, r2));
- gen_helper_mvst(cc_op, cpu_env, t1, t2);
+ gen_helper_mvst(cpu_env, t1, t2);
tcg_temp_free_i32(t1);
tcg_temp_free_i32(t2);
set_cc_static(s);
@@ -3659,7 +3659,7 @@ static DisasJumpType op_nabsf128(DisasContext *s, DisasOps *o)
static DisasJumpType op_nc(DisasContext *s, DisasOps *o)
{
TCGv_i32 l = tcg_const_i32(get_field(s, l1));
- gen_helper_nc(cc_op, cpu_env, l, o->addr1, o->in2);
+ gen_helper_nc(cpu_env, l, o->addr1, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -3693,7 +3693,7 @@ static DisasJumpType op_negf128(DisasContext *s, DisasOps *o)
static DisasJumpType op_oc(DisasContext *s, DisasOps *o)
{
TCGv_i32 l = tcg_const_i32(get_field(s, l1));
- gen_helper_oc(cc_op, cpu_env, l, o->addr1, o->in2);
+ gen_helper_oc(cpu_env, l, o->addr1, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -3979,7 +3979,7 @@ static DisasJumpType op_rll64(DisasContext *s, DisasOps *o)
#ifndef CONFIG_USER_ONLY
static DisasJumpType op_rrbe(DisasContext *s, DisasOps *o)
{
- gen_helper_rrbe(cc_op, cpu_env, o->in2);
+ gen_helper_rrbe(cpu_env, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4075,7 +4075,7 @@ static DisasJumpType op_sqxb(DisasContext *s, DisasOps *o)
#ifndef CONFIG_USER_ONLY
static DisasJumpType op_servc(DisasContext *s, DisasOps *o)
{
- gen_helper_servc(cc_op, cpu_env, o->in2, o->in1);
+ gen_helper_servc(cpu_env, o->in2, o->in1);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4084,7 +4084,7 @@ static DisasJumpType op_sigp(DisasContext *s, DisasOps *o)
{
TCGv_i32 r1 = tcg_const_i32(get_field(s, r1));
TCGv_i32 r3 = tcg_const_i32(get_field(s, r3));
- gen_helper_sigp(cc_op, cpu_env, o->in2, r1, r3);
+ gen_helper_sigp(cpu_env, o->in2, r1, r3);
set_cc_static(s);
tcg_temp_free_i32(r1);
tcg_temp_free_i32(r3);
@@ -4215,8 +4215,11 @@ static DisasJumpType op_srnmt(DisasContext *s, DisasOps *o)
static DisasJumpType op_spm(DisasContext *s, DisasOps *o)
{
- tcg_gen_extrl_i64_i32(cc_op, o->in1);
- tcg_gen_extract_i32(cc_op, cc_op, 28, 2);
+ TCGv_i64 tmp = tcg_temp_new_i64();
+
+ tcg_gen_extract_i64(tmp, o->in1, 28, 2);
+ tcg_gen_st32_i64(tmp, cpu_env, offsetof(CPUS390XState, cc_op));
+ tcg_temp_free_i64(tmp);
set_cc_static(s);
tcg_gen_shri_i64(o->in1, o->in1, 24);
@@ -4322,7 +4325,7 @@ static DisasJumpType op_stcke(DisasContext *s, DisasOps *o)
static DisasJumpType op_sck(DisasContext *s, DisasOps *o)
{
tcg_gen_qemu_ld_i64(o->in1, o->addr1, get_mem_index(s), MO_TEQ | MO_ALIGN);
- gen_helper_sck(cc_op, cpu_env, o->in1);
+ gen_helper_sck(cpu_env, o->in1);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4391,7 +4394,7 @@ static DisasJumpType op_stpt(DisasContext *s, DisasOps *o)
static DisasJumpType op_stsi(DisasContext *s, DisasOps *o)
{
- gen_helper_stsi(cc_op, cpu_env, o->in2, regs[0], regs[1]);
+ gen_helper_stsi(cpu_env, o->in2, regs[0], regs[1]);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4492,7 +4495,7 @@ static DisasJumpType op_stcrw(DisasContext *s, DisasOps *o)
static DisasJumpType op_tpi(DisasContext *s, DisasOps *o)
{
- gen_helper_tpi(cc_op, cpu_env, o->addr1);
+ gen_helper_tpi(cpu_env, o->addr1);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4556,7 +4559,7 @@ static DisasJumpType op_stura(DisasContext *s, DisasOps *o)
static DisasJumpType op_stfle(DisasContext *s, DisasOps *o)
{
- gen_helper_stfle(cc_op, cpu_env, o->in2);
+ gen_helper_stfle(cpu_env, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4747,17 +4750,19 @@ static DisasJumpType op_subu64(DisasContext *s, DisasOps *o)
/* Compute borrow (0, -1) into cc_src. */
static void compute_borrow(DisasContext *s)
{
+ TCGv_i32 cc_op;
+
switch (s->cc_op) {
case CC_OP_SUBU:
/* The borrow value is already in cc_src (0,-1). */
break;
default:
- gen_op_calc_cc(s);
- /* fall through */
- case CC_OP_STATIC:
+ cc_op = tcg_temp_new_i32();
+ gen_op_calc_cc(s, cc_op);
/* The carry flag is the msb of CC; compute into cc_src. */
tcg_gen_extu_i32_i64(cc_src, cc_op);
tcg_gen_shri_i64(cc_src, cc_src, 1);
+ tcg_temp_free_i32(cc_op);
/* fall through */
case CC_OP_ADDU:
/* Convert carry (1,0) to borrow (0,-1). */
@@ -4823,21 +4828,21 @@ static DisasJumpType op_tam(DisasContext *s, DisasOps *o)
static DisasJumpType op_tceb(DisasContext *s, DisasOps *o)
{
- gen_helper_tceb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_tceb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_tcdb(DisasContext *s, DisasOps *o)
{
- gen_helper_tcdb(cc_op, cpu_env, o->in1, o->in2);
+ gen_helper_tcdb(cpu_env, o->in1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_tcxb(DisasContext *s, DisasOps *o)
{
- gen_helper_tcxb(cc_op, cpu_env, o->out, o->out2, o->in2);
+ gen_helper_tcxb(cpu_env, o->out, o->out2, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4846,14 +4851,14 @@ static DisasJumpType op_tcxb(DisasContext *s, DisasOps *o)
static DisasJumpType op_testblock(DisasContext *s, DisasOps *o)
{
- gen_helper_testblock(cc_op, cpu_env, o->in2);
+ gen_helper_testblock(cpu_env, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
static DisasJumpType op_tprot(DisasContext *s, DisasOps *o)
{
- gen_helper_tprot(cc_op, cpu_env, o->addr1, o->in2);
+ gen_helper_tprot(cpu_env, o->addr1, o->in2);
set_cc_static(s);
return DISAS_NEXT;
}
@@ -4863,7 +4868,7 @@ static DisasJumpType op_tprot(DisasContext *s, DisasOps *o)
static DisasJumpType op_tp(DisasContext *s, DisasOps *o)
{
TCGv_i32 l1 = tcg_const_i32(get_field(s, l1) + 1);
- gen_helper_tp(cc_op, cpu_env, o->addr1, l1);
+ gen_helper_tp(cpu_env, o->addr1, l1);
tcg_temp_free_i32(l1);
set_cc_static(s);
return DISAS_NEXT;
@@ -4889,7 +4894,7 @@ static DisasJumpType op_tre(DisasContext *s, DisasOps *o)
static DisasJumpType op_trt(DisasContext *s, DisasOps *o)
{
TCGv_i32 l = tcg_const_i32(get_field(s, l1));
- gen_helper_trt(cc_op, cpu_env, l, o->addr1, o->in2);
+ gen_helper_trt(cpu_env, l, o->addr1, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -4898,7 +4903,7 @@ static DisasJumpType op_trt(DisasContext *s, DisasOps *o)
static DisasJumpType op_trtr(DisasContext *s, DisasOps *o)
{
TCGv_i32 l = tcg_const_i32(get_field(s, l1));
- gen_helper_trtr(cc_op, cpu_env, l, o->addr1, o->in2);
+ gen_helper_trtr(cpu_env, l, o->addr1, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -4925,7 +4930,7 @@ static DisasJumpType op_trXX(DisasContext *s, DisasOps *o)
tcg_gen_ext16u_i32(tst, tst);
}
}
- gen_helper_trXX(cc_op, cpu_env, r1, r2, tst, sizes);
+ gen_helper_trXX(cpu_env, r1, r2, tst, sizes);
tcg_temp_free_i32(r1);
tcg_temp_free_i32(r2);
@@ -4939,7 +4944,8 @@ static DisasJumpType op_ts(DisasContext *s, DisasOps *o)
{
TCGv_i32 t1 = tcg_const_i32(0xff);
tcg_gen_atomic_xchg_i32(t1, o->in2, t1, get_mem_index(s), MO_UB);
- tcg_gen_extract_i32(cc_op, t1, 7, 1);
+ tcg_gen_extract_i32(t1, t1, 7, 1);
+ tcg_gen_st_i32(t1, cpu_env, offsetof(CPUS390XState, cc_op));
tcg_temp_free_i32(t1);
set_cc_static(s);
return DISAS_NEXT;
@@ -4964,7 +4970,7 @@ static DisasJumpType op_unpka(DisasContext *s, DisasOps *o)
return DISAS_NORETURN;
}
l = tcg_const_i32(l1);
- gen_helper_unpka(cc_op, cpu_env, o->addr1, l, o->in2);
+ gen_helper_unpka(cpu_env, o->addr1, l, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -4981,7 +4987,7 @@ static DisasJumpType op_unpku(DisasContext *s, DisasOps *o)
return DISAS_NORETURN;
}
l = tcg_const_i32(l1);
- gen_helper_unpku(cc_op, cpu_env, o->addr1, l, o->in2);
+ gen_helper_unpku(cpu_env, o->addr1, l, o->in2);
tcg_temp_free_i32(l);
set_cc_static(s);
return DISAS_NEXT;
@@ -5035,7 +5041,7 @@ static DisasJumpType op_xc(DisasContext *s, DisasOps *o)
/* But in general we'll defer to a helper. */
o->in2 = get_address(s, 0, b2, d2);
t32 = tcg_const_i32(l);
- gen_helper_xc(cc_op, cpu_env, t32, o->addr1, o->in2);
+ gen_helper_xc(cpu_env, t32, o->addr1, o->in2);
tcg_temp_free_i32(t32);
set_cc_static(s);
return DISAS_NEXT;
Remove cc_op as a TCG global and store to it directly. This will help simplify the fix for some fpu bugs. Signed-off-by: Richard Henderson <richard.henderson@linaro.org> --- target/s390x/helper.h | 98 ++++++------- target/s390x/crypto_helper.c | 6 +- target/s390x/fpu_helper.c | 40 +++--- target/s390x/mem_helper.c | 265 ++++++++++++++++++----------------- target/s390x/misc_helper.c | 39 +++--- target/s390x/translate.c | 218 ++++++++++++++-------------- 6 files changed, 344 insertions(+), 322 deletions(-) -- 2.25.1