udb 0.1.13 → 0.1.15

data/.data/spec/std/isa/param/TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT.yaml

@@ -7,7 +7,7 @@ $schema: param_schema.json#
 kind: parameter
 name: TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT
 description: |
-  Value to write into htval/mtval2 when there is a guest page fault on a final translation.
+  Value written into htinst/mtinst when there is a load guest-page fault on a final translation.
 
   Possible values:
     * "always zero": Always write the value zero

data/.data/spec/std/isa/param/TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT.yaml

@@ -7,7 +7,7 @@ $schema: param_schema.json#
 kind: parameter
 name: TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT
 description: |
-  Value to write into htval/mtval2 when there is a guest page fault on a final translation.
+  Value written into htinst/mtinst when there is a store/AMO guest-page fault on a final translation.
 
   Possible values:
     * "always zero": Always write the value zero

data/.data/spec/std/isa/param/TINST_VALUE_ON_LOAD_ADDRESS_MISALIGNED.yaml

@@ -7,7 +7,7 @@ $schema: param_schema.json#
 kind: parameter
 name: TINST_VALUE_ON_LOAD_ADDRESS_MISALIGNED
 description: |
-  Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode.
+  Value written into htinst/mtinst on a LoadAddressMisaligned exception from VU/VS-mode.
 
   Possible values:
     * "always zero": Always write the value zero

data/.data/spec/std/isa/param/TINST_VALUE_ON_STORE_AMO_ADDRESS_MISALIGNED.yaml

@@ -7,7 +7,7 @@ $schema: param_schema.json#
 kind: parameter
 name: TINST_VALUE_ON_STORE_AMO_ADDRESS_MISALIGNED
 description: |
-  Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode.
+  Value written into htinst/mtinst on a StoreAmoAddressMisaligned exception from VU/VS-mode.
 
   Possible values:
     * "always zero": Always write the value zero

data/.data/spec/std/isa/param/TRAP_ON_EBREAK.yaml

@@ -15,3 +15,4 @@ description: |
   without raising a trap, in which case the EEI must provide a builtin.
 schema:
   type: boolean
+  default: true

data/.data/spec/std/isa/param/TRAP_ON_ECALL_FROM_M.yaml

@@ -15,3 +15,4 @@ description: |
   without raising a trap, in which case the EEI must provide a builtin.
 schema:
   type: boolean
+  default: true

data/.data/spec/std/isa/param/TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY.yaml

@@ -20,6 +20,7 @@ description: |
 long_name: TODO
 schema:
   type: boolean
+  default: false
 definedBy:
   extension:
     allOf:

data/.data/spec/std/isa/param/UXLEN.yaml

@@ -7,7 +7,7 @@ $schema: param_schema.json#
 kind: parameter
 name: UXLEN
 description: |
-  Set of XLENs supported in U-mode. When both 32 and 64 are supported, SXLEN can be changed,
+  Set of XLENs supported in U-mode. When both 32 and 64 are supported, UXLEN can be changed,
   via mstatus.UXL, between 32 and 64.
 long_name: TODO
 schema:

data/.data/spec/std/isa/param/VLEN.yaml

@@ -8,15 +8,24 @@ kind: parameter
 name: VLEN
 description: |
   The number of bits in a single vector register.
-long_name: TODO
+long_name: vector register bit width
 schema:
   type: integer
-  minimum: 32
-  maximum: 65536
-#    requirements:
-#      idl(): |
-#        -> (VLEN >= ELEN) && (VLEN <='h10000) && (popcount(VLEN) == 1);
-#      reason: VLEN >= ELEN, which must be a power of 2, and must be no greater than 2^16.
+  enum:
+    [
+      0x20,
+      0x40,
+      0x80,
+      0x100,
+      0x200,
+      0x400,
+      0x800,
+      0x1000,
+      0x2000,
+      0x4000,
+      0x8000,
+      0x10000,
+    ]
 definedBy:
   extension:
     name: Zvl32b

data/.data/spec/std/isa/param/VSTVEC_MODES.yaml

@@ -0,0 +1,31 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: VSTVEC_MODES
+long_name: |
+  Modes supported by `vstvec.MODE`
+definedBy:
+  extension:
+    name: H
+description: |
+  Options:
+
+    0::
+      Direct; All traps set `pc` to `vstvec.BASE`
+    1::
+      Vectored; Asynchronous interrupts set `pc` to `vstvec.BASE` + 4 x cause.
+
+  If only one mode is given, `vstvec.MODE` is assumed to be read-only with that value.
+  Otherwise, `vstvec.MODE` is read-write.
+schema:
+  type: array
+  items:
+    type: integer
+    enum: [0, 1]
+  minItems: 1
+  maxItems: 2
+  uniqueItems: true

