udb 0.1.0 → 0.1.1

data/lib/udb/cfg_arch.rb

@@ -182,6 +182,9 @@ module Udb
     sig { returns(T::Array[Integer]) }
     def possible_xlens = multi_xlen? ? [32, 64] : [mxlen]
 
+    sig { params(xlen: Integer).returns(T::Boolean) }
+    def possible_xlen?(xlen) = possible_xlens.include?(xlen)
+
     # @api private
     # hash for Hash lookup
     sig { override.returns(Integer) }
@@ -1340,16 +1343,23 @@ module Udb
     end
 
     # @return List of all implemented instructions, sorted by name
-    sig { returns(T::Array[Instruction]) }
-    def implemented_instructions
+    sig { params(show_progress: T::Boolean).returns(T::Array[Instruction]) }
+    def implemented_instructions(show_progress: false)
       unless fully_configured?
         raise ArgumentError, "implemented_instructions is only defined for fully configured systems"
       end
 
       @implemented_instructions ||=
-        instructions.select do |inst|
-          inst.defined_by_condition.satisfiable_by_cfg_arch?(self)
-          # inst.defined_by_condition.satisfied_by_cfg_arch?(self) == SatisfiedResult::Yes
+        begin
+          bar =
+            if show_progress
+              Udb.create_progressbar("determining implemented instructions [:bar] :current/:total", total: instructions.size)
+            end
+          instructions.select do |inst|
+            bar.advance if show_progress
+            inst.defined_by_condition.satisfiable_by_cfg_arch?(self)
+            # inst.defined_by_condition.satisfied_by_cfg_arch?(self) == SatisfiedResult::Yes
+          end
         end
     end
 
@@ -1382,11 +1392,11 @@ module Udb
 
       @not_prohibited_instructions ||=
         if @config.fully_configured?
-          implemented_instructions
+          implemented_instructions(show_progress:)
         elsif @config.partially_configured?
           bar =
             if show_progress
-              TTY::ProgressBar.new("determining possible instructions [:bar]", total: instructions.size, output: $stdout)
+              TTY::ProgressBar.new("determining possible instructions [:bar] :current/:total", total: instructions.size, clear: true)
             end
           instructions.select do |inst|
             bar.advance if show_progress
@@ -1405,6 +1415,25 @@ module Udb
 
     alias not_prohibited_instructions possible_instructions
 
+    sig { params(show_progress: T::Boolean).returns(T::Array[Csr]) }
+    def instructions_that_must_be_implemented(show_progress: false)
+      @instructions_that_must_be_implemented ||=
+        if @config.fully_configured?
+          implemented_instructions
+        elsif @config.partially_configured?
+          bar =
+            if show_progress
+              Udb.create_progressbar("determining instructions that must be implemented [:bar]", total: instructions.size, clear: true)
+            end
+          instructions.select do |inst|
+            bar.advance if show_progress
+            (-inst.defined_by_condition).unsatisfiable_by_cfg_arch?(self)
+          end
+        else
+          []
+        end
+    end
+
     # @return [Integer] The largest instruction encoding in the config
     sig { returns(Integer) }
     def largest_encoding

data/lib/udb/idl/condition_to_udb.rb

@@ -163,24 +163,24 @@ module Idl
     def to_udb_h(symtab)
       case name
       when "implemented?"
-        type_error "Bad argument to implemented?" unless args.fetch(0).text_value =~ /^ExtensionName::[A-Z][a-z0-9]*$/
+        type_error "Bad argument to implemented?" unless arg_nodes.fetch(0).text_value =~ /^ExtensionName::[A-Z][a-z0-9]*$/
         {
           "extension" => {
-            "name" => args.fetch(0).text_value.gsub("ExtensionName::", "")
+            "name" => arg_nodes.fetch(0).text_value.gsub("ExtensionName::", "")
           }
         }
       when "implemented_version?"
