Skip to contentSkip to conversation

riscv: add initial sdext support

RFC PATCH Superseded Chao Liu 2 participants 12 messages Jan 17 – Jan 20 RISC-V

v1 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Chao Liu

author
#0 lore raw

cover riscv: add initial sdext support

Hi Daniel,

This RFC series adds a minimal CPU-side model for Sdext and Sdtrig in RISC-V QEMU. It is based on RISC-V Debug Specification 1.0:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

It introduces the sdext/sdtrig config bits, DCSR/DPC/DSCRATCH state, Debug Mode enter/leave helpers, DRET, EBREAK entry, single-step, and trigger action=debug mode.

To reduce review load, this series focuses on the Sdext features first. The Debug Module (DM) and related flows will follow in a later series.

Current status:
- Debug Mode entry/exit updates DCSR/DPC and restores execution via DRET.
- EBREAK honors DCSR ebreak bits and enters Debug Mode when enabled.
- Single-step uses DCSR.STEP with a TB flag and a helper at TB exit. It references Max Chou's patch "target/riscv: Use the tb->cs_bqse as the extend tb flags.":
https://lore.kernel.org/qemu-devel/[email protected]/
- Sdtrig supports action=debug mode for mcontrol/mcontrol6 and reports inst-count triggers in tinfo.

Differences vs Debug Spec (known gaps):
- No Debug Module (no DMI, dmcontrol/dmstatus, haltreq/resumereq).
- No debug ROM, program buffer, abstract commands, or SBA.
- Resume is modeled by leaving Debug Mode at cpu_exec_enter.
- Step/exception ordering is simplified: if the stepped instruction traps, the normal exception is taken and Debug Mode is not forced.
- Several DCSR fields are not fully modeled (stopcount/stoptime, etc).

Roadmap (next stage, DM focus):
1) Add a DM core with DMI access and hart state tracking.
2) Implement halt/resume handshake and move Debug Mode transitions under DM control.
3) Add debug ROM, program buffer, and abstract commands for GPR/CSR and memory access.
4) Add SBA if required by tooling.
5) Tighten ordering rules for step/exception/trigger priorities.

Thanks,
Chao

Chao Liu (8):
riscv: split sdext and sdtrig config bits
riscv: add sdext debug CSRs state
riscv: add sdext Debug Mode helpers
riscv: add dret instruction
riscv: add sdext enter Debug Mode on ebreak
riscv: add sdext single-step support
riscv: add sdtrig trigger action=debug mode
tests: update riscv64 virt RHCT

 include/exec/translation-block.h              |   3 +-
 target/riscv/cpu.c                            |  23 ++-
 target/riscv/cpu.h                            |  10 ++
 target/riscv/cpu_bits.h                       |  33 ++++
 target/riscv/cpu_cfg_fields.h.inc             |   2 +
 target/riscv/cpu_helper.c                     |  93 ++++++++++++
 target/riscv/csr.c                            | 142 +++++++++++++++++-
 target/riscv/debug.c                          |  58 ++++++-
 target/riscv/helper.h                         |   3 +
 target/riscv/insn32.decode                    |   1 +
 .../riscv/insn_trans/trans_privileged.c.inc   |  24 ++-
 target/riscv/machine.c                        |  12 +-
 target/riscv/op_helper.c                      |  72 +++++++++
 target/riscv/tcg/tcg-cpu.c                    |  34 +++--
 target/riscv/translate.c                      |  16 +-
 tests/data/acpi/riscv64/virt/RHCT             | Bin 416 -> 422 bytes
 16 files changed, 492 insertions(+), 34 deletions(-)
Signature · 1 line
2.52.0
author
#1 lore raw

RFC PATCH 1/8 riscv: split sdext and sdtrig config bits

Add cfg.ext_sdext and cfg.ext_sdtrig and expose them as ISA extensions. Keep the legacy 'debug' CPU property as a global kill switch and force-disable both when it is off.

Trigger CSRs (tselect/tdata*/tinfo/mcontext) and trigger setup now depend on ext_sdtrig instead of cfg.debug.

---
 target/riscv/cpu.c                | 18 +++++++++++++++---
 target/riscv/cpu_cfg_fields.h.inc |  2 ++
 target/riscv/csr.c                | 16 ++++++++--------
 target/riscv/machine.c            |  4 ++--
 target/riscv/tcg/tcg-cpu.c        | 11 +----------
 5 files changed, 28 insertions(+), 23 deletions(-)
target/riscv/cpu.c +15 -3
index 73d4280d7c..bc0b385cc1 100644
@@ -189,7 +189,8 @@ const RISCVIsaExtData isa_edata_arr[] = {
     ISA_EXT_DATA_ENTRY(zvkt, PRIV_VERSION_1_12_0, ext_zvkt),
     ISA_EXT_DATA_ENTRY(zhinx, PRIV_VERSION_1_12_0, ext_zhinx),
     ISA_EXT_DATA_ENTRY(zhinxmin, PRIV_VERSION_1_12_0, ext_zhinxmin),
-    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, debug),
+    ISA_EXT_DATA_ENTRY(sdext, PRIV_VERSION_1_12_0, ext_sdext),
+    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, ext_sdtrig),
     ISA_EXT_DATA_ENTRY(shcounterenw, PRIV_VERSION_1_12_0, has_priv_1_12),
     ISA_EXT_DATA_ENTRY(sha, PRIV_VERSION_1_12_0, ext_sha),
     ISA_EXT_DATA_ENTRY(shgatpa, PRIV_VERSION_1_12_0, has_priv_1_12),
@@ -783,7 +784,7 @@ static void riscv_cpu_reset_hold(Object *obj, ResetType type)
     env->vill = true;
 
 #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
         riscv_trigger_reset_hold(env);
     }
 
@@ -922,6 +923,15 @@ void riscv_cpu_finalize_features(RISCVCPU *cpu, Error **errp)
             return;
         }
     }
+
+    /*
+     * Keep the legacy 'debug' CPU property as a global kill switch.
+     * If it is off, force-disable Sdext/Sdtrig regardless of ISA strings.
+     */
+    if (!cpu->cfg.debug) {
+        cpu->cfg.ext_sdext = false;
+        cpu->cfg.ext_sdtrig = false;
+    }
 }
 
 static void riscv_cpu_realize(DeviceState *dev, Error **errp)
@@ -946,7 +956,7 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)
     riscv_cpu_register_gdb_regs_for_features(cs);
 
 #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
         riscv_trigger_realize(&cpu->env);
     }
 #endif
@@ -1112,6 +1122,8 @@ static void riscv_cpu_init(Object *obj)
      */
     RISCV_CPU(obj)->cfg.ext_zicntr = !mcc->def->bare;
     RISCV_CPU(obj)->cfg.ext_zihpm = !mcc->def->bare;
+    RISCV_CPU(obj)->cfg.ext_sdext = true;
+    RISCV_CPU(obj)->cfg.ext_sdtrig = true;
 
     /* Default values for non-bool cpu properties */
     cpu->cfg.pmu_mask = MAKE_64BIT_MASK(3, 16);
target/riscv/cpu_cfg_fields.h.inc +2 -0
index a154ecdc79..9701319195 100644
@@ -44,6 +44,8 @@ BOOL_FIELD(ext_zihpm)
 BOOL_FIELD(ext_zimop)
 BOOL_FIELD(ext_zcmop)
 BOOL_FIELD(ext_ztso)
+BOOL_FIELD(ext_sdext)
+BOOL_FIELD(ext_sdtrig)
 BOOL_FIELD(ext_smstateen)
 BOOL_FIELD(ext_sstc)
 BOOL_FIELD(ext_smcdeleg)
target/riscv/csr.c +8 -8
index 5c91658c3d..4f071b1db2 100644
@@ -775,9 +775,9 @@ static RISCVException have_mseccfg(CPURISCVState *env, int csrno)
     return RISCV_EXCP_ILLEGAL_INST;
 }
 
