idlc 0.1.1 → 0.1.5

data/lib/idlc/passes/find_src_registers.rb

@@ -9,7 +9,7 @@ module Idl
 
   class AstNode
     def find_src_registers(symtab)
-      # if is_a?(Executable)
+      # if executable?
       #   value_result = value_try do
       #     execute(symtab)
       #   end
@@ -17,7 +17,7 @@ module Idl
       #     execute_unknown(symtab)
       #   end
       # end
-      add_symbol(symtab) if is_a?(Declaration)
+      add_symbol(symtab) if declaration?
 
       srcs = []
       @children.each do |child|
@@ -27,7 +27,7 @@ module Idl
     end
 
     def find_dst_registers(symtab)
-      # if is_a?(Executable)
+      # if executable?
       #   value_result = value_try do
       #     execute(symtab)
       #   end
@@ -35,7 +35,7 @@ module Idl
       #     execute_unknown(symtab)
       #   end
       # end
-      add_symbol(symtab) if is_a?(Declaration)
+      add_symbol(symtab) if declaration?
 
       srcs = []
       @children.each do |child|
@@ -80,16 +80,20 @@ module Idl
   class AryElementAccessAst
     def find_src_registers(symtab)
       value_result = value_try do
-        if var.text_value == "X"
-          return [index.value(symtab)]
+        var_type = var.type(symtab) rescue nil
+        if var_type&.kind == :array && var_type.sub_type.is_a?(RegFileElementType) && var_type.qualifiers.include?(:global)
+          rf_name = var_type.sub_type.name
+          return [[rf_name, index.value(symtab)]]
         else
           return []
         end
       end
       value_else(value_result) do
-        if var.text_value == "X"
+        var_type = var.type(symtab) rescue nil
+        if var_type&.kind == :array && var_type.sub_type.is_a?(RegFileElementType) && var_type.qualifiers.include?(:global)
+          rf_name = var_type.sub_type.name
           if index.type(symtab).const?
-            return [index.gen_cpp(symtab, 0)]
+            return [[rf_name, index.gen_cpp(symtab, 0)]]
           else
             raise ComplexRegDetermination
           end
@@ -102,22 +106,58 @@ module Idl
 
   class AryElementAssignmentAst
     def find_dst_registers(symtab)
-      value_result = value_try do
-        if lhs.text_value == "X"
-          return [idx.value(symtab)]
+      # Identify the base variable and the register index based on assignment shape.
+      # F[rd] = v    → lhs is IdAst(F),              reg_idx = idx
+      # F[rd][b] = v → lhs is AryElementAccessAst(F[rd]), reg_idx = lhs.index
+      lhs_base, reg_idx =
+        if lhs.is_a?(Idl::IdAst)
+          [lhs, idx]
+        elsif lhs.is_a?(Idl::AryElementAccessAst) && lhs.var.is_a?(Idl::IdAst)
+          [lhs.var, lhs.index]
         else
           return []
         end
+
+      # Only proceed if the base variable is a global array of RegFileElementType.
+      var_type = lhs_base.type(symtab) rescue nil
+      return [] unless var_type&.kind == :array &&
+                       var_type.sub_type.is_a?(RegFileElementType) &&
+                       var_type.qualifiers.include?(:global)
+
+      rf_name = var_type.sub_type.name
+
+      value_result = value_try do
+        return [[rf_name, reg_idx.value(symtab)]]
       end
       value_else(value_result) do
-        if lhs.text_value == "X"
-          if idx.type(symtab).const?
-            return [idx.gen_cpp(symtab, 0)]
-          else
-            raise ComplexRegDetermination
-          end
+        if reg_idx.type(symtab).const?
+          return [[rf_name, reg_idx.gen_cpp(symtab, 0)]]
         else
-          return []
+          raise ComplexRegDetermination
+        end
+      end
+    end
+  end
+
+  class AryRangeAssignmentAst
+    def find_dst_registers(symtab)
+      return [] unless variable.is_a?(Idl::AryElementAccessAst)
+
+      var_type = variable.var.type(symtab) rescue nil
+      return [] unless var_type&.kind == :array &&
+                       var_type.sub_type.is_a?(RegFileElementType) &&
+                       var_type.qualifiers.include?(:global)
+
+      rf_name = var_type.sub_type.name
+
+      value_result = value_try do
+        return [[rf_name, variable.index.value(symtab)]]
+      end
+      value_else(value_result) do
+        if variable.index.type(symtab).const?
+          return [[rf_name, variable.index.gen_cpp(symtab, 0)]]
+        else
+          raise ComplexRegDetermination
         end
       end
     end

