udb 0.1.9 → 0.1.13

data/lib/udb/cfg_arch.rb

@@ -204,7 +204,19 @@ module Udb
         begin
           @symtab = create_symtab
 
-          global_ast.add_global_symbols(@symtab)
+          # Guard against re-entrant solver calls from within add_global_symbols.
+          # Global initializers (e.g. FLEN) may call implemented?(), which triggers
+          # prohibited_ext?() and the Z3 solver chain. If those calls see @symtab is
+          # already set (partial), they'd use an incomplete symtab and fail.
+          # A depth counter (rather than a boolean) is used so that if this block
+          # ever nests (e.g. create_symtab is called recursively in the future),
+          # the inner ensure does not prematurely clear the guard for the outer block.
+          @constructing_symtab_depth = (@constructing_symtab_depth || 0) + 1
+          begin
+            global_ast.add_global_symbols(@symtab)
+          ensure
+            @constructing_symtab_depth -= 1
+          end
 
           @symtab.deep_freeze
           raise if @symtab.name.nil?
@@ -213,6 +225,11 @@ module Udb
         end
     end
 
+    # @return [Boolean] true while add_global_symbols is running inside symtab construction
+    # Used by implemented? callback to avoid triggering the Z3 solver on a partial symtab.
+    sig { returns(T::Boolean) }
+    def constructing_symtab? = (@constructing_symtab_depth || 0) > 0
+
     sig { returns(Idl::IsaAst) }
     def global_ast
       @global_ast ||=
@@ -277,7 +294,7 @@ module Udb
           reasons << "#{h.fetch("name")} is not a known extension"
         end
         if extensions.any? { |e| e.name == h.fetch("name") } && !T.must(extension(h.fetch("name"))).versions.any? { |v| v.version_spec == h.fetch("version") }
-          reasons << "#{h.fetch("version")} is not a known extension"
+          reasons << "#{h.fetch("version")} is not a known version of extension #{h.fetch("name")}"
         end
       end
 
@@ -336,6 +353,8 @@ module Udb
         reasons += missing_params.map { |p| "Parameter is required but missing: '#{p.name}'" }
       end
 
+      validate_compatible(reasons)
+
       if reasons.empty?
         raise "bad validity check" unless to_condition.satisfiable?
         ValidationResult.new(valid: true, reasons:)
@@ -466,6 +485,8 @@ module Udb
         end
       end
 
+      validate_compatible(reasons)
+
       if reasons.empty?
         raise "Bad validation" unless to_condition.satisfiable?
         return ValidationResult.new(valid: true, reasons: [])
@@ -488,6 +509,11 @@ module Udb
               # we can know if it is implemented, but not if it's not implemented for a partially configured
               if ext?(ext_name)
                 true
+              elsif constructing_symtab?
+                # During symtab construction (add_global_symbols), the Z3 solver is not
+                # available because the symtab is partial. Return nil (unknown) so that
+                # value_try falls back to storing the global with nil (no compile-time value).
+                nil
               elsif prohibited_ext?(ext_name)
                 false
               else
@@ -504,6 +530,9 @@ module Udb
               # we can know if it is implemented, but not if it's not implemented for a partially configured
               if ext?(ext_name, [version])
                 true
+              elsif constructing_symtab?
+                # Same guard as for implemented? above.
+                nil
               elsif prohibited_ext?(ext_name)
                 false
               else
@@ -583,6 +612,33 @@ module Udb
       end
       pb.finish
 
