Translators are no longer required to free tcg temporaries.
Reviewed-by: Weiwei Li <liweiwei@iscas.ac.cn>
Reviewed-by: Daniel Henrique Barboza <dbarboza@ventanamicro.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
TCGv t = tcg_temp_new();
tcg_gen_shli_tl(t, arg1, 32);
tcg_gen_clzi_tl(ret, t, 32);
- tcg_temp_free(t);
}
static bool trans_clz(DisasContext *ctx, arg_clz *a)
gen_sbop_mask(t, shamt);
tcg_gen_or_tl(ret, arg1, t);
-
- tcg_temp_free(t);
}
static bool trans_bset(DisasContext *ctx, arg_bset *a)
gen_sbop_mask(t, shamt);
tcg_gen_andc_tl(ret, arg1, t);
-
- tcg_temp_free(t);
}
static bool trans_bclr(DisasContext *ctx, arg_bclr *a)
gen_sbop_mask(t, shamt);
tcg_gen_xor_tl(ret, arg1, t);
-
- tcg_temp_free(t);
}
static bool trans_binv(DisasContext *ctx, arg_binv *a)
/* sign-extend 64-bits */
tcg_gen_ext_i32_tl(ret, t1);
-
- tcg_temp_free_i32(t1);
- tcg_temp_free_i32(t2);
}
static bool trans_ror(DisasContext *ctx, arg_ror *a)
tcg_gen_trunc_tl_i32(t1, arg1);
tcg_gen_rotri_i32(t1, t1, shamt);
tcg_gen_ext_i32_tl(ret, t1);
-
- tcg_temp_free_i32(t1);
}
static bool trans_rori(DisasContext *ctx, arg_rori *a)
/* sign-extend 64-bits */
tcg_gen_ext_i32_tl(ret, t1);
-
- tcg_temp_free_i32(t1);
- tcg_temp_free_i32(t2);
}
static bool trans_rol(DisasContext *ctx, arg_rol *a)
/* Replicate the lsb of each byte across the byte. */
tcg_gen_muli_tl(ret, tmp, 0xff);
-
- tcg_temp_free(tmp);
}
static bool trans_orc_b(DisasContext *ctx, arg_orc_b *a)
\
tcg_gen_shli_tl(t, arg1, SHAMT); \
tcg_gen_add_tl(ret, t, arg2); \
- \
- tcg_temp_free(t); \
}
GEN_SHADD(1)
\
tcg_gen_shli_tl(t, t, SHAMT); \
tcg_gen_add_tl(ret, t, arg2); \
- \
- tcg_temp_free(t); \
}
GEN_SHADD_UW(1)
TCGv t = tcg_temp_new();
tcg_gen_ext32u_tl(t, arg1);
tcg_gen_add_tl(ret, t, arg2);
- tcg_temp_free(t);
}
static bool trans_add_uw(DisasContext *ctx, arg_add_uw *a)
tcg_gen_ext8u_tl(t, src2);
tcg_gen_deposit_tl(ret, src1, t, 8, TARGET_LONG_BITS - 8);
- tcg_temp_free(t);
}
static void gen_packw(TCGv ret, TCGv src1, TCGv src2)
tcg_gen_ext16s_tl(t, src2);
tcg_gen_deposit_tl(ret, src1, t, 16, TARGET_LONG_BITS - 16);
- tcg_temp_free(t);
}
static bool trans_brev8(DisasContext *ctx, arg_brev8 *a)
TCGv_i64 t0 = tcg_temp_new_i64();
tcg_gen_not_i64(t0, src2);
tcg_gen_deposit_i64(dest, t0, src1, 0, 63);
- tcg_temp_free_i64(t0);
}
gen_set_fpr_d(ctx, a->rd, dest);
mark_fs_dirty(ctx);
TCGv_i64 t0 = tcg_temp_new_i64();
tcg_gen_andi_i64(t0, src2, INT64_MIN);
tcg_gen_xor_i64(dest, src1, t0);
- tcg_temp_free_i64(t0);
}
gen_set_fpr_d(ctx, a->rd, dest);
mark_fs_dirty(ctx);
/* This formulation retains the nanboxing of rs2 in normal 'F'. */
tcg_gen_deposit_i64(dest, rs2, rs1, 0, 31);
-
- tcg_temp_free_i64(rs1);
- tcg_temp_free_i64(rs2);
} else {
tcg_gen_deposit_i64(dest, src2, src1, 0, 31);
tcg_gen_ext32s_i64(dest, dest);
tcg_gen_nor_i64(rs2, rs2, mask);
tcg_gen_and_i64(dest, mask, rs1);
tcg_gen_or_i64(dest, dest, rs2);
-
- tcg_temp_free_i64(rs2);
}
/* signed-extended intead of nanboxing for result if enable zfinx */
if (ctx->cfg_ptr->ext_zfinx) {
tcg_gen_ext32s_i64(dest, dest);
}
gen_set_fpr_hs(ctx, a->rd, dest);
- tcg_temp_free_i64(rs1);
mark_fs_dirty(ctx);
return true;
}
*/
tcg_gen_andi_i64(dest, rs2, MAKE_64BIT_MASK(31, 1));
tcg_gen_xor_i64(dest, rs1, dest);
-
- tcg_temp_free_i64(rs2);
}
/* signed-extended intead of nanboxing for result if enable zfinx */
if (ctx->cfg_ptr->ext_zfinx) {
tcg_gen_ext32s_i64(dest, dest);
}
- tcg_temp_free_i64(rs1);
gen_set_fpr_hs(ctx, a->rd, dest);
mark_fs_dirty(ctx);
return true;
misaligned = gen_new_label();
tcg_gen_andi_tl(t0, cpu_pc, 0x2);
tcg_gen_brcondi_tl(TCG_COND_NE, t0, 0x0, misaligned);
- tcg_temp_free(t0);
}
gen_set_gpri(ctx, a->rd, ctx->pc_succ_insn);
tcg_gen_xor_tl(tmp, ah, bh);
tcg_gen_and_tl(rl, rl, tmp);
tcg_gen_xor_tl(rl, rh, rl);
-
- tcg_temp_free(tmp);
}
break;
/* seed third word with 1, which will be result */
tcg_gen_sub2_tl(tmp, rh, ah, one, tmp, zero);
tcg_gen_sub2_tl(tmp, rl, tmp, rh, bh, zero);
-
- tcg_temp_free(tmp);
}
break;
if (invert) {
cond = tcg_invert_cond(cond);
}
-
- tcg_temp_free(rh);
return cond;
}
cond = gen_compare_i128(a->rs2 == 0,
tmp, src1, src1h, src2, src2h, cond);
tcg_gen_brcondi_tl(cond, tmp, 0, l);
-
- tcg_temp_free(tmp);
} else {
tcg_gen_brcond_tl(cond, src1, src2, l);
}
}
gen_set_gpr128(ctx, a->rd, destl, desth);
-
- tcg_temp_free(addrl);
return true;
}
tcg_gen_addi_tl(addrl, addrl, 8);
tcg_gen_qemu_st_tl(src2h, addrl, ctx->mem_idx, MO_TEUQ);
}
-
- tcg_temp_free(addrl);
return true;
}
tcg_gen_movcond_tl(TCG_COND_NE, destl, hs, zero, zero, ll);
tcg_gen_movcond_tl(TCG_COND_NE, desth, hs, zero, ll, h1);
-
- tcg_temp_free(ls);
- tcg_temp_free(rs);
- tcg_temp_free(hs);
- tcg_temp_free(ll);
- tcg_temp_free(lr);
- tcg_temp_free(h0);
- tcg_temp_free(h1);
}
static bool trans_sll(DisasContext *ctx, arg_sll *a)
tcg_gen_movcond_tl(TCG_COND_NE, destl, hs, zero, h1, h0);
tcg_gen_movcond_tl(TCG_COND_NE, desth, hs, zero, zero, h1);
-
- tcg_temp_free(ls);
- tcg_temp_free(rs);
- tcg_temp_free(hs);
- tcg_temp_free(ll);
- tcg_temp_free(lr);
- tcg_temp_free(h0);
- tcg_temp_free(h1);
}
static bool trans_srl(DisasContext *ctx, arg_srl *a)
tcg_gen_movcond_tl(TCG_COND_NE, destl, hs, zero, h1, h0);
tcg_gen_movcond_tl(TCG_COND_NE, desth, hs, zero, lr, h1);
-
- tcg_temp_free(ls);
- tcg_temp_free(rs);
- tcg_temp_free(hs);
- tcg_temp_free(ll);
- tcg_temp_free(lr);
- tcg_temp_free(h0);
- tcg_temp_free(h1);
}
static bool trans_sra(DisasContext *ctx, arg_sra *a)
tcg_gen_ext_i32_tl(dest, t1);
gen_set_gpr(ctx, a->rd, dest);
- tcg_temp_free_i32(t0);
- tcg_temp_free_i32(t1);
- tcg_temp_free_i32(t2);
return true;
}
tcg_gen_trunc_i64_tl(dest, t1);
gen_set_gpr(ctx, a->rd, dest);
- tcg_temp_free_i64(t0);
- tcg_temp_free_i64(t1);
- tcg_temp_free_i64(t2);
return true;
}
tcg_gen_trunc_i64_tl(dest, t1);
gen_set_gpr(ctx, a->rd, dest);
- tcg_temp_free_i64(t0);
- tcg_temp_free_i64(t1);
- tcg_temp_free_i64(t2);
return true;
}
tcg_gen_trunc_i64_tl(dest, t1);
gen_set_gpr(ctx, a->rd, dest);
- tcg_temp_free_i64(t0);
- tcg_temp_free_i64(t1);
- tcg_temp_free_i64(t2);
return true;
}
tcg_gen_xor_i32(t1, t1, t0);
tcg_gen_ext_i32_tl(dest, t1);
gen_set_gpr(ctx, a->rd, dest);
-
- tcg_temp_free_i32(t0);
- tcg_temp_free_i32(t1);
return true;
}
tcg_gen_mulu2_tl(tmpl, tmph, ah, bh);
tcg_gen_add2_tl(r2, r3, r2, r3, tmpl, tmph);
-
- tcg_temp_free(tmpl);
- tcg_temp_free(tmph);
}
static void gen_mul_i128(TCGv rl, TCGv rh,
tcg_gen_add2_tl(rh, tmpx, rh, zero, tmpl, tmph);
tcg_gen_mulu2_tl(tmpl, tmph, rs1h, rs2l);
tcg_gen_add2_tl(rh, tmph, rh, tmpx, tmpl, tmph);
-
- tcg_temp_free(tmpl);
- tcg_temp_free(tmph);
- tcg_temp_free(tmpx);
}
static bool trans_mul(DisasContext *ctx, arg_mul *a)
tcg_gen_and_tl(t1h, t1h, rs1h);
tcg_gen_sub2_tl(t0l, t0h, rl, rh, t0l, t0h);
tcg_gen_sub2_tl(rl, rh, t0l, t0h, t1l, t1h);
-
- tcg_temp_free(t0l);
- tcg_temp_free(t0h);
- tcg_temp_free(t1l);
- tcg_temp_free(t1h);
}
static void gen_mulh(TCGv ret, TCGv s1, TCGv s2)
TCGv discard = tcg_temp_new();
tcg_gen_muls2_tl(discard, ret, s1, s2);
- tcg_temp_free(discard);
}
static void gen_mulh_w(TCGv ret, TCGv s1, TCGv s2)
tcg_gen_and_tl(t0l, t0h, rs2l);
tcg_gen_and_tl(t0h, t0h, rs2h);
tcg_gen_sub2_tl(rl, rh, rl, rh, t0l, t0h);
-
- tcg_temp_free(t0l);
- tcg_temp_free(t0h);
}
static void gen_mulhsu(TCGv ret, TCGv arg1, TCGv arg2)
tcg_gen_sari_tl(rl, arg1, TARGET_LONG_BITS - 1);
tcg_gen_and_tl(rl, rl, arg2);
tcg_gen_sub_tl(ret, rh, rl);
-
- tcg_temp_free(rl);
- tcg_temp_free(rh);
}
static void gen_mulhsu_w(TCGv ret, TCGv arg1, TCGv arg2)
tcg_gen_ext32s_tl(t1, arg1);
tcg_gen_ext32u_tl(t2, arg2);
tcg_gen_mul_tl(ret, t1, t2);
- tcg_temp_free(t1);
- tcg_temp_free(t2);
tcg_gen_sari_tl(ret, ret, 32);
}
TCGv discard = tcg_temp_new();
tcg_gen_mulu2_tl(discard, ret, s1, s2);
- tcg_temp_free(discard);
}
static bool trans_mulhu(DisasContext *ctx, arg_mulhu *a)
tcg_gen_movcond_tl(TCG_COND_EQ, temp2, source2, zero, one, temp2);
tcg_gen_div_tl(ret, temp1, temp2);
-
- tcg_temp_free(temp1);
- tcg_temp_free(temp2);
}
static bool trans_div(DisasContext *ctx, arg_div *a)
tcg_gen_movcond_tl(TCG_COND_EQ, temp1, source2, zero, max, source1);
tcg_gen_movcond_tl(TCG_COND_EQ, temp2, source2, zero, one, source2);
tcg_gen_divu_tl(ret, temp1, temp2);
-
- tcg_temp_free(temp1);
- tcg_temp_free(temp2);
}
static bool trans_divu(DisasContext *ctx, arg_divu *a)
/* If div by zero, the required result is the original dividend. */
tcg_gen_movcond_tl(TCG_COND_EQ, ret, source2, zero, source1, temp1);
-
- tcg_temp_free(temp1);
- tcg_temp_free(temp2);
}
static bool trans_rem(DisasContext *ctx, arg_rem *a)
/* If div by zero, the required result is the original dividend. */
tcg_gen_movcond_tl(TCG_COND_EQ, ret, source2, zero, source1, temp);
-
- tcg_temp_free(temp);
}
static bool trans_remu(DisasContext *ctx, arg_remu *a)
gen_set_pc_imm(s, s->pc_succ_insn);
lookup_and_goto_ptr(s);
s->base.is_jmp = DISAS_NORETURN;
-
- if (rd == 0 && rs1 == 0) {
- tcg_temp_free(s1);
- }
-
return true;
}
fn(dest, mask, base, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
-
if (!is_store) {
mark_vs_dirty(s);
}
fn(dest, mask, base, stride, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
-
if (!is_store) {
mark_vs_dirty(s);
}
fn(dest, mask, base, index, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(index);
-
if (!is_store) {
mark_vs_dirty(s);
}
fn(dest, mask, base, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
mark_vs_dirty(s);
gen_set_label(over);
return true;
fn(dest, base, cpu_env, desc);
- tcg_temp_free_ptr(dest);
-
if (!is_store) {
mark_vs_dirty(s);
}
fn(dest, mask, src1, src2, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(src2);
mark_vs_dirty(s);
gen_set_label(over);
return true;
gvec_fn(s->sew, vreg_ofs(s, a->rd), vreg_ofs(s, a->rs2),
src1, MAXSZ(s), MAXSZ(s));
- tcg_temp_free_i64(src1);
mark_vs_dirty(s);
return true;
}
fn(dest, mask, src1, src2, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(src2);
mark_vs_dirty(s);
gen_set_label(over);
return true;
gvec_fn(s->sew, vreg_ofs(s, a->rd), vreg_ofs(s, a->rs2),
src1, MAXSZ(s), MAXSZ(s));
- tcg_temp_free_i32(src1);
mark_vs_dirty(s);
return true;
}
tcg_gen_ext_tl_i64(s1_i64, s1);
tcg_gen_gvec_dup_i64(s->sew, vreg_ofs(s, a->rd),
MAXSZ(s), MAXSZ(s), s1_i64);
- tcg_temp_free_i64(s1_i64);
} else {
tcg_gen_gvec_dup_tl(s->sew, vreg_ofs(s, a->rd),
MAXSZ(s), MAXSZ(s), s1);
s->cfg_ptr->vlen / 8, data));
tcg_gen_addi_ptr(dest, cpu_env, vreg_ofs(s, a->rd));
fns[s->sew](dest, s1_i64, cpu_env, desc);
-
- tcg_temp_free_ptr(dest);
- tcg_temp_free_i64(s1_i64);
}
mark_vs_dirty(s);
tcg_gen_addi_ptr(dest, cpu_env, vreg_ofs(s, a->rd));
fns[s->sew](dest, s1, cpu_env, desc);
- tcg_temp_free_ptr(dest);
mark_vs_dirty(s);
gen_set_label(over);
}
fn(dest, mask, t1, src2, cpu_env, desc);
- tcg_temp_free_ptr(dest);
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(src2);
- tcg_temp_free_i64(t1);
mark_vs_dirty(s);
gen_set_label(over);
return true;
fns[s->sew - 1](dest, t1, cpu_env, desc);
- tcg_temp_free_ptr(dest);
mark_vs_dirty(s);
gen_set_label(over);
}
- tcg_temp_free_i64(t1);
return true;
}
return false;
gen_helper_vcpop_m(dst, mask, src2, cpu_env, desc);
gen_set_gpr(s, a->rd, dst);
-
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(src2);
-
return true;
}
return false;
gen_helper_vfirst_m(dst, mask, src2, cpu_env, desc);
gen_set_gpr(s, a->rd, dst);
-
- tcg_temp_free_ptr(mask);
- tcg_temp_free_ptr(src2);
return true;
}
return false;
/* Perform the load. */
load_element(dest, base,
vreg_ofs(s, vreg), s->sew, false);
- tcg_temp_free_ptr(base);
- tcg_temp_free_i32(ofs);
/* Flush out-of-range indexing to zero. */
t_vlmax = tcg_constant_i64(vlmax);
tcg_gen_movcond_i64(TCG_COND_LTU, dest, t_idx,
t_vlmax, dest, t_zero);
-
- tcg_temp_free_i64(t_idx);
}
static void vec_element_loadi(DisasContext *s, TCGv_i64 dest,
vec_element_loadi(s, t1, a->rs2, 0, true);
tcg_gen_trunc_i64_tl(dest, t1);
gen_set_gpr(s, a->rd, dest);
- tcg_temp_free_i64(t1);
- tcg_temp_free(dest);
-
return true;
}
return false;
s1 = get_gpr(s, a->rs1, EXT_NONE);
tcg_gen_ext_tl_i64(t1, s1);
vec_element_storei(s, a->rd, 0, t1);
- tcg_temp_free_i64(t1);
mark_vs_dirty(s);
gen_set_label(over);
return true;
do_nanbox(s, t1, cpu_fpr[a->rs1]);
vec_element_storei(s, a->rd, 0, t1);
- tcg_temp_free_i64(t1);
mark_vs_dirty(s);
gen_set_label(over);
return true;
tcg_gen_gvec_dup_i64(s->sew, vreg_ofs(s, a->rd),
MAXSZ(s), MAXSZ(s), dest);
- tcg_temp_free_i64(dest);
mark_vs_dirty(s);
} else {
static gen_helper_opivx * const fns[4] = {
/* This formulation retains the nanboxing of rs2 in normal 'Zfh'. */
tcg_gen_deposit_i64(dest, rs2, rs1, 0, 15);
-
- tcg_temp_free_i64(rs1);
- tcg_temp_free_i64(rs2);
} else {
tcg_gen_deposit_i64(dest, src2, src1, 0, 15);
tcg_gen_ext16s_i64(dest, dest);
tcg_gen_andc_i64(rs2, rs2, mask);
tcg_gen_and_i64(dest, mask, rs1);
tcg_gen_or_i64(dest, dest, rs2);
-
- tcg_temp_free_i64(mask);
- tcg_temp_free_i64(rs2);
}
/* signed-extended intead of nanboxing for result if enable zfinx */
if (ctx->cfg_ptr->ext_zfinx) {
tcg_gen_ext16s_i64(dest, dest);
}
- tcg_temp_free_i64(rs1);
mark_fs_dirty(ctx);
return true;
}
*/
tcg_gen_andi_i64(dest, rs2, MAKE_64BIT_MASK(15, 1));
tcg_gen_xor_i64(dest, rs1, dest);
-
- tcg_temp_free_i64(rs2);
}
/* signed-extended intead of nanboxing for result if enable zfinx */
if (ctx->cfg_ptr->ext_zfinx) {
tcg_gen_ext16s_i64(dest, dest);
}
- tcg_temp_free_i64(rs1);
mark_fs_dirty(ctx);
return true;
}
tcg_gen_shli_tl(offs, src2, imm2);
}
- TCGv addr = get_address_indexed(ctx, rs1, offs);
-
- tcg_temp_free(offs);
- return addr;
+ return get_address_indexed(ctx, rs1, offs);
}
/* XTheadBa */
TCGv t = tcg_temp_new(); \
tcg_gen_shli_tl(t, arg2, SHAMT); \
tcg_gen_add_tl(ret, t, arg1); \
- tcg_temp_free(t); \
}
GEN_TH_ADDSL(1)
gen_clz(dest, t);
}
- tcg_temp_free(t);
gen_set_gpr(ctx, a->rd, dest);
return true;
tcg_gen_extu_tl_i64(t1, src1);
tcg_gen_deposit_i64(cpu_fpr[a->rd], cpu_fpr[a->rd], t1, 32, 32);
- tcg_temp_free_i64(t1);
mark_fs_dirty(ctx);
return true;
}
tcg_gen_extract_i64(t1, cpu_fpr[a->rs1], 32, 32);
tcg_gen_trunc_i64_tl(dst, t1);
gen_set_gpr(ctx, a->rd, dst);
- tcg_temp_free_i64(t1);
mark_fs_dirty(ctx);
return true;
}
extend_operand_func(tmp, src1);
extend_operand_func(tmp2, src2);
tcg_gen_mul_tl(tmp, tmp, tmp2);
- tcg_temp_free(tmp2);
} else {
tcg_gen_mul_tl(tmp, src1, src2);
}
accumulate_func(dest, src0, tmp);
gen_set_gpr(ctx, a->rd, dest);
- tcg_temp_free(tmp);
-
return true;
}
tcg_gen_addi_tl(rs1, rs1, imm);
gen_set_gpr(ctx, a->rd, rd);
gen_set_gpr(ctx, a->rs1, rs1);
-
- tcg_temp_free(addr);
return true;
}
tcg_gen_qemu_st_tl(data, addr, ctx->mem_idx, memop);
tcg_gen_addi_tl(rs1, rs1, imm);
gen_set_gpr(ctx, a->rs1, rs1);
-
- tcg_temp_free(addr);
return true;
}
tcg_gen_qemu_ld_tl(t2, addr2, ctx->mem_idx, memop);
gen_set_gpr(ctx, a->rd1, t1);
gen_set_gpr(ctx, a->rd2, t2);
-
- tcg_temp_free(t1);
- tcg_temp_free(t2);
- tcg_temp_free(addr1);
- tcg_temp_free(addr2);
return true;
}
tcg_gen_qemu_st_tl(data1, addr1, ctx->mem_idx, memop);
tcg_gen_qemu_st_tl(data2, addr2, ctx->mem_idx, memop);
-
- tcg_temp_free(addr1);
- tcg_temp_free(addr2);
return true;
}
TCGv_i64 t_nan = tcg_const_i64(0xffffffffffff7e00ull);
tcg_gen_movcond_i64(TCG_COND_GEU, out, in, t_max, in, t_nan);
- tcg_temp_free_i64(t_max);
- tcg_temp_free_i64(t_nan);
}
static void gen_check_nanbox_s(TCGv_i64 out, TCGv_i64 in)
tcg_gen_ld_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus));
tcg_gen_ori_tl(tmp, tmp, MSTATUS_FS);
tcg_gen_st_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus));
- tcg_temp_free(tmp);
}
if (ctx->virt_enabled && ctx->mstatus_hs_fs != MSTATUS_FS) {
tcg_gen_ld_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus_hs));
tcg_gen_ori_tl(tmp, tmp, MSTATUS_FS);
tcg_gen_st_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus_hs));
- tcg_temp_free(tmp);
}
}
#else
tcg_gen_ld_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus));
tcg_gen_ori_tl(tmp, tmp, MSTATUS_VS);
tcg_gen_st_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus));
- tcg_temp_free(tmp);
}
if (ctx->virt_enabled && ctx->mstatus_hs_vs != MSTATUS_VS) {
tcg_gen_ld_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus_hs));
tcg_gen_ori_tl(tmp, tmp, MSTATUS_VS);
tcg_gen_st_tl(tmp, cpu_env, offsetof(CPURISCVState, mstatus_hs));
- tcg_temp_free(tmp);
}
}
#else
f128(dest, desth, src1, src1h, ext2);
gen_set_gpr128(ctx, a->rd, dest, desth);
}
- tcg_temp_free(ext2);
return true;
}