Fix --kernel and --initrd options w.r.t. sparse mem_t implementation

For some reason, the old accessors for the non-sparse version were left
dangling.  These methods are used by the --kernel and --initrd options,
and so those options were just broken.

This also fixes a memory leak and refactors the implementation a bit.

3 files changed, 53 insertions, 27 deletions

diff --git a/riscv/devices.cc b/riscv/devices.cc
index 6c78456..fb476ec 100644
--- a/riscv/devices.cc
+++ b/riscv/devices.cc
@@ -1,5 +1,6 @@
 #include "devices.h"
 #include "mmu.h"
+#include <stdexcept>
 
 void bus_t::add_device(reg_t addr, abstract_device_t* dev)
 {
@@ -90,17 +91,49 @@ bool mmio_plugin_device_t::store(reg_t addr, size_t len, const uint8_t* bytes)
   return (*plugin.store)(user_data, addr, len, bytes);
 }
 
-char* mem_t::contents() {
-    return data;
+mem_t::mem_t(reg_t size)
+  : sz(size)
+{
+  if (size == 0 || size % PGSIZE != 0)
+    throw std::runtime_error("memory size must be a positive multiple of 4 KiB");
+}
+
+mem_t::~mem_t()
+{
+  for (auto& entry : sparse_memory_map)
+    free(entry.second);
+}
+
+bool mem_t::load_store(reg_t addr, size_t len, uint8_t* bytes, bool store)
+{
+  if (addr + len < addr || addr + len > sz)
+    return false;
+
+  while (len > 0) {
+    auto n = std::min(PGSIZE - (addr % PGSIZE), len);
+
+    if (store)
+      memcpy(this->contents(addr), bytes, n);
+    else
+      memcpy(bytes, this->contents(addr), n);
+
+    addr += n;
+    bytes += n;
+    len -= n;
+  }
+
+  return true;
 }
 
 char* mem_t::contents(reg_t addr) {
-    reg_t pg_idx = addr & ~reg_t(PGSIZE - 1);
-    auto search = acc_tbl.find(pg_idx);
-    if (search == acc_tbl.end() || !search->second.second) {
-        char* mem_ptr = (char*)calloc(PGSIZE, sizeof(char));
-        acc_tbl[pg_idx] = std::make_pair(mem_ptr, true);
-    }
-    auto offset = addr & (PGSIZE - 1);
-    return acc_tbl[pg_idx].first + offset;
+  reg_t ppn = addr >> PGSHIFT, pgoff = addr % PGSIZE;
+  auto search = sparse_memory_map.find(ppn);
+  if (search == sparse_memory_map.end()) {
+    auto res = (char*)calloc(PGSIZE, 1);
+    if (res == nullptr)
+      throw std::bad_alloc();
+    sparse_memory_map[ppn] = res;
+    return res + pgoff;
+  }
+  return search->second + pgoff;
 }
diff --git a/riscv/devices.h b/riscv/devices.h
index 82aab89..2003d17 100644
--- a/riscv/devices.h
+++ b/riscv/devices.h
@@ -7,7 +7,6 @@
 #include <string>
 #include <map>
 #include <vector>
-#include <stdexcept>
 #include <utility>
 
 class processor_t;
@@ -43,26 +42,20 @@ class rom_device_t : public abstract_device_t {
 
 class mem_t : public abstract_device_t {
  public:
-  mem_t(size_t size) : len(size) {
-    if (!size)
-      throw std::runtime_error("zero bytes of target memory requested");
-    data = nullptr;
-  }
+  mem_t(reg_t size);
   mem_t(const mem_t& that) = delete;
-  ~mem_t() {
-        free(data);
-  }
+  ~mem_t();
 
-  bool load(reg_t addr, size_t len, uint8_t* bytes) { return false; }
-  bool store(reg_t addr, size_t len, const uint8_t* bytes) { return false; }
-  char* contents();
+  bool load(reg_t addr, size_t len, uint8_t* bytes) { return load_store(addr, len, bytes, false); }
+  bool store(reg_t addr, size_t len, const uint8_t* bytes) { return load_store(addr, len, const_cast<uint8_t*>(bytes), true); }
   char* contents(reg_t addr);
-  size_t size() { return len; }
+  reg_t size() { return sz; }
 
  private:
-  std::map<reg_t, std::pair<char*, bool>> acc_tbl;
-  char* data;
-  size_t len;
+  bool load_store(reg_t addr, size_t len, uint8_t* bytes, bool store);
+
+  std::map<reg_t, char*> sparse_memory_map;
+  reg_t sz;
 };
 
 class clint_t : public abstract_device_t {
diff --git a/riscv/sim.cc b/riscv/sim.cc
index 73d2b45..e9e61c5 100644
--- a/riscv/sim.cc
+++ b/riscv/sim.cc
@@ -353,7 +353,7 @@ char* sim_t::addr_to_mem(reg_t addr) {
   auto desc = bus.find_device(addr);
   if (auto mem = dynamic_cast<mem_t*>(desc.second))
     if (addr - desc.first < mem->size())
-      return mem->contents(addr);
+      return mem->contents(addr - desc.first);
   return NULL;
 }