udb 0.1.15 → 0.1.17

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

@@ -0,0 +1,40 @@
+# 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: SUPPORTED_PMLEN_SMMPM
+description: |
+  The `PMLEN` values supported by the `Smmpm` pointer masking facility
+  for M-mode, selected via the `PMM` field in `mseccfg`. `PMLEN` is the
+  number of high-order bits of an address that are masked.
+
+  Options:
+
+    0::
+      PMLEN=0 (pointer masking is disabled)
+    7::
+      PMLEN=XLEN-57 (i.e., PMLEN=7 on RV64)
+    16::
+      PMLEN=XLEN-48 (i.e., PMLEN=16 on RV64)
+
+  The current standard only supports these values (`zpm.adoc`, tag
+  `norm:pmlen_supported_values`). `PMM`=00 (pointer masking disabled,
+  PMLEN=0) is mandatory and always available, so it is mandatory
+  here.
+long_name: Pointer mask length for M mode
+schema:
+  type: array
+  items:
+    type: integer
+    enum: [0, 7, 16]
+  contains:
+    const: 0
+  minItems: 1
+  maxItems: 3
+  uniqueItems: true
+definedBy:
+  extension:
+    name: Smmpm

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

@@ -0,0 +1,42 @@
+# 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: SUPPORTED_PMLEN_SMNPM
+description: |
+  The `PMLEN` values supported by the `Smnpm` pointer masking facility
+  for the next privilege mode below M-mode (S/HS if S-mode is
+  implemented, or U-mode otherwise), selected via the `PMM` field in
+  `menvcfg`. `PMLEN` is the number of high-order bits of an address
+  that are masked.
+
+  Options:
+
+    0::
+      PMLEN=0 (pointer masking is disabled)
+    7::
+      PMLEN=XLEN-57 (i.e., PMLEN=7 on RV64)
+    16::
+      PMLEN=XLEN-48 (i.e., PMLEN=16 on RV64)
+
+  The current standard only supports these values (`zpm.adoc`, tag
+  `norm:pmlen_supported_values`). `PMM`=00 (pointer masking disabled,
+  PMLEN=0) is mandatory and always available, so it is mandatory
+  here.
+long_name: Pointer mask length for next mode below M mode
+schema:
+  type: array
+  items:
+    type: integer
+    enum: [0, 7, 16]
+  contains:
+    const: 0
+  minItems: 1
+  maxItems: 3
+  uniqueItems: true
+definedBy:
+  extension:
+    name: Smnpm

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

@@ -0,0 +1,42 @@
+# 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: SUPPORTED_PMLEN_SSNPM
+description: |
+  The `PMLEN` values supported by the `Ssnpm` pointer masking facility
+  for the next privilege mode below S-mode (U-mode, and VS-/VU-modes if
+  the H extension is present), selected via the `PMM` field in
+  `senvcfg`. `PMLEN` is the number of high-order bits of an address
+  that are masked.
+
+  Options:
+
+    0::
+      PMLEN=0 (pointer masking is disabled)
+    7::
+      PMLEN=XLEN-57 (i.e., PMLEN=7 on RV64)
+    16::
+      PMLEN=XLEN-48 (i.e., PMLEN=16 on RV64)
+
+  The current standard only supports these values (`zpm.adoc`, tag
+  `norm:pmlen_supported_values`). `PMM`=00 (pointer masking disabled,
+  PMLEN=0) is mandatory and always available, so it is mandatory
+  here.
+long_name: Pointer mask length for next mode below S-mode
+schema:
+  type: array
+  items:
+    type: integer
+    enum: [0, 7, 16]
+  contains:
+    const: 0
+  minItems: 1
+  maxItems: 3
+  uniqueItems: true
+definedBy:
+  extension:
+    name: Ssnpm

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

@@ -11,7 +11,7 @@ description: |
 
   The spec states that implementations may handle ECALLs transparently
   without raising a trap, in which case the EEI must provide a builtin.
-long_name: TODO
+long_name: "Trap on ECALL from S-mode"
 schema:
   type: boolean
   default: true

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

@@ -11,7 +11,7 @@ description: |
 
   The spec states that implementations may handle ECALLs transparently
   without raising a trap, in which case the EEI must provide a builtin.
-long_name: TODO
+long_name: "Trap on ECALL from U-mode"
 schema:
   type: boolean
   default: true

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

@@ -11,7 +11,7 @@ description: |
 
   The spec states that implementations may handle ECALLs transparently
   without raising a trap, in which case the EEI must provide a builtin.
