udb 0.1.9 → 0.1.13

data/lib/udb/config.rb

@@ -63,6 +63,9 @@ module Udb
     sig { returns(String) }
     def description = @data["description"]
 
+    sig { returns(T.nilable(T.any(String, T::Array[String]))) }
+    def compatible = @data["compatible"]
+
     sig { abstract.returns(T.nilable(Integer)) }
     def mxlen; end
 
@@ -103,6 +106,8 @@ module Udb
 
     sig { params(obj: T.untyped).returns(T.untyped) }
     def self.freeze_data(obj)
+      return obj if obj.frozen?
+
       if obj.is_a?(Hash)
         obj.each do |k, v|
           obj[k] = freeze_data(v)
@@ -156,13 +161,29 @@ module Udb
             }
           end
         }
-        data.fetch("params")["MXLEN"] = portfolio_grp.max_base
         freeze_data(data)
         PartialConfig.send(:new, data, info)
       else
         T.absurd(cfg_file_path_or_portfolio_grp)
       end
     end
+
+    # Create an AbstractConfig directly from a config data hash, bypassing file I/O.
+    # Used when the config is already in memory (e.g., portfolio-derived temp configs).
+    sig { params(data: T::Hash[String, T.untyped], info: Resolver::ConfigInfo).returns(AbstractConfig) }
+    def self.create_from_data(data, info)
+      freeze_data(data)
+      case data["type"]
+      when "fully configured"
+        FullConfig.send(:new, data, info)
+      when "partially configured"
+        PartialConfig.send(:new, data, info)
+      when "unconfigured"
+        UnConfig.send(:new, data, info)
+      else
+        raise "Unexpected type (#{data['type']}) in config"
+      end
+    end
   end
 
   #################################################################
@@ -220,12 +241,25 @@ module Udb
       @param_values = @data.key?("params") ? @data["params"] : [].freeze
 
       @mxlen = @data.dig("params", "MXLEN")
+
       if @mxlen.nil?
-        Udb.logger.error "Must set MXLEN for a configured config"
-        raise InvalidConfigError
+        # Infer MXLEN from subordinate mode XLENs: if any of UXLEN/SXLEN/VSXLEN/VUXLEN
+        # can be 64, then MXLEN must be 64 (lower modes cannot exceed machine-mode width).
+        MODE_XLEN_PARAMS.each do |param|
+          val = @data.dig("params", param)
+          if val == 64 || (val.is_a?(Array) && val.include?(64))
+            @mxlen = 64
+            break
+          end
+        end
+
+        if @mxlen.nil?
+          param_req = @data.dig("requirements", "param")
+          @mxlen = 64 if !param_req.nil? && param_req_implies_64?(param_req)
+        end
       end
 
-      @mxlen.freeze
+      @mxlen.freeze unless @mxlen.nil?
     end
 
     ###############################
@@ -235,7 +269,7 @@ module Udb
     sig { override.returns(T::Hash[String, ParamValueType]) }
     def param_values = @param_values
 
-    sig { override.returns(Integer) }
+    sig { override.returns(T.nilable(Integer)) }
     def mxlen = @mxlen
 
     sig { override.returns(T::Boolean) }
@@ -301,6 +335,37 @@ module Udb
 
     sig { returns(T.nilable(T::Hash[String, T.untyped])) }
     def requirements = @data["requirements"]
