Merge pull request rivosinc#4 from rivosinc/dev/joy/update_to_work_with_latest_spike

Updates to build with the current Spike

Author: jerinjoy

hammer.cpp

@@ -42,7 +42,11 @@ Hammer::Hammer(const char *isa, const char *privilege_levels, const char *vector
   const char *bootargs = nullptr;
   bool real_time_clint = false;
 
-  cfg_t cfg = cfg_t(initrd_bounds, bootargs, isa, privilege_levels, vector_arch, memory_layout,
+  reg_t num_pmpregions = 16;
+
+  endianness_t endinaness = endianness_little;
+
+  cfg_t cfg = cfg_t(initrd_bounds, bootargs, isa, privilege_levels, vector_arch, endinaness, num_pmpregions, memory_layout,
                     hart_ids, real_time_clint);
 
   if (start_pc.has_value()) {
@@ -56,9 +60,10 @@ Hammer::Hammer(const char *isa, const char *privilege_levels, const char *vector
 
   bool halted = false;
   bool dtb_enabled = true;
+  bool socket_enabled = false;
 
   simulator = new sim_t(&cfg, halted, mems, plugin_devices, htif_args, dm_config, log_path,
-                        dtb_enabled, dtb_file, cmd_file);
+                        dtb_enabled, dtb_file, socket_enabled, cmd_file);
 
   // Initializes everything
   simulator->start();
@@ -148,50 +153,3 @@ std::vector<uint64_t> Hammer::get_vector_reg(uint8_t hart_id, uint8_t vector_reg
   return vector_reg_value;
 }
 
-std::vector<uint8_t> Hammer::get_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
-                                              size_t num_bytes_to_read) {
-  std::vector<uint8_t> memory_contents;
-
-  processor_t *hart = simulator->get_core(hart_id);
-  mmu_t *mmu = hart->get_mmu();
-
-  while (num_bytes_to_read > 0) {
-    uint64_t bytes_read = 0;
-    size_t num_bytes_read = 0;
-
-    if ((num_bytes_to_read > 8) && (virtual_address % 8) == 0) {
-      bytes_read = mmu->load_uint64(virtual_address);
-      num_bytes_read = 8;
-    } else if ((num_bytes_to_read > 4) && (virtual_address % 4) == 0) {
-      bytes_read = mmu->load_uint32(virtual_address);
-      num_bytes_read = 4;
-    } else if ((num_bytes_to_read > 2) && (virtual_address % 2) == 0) {
-      bytes_read = mmu->load_uint16(virtual_address);
-      num_bytes_read = 2;
-    } else {
-      bytes_read = mmu->load_uint8(virtual_address);
-      num_bytes_read = 1;
-    }
-
-    for (size_t i = 0; i < num_bytes_read; ++i) {
-      memory_contents.push_back(bytes_read & 0xFF);
-      bytes_read >>= 8;
-    }
-
-    virtual_address += num_bytes_read;
-    num_bytes_to_read -= num_bytes_read;
-  }
-
-  return memory_contents;
-}
-
-void Hammer::set_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
-                              const std::vector<uint8_t> &memory_contents) {
-  processor_t *hart = simulator->get_core(hart_id);
-  mmu_t *mmu = hart->get_mmu();
-
-  for (uint8_t byte_to_write : memory_contents) {
-    mmu->store_uint8(virtual_address, byte_to_write);
-    ++virtual_address;
-  }
-}

hammer.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "hammer_enums.h"
+#include "riscv/mmu.h"
 #include "riscv/sim.h"
 
 #include <iostream>
@@ -35,10 +36,36 @@ class Hammer {
 
   std::vector<uint64_t> get_vector_reg(uint8_t hart_id, uint8_t vector_reg_id);
 
-  std::vector<uint8_t> get_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
-                                        size_t num_bytes_to_read);
-  void set_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
-                        const std::vector<uint8_t> &memory_contents);
+  template <typename T>
+  std::optional<std::vector<T>> get_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
+                                                 size_t num_bytes_to_read) {
+    if (num_bytes_to_read % sizeof(T))
+      return std::nullopt;
+    mmu_t *mmu = simulator->get_core(hart_id)->get_mmu();
+    std::vector<T> data;
+    try {
+      for (size_t i = 0; i < num_bytes_to_read; i += sizeof(T))
+        data.push_back(mmu->load<T>(virtual_address + i));
+    } catch (trap_t &t) {
+      return std::nullopt;
+    }
+    return data;
+  }
+
+  template <typename T>
+  int set_memory_at_VA(uint8_t hart_id, uint64_t virtual_address,
+                       const std::vector<T> &memory_contents) {
+    mmu_t *mmu = simulator->get_core(hart_id)->get_mmu();
+    try {
+      for (auto &i : memory_contents) {
+        mmu->store<T>(virtual_address, i);
+        virtual_address += sizeof(T);
+      }
+    } catch (trap_t &t) {
+      return -EFAULT;
+    }
+    return 0;
+  }
 
   void hello_world() { printf("Hammer: Hello World.\n"); }
 

