WIP

Author: Derek Hower

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

@@ -980,6 +980,20 @@ namespace udb
     }
   }
 
+  // signed bits
+  template <char... Str>
+  constexpr _Bits<BitsStr<Str..., '\0'>::width + 1, false> operator""_sb()
+  {
+    if constexpr ((BitsStr<Str..., '\0'>::width + 1) <= _Bits<(BitsStr<Str..., '\0'>::width + 1), false>::MaxNativePrecision)
+    {
+      return BitsStr<Str..., '\0'>::val;
+    }
+    else
+    {
+      return mpz_class{BitsStr<Str..., '\0'>::str};
+    }
+  }
+
   static_assert((0x0_b).Width == 1);
   static_assert((0x1_b).Width == 1);
   static_assert((0x2_b).Width == 2);

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

@@ -178,6 +178,15 @@ namespace udb {
     virtual bool implemented_Q_(const ExtensionName& ext) = 0;
     virtual bool implemented_Q_(const ExtensionName& ext, const VersionRequirement& req) = 0;
 
+    template <unsigned  M>
+    Bits<64> read_hpm_counter(const Bits<M>& hpm_num) { return 0; }
+
+    Bits<64> read_mcycle() { return 0; }
+
+    Bits<64> sw_write_mcycle(const Bits<64>& cycle) { return 0; }
+
+    unsigned hartid() const { return m_hart_id; }
+
     protected:
     const unsigned m_hart_id;
     Memory& m_mem;

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

@@ -109,7 +109,10 @@ namespace udb {
     static constexpr Bits<Size> MaximumValue = (Bits<1>(1).template sll<Size>()) - 1;
     static constexpr Bits<ParentSize> Mask = MaximumValue.template sll<Start>();
 
-    operator Bits<Size>() const;
+    template <unsigned N>
+      requires (N >= Size)
+    operator Bits<N>() const;
+
     operator PossiblyUndefinedBits() const;
 
     bool operator!() const {
@@ -131,6 +134,12 @@ namespace udb {
     template <unsigned N, bool Signed>
     bool operator>=(const _Bits<N, Signed>& other) { return static_cast<Bits<Size>>(*this) >= other; }
 
+    template <unsigned N, bool Signed>
+    bool operator<=(const _Bits<N, Signed>& other) { return static_cast<Bits<Size>>(*this) <= other; }
+
+    template <unsigned OtherParentSize, unsigned OtherStart, unsigned OtherSize>
+    bool operator<(const BitfieldMember<OtherParentSize, OtherStart, OtherSize>& other) { return static_cast<Bits<Size>>(*this) > static_cast<Bits<OtherSize>>(*this); }
+
     template <unsigned N, bool Signed>
     Bits<Size> operator&(const _Bits<N, Signed>& other) { return static_cast<Bits<Size>>(*this) & other; }
 
@@ -168,7 +177,9 @@ namespace udb {
   static_assert(std::is_copy_constructible_v<BitfieldMember<64, 0, 1>>);
 
   template <unsigned ParentSize, unsigned Start, unsigned Size>
-  BitfieldMember<ParentSize, Start, Size>::operator Bits<Size>() const
+  template <unsigned N>
+    requires (N >= Size)
+  BitfieldMember<ParentSize, Start, Size>::template operator Bits<N>() const
   {
     return (static_cast<Bits<ParentSize>>(m_parent) >> Start) & MaximumValue;
   }
@@ -186,12 +197,4 @@ namespace udb {
     m_parent = (static_cast<Bits<ParentSize>>(m_parent) & ~Mask) | ((value.template sll<Size>()) & Mask);
     return *this;
   }
-
-  // struct to define types based on XLEN
-  template <unsigned XLEN>
-  struct BaseIsa {
-    static_assert(XLEN == 32 || XLEN == 64);
-
-    using XReg = Bits<XLEN>; //std::conditional_t<(XLEN == 64), uint64_t, uint32_t>;
-  };
 }

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

@@ -27,7 +27,7 @@ namespace udb {
 
   // extract bits from a Bits type
   template <unsigned start, unsigned size, unsigned bits_len>
-  constexpr Bits<size> extract(Bits<bits_len> value)
+  constexpr Bits<size> extract(const Bits<bits_len>& value)
   {
     static_assert((start + size) <= bits_len, "Cannot extract more bits than type contains");
 
@@ -39,6 +39,19 @@ namespace udb {
     }
   }
 
+  // extract from a bitfield member
+  template <unsigned start, unsigned size, unsigned BitfieldParentSize, unsigned BitfieldMemberStart, unsigned BitfieldMemberSize>
+  constexpr Bits<size> extract(const BitfieldMember<BitfieldParentSize, BitfieldMemberStart, BitfieldMemberSize>& value)
+  {
+    static_assert((start + size) <= (BitfieldMemberSize), "Cannot extract more bits than type contains");
+
+    if constexpr (size == BitfieldMemberSize) {
+      return value;
+    } else {
+      constexpr Bits<BitfieldMemberSize> mask = (static_cast<Bits<BitfieldMemberSize>>(1).template const_sll<size>()) - 1;
+      return (value >> start) & mask;
+    }
+  }
   // extract bits, where the extraction is not known at compile time
   template <typename T>
   T extract(T value, unsigned start, unsigned size)

backends/cpp_hart_gen/lib/csr_template_helpers.rb

@@ -24,7 +24,7 @@ def type_to_cpp(xlen)
     symtab = fill_symtab_for_type(xlen, pruned_ast)
     value_result = pruned_ast.value_try do
       type_value = pruned_ast.return_value(symtab)
-      cpp = "return CsfFieldType::#{TYPE_VALUE_TO_CPP_NAME[type_value]};"
+      cpp = "return CsrFieldType::#{TYPE_VALUE_TO_CPP_NAME[type_value]};"
     end
     pruned_ast.value_else(value_result) do
       cpp = pruned_ast.gen_cpp(symtab)

backends/cpp_hart_gen/lib/gen_cpp.rb

@@ -83,7 +83,12 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
 
   class UserTypeNameAst
     def gen_cpp(symtab, indent = 0, indent_spaces: 2)
-      "#{' ' * indent}#{text_value}"
+      type = symtab.get(text_value)
+      if type.kind == :struct
+        "#{' ' * indent}__UDB_STRUCT(#{text_value})"
+      else
+        "#{' ' * indent}#{text_value}"
+      end
     end
   end
 
@@ -290,6 +295,12 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
         else
           "#{' ' * indent}__UDB_STATIC_PARAM(#{text_value}) /* #{var.value} */"
         end
+      elsif !var.nil? && var.type.global?
+        if var.type.const?
+          "#{' ' * indent}__UDB_CONST_GLOBAL(#{text_value})"
+        else
+          "#{' ' * indent}__UDB_MUTABLE_GLOBAL(#{text_value})"
+        end
       else
         "#{' ' * indent}#{text_value}"
       end
@@ -343,11 +354,19 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
           result = "#{' '*indent}Bits<#{bits_expression.gen_cpp(symtab, 0, indent_spaces:)}>"
         end
         value_else(value_result) do
-          result = "#{' '*indent}Bits<BitsInfinitePrecision>"
+          # see if this is a param with a bound
+          if bits_expression.is_a?(IdAst)
+            sym = symtab.get(bits_expression.text_value)
+            if !sym.nil? && sym.param?
+              param = symtab.cfg_arch.param(bits_expression.text_value)
+              result = "#{' '*indent}Bits<#{param.schema.max_val}>" if param.schema.max_val_known?
+            end
+          end
+          result = "#{' '*indent}Bits<BitsInfinitePrecision>" if result == ""
         end
         result
       elsif @type_name == "XReg"
-        "#{' '*indent}Bits<#{symtab.cfg_arch.possible_xlens.max()}>"
+        "#{' '*indent}Bits<#{symtab.cfg_arch.possible_xlens.max}>"
       elsif @type_name == "Boolean"
         "#{' '*indent}bool"
       elsif @type_name == "U32"
@@ -507,20 +526,26 @@ def gen_cpp(symtab, indent = 0, indent_spaces: 2)
 
   class FunctionCallExpressionAst
     def gen_cpp(symtab, indent = 0, indent_spaces: 2)
-      targs_cpp = template_arg_nodes.map { |t| t.gen_cpp(symtab, 0, indent_spaces:) }
-      args_cpp = arg_nodes.map { |a| a.gen_cpp(symtab, 0, indent_spaces:) }
-      ftype = func_type(symtab)
-      if ftype.func_def_ast.constexpr?(symtab)
-        if targs_cpp.empty?
-          "__UDB_CONSTEXPR_FUNC_CALL #{name.gsub("?", "_Q_")}(#{args_cpp.join(', ')})"
-        else
-          "__UDB_CONSTEXPR_FUNC_CALL #{name.gsub("?", "_Q_")}<#{targs_cpp.join(', ')}>(#{args_cpp.join(', ')})"
-        end
+      if name == "ary_includes?"
+        # special case
+        args_cpp = arg_nodes.map { |a| a.gen_cpp(symtab, 0, indent_spaces:) }
+        "(std::find(#{args_cpp[0]}.begin(), #{args_cpp[0]}.end(), #{args_cpp[1]}) != #{args_cpp[0]}.end())"
       else
-        if targs_cpp.empty?
-          "__UDB_FUNC_CALL #{name.gsub("?", "_Q_")}(#{args_cpp.join(', ')})"
+        targs_cpp = template_arg_nodes.map { |t| t.gen_cpp(symtab, 0, indent_spaces:) }
+        args_cpp = arg_nodes.map { |a| a.gen_cpp(symtab, 0, indent_spaces:) }
+        ftype = func_type(symtab)
+        if ftype.func_def_ast.constexpr?(symtab)
+          if targs_cpp.empty?
+            "__UDB_CONSTEXPR_FUNC_CALL #{name.gsub("?", "_Q_")}(#{args_cpp.join(', ')})"
+          else
+            "__UDB_CONSTEXPR_FUNC_CALL #{name.gsub("?", "_Q_")}<#{targs_cpp.join(', ')}>(#{args_cpp.join(', ')})"
+          end
         else
-          "__UDB_FUNC_CALL #{name.gsub("?", "_Q_")}<#{targs_cpp.join(', ')}>(#{args_cpp.join(', ')})"
+          if targs_cpp.empty?
+            "__UDB_FUNC_CALL #{name.gsub("?", "_Q_")}(#{args_cpp.join(', ')})"
+          else
+            "__UDB_FUNC_CALL #{name.gsub("?", "_Q_")}<#{targs_cpp.join(', ')}>(#{args_cpp.join(', ')})"
+          end
         end
       end
     end

backends/cpp_hart_gen/lib/template_helpers.rb

@@ -97,6 +97,10 @@ def name_of(kind, cfg_arch_or_config_name, *extras)
         raise "Missing Instruction name" unless extras.size == 1
 
         "#{config_name.camelize}_#{extras[0].gsub(".", "_").capitalize}_Inst"
+      when :struct
+        raise "Missing struct name" unless extras.size == 1
+
+        "#{config_name.camelize}_#{extras[0]}_Struct"
       else
         raise "TODO: #{kind}"
       end

backends/cpp_hart_gen/tasks.rake

@@ -235,6 +235,7 @@ namespace :gen do
       Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/include/udb/cfgs/#{config}/csrs.hxx"].invoke
       Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/src/cfgs/#{config}/csrs.cxx"].invoke
       Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/include/udb/cfgs/#{config}/csr_container.hxx"].invoke
+      Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/include/udb/cfgs/#{config}/structs.hxx"].invoke
       Rake::Task["#{CPP_HART_GEN_DST}/#{build_name}/include/udb/cfgs/#{config}/func_prototypes.hxx"].invoke
 
       Dir.glob("#{CPP_HART_GEN_SRC}/cpp/include/udb/*.hpp") do |f|

backends/cpp_hart_gen/templates/csrs.cxx.erb

@@ -1,5 +1,9 @@
+
+#include <algorithm>
+
 #include "udb/util.hpp"
 #include "udb/cfgs/<%= cfg_arch.name %>/hart.hxx"
+#include "udb/inst.hpp"
 
 using namespace udb;
 
@@ -12,6 +16,11 @@ using namespace udb;
 #define __UDB_STATIC_PARAM(param_name) <%= name_of(:params, cfg_arch) %>::param_name
 #define __UDB_FUNC_CALL m_hart->
 #define __UDB_CONSTEXPR_FUNC_CALL <%= name_of(:hart, cfg_arch) %>::
+#define __UDB_CSR_BY_NAME(csr_name) m_hart->m_csrs.csr_name
+#define __UDB_CONST_GLOBAL(global_name) <%= name_of(:hart, cfg_arch) %>::global_name
+#define __UDB_MUTABLE_GLOBAL(global_name) m_hart->global_name
+#define __UDB_STRUCT(struct_name) <%= cfg_arch.name.camelize %>_ ## struct_name ## _Struct
+
 
 <%- fields.each do |field| -%>
 <%- max_width = cfg_arch.possible_xlens.map { |xlen| field.defined_in_base?(xlen) ? field.location(xlen).size : 0 }.max -%>
@@ -65,6 +74,10 @@ void <%= name_of(:csr_field, cfg_arch, csr.name, field.name) %>::reset() {
 #undef __UDB_STATIC_PARAM
 #undef __UDB_CONSTEXPR_FUNC_CALL
 #undef __UDB_FUNC_CALL
+#undef __UDB_CSR_BY_NAME
+#undef __UDB_CONST_GLOBAL
+#undef __UDB_MUTABLE_GLOBAL
+#undef __UDB_STRUCT
 
 #define __UDB_RUNTIME_PARAM(param_name) m_parent->m_params.param_name
 #define __UDB_STATIC_PARAM(param_name) <%= name_of(:params, cfg_arch) %>::param_name
@@ -74,6 +87,10 @@ void <%= name_of(:csr_field, cfg_arch, csr.name, field.name) %>::reset() {
 #define __UDB_FUNC_CALL m_parent->
 #define __UDB_CONSTEXPR_FUNC_CALL <%= name_of(:hart, cfg_arch) %>::
 #define __UDB_XLEN m_parent->xlen()
+#define __UDB_ENCODING m_parent->m_cur_inst->encoding()
+#define __UDB_CONST_GLOBAL(global_name) <%= name_of(:hart, cfg_arch) %>::global_name
+#define __UDB_MUTABLE_GLOBAL(global_name) m_parent->global_name
+#define __UDB_STRUCT(struct_name) <%= cfg_arch.name.camelize %>_ ## struct_name ## _Struct
 
 // constructor
 <%- fields_for_xlen = fields.select { |f| cfg_arch.possible_xlens.any? { |xlen| f.defined_in_base?(xlen) } } -%>
@@ -191,6 +208,9 @@ bool <%= name_of(:csr, cfg_arch, csr.name) %>::_sw_write(const Bits<<%= csr.max_
 #undef __UDB_FUNC_CALL
 #undef __UDB_CONSTEXPR_FUNC_CALL
 #undef __UDB_XLEN
+#undef __UDB_CONST_GLOBAL
+#undef __UDB_MUTABLE_GLOBAL
+#undef __UDB_STRUCT
 
 <%- end -%>
 

backends/cpp_hart_gen/templates/func_prototypes.hxx.erb

@@ -2,6 +2,9 @@
 // IT IS NOT STANDALONE. IT IS A FUNCTION LIST FOR THE Hart CLASS
 
 #define __UDB_CONSTEXPR_FUNC_CALL
+#define __UDB_CONST_GLOBAL(global_name) <%= name_of(:hart, cfg_arch) %>::global_name
+#define __UDB_MUTABLE_GLOBAL(global_name) global_name
+#define __UDB_STRUCT(struct_name) <%= cfg_arch.name.camelize %>_ ## struct_name ## _Struct
 
 <%# need to get symtab at function scope -%>
 <%- symtab = cfg_arch.symtab.global_clone.push(nil) -%>
@@ -14,5 +17,8 @@
 <%- end -%>
 
 #undef __UDB_CONSTEXPR_FUNC_CALL
+#undef __UDB_CONST_GLOBAL
+#undef __UDB_MUTABLE_GLOBAL
+#undef __UDB_STRUCT
 
 <%- symtab.release -%>