Skip to contentSkip to conversation

Add J-extension into RISC-V

PATCH Superseded Alexey Baturo 2 participants 12 messages Oct 14, 2020 – Oct 15, 2020 1 message not in the archive RISC-V

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#1 lore raw

PATCH 1/5 Add J-extension into RISC-V

In reply to a message not in the archive
---
 target/riscv/cpu.c | 4 ++++
 target/riscv/cpu.h | 2 ++
 2 files changed, 6 insertions(+)
target/riscv/cpu.c +4 -0
index 0bbfd7f457..fe6bab4a52 100644
@@ -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
index de275782e6..eca611a367 100644
@@ -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
#2 lore raw

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
index fe6bab4a52..d63031eb08 100644
@@ -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
index eca611a367..21e47b8283 100644
@@ -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
#3 lore raw

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
index d63031eb08..8f8ee4d29c 100644
@@ -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
#6 lore raw

PATCH 4/5 Add address masking functions required for RISC-V Pointer Masking extension

In reply to a message not in the archive

From: Anatoly Parshintsev <[email protected]>

---
 target/riscv/translate.c | 65 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
target/riscv/translate.c +65 -0
index 79dca2291b..338a967e0c 100644
@@ -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
#10 lore raw

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
index be8a9f06dd..3bf2e82013 100644
@@ -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
index 4f832637fa..0391bb02be 100644
@@ -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
index 3dfec8211d..176bc992e1 100644
@@ -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
index d04ca0394c..3ee2fea271 100644
@@ -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
index 338a967e0c..0b086753d4 100644
@@ -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
#4 lore raw

Re: [PATCH 3/5] [RISCV_PM] Print new PM CSRs in QEMU logs

In reply to Alexey Baturo
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~

#7 lore raw

Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension

In reply to Alexey Baturo

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~

#11 lore raw

Re: [PATCH 5/5] [RISCV_PM] Support pointer masking for RISC-V for i/c/f/d/a types of instructions

In reply to Alexey Baturo

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~

#5 lore raw

Re: [PATCH 3/5] [RISCV_PM] Print new PM CSRs in QEMU logs

In reply to Richard Henderson

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~

#8 lore raw

Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension

In reply to Richard Henderson
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 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~

#12 lore raw

Re: [PATCH 5/5] [RISCV_PM] Support pointer masking for RISC-V for i/c/f/d/a types of instructions

In reply to Richard Henderson
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_masking and 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_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~

#9 lore raw

Re: [PATCH 4/5] [RISCV_PM] Add address masking functions required for RISC-V Pointer Masking extension

In reply to Alexey Baturo

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 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~