-long_name: TODO
+long_name: "Trap on ECALL from VS-mode"
 schema:
   type: boolean
   default: true

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

@@ -17,7 +17,7 @@ description: |
 
   TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY has no effect when
   some virtual translation mode is supported.
-long_name: TODO
+long_name: "Trap on SFENCE.VMA when satp.MODE is read-only"
 schema:
   type: boolean
   default: false

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

@@ -0,0 +1,28 @@
+# 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: VSEI_INTR_IMPL
+description: |
+  Whether or not virtual supervisor-level external interrupts are implemented.
+
+  Possible values:
+
+  true::
+    Virtual supervisor-level external interrupts are implemented.
+    `mie.VSEIE` and `mideleg.VSEI` are writable.
+
+  false::
+    Virtual supervisor-level external interrupts are not implemented.
+    `mie.VSEIE`, `mip.VSEIP`, and `mideleg.VSEI` are read-only zero.
+long_name: Virtual supervisor-level external interrupts are implemented
+schema:
+  type: boolean
+definedBy:
+  extension:
+    allOf:
+      - name: Zicsr
+      - name: H

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

@@ -0,0 +1,28 @@
+# 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: VSSI_INTR_IMPL
+description: |
+  Whether or not virtual supervisor-level software interrupts are implemented.
+
+  Possible values:
+
+  true::
+    Virtual supervisor-level software interrupts are implemented.
+    `mie.VSSIE` and `mideleg.VSSI` are writable.
+
+  false::
+    Virtual supervisor-level software interrupts are not implemented.
+    `mie.VSSIE`, `mip.VSSIP`, and `mideleg.VSSI` are read-only zero.
+long_name: Virtual supervisor-level software interrupts are implemented
+schema:
+  type: boolean
+definedBy:
+  extension:
+    allOf:
+      - name: Zicsr
+      - name: H

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

@@ -0,0 +1,33 @@
+# 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: VSTI_INTR_IMPL
+description: |
+  Whether or not virtual supervisor-level timer interrupts are implemented.
+  If Sstc is implemented, then VSTI_INTR_IMPL must be true.
+
+  Possible values:
+
+  true::
+    Virtual supervisor-level timer interrupts are implemented.
+    `mie.VSTIE` and `mdeleg.VSTI` are writable.
+
+  false::
+    Virtual supervisor-level timer interrupts are not implemented.
+    `mie.VSTIE`, `mip.VSTIP`, and and `mdeleg.VSTI` are read-only zero.
+long_name: Virtual supervisor-level timer interrupts are implemented.
+schema:
+  type: boolean
+requirements:
+  idl(): |
+    implemented?(ExtensionName::Sstc) -> VSTI_INTR_IMPL;
+  reason: "When the Sstc extension is implemented, VSTIP reflects the timer interrupt signal resulting from `vstimecmp`."
+definedBy:
+  extension:
+    allOf:
+      - name: Zicsr
+      - name: H

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

@@ -0,0 +1,20 @@
+# Copyright (c) 2026 Neel Kumar
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: WFI_FINITE
+long_name: |
+  Whether WFI resumes execution after a finite amount of time
+definedBy:
+  extension:
+    name: Sm
+description: |
+  Options:
+
+    * true: WFI resumes execution after waiting for a finite amount of time
+    * false: WFI may continue waiting until another event causes execution to resume
+schema:
+  type: boolean

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

@@ -0,0 +1,20 @@
+# Copyright (c) 2026 Neel Kumar
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# yaml-language-server: $schema=../../../schemas/param_schema.json
+
+$schema: param_schema.json#
+kind: parameter
+name: WFI_U_MODE
+long_name: |
+  Whether WFI is supported in U mode
+definedBy:
+  extension:
+    name: Sm
+description: |
+  Options:
+
+    * true: WFI can be executed in U mode
+    * false: Executing WFI in U mode raises an illegal instruction exception
+schema:
+  type: boolean

data/lib/udb/Z3_VERSION

@@ -1 +1 @@
-z3-5.0.0
+z3-5.1.0

data/lib/udb/config.rb

@@ -238,7 +238,7 @@ module Udb
     def initialize(data, info)
       super(data, info)
 
-      @param_values = @data.key?("params") ? @data["params"] : [].freeze
+      @param_values = @data.key?("params") ? @data["params"] : {}.freeze
 
       @mxlen = @data.dig("params", "MXLEN")
 