-        type_error "Bad first argument to implemented_version?" unless args.fetch(0).text_value =~ /^ExtensionName::[A-Z][a-z0-9]*$/
-        type_error "Bad second argument to implemented_version?" unless args.fetch(1).text_value =~ /((?:>=)|(?:>)|(?:~>)|(?:<)|(?:<=)|(?:!=)|(?:=))\s*([0-9]+)(?:\.([0-9]+)(?:\.([0-9]+)(?:-(pre))?)?)?/
+        type_error "Bad first argument to implemented_version?" unless arg_nodes.fetch(0).text_value =~ /^ExtensionName::[A-Z][a-z0-9]*$/
+        type_error "Bad second argument to implemented_version?" unless arg_nodes.fetch(1).text_value =~ /((?:>=)|(?:>)|(?:~>)|(?:<)|(?:<=)|(?:!=)|(?:=))\s*([0-9]+)(?:\.([0-9]+)(?:\.([0-9]+)(?:-(pre))?)?)?/
         {
           "extension" => {
-            "name" => args.fetch(0).text_value.gsub("ExtensionName::", ""),
-            "version" => args.fetch(1).text_value.gsub('"', "")
+            "name" => arg_nodes.fetch(0).text_value.gsub("ExtensionName::", ""),
+            "version" => arg_nodes.fetch(1).text_value.gsub('"', "")
           }
         }
       when "xlen"
         {
-          "xlen" => args.fetch(0).value(symtab)
+          "xlen" => arg_nodes.fetch(0).value(symtab)
         }
       else
         type_error "unsupported function in an IDL condition: #{name}"

data/lib/udb/obj/extension.rb

@@ -207,45 +207,23 @@ module Udb
       end
     end
 
-    # @return the list of instructions implemented *directly* by *any version* of this extension (may be empty)
-    #  Direct means that the instruction must be defined when the extension is implemented and may not be
-    #  implemented when just the extension's requirements are met
-    #
-    #  In other words, direct is the set of instructions that are defined without transitivity
-    sig { returns(T::Array[Instruction]) }
-    def instructions
-      @instructions ||=
+    def all_instructions_that_must_be_implemented
+      @all_instructions_that_must_be_implemented ||=
         begin
           pb =
             Udb.create_progressbar(
-              "Finding instructions for #{name} [:bar] :current/:total",
-              total: cfg_arch.instructions.size,
+              "Finding all required instructions for #{name} [:bar] :current/:total",
+              total: @arch.instructions.size,
               clear: true
             )
-          cfg_arch.instructions.select do |i|
+          @arch.instructions.select do |i|
             pb.advance
-            inst_defined = i.defined_by_condition
-            next unless inst_defined.mentions?(self)
-            requirement_met = to_condition
-            preconditions_met = requirements_condition
 
-            # inst is defined exclusively by self if:
-            (
-              (-inst_defined & requirement_met) # it must be defined when self is met, and
-            ).unsatisfiable? &
-            (
-              (-inst_defined & preconditions_met)  # it may not be defined when only self's requirements are met
-            ).satisfiable?
+            (-i.defined_by_condition & to_condition).unsatisfiable_by_arch?(@arch)
           end
         end
     end
 
-    # @api private
-    sig { returns(T::Set[Instruction]) }
-    def instructions_set
-      @instructions_set ||= Set.new(instructions)
-    end
-
     # @return the list of instructions implemented *indirectly* by *any version* of this extension because
     # a requirement of the extension directly defines the instruction
     #
@@ -255,65 +233,87 @@ module Udb
     # This list may be empty
     sig { returns(T::Array[Instruction]) }
     def implied_instructions
-      @instructions ||=
+      @implied_instructions ||=
         begin
           pb =
             Udb.create_progressbar(
               "Finding implied instructions for #{name} [:bar] :current/:total",
-              total: cfg_arch.instructions.size,
+              total: @arch.instructions.size,
               clear: true
             )
-          cfg_arch.instructions.select do |i|
+          @arch.instructions.select do |i|
             pb.advance
-            if i.defined_by_condition.mentions?(to_ext_req)
-              inst_defined = i.defined_by_condition
-              preconditions_met = requirements_condition
-
-              # inst is defined transitively by self if:
-              (
-                (-inst_defined & preconditions_met) # it must be defined when preconditions are met, and
-              ).unsatisfiable?
-            end
+
+            (-i.defined_by_condition & requirements_condition).unsatisfiable_by_arch?(@arch)
           end
         end
     end
 