-static RISCVException debug(CPURISCVState *env, int csrno)
+static RISCVException sdtrig(CPURISCVState *env, int csrno)
 {
-    if (riscv_cpu_cfg(env)->debug) {
+    if (riscv_cpu_cfg(env)->ext_sdtrig) {
         return RISCV_EXCP_NONE;
     }
 
@@ -6308,12 +6308,12 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
                          .min_priv_ver = PRIV_VERSION_1_12_0           },
 
     /* Debug CSRs */
-    [CSR_TSELECT]   =  { "tselect",  debug, read_tselect,  write_tselect  },
-    [CSR_TDATA1]    =  { "tdata1",   debug, read_tdata,    write_tdata    },
-    [CSR_TDATA2]    =  { "tdata2",   debug, read_tdata,    write_tdata    },
-    [CSR_TDATA3]    =  { "tdata3",   debug, read_tdata,    write_tdata    },
-    [CSR_TINFO]     =  { "tinfo",    debug, read_tinfo,    write_ignore   },
-    [CSR_MCONTEXT]  =  { "mcontext", debug, read_mcontext, write_mcontext },
+    [CSR_TSELECT]   =  { "tselect",  sdtrig, read_tselect,  write_tselect  },
+    [CSR_TDATA1]    =  { "tdata1",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TDATA2]    =  { "tdata2",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TDATA3]    =  { "tdata3",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TINFO]     =  { "tinfo",    sdtrig, read_tinfo,    write_ignore   },
+    [CSR_MCONTEXT]  =  { "mcontext", sdtrig, read_mcontext, write_mcontext },
 
     [CSR_MCTRCTL]    = { "mctrctl",    ctr_mmode,  NULL, NULL, rmw_xctrctl    },
     [CSR_SCTRCTL]    = { "sctrctl",    ctr_smode,  NULL, NULL, rmw_xctrctl    },
target/riscv/machine.c +2 -2
index 18d790af0d..d6a0b8e357 100644
@@ -222,7 +222,7 @@ static bool debug_needed(void *opaque)
 {
     RISCVCPU *cpu = opaque;
 
-    return cpu->cfg.debug;
+    return cpu->cfg.ext_sdext || cpu->cfg.ext_sdtrig;
 }
 
 static int debug_post_load(void *opaque, int version_id)
@@ -230,7 +230,7 @@ static int debug_post_load(void *opaque, int version_id)
     RISCVCPU *cpu = opaque;
     CPURISCVState *env = &cpu->env;
 
-    if (icount_enabled()) {
+    if (cpu->cfg.ext_sdtrig && icount_enabled()) {
         env->itrigger_enabled = riscv_itrigger_enabled(env);
     }
 
target/riscv/tcg/tcg-cpu.c +1 -10
index d3968251fa..b5a26cf662 100644
@@ -177,7 +177,7 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
              ? EXT_STATUS_DIRTY : EXT_STATUS_DISABLED;
     }
 
-    if (cpu->cfg.debug && !icount_enabled()) {
+    if (cpu->cfg.ext_sdtrig && !icount_enabled()) {
         flags = FIELD_DP32(flags, TB_FLAGS, ITRIGGER, env->itrigger_enabled);
     }
 #endif
@@ -469,15 +469,6 @@ static void riscv_cpu_disable_priv_spec_isa_exts(RISCVCPU *cpu)
                 continue;
             }
 
-            /*
-             * cpu.debug = true is marked as 'sdtrig', priv spec 1.12.
-             * Skip this warning since existing CPUs with older priv
-             * spec and debug = true will be impacted.
-             */
-            if (!strcmp(edata->name, "sdtrig")) {
-                continue;
-            }
-
             isa_ext_update_enabled(cpu, edata->ext_enable_offset, false);
 
             /*
Signature · 1 line
2.52.0
#2 lore raw

Re: [RFC PATCH v1 1/8] riscv: split sdext and sdtrig config bits

Quoted 3 lines · Chao Liu

Add cfg.ext_sdext and cfg.ext_sdtrig and expose them as ISA extensions. Keep the legacy 'debug' CPU property as a global kill switch and force-disable both when it is off.

I would rather put the 'debug' flag in deprecation. It's a flag that at this moment means 'enable sdtrig' and I'd rather get rid of it than making it enable sdext too.

But deprecating 'debug' is out of scope for this work and we can handle it later. Matter of fact I might drop patches deprecating it today.

About enabling sdext by default, the patch is breaking bios-table-test because we're adding an extra string in riscv,isa ...

Quoted 62 lines

Trigger CSRs (tselect/tdata*/tinfo/mcontext) and trigger setup now depend on ext_sdtrig instead of cfg.debug.

---
  target/riscv/cpu.c                | 18 +++++++++++++++---
  target/riscv/cpu_cfg_fields.h.inc |  2 ++
  target/riscv/csr.c                | 16 ++++++++--------
  target/riscv/machine.c            |  4 ++--
  target/riscv/tcg/tcg-cpu.c        | 11 +----------
  5 files changed, 28 insertions(+), 23 deletions(-)
target/riscv/cpu.c +13 -3
index 73d4280d7c..bc0b385cc1 100644
@@ -189,7 +189,8 @@ const RISCVIsaExtData isa_edata_arr[] = {
      ISA_EXT_DATA_ENTRY(zvkt, PRIV_VERSION_1_12_0, ext_zvkt),
      ISA_EXT_DATA_ENTRY(zhinx, PRIV_VERSION_1_12_0, ext_zhinx),
      ISA_EXT_DATA_ENTRY(zhinxmin, PRIV_VERSION_1_12_0, ext_zhinxmin),
-    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, debug),
+    ISA_EXT_DATA_ENTRY(sdext, PRIV_VERSION_1_12_0, ext_sdext),
+    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, ext_sdtrig),
      ISA_EXT_DATA_ENTRY(shcounterenw, PRIV_VERSION_1_12_0, has_priv_1_12),
      ISA_EXT_DATA_ENTRY(sha, PRIV_VERSION_1_12_0, ext_sha),
      ISA_EXT_DATA_ENTRY(shgatpa, PRIV_VERSION_1_12_0, has_priv_1_12),
@@ -783,7 +784,7 @@ static void riscv_cpu_reset_hold(Object *obj, ResetType type)
      env->vill = true;
 
  #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
          riscv_trigger_reset_hold(env);
      }
 
@@ -922,6 +923,15 @@ void riscv_cpu_finalize_features(RISCVCPU *cpu, Error **errp)
              return;
          }
      }
+
+    /*
+     * Keep the legacy 'debug' CPU property as a global kill switch.
+     * If it is off, force-disable Sdext/Sdtrig regardless of ISA strings.
+     */
+    if (!cpu->cfg.debug) {
+        cpu->cfg.ext_sdext = false;
+        cpu->cfg.ext_sdtrig = false;
+    }
  }
 
  static void riscv_cpu_realize(DeviceState *dev, Error **errp)
@@ -946,7 +956,7 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)
      riscv_cpu_register_gdb_regs_for_features(cs);
 
  #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
          riscv_trigger_realize(&cpu->env);
      }
  #endif

target/riscv/cpu.c static void riscv_cpu_init(Object *obj) · line 1126

Quoted 5 lines
target/riscv/cpu.c +2 -0
@@ -1112,6 +1122,8 @@ static void riscv_cpu_init(Object *obj)
       */
      RISCV_CPU(obj)->cfg.ext_zicntr = !mcc->def->bare;
      RISCV_CPU(obj)->cfg.ext_zihpm = !mcc->def->bare;
+    RISCV_CPU(obj)->cfg.ext_sdext = true;
+    RISCV_CPU(obj)->cfg.ext_sdtrig = true;

^ here. Every time we change the defaults we have to dance around bios-tables-test due to riscv,isa changes.

If we really want sdext to be enabled by default we should (1) only enable it when the feature is already fully implemented and (2) changing bios-tables-test according to avoid leaving broken tests.

The remaining of the patch has the right idea, like here:

Quoted 21 lines
target/riscv/cpu.c +0 -0
      /* Default values for non-bool cpu properties */
      cpu->cfg.pmu_mask = MAKE_64BIT_MASK(3, 16);
target/riscv/cpu_cfg_fields.h.inc +2 -0
index a154ecdc79..9701319195 100644
@@ -44,6 +44,8 @@ BOOL_FIELD(ext_zihpm)
  BOOL_FIELD(ext_zimop)
  BOOL_FIELD(ext_zcmop)
  BOOL_FIELD(ext_ztso)
+BOOL_FIELD(ext_sdext)
+BOOL_FIELD(ext_sdtrig)
  BOOL_FIELD(ext_smstateen)
  BOOL_FIELD(ext_sstc)
  BOOL_FIELD(ext_smcdeleg)
target/riscv/csr.c +0 -0
index 5c91658c3d..4f071b1db2 100644

target/riscv/csr.c static RISCVException have_mseccfg(CPURISCVState *env, int csrno) · line 782

Quoted 10 lines
target/riscv/csr.c +2 -2
@@ -775,9 +775,9 @@ static RISCVException have_mseccfg(CPURISCVState *env, int csrno)
      return RISCV_EXCP_ILLEGAL_INST;
  }
 