data/lib/udb/log.rb

@@ -132,6 +132,8 @@ module Udb
 
   sig { params(fmt: String, options: T.untyped).returns(T.any(TTY::ProgressBar, DummyProgressBar)) }
   def self.create_progressbar(fmt, **options)
+    fmt = progressbar_format_for_terminal(fmt, **options)
+
     if @top_level_progressbar.nil?
 
       target_level = options.key?(:level) ? LogLevel.deserialize(options[:level].to_s) : LogLevel::Info
@@ -144,4 +146,18 @@ module Udb
       @top_level_progressbar.register(fmt, **options)
     end
   end
+
+  sig { params(fmt: String, options: T.untyped).returns(String) }
+  def self.progressbar_format_for_terminal(fmt, **options)
+    return fmt unless fmt.match?(/:bar/i)
+    return fmt unless options[:total].nil?
+
+    inset = options.fetch(:inset, 0).to_i
+    without_bar = fmt.gsub(/:bar/i, "")
+    available_space = TTY::ProgressBar.max_columns - TTY::ProgressBar.display_columns(without_bar) - inset
+    return fmt if available_space >= 1
+
+    fmt.gsub(/\s*\[:bar\]\s*/i, " ").gsub(/\s*:bar\s*/i, " ").squeeze(" ").strip
+  end
+  private_class_method :progressbar_format_for_terminal
 end

data/lib/udb/obj/csr.rb

@@ -20,6 +20,17 @@ module Udb
     BITS6_CONST_TYPE = Idl::Type.new(:bits, width: 6, qualifiers: [:const]).freeze
     BITS128_TYPE = Idl::Type.new(:bits, width: 128).freeze
     ENCODING_SIZE_VAR = Idl::Var.new("__instruction_encoding_size", BITS6_TYPE, 32).freeze
+    # Privilege mode => IDL expression naming the field that selects the effective
+    # XLEN in that mode. Debug mode executes at MXLEN, so it shares M-mode's field.
+    MODE_TO_XLEN_FIELD = {
+      "M" => "CSR[misa].MXL",
+      "D" => "CSR[misa].MXL",
+      "S" => "CSR[mstatus].SXL",
+      "U" => "CSR[mstatus].UXL",
+      "VS" => "CSR[hstatus].VSXL",
+      "VU" => "CSR[vsstatus].UXL"
+    }.freeze
+    XLEN_TO_ENCODING = { 32 => 0, 64 => 1 }.freeze
     # Add all methods in this module to this type of database object.
     include HasFields
 
@@ -193,14 +204,7 @@ module Udb
         # dynamic if either we don't know VSXLEN or VSXLEN is explicitly mutable
         !cfg_arch.param_values.key?("VSXLEN") || cfg_arch.param_values["VSXLEN"].size > 1
       when "XLEN"
-        # must always have M-mode
-        # SXLEN condition applies if S-mode is possible
-        # 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.possible_extensions.map(&:name).include?("H") && \
-          (cfg_arch.param_values["VSXLEN"].nil? || cfg_arch.param_values["VSXLEN"].size > 1))
+        modes_with_dynamic_xlen.any?
       else
         raise "Unexpected length"
       end
@@ -299,7 +303,7 @@ module Udb
           64
         end
       when "XLEN"
-        if cfg_arch.possible_extensions.map(&:name).include?("M")
+        if cfg_arch.possible_extensions.map(&:name).include?("Sm")
           cfg_arch.mxlen || 64
         elsif cfg_arch.possible_extensions.map(&:name).include?("S")
           if cfg_arch.param_values.key?("SXLEN")
@@ -341,61 +345,50 @@ module Udb
       end
     end
 
-    # @return [String] IDL condition of when the effective xlen is 32
-    def length_cond32
+    # @return [Array<String>] Modes with access to this CSR whose effective XLEN can
+    #                          vary in this configuration
+    def modes_with_dynamic_xlen
+      modes_with_access.select { |mode| cfg_arch.multi_xlen_in_mode?(mode) }
+    end
+
+    # @param xlen [Integer] 32 or 64
+    # @return [String] IDL condition of when the effective xlen is +xlen+
+    def length_cond(xlen)
+      encoding = XLEN_TO_ENCODING.fetch(xlen)
       case @data["length"]
       when "MXLEN"
-        "CSR[misa].MXL == 0"
+        "#{MODE_TO_XLEN_FIELD['M']} == #{encoding}"
       when "SXLEN"
