Add support for per-hart start PCs (--pcs)

riscv/cfg.cc

@@ -48,3 +48,24 @@ cfg_t::cfg_t()
   trigger_count    = 4;
   cache_blocksz    = 64;
 }
+
+void start_pc_t::set_global(reg_t pc)
+{
+  global_pc = pc;
+}
+
+void start_pc_t::set_override(size_t hart_id, reg_t pc)
+{
+  hart_pcs[hart_id] = pc;
+}
+
+std::optional<reg_t> start_pc_t::get(size_t hart_id) const
+{
+  auto it = hart_pcs.find(hart_id);
+
+  if (it != hart_pcs.end()) {
+    return it->second;
+  } else {
+    return global_pc;
+  }
+}

riscv/cfg.h

@@ -6,6 +6,7 @@
 #include <vector>
 #include "decode.h"
 #include <cassert>
+#include <map>
 class abstract_sim_if_t;
 
 typedef enum {
@@ -59,6 +60,20 @@ class mem_cfg_t
   reg_t size;
 };
 
+class start_pc_t
+{
+public:
+  void set_global(reg_t pc);
+
+  void set_override(size_t hart_id, reg_t pc);
+
+  std::optional<reg_t> get(size_t hart_id) const;
+
+private:
+  std::optional<reg_t>    global_pc;
+  std::map<size_t, reg_t> hart_pcs;
+};
+
 class cfg_t
 {
 public:
@@ -72,7 +87,7 @@ class cfg_t
   reg_t                   pmpregions;
   reg_t                   pmpgranularity;
   std::vector<mem_cfg_t>  mem_layout;
-  std::optional<reg_t>    start_pc;
+  start_pc_t              start_pc;
   std::vector<size_t>     hartids;
   bool                    explicit_hartids;
   bool                    real_time_clint;

riscv/sim.cc

@@ -360,7 +360,7 @@ void sim_t::set_rom()
 {
   const int reset_vec_size = 8;
 
-  reg_t start_pc = cfg->start_pc.value_or(get_entry_point());
+  reg_t start_pc = cfg->start_pc.get(0).value_or(get_entry_point());
 
   uint32_t reset_vec[reset_vec_size] = {
     0x297,                                      // auipc  t0,0x0
@@ -479,4 +479,8 @@ endianness_t sim_t::get_target_endianness() const
 void sim_t::proc_reset(unsigned id)
 {
   debug_module.proc_reset(id);
+  if (id < procs.size()) {
+    procs[id]->get_state()->pc =
+        cfg->start_pc.get(id).value_or(get_entry_point());
+  }
 }

spike_main/spike.cc

@@ -20,6 +20,7 @@
 #include <limits>
 #include <cinttypes>
 #include <sstream>
+#include <map>
 #include "../VERSION"
 
 static void help(int exit_code = 1)
@@ -46,6 +47,7 @@ static void help(int exit_code = 1)
   fprintf(stderr, "  --pmpgranularity=<n>  PMP Granularity in bytes [default 4]\n");
   fprintf(stderr, "  --priv=<m|mu|msu>     RISC-V privilege modes supported [default %s]\n", DEFAULT_PRIV);
   fprintf(stderr, "  --pc=<address>        Override ELF entry point\n");
+  fprintf(stderr, "  --pcs=<H:A,...>       Override start PC for specific harts\n");
   fprintf(stderr, "  --hartids=<a,b,...>   Explicitly specify hartids, default is 0,1,...\n");
   fprintf(stderr, "  --ic=<S>:<W>:<B>      Instantiate a cache model with S sets,\n");
   fprintf(stderr, "  --dc=<S>:<W>:<B>        W ways, and B-byte blocks (with S and\n");
@@ -380,7 +382,24 @@ int main(int argc, char** argv)
   parser.option('m', 0, 1, [&](const char* s){cfg.mem_layout = parse_mem_layout(s);});
   parser.option(0, "halted", 0, [&](const char UNUSED *s){halted = true;});
   parser.option(0, "rbb-port", 1, [&](const char* s){use_rbb = true; rbb_port = atoul_safe(s);});
-  parser.option(0, "pc", 1, [&](const char* s){cfg.start_pc = strtoull(s, 0, 0);});
+  parser.option(0, "pc", 1, [&](const char* s){cfg.start_pc.set_global(strtoull(s, 0, 0));});
+
+  parser.option(0, "pcs", 1, [&](const char* s){
+    std::string arg(s);
+    std::stringstream ss(arg);
+    std::string pair;
+    while (std::getline(ss, pair, ',')) {
+      size_t delim = pair.find(':');
+      if (delim == std::string::npos) {
+        fprintf(stderr, "Error: --pcs format is hartid:addr,hartid:addr\n");
+        exit(1);
+      }
+      size_t hartid = std::stoul(pair.substr(0, delim));
+      reg_t addr = std::strtoull(pair.substr(delim+1).c_str(), NULL, 0);
+      cfg.start_pc.set_override(hartid, addr);
+    }
+  });
+
   parser.option(0, "hartids", 1, [&](const char* s){
     cfg.hartids = parse_hartids(s);
     cfg.explicit_hartids = true;