data/.data/spec/std/isa/param/ZAWRS_NTO_IS_NOP.yaml

@@ -0,0 +1,19 @@
+# Copyright (c) 2025-26 Harvey Mudd College
+# Author: Ellen Yu (ellyu@hmc.edu)
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: ZAWRS_NTO_IS_NOP
+description: |
+  When true, WRS.NTO completes immediately, behaving as a no-op, rather than
+  stalling the hart.
+
+long_name: TODO
+schema:
+  type: boolean
+definedBy:
+  extension:
+    name: Zawrs

data/lib/udb/ESPRESSO_VERSION

@@ -1 +1 @@
-espresso-1.0
+espresso-18f59c7

data/lib/udb/Z3_VERSION

@@ -1 +1 @@
-z3-4.16.0
+z3-5.0.0

data/lib/udb/config.rb

@@ -417,13 +417,25 @@ module Udb
         else
           @data["implemented_extensions"].map do |e|
             if e.is_a?(Array)
-              { "name" => e[0], "version" => e[1] }
+              { "name" => e[0], "version" => implemented_extension_version(e[1]) }
             elsif e.is_a?(Hash)
-              { "name" => e.fetch("name"), "version" => RequirementSpec.new(e.fetch("version")).version_spec.to_s }
+              { "name" => e.fetch("name"), "version" => implemented_extension_version(e.fetch("version")) }
             end
           end
         end
     end
 
+    private
+
+    sig { params(version: String).returns(String) }
+    def implemented_extension_version(version)
+      version_str = version.strip
+      if version_str.start_with?("=")
+        RequirementSpec.new(version_str).version_spec.to_s
+      else
+        VersionSpec.new(version_str).to_s
+      end
+    end
+
   end
 end

data/lib/udb/doc_link.rb

@@ -33,12 +33,11 @@
 module Udb
   class DocLink
     # @param dst_link [String] The documentation link provided in the YAML
-    # @param db_obj [String] Database object
+    # @param db_obj [Object] Database object
     def initialize(dst_link, db_obj)
-      raise ArgumentError, "Need String but was passed a #{data.class}" unless dst_link.is_a?(String)
+      raise ArgumentError, "Missing documentation link for #{db_obj.name} of kind #{db_obj.kind}" if dst_link.nil?
+      raise ArgumentError, "Need String but was passed a #{dst_link.class}" unless dst_link.is_a?(String)
       @dst_link = dst_link
-
-      raise ArgumentError, "Missing documentation link for #{db_obj.name} of kind #{db_obj.kind}" if @dst_link.nil?
     end
 
     # @return [String] Unique ID of the linked to normative rule

data/lib/udb/obj/csr.rb

@@ -198,7 +198,7 @@ module Udb
         # VSXLEN condition applies if VS-mode is possible
         (cfg_arch.mxlen.nil?) || \
         (cfg_arch.possible_extensions.map(&:name).include?("S") && \
-          (cfg_arch.param_values["SXLEN"].nil? || cfg_arch.param_values["SXLEN"].size > 1)) && \
+          (cfg_arch.param_values["SXLEN"].nil? || cfg_arch.param_values["SXLEN"].size > 1)) || \
         (cfg_arch.possible_extensions.map(&:name).include?("H") && \
           (cfg_arch.param_values["VSXLEN"].nil? || cfg_arch.param_values["VSXLEN"].size > 1))
       else

data/lib/udb/obj/csr_field.rb

@@ -715,7 +715,7 @@ module Udb
     sig { override.returns(T::Boolean) }
     def defined_in_base64? = base != 32
 
-    sig { params(xlen: Integer).returns(T::Boolean) }
+    sig { override.params(xlen: Integer).returns(T::Boolean) }
     def defined_in_base?(xlen) = xlen == 32 ? defined_in_base32? : defined_in_base64?
 
     # @return [Boolean] Whether or not this field exists for any XLEN

data/lib/udb/obj/extension.rb