+
+    private
+
+    MODE_XLEN_PARAMS = %w[UXLEN SXLEN VSXLEN VUXLEN].freeze
+
+    # Returns true if the param requirements condition guarantees that at least one
+    # subordinate-mode XLEN param must be 64, which implies MXLEN = 64.
+    #
+    # Entailment rules:
+    #   allOf: any child entailing 64 is sufficient (all must hold)
+    #   anyOf: all children must entail 64 (only one needs to hold, so we can't
+    #          conclude 64 unless every branch requires it)
+    #   noneOf/not/if/oneOf: too complex to reason about without a solver → false
+    #   leaf with a MODE_XLEN_PARAMS name and equal/includes 64 → true
+    #   anything else (extension, xlen, idl, other params) → false
+    sig { params(yaml: T.untyped).returns(T::Boolean) }
+    def param_req_implies_64?(yaml)
+      return false unless yaml.is_a?(Hash)
+
+      if yaml.key?("allOf")
+        yaml["allOf"].any? { |child| param_req_implies_64?(child) }
+      elsif yaml.key?("anyOf")
+        yaml["anyOf"].all? { |child| param_req_implies_64?(child) }
+      elsif yaml.key?("param")
+        param_req_implies_64?(yaml["param"])
+      elsif yaml.key?("name") && MODE_XLEN_PARAMS.include?(yaml["name"])
+        yaml["equal"] == 64 || yaml["includes"] == 64
+      else
+        false
+      end
+    end
   end
 
   ################################################################################################################
@@ -320,7 +385,7 @@ module Udb
 
       @mxlen = @data.dig("params", "MXLEN").freeze
       if @mxlen.nil?
-        Udb.logger.error "Must set MXLEN for a configured config"
+        Udb.logger.error "Must set MXLEN for a full config"
         raise InvalidConfigError
       end
     end
@@ -359,5 +424,6 @@ module Udb
           end
         end
     end
+
   end
 end

data/lib/udb/logic.rb

@@ -293,7 +293,10 @@ module Udb
       .checked(:never)
     }
     def eql?(other)
-      (self <=> other) == 0
+      return false unless other.is_a?(ExtensionTerm)
+      return false unless hash == other.hash
+
+      to_s == other.to_s
     end
 
   end
@@ -321,8 +324,12 @@ module Udb
     sig { params(yaml: T::Hash[String, T.untyped]).void }
     def initialize(yaml)
       @yaml = yaml
+      @yaml_no_reason = yaml.key?("reason") ? yaml.reject { |k, _| k == "reason" }.freeze : yaml
     end
 
+    sig { returns(T::Hash[String, T.untyped]) }
+    def yaml_no_reason = @yaml_no_reason
+
     sig { returns(String) }
     def name = @yaml.fetch("name")
 
@@ -1083,7 +1090,7 @@ module Udb
       .returns(Integer)
       .checked(:never)
     }
-    def hash = @hash ||= @yaml.reject { |k, _| k == "reason" }.hash
+    def hash = @hash ||= @yaml_no_reason.hash
 
     sig {
       override
@@ -1093,8 +1100,9 @@ module Udb
     }
     def eql?(other)
       return false unless other.is_a?(ParameterTerm)
+      return false unless hash == other.hash
 
-      (self <=> other) == 0
+      @yaml_no_reason == other.yaml_no_reason
     end
   end
 
@@ -1226,37 +1234,8 @@ module Udb
     # object to hold results of expensive calculations
     # LogicNode type and children are frozen at construction so
     # we can safely remember and return these values
-    class MemoizedState < T::Struct
-      # when true, the formula is known to be in CNF form
-      # when false, the formula is known to not be in CNF form
-      prop :is_cnf, T.nilable(T::Boolean)
-
-      # when not nil, an equisatisfiable representation of self in CNF form
-      prop :cnf_form, T.nilable(LogicNode)
-
-      # when true, a flattened version of the formula would be CNF
-      # when false, a flattened version of the formula would not be CNF
-      prop :is_nested_cnf, T.nilable(T::Boolean)
-
-      # when true, the formula would be unaltered by calling reduce
-      # when false, the formula would be reduced further by calling reduce
-      prop :is_reduced, T.nilable(T::Boolean)
-
-      # list of terms in the formula
-      prop :terms, T.nilable(T::Array[TermType])
-
-      # list of literals in the formula
-      prop :literals, T.nilable(T::Array[TermType])
-
-      # when true, formula is known to be satisfiable
-      # when false, formula is known to be unsatisfiable
-      prop :is_satisfiable, T.nilable(T::Boolean)
-
-      # result of #equisat_cnf
-      prop :equisat_cnf, T.nilable(LogicNode)
-
-      # result of #equisat_cnf
-      prop :equiv_cnf, T.nilable(LogicNode)
+    class MemoizedState
+      attr_accessor :is_cnf, :cnf_form, :is_nested_cnf, :is_reduced, :terms, :literals, :is_satisfiable, :equisat_cnf, :equiv_cnf, :terms_no_antecendents
     end
 
     attr_accessor :memo