data/lib/idlc/passes/prune.rb

@@ -97,23 +97,27 @@ end
 module Idl
   # set up a default
   class AstNode
+    def always_terminates? = false
+
     # forced_type, when not nil, is the type that the pruned result must be
     # if is used when pruning expressions to ensure that the prune doesn't change
     # bit width just because a value is known and would fit in something smaller
     def prune(symtab, forced_type: nil)
       new_children = children.map { |child| child.prune(symtab, forced_type:) }
 
-      new_node = dup
-      new_node.instance_variable_set(:@children, new_children)
-
-      if is_a?(Executable)
+      if executable?
         value_try do
           execute(symtab)
         end
         # value_else: execute raised ValueError; symtab state is already correct
       end
-      add_symbol(symtab) if is_a?(Declaration)
+      add_symbol(symtab) if declaration?
+
+      # avoid allocation when nothing changed
+      return self if !frozen? && new_children.each_with_index.all? { |c, i| c.equal?(children[i]) }
 
+      new_node = dup
+      new_node.instance_variable_set(:@children, new_children)
       new_node
     end
 
@@ -155,7 +159,9 @@ module Idl
           # array var itself is unknown; nothing more to do
         end
       when :bits
-        var = symtab.get(lhs.text_value)
+        root = lhs
+        root = root.var while root.is_a?(AryElementAccessAst) || root.is_a?(AryRangeAccessAst)
+        var = symtab.get(root.name)
         var.value = nil unless var.nil?
       end
     end
@@ -163,7 +169,9 @@ module Idl
   class AryRangeAssignmentAst < AstNode
     def nullify_assignments(symtab)
       return if variable.type(symtab).global?
-      var = symtab.get(variable.name)
+      root = variable
+      root = root.var while root.is_a?(AryElementAccessAst) || root.is_a?(AryRangeAccessAst)
+      var = symtab.get(root.name)
       var.value = nil unless var.nil?
     end
   end
@@ -265,6 +273,9 @@ module Idl
         symtab.restore_values(snapshot)
         symtab.pop
       end
+      # Nullify any outer-scope variable assigned in the loop body, since we
+      # don't know how many iterations ran (or if any ran at all)
+      stmts.each { |stmt| stmt.nullify_assignments(symtab) }
       new_loop
     end
   end
@@ -314,6 +325,14 @@ module Idl
         end
 
         pruned_body = nil
+        prune_stmts = -> {
+          [].tap do |out|
+            statements.each do |s|
+              out << s.prune(symtab)
+              break if out.last.always_terminates?
+            end
+          end
+        }
 
         value_result = value_try do
           # go through the statements, and stop if we find one that returns or raises an exception
@@ -340,10 +359,10 @@ module Idl
             end
           end
 
-          pruned_body = FunctionBodyAst.new(input, interval, statements.map { |s| s.prune(symtab) })
+          pruned_body = FunctionBodyAst.new(input, interval, prune_stmts.())
         end
         value_else(value_result) do
-          pruned_body = FunctionBodyAst.new(input, interval, statements.map { |s| s.prune(symtab) })
+          pruned_body = FunctionBodyAst.new(input, interval, prune_stmts.())
         end
       ensure
         symtab.pop
@@ -353,13 +372,17 @@ module Idl
     end
   end
   class StatementAst < AstNode
+    def always_terminates?
+      action.is_a?(FunctionCallExpressionAst) && action.name == "raise"
+    end
+
     def prune(symtab, forced_type: nil)
       pruned_action = action.prune(symtab)
 
       new_stmt = StatementAst.new(input, interval, pruned_action)
-      pruned_action.freeze_tree(symtab) unless pruned_action.frozen?
+      # pruned_action.freeze_tree(symtab) unless pruned_action.frozen?
 
-      pruned_action.add_symbol(symtab) if pruned_action.is_a?(Declaration)
+      pruned_action.add_symbol(symtab) if pruned_action.declaration?
       # action#prune already handles symtab update (execute)
 
       new_stmt
@@ -466,6 +489,10 @@ module Idl
   end
 
   class IfBodyAst < AstNode