@@ -403,7 +403,7 @@ module Udb
     sig { override.params(other_ext: Object).returns(T.nilable(Integer)).checked(:never) }
     def <=>(other_ext)
       return nil unless other_ext.is_a?(Extension)
-      other_ext.name <=> name
+      name <=> other_ext.name
     end
 
     # returns list of exception codes that are defined by any version of this extension

data/lib/udb/obj/instruction.rb

@@ -791,7 +791,7 @@ module Udb
         @left_shift = field_data["left_shift"].nil? ? 0 : field_data["left_shift"]
         @sext = field_data["sign_extend"].nil? ? false : field_data["sign_extend"]
         @alias = field_data["alias"].nil? ? nil : field_data["alias"]
-        @location = field_data["location"]
+        @location = field_data["location"].to_s
         extract_location(field_data["location"])
         @excludes =
           if field_data.key?("not")

data/lib/udb/obj/non_isa_specification.rb

@@ -143,72 +143,19 @@ class NonIsaSpecification
     )
   end
 
-  # Validation methods
-  sig { returns(T::Array[String]) }
-  # Validate all prose statement IDs and conventions for this spec.
-  def validate_prose_ids
-    return [] unless valid?
-
-    issues = []
-    statements = extract_prose_statements
-    statements.each do |stmt|
-      next unless stmt['id']
-      id = stmt['id']
-      source = stmt[:source] || 'unknown'
-
-      # Check ID format according to prose-schema conventions
-      unless valid_id_format?(id)
-        issues << "Invalid ID format '#{id}' in #{source}: must be lowercase with underscores/hyphens only"
-      end
-
-      # Check for non-ISA specification naming convention
-      unless valid_id_naming?(id)
-        issues << "ID '#{id}' in #{source} should start with '#{name.downcase}-' for non-ISA specifications"
-      end
-    end
-
-    # Check for duplicate IDs
-    issues.concat(find_duplicate_ids(statements))
-    issues
-  end
-
-  sig { params(include_sections: T::Boolean).returns(T::Array[T::Hash[T.any(String, Symbol), T.untyped]]) }
-  # Extract all prose statements from description and sections, tagging their source.
-  def extract_prose_statements(include_sections: true)
-    statements = []
-    # Extract from description
-    if spec_description.is_a?(Array)
-      spec_description.each_with_index { |stmt, i| statements << stmt.merge(source: "description[#{i}]") if stmt.is_a?(Hash) }
-    end
-    # Extract from sections
-    if include_sections
-      sections.each_with_index do |section, section_idx|
-        next unless section['content'].is_a?(Array)
-        section['content'].each_with_index do |stmt, stmt_idx|
-          statements << stmt.merge(source: "sections[#{section_idx}].content[#{stmt_idx}]") if stmt.is_a?(Hash)
-        end
-      end
-    end
-    statements
-  end
-
   # Rendering methods
   sig do
     params(
       cfg_arch: T.untyped,
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean
     ).returns(String)
   end
   # Configuration-aware rendering
-  def render_for_cfg(cfg_arch, base_level: 3, normative: true, non_normative: true)
+  def render_for_cfg(cfg_arch, base_level: 3)
     return "" unless exists_in_cfg?(cfg_arch)
 
     to_asciidoc(
       base_level: base_level,
-      normative: normative,
-      non_normative: non_normative,
       when_callback: create_when_callback(cfg_arch)
     )
   end