+      # Build a bootstrap symtab and compute RF max widths before constructing the real
+      # symtab. The bootstrap needs add_global_symbols so that implemented?() is a known
+      # function (required for type_check to pass). Running it under @constructing_symtab=true
+      # ensures implemented?() returns nil → value_error during value evaluation, which
+      # causes TernaryOperatorExpressionAst#max_value to explore both branches.
+      bootstrap_st = Idl::SymbolTable.new(
+        mxlen:,
+        builtin_global_vars: final_param_vars,
+        builtin_enums: symtab_enums,
+        builtin_funcs: symtab_callbacks,
+        params: all_params,
+        name: "#{@name}/bootstrap",
+        register_files: []
+      )
+      rf_max_widths = begin
+        @constructing_symtab_depth = (@constructing_symtab_depth || 0) + 1
+        global_ast.add_global_symbols(bootstrap_st)
+        register_files.each_with_object({}) do |rf, h|
+          node = @idl_compiler.compile_expression(rf.register_length_expr, bootstrap_st, pass_error: true)
+          max = node.max_value(bootstrap_st)
+          raise "Cannot determine max width for register file '#{rf.name}'" if max == :unknown
+          h[rf.name] = Integer(max)
+        end
+      ensure
+        @constructing_symtab_depth -= 1
+      end
+
       Idl::SymbolTable.new(
         mxlen:,
         possible_xlens_cb: proc { possible_xlens },
@@ -591,7 +647,9 @@ module Udb
         builtin_enums: symtab_enums,
         name: @name,
         csrs:,
-        params: all_params
+        params: all_params,
+        register_files: register_files,
+        register_file_max_widths: rf_max_widths
       )
     end
     private :create_symtab
@@ -665,6 +723,12 @@ module Udb
     #   @param name [String] The $1 name
     #   @return [$3] The $1
     #   @return [nil] if there is no $1 named +name+
+    # Class-level cache of raw YAML file contents keyed by "#{resolved_spec_path}/#{obj_type_dir}".
+    # Maps each directory to an array of [content, original_path, realpath] triples so that a
+    # second ConfiguredArchitecture sharing the same spec path skips disk I/O and file locking.
+    # Benign race: two threads both missing the cache produce identical entries.
+    @@yaml_data_cache = Concurrent::Hash.new
+
     sig { params(fn_name: String, arch_dir: String, obj_class: T.class_of(TopLevelDatabaseObject)).void }
     def self.generate_obj_methods(fn_name, arch_dir, obj_class)
 
@@ -675,12 +739,25 @@ module Udb
 
         @objects[arch_dir] = Concurrent::Array.new
         @object_hashes[arch_dir] = Concurrent::Hash.new
-        Dir.glob(@arch_dir / arch_dir / "**" / "*.yaml") do |obj_path|
-          f = File.open(obj_path)
-          f.flock(File::LOCK_EX)
-          obj_yaml = YAML.load(f.read, filename: obj_path, permitted_classes: [Date])
-          f.flock(File::LOCK_UN)
-          @objects[arch_dir] << obj_class.new(obj_yaml, Pathname.new(obj_path).realpath, T.cast(self, ConfiguredArchitecture))
+
+        yaml_cache_key = "#{@arch_dir}/#{arch_dir}"
+        cached_files = @@yaml_data_cache[yaml_cache_key]
+        if cached_files.nil?
+          entries = []
+          Dir.glob(@arch_dir / arch_dir / "**" / "*.yaml") do |obj_path|
+            File.open(obj_path) do |f|
+              f.flock(File::LOCK_EX)
+              content = f.read
+              f.flock(File::LOCK_UN)
+              entries << [content, obj_path, Pathname.new(obj_path).realpath]
+            end
+          end
+          cached_files = @@yaml_data_cache[yaml_cache_key] = entries
+        end
+
+        cached_files.each do |content, obj_path, realpath|
+          obj_yaml = YAML.load(content, filename: obj_path, permitted_classes: [Date])
+          @objects[arch_dir] << obj_class.new(obj_yaml, realpath, T.cast(self, ConfiguredArchitecture))
           @object_hashes[arch_dir][@objects[arch_dir].last.name] = @objects[arch_dir].last
         end
         @objects[arch_dir]
@@ -714,43 +791,28 @@ module Udb
     # @param io where to write progress bars
     # @return [void]
     sig { params(show_progress: T::Boolean, io: IO).void }
-    def type_check(show_progress: true, io: $stdout)
+    def type_check(show_progress: true, io: $stderr)
       io.puts "Type checking IDL code for #{@config.name}..." if show_progress
       insts = @config.unconfigured? ? instructions : possible_instructions(show_progress:)
       xlens = @config.unconfigured? ? [32, 64] : possible_xlens
 
       progressbar =
         if show_progress
-          TTY::ProgressBar.new("type checking possible instructions [:bar] :current/:total", total: insts.size, output: $stdout)
+          TTY::ProgressBar.new("type checking possible instructions [:bar] :current/:total", total: insts.size, output: io)
         end
 
       insts.each do |inst|
         progressbar.advance if show_progress
         if @mxlen == 32
           if inst.rv32?
