riscv/sim.cc

   1 // See LICENSE for license details.
   2
   3 #include "sim.h"
   4 #include "mmu.h"
   5 #include "remote_bitbang.h"
   6 #include <map>
   7 #include <iostream>
   8 #include <sstream>
   9 #include <climits>
  10 #include <cstdlib>
  11 #include <cassert>
  12 #include <signal.h>
  13 #include <unistd.h>
  14 #include <sys/wait.h>
  15 #include <sys/types.h>
  16
  17 volatile bool ctrlc_pressed = false;
  18 static void handle_signal(int sig)
  19 {
  20   if (ctrlc_pressed)
  21     exit(-1);
  22   ctrlc_pressed = true;
  23   signal(sig, &handle_signal);
  24 }
  25
  26 sim_t::sim_t(const char* isa, size_t nprocs, bool halted, reg_t start_pc,
  27              std::vector<std::pair<reg_t, mem_t*>> mems,
  28              const std::vector<std::string>& args)
  29   : htif_t(args), debug_module(this), mems(mems), procs(std::max(nprocs, size_t(1))),
  30     start_pc(start_pc),
  31     current_step(0), current_proc(0), debug(false), remote_bitbang(NULL)
  32 {
  33   signal(SIGINT, &handle_signal);
  34
  35   for (auto& x : mems)
  36     bus.add_device(x.first, x.second);
  37
  38   debug_module.add_device(&bus);
  39
  40   debug_mmu = new mmu_t(this, NULL);
  41
  42   for (size_t i = 0; i < procs.size(); i++) {
  43     procs[i] = new processor_t(isa, this, i, halted);
  44   }
  45
  46   clint.reset(new clint_t(procs));
  47   bus.add_device(CLINT_BASE, clint.get());
  48 }
  49
  50 sim_t::~sim_t()
  51 {
  52   for (size_t i = 0; i < procs.size(); i++)
  53     delete procs[i];
  54   delete debug_mmu;
  55 }
  56
  57 void sim_thread_main(void* arg)
  58 {
  59   ((sim_t*)arg)->main();
  60 }
  61
  62 void sim_t::main()
  63 {
  64   if (!debug && log)
  65     set_procs_debug(true);
  66
  67   while (!done())
  68   {
  69     if (debug || ctrlc_pressed)
  70       interactive();
  71     else
  72       step(INTERLEAVE);
  73     if (remote_bitbang) {
  74       remote_bitbang->tick();
  75     }
  76   }
  77 }
  78
  79 int sim_t::run()
  80 {
  81   host = context_t::current();
  82   target.init(sim_thread_main, this);
  83   return htif_t::run();
  84 }
  85
  86 void sim_t::step(size_t n)
  87 {
  88   for (size_t i = 0, steps = 0; i < n; i += steps)
  89   {
  90     steps = std::min(n - i, INTERLEAVE - current_step);
  91     procs[current_proc]->step(steps);
  92
  93     current_step += steps;
  94     if (current_step == INTERLEAVE)
  95     {
  96       current_step = 0;
  97       procs[current_proc]->yield_load_reservation();
  98       if (++current_proc == procs.size()) {
  99         current_proc = 0;
 100         clint->increment(INTERLEAVE / INSNS_PER_RTC_TICK);
 101       }
 102
 103       host->switch_to();
 104     }
 105   }
 106 }
 107
 108 void sim_t::set_debug(bool value)
 109 {
 110   debug = value;
 111 }
 112
 113 void sim_t::set_log(bool value)
 114 {
 115   log = value;
 116 }
 117
 118 void sim_t::set_histogram(bool value)
 119 {
 120   histogram_enabled = value;
 121   for (size_t i = 0; i < procs.size(); i++) {
 122     procs[i]->set_histogram(histogram_enabled);
 123   }
 124 }
 125
 126 void sim_t::set_procs_debug(bool value)
 127 {
 128   for (size_t i=0; i< procs.size(); i++)
 129     procs[i]->set_debug(value);
 130 }
 131
 132 bool sim_t::mmio_load(reg_t addr, size_t len, uint8_t* bytes)
 133 {
 134   if (addr + len < addr)
 135     return false;
 136   return bus.load(addr, len, bytes);
 137 }
 138
 139 bool sim_t::mmio_store(reg_t addr, size_t len, const uint8_t* bytes)
 140 {
 141   if (addr + len < addr)
 142     return false;
 143   return bus.store(addr, len, bytes);
 144 }
 145
 146 static std::string dts_compile(const std::string& dts)
 147 {
 148   // Convert the DTS to DTB
 149   int dts_pipe[2];
 150   pid_t dts_pid;
 151
 152   if (pipe(dts_pipe) != 0 || (dts_pid = fork()) < 0) {
 153     std::cerr << "Failed to fork dts child: " << strerror(errno) << std::endl;
 154     exit(1);
 155   }
 156
 157   // Child process to output dts
 158   if (dts_pid == 0) {
 159     close(dts_pipe[0]);
 160     int step, len = dts.length();
 161     const char *buf = dts.c_str();
 162     for (int done = 0; done < len; done += step) {
 163       step = write(dts_pipe[1], buf+done, len-done);
 164       if (step == -1) {
 165         std::cerr << "Failed to write dts: " << strerror(errno) << std::endl;
 166         exit(1);
 167       }
 168     }
 169     close(dts_pipe[1]);
 170     exit(0);
 171   }
 172
 173   pid_t dtb_pid;
 174   int dtb_pipe[2];
 175   if (pipe(dtb_pipe) != 0 || (dtb_pid = fork()) < 0) {
 176     std::cerr << "Failed to fork dtb child: " << strerror(errno) << std::endl;
 177     exit(1);
 178   }
 179
 180   // Child process to output dtb
 181   if (dtb_pid == 0) {
 182     dup2(dts_pipe[0], 0);
 183     dup2(dtb_pipe[1], 1);
 184     close(dts_pipe[0]);
 185     close(dts_pipe[1]);
 186     close(dtb_pipe[0]);
 187     close(dtb_pipe[1]);
 188     execl(DTC, DTC, "-O", "dtb", 0);
 189     std::cerr << "Failed to run " DTC ": " << strerror(errno) << std::endl;
 190     exit(1);
 191   }
 192
 193   close(dts_pipe[1]);
 194   close(dts_pipe[0]);
 195   close(dtb_pipe[1]);
 196
 197   // Read-out dtb
 198   std::stringstream dtb;
 199
 200   int got;
 201   char buf[4096];
 202   while ((got = read(dtb_pipe[0], buf, sizeof(buf))) > 0) {
 203     dtb.write(buf, got);
 204   }
 205   if (got == -1) {
 206     std::cerr << "Failed to read dtb: " << strerror(errno) << std::endl;
 207     exit(1);
 208   }
 209   close(dtb_pipe[0]);
 210
 211   // Reap children
 212   int status;
 213   waitpid(dts_pid, &status, 0);
 214   if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 215     std::cerr << "Child dts process failed" << std::endl;
 216     exit(1);
 217   }
 218   waitpid(dtb_pid, &status, 0);
 219   if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 220     std::cerr << "Child dtb process failed" << std::endl;
 221     exit(1);
 222   }
 223
 224   return dtb.str();
 225 }
 226
 227 void sim_t::make_dtb()
 228 {
 229   const int reset_vec_size = 8;
 230
 231   start_pc = start_pc == reg_t(-1) ? get_entry_point() : start_pc;
 232
 233   uint32_t reset_vec[reset_vec_size] = {
 234     0x297,                                      // auipc  t0,0x0
 235     0x28593 + (reset_vec_size * 4 << 20),       // addi   a1, t0, &dtb
 236     0xf1402573,                                 // csrr   a0, mhartid
 237     get_core(0)->xlen == 32 ?
 238       0x0182a283u :                             // lw     t0,24(t0)
 239       0x0182b283u,                              // ld     t0,24(t0)
 240     0x28067,                                    // jr     t0
 241     0,
 242     (uint32_t) (start_pc & 0xffffffff),
 243     (uint32_t) (start_pc >> 32)
 244   };
 245
 246   std::vector<char> rom((char*)reset_vec, (char*)reset_vec + sizeof(reset_vec));
 247
 248   std::stringstream s;
 249   s << std::dec <<
 250          "/dts-v1/;\n"
 251          "\n"
 252          "/ {\n"
 253          "  #address-cells = <2>;\n"
 254          "  #size-cells = <2>;\n"
 255          "  compatible = \"ucbbar,spike-bare-dev\";\n"
 256          "  model = \"ucbbar,spike-bare\";\n"
 257          "  cpus {\n"
 258          "    #address-cells = <1>;\n"
 259          "    #size-cells = <0>;\n"
 260          "    timebase-frequency = <" << (CPU_HZ/INSNS_PER_RTC_TICK) << ">;\n";
 261   for (size_t i = 0; i < procs.size(); i++) {
 262     s << "    CPU" << i << ": cpu@" << i << " {\n"
 263          "      device_type = \"cpu\";\n"
 264          "      reg = <" << i << ">;\n"
 265          "      status = \"okay\";\n"
 266          "      compatible = \"riscv\";\n"
 267          "      riscv,isa = \"" << procs[i]->isa_string << "\";\n"
 268          "      mmu-type = \"riscv," << (procs[i]->max_xlen <= 32 ? "sv32" : "sv48") << "\";\n"
 269          "      clock-frequency = <" << CPU_HZ << ">;\n"
 270          "      CPU" << i << "_intc: interrupt-controller {\n"
 271          "        #interrupt-cells = <1>;\n"
 272          "        interrupt-controller;\n"
 273          "        compatible = \"riscv,cpu-intc\";\n"
 274          "      };\n"
 275          "    };\n";
 276   }
 277   s <<   "  };\n";
 278   for (auto& m : mems) {
 279     s << std::hex <<
 280          "  memory@" << m.first << " {\n"
 281          "    device_type = \"memory\";\n"
 282          "    reg = <0x" << (m.first >> 32) << " 0x" << (m.first & (uint32_t)-1) <<
 283                    " 0x" << (m.second->size() >> 32) << " 0x" << (m.second->size() & (uint32_t)-1) << ">;\n"
 284          "  };\n";
 285   }
 286   s <<   "  soc {\n"
 287          "    #address-cells = <2>;\n"
 288          "    #size-cells = <2>;\n"
 289          "    compatible = \"ucbbar,spike-bare-soc\", \"simple-bus\";\n"
 290          "    ranges;\n"
 291          "    clint@" << CLINT_BASE << " {\n"
 292          "      compatible = \"riscv,clint0\";\n"
 293          "      interrupts-extended = <" << std::dec;
 294   for (size_t i = 0; i < procs.size(); i++)
 295     s << "&CPU" << i << "_intc 3 &CPU" << i << "_intc 7 ";
 296   reg_t clintbs = CLINT_BASE;
 297   reg_t clintsz = CLINT_SIZE;
 298   s << std::hex << ">;\n"
 299          "      reg = <0x" << (clintbs >> 32) << " 0x" << (clintbs & (uint32_t)-1) <<
 300                      " 0x" << (clintsz >> 32) << " 0x" << (clintsz & (uint32_t)-1) << ">;\n"
 301          "    };\n"
 302          "  };\n"
 303          "  htif {\n"
 304          "    compatible = \"ucb,htif0\";\n"
 305          "  };\n"
 306          "};\n";
 307
 308   dts = s.str();
 309   std::string dtb = dts_compile(dts);
 310
 311   rom.insert(rom.end(), dtb.begin(), dtb.end());
 312   const int align = 0x1000;
 313   rom.resize((rom.size() + align - 1) / align * align);
 314
 315   boot_rom.reset(new rom_device_t(rom));
 316   bus.add_device(DEFAULT_RSTVEC, boot_rom.get());
 317 }
 318
 319 char* sim_t::addr_to_mem(reg_t addr) {
 320   auto desc = bus.find_device(addr);
 321   if (auto mem = dynamic_cast<mem_t*>(desc.second))
 322     if (addr - desc.first < mem->size())
 323       return mem->contents() + (addr - desc.first);
 324   return NULL;
 325 }
 326
 327 // htif
 328
 329 void sim_t::reset()
 330 {
 331   make_dtb();
 332 }
 333
 334 void sim_t::idle()
 335 {
 336   target.switch_to();
 337 }
 338
 339 void sim_t::read_chunk(addr_t taddr, size_t len, void* dst)
 340 {
 341   assert(len == 8);
 342   auto data = debug_mmu->load_uint64(taddr);
 343   memcpy(dst, &data, sizeof data);
 344 }
 345
 346 void sim_t::write_chunk(addr_t taddr, size_t len, const void* src)
 347 {
 348   assert(len == 8);
 349   uint64_t data;
 350   memcpy(&data, src, sizeof data);
 351   debug_mmu->store_uint64(taddr, data);
 352 }