hammer_pybind.cpp

@@ -29,8 +29,48 @@ PYBIND11_MODULE(hammer, m) {
       .def("get_vlen", &Hammer::get_vlen)
       .def("get_elen", &Hammer::get_elen)
       .def("get_vector_reg", &Hammer::get_vector_reg)
-      .def("get_memory_at_VA", &Hammer::get_memory_at_VA)
-      .def("set_memory_at_VA", &Hammer::set_memory_at_VA)
+      .def("get_memory_at_VA",
+           [](Hammer &h, uint8_t hart_id, uint64_t virtual_address, size_t num_bytes_to_read,
+              size_t stride) -> pybind11::object {
+             switch (stride) {
+               case 1:
+                 return pybind11::cast(
+                     h.get_memory_at_VA<uint8_t>(hart_id, virtual_address, num_bytes_to_read));
+               case 2:
+                 return pybind11::cast(
+                     h.get_memory_at_VA<uint16_t>(hart_id, virtual_address, num_bytes_to_read));
+               case 4:
+                 return pybind11::cast(
+                     h.get_memory_at_VA<uint32_t>(hart_id, virtual_address, num_bytes_to_read));
+               case 8:
+                 return pybind11::cast(
+                     h.get_memory_at_VA<uint64_t>(hart_id, virtual_address, num_bytes_to_read));
+               default:
+                 throw std::length_error("Invalid stride");
+             }
+             return pybind11::none();
+           })
+      .def("set_memory_at_VA",
+           [](Hammer &h, uint8_t hart_id, uint64_t virtual_address, pybind11::list &data,
+              size_t stride) {
+             switch (stride) {
+               case 1:
+                 return h.set_memory_at_VA<uint8_t>(hart_id, virtual_address,
+                                                    data.cast<std::vector<uint8_t>>());
+               case 2:
+                 return h.set_memory_at_VA<uint16_t>(hart_id, virtual_address,
+                                                     data.cast<std::vector<uint16_t>>());
+               case 4:
+                 return h.set_memory_at_VA<uint32_t>(hart_id, virtual_address,
+                                                     data.cast<std::vector<uint32_t>>());
+               case 8:
+                 return h.set_memory_at_VA<uint64_t>(hart_id, virtual_address,
+                                                     data.cast<std::vector<uint64_t>>());
+               default:
+                 throw std::length_error("Invalid stride");
+             }
+             return -EINVAL;
+           })
       .def("single_step", &Hammer::single_step);
 
   // Reference:

pytests/pytest002.py

@@ -32,7 +32,10 @@ def main():
     # Reads memory using Hammer::get_memory_at_VA(), single steps a load that
     # reads the same address and compares values.
     virtual_address = 0x80001000
-    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8)
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8, 1)
+
+    if (memory_contents is None):
+        sys.exit("ERROR: Unable to read memory")
 
     value_at_address = 0
     i = 0
@@ -50,6 +53,22 @@ def main():
               "the load instruction which returned {current_x2}")
         sys.exit(1)
 
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8, 8)
+    if (memory_contents[0] != current_x2):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8, 4)
+    memory_contents[0] |= memory_contents[1] << 32
+    if (memory_contents[0] != current_x2):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8, 2)
+    memory_contents[0] |= memory_contents[1] << 16
+    memory_contents[0] |= memory_contents[2] << 32
+    memory_contents[0] |= memory_contents[3] << 48
+    if (memory_contents[0] != current_x2):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
     # Writes memory using Hammer::set_memory_at_VA(), single steps a load that
     # reads the same address and compares values.
     new_memory_contents = [0xab, 0xcd, 0xef, 0xde, 0x11, 0x22, 0x33, 0x44]
@@ -59,7 +78,8 @@ def main():
         new_value_at_address |= (byte_value << (i * 8))
         i = i + 1
 
