udb 0.1.9 → 0.1.13

data/lib/udb/obj/portfolio.rb

@@ -23,6 +23,7 @@ module Udb
   class PortfolioExtensionRequirement
     extend T::Sig
     extend Forwardable
+    include Comparable
 
     def_delegators :@ext_req,
       :name,
@@ -41,12 +42,22 @@ module Udb
         presence: T.nilable(Presence)
       ).void
     }
-    def initialize(name, requirements, arch:, note:, req_id:, presence:)
+    def initialize(name, requirements, arch:, note: nil, req_id: nil, presence: nil)
       @ext_req = arch.extension_requirement(name, requirements)
       @note = note
       @req_id = req_id
       @presence = presence
     end
+
+    sig { params(other: T.any(PortfolioExtensionRequirement, ExtensionRequirement)).returns(T.nilable(Integer)) }
+    def <=>(other)
+      case other
+      when PortfolioExtensionRequirement
+        @ext_req <=> other.ext_req
+      when ExtensionRequirement
+        @ext_req <=> other
+      end
+    end
   end
 
 ##################
@@ -440,22 +451,22 @@ module Udb
         end
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
-    def to_config
-      {
+    sig { params(mandatory: T::Array[PortfolioExtensionRequirement]).returns(T::Hash[String, T.untyped]) }
+    def to_config(mandatory: mandatory_ext_reqs)
+      c = {
         "$schema" => "config_schema.json#",
         "kind" => "architecture configuration",
         "type" => "partially configured",
         "name" => name,
         "description" => description,
-        "params" => all_in_scope_params.map do |p|
+        "params" => all_in_scope_params.sort.map do |p|
           if p.single_value?
             [p.name, p.value]
           else
             nil
           end
         end.compact.to_h,
-        "mandatory_extensions" => mandatory_ext_reqs.map do |ext_req|
+        "mandatory_extensions" => mandatory.sort.map do |ext_req|
           {
             "name" => ext_req.name,
             "version" => \
@@ -466,7 +477,7 @@ module Udb
               end
           }
         end,
-        "non_mandatory_extensions" => optional_ext_reqs.map do |ext_req|
+        "non_mandatory_extensions" => optional_ext_reqs.sort.map do |ext_req|
           {
             "name" => ext_req.name,
             "version" => \
@@ -479,19 +490,41 @@ module Udb
         end,
         "additional_extensions" => true
       }
+      c["requirements"] = requirements_condition.to_h unless requirements_condition.empty?
+      c
     end
 
-    # returns a config arch that treats the Portfolio like a partial config
-    sig { returns(ConfiguredArchitecture) }
-    def to_cfg_arch
-      @cfg_arch_for_mandatory ||= begin
-        Tempfile.create do |f|
-          f.write YAML.dump(to_config)
-          f.fsync
+    # @return portfolio in config form, with requirements of mandatory extensions expanded
+    sig { returns(T::Hash[String, T.untyped]) }
+    def to_strict_config
+      strict_mandatory_ext_reqs = mandatory_ext_reqs
+      mandatory_ext_req_names = strict_mandatory_ext_reqs.map(&:name).to_set
+      cfg_arch_obj = to_cfg_arch
+
+      cfg_arch_obj.extensions.each do |ext|
+        next if mandatory_ext_req_names.include?(ext.name)
+
+        if (-ext.to_ext_req.to_condition & cfg_arch_obj.to_condition).unsatisfiable_by_cfg_arch?(cfg_arch_obj)
+          # what's the minimum?
+          min_ext_ver = ext.versions.find do |ext_ver|
+            compat_with_ext_ver = Condition.new({ "extension" => { "name" => ext.name, "version" => "= #{ext_ver.version_str}" } }, cfg_arch_obj)
+            c = (compat_with_ext_ver & cfg_arch_obj.to_condition)
+            c.satisfiable_by_cfg_arch?(cfg_arch_obj)
+          end
+          raise "condition problem: ext is required but none of the versions are" if min_ext_ver.nil?
 
-          @cfg_arch.config.info.resolver.cfg_arch_for(Pathname.new f.path)
+          strict_mandatory_ext_reqs << PortfolioExtensionRequirement.new(ext.name, "~> #{min_ext_ver.version_str}", arch: cfg_arch_obj)
+          mandatory_ext_req_names.add(ext.name)
         end
       end
+
+      to_config(mandatory: strict_mandatory_ext_reqs)
+    end
+
+    # returns a config arch that treats the Portfolio like a partial config
+    sig { returns(ConfiguredArchitecture) }
+    def to_cfg_arch
+      @cfg_arch_for_mandatory ||= cfg_arch_for_config_data(to_config)
     end
 
     # returns a config arch that treats the *optional* extensions in Portfolio like a partial config
@@ -525,15 +558,38 @@ module Udb
             end,
             "additional_extensions" => true
           }
+        contents["requirements"] = requirements_condition.to_h unless requirements_condition.empty?
+        cfg_arch_for_config_data(contents)
+      end
+    end
+
+    # Build a ConfiguredArchitecture from an in-memory config data hash.
+    # Uses the fast path (no disk round-trip) when the parent has no overlay;
+    # falls back to the full pipeline when the parent's resolved spec differs.
+    sig { params(config_data: T::Hash[String, T.untyped]).returns(ConfiguredArchitecture) }
+    def cfg_arch_for_config_data(config_data)
+      resolver = @cfg_arch.config.info.resolver
+      if @cfg_arch.config.info.overlay_path.nil?
+        resolver.cfg_arch_for_data(config_data)
+      else
         Tempfile.create do |f|
-          f.write YAML.dump(contents)
+          f.write YAML.dump(config_data)
           f.fsync
-
-          @cfg_arch.config.info.resolver.cfg_arch_for(Pathname.new f.path)
+          resolver.cfg_arch_for(Pathname.new f.path)
         end
       end
     end
 
+    sig { returns(AbstractCondition) }
+    def requirements_condition
+      @requirements_condition ||=
+        if @data.key?("requirements")
+          Condition.new(@data.fetch("requirements"), cfg_arch)
+        else
+          AlwaysTrueCondition.new(cfg_arch)
+        end
+    end
+
     # @return [String] Given an instruction +inst_name+, return the presence as a string.
     #                  If the instruction name isn't found in the portfolio, return "-".
     sig { params(inst_name: String).returns(T.nilable(Presence)) }
@@ -739,8 +795,7 @@ module Udb
 
       return @in_scope_csrs unless @in_scope_csrs.nil?
 
-      @in_scope_csrs =
-        in_scope_min_satisfying_extension_versions.map { |ext_ver| ext_ver.in_scope_csrs(design.possible_xlens) }.flatten.uniq
+      @in_scope_csrs = to_cfg_arch.in_scope_csrs()
     end
 
     # @param design [Design] The design

data/lib/udb/obj/profile.rb

@@ -196,10 +196,6 @@ module Udb
       @data["base"]
     end
 
-    def all_in_scope_params
-      [Portfolio::InScopeParameter.new(@cfg_arch.param("MXLEN"), { "const" => @data["base"] }, "")]
-    end
-
     # Too complicated to put in profile ERB template.
     # @param presence_type [String]
     # @param heading_level [Integer]

data/lib/udb/obj/register_file.rb

@@ -49,6 +49,12 @@ class RegisterFile < TopLevelDatabaseObject
     sig { returns(T::Array[String]) }
     def abi_mnemonics = @data.fetch("abi_mnemonics", [])
 
+    sig { returns(T.nilable(String)) }
+    def reset_value = @data["reset_value"]
+
+    sig { returns(RegisterFile) }
+    def register_file = @file
+
     sig { returns(T.any(Integer, String)) }
     def index = @index
 
@@ -97,8 +103,63 @@ class RegisterFile < TopLevelDatabaseObject
     end
   end
 
-  sig { returns(T.any(Integer, String)) }
-  def register_length = @data.fetch("register_length")
+  # Returns the IDL function body string for the register_length() field.
+  # e.g. "return MXLEN;" or "return implemented?(ExtensionName::D) ? 64 : 32;"
+  sig { returns(String) }
+  def register_length = @data.fetch("register_length()")
+
+  # Returns the stripped IDL expression (no 'return' keyword or trailing semicolon).
+  sig { returns(String) }
+  def register_length_expr
+    register_length.strip.sub(/\Areturn\s+/, "").sub(/;\z/, "").strip
+  end
+
+  # Evaluate the register_length() IDL body against the given cfg_arch parameter context.
+  # Returns an Integer if the width is statically determined, or a String param name
+  # if the width depends on a runtime parameter (e.g. "VLEN").
+  sig { params(cfg_arch: ConfiguredArchitecture).returns(T.any(Integer, String)) }
+  def eval_register_length(cfg_arch)
+    expr = register_length_expr
+
+    # Literal integer
+    return Integer(expr) if expr =~ /\A\d+\z/
+
+    # Simple MXLEN reference
+    if expr == "MXLEN"
+      mxlen = cfg_arch.mxlen
+      return mxlen || "MXLEN"  # Return String "MXLEN" for dynamic-XLEN configs
+    end
+
+    # Check for a fixed parameter
+    fixed = cfg_arch.params_with_value.find { |p| p.name == expr }
+    return T.cast(fixed.value, Integer).to_i if fixed
+
+    # Check if it's a free parameter name
+    free = cfg_arch.params_without_value.find { |p| p.name == expr }
+    return expr if free
+
+    # Complex expression — fall back to the architectural maximum.
+    max_register_length
+  end
+
+  # Maximum value register_length() can return across all valid configurations.
+  # Derived by compiling the register_length() expression against the full symtab
+  # and calling max_value — unknown conditions (e.g. implemented?) cause the ternary
+  # to return the max of both branches.
+  sig { returns(Integer) }
+  def max_register_length
+    @max_register_length ||= _compute_max_register_length
+  end
+
+  private def _compute_max_register_length
+    node = cfg_arch.idl_compiler.compile_expression(
+      register_length_expr, cfg_arch.symtab, pass_error: true
+    )
+    max = node.max_value(cfg_arch.symtab)
+    raise "Cannot determine max_register_length for register file '#{name}' " \
+          "(register_length() expression: '#{register_length_expr}')" if max == :unknown
+    Integer(max)
+  end
 
   sig { returns(T.nilable(String)) }
   def summary = @data["summary"]

data/lib/udb/portfolio_design.rb

@@ -4,13 +4,12 @@
 
 # frozen_string_literal: true
 
-# Combines knowledge of the architecture database with one or more portfolios (profile or certificate).
+# Combines knowledge of the architecture database with one or more portfolios (profile).
 #
 # Used in portfolio-based ERB templates to gather information about the "portfolio_design".
 # The "portfolio_design" corresponds to the file being created by the ERB template and facilitates
 # sharing ERB template fragments between different kinds of portfolios (mostly in the appendices).
-# For example, a processor certificate model has one portfolio but a profile release has multiple portfolios
-# but they both have just one PortfolioDesign object.
+# For example, a profile release has multiple portfolios but just one PortfolioDesign object.
 
 require "forwardable"
 
@@ -66,9 +65,7 @@ module Udb
 
     # Class methods
     def self.profile_release_type = "Profile Release"
-    def self.proc_crd_type = "Certification Requirements Document"
-    def self.proc_ctp_type = "Certification Test Plan"
-    def self.portfolio_design_types = [profile_release_type, proc_crd_type, proc_ctp_type]
+    def self.portfolio_design_types = [profile_release_type]
 
     # @param name [#to_s] The name of the portfolio design (i.e., backend filename without a suffix)
     # @param cfg_arch [ConfiguredArchitecture] The database of RISC-V standards for a particular configuration

data/lib/udb/resolver.rb

@@ -15,6 +15,9 @@ require_relative "yaml/yaml_resolver"
 module Udb
   # resolves the specification in the context of a config, and writes to a generation folder
   #
+  # Raised by Resolver#cfg_info when a config name or path cannot be found.
+  class ConfigNotFoundError < StandardError; end
+
   # The primary interface for users will be #cfg_arch_for
   class Resolver
     extend T::Sig
@@ -186,15 +189,20 @@ module Udb
           end
         raise "custom directory '#{overlay_path}' does not exist" if !overlay_path.nil? && !overlay_path.directory?
 
-        if any_newer?(merged_spec_path(config_name) / ".stamp", deps)
-          # Use Ruby YAML resolver instead of Python
-          yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
-          yaml_resolver.merge_files(
-            std_path.to_s,
-            overlay_path&.to_s,
-            merged_spec_path(config_name).to_s
-          )
-          FileUtils.touch(merged_spec_path(config_name) / ".stamp")
+        FileUtils.mkdir_p(@gen_path / "spec")
+        merge_lock_name = merged_spec_path(config_name).basename
+        File.open(@gen_path / "spec" / ".#{merge_lock_name}.lock", File::CREAT | File::RDWR) do |f|
+          f.flock(File::LOCK_EX)
+          if any_newer?(merged_spec_path(config_name) / ".stamp", deps)
+            # Use Ruby YAML resolver instead of Python
+            yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
+            yaml_resolver.merge_files(
+              std_path.to_s,
+              overlay_path&.to_s,
+              merged_spec_path(config_name).to_s
+            )
+            FileUtils.touch(merged_spec_path(config_name) / ".stamp")
+          end
         end
       end
     end
@@ -205,19 +213,24 @@ module Udb
       @mutex.synchronize do
         config_name = config_yaml["name"]
 
-        deps = Dir[merged_spec_path(config_name) / "**" / "*.yaml"].map { |p| Pathname.new(p) }
-        if any_newer?(resolved_spec_path(config_name) / ".stamp", deps)
-          # Use Ruby YAML resolver instead of Python
-          yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
-          yaml_resolver.resolve_files(
-            merged_spec_path(config_name).to_s,
-            resolved_spec_path(config_name).to_s,
-            no_checks: false
-          )
-          FileUtils.touch(resolved_spec_path(config_name) / ".stamp")
-        end
+        FileUtils.mkdir_p(@gen_path / "resolved_spec")
+        resolve_lock_name = resolved_spec_path(config_name).basename
+        File.open(@gen_path / "resolved_spec" / ".#{resolve_lock_name}.lock", File::CREAT | File::RDWR) do |f|
+          f.flock(File::LOCK_EX)
+          deps = Dir[merged_spec_path(config_name) / "**" / "*.yaml"].map { |p| Pathname.new(p) }
+          if any_newer?(resolved_spec_path(config_name) / ".stamp", deps)
+            # Use Ruby YAML resolver instead of Python
+            yaml_resolver = Udb::Yaml::Resolver.new(quiet: @quiet, compile_idl: @compile_idl)
+            yaml_resolver.resolve_files(
+              merged_spec_path(config_name).to_s,
+              resolved_spec_path(config_name).to_s,
+              no_checks: false
+            )
+            FileUtils.touch(resolved_spec_path(config_name) / ".stamp")
+          end
 
-        FileUtils.cp_r(std_path / "isa", resolved_spec_path(config_name))
+          FileUtils.cp_r(std_path / "isa", resolved_spec_path(config_name))
+        end
       end
     end
 
@@ -240,8 +253,7 @@ module Udb
             if (@cfgs_path / "#{config_path_or_name}.yaml").file?
               (@cfgs_path / "#{config_path_or_name}.yaml").realpath
             else
-              Udb.logger.error "Could not find config: #{config_path_or_name}"
-              exit 1
+              raise ConfigNotFoundError, "Could not find config: #{config_path_or_name}"
             end
           else
             T.absurd(config_path_or_name)
@@ -291,6 +303,33 @@ module Udb
       end
     end
 
+    # Resolve a config pointer (name or file path) to a ConfiguredArchitecture.
+    # Resolution order:
+    #   1. If <cfgs_path>/<pointer>.yaml exists on disk, treat as a repo config name
+    #      (handles names that contain '/', e.g. "profile/RVA23U64").
+    #   2. If the pointer ends in .yaml/.yml, is absolute, or starts with ./ or ../,
+    #      treat as a file path resolved relative to +relative_dir+.
+    #   3. Otherwise raise ArgumentError — the pointer is neither a known config name
+    #      nor a recognisable file path.
+    sig { params(pointer: String, relative_dir: Pathname).returns(Udb::ConfiguredArchitecture) }
+    def cfg_arch_for_pointer(pointer, relative_dir:)
+      if (@cfgs_path / "#{pointer}.yaml").file?
+        # Repo config name — may contain '/' for nested configs (e.g. "profile/RVA23U64").
+        cfg_arch_for(pointer)
+      elsif pointer.end_with?(".yaml", ".yml") ||
+            Pathname.new(pointer).absolute? ||
+            pointer.start_with?("./", "../")
+        # Explicit file path — resolve relative to the caller's directory.
+        path = Pathname.new(pointer)
+        cfg_arch_for(path.absolute? ? path : (relative_dir / path).cleanpath)
+      else
+        raise ArgumentError,
+          "Cannot resolve config pointer '#{pointer}': not a known config name " \
+          "under '#{@cfgs_path}' and not a recognisable file path " \
+          "(.yaml/.yml extension, absolute, or starting with ./ or ../)"
+      end
+    end
+
     # resolve the specification for a config, and return a ConfiguredArchitecture
     sig { params(config_path_or_name: T.any(Pathname, String)).returns(Udb::ConfiguredArchitecture) }
     def cfg_arch_for(config_path_or_name)
@@ -312,6 +351,28 @@ module Udb
       end
     end
 
+    # Create a ConfiguredArchitecture directly from an in-memory config data hash,
+    # bypassing resolve_config and resolve_arch entirely. Only valid when the config
+    # has no arch_overlay (i.e., it uses the standard spec at gen/resolved_spec/_).
+    # Callers must ensure this precondition holds before calling this method.
+    sig { params(config_data: T::Hash[String, T.untyped]).returns(Udb::ConfiguredArchitecture) }
+    def cfg_arch_for_data(config_data)
+      info = ConfigInfo.new(
+        name: config_data["name"],
+        path: Pathname.new("portfolio/#{config_data["name"]}"),
+        overlay_path: nil,
+        unresolved_yaml: config_data,
+        spec_path: std_path,
+        merged_spec_path: @gen_path / "spec" / "_",
+        resolved_spec_path: @gen_path / "resolved_spec" / "_",
+        resolver: self
+      )
+      Udb::ConfiguredArchitecture.new(
+        config_data["name"],
+        Udb::AbstractConfig.create_from_data(config_data, info)
+      )
+    end
+
     SCHEMAS_BASE_URL = "https://riscv.github.io/riscv-unified-db/schemas"
 
     # Resolve schema files by rewriting their $id to the full published URL and

data/lib/udb/version.rb

@@ -5,5 +5,5 @@
 # frozen_string_literal: true
 
 module Udb
-  def self.version = "0.1.9"
+  def self.version = "0.1.13"
 end

data/lib/udb/version_spec.rb

@@ -192,6 +192,14 @@ module Udb
     REQUIREMENT_OP_REGEX = /((?:>=)|(?:>)|(?:~>)|(?:<)|(?:<=)|(?:!=)|(?:=))/
     REQUIREMENT_REGEX = /#{REQUIREMENT_OP_REGEX}\s*(#{VersionSpec::VERSION_REGEX})/
 
+    # Intern cache: RequirementSpec.new with the same string returns the same object.
+    @intern_cache = T.let({}, T::Hash[String, RequirementSpec])
+
+    sig { params(requirement: String).returns(RequirementSpec) }
+    def self.new(requirement)
+      @intern_cache[requirement] ||= super
+    end
+
     sig { returns(String) }
     attr_reader :op
 

data/lib/udb/z3.rb

@@ -23,6 +23,29 @@ Udb::Z3Loader.ensure_z3_loaded
 
 require "z3"
 
+# Patch Z3::AST#ast_kind to use a constant hash instead of allocating a new one on every call
+module Z3
+  class AST
+    extend T::Sig
+
+    AST_KIND_LOOKUP = T.let({
+      0 => :numeral,
+      1 => :app,
+      2 => :var,
+      3 => :quantifier,
+      4 => :sort,
+      5 => :func_decl,
+      1000 => :unknown,
+    }.freeze, T::Hash[Integer, Symbol])
+
+    sig { returns(Symbol).checked(:never) }
+    def ast_kind
+      kind_id = LowLevel.get_ast_kind(self)
+      AST_KIND_LOOKUP[kind_id] or raise Z3::Exception, "Unknown AST kind #{kind_id}"
+    end
+  end
+end
+
 module Z3
   # Extension to the Z3::Solver class to add tracked assertions
   class Solver

data/lib/udb.rb

@@ -6,14 +6,11 @@
 
 module Udb; end
 
-require_relative "udb/cert_normative_rule"
 require_relative "udb/doc_link"
 require_relative "udb/condition"
 require_relative "udb/schema"
 require_relative "udb/version"
 
-require_relative "udb/obj/certifiable_obj"
-require_relative "udb/obj/certificate"
 require_relative "udb/obj/csr_field"
 require_relative "udb/obj/csr"
 require_relative "udb/obj/database_obj"