@@ -1288,16 +1267,7 @@ module Udb
       @type.freeze
 
       # used for memoization in transformation routines
-      @memo = MemoizedState.new(
-        is_cnf: nil,
-        is_nested_cnf: nil,
-        is_reduced: nil,
-        terms: nil,
-        literals: nil,
-        is_satisfiable: nil,
-        equisat_cnf: nil,
-        equiv_cnf: nil
-      )
+      @memo = MemoizedState.new
     end
 
     # @api private
@@ -1360,21 +1330,24 @@ module Udb
     # @return The unique terms (leafs) of this tree, exculding antecendents of an IF
     sig { returns(T::Array[TermType]).checked(:never) }
     def terms_no_antecendents
-      if @type == LogicNodeType::If
-        node_children.fetch(1).terms_no_antecendents
-      elsif @type == LogicNodeType::Term
-        [T.cast(@children.fetch(0), TermType)]
-      else
-        seen = {}
-        node_children.each_with_object([]) do |child, result|
-          child.terms_no_antecendents.each do |t|
-            unless seen.key?(t)
-              seen[t] = true
-              result << t
+      return @memo.terms_no_antecendents unless @memo.terms_no_antecendents.nil?
+
+      @memo.terms_no_antecendents =
+        if @type == LogicNodeType::If
+          node_children.fetch(1).terms_no_antecendents
+        elsif @type == LogicNodeType::Term
+          [T.cast(@children.fetch(0), TermType)]
+        else
+          seen = {}
+          node_children.each_with_object([]) do |child, result|
+            child.terms_no_antecendents.each do |t|
+              unless seen.key?(t)
+                seen[t] = true
+                result << t
+              end
             end
           end
         end
-      end
     end
 
     # @return all unique literals (leafs) in the tree

data/lib/udb/obj/csr.rb

@@ -9,7 +9,6 @@ require "idlc/interfaces"
 require "idlc/passes/reachable_functions"
 
 require_relative "database_obj"
-require_relative "certifiable_obj"
 require_relative "has_fields"
 
 module Udb
@@ -22,7 +21,6 @@ module Udb
     BITS128_TYPE = Idl::Type.new(:bits, width: 128).freeze
     ENCODING_SIZE_VAR = Idl::Var.new("__instruction_encoding_size", BITS6_TYPE, 32).freeze
     # Add all methods in this module to this type of database object.
-    include CertifiableObject
     include HasFields
 
     include Idl::Csr
@@ -520,8 +518,8 @@ module Udb
     def sw_read_ast(symtab)
       raise ArgumentError, "Argument should be a symtab" unless symtab.is_a?(Idl::SymbolTable)
 
