Fix remaining IDL translation errors

Author: Derek Hower

backends/cpp_hart_gen/CMakeLists.txt

@@ -70,8 +70,8 @@ set(CONFIG_LIST _)
 
 set(GENERATED_SRCS "")
 foreach(config ${CONFIG_LIST})
-  list(APPEND GENERATED_SRCS "${CMAKE_SOURCE_DIR}/src/cfgs/${config}/csrs.cxx")
   list(APPEND GENERATED_SRCS "${CMAKE_SOURCE_DIR}/src/cfgs/${config}/decode.cxx")
+  list(APPEND GENERATED_SRCS "${CMAKE_SOURCE_DIR}/src/cfgs/${config}/csrs.cxx")
   # list(APPEND GENERATED_SRCS "${CMAKE_SOURCE_DIR}/src/cfgs/${config}/params.cxx")
   # list(APPEND GENERATED_SRCS "${CMAKE_SOURCE_DIR}/src/cfgs/${config}/hart.cxx")
 endforeach()

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

@@ -13,6 +13,9 @@
 // we need this to be true for GMP
 static_assert(sizeof(long unsigned int) == sizeof(long long unsigned int));
 
+// we make this assumption frequently
+static_assert(sizeof(1ull) == 8);
+
 namespace udb
 {
 
@@ -54,6 +57,9 @@ namespace udb
     static_assert(N > 0);
 
   public:
+    // used for template concept resolution
+    constexpr static bool IsABits = true;
+
     // value of N that represents unknown precision (happens when there is a left shift by unknown value)
     constexpr static unsigned InfinitePrecision = BitsInfinitePrecision;
 
@@ -64,6 +70,8 @@ namespace udb
     // advertise the width
     constexpr static unsigned Width = N;
 
+    constexpr static unsigned width() { return N; }
+
     using StorageType = typename BitsStorageType<N>::type;
     using SignedStorageType = typename BitsSignedStorageType<N>::type;
 
@@ -78,9 +86,7 @@ namespace udb
     {
       using _StorageType = typename BitsStorageType<_N>::type;
 
-      if constexpr (_N == InfinitePrecision)
-      {
-        // infinite bits, so there is no masking
+      if constexpr (_N == InfinitePrecision) {
         return false;
       }
       else if constexpr (_N > MaxNativePrecision)
@@ -996,6 +1002,8 @@ namespace udb
 
   static_assert((0x0_b).Width == 1);
   static_assert((0x1_b).Width == 1);
+  static_assert((0_b).Width == 1);
+  static_assert((1_b).Width == 1);
   static_assert((0x2_b).Width == 2);
   static_assert((0x7_b).Width == 3);
   static_assert((0x8_b).Width == 4);
@@ -1247,3 +1255,49 @@ namespace udb {
 
   using PossiblyUndefinedBits = Bits<66>;
 }
+
+namespace udb {
+  // Bits where the width is only known at runtime (usually because the width is parameter-dependent)
+  template <bool Signed>
+  class _RuntimeBits {
+    public:
+    template <unsigned N, bool _Signed>
+    _RuntimeBits(const _Bits<N, _Signed>& initial_value)
+      : m_value(initial_value), m_width(N)
+    {}
+
+    template <typename T>
+    _RuntimeBits(const T& initial_value, unsigned initial_width)
+      : m_value(initial_value), m_width(initial_width)
+    {}
+
+    unsigned width() const { return m_width; }
+    auto value() const { return m_value; }
+
+    template <typename T>
+    _RuntimeBits operator<<(const T& shamt) {
+      return {m_value << shamt, m_width + shamt};
+    }
+
+    template <unsigned N, bool _Signed>
+    _RuntimeBits operator|(const _Bits<N, _Signed>& other) {
+      return {m_value | other, std::max(N, m_width)};
+    }
+
+    _RuntimeBits operator|(const _RuntimeBits& other) {
+      return {m_value | other.m_value, std::max(other.m_width, m_width)};
+    }
+
+    private:
+    _Bits<BitsInfinitePrecision, Signed> m_value;
+    unsigned m_width;
+  };
+
+  template <unsigned N, bool ASigned, bool BSigned>
+  bool operator==(const _Bits<N, ASigned>& a, const _RuntimeBits<BSigned>& b)
+  {
+    return a == b.value();
+  }
+
+  using RuntimeBits = _RuntimeBits<false>;
+}

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

@@ -52,17 +52,20 @@ namespace udb {
       return (value >> start) & mask;
     }
   }
+
   // extract bits, where the extraction is not known at compile time
-  template <typename T>
-    requires (std::integral<T>)
-  T extract(T value, unsigned start, unsigned size)
+  template <typename ValueType, typename StartType, typename SizeType>
+    requires ((std::integral<ValueType> || ValueType::IsABits) &&
+              (std::integral<StartType> || StartType::IsABits) &&
+              (std::integral<SizeType> || SizeType::IsABits))
+  ValueType extract(const ValueType& value, const StartType& start, const SizeType& size)
   {
-    udb_assert((start + size) <= sizeof(T)*8, "extraction out of bound");
+    udb_assert((start + size) <= sizeof(ValueType)*8, "extraction out of bound");
 
-    if (size == sizeof(T)*8) {
+    if (size == sizeof(ValueType)*8) {
       return value;
     } else {
-      T mask = (static_cast<T>(1) << size) - 1;
+      ValueType mask = (static_cast<ValueType>(1) << size) - 1;
       return (value >> start) & mask;
     }
   }
@@ -126,7 +129,7 @@ namespace udb {
   }
 
   template <unsigned M, typename T>
-  constexpr Bits<BitsInfinitePrecision> replicate(const Bits<M>& value, const T& N)
+  constexpr RuntimeBits replicate(const Bits<M>& value, const T& N)
   {
     udb_assert(N > 0, "Must replicate at least once");
     static_assert(M < BitsMaxNativePrecision, "Please don't replicate multiprecision numbers ;(");
@@ -135,7 +138,7 @@ namespace udb {
     for (unsigned i=1; i<N; i++) {
       result |= value << (i*M);
     }
-    return result;
+    return {result, M * N};
   }
 
 
@@ -178,10 +181,27 @@ namespace udb {
   }
 
   template <typename... BitsTypes>
+    requires ((BitsTypes::Width != BitsInfinitePrecision) && ...)
   constexpr Bits<ConcatWidth<BitsTypes...>::Width> concat(BitsTypes... bits) {
     return __concat(bits...);
   }
 
+  template <typename BitsType, typename... BitsTypes>
+  RuntimeBits __runtime_concat(const BitsType& a, const BitsTypes&... bits) {
+    if constexpr (sizeof...(BitsTypes) == 0) {
+      return a;
+    } else {
+      auto shamt = (bits.width() + ...);
+      return (RuntimeBits{a} << shamt) | __runtime_concat(bits...);
+    }
+  }
+
+  template <typename... BitsTypes>
+    requires ((std::same_as<BitsTypes, RuntimeBits> || ...))
+  RuntimeBits concat(BitsTypes... bits) {
+    return __runtime_concat(bits...);
+  }
+
   static_assert(std::is_same_v<decltype(concat(Bits<4>{1}, Bits<4>(2), Bits<4>(3))), Bits<12>>);
   static_assert(concat(Bits<4>{1}, Bits<4>(2), Bits<4>(3)) == Bits<12>(0x123));
 }

backends/cpp_hart_gen/lib/constexpr_pass.rb

@@ -16,7 +16,11 @@ def constexpr?(symtab)
       return true if sym.nil? # assuming undefined syms are local (be sure to type check first!!)
       return true if sym.is_a?(Type)
 
-      !sym.type.global?
+      if sym.param?
+        symtab.cfg_arch.params_with_value.any? { |p| p.name == text_value }
+      else
+        !sym.type.global?
+      end
     end
   end
   class PcAssignmentAst

backends/cpp_hart_gen/lib/gen_cpp.rb

@@ -300,10 +300,10 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
       var = symtab.get(text_value)
 
       if !var.nil? && var.param?
-        if symtab.cfg_arch.params_without_value.any? { |p| p.name == text_value }
-          "#{' ' * indent}__UDB_RUNTIME_PARAM(#{text_value})"
-        else
+        if constexpr?(symtab)
           "#{' ' * indent}__UDB_STATIC_PARAM(#{text_value}) /* #{var.value} */"
+        else
+          "#{' ' * indent}__UDB_RUNTIME_PARAM(#{text_value})"
         end
       elsif !var.nil? && var.type.global?
         if var.type.const?
@@ -457,7 +457,11 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
 
   class BinaryExpressionAst
     def gen_cpp(symtab, indent = 0, indent_spaces: 2)
-      "#{' '*indent}(#{lhs.gen_cpp(symtab, 0, indent_spaces:)} #{op} #{rhs.gen_cpp(symtab, 0, indent_spaces:)})"
+      if op == ">>>"
+        "#{' '*indent}(#{lhs.gen_cpp(symtab, 0, indent_spaces:)}.sra(#{rhs.gen_cpp(symtab, 0, indent_spaces:)}))"
+      else
+        "#{' '*indent}(#{lhs.gen_cpp(symtab, 0, indent_spaces:)} #{op} #{rhs.gen_cpp(symtab, 0, indent_spaces:)})"
+      end
     end
   end
 

backends/cpp_hart_gen/templates/inst.hxx.erb

@@ -79,6 +79,7 @@ namespace udb {
 #define __UDB_MUTABLE_GLOBAL(x) m_parent->x
 #define __UDB_CONSTEXPR_FUNC_CALL <%= name_of(:hart, cfg_arch)%>::
 #define __UDB_CONST_GLOBAL(F) <%= name_of(:hart, cfg_arch)%>:: F
+#define __UDB_XLEN m_parent->xlen()
 
     void execute() override {
 
@@ -117,6 +118,7 @@ namespace udb {
 #undef __UDB_CONSTEXPR_FUNC_CALL
 #undef __UDB_SET_PC
 #undef __UDB_CONST_GLOBAL
+#undef __UDB_XLEN
 
 
   private:

bin/setup

@@ -202,14 +202,15 @@ else
     MAKE="singularity run ${HOME_OPT} ${CONTAINER_PATH} make"
 fi
 
-if [ ! -f $ROOT/.git/hooks/pre-commit ]; then
-  cat << HOOK > $ROOT/.git/hooks/pre-commit
+GIT_REPO_ROOT=`git rev-parse --path-format=absolute --git-common-dir | tr -d '\n'`
+if [ ! -f $GIT_REPO_ROOT/hooks/pre-commit ]; then
+  cat << HOOK > $GIT_REPO_ROOT/hooks/pre-commit
 #!/usr/bin/env bash
 # File generated by pre-commit: https://pre-commit.com
 # ID: 138fd403232d2ddd5efb44317e38bf03
 
 # start templated
-INSTALL_PYTHON=$ROOT/bin/python
+INSTALL_PYTHON=\$(realpath ./bin/python)
 ARGS=(hook-impl --config=.pre-commit-config.yaml --hook-type=pre-commit)
 # end templated
 
@@ -225,5 +226,5 @@ else
     exit 1
 fi
 HOOK
-  chmod +x $ROOT/.git/hooks/pre-commit
+  chmod +x $GIT_REPO_ROOT/hooks/pre-commit
 fi