Add J-extension into RISC-V
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/5 Add J-extension into RISC-V
--- target/riscv/cpu.c | 4 ++++ target/riscv/cpu.h | 2 ++ 2 files changed, 6 insertions(+)
target/riscv/cpu.c +4 -0
@@ -438,6 +438,9 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)if (cpu->cfg.ext_h) { target_misa |=RVH ; } +if (cpu->cfg.ext_j) { + target_misa |=RVJ ; + }if (cpu->cfg.ext_v) { target_misa |=RVV ;if (!is_power_of_2 (cpu->cfg.vlen)) {
@@ -516,6 +519,7 @@ static Property riscv_cpu_properties[] = {DEFINE_PROP_BOOL ("u" ,RISCVCPU , cfg.ext_u, true),/* This is experimental so mark with 'x-' */ DEFINE_PROP_BOOL ("x-h" ,RISCVCPU , cfg.ext_h, false), +DEFINE_PROP_BOOL ("x-j" ,RISCVCPU , cfg.ext_j, false),DEFINE_PROP_BOOL ("x-v" ,RISCVCPU , cfg.ext_v, false),DEFINE_PROP_BOOL ("Counters" ,RISCVCPU , cfg.ext_counters, true), DEFINE_PROP_BOOL("Zifencei", RISCVCPU, cfg.ext_ifencei, true),
target/riscv/cpu.h +2 -0
@@ -66,6 +66,7 @@#define RVS RV('S')#define RVU RV('U')#define RVH RV('H') +#define RVJ RV('J')/* S extension denotes that Supervisor mode exists, however it is possible to have a core that support S mode but does not have an MMU and there
@@ -277,6 +278,7 @@ struct RISCVCPU {bool ext_s;bool ext_u;bool ext_h; +bool ext_j;bool ext_v;bool ext_counters;bool ext_ifencei;
Signature · 1 line
2.20.1
PATCH 2/5 Support CSRs required for RISC-V PM extension except for ones in hypervisor mode
In reply to a message not in the archive--- target/riscv/cpu.c | 1 + target/riscv/cpu.h | 11 ++ target/riscv/cpu_bits.h | 66 +++++++++ target/riscv/csr.c | 302 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 380 insertions(+)
target/riscv/cpu.c +1 -0
@@ -440,6 +440,7 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp) }if (cpu->cfg.ext_j) { target_misa |=RVJ ; + env->mmte |=PM_EXT_INITIAL ; }if (cpu->cfg.ext_v) { target_misa |=RVV ;
target/riscv/cpu.h +11 -0
@@ -226,6 +226,17 @@ struct CPURISCVState {/* True if in debugger mode. */ bool debugger; + +/* CSRs for PM +* TODO: move these csr to appropriate groups +*/ +target_ulong mmte; +target_ulong mpmmask; +target_ulong mpmbase; +target_ulong spmmask; +target_ulong spmbase; +target_ulong upmmask; +target_ulong upmbase;#endif float_status fp_status;
target/riscv/cpu_bits.h +66 -0
76 lines not on this page · raw message
target/riscv/csr.c +302 -0
320 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH 3/5 Print new PM CSRs in QEMU logs
In reply to a message not in the archive--- target/riscv/cpu.c | 9 +++++++++ 1 file changed, 9 insertions(+)
target/riscv/cpu.c +9 -0
@@ -255,6 +255,15 @@ static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"htval " , env->htval);qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mtval2 " , env->mtval2); } +if (riscv_has_ext (env,RVH )) { +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mmte " , env->mmte); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"upmbase " , env->upmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"spmbase " , env->spmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mpmbase " , env->mpmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"upmmask " , env->upmmask); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"spmmask " , env->spmmask); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mpmmask " , env->mpmmask); + }#endif for (i =0 ; i <32 ; i++) {
Signature · 1 line
2.20.1
Re: [PATCH 3/5] [RISCV_PM] Print new PM CSRs in QEMU logs
Quoted 1 line · Alexey Baturo
+ if (
riscv_has_ext(env, RVH)) {
RVJ.
target/riscv/cpu.c static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags) · line 265
Quoted 7 lines
target/riscv/cpu.c +7
-0+qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mmte " , env->mmte); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"upmbase " , env->upmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"spmbase " , env->spmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mpmbase " , env->mpmbase); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"upmmask " , env->upmmask); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"spmmask " , env->spmmask); +qemu_fprintf (f," %s " TARGET_FMT_lx"\n" ,"mpmmask " , env->mpmmask);
Probably you only want to dump the set that's current.
r~
Re: [PATCH 3/5] [RISCV_PM] Print new PM CSRs in QEMU logs
First of all thank you so much for reviewing these patches!
Quoted 1 line
RVJ.
Thanks, I missed this typo, will fix it.
Quoted 1 line
Probably you only want to dump the set that's current.
I don't know for sure how anyone would be using this while debugging PM related code, but I like the idea, so I'll try to do it, thanks!
ср, 14 окт. 2020 г. в 21:41, Richard Henderson <[email protected]
Quoted 27 lines
:
Quoted 1 line · Alexey Baturo
+ if (
riscv_has_ext(env, RVH)) {RVJ.
Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "mmte ",
env->mmte);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "upmbase ",
env->upmbase);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "spmbase ",
env->spmbase);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "mpmbase ",
env->mpmbase);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "upmmask ",
env->upmmask);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "spmmask ",
env->spmmask);Quoted 1 line
+ qemu_fprintf(f, " %s "
TARGET_FMT_lx"\n", "mpmmask ",
env->mpmmask);Probably you only want to dump the set that's current.
r~
PATCH 4/5 Add address masking functions required for RISC-V Pointer Masking extension
In reply to a message not in the archiveFrom: Anatoly Parshintsev <[email protected]>
--- target/riscv/translate.c | 65 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+)
target/riscv/translate.c +65 -0
@@ -63,6 +63,10 @@ typedef struct DisasContext {uint16_t vlen;uint16_t mlen;bool vl_eq_vlmax; +/* PointerMasking extension */ +uint8_t pm_enabled; +target_ulong pm_mask; +target_ulong pm_base; } DisasContext;#ifdef TARGET_RISCV64
@@ -90,6 +94,38 @@ static inline bool has_ext(DisasContext *ctx, uint32_t ext)return ctx->misa & ext; } +/* Generates address adjustment for PointerMasking */ +static void gen_pm_adjust_address (DisasContext *s, +TCGv_i64 dst, +TCGv_i64 src) +{ +if (s->pm_enabled ==0 ) { +/* Load unmodified address */ +tcg_gen_mov_i64 (dst, src); + }else { +TCGv_i64 mask_neg =tcg_const_i64 (~s->pm_mask); +TCGv_i64 base =tcg_const_i64 (s->pm_base); +/* calculate (addr & ~mask) */ +TCGv res1 =tcg_temp_new (); +tcg_gen_and_tl (res1, mask_neg, src); +/* calculate (1) | (base) */ +TCGv res2 =tcg_temp_new (); +tcg_gen_or_tl (res2, res1, base); +/* move result to dst */ +tcg_gen_mov_i64 (dst, res2); +/* free allocated temps */ +tcg_temp_free (res1); +tcg_temp_free (res2); +tcg_temp_free_i64 (mask_neg); +tcg_temp_free_i64 (base); + } +} + +static TCGv_i64 apply_pointer_masking (DisasContext *s,TCGv_i64 addr) +{ +gen_pm_adjust_address (s, addr, addr); +return addr; +}/* * RISC-V requires NaN-boxing of narrower width floating point values. * This applies when a 32-bit value is assigned to a 64-bit FP register.
@@ -800,8 +836,36 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs) } else { ctx->virt_enabled = false; } +if (riscv_has_ext (env,RVJ )) { +switch (env->priv) { +case PRV_U : + ctx->pm_enabled =get_field (env->mmte,UMTE_U_PM_ENABLE ); + ctx->pm_mask = env->upmmask; + ctx->pm_base = env->upmbase; +break ; +case PRV_S : + ctx->pm_enabled =get_field (env->mmte,SMTE_S_PM_ENABLE ); + ctx->pm_mask = env->spmmask; + ctx->pm_base = env->spmbase; +break ; +case PRV_M : + ctx->pm_enabled =get_field (env->mmte,MMTE_M_PM_ENABLE ); + ctx->pm_mask = env->mpmmask; + ctx->pm_base = env->mpmbase; +break ; +default : +assert (0 &&"Unreachable" ); + } + }else { + ctx->pm_enabled =0 ; + ctx->pm_mask =0 ; + ctx->pm_base =0 ; + }#else ctx->virt_enabled = false; + ctx->pm_enabled =0 ; + ctx->pm_mask =0 ; + ctx->pm_base =0 ;#endif ctx->misa = env->misa; ctx->frm =-1 ;/* unknown rounding mode */
@@ -932,3 +996,4 @@ void riscv_translate_init(void) load_val =tcg_global_mem_new (cpu_env, offsetof(CPURISCVState , load_val),"load_val" ); } +
Signature · 1 line
2.20.1
Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension
target/riscv/translate.c static inline bool has_ext(DisasContext *ctx, uint32_t ext) · line 128
Quoted 5 lines · Alexey Baturo
target/riscv/translate.c +5
-0+static TCGv_i64 apply_pointer_masking (DisasContext *s,TCGv_i64 addr) +{ +gen_pm_adjust_address (s, addr, addr); +return addr; +}
This function is unused in this patch, which means the series as a whole is non-bisectable.
Rather than merge the two, I suggest adding a stub version of this function to patch 5, and then swap patch 4 and patch 5. So you will add uses of apply_pointer_masking without actually implementing it yet. Which should be fine.
Quoted 9 lines
target/riscv/translate.c +5
-0@@ -800,8 +836,36 @@ static void riscv_tr_init_disas_context }else { ctx->virt_enabled = false; } +if (riscv_has_ext (env,RVJ )) { +switch (env->priv) { +case PRV_U : + ctx->pm_enabled =get_field (env->mmte,UMTE_U_PM_ENABLE ); + ctx->pm_mask = env->upmmask;
target/riscv/translate.c static void riscv_tr_init_disas_context · line 853
Quoted 10 lines
target/riscv/translate.c +10
-0+ ctx->pm_base = env->upmbase; +break ; +case PRV_S : + ctx->pm_enabled =get_field (env->mmte,SMTE_S_PM_ENABLE ); + ctx->pm_mask = env->spmmask; + ctx->pm_base = env->spmbase; +break ; +case PRV_M : + ctx->pm_enabled =get_field (env->mmte,MMTE_M_PM_ENABLE ); + ctx->pm_mask = env->mpmmask;
You can't read env like this.
This bakes in values from ENV without adding any way to verify that those values are still current.
The one thing that you must bake into the generated code is the state of PM_ENABLE. Anything else would penalize normal risc-v emulation.
You do that in cpu_get_tb_cpu_state(). Allocate one bit to hold the current state of the flag. E.g.
FIELD(TB_FLAGS, PM_ENABLED, 9, 1)
then fill it in from the correct mmte bit for priv (which itself is encoded by cpu_mmu_index()).
Except for special cases, the mask and base variables cannot be placed into TB_FLAGS. For now, I think it's best to ignore the special cases and implement them all as tcg globals. Which means that we do *not* bake in a particular value, but instead read the value from env at runtime.
So, in riscv_translate_init, you create new globals for each of the mask and base. In riscv_tr_init_disas_context you examine priv (via mmu_index) and assign one pair of the globals to DisasContext, so that you don't have to keep looking them up.
Then you have
static void gen_pm_adjust_address(DisasContext *s,
TCGv_i64 dst,
TCGv_i64 src)
{
if (s->pm_enabled == 0) {
/* Load unmodified address */
tcg_gen_mov_i64(dst, src);
} else {
tcg_gen_andc_i64(dst, src, s->pm_mask);
tcg_gen_or_i64(dst, dst, s->pm_base);
}
}r~
Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension
Quoted 1 line
I suggest adding a stub version of this function to patch 5, and then
swap patch 4 and patch 5.
Thanks, will do.
Quoted 1 line
This bakes in values from ENV without adding any way to verify that those
values are still current.
If I correctly get your idea, you're talking about the situation, when DisasContext was initialized with some values, which at some point got changed, so this could lead to incorrect address masking. I tried to handle this situation by dropping the translation cache in case different values are written in any of the PM CSRs, which I assumed would lead to refilling the DIsasContext structure.
This is obviously not the best way to do it, since it may lead to performance degradation in some cases, so let me process your suggestion and try to implement it.
Thanks!
ср, 14 окт. 2020 г. в 22:19, Richard Henderson <[email protected]
Quoted 86 lines
:
target/riscv/translate.c static inline bool has_ext(DisasContext *ctx, uint32_t ext) · line 128
Quoted 5 lines · Alexey Baturo
target/riscv/translate.c +5
-0+static TCGv_i64 apply_pointer_masking (DisasContext *s,TCGv_i64 addr) +{ +gen_pm_adjust_address (s, addr, addr); +return addr; +}This function is unused in this patch, which means the series as a whole is non-bisectable.
Rather than merge the two, I suggest adding a stub version of this function to
patch 5, and then swap patch 4 and patch 5. So you will add uses ofapply_pointer_maskingwithout actually implementing it yet. Which should be fine.Quoted 9 lines
target/riscv/translate.c +5
-0@@ -800,8 +836,36 @@ static void riscv_tr_init_disas_context }else { ctx->virt_enabled = false; } +if (riscv_has_ext (env,RVJ )) { +switch (env->priv) { +case PRV_U : + ctx->pm_enabled =get_field (env->mmte,UMTE_U_PM_ENABLE ); + ctx->pm_mask = env->upmmask;target/riscv/translate.c static void riscv_tr_init_disas_context · line 853
Quoted 10 lines
target/riscv/translate.c +10
-0+ ctx->pm_base = env->upmbase; +break ; +case PRV_S : + ctx->pm_enabled =get_field (env->mmte,SMTE_S_PM_ENABLE ); + ctx->pm_mask = env->spmmask; + ctx->pm_base = env->spmbase; +break ; +case PRV_M : + ctx->pm_enabled =get_field (env->mmte,MMTE_M_PM_ENABLE ); + ctx->pm_mask = env->mpmmask;You can't read env like this.
This bakes in values from ENV without adding any way to verify that those values are still current.
The one thing that you must bake into the generated code is the state of
PM_ENABLE. Anything else would penalize normal risc-v emulation.You do that in
cpu_get_tb_cpu_state(). Allocate one bit to hold the current state of the flag. E.g.
FIELD(TB_FLAGS, PM_ENABLED, 9, 1)then fill it in from the correct mmte bit for priv (which itself is encoded by
cpu_mmu_index()).Except for special cases, the mask and base variables cannot be placed into
TB_FLAGS. For now, I think it's best to ignore the special cases and implement
them all as tcg globals. Which means that we do *not* bake in a particular value, but instead read the value from env at runtime.So, in
riscv_translate_init, you create new globals for each of the mask and
base. Inriscv_tr_init_disas_contextyou examine priv (viammu_index) and assign one pair of the globals to DisasContext, so that you don't have to keep
looking them up.Then you have
static void gen_pm_adjust_address(DisasContext *s,
TCGv_i64 dst, TCGv_i64 src) { if (s->pm_enabled == 0) { /* Load unmodified address */ tcg_gen_mov_i64(dst, src); } else { tcg_gen_andc_i64(dst, src, s->pm_mask); tcg_gen_or_i64(dst, dst, s->pm_base); } }r~
Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension
Hi folks,
I've sent new v2 patches where, I hope, I managed to address all the comments and suggestions that were provided.
Thanks!
ср, 14 окт. 2020 г. в 23:10, Alexey Baturo <[email protected]>:
Quoted 109 lines
Quoted 1 line
I suggest adding a stub version of this function to patch 5, and then
swap patch 4 and patch 5.
Thanks, will do.Quoted 1 line
This bakes in values from ENV without adding any way to verify that those
values are still current.
If I correctly get your idea, you're talking about the situation, when DisasContext was initialized with some values, which at some point got changed, so this could lead to incorrect address masking. I tried to handle this situation by dropping the translation cache in case different values are written in any of the PM CSRs, which I assumed would lead to refilling the DIsasContext structure.
This is obviously not the best way to do it, since it may lead to performance degradation in some cases, so let me process your suggestion and try to implement it.Thanks!
ср, 14 окт. 2020 г. в 22:19, Richard Henderson <
[email protected]>:Quoted 87 lines · Alexey Baturo
target/riscv/translate.c static inline bool has_ext(DisasContext *ctx, uint32_t ext) · line 128
Quoted 5 lines
target/riscv/translate.c +5
-0+static TCGv_i64 apply_pointer_masking (DisasContext *s,TCGv_i64 addr) +{ +gen_pm_adjust_address (s, addr, addr); +return addr; +}This function is unused in this patch, which means the series as a whole is
non-bisectable.Rather than merge the two, I suggest adding a stub version of this function to
patch 5, and then swap patch 4 and patch 5. So you will add uses ofapply_pointer_maskingwithout actually implementing it yet. Which should be fine.Quoted 9 lines
target/riscv/translate.c +5
-0@@ -800,8 +836,36 @@ static void riscv_tr_init_disas_context }else { ctx->virt_enabled = false; } +if (riscv_has_ext (env,RVJ )) { +switch (env->priv) { +case PRV_U : + ctx->pm_enabled =get_field (env->mmte,UMTE_U_PM_ENABLE ); + ctx->pm_mask = env->upmmask;target/riscv/translate.c static void riscv_tr_init_disas_context · line 853
Quoted 10 lines
target/riscv/translate.c +10
-0+ ctx->pm_base = env->upmbase; +break ; +case PRV_S : + ctx->pm_enabled =get_field (env->mmte,SMTE_S_PM_ENABLE ); + ctx->pm_mask = env->spmmask; + ctx->pm_base = env->spmbase; +break ; +case PRV_M : + ctx->pm_enabled =get_field (env->mmte,MMTE_M_PM_ENABLE ); + ctx->pm_mask = env->mpmmask;You can't read env like this.
This bakes in values from ENV without adding any way to verify that those values are still current.
The one thing that you must bake into the generated code is the state of
PM_ENABLE. Anything else would penalize normal risc-v emulation.You do that in
cpu_get_tb_cpu_state(). Allocate one bit to hold the current state of the flag. E.g.
FIELD(TB_FLAGS, PM_ENABLED, 9, 1)then fill it in from the correct mmte bit for priv (which itself is encoded by
cpu_mmu_index()).Except for special cases, the mask and base variables cannot be placed into
TB_FLAGS. For now, I think it's best to ignore the special cases and implement
them all as tcg globals. Which means that we do *not* bake in a particular
value, but instead read the value from env at runtime.So, in
riscv_translate_init, you create new globals for each of the mask and
base. Inriscv_tr_init_disas_contextyou examine priv (viammu_index) and assign one pair of the globals to DisasContext, so that you don't have to keep
looking them up.Then you have
static void gen_pm_adjust_address(DisasContext *s,
TCGv_i64 dst, TCGv_i64 src) { if (s->pm_enabled == 0) { /* Load unmodified address */ tcg_gen_mov_i64(dst, src); } else { tcg_gen_andc_i64(dst, src, s->pm_mask); tcg_gen_or_i64(dst, dst, s->pm_base); } }r~
PATCH 5/5 Support pointer masking for RISC-V for i/c/f/d/a types of instructions
In reply to a message not in the archive--- target/riscv/insn_trans/trans_rva.c.inc | 9 +++++++++ target/riscv/insn_trans/trans_rvd.c.inc | 6 ++++++ target/riscv/insn_trans/trans_rvf.c.inc | 6 ++++++ target/riscv/insn_trans/trans_rvi.c.inc | 6 ++++++ target/riscv/translate.c | 12 ++++++++++++ 5 files changed, 39 insertions(+)
target/riscv/insn_trans/trans_rva.c.inc +9 -0
@@ -26,6 +26,9 @@ static inline bool gen_lr(DisasContext *ctx, arg_atomic *a, MemOp mop) if (a->rl) { tcg_gen_mb(TCG_MO_ALL | TCG_BAR_STRL); } + if (has_ext(ctx, RVJ)) { + src1 = apply_pointer_masking(ctx, src1); + } tcg_gen_qemu_ld_tl(load_val, src1, ctx->mem_idx, mop); if (a->aq) { tcg_gen_mb(TCG_MO_ALL | TCG_BAR_LDAQ);
@@ -46,6 +49,9 @@ static inline bool gen_sc(DisasContext *ctx, arg_atomic *a, MemOp mop) TCGLabel *l2 = gen_new_label(); gen_get_gpr(src1, a->rs1); + if (has_ext(ctx, RVJ)) { + src1 = apply_pointer_masking(ctx, src1); + } tcg_gen_brcond_tl(TCG_COND_NE, load_res, src1, l1); gen_get_gpr(src2, a->rs2);
@@ -91,6 +97,9 @@ static bool gen_amo(DisasContext *ctx, arg_atomic *a, gen_get_gpr(src1, a->rs1); gen_get_gpr(src2, a->rs2); + if (has_ext(ctx, RVJ)) { + src1 = apply_pointer_masking(ctx, src1); + } (*func)(src2, src1, src2, ctx->mem_idx, mop); gen_set_gpr(a->rd, src2);
target/riscv/insn_trans/trans_rvd.c.inc +6 -0
@@ -25,6 +25,9 @@ static bool trans_fld(DisasContext *ctx, arg_fld *a) TCGv t0 = tcg_temp_new(); gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } tcg_gen_qemu_ld_i64(cpu_fpr[a->rd], t0, ctx->mem_idx, MO_TEQ);
@@ -40,6 +43,9 @@ static bool trans_fsd(DisasContext *ctx, arg_fsd *a) TCGv t0 = tcg_temp_new(); gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } tcg_gen_qemu_st_i64(cpu_fpr[a->rs2], t0, ctx->mem_idx, MO_TEQ);
target/riscv/insn_trans/trans_rvf.c.inc +6 -0
@@ -30,6 +30,9 @@ static bool trans_flw(DisasContext *ctx, arg_flw *a) TCGv t0 = tcg_temp_new(); gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } tcg_gen_qemu_ld_i64(cpu_fpr[a->rd], t0, ctx->mem_idx, MO_TEUL); gen_nanbox_s(cpu_fpr[a->rd], cpu_fpr[a->rd]);
@@ -47,6 +50,9 @@ static bool trans_fsw(DisasContext *ctx, arg_fsw *a) gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } tcg_gen_qemu_st_i64(cpu_fpr[a->rs2], t0, ctx->mem_idx, MO_TEUL);
target/riscv/insn_trans/trans_rvi.c.inc +6 -0
@@ -141,6 +141,9 @@ static bool gen_load(DisasContext *ctx, arg_lb *a, MemOp memop) TCGv t1 = tcg_temp_new(); gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx, memop); gen_set_gpr(a->rd, t1);
@@ -180,6 +183,9 @@ static bool gen_store(DisasContext *ctx, arg_sb *a, MemOp memop) TCGv dat = tcg_temp_new(); gen_get_gpr(t0, a->rs1); tcg_gen_addi_tl(t0, t0, a->imm); + if (has_ext(ctx, RVJ)) { + t0 = apply_pointer_masking(ctx, t0); + } gen_get_gpr(dat, a->rs2); tcg_gen_qemu_st_tl(dat, t0, ctx->mem_idx, memop);
target/riscv/translate.c +12 -0
@@ -416,6 +416,9 @@ static void gen_load_c(DisasContext *ctx, uint32_t opc, int rd, int rs1,TCGv t1 =tcg_temp_new ();gen_get_gpr (t0, rs1);tcg_gen_addi_tl (t0, t0, imm); +if (has_ext (ctx,RVJ )) { + t0 =apply_pointer_masking (ctx, t0); + }int memop = tcg_memop_lookup[(opc >>12 ) &0x7 ];if (memop <0 ) {
@@ -436,6 +439,9 @@ static void gen_store_c(DisasContext *ctx, uint32_t opc, int rs1, int rs2,TCGv dat =tcg_temp_new ();gen_get_gpr (t0, rs1);tcg_gen_addi_tl (t0, t0, imm); +if (has_ext (ctx,RVJ )) { + t0 =apply_pointer_masking (ctx, t0); + }gen_get_gpr (dat, rs2);int memop = tcg_memop_lookup[(opc >>12 ) &0x7 ];
@@ -495,6 +501,9 @@ static void gen_fp_load(DisasContext *ctx, uint32_t opc, int rd, t0 =tcg_temp_new ();gen_get_gpr (t0, rs1);tcg_gen_addi_tl (t0, t0, imm); +if (riscv_has_ext (env,RVJ )) { + t0 =apply_pointer_masking (ctx, t0); + }switch (opc) {case OPC_RISC_FLW :
@@ -534,6 +543,9 @@ static void gen_fp_store(DisasContext *ctx, uint32_t opc, int rs1, t0 =tcg_temp_new ();gen_get_gpr (t0, rs1);tcg_gen_addi_tl (t0, t0, imm); +if (riscv_has_ext (env,RVJ )) { + t0 =apply_pointer_masking (ctx, t0); + }switch (opc) {case OPC_RISC_FSW :
Signature · 1 line
2.20.1
Re: [PATCH 5/5] [RISCV_PM] Support pointer masking for RISC-V for i/c/f/d/a types of instructions
target/riscv/insn_trans/trans_rva.c.inc static inline bool gen_lr(DisasContext *ctx, arg_atomic *a, MemOp mop) · line 31
Quoted 3 lines · Alexey Baturo
target/riscv/insn_trans/trans_rva.c.inc +3
-0+ if (has_ext(ctx, RVJ)) { + src1 = apply_pointer_masking(ctx, src1); + }
The if is redundant, since that will have been done in cpu_get_tb_cpu_state while assigning pm_enabled.
The test for pm_enabled is in gen_pm_adjust_address.
The final thing is that the API for apply_pointer_masking is misleading. Here, it appears as if you are allocating a new temporary and assigning it to src1. Which is not the case.
I suggest you drop apply_pointer_masking and just use gen_pm_adjust_address.
r~
Re: [PATCH 5/5] [RISCV_PM] Support pointer masking for RISC-V for i/c/f/d/a types of instructions
Quoted 1 line
The if is redundant, since that will have been done in
cpu_get_tb_cpu_state while assigning pm_enabled.
I totally agree here, however I tried to do explicit checks, so this functionality is available only if a special option is supplied. But if you think that's too much and I could do just mov(dst, src) in case PM is disabled, I'd gladly fix that.
Quoted 1 line
I suggest you drop
apply_pointer_maskingand just use
gen_pm_adjust_address.
Sure, will do.
Thanks!
ср, 14 окт. 2020 г. в 22:24, Richard Henderson <[email protected]
Quoted 24 lines
:
target/riscv/insn_trans/trans_rva.c.inc static inline bool gen_lr(DisasContext *ctx, arg_atomic *a, MemOp mop) · line 31
Quoted 3 lines · Alexey Baturo
target/riscv/insn_trans/trans_rva.c.inc +3
-0+ if (has_ext(ctx, RVJ)) { + src1 = apply_pointer_masking(ctx, src1); + }The if is redundant, since that will have been done in
cpu_get_tb_cpu_statewhile assigningpm_enabled.The test for
pm_enabledis ingen_pm_adjust_address.The final thing is that the API for
apply_pointer_maskingis misleading. Here,
it appears as if you are allocating a new temporary and assigning it to src1.
Which is not the case.I suggest you drop
apply_pointer_maskingand just usegen_pm_adjust_address.r~