+    def always_terminates?
+      !stmts.empty? && stmts.last.always_terminates?
+    end
+
     def prune(symtab, restore: true, forced_type: nil)
       pruned_stmts = []
       symtab.push(nil)
@@ -473,7 +500,7 @@ module Idl
       stmts.each do |s|
         pruned_stmts << s.prune(symtab)
 
-        break if pruned_stmts.last.is_a?(StatementAst) && pruned_stmts.last.action.is_a?(FunctionCallExpressionAst) && pruned_stmts.last.action.name == "raise"
+        break if pruned_stmts.last.always_terminates?
       end
       if restore
         symtab.restore_values(snapshot)
@@ -542,16 +569,23 @@ module Idl
           end
         end
         # we get here, then we don't know the value of anything. just return this if with everything pruned
+        # After pruning, some elseif conditions may resolve to a literal (e.g., `false && <runtime_csr_read>`
+        # fails value() due to the CSR read but prune() short-circuits the && to false). Filter those out.
+        pruned_elsifs = unknown_elsifs.filter_map do |eif|
+          pruned = eif.prune(symtab)
+          next nil if pruned.cond.is_a?(FalseExpressionAst)
+          pruned
+        end
         result = IfAst.new(
           input, interval,
           if_cond.prune(symtab),
           if_body.prune(symtab),
-          unknown_elsifs.map { |eif| eif.prune(symtab) },
+          pruned_elsifs,
           final_else_body.prune(symtab)
         )
         # Nullify any variable assigned in any branch, since we don't know which ran
         if_body.nullify_assignments(symtab)
-        unknown_elsifs.each { |eif| eif.body.nullify_assignments(symtab) }
+        pruned_elsifs.each { |eif| eif.body.nullify_assignments(symtab) }
         final_else_body.nullify_assignments(symtab)
         result
       end
@@ -578,9 +612,9 @@ module Idl
       value_result = value_try do
         if condition.value(symtab)
           pruned_action = action.prune(symtab)
-          pruned_action.add_symbol(symtab) if pruned_action.is_a?(Declaration)
+          pruned_action.add_symbol(symtab) if pruned_action.declaration?
           value_result = value_try do
-            pruned_action.execute(symtab) if pruned_action.is_a?(Executable)
+            pruned_action.execute(symtab) if pruned_action.executable?
           end
 
           return StatementAst.new(input, interval, pruned_action)
@@ -591,9 +625,9 @@ module Idl
       value_else(value_result) do
         # condition not known
         pruned_action = action.prune(symtab)
-        pruned_action.add_symbol(symtab) if pruned_action.is_a?(Declaration)
+        pruned_action.add_symbol(symtab) if pruned_action.declaration?
         value_result = value_try do
-          pruned_action.execute(symtab) if pruned_action.is_a?(Executable)
+          pruned_action.execute(symtab) if pruned_action.executable?
         end
         # Condition is unknown, so the assignment may not have run; nullify to prevent leakage
         pruned_action.nullify_assignments(symtab)
@@ -832,6 +866,8 @@ module Idl
   end
 
   class ReturnStatementAst < AstNode
+    def always_terminates? = true
+
     def prune(symtab, forced_type: nil)
       ReturnStatementAst.new(input, interval, return_expression.prune(symtab))
     end

data/lib/idlc/passes/reachable_exceptions.rb

@@ -79,8 +79,8 @@ module Idl
         # else
           # 0
         # end
-      action.add_symbol(symtab) if action.is_a?(Declaration)
-      if action.is_a?(Executable)
+      action.add_symbol(symtab) if action.declaration?
+      if action.executable?
         value_try do
           action.execute(symtab)
         end
@@ -162,8 +162,8 @@ module Idl
         mask |= condition.reachable_exceptions(symtab, cache)
         if condition.value(symtab)
           mask |= action.reachable_exceptions(symtab, cache)
-          action.add_symbol(symtab) if action.is_a?(Declaration)
-          if action.is_a?(Executable)
+          action.add_symbol(symtab) if action.declaration?
+          if action.executable?
             value_result = value_try do
               action.execute(symtab)
             end
@@ -175,8 +175,8 @@ module Idl
         # condition not known
         mask |= condition.reachable_exceptions(symtab, cache)
         mask |= action.reachable_exceptions(symtab, cache)