-            op_ast = inst.operation_ast
-            unless op_ast.nil?
-              s = inst.fill_symtab(32, op_ast)
-              op_ast.prune(s).type_check(s, strict: true)
-              s.release
-            end
+            inst.pruned_operation_ast(32)
           end
         else
           if inst.rv64?
-            op_ast = inst.operation_ast
-            unless op_ast.nil?
-              s = inst.fill_symtab(64, op_ast)
-              op_ast.prune(s).type_check(s, strict: true)
-              s.release
-            end
+            inst.pruned_operation_ast(64)
           end
           if xlens.include?(32) && inst.rv32?
-            op_ast = inst.operation_ast
-            unless op_ast.nil?
-              s = inst.fill_symtab(32, op_ast)
-              op_ast.prune(s).type_check(s, strict: true)
-              s.release
-            end
+            inst.pruned_operation_ast(32)
           end
         end
       end
@@ -758,7 +820,7 @@ module Udb
       csr_list = @config.unconfigured? ? csrs : possible_csrs
       progressbar =
         if show_progress
-          TTY::ProgressBar.new("type checking CSRs [:bar]", total: csr_list.size, output: $stdout)
+          TTY::ProgressBar.new("type checking CSRs [:bar] :current/:total", total: csr_list.size, output: io)
         end
 
       csr_list.each do |csr|
@@ -769,53 +831,35 @@ module Udb
 
         if csr.has_custom_sw_read?
           if (xlens.include?(32) && csr_in_base32)
-            s = csr.fill_symtab(nil, 32)
-            csr.sw_read_ast(s).prune(s).type_check(s, strict: true)
-            s.release
+            csr.type_checked_pruned_sw_read_ast(32)
           end
           if (xlens.include?(64) && csr_in_base64)
-            s = csr.fill_symtab(nil, 64)
-            csr.sw_read_ast(s).prune(s).type_check(s, strict: true)
-            s.release
+            csr.type_checked_pruned_sw_read_ast(64)
           end
         end
         csr.possible_fields.each do |field|
-          reset_ast = field.reset_value_ast
-          unless reset_ast.nil?
+          if field.reset_value_ast
             if xlens.include?(32) && csr_in_base32 && field.defined_in_base32?
-              s = field.fill_symtab_for_reset(nil)
-              reset_ast.prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_reset_value_ast
             end
             if xlens.include?(64) && csr_in_base64 && field.defined_in_base64?
-              s = field.fill_symtab_for_reset(nil)
-              reset_ast.prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_reset_value_ast
             end
           end
           if field.has_custom_sw_write?
             if xlens.include?(32) && csr_in_base32 && field.defined_in_base32?
-              s = field.fill_symtab_for_sw_write(32, nil)
-              field.sw_write_ast(s).prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_sw_write_ast(32)
             end
             if xlens.include?(64) && csr_in_base64 && field.defined_in_base64?
-              s = field.fill_symtab_for_sw_write(64, nil)
-              field.sw_write_ast(s).prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_sw_write_ast(64)
             end
           end
-          type_ast = field.type_ast
-          unless type_ast.nil?
+          if field.type_ast
             if xlens.include?(32) && csr_in_base32 && field.defined_in_base32?
-              s = field.fill_symtab_for_type(32, nil)
-              type_ast.prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_type_ast(32)
             end
             if xlens.include?(64) && csr_in_base64 && field.defined_in_base64?
-              s = field.fill_symtab_for_type(64, nil)
-              type_ast.prune(s).type_check(s, strict: true)
-              s.release
+              field.pruned_type_ast(64)
             end
           end
         end
@@ -824,7 +868,7 @@ module Udb
       func_list = @config.unconfigured? ? functions : reachable_functions(show_progress:)
       progressbar =
         if show_progress
-          TTY::ProgressBar.new("type checking functions [:bar]", total: func_list.size, output: $stdout)
+          TTY::ProgressBar.new("type checking functions [:bar] :current/:total", total: func_list.size, output: io)
         end
       func_list.each do |func|
         progressbar.advance if show_progress
@@ -1080,6 +1124,21 @@ module Udb
         end
     end
 