-static RISCVException debug(CPURISCVState *env, int csrno)
+static RISCVException sdtrig(CPURISCVState *env, int csrno)
  {
-    if (riscv_cpu_cfg(env)->debug) {
+    if (riscv_cpu_cfg(env)->ext_sdtrig) {
          return RISCV_EXCP_NONE;
      }

debug == sdtrig is what we want and we should use 'sdtrig' everywhere 'debug' is appearing, but there's a particular way to go about it. We need to add getters/setters for 'debug' that would enable/disable sdtrig. We should avoid adding this kind of handling in init() or finalize().

I can do that in a deprecation patch. You can use your patches to handle sdext only.

Thanks,
Daniel

Quoted 71 lines
target/riscv/csr.c +6 -6
@@ -6308,12 +6308,12 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
                           .min_priv_ver = PRIV_VERSION_1_12_0           },
 
      /* Debug CSRs */
-    [CSR_TSELECT]   =  { "tselect",  debug, read_tselect,  write_tselect  },
-    [CSR_TDATA1]    =  { "tdata1",   debug, read_tdata,    write_tdata    },
-    [CSR_TDATA2]    =  { "tdata2",   debug, read_tdata,    write_tdata    },
-    [CSR_TDATA3]    =  { "tdata3",   debug, read_tdata,    write_tdata    },
-    [CSR_TINFO]     =  { "tinfo",    debug, read_tinfo,    write_ignore   },
-    [CSR_MCONTEXT]  =  { "mcontext", debug, read_mcontext, write_mcontext },
+    [CSR_TSELECT]   =  { "tselect",  sdtrig, read_tselect,  write_tselect  },
+    [CSR_TDATA1]    =  { "tdata1",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TDATA2]    =  { "tdata2",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TDATA3]    =  { "tdata3",   sdtrig, read_tdata,    write_tdata    },
+    [CSR_TINFO]     =  { "tinfo",    sdtrig, read_tinfo,    write_ignore   },
+    [CSR_MCONTEXT]  =  { "mcontext", sdtrig, read_mcontext, write_mcontext },
 
      [CSR_MCTRCTL]    = { "mctrctl",    ctr_mmode,  NULL, NULL, rmw_xctrctl    },
      [CSR_SCTRCTL]    = { "sctrctl",    ctr_smode,  NULL, NULL, rmw_xctrctl    },
target/riscv/machine.c +2 -2
index 18d790af0d..d6a0b8e357 100644
@@ -222,7 +222,7 @@ static bool debug_needed(void *opaque)
  {
      RISCVCPU *cpu = opaque;
 
-    return cpu->cfg.debug;
+    return cpu->cfg.ext_sdext || cpu->cfg.ext_sdtrig;
  }
 
  static int debug_post_load(void *opaque, int version_id)
@@ -230,7 +230,7 @@ static int debug_post_load(void *opaque, int version_id)
      RISCVCPU *cpu = opaque;
      CPURISCVState *env = &cpu->env;
 
-    if (icount_enabled()) {
+    if (cpu->cfg.ext_sdtrig && icount_enabled()) {
          env->itrigger_enabled = riscv_itrigger_enabled(env);
      }
 
target/riscv/tcg/tcg-cpu.c +1 -10
index d3968251fa..b5a26cf662 100644
@@ -177,7 +177,7 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
               ? EXT_STATUS_DIRTY : EXT_STATUS_DISABLED;
      }
 
-    if (cpu->cfg.debug && !icount_enabled()) {
+    if (cpu->cfg.ext_sdtrig && !icount_enabled()) {
          flags = FIELD_DP32(flags, TB_FLAGS, ITRIGGER, env->itrigger_enabled);
      }
  #endif
@@ -469,15 +469,6 @@ static void riscv_cpu_disable_priv_spec_isa_exts(RISCVCPU *cpu)
                  continue;
              }
 
-            /*
-             * cpu.debug = true is marked as 'sdtrig', priv spec 1.12.
-             * Skip this warning since existing CPUs with older priv
-             * spec and debug = true will be impacted.
-             */
-            if (!strcmp(edata->name, "sdtrig")) {
-                continue;
-            }
-
              isa_ext_update_enabled(cpu, edata->ext_enable_offset, false);
 
              /*
author
#3 lore raw

Re: [RFC PATCH v1 1/8] riscv: split sdext and sdtrig config bits

Hi Daniel:

Quoted 10 lines · Daniel Henrique Barboza
Quoted 3 lines · Chao Liu

Add cfg.ext_sdext and cfg.ext_sdtrig and expose them as ISA extensions. Keep the legacy 'debug' CPU property as a global kill switch and force-disable both when it is off.

I would rather put the 'debug' flag in deprecation. It's a flag that at this moment means 'enable sdtrig' and I'd rather get rid of it than making it enable sdext too.

Quoted 5 lines

But deprecating 'debug' is out of scope for this work and we can handle it later. Matter of fact I might drop patches deprecating it today.

About enabling sdext by default, the patch is breaking bios-table-test because we're adding an extra string in riscv,isa ...

Thanks for the review :)

Enabling sdext by default is indeed not a good idea, especially when it is not fully implemented,

so I agree to set it to disable by default until it is fully available before considering whether to enable it by default.

Quoted 72 lines
Quoted 62 lines

Trigger CSRs (tselect/tdata*/tinfo/mcontext) and trigger setup now depend on ext_sdtrig instead of cfg.debug.

---
  target/riscv/cpu.c                | 18 +++++++++++++++---
  target/riscv/cpu_cfg_fields.h.inc |  2 ++
  target/riscv/csr.c                | 16 ++++++++--------
  target/riscv/machine.c            |  4 ++--
  target/riscv/tcg/tcg-cpu.c        | 11 +----------
  5 files changed, 28 insertions(+), 23 deletions(-)
target/riscv/cpu.c +13 -3
index 73d4280d7c..bc0b385cc1 100644
@@ -189,7 +189,8 @@ const RISCVIsaExtData isa_edata_arr[] = {
      ISA_EXT_DATA_ENTRY(zvkt, PRIV_VERSION_1_12_0, ext_zvkt),
      ISA_EXT_DATA_ENTRY(zhinx, PRIV_VERSION_1_12_0, ext_zhinx),
      ISA_EXT_DATA_ENTRY(zhinxmin, PRIV_VERSION_1_12_0, ext_zhinxmin),
-    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, debug),
+    ISA_EXT_DATA_ENTRY(sdext, PRIV_VERSION_1_12_0, ext_sdext),
+    ISA_EXT_DATA_ENTRY(sdtrig, PRIV_VERSION_1_12_0, ext_sdtrig),
      ISA_EXT_DATA_ENTRY(shcounterenw, PRIV_VERSION_1_12_0, has_priv_1_12),
      ISA_EXT_DATA_ENTRY(sha, PRIV_VERSION_1_12_0, ext_sha),
      ISA_EXT_DATA_ENTRY(shgatpa, PRIV_VERSION_1_12_0, has_priv_1_12),
@@ -783,7 +784,7 @@ static void riscv_cpu_reset_hold(Object *obj, ResetType type)
      env->vill = true;
 
  #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
          riscv_trigger_reset_hold(env);
      }
 
@@ -922,6 +923,15 @@ void riscv_cpu_finalize_features(RISCVCPU *cpu, Error **errp)
              return;
          }
      }
+
+    /*
+     * Keep the legacy 'debug' CPU property as a global kill switch.
+     * If it is off, force-disable Sdext/Sdtrig regardless of ISA strings.
+     */
+    if (!cpu->cfg.debug) {
+        cpu->cfg.ext_sdext = false;
+        cpu->cfg.ext_sdtrig = false;
+    }
  }
 
  static void riscv_cpu_realize(DeviceState *dev, Error **errp)
@@ -946,7 +956,7 @@ static void riscv_cpu_realize(DeviceState *dev, Error **errp)
      riscv_cpu_register_gdb_regs_for_features(cs);
 
  #ifndef CONFIG_USER_ONLY
-    if (cpu->cfg.debug) {
+    if (cpu->cfg.ext_sdtrig) {
          riscv_trigger_realize(&cpu->env);
      }
  #endif

target/riscv/cpu.c static void riscv_cpu_init(Object *obj) · line 1126

Quoted 5 lines
target/riscv/cpu.c +2 -0
@@ -1112,6 +1122,8 @@ static void riscv_cpu_init(Object *obj)
       */
      RISCV_CPU(obj)->cfg.ext_zicntr = !mcc->def->bare;
      RISCV_CPU(obj)->cfg.ext_zihpm = !mcc->def->bare;
+    RISCV_CPU(obj)->cfg.ext_sdext = true;
+    RISCV_CPU(obj)->cfg.ext_sdtrig = true;

^ here. Every time we change the defaults we have to dance around bios-tables-test due to riscv,isa changes.

Quoted 3 lines

If we really want sdext to be enabled by default we should (1) only enable it when the feature is already fully implemented and (2) changing bios-tables-test according to avoid leaving broken tests.

I agree, as stated above.

Quoted 41 lines

The remaining of the patch has the right idea, like here:

Quoted 21 lines
target/riscv/cpu.c +0 -0
      /* Default values for non-bool cpu properties */
      cpu->cfg.pmu_mask = MAKE_64BIT_MASK(3, 16);
target/riscv/cpu_cfg_fields.h.inc +2 -0
index a154ecdc79..9701319195 100644
@@ -44,6 +44,8 @@ BOOL_FIELD(ext_zihpm)
  BOOL_FIELD(ext_zimop)
  BOOL_FIELD(ext_zcmop)
  BOOL_FIELD(ext_ztso)
+BOOL_FIELD(ext_sdext)
+BOOL_FIELD(ext_sdtrig)
  BOOL_FIELD(ext_smstateen)
  BOOL_FIELD(ext_sstc)
  BOOL_FIELD(ext_smcdeleg)
target/riscv/csr.c +0 -0
index 5c91658c3d..4f071b1db2 100644

target/riscv/csr.c static RISCVException have_mseccfg(CPURISCVState *env, int csrno) · line 782

Quoted 10 lines
target/riscv/csr.c +2 -2
@@ -775,9 +775,9 @@ static RISCVException have_mseccfg(CPURISCVState *env, int csrno)
      return RISCV_EXCP_ILLEGAL_INST;
  }
 