-        action.add_symbol(symtab) if action.is_a?(Declaration)
-        if action.is_a?(Executable)
+        action.add_symbol(symtab) if action.declaration?
+        if action.executable?
           value_result = value_try do
             action.execute(symtab)
           end

data/lib/idlc/passes/reachable_functions.rb

@@ -82,9 +82,9 @@ module Idl
     def reachable_functions(symtab, cache = T.let({}, ReachableFunctionCacheType))
       fns = action.reachable_functions(symtab, cache)
 
-      action.add_symbol(symtab) if action.is_a?(Declaration)
+      action.add_symbol(symtab) if action.declaration?
       value_try do
-        action.execute(symtab) if action.is_a?(Executable)
+        action.execute(symtab) if action.executable?
       rescue SystemStackError
         type_error "Detected unbounded recursion during compile-time constant evaluation at #{input_file}:#{input_line}.. This recursion cannot be represented or validated."
       end

data/lib/idlc/symbol_table.rb

@@ -208,10 +208,12 @@ module Idl
         builtin_funcs: T.nilable(BuiltinFunctionCallbacks),
         csrs: T::Array[Csr],
         params: T::Array[RuntimeParam],
-        name: String
+        name: String,
+        register_files: T::Array[T.untyped],
+        register_file_max_widths: T::Hash[String, Integer]
       ).void
     }
-    def initialize(mxlen: nil, possible_xlens_cb: nil, builtin_global_vars: [], builtin_enums: [], builtin_funcs: nil, csrs: [], params: [], name: "")
+    def initialize(mxlen: nil, possible_xlens_cb: nil, builtin_global_vars: [], builtin_enums: [], builtin_funcs: nil, csrs: [], params: [], name: "", register_files: [], register_file_max_widths: {})
       @mutex = Thread::Mutex.new
       @mxlen = mxlen
       @possible_xlens_cb = possible_xlens_cb
@@ -221,11 +223,6 @@ module Idl
 
       # builtin types
       @scopes = [{
-        "X" => Var.new(
-          "X",
-          Type.new(:array, sub_type: XregType.new(@mxlen.nil? ? 64 : @mxlen), width: 32, qualifiers: [:global])
-        ),
-        "XReg" => XregType.new(@mxlen.nil? ? 64 : @mxlen),
         "Boolean" => Type.new(:boolean),
         "true" => Var.new(
           "true",
@@ -237,8 +234,29 @@ module Idl
           Type.new(:boolean),
           false
         )
-
       }]
+      # @params must be set before the register_files loop so that param schema
+      # max lookups (used to compute int_width for dynamic-width register files)
+      # can access @params without triggering a cfg_arch.symtab circular dependency.
+      @params = params
+
+      # Register file globals (X, F, V, etc.) from YAML-derived register file objects.
+      # Each RF provides: .name (String), .register_length (IDL body String), .registers.count (Integer).
+      register_files.each do |rf|
+        int_width = if register_file_max_widths.key?(rf.name)
+          register_file_max_widths[rf.name]
+        else
+          # Fallback for callers without pre-computed widths (CLI, tests with literal-width RFs).
+          # eval_register_length_idl handles literals ("return 64;") and simple MXLEN references.
+          w = eval_register_length_idl(rf.register_length)
+          w.is_a?(Integer) ? w : raise("Cannot determine max register width for '#{rf.name}'. " \
+                                        "Pass register_file_max_widths: to SymbolTable.new.")
+        end
+        elem_type = RegFileElementType.new(rf.name, int_width, max_width: int_width)
+        array_type = Type.new(:array, sub_type: elem_type, width: rf.registers.count, qualifiers: [:global])
+        @scopes[0][rf.name] = Var.new(rf.name, array_type)
+        @scopes[0]["#{rf.name}Reg"] = elem_type
+      end
       builtin_global_vars.each do |v|
         add!(v.name, v)
       end
@@ -248,12 +266,35 @@ module Idl
       @builtin_funcs = builtin_funcs
       @csrs = csrs
       @csr_hash = @csrs.map { |csr| [csr.name.freeze, csr].freeze }.to_h.freeze
-      @params = params
 
       # set up the global clone that be used as a mutable table
       @global_clone_pool = T.let([], T::Array[SymbolTable])
     end
 