+    # @return [Hash<String, Array<ExtensionVersion>>] possible_extension_versions grouped by name
+    def possible_extension_versions_by_name
+      @possible_extension_versions_by_name ||=
+        possible_extension_versions.group_by(&:name)
+    end
+
+    # Memoized Z3 satisfiability result for a ParameterTerm against this cfg_arch.
+    # Keyed by ParameterTerm (uses hash/eql? based on yaml_no_reason), so identical
+    # terms across different Condition objects share the same Z3 result.
+    #
+    # @return [Hash<ParameterTerm, SatisfiedResult>]
+    def param_term_satisfied_memo
+      @param_term_satisfied_memo ||= {}
+    end
+
     # @overload prohibited_ext?(ext)
     #   Returns true if the ExtensionVersion +ext+ is prohibited
     #   @param ext [ExtensionVersion] An extension version
@@ -1740,5 +1799,58 @@ module Udb
       end
     end
 
+    sig { params(pointer: String).returns(ConfiguredArchitecture) }
+    def resolve_compatible_pointer(pointer)
+      @config.info.resolver.cfg_arch_for_pointer(
+        pointer,
+        relative_dir: Pathname.new(@config.info.path).dirname
+      )
+    end
+    private :resolve_compatible_pointer
+
+    sig { params(other: ConfiguredArchitecture, reasons: T::Array[String], visited: T::Set[String]).void }
+    def check_compatible_with(other, reasons, visited)
+      return if visited.include?(other.name)
+      visited.add(other.name)
+
+      combined = to_condition & other.to_condition
+      unless combined.satisfiable_by_cfg_arch?(self)
+        combined.to_logic_tree(expand: true).minimal_unsat_subsets.each do |min|
+          reasons << "Config '#{name}' is not compatible with '#{other.name}': not satisfiable: #{min.to_s(format: LogicNode::LogicSymbolFormat::C)}"
+        end
+      end
+
+      # Resolve transitive pointers relative to `other`'s directory, not self's.
+      Array(other.config.compatible).each do |pointer|
+        begin
+          trans = other.send(:resolve_compatible_pointer, pointer)
+          check_compatible_with(trans, reasons, visited)
+        rescue => e
+          reasons << "Cannot resolve transitive compatible pointer '#{pointer}': #{e.message}"
+        end
+      end
+    end
+    private :check_compatible_with
+
+    sig { params(reasons: T::Array[String]).void }
+    def validate_compatible(reasons)
+      return if @config.compatible.nil?
+
+      # Use dup per top-level pointer so sibling pointers each get a fresh visited set —
+      # each branch independently validates against any shared transitive targets. Cycle
+      # detection within a single chain is still enforced because visited mutates in-place
+      # during the recursive descent.
+      visited = T.let(Set.new([name]), T::Set[String])
+      Array(@config.compatible).each do |pointer|
+        begin
+          other = resolve_compatible_pointer(pointer)
+          check_compatible_with(other, reasons, visited.dup)
+        rescue => e
+          reasons << "Cannot resolve compatible pointer '#{pointer}': #{e.message}"
+        end
+      end
+    end
+    private :validate_compatible
+
   end
 end

data/lib/udb/cli.rb

@@ -82,17 +82,21 @@ module Udb
       method_option :custom, type: :string, desc: "Path to custom specification directory, if needed", default: Udb.default_custom_isa_path.to_s
       method_option :config_dir, type: :string, desc: "Path to directory with config files", default: Udb.default_cfgs_path.to_s
       method_option :gen, type: :string, desc: "Path to folder used for generation", default: Udb.default_gen_path.to_s
+      method_option :strict_partial, type: :boolean, desc: "Whether or not to check if a partial config is fully specified -- that is, all requirements of a mandatory extension are also listed in mandatory extensions and/or parameters", default: false
       method_option :z3parallel, type: :boolean, desc: "Use parallel.enable for Z3", default: true
       def cfg(name_or_path)
         raise ArgumentError, "Spec directory does not exist: #{options[:std]}" unless File.directory?(options[:std])
 
         Udb.global_options.parallel_z3 = options[:z3parallel]
 
+
         cfg_file =
           if File.file?(name_or_path)
             Pathname.new(name_or_path)
           elsif File.file?("#{options[:config_dir]}/#{name_or_path}.yaml")
             Pathname.new("#{options[:config_dir]}/#{name_or_path}.yaml")