@@ -216,24 +163,22 @@ class NonIsaSpecification
   sig do
     params(
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(String)
   end
   # Render the full specification as AsciiDoc, including description, sections, and references.
-  def to_asciidoc(base_level: 3, normative: true, non_normative: true, when_callback: nil)
+  def to_asciidoc(base_level: 3, when_callback: nil)
     return create_fallback_content(base_level) unless valid?
 
     content = []
 
     # Add main description prose
-    desc_content = render_structured_prose(spec_description, normative: normative, non_normative: non_normative, when_callback: when_callback)
+    desc_content = render_structured_prose(spec_description, when_callback: when_callback)
     content << desc_content if desc_content && !desc_content.empty?
     content << ""
 
     # Process all sections
-    content.concat(render_sections(base_level, normative, non_normative, when_callback))
+    content.concat(render_sections(base_level, when_callback))
 
     # Add references section if present
     content.concat(render_references(base_level)) unless references.empty?
@@ -243,50 +188,22 @@ class NonIsaSpecification
 
   private
 
-  # Validation helper methods
-  sig { params(id: String).returns(T::Boolean) }
-  # IDs must be lowercase, start with a letter, and use only underscores/hyphens.
-  def valid_id_format?(id)
-    id.match?(/^[a-z][a-z0-9_-]*$/)
-  end
-
-  sig { params(id: String).returns(T::Boolean) }
-  # IDs should start with spec name or allowed prefixes for non-ISA specs.
-  def valid_id_naming?(id)
-    id.start_with?(name.downcase) || id.match?(/^(ext|inst|csr)-/)
-  end
-
-  sig { params(statements: T::Array[T::Hash[T.any(String, Symbol), T.untyped]]).returns(T::Array[String]) }
-  # Find duplicate IDs in the statements array.
-  def find_duplicate_ids(statements)
-    issues = []
-    id_counts = Hash.new(0)
-    statements.each { |stmt| id_counts[stmt['id']] += 1 if stmt['id'] }
-    id_counts.each do |id, count|
-      next if count == 1
-      issues << "Duplicate ID '#{id}' appears #{count} times"
-    end
-    issues
-  end
-
   # Rendering helper methods
   sig do
     params(
       base_level: Integer,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(T::Array[String])
   end
   # Render all sections, adjusting heading levels and filtering by callback.
-  def render_sections(base_level, normative, non_normative, when_callback)
+  def render_sections(base_level, when_callback)
     content = []
     sections.each do |section|
       next unless should_include_section?(section, when_callback)
       level = section['level'] || (base_level + 1)
       content << "#{'=' * level} #{section['title']}"
       content << ""
-      section_content = render_structured_prose(section['content'], normative: normative, non_normative: non_normative, when_callback: when_callback)
+      section_content = render_structured_prose(section['content'], when_callback: when_callback)
       content << section_content if section_content && !section_content.empty?
       content << ""
     end
@@ -311,29 +228,34 @@ class NonIsaSpecification
   sig do
     params(
       prose_content: T.untyped,
-      normative: T::Boolean,
-      non_normative: T::Boolean,
       when_callback: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
     ).returns(T.nilable(String))
   end
-  # Render an array of prose statements as AsciiDoc, filtering by normative and conditional status.
-  def render_structured_prose(prose_content, normative: true, non_normative: true, when_callback: nil)
+  # Render an array of prose statements as AsciiDoc.
+  def render_structured_prose(prose_content, when_callback: nil)
     return nil if prose_content.nil?
+
+    # Handle simple string (Asciidoc source)
+    return prose_content if prose_content.is_a?(String)
+
     return "" unless prose_content.is_a?(Array)
 
     rendered_statements = []
     prose_content.each do |statement|
-      next unless statement.is_a?(Hash) && statement['id'] && statement['text']
+      text = nil
+      condition = nil
+
+      next unless statement.is_a?(Hash)
+
+      text = statement['text']
+      condition = statement['when()']
 
-      # Filter by normative status
-      stmt_normative = statement['normative']
-      next if stmt_normative == true && !normative
-      next if stmt_normative == false && !non_normative
+      next unless text
 
       # Filter by when condition
-      next if when_callback && !when_callback.call(statement['when()'], statement)
+      next if when_callback && !when_callback.call(condition, statement)
 
-      rendered_statements << statement['text']
+      rendered_statements << text
     end
     rendered_statements.join("\n\n")
   end

data/lib/udb/version.rb

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

data/lib/udb/version_spec.rb

@@ -114,7 +114,7 @@ module Udb
     sig { params(other: T.untyped).returns(T.nilable(Integer)).checked(:never) }
     def <=>(other)
       if other.is_a?(String)
-        VersionSpec.new(other) <=> self
+        self <=> VersionSpec.new(other)
       elsif other.is_a?(VersionSpec)
         if @major != other.major
           @major <=> other.major

data/lib/udb/z3.rb

@@ -318,12 +318,13 @@ module Udb
   # Supported JSON schema features:
   # - Type constraints (boolean, integer, string, array)
   # - Value constraints (const, enum, minimum, maximum)
-  # - Composition (allOf)
+  # - Composition (allOf; anyOf for boolean, integer, and string)
   # - References ($ref to uint32/uint64)
   # - Array constraints (items, minItems, maxItems, contains, uniqueItems)
   #
   # Not yet supported (TODO):
-  # - anyOf, oneOf, noneOf (would require disjunctive constraints)
+  # - anyOf for array
+  # - oneOf, noneOf
   # - if/then/else (conditional schemas)
   class Z3ParameterTerm
     extend T::Sig
@@ -341,6 +342,7 @@ module Udb
     # - enum: one of several values
     # - minimum/maximum: range bounds (unsigned comparison)
     # - allOf: conjunction of subschemas
+    # - anyOf: inclusive disjunction of subschemas (at least one must hold)
     # - $ref: references to uint32/uint64 types
     #
     # @param solver [Z3Solver] The solver to add assertions to
@@ -385,12 +387,15 @@ module Udb
 
       if schema_hsh.key?("allOf")
         schema_hsh.fetch("allOf").each do |h|
-          assertions += constrain_int(solver, term, h)
+          assertions += constrain_int(solver, term, h, assert: false)
         end
       end
 
       if schema_hsh.key?("anyOf")
-        raise "TODO: anyOf not yet implemented for integer constraints"
+        branches = schema_hsh.fetch("anyOf").map do |h|
+          constrain_int(solver, term, h, assert: false)
+        end
+        assertions << any_of_constraint(branches)
       end
 
       if schema_hsh.key?("oneOf")
@@ -433,6 +438,7 @@ module Udb
     # Handles JSON schema keywords:
     # - const: exact boolean value
     # - allOf: conjunction of subschemas
+    # - anyOf: inclusive disjunction of subschemas (at least one must hold)
     #
     # @param solver [Z3Solver] The solver to add assertions to
     # @param term [Z3::BoolExpr] The Z3 boolean term to constrain
@@ -458,12 +464,15 @@ module Udb
 
       if schema_hsh.key?("allOf")
         schema_hsh.fetch("allOf").each do |h|
-          assertions += constrain_bool(solver, term, h)
+          assertions += constrain_bool(solver, term, h, assert: false)
         end
       end
 
       if schema_hsh.key?("anyOf")
-        raise "TODO: anyOf not yet implemented for boolean constraints"
+        branches = schema_hsh.fetch("anyOf").map do |h|
+          constrain_bool(solver, term, h, assert: false)
+        end
+        assertions << any_of_constraint(branches)
       end
 
       if schema_hsh.key?("oneOf")
@@ -492,6 +501,7 @@ module Udb
     # Handles JSON schema keywords:
     # - const: exact string value (compared via hash)
     # - enum: one of several string values (compared via hash)
+    # - anyOf: inclusive disjunction of subschemas (at least one must hold)
     #
     # @param solver [Z3Solver] The solver to add assertions to
     # @param term [Z3::IntExpr] The Z3 integer term representing the string hash
@@ -526,7 +536,10 @@ module Udb
       end
 
       if schema_hsh.key?("anyOf")
-        raise "TODO: anyOf not yet implemented for string constraints"
+        branches = schema_hsh.fetch("anyOf").map do |h|
+          constrain_string(solver, term, h, assert: false)
+        end
+        assertions << any_of_constraint(branches)
       end
 
       if schema_hsh.key?("oneOf")
@@ -547,6 +560,15 @@ module Udb
       assertions
     end
 
+    sig { params(branches: T::Array[T::Array[Z3::BoolExpr]]).returns(Z3::BoolExpr) }
+    def self.any_of_constraint(branches)
+      expressions = branches.map do |branch|
+        branch.reduce(Z3.True) { |expression, assertion| expression & assertion }
+      end
+      expressions.reduce(Z3.False) { |expression, branch| expression | branch }
+    end
+    private_class_method :any_of_constraint
+
     # Extract array constraints from JSON schema
     #
     # Processes JSON schema array keywords and returns an ArrayConstraints object
@@ -1125,8 +1147,8 @@ module Udb
       @solver = T.let(Z3::Solver.new, Z3::Solver)
 
       # Stacks for incremental solving with push/pop
-      @ext_vers = T.let([{}], T::Array[T::Hash[String, Z3ExtensionVersion]])
-      @ext_reqs = T.let([{}], T::Array[T::Hash[String, Z3ExtensionRequirement]])
+      @ext_vers = T.let([{}], T::Array[T::Hash[Integer, Z3ExtensionVersion]])
+      @ext_reqs = T.let([{}], T::Array[T::Hash[Integer, Z3ExtensionRequirement]])
       @param_terms = T.let([{}], T::Array[T::Hash[String, Z3ParameterTerm]])
 
       # Extension version component terms (shared across versions of same extension)