+    # Compile and evaluate the IDL function body string that defines register width.
+    # Returns an Integer if statically known, or the expression string if dynamic.
+    # @param idl_body [String] e.g. "return 64;" or "return MXLEN;"
+    #
+    # NOTE: The body-stripping logic here (strip 'return', strip ';', match literal/MXLEN)
+    # is intentionally duplicated in Udb::RegisterFile#register_length_expr and
+    # Udb::RegisterFile#eval_register_length (udb gem). Changes here must be mirrored there.
+    # idlc cannot depend on udb (udb depends on idlc), so a shared utility is not possible
+    # without an additional gem layer.
+    def eval_register_length_idl(idl_body)
+      # Strip 'return' and ';'
+      expr = idl_body.strip.sub(/\Areturn\s+/, "").sub(/;\z/, "").strip
+      case expr
+      when /\A\d+\z/
+        expr.to_i
+      when /\AMXLEN\z/
+        @mxlen || 64
+      else
+        # Dynamic parameter — return the parameter name as a String
+        expr
+      end
+    end
+    private :eval_register_length_idl
+
     # @return [String] inspection string
     sig { returns(String) }
     def inspect

data/lib/idlc/syntax_node.rb

@@ -18,18 +18,12 @@ module Treetop
       # @param starting_line [Integer] Starting line in the file
       # @param starting_offset [Integer] Starting byte offset in the file
       # @param line_file_offsets [Array<Integer>, nil] Per-IDL-line file byte offsets
-      sig { params(filename: T.nilable(String), starting_line: Integer, starting_offset: Integer, line_file_offsets: T.nilable(T::Array[Integer])).void }
+      sig { params(filename: T.nilable(String), starting_line: Integer, starting_offset: Integer, line_file_offsets: T.nilable(T::Array[Integer])).void.checked(:never) }
       def set_input_file(filename, starting_line = 0, starting_offset = 0, line_file_offsets = nil)
         @input_file = filename
         @starting_line = starting_line
         @starting_offset = starting_offset
         @line_file_offsets = line_file_offsets
-        elements&.each do |child|
-          # Adjust the starting offset for each child based on its position in the input
-          child_offset = starting_offset + child.interval.first
-          child.set_input_file(filename, starting_line, child_offset, line_file_offsets)
-        end
-        raise "?" if @starting_line.nil?
       end
 
       sig { returns(T::Boolean) }
@@ -43,7 +37,7 @@ module Treetop
       # @param [Integer] starting_line The starting line number in the input file.
       # @param [Integer] starting_offset The starting byte offset in the input file.
       # @param [Array<Integer>, nil] line_file_offsets Per-IDL-line file byte offsets
-      sig { params(filename: T.nilable(String), starting_line: Integer, starting_offset: Integer, line_file_offsets: T.nilable(T::Array[Integer])).void }
+      sig { params(filename: T.nilable(String), starting_line: Integer, starting_offset: Integer, line_file_offsets: T.nilable(T::Array[Integer])).void.checked(:never) }
       def set_input_file_unless_already_set(filename, starting_line = 0, starting_offset = 0, line_file_offsets = nil)
         if @input_file.nil?
           set_input_file(filename, starting_line, starting_offset, line_file_offsets)

data/lib/idlc/type.rb

@@ -65,7 +65,7 @@ module Idl
       if @kind == :array
         T.must(@sub_type).runtime?
       else
-        @kind == :bits && @width == :unknown
+        @kind == :bits && !@width.is_a?(Integer)
       end
     end
 
@@ -963,19 +963,24 @@ module Idl
     def body = @func_def_ast.body
   end
 
-  # XReg is really a Bits<> type, so we override it just to get
-  # prettier prints
-  class XregType < Type
-    def initialize(xlen)
-      super(:bits, width: xlen, max_width: 64)
-    end
+  # General-purpose register file element type.
+  # Represents the type of one element in a named register file (e.g. F, V, X).
+  class RegFileElementType < Type
+    attr_reader :name
 
-    def to_s
-      "XReg"
+    def initialize(name, width, max_width: nil)
+      super(:bits, width:, max_width: max_width || width)
+      @name = name
     end
 
-    def to_cxx
-      "XReg"
+    def to_s = "#{name}Reg"
+    def to_cxx = "#{name}Reg"
+  end
+
+  # XReg is really a Bits<> type -- keep as a named alias for backwards compatibility
+  class XregType < RegFileElementType
+    def initialize(xlen)
+      super("X", xlen, max_width: 64)
     end
   end
 