+          elsif File.file?("#{options[:config_dir]}/profile/#{name_or_path}.yaml")
+            Pathname.new("#{options[:config_dir]}/profile/#{name_or_path}.yaml")
           else
             raise ArgumentError, "Cannot find config: #{name_or_path}"
           end
@@ -108,7 +112,12 @@ module Udb
           say "Config is #{pastel.red.bold("invalid")}"
           exit 1
         end
-        result = cfg_arch.valid?
+        result =
+          if options[:strict_partial]
+            cfg_arch.partial_config_strictly_specified?
+          else
+            cfg_arch.valid?
+          end
 
         if result.valid
           say "Config #{pastel.bold(cfg_arch.name)} is #{pastel.green.bold("valid")}"

data/lib/udb/condition.rb

@@ -432,10 +432,6 @@ module Udb
       end
     end
 
-    class MemoizedState < T::Struct
-      prop :satisfied_by_cfg_arch, T::Hash[ConfiguredArchitecture, SatisfiedResult]
-    end
-
     sig {
       params(
         yaml: T.any(T::Hash[String, T.untyped], T::Boolean),
@@ -450,7 +446,7 @@ module Udb
       @cfg_arch = cfg_arch
       @input_file = input_file
       @input_line = input_line
-      @memo = MemoizedState.new(satisfied_by_cfg_arch: {})
+      @satisfied_by_cfg_arch_memo = T.let({}, T::Hash[ConfiguredArchitecture, SatisfiedResult])
     end
 
     sig { override.returns(T::Boolean) }
@@ -1103,7 +1099,7 @@ module Udb
 
     sig { override.params(cfg_arch: ConfiguredArchitecture).returns(SatisfiedResult) }
     def satisfied_by_cfg_arch?(cfg_arch)
-      @memo.satisfied_by_cfg_arch[cfg_arch] ||=
+      @satisfied_by_cfg_arch_memo[cfg_arch] ||=
         if cfg_arch.fully_configured?
           implemented_ext_cb = make_cb_proc do |term|
             if term.is_a?(ExtensionTerm)
@@ -1115,18 +1111,7 @@ module Udb
             elsif term.is_a?(ParameterTerm)
               if cfg_arch.param_values.key?(term.name)
                 result = term.eval(cfg_arch)
-                if result == SatisfiedResult::Maybe
-                  # this might just mean we don't know the value.
-                  # however, given the parameter schema and constraints, we could know that term is
-                  # always false
-                  if (Condition.new({ "param" => term.to_h }, cfg_arch) & cfg_arch.to_condition).unsatisfiable?
-                    result = SatisfiedResult::No
-
-                  # or always true
-                  elsif (-Condition.new({ "param" => term.to_h }, cfg_arch) & cfg_arch.to_condition).unsatisfiable?
-                    result = SatisfiedResult::Yes
-                  end
-                end
+                result = resolve_param_term_from_maybe(term, cfg_arch) if result == SatisfiedResult::Maybe
                 result
               else
                 SatisfiedResult::No
@@ -1155,27 +1140,17 @@ module Udb
         elsif cfg_arch.partially_configured?
           cb = make_cb_proc do |term|
             if term.is_a?(ExtensionTerm)
-              if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_req) }
+              ext_req = term.to_ext_req(cfg_arch)
+              if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| ext_req.satisfied_by?(cfg_ext_req) }
                 SatisfiedResult::Yes
-              elsif cfg_arch.possible_extension_versions.any? { |cfg_ext_ver| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_ver) }
+              elsif (cfg_arch.possible_extension_versions_by_name[term.name] || []).any? { |cfg_ext_ver| ext_req.satisfied_by?(cfg_ext_ver) }
                 SatisfiedResult::Maybe
               else
                 SatisfiedResult::No
               end
             elsif term.is_a?(ParameterTerm)
               result = term.eval(cfg_arch)