-        "CSR[mstatus].SXL == 0"
+        "#{MODE_TO_XLEN_FIELD['S']} == #{encoding}"
       when "VSXLEN"
-        "CSR[hstatus].VSXL == 0"
+        "#{MODE_TO_XLEN_FIELD['VS']} == #{encoding}"
       when "XLEN"
-        "(priv_mode() == PrivilegeMode::M && CSR[misa].MXL == 0) || (priv_mode() == PrivilegeMode::S && CSR[mstatus].SXL == 0) || (priv_mode() == PrivilegeMode::VS && CSR[hstatus].VSXL == 0)"
+        modes = modes_with_dynamic_xlen
+        raise "No mode with access to #{name} has a dynamic XLEN" if modes.empty?
+
+        modes.map { |mode|
+          "(priv_mode() == PrivilegeMode::#{mode} && #{MODE_TO_XLEN_FIELD.fetch(mode)} == #{encoding})"
+        }.join(" || ")
       else
         raise "Unexpected length #{@data['length']} for #{name}"
       end
     end
 
+    # @return [String] IDL condition of when the effective xlen is 32
+    def length_cond32 = length_cond(32)
+
     # @return [String] IDL condition of when the effective xlen is 64
-    def length_cond64
-      case @data["length"]
-      when "MXLEN"
-        "CSR[misa].MXL == 1"
-      when "SXLEN"
-        "CSR[mstatus].SXL == 1"
-      when "VSXLEN"
-        "CSR[hstatus].VSXL == 1"
-      when "XLEN"
-        "(priv_mode() == PrivilegeMode::M && CSR[misa].MXL == 1) || (priv_mode() == PrivilegeMode::S && CSR[mstatus].SXL == 1) || (priv_mode() == PrivilegeMode::VS && CSR[hstatus].VSXL == 1)"
-      else
-        raise "Unexpected length"
-      end
-    end
+    def length_cond64 = length_cond(64)
 
     # @param effective_xlen [Integer or nil] 32 or 64 for fixed xlen, nil for dynamic
     # @return [String] Pretty-printed length string
     def length_pretty(effective_xlen = nil)
       raise ArgumentError, "effective_xlen is non-nil and is a #{effective_xlen.class} but must be an Integer" unless effective_xlen.nil? || effective_xlen.is_a?(Integer)
       if dynamic_length?
-        cond =
-          case @data["length"]
-          when "MXLEN"
-            "CSR[misa].MXL == %%"
-          when "SXLEN"
-            "CSR[mstatus].SXL == %%"
-          when "VSXLEN"
-            "CSR[hstatus].VSXL == %%"
-          when "XLEN"
-            "(priv_mode() == PrivilegeMode::M && CSR[misa].MXL == %%) || (priv_mode() == PrivilegeMode::S && CSR[mstatus].SXL == %%) || (priv_mode() == PrivilegeMode::VS && CSR[hstatus].VSXL == %%)"
-          else
-            raise "Unexpected length '#{@data['length']}'"
-          end
-
         if effective_xlen.nil?
           [
-            "* #{length(32)} when #{cond.sub('%%', '0')}",
-            "* #{length(64)} when #{cond.sub('%%', '1')}"
+            "* #{length(32)} when #{length_cond(32)}",
+            "* #{length(64)} when #{length_cond(64)}"
           ].join("\n")
         else
           "#{length(effective_xlen)}-bit"

data/lib/udb/obj/database_obj.rb

@@ -115,7 +115,7 @@ module Udb
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
       return nil unless other.is_a?(DatabaseObject)
-      return nil unless @Kind == other.kind
+      return nil unless kind == other.kind
 
       @name <=> other.name
     end

data/lib/udb/obj/exception_code.rb

@@ -82,9 +82,9 @@ module Udb
 
     sig { override.params(other: BasicObject).returns(T.nilable(Integer)) }
     def <=>(other)
-      return nil unless T.cast(other, Object).is_a?(ExceptionCode)
+      return nil unless T.cast(other, Object).is_a?(InterruptCode)
 
-      num <=> T.cast(other, ExceptionCode).num
+      num <=> T.cast(other, InterruptCode).num
     end
 
     sig { override.params(other: BasicObject).returns(T::Boolean) }
@@ -93,6 +93,6 @@ module Udb
     end
 
     sig { override.returns(Integer) }
-    def hash = [ExceptionCode, num].hash
+    def hash = [InterruptCode, num].hash
   end
 end

data/lib/udb/version.rb

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