+    # @return the list of instructions implemented *directly* by *any version* of this extension (may be empty)
+    #  Direct means that the instruction must be defined when the extension is implemented and may not be
+    #  implemented when just the extension's requirements are met
+    #
+    #  In other words, direct is the set of instructions that are defined without transitivity
+    sig { returns(T::Array[Instruction]) }
+    def instructions
+      @instructions ||= all_instructions_that_must_be_implemented - implied_instructions
+    end
+
+    # @api private
+    sig { returns(T::Set[Instruction]) }
+    def instructions_set
+      @instructions_set ||= Set.new(instructions)
+    end
+
+
     # @api private
     sig { returns(T::Set[Instruction]) }
     def implied_instructions_set
       @implied_instructions_set ||= Set.new(implied_instructions)
     end
 
-    # @return the list of CSRs implemented by *any version* of this extension (may be empty),
-    # not including those defined by requirements of this extension
     sig { returns(T::Array[Csr]) }
-    def csrs
-      @csrs ||=
+    def all_csrs_that_must_be_implemented
+      @all_csrs_that_must_be_implemented ||=
         begin
           pb =
             Udb.create_progressbar(
-              "Finding csrs for #{name} [:bar] :current/:total",
-              total: cfg_arch.csrs.size,
+              "Finding all required csrs for #{name} [:bar] :current/:total",
+              total: @arch.csrs.size,
               clear: true
             )
-          cfg_arch.csrs.select do |csr|
+          @arch.csrs.select do |csr|
             pb.advance
-            csr_defined = csr.defined_by_condition
-            next unless csr_defined.mentions?(self)
-            requirement_met = to_condition
-            preconditions_met = requirements_condition
 
-            # csr is defined exclusively by self if:
-            (
-              (-csr_defined & requirement_met) # it must be defined when self is met, and
-            ).unsatisfiable? &
-            (
-              (-csr_defined & preconditions_met)  # it may not be defined when only self's requirements are met
-            ).satisfiable?
+            (-csr.defined_by_condition & to_condition).unsatisfiable_by_arch?(@arch)
           end
         end
     end
 
+    def implied_csrs
+      @implied_csrs ||=
+        begin
+          pb =
+            Udb.create_progressbar(
+              "Finding implied csrs for #{name} [:bar] :current/:total",
+              total: @arch.csrs.size,
+              clear: true
+            )
+          @arch.csrs.select do |csr|
+            pb.advance
+
+            (-csr.defined_by_condition & requirements_condition).unsatisfiable_by_arch?(@arch)
+          end
+        end
+    end
+
+    # @return the list of CSRs implemented by *any version* of this extension (may be empty),
+    # not including those defined by requirements of this extension
+    sig { returns(T::Array[Csr]) }
+    def csrs
+      @csrs ||= all_csrs_that_must_be_implemented - implied_csrs
+    end
+
     # @return the list of csrs implemented *indirectly* by *any version* of this extension because
     # a requirement of the extension directly defines the csr
     #
@@ -388,13 +388,16 @@ module Udb
 
       Udb.logger.info "Finding all reachable functions from extension #{name}"
 
+      cache = T.let({ 32 => {}, 64 => {}, nil => {} }, T::Hash[Integer, Idl::AstNode::ReachableFunctionCacheType])
+
       instructions.each do |inst|
-        funcs += inst.reachable_functions(32) if inst.defined_in_base?(32)
-        funcs += inst.reachable_functions(64) if inst.defined_in_base?(64)
+        funcs += inst.reachable_functions(32, cache.fetch(32)) if inst.defined_in_base?(32)
+        funcs += inst.reachable_functions(64, cache.fetch(64)) if inst.defined_in_base?(64)
       end
 
       csrs.each do |csr|
-        funcs += csr.reachable_functions
+        funcs += csr.reachable_functions(32, cache) if csr.defined_in_base?(32)
+        funcs += csr.reachable_functions(64, cache) if csr.defined_in_base?(64)
       end
 
       @reachable_functions = funcs.uniq
@@ -506,6 +509,7 @@ module Udb
       prop :unexpanded_ext_conflicts, T.nilable(T::Array[ConditionalExtensionRequirement])
       prop :term, T.nilable(ExtensionTerm)
       prop :condition, T.nilable(AbstractCondition)
+      prop :condition_exclusive, T.nilable(AbstractCondition)
       prop :compatible_versions, T.nilable(T::Array[ExtensionVersion])
       prop :key, T.nilable(Integer)
     end
@@ -582,6 +586,22 @@ module Udb
         Condition.new(condition_hash, @arch)
     end
 