data/lib/idlc/version.rb

@@ -5,6 +5,6 @@
 
 module Idl
   class Compiler
-    def self.version = "0.1.1"
+    def self.version = "0.1.5"
   end
 end

data/lib/idlc.rb

@@ -55,6 +55,14 @@ module Idl
 
     attr_reader :parser
 
+    # Class-level parse cache: absolute file path (String) → IsaSyntaxNode.
+    # Shared across all Compiler instances so each file is parsed only once per
+    # process.  Safe to share because IsaSyntaxNode#to_ast is non-destructive
+    # and returns a fresh, independent IsaAst on every call.
+    # Mutex guards writes; under MRI, reads without the lock are safe.
+    @@parse_cache = {}
+    @@parse_cache_mutex = Mutex.new
+
     def initialize
       @parser = ::IdlParser.new
     end
@@ -71,40 +79,56 @@ module Idl
     end
 
     def compile_file(path, source_mapper = nil)
-      @parser.set_input_file(path.to_s)
+      path_key = path.realpath.to_s
 
-      unless source_mapper.nil?
-        source_mapper[path.to_s] = path.read
-      end
-
-      old_format = @pb.format unless @pb.nil?
-      @pb.format = "Parsing #{File.basename(path)} [:bar]" unless @pb.nil?
-      pid = unless @pb.nil?
-              fork {
-                loop do
-                  sleep 1
-                  @pb.advance unless @pb.nil?
-                end
-              }
-      end
-      m = @parser.parse path.read
-      unless @pb.nil?
-        Process.kill("TERM", T.must(pid))
-        Process.wait(T.must(pid))
-        @pb.format = old_format
-      end
+      m = T.let(@@parse_cache[path_key], T.nilable(IsaSyntaxNode))
 
       if m.nil?
-        raise SyntaxError, <<~MSG
-          While parsing #{@parser.input_file}:#{@parser.failure_line}:#{@parser.failure_column}
-
-          #{@parser.failure_reason}
-        MSG
+        @@parse_cache_mutex.synchronize do
+          # Re-check inside the lock in case another thread just populated the entry.
+          unless @@parse_cache.key?(path_key)
+            @parser.set_input_file(path_key)
+
+            content = path.read
+            source_mapper[path_key] = content unless source_mapper.nil?
+
+            old_format = @pb.format unless @pb.nil?
+            @pb.format = "Parsing #{File.basename(path)} [:bar]" unless @pb.nil?
+            pid = unless @pb.nil?
+                    fork {
+                      loop do
+                        sleep 1
+                        @pb.advance unless @pb.nil?
+                      end
+                    }
+                  end
+            m = @parser.parse(content)
+            unless @pb.nil?
+              Process.kill("TERM", T.must(pid))
+              Process.wait(T.must(pid))
+              @pb.format = old_format
+            end
+
+            if m.nil?
+              raise SyntaxError, <<~MSG
+                While parsing #{@parser.input_file}:#{@parser.failure_line}:#{@parser.failure_column}
+
+                #{@parser.failure_reason}
+              MSG
+            end
+
+            raise "unexpected type #{m.class.name}" unless m.is_a?(IsaSyntaxNode)
+
+            @@parse_cache[path_key] = m
+          end
+          m = @@parse_cache[path_key]
+        end
+      else
+        # Cache hit: still populate source_mapper if provided (test-only path).
+        source_mapper[path_key] = path.read unless source_mapper.nil?
       end
 
-      raise "unexpected type #{m.class.name}" unless m.is_a?(IsaSyntaxNode)
-
-      ast = m.to_ast
+      ast = T.must(m).to_ast
 
       ast.children.each do |child|
         next unless child.is_a?(IncludeStatementAst)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: idlc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.5
 platform: ruby
 authors:
 - Derek Hower
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-17 00:00:00.000000000 Z
+date: 2026-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -372,7 +371,6 @@ metadata:
   homepage_uri: https://github.com/riscv/riscv-unified-db
   mailing_list_uri: https://lists.riscv.org/g/tech-unifieddb
   bug_tracker_uri: https://github.com/riscv/riscv-unified-db/issues
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -387,8 +385,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: ISA Description Language Compiler
 test_files: []