-    hammer.set_memory_at_VA(0, virtual_address, new_memory_contents)
+    if (hammer.set_memory_at_VA(0, virtual_address, new_memory_contents, 1)):
+        sys.exit("ERROR: set_memory_at_VA() failed")
 
     # Step the next load that will read the same location
     hammer.single_step(0)
@@ -71,6 +91,46 @@ def main():
               "the load instruction returned {current_x2:x}")
         sys.exit(1)
 
+    # Tests the fail case.
+    memory_contents = hammer.get_memory_at_VA(0, 0xabcdabcdabcd, 1, 1)
+    if (memory_contents is not None):
+        sys.exit("ERROR: Expected memory load to fail.")
+
+    if (hammer.set_memory_at_VA(0, 0xabcdabcdabcd, new_memory_contents, 1) == 0):
+        sys.exit("ERROR: Expected memory store to fail.")
+
+    # Test set of various sizes (8/4/2)
+    new_memory_contents = [0xdeadbeef01234567]
+    if (hammer.set_memory_at_VA(0, virtual_address, new_memory_contents, 8)):
+        sys.exit("ERROR: set_memory_at_VA() failed")
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 8, 8)
+    if (memory_contents[0] != new_memory_contents[0]):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
+    new_memory_contents = [0xdeadbeef]
+    if (hammer.set_memory_at_VA(0, virtual_address, new_memory_contents, 4)):
+        sys.exit("ERROR: set_memory_at_VA() failed")
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 4, 4)
+    if (memory_contents[0] != new_memory_contents[0]):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
+    new_memory_contents = [0xdead]
+    if (hammer.set_memory_at_VA(0, virtual_address, new_memory_contents, 2)):
+        sys.exit("ERROR: set_memory_at_VA() failed")
+    memory_contents = hammer.get_memory_at_VA(0, virtual_address, 2, 2)
+    if (memory_contents[0] != new_memory_contents[0]):
+        sys.exit(f'unexpected data read: 0x{memory_contents[0]:x}')
+
+    # Invalid stride
+    try:
+        hammer.set_memory_at_VA(0, virtual_address, new_memory_contents, 3)
+    except ValueError:
+        pass
+    try:
+        hammer.get_memory_at_VA(0, virtual_address, 2, 5)
+    except ValueError:
+        pass
+
     pass
 
 

tests/test002.cpp

@@ -29,17 +29,20 @@ int main(int argc, char *argv[]) {
 
   uint64_t virtual_address = data_area_start_address;
   for (uint32_t bytes_to_read = 8; bytes_to_read > 0; --bytes_to_read) {
-    std::vector<uint8_t> memory_contents =
-        hammer.get_memory_at_VA(0, virtual_address, bytes_to_read);
+    auto memory_contents = hammer.get_memory_at_VA<uint8_t>(0, virtual_address, bytes_to_read);
+    if (memory_contents.has_value() == false) {
+      printf("ERROR: Unable to read memory\n");
+      exit(1);
+    }
 
-    if (memory_contents.size() != bytes_to_read) {
+    if (memory_contents.value().size() != bytes_to_read) {
       printf("ERROR: Bytes read did not match requested num bytes\n");
       exit(1);
     }
 
     uint64_t value_at_address = 0;
     uint8_t i = 0;
-    for (uint64_t byte_value : memory_contents) {
+    for (uint64_t byte_value : memory_contents.value()) {
       value_at_address |= (byte_value << (i * 8));
       ++i;
     }
@@ -67,7 +70,10 @@ int main(int argc, char *argv[]) {
   }
 
   virtual_address = data_area_start_address;
-  hammer.set_memory_at_VA(0, virtual_address, new_memory_contents);
+  if (hammer.set_memory_at_VA<uint8_t>(0, virtual_address, new_memory_contents)) {
+    printf("ERROR: set_memory_at_VA() failed\n");
+    exit(1);
+  }
 
   // Step the next load that will read the same location
   hammer.single_step(0);
@@ -81,4 +87,16 @@ int main(int argc, char *argv[]) {
            new_value_at_address, current_x2);
     exit(1);
   }
+
+  // Tests the fail case.
+  auto memory_contents = hammer.get_memory_at_VA<uint32_t>(0, 0xabcdabcdabcd, 1);
+  if (memory_contents.has_value()) {
+    printf("ERROR: Expected memory load to fail.\n");
+    exit(1);
+  }
+
+  if (hammer.set_memory_at_VA<uint8_t>(0, 0xabcdabcdabcd, new_memory_contents) == 0) {
+    printf("ERROR: Expected memory store to fail.\n");
+    exit(1);
+  }
 }