-              if result == SatisfiedResult::Maybe
-                # this might just mean we don't know the value.
-                # however, given the parameter schema and constraints, we could know that term is
-                # always false
-                if (Condition.new({ "param" => term.to_h }, cfg_arch) & cfg_arch.to_condition).unsatisfiable?
-                  result = SatisfiedResult::No
-
-                # or always true
-                elsif (-Condition.new({ "param" => term.to_h }, cfg_arch) & cfg_arch.to_condition).unsatisfiable?
-                  result = SatisfiedResult::Yes
-                end
-              end
+              result = resolve_param_term_from_maybe(term, cfg_arch) if result == SatisfiedResult::Maybe
               result
             elsif term.is_a?(FreeTerm)
               raise "unreachable"
@@ -1232,7 +1207,8 @@ module Udb
         if node.type == LogicNodeType::Term
           term = node.children.fetch(0)
           if term.is_a?(ExtensionTerm)
-            if ext_reqs.any? { |ext_req| term.to_ext_req(@cfg_arch).satisfied_by?(ext_req) }
+            term_ext_req = term.to_ext_req(@cfg_arch)
+            if ext_reqs.any? { |ext_req| term_ext_req.satisfied_by?(ext_req) }
               next LogicNode::True
             end
           end
@@ -1277,9 +1253,10 @@ module Udb
               SatisfiedResult::Yes
             end
           elsif cfg_arch.partially_configured?
-            if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_req) }
+            ext_req = term.to_ext_req(cfg_arch)
+            if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| ext_req.satisfied_by?(cfg_ext_req) }
               SatisfiedResult::Yes
-            elsif cfg_arch.possible_extension_versions.any? { |cfg_ext_ver| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_ver) }
+            elsif (cfg_arch.possible_extension_versions_by_name[term.name] || []).any? { |cfg_ext_ver| ext_req.satisfied_by?(cfg_ext_ver) }
               SatisfiedResult::Maybe
             else
               SatisfiedResult::No
@@ -1329,9 +1306,10 @@ module Udb
               SatisfiedResult::Yes
             end
           elsif cfg_arch.partially_configured?
-            if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_req) }
+            ext_req = term.to_ext_req(cfg_arch)
+            if cfg_arch.mandatory_extension_reqs.any? { |cfg_ext_req| ext_req.satisfied_by?(cfg_ext_req) }
               SatisfiedResult::Yes
-            elsif cfg_arch.possible_extension_versions.any? { |cfg_ext_ver| term.to_ext_req(cfg_arch).satisfied_by?(cfg_ext_ver) }
+            elsif (cfg_arch.possible_extension_versions_by_name[term.name] || []).any? { |cfg_ext_ver| ext_req.satisfied_by?(cfg_ext_ver) }
               SatisfiedResult::Maybe
             else
               SatisfiedResult::No
@@ -1645,6 +1623,27 @@ module Udb
     def -@
       Condition.not(self, @cfg_arch)
     end
+
+    private
+
+    # When term.eval returns Maybe, check whether the parameter schema and constraints
+    # imply the term is always false or always true, and cache the result per (term, cfg_arch).
+    sig { params(term: ParameterTerm, cfg_arch: ConfiguredArchitecture).returns(SatisfiedResult) }
+    def resolve_param_term_from_maybe(term, cfg_arch)
+      memo = cfg_arch.param_term_satisfied_memo
+      unless memo.key?(term)
+        param_cond = Condition.new({ "param" => term.to_h }, cfg_arch)
+        memo[term] =
+          if param_cond.unsatisfiable_by_cfg_arch?(cfg_arch)
+            SatisfiedResult::No
+          elsif (-param_cond).unsatisfiable_by_cfg_arch?(cfg_arch)
+            SatisfiedResult::Yes
+          else
+            SatisfiedResult::Maybe
+          end
+      end
+      memo[term]
+    end
   end
 
   class LogicCondition < Condition
@@ -1654,6 +1653,7 @@ module Udb
       @logic_node = logic_node
       @cfg_arch = cfg_arch
       @yaml = logic_node.to_h
+      @satisfied_by_cfg_arch_memo = T.let({}, T::Hash[ConfiguredArchitecture, SatisfiedResult])
     end
 
     sig { override.returns(T::Boolean) }
@@ -2040,6 +2040,7 @@ module Udb
     sig { params(xlen: Integer).void }
     def initialize(xlen)
       @xlen = xlen
+      @satisfied_by_cfg_arch_memo = T.let({}, T::Hash[ConfiguredArchitecture, SatisfiedResult])
     end
 
     sig { override.returns(LogicNode) }