npc: wip, cannot build

npc/include/components.hpp

@@ -11,6 +11,7 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <string>
@@ -32,21 +33,21 @@ public:
   }
 };
 
-template <typename T, std::size_t n> class Memory {
-  uint32_t expand_bits(uint8_t bits) {
-    uint32_t x = bits;
-    x = (x | (x << 7) | (x << 14) | (x << 21)) & 0x01010101;
-    x = x * 0xFF;
-    // printf("expand: %hhx->%x\n", bits, x);
-    return x;
-  }
+// class MemoryFile {
+//   std::filesystem::path filepath;
+//   public:
+
+// };
+
+template <std::size_t n> class Memory {
+  paddr_t pmem_start, pmem_end;
 
 public:
-  std::array<T, n> mem;
-  std::vector<std::array<uint64_t, 2>> trace_ranges;
-  Memory(std::filesystem::path filepath, bool is_binary,
-         std::vector<std::array<uint64_t, 2>> &&trace_ranges)
-      : trace_ranges(std::move(trace_ranges)) {
+  std::array<uint8_t, n> mem;
+  // TODO: Read memory file before init and use memcpy to initialize memory.
+  Memory(std::filesystem::path filepath, bool is_binary, paddr_t pmem_start,
+         paddr_t pmem_end)
+      : pmem_start(pmem_start), pmem_end(pmem_end) {
     if (!std::filesystem::exists(filepath))
       throw std::runtime_error("Memory file not found");
     if (is_binary) {
@@ -62,54 +63,79 @@ public:
       }
     }
   }
-  const T &operator[](std::size_t addr) { return this->read(addr); }
-  /**
-   * Always reads and returns 4 bytes from the address raddr & ~0x3u.
-   */
-  T read(paddr_t raddr) {
-    // printf("raddr: 0x%x\n", raddr);
-    return *(word_t *)guest_to_host(raddr);
+  const word_t &operator[](std::size_t addr) { return this->read(addr); }
+  void transfer(paddr_t addr, uint8_t data[], size_t len, bool is_write) {
+    if (is_write) {
+      // memcpy(guest_to_host(addr), data, len);
+      size_t offset = (addr - pmem_start);
+      std::copy(data, data + len, &mem[offset]);
+    } else {
+      // memcpy(data, guest_to_host(addr), len);
+      size_t offset = (addr - pmem_start);
+      std::copy(&mem[offset], &mem[offset + len], data);
+    }
   }
-  /**
-   * Always writes to the 4 bytes at the address `waddr` & ~0x3u.
-   * Each bit in `wmask` represents a mask for one byte in wdata.
-   * For example, wmask = 0x3 means only the lowest 2 bytes are written,
-   * and the other bytes in memory remain unchanged.
-   */
-  void write(paddr_t waddr, T wdata, char wmask) {
+  bool in_pmem(paddr_t addr) const {
+    return addr >= pmem_start && addr <= pmem_end;
+  }
+};
+
+template <typename Mem, typename DevMap> class MemoryMap {
+  std::unique_ptr<Mem> ram;
+  std::unique_ptr<DevMap> devices;
+  const std::vector<std::array<uint64_t, 2>> &trace_ranges;
+
+public:
+  MemoryMap(std::unique_ptr<Mem> &&ram, std::unique_ptr<DevMap> &&devices,
+            const std::vector<std::array<uint64_t, 2>> &trace_ranges)
+      : ram(std::move(ram)), devices(std::move(devices)),
+        trace_ranges(trace_ranges) {}
+  void write(paddr_t waddr, word_t wdata, char wmask) {
     // printf("waddr: 0x%x\n", waddr);
-    uint8_t *p_data = (uint8_t *)&wdata;
-    while (wmask & 0x1) {
-      memcpy(guest_to_host(waddr), p_data, 1);
-      waddr++;
-      p_data++;
-      wmask >>= 1;
+    size_t len = (wmask & 1) + ((wmask & 2) >> 1) + ((wmask & 4) >> 2) +
+                 ((wmask & 8) >> 3);
+    if (ram->in_pmem(waddr)) {
+      ram->transfer(waddr, (uint8_t *)&wdata, len, true);
+    } else if (devices->handle(waddr, (uint8_t *)&wdata, len, true)) {
     }
   }
-  void *guest_to_host(std::size_t addr) {
-    extern bool g_skip_memcheck;
-    if (g_skip_memcheck) {
-      return mem.data();
+  word_t read(paddr_t raddr) const {
+    word_t res = 0;
+    // printf("raddr: 0x%x, in_pmem: %d\n", raddr, ram->in_pmem(raddr));
+    if (ram->in_pmem(raddr)) {
+      ram->transfer(raddr, (uint8_t *)&res, 4, false);
+    } else if (devices->handle(raddr, (uint8_t *)&res, 4, false)) {
     }
-    if (addr < 0x80000000 || addr > 0x87ffffff) {
-      std::cerr << std::hex << "ACCESS " << addr << std::dec << std::endl;
-      throw std::runtime_error("Invalid memory access");
-    }
-    // Linear mapping
-    return (uint8_t *)(mem.data() + (addr >> 2) - 0x20000000) + (addr & 0x3);
+    return res;
   }
+  void copy_to(paddr_t addr, uint8_t *buf, size_t len) const {
+    if (ram->in_pmem(addr)) {
+      ram->transfer(addr, buf, len, false);
+    } else {
+      std::cerr << "Not in pmem" << std::endl;
+    }
+  }
+  void copy_from(paddr_t addr, const uint8_t *buf, size_t len) {
+    if (ram->in_pmem(addr)) {
+      ram->transfer(addr, buf, len, true);
+    } else {
+      std::cerr << "Not in pmem" << std::endl;
+    }
+  }
+  void *get_pmem() { return ram->mem.data(); }
   void trace(paddr_t addr, bool is_read, word_t pc = 0, word_t value = 0) {
     for (auto &r : trace_ranges) {
       if (r[0] <= addr && r[1] >= addr) {
         std::stringstream os;
-        os << std::hex;
         if (pc != 0)
-          os << "0x" << pc << " ";
+          os << "0x" << std::hex << pc << " ";
         if (is_read)
-          os << "[R] ";
+          os << "[R] "
+             << "0x" << addr << ": 0x" << this->read(addr);
         else
-          os << "[W] " << value << " -> ";
-        os << "0x" << addr << std::dec << std::endl;
+          os << "[W] " << value << " -> "
+             << "0x" << addr;
+        os << std::dec << std::endl;
         std::cout << os.rdbuf();
         break;
       }

npc/include/config.hpp

@@ -9,7 +9,7 @@
 
 struct Config {
   std::filesystem::path memory_file;
-  uint64_t max_sim_time = 0;
+  bool interactive{false};
   bool memory_file_binary = {true};
   bool do_mtrace{false};
   std::vector<std::array<std::size_t, 2>> mtrace_ranges{
@@ -21,4 +21,4 @@ struct Config {
 
 extern Config config;
 
-#endif
+#endif

npc/include/trm_interface.hpp

@@ -37,6 +37,7 @@ template <typename R, size_t nr_reg> struct CPUStateBase {
 
   /* This does not update the register!!! */
   R at(std::string name) {
+    // FIXME: Using this to get pc seems broken
     return name == "pc" ? pc : reg[regs_by_name.at(name)];
   }
 
@@ -154,4 +155,4 @@ struct RefTrmInterface : TrmInterface {
   void print(std::ostream &os) const override { os << *(CPUState *)cpu_state; }
 };
 
-#endif
+#endif