-static RISCVException debug(CPURISCVState *env, int csrno)
+static RISCVException sdtrig(CPURISCVState *env, int csrno)
  {
-    if (riscv_cpu_cfg(env)->debug) {
+    if (riscv_cpu_cfg(env)->ext_sdtrig) {
          return RISCV_EXCP_NONE;
      }

debug == sdtrig is what we want and we should use 'sdtrig' everywhere 'debug' is appearing, but there's a particular way to go about it. We need to add getters/setters for 'debug' that would enable/disable sdtrig. We should avoid adding this kind of handling in init() or finalize().

Quoted 2 lines

I can do that in a deprecation patch. You can use your patches to handle sdext only.

Thanks! I agree with this plan. I will focus on the implementation of sdext in subsequent patches.

If you have patches related to handling debug flags, I will rebase them to continue the work on sdext.

Thanks,
Chao

author
#4 lore raw

RFC PATCH 2/8 riscv: add sdext debug CSRs state

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Add architectural state for Sdext Debug Mode: debug_mode, dcsr, dpc and dscratch0/1. Wire up CSR access for dcsr/dpc/dscratch and gate them to Debug Mode (or host debugger access).

Also migrate the new state in vmstate_debug.

---
 target/riscv/cpu.c      |   5 ++
 target/riscv/cpu.h      |   4 ++
 target/riscv/cpu_bits.h |  33 ++++++++++
 target/riscv/csr.c      | 133 ++++++++++++++++++++++++++++++++++++++++
 target/riscv/machine.c  |   8 ++-
 5 files changed, 181 insertions(+), 2 deletions(-)
target/riscv/cpu.c +5 -0
index bc0b385cc1..d7c0f255a8 100644
@@ -782,6 +782,11 @@ static void riscv_cpu_reset_hold(Object *obj, ResetType type)
     /* Default NaN value: sign bit clear, frac msb set */
     set_float_default_nan_pattern(0b01000000, &env->fp_status);
     env->vill = true;
+    env->debug_mode = false;
+    env->dcsr = DCSR_DEBUGVER(4);
+    env->dpc = 0;
+    env->dscratch[0] = 0;
+    env->dscratch[1] = 0;
 
 #ifndef CONFIG_USER_ONLY
     if (cpu->cfg.ext_sdtrig) {
target/riscv/cpu.h +4 -0
index 36e7f10037..18ebac830a 100644
@@ -482,6 +482,10 @@ struct CPUArchState {
 
     /* True if in debugger mode.  */
     bool debugger;
+    bool debug_mode;
+    target_ulong dcsr;
+    target_ulong dpc;
+    target_ulong dscratch[2];
 
     uint64_t mstateen[SMSTATEEN_MAX_COUNT];
     uint64_t hstateen[SMSTATEEN_MAX_COUNT];
target/riscv/cpu_bits.h +33 -0
index b62dd82fe7..bb59f7ff56 100644
@@ -467,6 +467,39 @@
 #define CSR_DCSR            0x7b0
 #define CSR_DPC             0x7b1
 #define CSR_DSCRATCH        0x7b2
+#define CSR_DSCRATCH1       0x7b3
+
+/* DCSR fields */
+#define DCSR_XDEBUGVER_SHIFT    28
+#define DCSR_XDEBUGVER_MASK     (0xfu << DCSR_XDEBUGVER_SHIFT)
+#define DCSR_DEBUGVER(val)      ((target_ulong)(val) << DCSR_XDEBUGVER_SHIFT)
+#define DCSR_EXTCAUSE_SHIFT     24
+#define DCSR_EXTCAUSE_MASK      (0x7u << DCSR_EXTCAUSE_SHIFT)
+#define DCSR_CETRIG             BIT(19)
+#define DCSR_PELP               BIT(18)
+#define DCSR_EBREAKVS           BIT(17)
+#define DCSR_EBREAKVU           BIT(16)
+#define DCSR_EBREAKM            BIT(15)
+#define DCSR_EBREAKS            BIT(13)
+#define DCSR_EBREAKU            BIT(12)
+#define DCSR_STEPIE             BIT(11)
+#define DCSR_STOPCOUNT          BIT(10)
+#define DCSR_STOPTIME           BIT(9)
+#define DCSR_CAUSE_SHIFT        6
+#define DCSR_CAUSE_MASK         (0x7u << DCSR_CAUSE_SHIFT)
+#define DCSR_V                  BIT(5)
+#define DCSR_MPRVEN             BIT(4)
+#define DCSR_NMIP               BIT(3)
+#define DCSR_STEP               BIT(2)
+#define DCSR_PRV_MASK           0x3u
+
+#define DCSR_CAUSE_EBREAK       1
+#define DCSR_CAUSE_TRIGGER      2
+#define DCSR_CAUSE_HALTREQ      3
+#define DCSR_CAUSE_STEP         4
+#define DCSR_CAUSE_RESET        5
+#define DCSR_CAUSE_GROUP        6
+#define DCSR_CAUSE_OTHER        7
 
 /* Performance Counters */
 #define CSR_MHPMCOUNTER3    0xb03
target/riscv/csr.c +133 -0

145 lines not on this page · raw message

target/riscv/machine.c +6 -2
index d6a0b8e357..c6fe2d8541 100644
@@ -239,8 +239,8 @@ static int debug_post_load(void *opaque, int version_id)
 
 static const VMStateDescription vmstate_debug = {
     .name = "cpu/debug",
-    .version_id = 2,
-    .minimum_version_id = 2,
+    .version_id = 3,
+    .minimum_version_id = 3,
     .needed = debug_needed,
     .post_load = debug_post_load,
     .fields = (const VMStateField[]) {
@@ -248,6 +248,10 @@ static const VMStateDescription vmstate_debug = {
         VMSTATE_UINTTL_ARRAY(env.tdata1, RISCVCPU, RV_MAX_TRIGGERS),
         VMSTATE_UINTTL_ARRAY(env.tdata2, RISCVCPU, RV_MAX_TRIGGERS),
         VMSTATE_UINTTL_ARRAY(env.tdata3, RISCVCPU, RV_MAX_TRIGGERS),
+        VMSTATE_BOOL_V(env.debug_mode, RISCVCPU, 3),
+        VMSTATE_UINTTL_V(env.dcsr, RISCVCPU, 3),
+        VMSTATE_UINTTL_V(env.dpc, RISCVCPU, 3),
+        VMSTATE_UINTTL_ARRAY_V(env.dscratch, RISCVCPU, 2, 3),
         VMSTATE_END_OF_LIST()
     }
 };
Signature · 1 line
2.52.0
author
#5 lore raw

RFC PATCH 3/8 riscv: add sdext Debug Mode helpers

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Add helpers to enter/leave Debug Mode and to update dpc/dcsr. Model resume without a Debug Module by leaving Debug Mode at cpu_exec_enter and continuing from dpc.

---
 target/riscv/cpu.h         |  3 ++
 target/riscv/cpu_helper.c  | 87 ++++++++++++++++++++++++++++++++++++++
 target/riscv/debug.c       |  5 +++
 target/riscv/tcg/tcg-cpu.c | 14 ++++++
 4 files changed, 109 insertions(+)
target/riscv/cpu.h +3 -0
index 18ebac830a..ca861aa5f8 100644
@@ -630,6 +630,9 @@ bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
 char *riscv_isa_string(RISCVCPU *cpu);
 int riscv_cpu_max_xlen(RISCVCPUClass *mcc);
 bool riscv_cpu_option_set(const char *optname);
+void riscv_cpu_enter_debug_mode(CPURISCVState *env, target_ulong pc,
+                                uint32_t cause);
+void riscv_cpu_leave_debug_mode(CPURISCVState *env);
 
 #ifndef CONFIG_USER_ONLY
 void riscv_cpu_do_interrupt(CPUState *cpu);
target/riscv/cpu_helper.c +87 -0

93 lines not on this page · raw message

target/riscv/debug.c +5 -0
index 5664466749..5877a60c50 100644
@@ -927,6 +927,11 @@ void riscv_cpu_debug_excp_handler(CPUState *cs)
     RISCVCPU *cpu = RISCV_CPU(cs);
     CPURISCVState *env = &cpu->env;
 
+    /* Triggers must not match or fire while in Debug Mode. */
+    if (env->debug_mode) {
+        return;
+    }
+
     if (cs->watchpoint_hit) {
         if (cs->watchpoint_hit->flags & BP_CPU) {
             do_trigger_action(env, DBG_ACTION_BP);
target/riscv/tcg/tcg-cpu.c +14 -0
index b5a26cf662..2b543ced07 100644
@@ -261,6 +261,19 @@ static vaddr riscv_pointer_wrap(CPUState *cs, int mmu_idx,
     }
     return extract64(result, 0, 64 - pm_len);
 }
+
+static void riscv_cpu_exec_enter(CPUState *cs)
+{
+    RISCVCPU *cpu = RISCV_CPU(cs);
+    CPURISCVState *env = &cpu->env;
+
+    if (!cpu->cfg.ext_sdext || !env->debug_mode) {
+        return;
+    }
+    target_ulong pc = env->dpc;
+    riscv_cpu_leave_debug_mode(env);
+    env->pc = pc;
+}
 #endif
 
 const TCGCPUOps riscv_tcg_ops = {
@@ -277,6 +290,7 @@ const TCGCPUOps riscv_tcg_ops = {
 #ifndef CONFIG_USER_ONLY
     .tlb_fill = riscv_cpu_tlb_fill,
     .pointer_wrap = riscv_pointer_wrap,
+    .cpu_exec_enter = riscv_cpu_exec_enter,
     .cpu_exec_interrupt = riscv_cpu_exec_interrupt,
     .cpu_exec_halt = riscv_cpu_has_work,
     .cpu_exec_reset = cpu_reset,
Signature · 1 line
2.52.0
author
#6 lore raw

RFC PATCH 4/8 riscv: add dret instruction

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Add DRET decode/translate and a helper to leave Debug Mode and return to dpc. Executing DRET outside Debug Mode raises illegal instruction.

---
 target/riscv/helper.h                          |  1 +
 target/riscv/insn32.decode                     |  1 +
 target/riscv/insn_trans/trans_privileged.c.inc | 18 ++++++++++++++++++
 target/riscv/op_helper.c                       | 16 ++++++++++++++++
 4 files changed, 36 insertions(+)
target/riscv/helper.h +1 -0
index b785456ee0..6140b6340d 100644
@@ -131,6 +131,7 @@ DEF_HELPER_6(csrrw_i128, tl, env, int, tl, tl, tl, tl)
 #ifndef CONFIG_USER_ONLY
 DEF_HELPER_1(sret, tl, env)
 DEF_HELPER_1(mret, tl, env)
+DEF_HELPER_1(dret, tl, env)
 DEF_HELPER_1(mnret, tl, env)
 DEF_HELPER_1(ctr_clear, void, env)
 DEF_HELPER_1(wfi, void, env)
target/riscv/insn32.decode +1 -0
index cd23b1f3a9..318d330c57 100644
@@ -118,6 +118,7 @@ sctrclr     000100000100     00000 000 00000 1110011
 uret        0000000    00010 00000 000 00000 1110011
 sret        0001000    00010 00000 000 00000 1110011
 mret        0011000    00010 00000 000 00000 1110011
+dret        0111101    10010 00000 000 00000 1110011
 wfi         0001000    00101 00000 000 00000 1110011
 sfence_vma  0001001    ..... ..... 000 00000 1110011 @sfence_vma
 
target/riscv/insn_trans/trans_privileged.c.inc +18 -0
index 8a62b4cfcd..f8641b1977 100644
@@ -125,6 +125,24 @@ static bool trans_mret(DisasContext *ctx, arg_mret *a)
 #endif
 }
 
+static bool trans_dret(DisasContext *ctx, arg_dret *a)
+{
+#ifndef CONFIG_USER_ONLY
+    if (!ctx->cfg_ptr->ext_sdext) {
+        return false;
+    }
+    decode_save_opc(ctx, 0);
+    translator_io_start(&ctx->base);
+    gen_update_pc(ctx, 0);
+    gen_helper_dret(cpu_pc, tcg_env);
+    exit_tb(ctx); /* no chaining */
+    ctx->base.is_jmp = DISAS_NORETURN;
+    return true;
+#else
+    return false;
+#endif
+}
+
 static bool trans_mnret(DisasContext *ctx, arg_mnret *a)
 {
 #ifndef CONFIG_USER_ONLY
target/riscv/op_helper.c +16 -0
index 6ccc127c30..99736bbebb 100644
@@ -454,6 +454,22 @@ target_ulong helper_mret(CPURISCVState *env)
     return retpc;
 }
 
+target_ulong helper_dret(CPURISCVState *env)
+{
+    uintptr_t ra = GETPC();
+#ifdef CONFIG_USER_ONLY
+    riscv_raise_exception(env, RISCV_EXCP_ILLEGAL_INST, ra);
+    return 0;
+#else
+    if (!riscv_cpu_cfg(env)->ext_sdext || !env->debug_mode) {
+        riscv_raise_exception(env, RISCV_EXCP_ILLEGAL_INST, ra);
+    }
+    target_ulong retpc = env->dpc & get_xepc_mask(env);
+    riscv_cpu_leave_debug_mode(env);
+    return retpc;
+#endif
+}
+
 target_ulong helper_mnret(CPURISCVState *env)
 {
     target_ulong retpc = env->mnepc;
Signature · 1 line
2.52.0
author
#7 lore raw

RFC PATCH 5/8 riscv: add sdext enter Debug Mode on ebreak

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Route EBREAK via helper_sdext_ebreak. If Sdext is enabled and the matching dcsr.ebreak* bit is set, enter Debug Mode with cause=ebreak and stop with EXCP_DEBUG. Otherwise keep the normal breakpoint trap.

---
 target/riscv/helper.h                         |  1 +
 .../riscv/insn_trans/trans_privileged.c.inc   |  6 ++--
 target/riscv/op_helper.c                      | 36 +++++++++++++++++++
 3 files changed, 40 insertions(+), 3 deletions(-)
target/riscv/helper.h +1 -0
index 6140b6340d..acff73051b 100644
@@ -141,6 +141,7 @@ DEF_HELPER_1(tlb_flush_all, void, env)
 DEF_HELPER_4(ctr_add_entry, void, env, tl, tl, tl)
 /* Native Debug */
 DEF_HELPER_1(itrigger_match, void, env)
+DEF_HELPER_2(sdext_ebreak, void, env, tl)
 #endif
 
 /* Hypervisor functions */
target/riscv/insn_trans/trans_privileged.c.inc +3 -3
index f8641b1977..377f551bb3 100644
@@ -68,9 +68,9 @@ static bool trans_ebreak(DisasContext *ctx, arg_ebreak *a)
     if (pre == 0x01f01013 && ebreak == 0x00100073 && post == 0x40705013) {
         generate_exception(ctx, RISCV_EXCP_SEMIHOST);
     } else {
-        tcg_gen_st_tl(tcg_constant_tl(ebreak_addr), tcg_env,
-                      offsetof(CPURISCVState, badaddr));
-        generate_exception(ctx, RISCV_EXCP_BREAKPOINT);
+        gen_update_pc(ctx, 0);
+        gen_helper_sdext_ebreak(tcg_env, tcg_constant_tl(ebreak_addr));
+        ctx->base.is_jmp = DISAS_NORETURN;
     }
     return true;
 }
target/riscv/op_helper.c +36 -0
index 99736bbebb..dfe5388ab7 100644
@@ -470,6 +470,42 @@ target_ulong helper_dret(CPURISCVState *env)
 #endif
 }
 
+void helper_sdext_ebreak(CPURISCVState *env, target_ulong pc)
+{
+#ifndef CONFIG_USER_ONLY
+    CPUState *cs = env_cpu(env);
+    bool enter_debug = false;
+
+    if (riscv_cpu_cfg(env)->ext_sdext && !env->debug_mode) {
+        if (env->virt_enabled) {
+            if (env->priv == PRV_S) {
+                enter_debug = env->dcsr & DCSR_EBREAKVS;
+            } else if (env->priv == PRV_U) {
+                enter_debug = env->dcsr & DCSR_EBREAKVU;
+            }
+        } else {
+            if (env->priv == PRV_M) {
+                enter_debug = env->dcsr & DCSR_EBREAKM;
+            } else if (env->priv == PRV_S) {
+                enter_debug = env->dcsr & DCSR_EBREAKS;
+            } else if (env->priv == PRV_U) {
+                enter_debug = env->dcsr & DCSR_EBREAKU;
+            }
+        }
+    }
+
+    env->badaddr = pc;
+
+    if (enter_debug) {
+        riscv_cpu_enter_debug_mode(env, pc, DCSR_CAUSE_EBREAK);
+        cs->exception_index = EXCP_DEBUG;
+        cpu_loop_exit_restore(cs, GETPC());
+    }
+
+    riscv_raise_exception(env, RISCV_EXCP_BREAKPOINT, GETPC());
+#endif
+}
+
 target_ulong helper_mnret(CPURISCVState *env)
 {
     target_ulong retpc = env->mnepc;
Signature · 1 line
2.52.0
author
#8 lore raw

RFC PATCH 6/8 riscv: add sdext single-step support

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Use a TB flag when dcsr.step is set (and we are not in Debug Mode). When the flag is on, build 1-insn TBs and do not chain to the next TB. Add a TB-exit helper that enters Debug Mode with cause=step and sets dpc to the next pc, then stops with EXCP_DEBUG.

If dcsr.stepie is 0, do not take interrupts while stepping. Treat WFI as a nop so the hart does not sleep during a step.

PS: This patch references Max Chou's handling of ext_tb_flags.
https://lore.kernel.org/qemu-devel/[email protected]/

---
 include/exec/translation-block.h |  3 ++-
 target/riscv/cpu.h               |  3 +++
 target/riscv/cpu_helper.c        |  6 ++++++
 target/riscv/csr.c               | 21 +++++++--------------
 target/riscv/helper.h            |  1 +
 target/riscv/op_helper.c         | 20 ++++++++++++++++++++
 target/riscv/tcg/tcg-cpu.c       |  9 ++++++++-
 target/riscv/translate.c         | 16 ++++++++++++++--
 8 files changed, 61 insertions(+), 18 deletions(-)
include/exec/translation-block.h +2 -1
index cdce399eba..75188f56c8 100644
@@ -62,7 +62,8 @@ struct TranslationBlock {
      * x86: the original user, the Code Segment virtual base,
      * arm: an extension of tb->flags,
      * s390x: instruction data for EXECUTE,
-     * sparc: the next pc of the instruction queue (for delay slots).
+     * sparc: the next pc of the instruction queue (for delay slots),
+     * riscv: an extension of tb->flags.
      */
     uint64_t cs_base;
 
target/riscv/cpu.h +3 -0
index ca861aa5f8..fe37ae8458 100644
@@ -712,6 +712,9 @@ FIELD(TB_FLAGS, BCFI_ENABLED, 28, 1)
 FIELD(TB_FLAGS, PM_PMM, 29, 2)
 FIELD(TB_FLAGS, PM_SIGNEXTEND, 31, 1)
 
+/* sdext single-step needs a TB flag to build 1-insn TBs */
+FIELD(EXT_TB_FLAGS, SDEXT_STEP, 33, 1)
+
 #ifdef TARGET_RISCV32
 #define riscv_cpu_mxl(env)  ((void)(env), MXL_RV32)
 #else
target/riscv/cpu_helper.c +6 -0
index 83d2aa1b75..d8905a5a1e 100644
@@ -638,6 +638,12 @@ bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
     if (interrupt_request & mask) {
         RISCVCPU *cpu = RISCV_CPU(cs);
         CPURISCVState *env = &cpu->env;
+
+        if (cpu->cfg.ext_sdext && !env->debug_mode &&
+            (env->dcsr & DCSR_STEP) && !(env->dcsr & DCSR_STEPIE)) {
+            return false;
+        }
+
         int interruptno = riscv_cpu_local_irq_pending(env);
         if (interruptno >= 0) {
             cs->exception_index = RISCV_EXCP_INT_FLAG | interruptno;
target/riscv/csr.c +7 -14
index 4a732b9364..8dff9615c4 100644
@@ -3171,15 +3171,10 @@ static RISCVException write_mtval(CPURISCVState *env, int csrno,
     return RISCV_EXCP_NONE;
 }
 
-#ifndef CONFIG_USER_ONLY
-static bool riscv_sdext_available(CPURISCVState *env)
-{
-    return riscv_cpu_cfg(env)->ext_sdext;
-}
-
-static RISCVException dcsr_predicate(CPURISCVState *env, int csrno)
+#if !defined(CONFIG_USER_ONLY)
+static RISCVException sdext(CPURISCVState *env, int csrno)
 {
-    if (!riscv_sdext_available(env)) {
+    if (!riscv_cpu_cfg(env)->ext_sdext) {
         return RISCV_EXCP_ILLEGAL_INST;
     }
 
@@ -6440,12 +6435,10 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
     [CSR_TINFO]     =  { "tinfo",    sdtrig, read_tinfo,    write_ignore   },
     [CSR_MCONTEXT]  =  { "mcontext", sdtrig, read_mcontext, write_mcontext },
 #if !defined(CONFIG_USER_ONLY)
-    [CSR_DCSR]      =  { "dcsr", dcsr_predicate, read_dcsr, write_dcsr },
-    [CSR_DPC]       =  { "dpc", dcsr_predicate, read_dpc, write_dpc },
-    [CSR_DSCRATCH]  =  { "dscratch0", dcsr_predicate,
-                         read_dscratch, write_dscratch },
-    [CSR_DSCRATCH1] =  { "dscratch1", dcsr_predicate,
-                         read_dscratch, write_dscratch },
+    [CSR_DCSR]      =  { "dcsr",      sdext, read_dcsr,     write_dcsr },
+    [CSR_DPC]       =  { "dpc",       sdext, read_dpc,      write_dpc },
+    [CSR_DSCRATCH]  =  { "dscratch0", sdext, read_dscratch, write_dscratch },
+    [CSR_DSCRATCH1] =  { "dscratch1", sdext, read_dscratch, write_dscratch },
 #endif
 
     [CSR_MCTRCTL]    = { "mctrctl",    ctr_mmode,  NULL, NULL, rmw_xctrctl    },
target/riscv/helper.h +1 -0
index acff73051b..0b709c2b99 100644
@@ -141,6 +141,7 @@ DEF_HELPER_1(tlb_flush_all, void, env)
 DEF_HELPER_4(ctr_add_entry, void, env, tl, tl, tl)
 /* Native Debug */
 DEF_HELPER_1(itrigger_match, void, env)
+DEF_HELPER_1(sdext_step, void, env)
 DEF_HELPER_2(sdext_ebreak, void, env, tl)
 #endif
 
target/riscv/op_helper.c +20 -0
index dfe5388ab7..6fe29ce905 100644
@@ -470,6 +470,22 @@ target_ulong helper_dret(CPURISCVState *env)
 #endif
 }
 
+void helper_sdext_step(CPURISCVState *env)
+{
+#ifndef CONFIG_USER_ONLY
+    CPUState *cs = env_cpu(env);
+
+    if (!riscv_cpu_cfg(env)->ext_sdext || env->debug_mode ||
+        !(env->dcsr & DCSR_STEP)) {
+        return;
+    }
+
+    riscv_cpu_enter_debug_mode(env, env->pc, DCSR_CAUSE_STEP);
+    cs->exception_index = EXCP_DEBUG;
+    cpu_loop_exit_restore(cs, GETPC());
+#endif
+}
+
 void helper_sdext_ebreak(CPURISCVState *env, target_ulong pc)
 {
 #ifndef CONFIG_USER_ONLY
@@ -604,6 +620,10 @@ void helper_wfi(CPURISCVState *env)
                (prv_u || (prv_s && get_field(env->hstatus, HSTATUS_VTW)))) {
         riscv_raise_exception(env, RISCV_EXCP_VIRT_INSTRUCTION_FAULT, GETPC());
     } else {
+        if (riscv_cpu_cfg(env)->ext_sdext && !env->debug_mode &&
+            (env->dcsr & DCSR_STEP)) {
+            return;
+        }
         cs->halted = 1;
         cs->exception_index = EXCP_HLT;
         cpu_loop_exit(cs);
target/riscv/tcg/tcg-cpu.c +8 -1
index 2b543ced07..0426855145 100644
@@ -104,6 +104,7 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
     RISCVCPU *cpu = env_archcpu(env);
     RISCVExtStatus fs, vs;
     uint32_t flags = 0;
+    uint64_t ext_flags = 0;
     bool pm_signext = riscv_cpu_virt_mem_enabled(env);
 
     if (cpu->cfg.ext_zve32x) {
@@ -189,10 +190,16 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
     flags = FIELD_DP32(flags, TB_FLAGS, PM_PMM, riscv_pm_get_pmm(env));
     flags = FIELD_DP32(flags, TB_FLAGS, PM_SIGNEXTEND, pm_signext);
 
+#ifndef CONFIG_USER_ONLY
+    if (cpu->cfg.ext_sdext && !env->debug_mode && (env->dcsr & DCSR_STEP)) {
+        ext_flags = FIELD_DP64(ext_flags, EXT_TB_FLAGS, SDEXT_STEP, 1);
+    }
+#endif
+
     return (TCGTBCPUState){
         .pc = env->xl == MXL_RV32 ? env->pc & UINT32_MAX : env->pc,
         .flags = flags,
-        .cs_base = env->misa_ext,
+        .cs_base = ext_flags,
     };
 }
 
target/riscv/translate.c +14 -2
index e1f4dc5ffd..4660387164 100644
@@ -110,6 +110,8 @@ typedef struct DisasContext {
     bool ztso;
     /* Use icount trigger for native debug */
     bool itrigger;
+    /* Enter Debug Mode after next instruction (sdext single-step). */
+    bool sdext_step;
     /* FRM is known to contain a valid value. */
     bool frm_valid;
     bool insn_start_updated;
@@ -284,6 +286,9 @@ static void lookup_and_goto_ptr(DisasContext *ctx)
     if (ctx->itrigger) {
         gen_helper_itrigger_match(tcg_env);
     }
+    if (ctx->sdext_step) {
+        gen_helper_sdext_step(tcg_env);
+    }
 #endif
     tcg_gen_lookup_and_goto_ptr();
 }
@@ -294,6 +299,9 @@ static void exit_tb(DisasContext *ctx)
     if (ctx->itrigger) {
         gen_helper_itrigger_match(tcg_env);
     }
+    if (ctx->sdext_step) {
+        gen_helper_sdext_step(tcg_env);
+    }
 #endif
     tcg_gen_exit_tb(NULL, 0);
 }
@@ -307,7 +315,8 @@ static void gen_goto_tb(DisasContext *ctx, unsigned tb_slot_idx,
       * Under itrigger, instruction executes one by one like singlestep,
       * direct block chain benefits will be small.
       */
-    if (translator_use_goto_tb(&ctx->base, dest) && !ctx->itrigger) {
+    if (translator_use_goto_tb(&ctx->base, dest) &&
+        !ctx->itrigger && !ctx->sdext_step) {
         /*
          * For pcrel, the pc must always be up-to-date on entry to
          * the linked TB, so that it can use simple additions for all
@@ -1297,6 +1306,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
     RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cs);
     RISCVCPU *cpu = RISCV_CPU(cs);
     uint32_t tb_flags = ctx->base.tb->flags;
+    uint64_t ext_tb_flags = ctx->base.tb->cs_base;
 
     ctx->pc_save = ctx->base.pc_first;
     ctx->priv = FIELD_EX32(tb_flags, TB_FLAGS, PRIV);
@@ -1333,6 +1343,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
     ctx->bcfi_enabled = FIELD_EX32(tb_flags, TB_FLAGS, BCFI_ENABLED);
     ctx->fcfi_lp_expected = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_LP_EXPECTED);
     ctx->fcfi_enabled = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_ENABLED);
+    ctx->sdext_step = FIELD_EX64(ext_tb_flags, EXT_TB_FLAGS, SDEXT_STEP);
     ctx->zero = tcg_constant_tl(0);
     ctx->virt_inst_excp = false;
     ctx->decoders = cpu->decoders;
@@ -1383,7 +1394,8 @@ static void riscv_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
 
     /* Only the first insn within a TB is allowed to cross a page boundary. */
     if (ctx->base.is_jmp == DISAS_NEXT) {
-        if (ctx->itrigger || !translator_is_same_page(&ctx->base, ctx->base.pc_next)) {
+        if (ctx->itrigger || ctx->sdext_step ||
+            !translator_is_same_page(&ctx->base, ctx->base.pc_next)) {
             ctx->base.is_jmp = DISAS_TOO_MANY;
         } else {
             unsigned page_ofs = ctx->base.pc_next & ~TARGET_PAGE_MASK;
Signature · 1 line
2.52.0
author
#9 lore raw

Re: [RFC PATCH v1 6/8] riscv: add sdext single-step support

Quoted 78 lines · Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Use a TB flag when dcsr.step is set (and we are not in Debug Mode). When the flag is on, build 1-insn TBs and do not chain to the next TB. Add a TB-exit helper that enters Debug Mode with cause=step and sets dpc to the next pc, then stops with EXCP_DEBUG.

If dcsr.stepie is 0, do not take interrupts while stepping. Treat WFI as a nop so the hart does not sleep during a step.

PS: This patch references Max Chou's handling of ext_tb_flags.
https://lore.kernel.org/qemu-devel/[email protected]/

---
 include/exec/translation-block.h |  3 ++-
 target/riscv/cpu.h               |  3 +++
 target/riscv/cpu_helper.c        |  6 ++++++
 target/riscv/csr.c               | 21 +++++++--------------
 target/riscv/helper.h            |  1 +
 target/riscv/op_helper.c         | 20 ++++++++++++++++++++
 target/riscv/tcg/tcg-cpu.c       |  9 ++++++++-
 target/riscv/translate.c         | 16 ++++++++++++++--
 8 files changed, 61 insertions(+), 18 deletions(-)
include/exec/translation-block.h +2 -1
index cdce399eba..75188f56c8 100644
@@ -62,7 +62,8 @@ struct TranslationBlock {
      * x86: the original user, the Code Segment virtual base,
      * arm: an extension of tb->flags,
      * s390x: instruction data for EXECUTE,
-     * sparc: the next pc of the instruction queue (for delay slots).
+     * sparc: the next pc of the instruction queue (for delay slots),
+     * riscv: an extension of tb->flags.
      */
     uint64_t cs_base;
 
target/riscv/cpu.h +3 -0
index ca861aa5f8..fe37ae8458 100644
@@ -712,6 +712,9 @@ FIELD(TB_FLAGS, BCFI_ENABLED, 28, 1)
 FIELD(TB_FLAGS, PM_PMM, 29, 2)
 FIELD(TB_FLAGS, PM_SIGNEXTEND, 31, 1)
 
+/* sdext single-step needs a TB flag to build 1-insn TBs */
+FIELD(EXT_TB_FLAGS, SDEXT_STEP, 33, 1)
+
 #ifdef TARGET_RISCV32
 #define riscv_cpu_mxl(env)  ((void)(env), MXL_RV32)
 #else
target/riscv/cpu_helper.c +6 -0
index 83d2aa1b75..d8905a5a1e 100644
@@ -638,6 +638,12 @@ bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
     if (interrupt_request & mask) {
         RISCVCPU *cpu = RISCV_CPU(cs);
         CPURISCVState *env = &cpu->env;
+
+        if (cpu->cfg.ext_sdext && !env->debug_mode &&
+            (env->dcsr & DCSR_STEP) && !(env->dcsr & DCSR_STEPIE)) {
+            return false;
+        }
+
         int interruptno = riscv_cpu_local_irq_pending(env);
         if (interruptno >= 0) {
             cs->exception_index = RISCV_EXCP_INT_FLAG | interruptno;
target/riscv/csr.c +0 -0
index 4a732b9364..8dff9615c4 100644
@@ -3171,15 +3171,10 @@ static RISCVException write_mtval(CPURISCVState *env, int csrno,
     return RISCV_EXCP_NONE;
 }

target/riscv/csr.c static RISCVException write_mtval(CPURISCVState *env, int csrno, · line 3175

Quoted 10 lines
target/riscv/csr.c +2 -7
 
-#ifndef CONFIG_USER_ONLY
-static bool riscv_sdext_available(CPURISCVState *env)
-{
-    return riscv_cpu_cfg(env)->ext_sdext;
-}
-
-static RISCVException dcsr_predicate(CPURISCVState *env, int csrno)
+#if !defined(CONFIG_USER_ONLY)
+static RISCVException sdext(CPURISCVState *env, int csrno)

This change should apply patch 2 ("riscv: add sdext debug CSRs state").

I will fix it in v2.

Quoted 10 lines
target/riscv/csr.c +1 -1
 {
-    if (!riscv_sdext_available(env)) {
+    if (!riscv_cpu_cfg(env)->ext_sdext) {
         return RISCV_EXCP_ILLEGAL_INST;
     }
 
@@ -6440,12 +6435,10 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
     [CSR_TINFO]     =  { "tinfo",    sdtrig, read_tinfo,    write_ignore   },
     [CSR_MCONTEXT]  =  { "mcontext", sdtrig, read_mcontext, write_mcontext },
 #if !defined(CONFIG_USER_ONLY)

target/riscv/csr.c riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { · line 6441

Quoted 10 lines
target/riscv/csr.c +4 -6
-    [CSR_DCSR]      =  { "dcsr", dcsr_predicate, read_dcsr, write_dcsr },
-    [CSR_DPC]       =  { "dpc", dcsr_predicate, read_dpc, write_dpc },
-    [CSR_DSCRATCH]  =  { "dscratch0", dcsr_predicate,
-                         read_dscratch, write_dscratch },
-    [CSR_DSCRATCH1] =  { "dscratch1", dcsr_predicate,
-                         read_dscratch, write_dscratch },
+    [CSR_DCSR]      =  { "dcsr",      sdext, read_dcsr,     write_dcsr },
+    [CSR_DPC]       =  { "dpc",       sdext, read_dpc,      write_dpc },
+    [CSR_DSCRATCH]  =  { "dscratch0", sdext, read_dscratch, write_dscratch },
+    [CSR_DSCRATCH1] =  { "dscratch1", sdext, read_dscratch, write_dscratch },

As mentioned above.

Thanks,
Chao

Quoted 152 lines
target/riscv/csr.c +0 -0
 #endif
 
     [CSR_MCTRCTL]    = { "mctrctl",    ctr_mmode,  NULL, NULL, rmw_xctrctl    },
target/riscv/helper.h +1 -0
index acff73051b..0b709c2b99 100644
@@ -141,6 +141,7 @@ DEF_HELPER_1(tlb_flush_all, void, env)
 DEF_HELPER_4(ctr_add_entry, void, env, tl, tl, tl)
 /* Native Debug */
 DEF_HELPER_1(itrigger_match, void, env)
+DEF_HELPER_1(sdext_step, void, env)
 DEF_HELPER_2(sdext_ebreak, void, env, tl)
 #endif
 
target/riscv/op_helper.c +20 -0
index dfe5388ab7..6fe29ce905 100644
@@ -470,6 +470,22 @@ target_ulong helper_dret(CPURISCVState *env)
 #endif
 }
 
+void helper_sdext_step(CPURISCVState *env)
+{
+#ifndef CONFIG_USER_ONLY
+    CPUState *cs = env_cpu(env);
+
+    if (!riscv_cpu_cfg(env)->ext_sdext || env->debug_mode ||
+        !(env->dcsr & DCSR_STEP)) {
+        return;
+    }
+
+    riscv_cpu_enter_debug_mode(env, env->pc, DCSR_CAUSE_STEP);
+    cs->exception_index = EXCP_DEBUG;
+    cpu_loop_exit_restore(cs, GETPC());
+#endif
+}
+
 void helper_sdext_ebreak(CPURISCVState *env, target_ulong pc)
 {
 #ifndef CONFIG_USER_ONLY
@@ -604,6 +620,10 @@ void helper_wfi(CPURISCVState *env)
                (prv_u || (prv_s && get_field(env->hstatus, HSTATUS_VTW)))) {
         riscv_raise_exception(env, RISCV_EXCP_VIRT_INSTRUCTION_FAULT, GETPC());
     } else {
+        if (riscv_cpu_cfg(env)->ext_sdext && !env->debug_mode &&
+            (env->dcsr & DCSR_STEP)) {
+            return;
+        }
         cs->halted = 1;
         cs->exception_index = EXCP_HLT;
         cpu_loop_exit(cs);
target/riscv/tcg/tcg-cpu.c +8 -1
index 2b543ced07..0426855145 100644
@@ -104,6 +104,7 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
     RISCVCPU *cpu = env_archcpu(env);
     RISCVExtStatus fs, vs;
     uint32_t flags = 0;
+    uint64_t ext_flags = 0;
     bool pm_signext = riscv_cpu_virt_mem_enabled(env);
 
     if (cpu->cfg.ext_zve32x) {
@@ -189,10 +190,16 @@ static TCGTBCPUState riscv_get_tb_cpu_state(CPUState *cs)
     flags = FIELD_DP32(flags, TB_FLAGS, PM_PMM, riscv_pm_get_pmm(env));
     flags = FIELD_DP32(flags, TB_FLAGS, PM_SIGNEXTEND, pm_signext);
 
+#ifndef CONFIG_USER_ONLY
+    if (cpu->cfg.ext_sdext && !env->debug_mode && (env->dcsr & DCSR_STEP)) {
+        ext_flags = FIELD_DP64(ext_flags, EXT_TB_FLAGS, SDEXT_STEP, 1);
+    }
+#endif
+
     return (TCGTBCPUState){
         .pc = env->xl == MXL_RV32 ? env->pc & UINT32_MAX : env->pc,
         .flags = flags,
-        .cs_base = env->misa_ext,
+        .cs_base = ext_flags,
     };
 }
 
target/riscv/translate.c +14 -2
index e1f4dc5ffd..4660387164 100644
@@ -110,6 +110,8 @@ typedef struct DisasContext {
     bool ztso;
     /* Use icount trigger for native debug */
     bool itrigger;
+    /* Enter Debug Mode after next instruction (sdext single-step). */
+    bool sdext_step;
     /* FRM is known to contain a valid value. */
     bool frm_valid;
     bool insn_start_updated;
@@ -284,6 +286,9 @@ static void lookup_and_goto_ptr(DisasContext *ctx)
     if (ctx->itrigger) {
         gen_helper_itrigger_match(tcg_env);
     }
+    if (ctx->sdext_step) {
+        gen_helper_sdext_step(tcg_env);
+    }
 #endif
     tcg_gen_lookup_and_goto_ptr();
 }
@@ -294,6 +299,9 @@ static void exit_tb(DisasContext *ctx)
     if (ctx->itrigger) {
         gen_helper_itrigger_match(tcg_env);
     }
+    if (ctx->sdext_step) {
+        gen_helper_sdext_step(tcg_env);
+    }
 #endif
     tcg_gen_exit_tb(NULL, 0);
 }
@@ -307,7 +315,8 @@ static void gen_goto_tb(DisasContext *ctx, unsigned tb_slot_idx,
       * Under itrigger, instruction executes one by one like singlestep,
       * direct block chain benefits will be small.
       */
-    if (translator_use_goto_tb(&ctx->base, dest) && !ctx->itrigger) {
+    if (translator_use_goto_tb(&ctx->base, dest) &&
+        !ctx->itrigger && !ctx->sdext_step) {
         /*
          * For pcrel, the pc must always be up-to-date on entry to
          * the linked TB, so that it can use simple additions for all
@@ -1297,6 +1306,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
     RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cs);
     RISCVCPU *cpu = RISCV_CPU(cs);
     uint32_t tb_flags = ctx->base.tb->flags;
+    uint64_t ext_tb_flags = ctx->base.tb->cs_base;
 
     ctx->pc_save = ctx->base.pc_first;
     ctx->priv = FIELD_EX32(tb_flags, TB_FLAGS, PRIV);
@@ -1333,6 +1343,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
     ctx->bcfi_enabled = FIELD_EX32(tb_flags, TB_FLAGS, BCFI_ENABLED);
     ctx->fcfi_lp_expected = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_LP_EXPECTED);
     ctx->fcfi_enabled = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_ENABLED);
+    ctx->sdext_step = FIELD_EX64(ext_tb_flags, EXT_TB_FLAGS, SDEXT_STEP);
     ctx->zero = tcg_constant_tl(0);
     ctx->virt_inst_excp = false;
     ctx->decoders = cpu->decoders;
@@ -1383,7 +1394,8 @@ static void riscv_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
 
     /* Only the first insn within a TB is allowed to cross a page boundary. */
     if (ctx->base.is_jmp == DISAS_NEXT) {
-        if (ctx->itrigger || !translator_is_same_page(&ctx->base, ctx->base.pc_next)) {
+        if (ctx->itrigger || ctx->sdext_step ||
+            !translator_is_same_page(&ctx->base, ctx->base.pc_next)) {
             ctx->base.is_jmp = DISAS_TOO_MANY;
         } else {
             unsigned page_ofs = ctx->base.pc_next & ~TARGET_PAGE_MASK;
author
#10 lore raw

RFC PATCH 7/8 riscv: add sdtrig trigger action=debug mode

In reply to Chao Liu

RISC-V Debug Specification:
https://github.com/riscv/riscv-debug-spec/releases/tag/1.0

Allow mcontrol/mcontrol6 action=1 when Sdext is enabled. When such a trigger hits, enter Debug Mode with cause=trigger and stop with EXCP_DEBUG.

Also report inst-count triggers in tinfo and read their action field.

---
 target/riscv/debug.c | 53 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 51 insertions(+), 2 deletions(-)
target/riscv/debug.c +51 -2
index 5877a60c50..4e30d42905 100644
@@ -110,6 +110,8 @@ static trigger_action_t get_trigger_action(CPURISCVState *env,
         action = (tdata1 & TYPE6_ACTION) >> 12;
         break;
     case TRIGGER_TYPE_INST_CNT:
+        action = tdata1 & ITRIGGER_ACTION;
+        break;
     case TRIGGER_TYPE_INT:
     case TRIGGER_TYPE_EXCP:
     case TRIGGER_TYPE_EXT_SRC:
@@ -280,6 +282,7 @@ static target_ulong textra_validate(CPURISCVState *env, target_ulong tdata3)
 
 static void do_trigger_action(CPURISCVState *env, target_ulong trigger_index)
 {
+    CPUState *cs = env_cpu(env);
     trigger_action_t action = get_trigger_action(env, trigger_index);
 
     switch (action) {
@@ -289,6 +292,21 @@ static void do_trigger_action(CPURISCVState *env, target_ulong trigger_index)
         riscv_raise_exception(env, RISCV_EXCP_BREAKPOINT, 0);
         break;
     case DBG_ACTION_DBG_MODE:
+        if (!env_archcpu(env)->cfg.ext_sdext) {
+            qemu_log_mask(LOG_UNIMP,
+                          "trigger action=debug mode requires Sdext\n");
+            riscv_raise_exception(env, RISCV_EXCP_BREAKPOINT, 0);
+        }
+        riscv_cpu_enter_debug_mode(env, env->pc, DCSR_CAUSE_TRIGGER);
+        /*
+         * If this came from the Trigger Module's CPU breakpoint/watchpoint,
+         * we're already returning via EXCP_DEBUG. Otherwise, stop now.
+         */
+        if (cs->exception_index != EXCP_DEBUG) {
+            cs->exception_index = EXCP_DEBUG;
+            cpu_loop_exit_restore(cs, GETPC());
+        }
+        break;
     case DBG_ACTION_TRACE0:
     case DBG_ACTION_TRACE1:
     case DBG_ACTION_TRACE2:
@@ -441,6 +459,7 @@ static target_ulong type2_mcontrol_validate(CPURISCVState *env,
 {
     target_ulong val;
     uint32_t size;
+    uint32_t action;
 
     /* validate the generic part first */
     val = tdata1_validate(env, ctrl, TRIGGER_TYPE_AD_MATCH);
@@ -448,11 +467,25 @@ static target_ulong type2_mcontrol_validate(CPURISCVState *env,
     /* validate unimplemented (always zero) bits */
     warn_always_zero_bit(ctrl, TYPE2_MATCH, "match");
     warn_always_zero_bit(ctrl, TYPE2_CHAIN, "chain");
-    warn_always_zero_bit(ctrl, TYPE2_ACTION, "action");
     warn_always_zero_bit(ctrl, TYPE2_TIMING, "timing");
     warn_always_zero_bit(ctrl, TYPE2_SELECT, "select");
     warn_always_zero_bit(ctrl, TYPE2_HIT, "hit");
 
+    action = (ctrl & TYPE2_ACTION) >> 12;
+    if (action == DBG_ACTION_BP) {
+        val |= ctrl & TYPE2_ACTION;
+    } else if (action == DBG_ACTION_DBG_MODE) {
+        if (env_archcpu(env)->cfg.ext_sdext) {
+            val |= ctrl & TYPE2_ACTION;
+        } else {
+            qemu_log_mask(LOG_UNIMP,
+                          "trigger action=debug mode requires Sdext\n");
+        }
+    } else {
+        qemu_log_mask(LOG_UNIMP, "trigger action: %u is not supported\n",
+                      action);
+    }
+
     /* validate size encoding */
     size = type2_breakpoint_size(env, ctrl);
     if (access_size[size] == -1) {
@@ -569,6 +602,7 @@ static target_ulong type6_mcontrol6_validate(CPURISCVState *env,
 {
     target_ulong val;
     uint32_t size;
+    uint32_t action;
 
     /* validate the generic part first */
     val = tdata1_validate(env, ctrl, TRIGGER_TYPE_AD_MATCH6);
@@ -576,11 +610,25 @@ static target_ulong type6_mcontrol6_validate(CPURISCVState *env,
     /* validate unimplemented (always zero) bits */
     warn_always_zero_bit(ctrl, TYPE6_MATCH, "match");
     warn_always_zero_bit(ctrl, TYPE6_CHAIN, "chain");
-    warn_always_zero_bit(ctrl, TYPE6_ACTION, "action");
     warn_always_zero_bit(ctrl, TYPE6_TIMING, "timing");
     warn_always_zero_bit(ctrl, TYPE6_SELECT, "select");
     warn_always_zero_bit(ctrl, TYPE6_HIT, "hit");
 
+    action = (ctrl & TYPE6_ACTION) >> 12;
+    if (action == DBG_ACTION_BP) {
+        val |= ctrl & TYPE6_ACTION;
+    } else if (action == DBG_ACTION_DBG_MODE) {
+        if (env_archcpu(env)->cfg.ext_sdext) {
+            val |= ctrl & TYPE6_ACTION;
+        } else {
+            qemu_log_mask(LOG_UNIMP,
+                          "trigger action=debug mode requires Sdext\n");
+        }
+    } else {
+        qemu_log_mask(LOG_UNIMP, "trigger action: %u is not supported\n",
+                      action);
+    }
+
     /* validate size encoding */
     size = extract32(ctrl, 16, 4);
     if (access_size[size] == -1) {
@@ -919,6 +967,7 @@ target_ulong tinfo_csr_read(CPURISCVState *env)
 {
     /* assume all triggers support the same types of triggers */
     return BIT(TRIGGER_TYPE_AD_MATCH) |
+           BIT(TRIGGER_TYPE_INST_CNT) |
            BIT(TRIGGER_TYPE_AD_MATCH6);
 }
 
Signature · 1 line
2.52.0
author
#11 lore raw

RFC PATCH 8/8 tests: update riscv64 virt RHCT

In reply to Chao Liu

Update the golden RHCT table for riscv64 virt after the Sdext/Sdtrig changes. Rebuilt with tests/data/acpi/ rebuild-expected-aml.sh.

---
 tests/data/acpi/riscv64/virt/RHCT | Bin 416 -> 422 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
tests/data/acpi/riscv64/virt/RHCT binary +0 -0
index 52a4cc4b6380eee3299b965271a39e9e01f5a698..b9a288b299ef98491d33d3c5cda59c50ab434fc9 100644
GIT binary patch
Signature · 1 line
2.52.0