-      return @sw_read_ast unless @sw_read_ast.nil?
-      return nil if @data["sw_read()"].nil?
+      return @sw_read_ast if instance_variable_defined?(:@sw_read_ast)
+      return (@sw_read_ast = nil) if @data["sw_read()"].nil?
 
       # now, parse the function
       @sw_read_ast = @cfg_arch.idl_compiler.compile_func_body(
@@ -568,6 +566,7 @@ module Udb
     end
 
     # @param effective_xlen [Integer or nil] 32 or 64 for fixed xlen, nil for dynamic
+    # @return [FunctionBodyAst] Pruned (but not re-type-checked) AST for sw_read()
     def pruned_sw_read_ast(effective_xlen)
       raise ArgumentError, "effective_xlen is non-nil and is a #{effective_xlen.class} but must be an Integer" unless effective_xlen.nil? || effective_xlen.is_a?(Integer)
       @pruned_sw_read_ast ||= {}
@@ -580,6 +579,25 @@ module Udb
       ast = ast.prune(symtab)
       ast.freeze_tree(@cfg_arch.symtab)
 
+      symtab.pop
+      symtab.release
+
+      @pruned_sw_read_ast[effective_xlen] = ast
+    end
+
+    # @param effective_xlen [Integer or nil] 32 or 64 for fixed xlen, nil for dynamic
+    # @return [FunctionBodyAst] Pruned and re-type-checked AST for sw_read()
+    #   Use this when you need the AST to be fully type-checked (e.g., for the type_check pass).
+    #   For reachable_functions, use pruned_sw_read_ast directly.
+    def type_checked_pruned_sw_read_ast(effective_xlen)
+      raise ArgumentError, "effective_xlen is non-nil and is a #{effective_xlen.class} but must be an Integer" unless effective_xlen.nil? || effective_xlen.is_a?(Integer)
+      @type_checked_pruned_sw_read_ast ||= {}
+      return @type_checked_pruned_sw_read_ast[effective_xlen] if @type_checked_pruned_sw_read_ast.key?(effective_xlen)
+
+      ast = pruned_sw_read_ast(effective_xlen)
+
+      symtab = fill_symtab(type_checked_sw_read_ast(effective_xlen), effective_xlen)
+
       @cfg_arch.idl_compiler.type_check(
         ast,
         symtab,
@@ -589,7 +607,7 @@ module Udb
       symtab.pop
       symtab.release
 
-      @pruned_sw_read_ast[effective_xlen] = ast
+      @type_checked_pruned_sw_read_ast[effective_xlen] = ast
     end
 
     # @param cfg_arch [ConfiguredArchitecture] Architecture def

data/lib/udb/obj/csr_field.rb

@@ -8,7 +8,6 @@ require "sorbet-runtime"
 require "idlc/passes/gen_option_adoc"
 
 require_relative "database_obj"
-require_relative "certifiable_obj"
 
 module Udb
 
@@ -16,9 +15,6 @@ module Udb
   class CsrField < DatabaseObject
     extend T::Sig
 
-    # Add all methods in this module to this type of database object.
-    include CertifiableObject
-
     include Idl::CsrField
 
     # @return [Csr, Mmr] The Csr or Mmr that defines this field
@@ -60,6 +56,19 @@ module Udb
       @memo = MemoizedState.new(reachable_functions: {})
     end
 
+    # When a field has no definedBy of its own, it inherits the parent CSR's condition.
+    # Returning the parent's condition object directly lets us reuse its memoized
+    # satisfied_by_cfg_arch? result instead of re-evaluating an equivalent condition.
+    sig { override.returns(AbstractCondition) }
+    def defined_by_condition
+      @defined_by_condition ||=
+        if @data.key?("definedBy")
+          Condition.new(@data["definedBy"], @cfg_arch)
+        else
+          @parent.defined_by_condition
+        end
+    end
+
     # CSR fields are defined in their parent CSR YAML file
     def __source = @parent.__source
 
@@ -75,6 +84,11 @@ module Udb
     # @return [Boolean] True if this field might exist in a config
     sig { params(cfg_arch: ConfiguredArchitecture).returns(T::Boolean) }
     def exists_in_cfg?(cfg_arch)
+      # When the field has no definedBy of its own, its existence is identical to the parent's.
+      # base is also nil in this case (no xlen restriction from the condition), so we can
+      # skip the condition evaluation entirely and just delegate to the parent.
+      return parent.exists_in_cfg?(cfg_arch) unless @data.key?("definedBy")
+
       if cfg_arch.fully_configured?
         parent.exists_in_cfg?(cfg_arch) &&
           (base.nil? || cfg_arch.possible_xlens.include?(base)) &&
@@ -116,8 +130,8 @@ module Udb
     # @return [nil] if the type property is not a function
     sig { returns(T.nilable(Idl::FunctionBodyAst)) }
     def type_ast
-      return @type_ast unless @type_ast.nil?
-      return nil if @data["type()"].nil?
+      return @type_ast if instance_variable_defined?(:@type_ast)
+      return (@type_ast = nil) if @data["type()"].nil?
 
       idl_code = T.must(@data["type()"])
 
@@ -370,8 +384,8 @@ module Udb
     # @return [nil] If the reset_value is not a function
     sig { returns(T.nilable(Idl::FunctionBodyAst)) }
     def reset_value_ast
-      return @reset_value_ast unless @reset_value_ast.nil?
-      return nil unless @data.key?("reset_value()")
+      return @reset_value_ast if instance_variable_defined?(:@reset_value_ast)
+      return (@reset_value_ast = nil) unless @data.key?("reset_value()")
 
       @reset_value_ast = cfg_arch.idl_compiler.compile_func_body(
         @data["reset_value()"],
@@ -388,9 +402,9 @@ module Udb
     # @return [nil] If the reset_value is not a function
     sig { returns(T.nilable(Idl::FunctionBodyAst)) }
     def type_checked_reset_value_ast
-      return @type_checked_reset_value_ast unless @type_checked_reset_value_ast.nil?
+      return @type_checked_reset_value_ast if instance_variable_defined?(:@type_checked_reset_value_ast)
 
-      return nil unless @data.key?("reset_value()")
+      return (@type_checked_reset_value_ast = nil) unless @data.key?("reset_value()")
 
       ast = reset_value_ast
 
@@ -409,9 +423,9 @@ module Udb
     # @return [nil] If the reset_value is not a function
     sig { returns(T.nilable(Idl::FunctionBodyAst)) }
     def pruned_reset_value_ast
-      return @pruned_reset_value_ast unless @pruned_reset_value_ast.nil?
+      return @pruned_reset_value_ast if instance_variable_defined?(:@pruned_reset_value_ast)
 
-      return nil unless @data.key?("reset_value()")
+      return (@pruned_reset_value_ast = nil) unless @data.key?("reset_value()")
 
       ast = T.must(type_checked_reset_value_ast)
 
@@ -517,8 +531,8 @@ module Udb
     # @param symtab [Idl::SymbolTable] Symbols
     sig { params(symtab: Idl::SymbolTable).returns(T.nilable(Idl::FunctionBodyAst)) }
     def sw_write_ast(symtab)
-      return @sw_write_ast unless @sw_write_ast.nil?
-      return nil if @data["sw_write(csr_value)"].nil?
+      return @sw_write_ast if instance_variable_defined?(:@sw_write_ast)
+      return (@sw_write_ast = nil) if @data["sw_write(csr_value)"].nil?
 
       # now, parse the function
       @sw_write_ast = @cfg_arch.idl_compiler.compile_func_body(
@@ -610,13 +624,14 @@ module Udb
     # @param effective_xlen [Integer] effective xlen, needed because fields can change in different bases
     sig { params(effective_xlen: T.nilable(Integer)).returns(T.nilable(Idl::AstNode)) }
     def pruned_sw_write_ast(effective_xlen)
-      return @pruned_sw_write_ast unless @pruned_sw_write_ast.nil?
+      @pruned_sw_write_ast ||= {}
+      return @pruned_sw_write_ast[effective_xlen] if @pruned_sw_write_ast.key?(effective_xlen)
 
-      return nil unless @data.key?("sw_write(csr_value)")
+      return (@pruned_sw_write_ast[effective_xlen] = nil) unless @data.key?("sw_write(csr_value)")
 
       ast = T.must(type_checked_sw_write_ast(cfg_arch.symtab, effective_xlen))
 
-      return ast if cfg_arch.unconfigured?
+      return (@pruned_sw_write_ast[effective_xlen] = ast) if cfg_arch.unconfigured?
 
       symtab = fill_symtab_for_sw_write(effective_xlen, ast)
 
@@ -634,7 +649,7 @@ module Udb
       symtab.pop
       symtab.release
 
-      @pruned_sw_write_ast = ast
+      @pruned_sw_write_ast[effective_xlen] = ast
     end
 
     # @param cfg_arch [ConfiguredArchitecture] A config. May be nil if the location is not configturation-dependent
@@ -751,7 +766,7 @@ module Udb
     sig { returns(String) }
     def location_cond32
       case csr.priv_mode
-      when "M"
+      when "M", "D"
         "CSR[misa].MXL == 0"
       when "S"
         "CSR[mstatus].SXL == 0"
@@ -767,7 +782,7 @@ module Udb
     sig { returns(String) }
     def location_cond64
       case csr.priv_mode
-      when "M"
+      when "M", "D"
         "CSR[misa].MXL == 1"
       when "S"
         "CSR[mstatus].SXL == 1"
@@ -793,7 +808,7 @@ module Udb
       if dynamic_location?
         condition =
           case csr.priv_mode
-          when "M"
+          when "M", "D"
             "CSR[misa].MXL == %%"
           when "S"
             "CSR[mstatus].SXL == %%"

data/lib/udb/obj/database_obj.rb

@@ -33,8 +33,6 @@ module Udb
         InterruptCode = new("interrupt_code")
         Manual = new("manual")
         ManualVersion = new("manual version")
-        ProcessorCertificateClass = new("processor certificate class")
-        ProcessorCertificateModel = new("processor certificate model")
         Profile = new("profile")
         ProfileFamily = new("profile family")
         ProfileRelease = new("profile release")
@@ -136,10 +134,9 @@ module Udb
     # defer the calculation of 'blk' until later, then memoize the result
     sig { params(fn_name: Symbol, _block: T.proc.void).returns(T.untyped) }
     def defer(fn_name, &_block)
-      cache_value = @cache[fn_name]
-      return cache_value unless cache_value.nil?
+      return @cache[fn_name] if @cache.key?(fn_name)
 
-      @cache[fn_name] ||= yield
+      @cache[fn_name] = yield
     end
 
     # @return Condition for when the object exists

data/lib/udb/obj/extension.rb

@@ -5,7 +5,6 @@
 # frozen_string_literal: true
 
 require_relative "database_obj"
-require_relative "certifiable_obj"
 require_relative "parameter"
 require_relative "../schema"
 require_relative "../condition"
@@ -16,8 +15,6 @@ module Udb
 
 # Extension definition
   class Extension < TopLevelDatabaseObject
-    # Add all methods in this module to this type of database object.
-    include CertifiableObject
     include Comparable
 
     # @return Long name of the extension

data/lib/udb/obj/instruction.rb

@@ -7,7 +7,6 @@
 # require 'ruby-prof-flamegraph'
 
 require_relative "database_obj"
-require_relative "certifiable_obj"
 require_relative "../presence"
 require "udb_helpers/backend_helpers"
 require "awesome_print"
@@ -110,8 +109,6 @@ module Udb
 
 # model of a specific instruction in a specific base (RV32/RV64)
   class Instruction < TopLevelDatabaseObject
-    # Add all methods in this module to this type of database object.
-    include CertifiableObject
     include Helpers::WavedromUtil
 
     class MemoizedState < T::Struct
@@ -1104,7 +1101,7 @@ module Udb
     # @return [FunctionBodyAst] A type-checked abstract syntax tree of the operation
     # @param effective_xlen [Integer] 32 or 64, the effective xlen to type check against
     def type_checked_operation_ast(effective_xlen)
-      defer :type_checked_operation_ast do
+      defer :"type_checked_operation_ast_#{effective_xlen}" do
         return nil unless @data.key?("operation()")
 
         ast = operation_ast