+    # condition that requires this version and prohibits any other version from the same extension
+    sig { returns(AbstractCondition) }
+    def to_condition_exclusive
+      @memo.condition_exclusive ||=
+        begin
+          other_versions = @ext.versions - [self]
+          if other_versions.empty?
+            to_condition
+          elsif other_versions.size == 1
+            to_condition & -other_versions.fetch(0).to_condition
+          else
+            to_condition & -Condition.disjunction(other_versions.map(&:to_condition), @arch)
+          end
+        end
+    end
+
     sig { returns(T.any(T::Hash[String, T.untyped], FalseClass)) }
     def condition_hash
       {
@@ -1437,6 +1457,22 @@ module Udb
         Condition.new(condition_hash, @arch)
     end
 
+    # returns a condition that meets the requirement _and_ exludes any other version
+    # from the same extension
+    sig { returns(AbstractCondition) }
+    def to_condition_exclusive
+      if (satisfying_versions.size == 0) || (extension.versions.size == satisfying_versions.size)
+        to_condition
+      else
+        exclusions = extension.versions - satisfying_versions
+        if exclusions.size == 1
+          to_condition & -exclusions.fetch(0).to_condition
+        else
+          to_condition & -Condition.disjunction(exclusions.map(&:to_condition), @arch)
+        end
+      end
+    end
+
     # return the UDB YAML representation of a Condition representing this ExtensionRequirement
     sig { returns(T.any(T::Hash[String, T.untyped], FalseClass)) }
     def condition_hash
@@ -1497,7 +1533,7 @@ module Udb
     def instructions
       @instructions ||=
         extension.instructions.select do |inst|
-          (inst.defined_by_condition & to_condition).satisfiable?
+          (inst.defined_by_condition & to_condition).satisfiable_by_arch?(@arch)
         end
     end
 
@@ -1529,7 +1565,7 @@ module Udb
 
             next if instructions_set.include?(i)
 
-            (-i.defined_by_condition & to_condition).unsatisfiable?
+            (-i.defined_by_condition & to_condition).unsatisfiable_by_arch?(@arch)
           end
         end
     end
@@ -1552,7 +1588,7 @@ module Udb
     def csrs
       @csrs ||=
         extension.csrs.select do |csr|
-          (csr.defined_by_condition & to_condition).satisfiable?
+          (csr.defined_by_condition & to_condition).satisfiable_by_arch?(@arch)
         end
     end
 
@@ -1564,15 +1600,18 @@ module Udb
 
       bar = Udb.create_progressbar("Finding reachable functions for #{name} [:bar] :current/:total", total: instructions.size + csrs.size)
 
+      cache = T.let({ 32 => {}, 64 => {}, nil => {} }, T::Hash[Integer, Idl::AstNode::ReachableFunctionCacheType])
+
       instructions.each do |inst|
         bar.advance
-        funcs += inst.reachable_functions(32) if inst.defined_in_base?(32)
-        funcs += inst.reachable_functions(64) if inst.defined_in_base?(64)
+        funcs += inst.reachable_functions(32, cache.fetch(32)) if inst.defined_in_base?(32)
+        funcs += inst.reachable_functions(64, cache.fetch(32)) if inst.defined_in_base?(64)
       end
 
       csrs.each do |csr|
         bar.advance
-        funcs += csr.reachable_functions
+        funcs += csr.reachable_functions(32, cache) if csr.defined_in_base?(32)
+        funcs += csr.reachable_functions(64, cache) if csr.defined_in_base?(64)
       end
 
       @reachable_functions = funcs.uniq

data/lib/udb/version.rb

@@ -4,5 +4,5 @@
 # frozen_string_literal: true
 
 module Udb
-  def self.version = "0.1.0"
+  def self.version = "0.1.1"
 end

data/lib/udb/yaml/yaml_resolver.rb

@@ -368,7 +368,7 @@ module Udb
               raise TypeError, "Expected IDL body for #{(obj_path + [key]).join('.')} to be a String, got #{idl_source.class}"
             end
 
-            key_minus_args = key.split("(")[0]
+            key_minus_args = key.split("(")[0] + "_ast"
             source_loc = @current_comment_map&.get_source_location(obj_path + [key])
             # :line is 1-based; set_input_file expects 0-based, so subtract 1
             starting_line = source_loc ? source_loc[:line] - 1 : 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: udb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Derek Hower
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport