feat: adding RV64 riscv-tests suite in build and regression (#1259)

- RV64 tests for the ISS
 Added rv64-riscv-tests configuration 
Updated test:riscv-tests target with ability to build and test RV64
configuration
- Corrected many instruction implementations to handle 64bit mode
- Corrected the page walker and address translation
- Added rv64 riscv-tests to the regression

Author: henrikg-qc

.github/workflows/regress.yml

@@ -221,8 +221,19 @@ jobs:
         uses: actions/checkout@v4
       - name: singularity setup
         uses: ./.github/actions/singularity-setup
-      - name: Run riscv-tests
-        run: ./do test:riscv_tests CONFIG=rv32 JOBS=4
+      - name: Run RV32 riscv-tests
+        run: ./do test:riscv_tests CONFIG=rv32 IGNOREUNDEFINED=YES JOBS=4
+  regress-riscv-tests-64:
+    runs-on: ubuntu-latest
+    env:
+      SINGULARITY: 1
+    steps:
+      - name: Clone Github Repo Action
+        uses: actions/checkout@v4
+      - name: singularity setup
+        uses: ./.github/actions/singularity-setup
+      - name: Run RV64 riscv-tests
+        run: ./do test:riscv_tests CONFIG=rv64 IGNOREUNDEFINED=YES JOBS=4
   regress-xqci-doc:
     runs-on: ubuntu-latest
     env:

.vscode/launch.json

@@ -5,8 +5,8 @@
       "name": "ISS debug Launch",
       "type": "cppdbg",
       "request": "launch",
-      "program": "${workspaceFolder}/gen/cpp_hart_gen/rv32_Debug/build/iss",
-      "args": ["-m", "rv32", "-c", "${workspaceFolder}/cfgs/rv32-riscv-tests.yaml", "${workspaceFolder}/ext/riscv-tests/isa/rv32ui-p-addi"],
+      "program": "${workspaceFolder}/gen/cpp_hart_gen/rv64_Debug/build/iss",
+      "args": ["-m", "rv64", "-c", "${workspaceFolder}/cfgs/rv64-riscv-tests.yaml", "${workspaceFolder}/ext/riscv-tests/isa/rv64ui-p-addi"],
       "stopAtEntry": true,
       "cwd": "${workspaceFolder}",
       "environment": [],

backends/cpp_hart_gen/CMakeLists.txt

@@ -118,6 +118,9 @@ add_library(hart
 #  ../gen/iss/oryon/src/decode.cxx
 )
 target_include_directories(hart PUBLIC ${CMAKE_SOURCE_DIR}/include)
+if(IGNOREUNDEFINED STREQUAL "YES")
+target_compile_definitions(hart PUBLIC IGNOREUNDEFINED)
+endif()
 target_link_libraries(hart PUBLIC yaml-cpp::yaml-cpp nlohmann_json_schema_validator fmt::fmt ctre::ctre -lgmp -lgmpxx)
 
 # add_library(hart_c ${CMAKE_SOURCE_DIR}/src/libhart_c.cpp)
@@ -135,6 +138,9 @@ add_executable(iss
   ${CMAKE_SOURCE_DIR}/src/iss.cpp
   ${CMAKE_SOURCE_DIR}/src/elf_reader.cpp
 )
+if(IGNOREUNDEFINED STREQUAL "YES")
+target_compile_definitions(iss PUBLIC IGNOREUNDEFINED)
+endif()
 target_link_libraries(iss PRIVATE hart elf CLI11::CLI11)
 
 

backends/cpp_hart_gen/cpp/include/udb/bits.hpp

@@ -60,6 +60,13 @@ static_assert(sizeof(1ull) == 8);
 #error "Compiler does not support __int128"
 #endif
 
+#ifndef IGNOREUNDEFINED
+#define UNDEFINED_VALUE_ERROR(s)  throw UndefinedValueError(s)
+#else
+#define UNDEFINED_VALUE_ERROR(s)
+#endif
+
+
 namespace udb {
 
   // helper to find the max of N unsigned values at compile time
@@ -694,6 +701,10 @@ namespace udb {
       }
     }
 
+    constexpr std::conditional_t<Signed, SignedStorageType, const StorageType &> get_ignore_unknown() const {
+      return m_val;
+    }
+
     constexpr const _Bits& to_defined() const { return *this; }
 
     // cast to other Bits types
@@ -2408,27 +2419,25 @@ namespace udb {
     constexpr operator BitsType<M, _Signed>() const {
       if constexpr (!BitsType<M, _Signed>::PossiblyUnknown) {
         if (m_unknown_mask != 0) {
-          throw UndefinedValueError("Cannot convert value with unknowns to Bits type");
+          UNDEFINED_VALUE_ERROR("Cannot convert value with unknowns to Bits type");
         }
       }
       return BitsType<M, _Signed>{*this};
     }
 
     template <typename T = std::conditional_t<Signed, SignedStorageType, StorageType>>
     constexpr T get() const {
-      if (m_unknown_mask == 0_b) {
-        return m_val.get();
-      } else {
-        throw UndefinedValueError("Cannot convert value with unknowns to a native C++ type");
+      if (m_unknown_mask != 0_b) {
+        UNDEFINED_VALUE_ERROR("Cannot convert value with unknowns to a native C++ type");
       }
+      return m_val.get();
     }
 
     constexpr _Bits<N, Signed> to_defined() const {
-      if (m_unknown_mask == 0_b) {
-        return m_val;
-      } else {
-        throw UndefinedValueError("Cannot convert value with unknowns to a defined type");
+      if (m_unknown_mask != 0_b) {
+        UNDEFINED_VALUE_ERROR("Cannot convert value with unknowns to a defined type");
       }
+      return m_val;
     }
 
 
@@ -2480,7 +2489,7 @@ namespace udb {
   constexpr bool operator op(const BitsType<M, _Signed> &rhs) const {                   \
     if (m_unknown_mask != 0_b ||                                                  \
         (BitsType<M, _Signed>::PossiblyUnknown && (rhs.unknown_mask() != 0_b))) { \
-      throw UndefinedValueError("Cannot compare unknown value");                  \
+      UNDEFINED_VALUE_ERROR("Cannot compare unknown value");                  \
     }                                                                             \
     return get() op rhs.to_defined().get();                                       \
   }
@@ -2626,7 +2635,7 @@ namespace udb {
     constexpr _PossiblyUnknownBits operator<<(const BitsType<M, false> &shamt) const {
       if constexpr (BitsType<M, false>::PossiblyUnknown) {
         if (shamt.unknown_mask() != 0_b) {
-          throw UndefinedValueError("Cannot shift an unknown amount");
+          UNDEFINED_VALUE_ERROR("Cannot shift an unknown amount");
         }
       }
       if (shamt.get() >= N) {
@@ -2641,7 +2650,7 @@ namespace udb {
     constexpr _PossiblyUnknownBits operator>>(const BitsClass<M, false> &shamt) const {
       if constexpr (BitsClass<M, false>::PossiblyUnknown) {
         if (shamt.unknown_mask() != 0_b) {
-          throw UndefinedValueError("Cannot shift an unknown amount");
+          UNDEFINED_VALUE_ERROR("Cannot shift an unknown amount");
         }
       }
       if (shamt.get() >= N) {
@@ -2656,7 +2665,7 @@ namespace udb {
     constexpr _PossiblyUnknownBits sra(const BitsClass<M, false> &shamt) const {
       if constexpr (BitsClass<M, false>::PossiblyUnknown) {
         if (shamt.unknown_mask() != 0_b) {
-          throw UndefinedValueError("Cannot shift an unknown amount");
+          UNDEFINED_VALUE_ERROR("Cannot shift an unknown amount");
         }
       }
       if (shamt.get() >= N) {
@@ -2715,7 +2724,7 @@ namespace udb {
       _Bits<constmax_v<N, RhsN> + 1, Signed> lhs{*this};
 
       if (m_unknown_mask != 0_b || _rhs.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Addition is not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Addition is not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<RhsN, RhsSigned>::RuntimeWidth) {
@@ -2738,7 +2747,7 @@ namespace udb {
       _Bits<constmax_v<N, RhsN> + 1, Signed> lhs{*this};
 
       if (m_unknown_mask != 0_b || _rhs.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Addition is not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Addition is not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<RhsN, RhsSigned>::RuntimeWidth) {
@@ -2767,7 +2776,7 @@ namespace udb {
       _Bits<addsat_v<N, RhsN>, Signed> lhs{*this};
 
       if (m_unknown_mask != 0_b || _rhs.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Addition is not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Addition is not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<RhsN, RhsSigned>::RuntimeWidth) {
@@ -3171,7 +3180,7 @@ namespace udb {
           m_val, result_width};
 
       if (unknown_mask() != 0_b || other.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Multiplication not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Multiplication not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<addsat_v<MaxN, RhsN>, RhsSigned>::RuntimeWidth) {
@@ -3194,7 +3203,7 @@ namespace udb {
           m_val, result_width};
 
       if (unknown_mask() != 0_b || other.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Addition not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Addition not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<constmax_v<MaxN, RhsN> + 1, RhsSigned>::RuntimeWidth) {
@@ -3217,7 +3226,7 @@ namespace udb {
           m_val, result_width};
 
       if (unknown_mask() != 0_b || other.unknown_mask() != 0_b) {
-        throw UndefinedValueError("Subtraction not defined on undefined values");
+        UNDEFINED_VALUE_ERROR("Subtraction not defined on undefined values");
       }
 
       if constexpr (RhsBitsType<constmax_v<MaxN, RhsN> + 1, RhsSigned>::RuntimeWidth) {
@@ -3467,7 +3476,7 @@ struct fmt::formatter<BitsClass<N, Signed>>
     : formatter<typename BitsClass<N, Signed>::StorageType> {
   template <typename CONTEXT_TYPE>
   auto format(BitsClass<N, Signed> value, CONTEXT_TYPE &ctx) const {
-    return fmt::formatter<typename BitsClass<N, Signed>::StorageType>::format(value.get(), ctx);
+    return fmt::formatter<typename BitsClass<N, Signed>::StorageType>::format(value.get_ignore_unknown(), ctx);
   }
 };
 

backends/cpp_hart_gen/tasks.rake

@@ -202,9 +202,14 @@ rule %r{#{CPP_HART_GEN_DST}/[^/]+/build/Makefile} => [
     "-DCONFIG_LIST=\"#{ENV['CONFIG'].gsub(',', ';')}\"",
     "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
     "-DCMAKE_BUILD_TYPE=#{cmake_build_type}"
-  ].join(" ")
+  ]
+  if ENV["IGNOREUNDEFINED"].nil?
+    cmd.push("-DIGNOREUNDEFINED=NO")
+  else
+    cmd.push("-DIGNOREUNDEFINED=YES")
+  end
 
-  sh cmd
+  sh cmd.join(" ")
 end
 
 rule %r{#{CPP_HART_GEN_DST}/[^/]+/include/udb/[^/]+\.hpp} do |t|
@@ -346,6 +351,15 @@ namespace :build do
     end
   end
 
+  task iss: ["gen:cpp_hart"] do
+    _, build_name = configs_build_name
+
+    Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/build/Makefile"].invoke
+    Dir.chdir("#{CPP_HART_GEN_DST}/#{build_name}/build") do
+      sh "make -j #{$jobs} iss"
+    end
+  end
+
   task renode_hart: ["gen:cpp_hart"] do
     _, build_name = configs_build_name
 
@@ -395,7 +409,7 @@ namespace :test do
     end
   end
 
-  task riscv_tests: ["build_riscv_tests", "build:cpp_hart"] do
+  task riscv_tests: ["build_riscv_tests", "build:iss"] do
     configs_name, build_name = configs_build_name
     rv32uiTests = ["simple", "add", "addi", "and",
       "andi", "auipc", "beq", "bge", "bgeu", "blt",
@@ -405,24 +419,62 @@ namespace :test do
       "sw", "st_ld", "sll", "slli", "slt", "slti",
       "sltiu", "sltu", "sra", "srai", "srl",
       "srli", "sub", "xor", "xori"]
+    rv64uiTests = ["add", "addi", "addiw", "addw",
+      "and", "andi",
+      "auipc",
+      "beq", "bge", "bgeu", "blt", "bltu", "bne",
+      "simple",
+      "fence_i",
+      "jal", "jalr",
+      "lb", "lbu", "lh", "lhu", "lw", "lwu", "ld", "ld_st",
+      "lui",
+      "ma_data",
+      "or", "ori",
+      "sb", "sh", "sw", "sd", "st_ld",
+      "sll", "slli", "slliw", "sllw",
+      "slt", "slti", "sltiu", "sltu",
+      "sra", "srai", "sraiw", "sraw",
+      "srl", "srli", "srliw", "srlw",
+      "sub", "subw",
+      "xor", "xori"]
+
+    rv32umTests = [ "div", "divu",
+      "mul", "mulh", "mulhsu", "mulhu",
+      "rem", "remu" ]
+    rv64umTests = ["div", "divu", "divuw", "divw",
+      "mul", "mulh", "mulhsu", "mulhu", "mulw",
+      "rem", "remu", "remuw", "remw"]
+
+    # compressed tests same for rv32 as rv64
+    ucTests = [ "rvc" ]
+
+    rv32siTests = ["csr", "dirty", "ma_fetch", "scall", "sbreak"]
+    rv64siTests = ["csr", "dirty", "icache-alias", "ma_fetch", "scall", "sbreak"]
 
-    rv32uiTests.each do |t|
-      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m rv32 -c #{$root}/cfgs/rv32-riscv-tests.yaml ext/riscv-tests/isa/rv32ui-p-#{t}"
+    if configs_name[0] == "rv64"
+      uiTests = rv64uiTests
+      umTests = rv64umTests
+      siTests = rv64siTests
+    else
+      uiTests = rv32uiTests
+      umTests = rv32umTests
+      siTests = rv32siTests
     end
 
-    rv32umTests = [ "div", "divu", "mul", "mulh", "mulhsu", "mulhu", "rem", "remu" ]
-    rv32umTests.each do |t|
-      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m rv32 -c #{$root}/cfgs/rv32-riscv-tests.yaml ext/riscv-tests/isa/rv32um-p-#{t}"
+    uiTests.each do |t|
+      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m #{configs_name[0]} -c #{$root}/cfgs/#{configs_name[0]}-riscv-tests.yaml ext/riscv-tests/isa/#{configs_name[0]}ui-p-#{t}"
     end
 
-    rv32ucTests = [ "rvc" ]
-    rv32ucTests.each do |t|
-      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m rv32 -c #{$root}/cfgs/rv32-riscv-tests.yaml ext/riscv-tests/isa/rv32uc-p-#{t}"
+    umTests.each do |t|
+      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m #{configs_name[0]} -c #{$root}/cfgs/#{configs_name[0]}-riscv-tests.yaml ext/riscv-tests/isa/#{configs_name[0]}um-p-#{t}"
     end
 
-    rv32siTests = ["csr", "dirty", "ma_fetch", "scall", "sbreak"]
-    rv32siTests.each do |t|
-      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m rv32 -c #{$root}/cfgs/rv32-riscv-tests.yaml ext/riscv-tests/isa/rv32si-p-#{t}"
+    ucTests.each do |t|
+      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m #{configs_name[0]} -c #{$root}/cfgs/#{configs_name[0]}-riscv-tests.yaml ext/riscv-tests/isa/#{configs_name[0]}uc-p-#{t}"
+    end
+
+    siTests.each do |t|
+      sh "#{CPP_HART_GEN_DST}/#{build_name}/build/iss -m #{configs_name[0]} -c #{$root}/cfgs/#{configs_name[0]}-riscv-tests.yaml ext/riscv-tests/isa/#{configs_name[0]}si-p-#{t}"
     end
   end
 end

backends/cpp_hart_gen/templates/csrs.hxx.erb

@@ -254,7 +254,7 @@ namespace udb {
       } else {
         udb_assert(xlen == 64_b, "Bad xlen");
         <%-
-          field_cpp = fields_for_xlen32.map do |field|
+          field_cpp = fields_for_xlen64.map do |field|
             if field.dynamic_location?
               "((m_#{field.name}._hw_read() & 0x#{((1 << field.location(64).size) - 1).to_s(16)}_b).template widening_sll<#{field.location(64).begin}>())"
             else

backends/cpp_hart_gen/templates/hart.hxx.erb

@@ -402,12 +402,9 @@ namespace udb {
         _set_xreg(Bits<8>{num}, Bits<MXLEN>{value});
       }
 
-      template <
-        template <unsigned, bool> class IdxType, unsigned IdxN, bool IdxSigned,
-        template<unsigned, bool> class ValueType, unsigned ValueN, bool ValueSigned
-      >
-        requires (BitsType<IdxType<IdxN, IdxSigned>> && BitsType<ValueType<ValueN, ValueSigned>>)
-      void _set_xreg(const IdxType<IdxN, IdxSigned>& num, const ValueType<ValueN, ValueSigned>& value) {
+      template < template <unsigned, bool> class IdxType, unsigned IdxN, bool IdxSigned >
+        requires (BitsType<IdxType<IdxN, IdxSigned>>)
+      void _set_xreg(const IdxType<IdxN, IdxSigned>& num, const _PossiblyUnknownBits<MXLEN, false>& value) {
         if (num != 0_b) {
           m_xregs[static_cast<unsigned>(num.get())] = value;
         }