Architectural Parameters

The following 148 parameters are defined in this manual:

Name Type Existence Description

Name	Type	Existence	Description
ASID_WIDTH	0 to 9 when `MXLEN` == 32	0 to 16 when `MXLEN` == 64	Sa
Number of implemented ASID bits. Maximum is 16 for XLEN==64, and 9 for XLEN==32	CACHE_BLOCK_SIZE	1 to 0xffffffffffffffff	(Zicbom pass:[
	] Zicbop pass:[		] Zicboz)a
The observable size of a cache block, in bytes	CACHE_BLOCK_SIZE	1 to 0xffffffffffffffff	(Zicbom pass:[
	] Zicbop pass:[		] Zicboz)a
The observable size of a cache block, in bytes	CACHE_BLOCK_SIZE	1 to 0xffffffffffffffff	(Zicbom pass:[
	] Zicbop pass:[		] Zicboz)a
The observable size of a cache block, in bytes	COUNTINHIBIT_EN	32-element array where: [0] is boolean [1] is false [2] is boolean additional items are: boolean	Sma
Indicates which hardware performance monitor counters can be disabled from mcountinhibit. An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set COUNTINHIBIT_EN[3] to true. COUNTINHIBIT_EN[1] can never be true, since it corresponds to mcountinhibit, which is always read-only-0.	ELEN	integer	Zvl32ba
The maximum size in bits of a vector element that any operation can produce or consume.	FOLLOW_VTYPE_RESET_RECOMMENDATION	boolean	Zvl32ba
It is recommended that at reset, vtype.vill is set, the remaining bits in vtype are zero, and vl is set to zero. If this parameter is set to true, this recommendation is followed. If it is false, at reset the respective fields will be UNDEFINED_LEGAL.	FORCE_UPGRADE_CBO_INVAL_TO_FLUSH	boolean	Zicboma
When true, an implementation prohibits setting menvcfg.CBIE == `11` such that all cbo.inval instructions either trap (when menvcfg.CBIE == '00') or flush (when menvcfg.CBIE == '01'). When false, an implementation allows a true INVAL operation for cbo.inval, and thus supports the setting menvcfg.CBIE == `11`.	GSTAGE_MODE_BARE	boolean	Ha
Whether or not writing mode=Bare is supported in the hgatp register.	HCOUNTENABLE_EN	32-element array of boolean	Ha
Indicates which counters can delegated via hcounteren An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set HCOUNTENABLE_EN[3] to true. HCOUNTENABLE_EN[0:2] must all be false if Zicntr is not implemented. HCOUNTENABLE_EN[3:31] must all be false if Zihpm is not implemented.	HPM_COUNTER_EN	32-element array where: [0] is false [1] is false [2] is false additional items are: boolean	Smhpma
List of HPM counters that are enabled. There is one entry for each hpmcounter. The first three entries must be false (as they correspond to CY, IR, TM in, e.g. `mhmpcountinhibit`) Index 3 in HPM_COUNTER_EN corresponds to hpmcounter3. Index 31 in HPM_COUNTER_EN corresponds to hpmcounter31.	HPM_EVENTS	array of 58-bit integer	Smhpma
List of defined event numbers that can be written into hpmeventN	IGNORE_INVALID_VSATP_MODE_WRITES_WHEN_V_EQ_ZERO	boolean	Ha
Whether writes from M-mode, U-mode, or S-mode to vsatp with an illegal mode setting are ignored (as they are with satp), or if they are treated as WARL, leading to undpredictable behavior.	IMPRECISE_VECTOR_TRAP_SETTABLE	boolean	Zvl32ba
Some profiles may provide a privileged configuration bit that selects between precise and imprecise vector trap behavior, allowing flexibility in how traps and partial updates are reported.	JVT_BASE_TYPE	[mask, custom]	Zcmta
Type of the jvt.BASE CSR field. One of: * mask: jvt.BASE contains one or more implemented bits, which are indicated by JVT_BASE_MASK. * custom: Custom behavior. Will cause hart to enter 'unpredictable' state on a write to jvt.BASE.	JVT_READ_ONLY	boolean	Zcmta
If Zcmt is implemented, JVT is implemented, but can contain a read-only value	LEGAL_VSTART	[1_stride, 2_stride, 4_stride, custom]	Zvl32ba
Implementations may raise illegal-instruction exceptions for vector instructions that specify a vstart value the implementation can never produce under the same vtype configuration (e.g., due to restrictions on supported strides or alignments).	MARCHID_IMPLEMENTED	boolean	Sma
* false: marchid is not implemented, and must be read-only-0 * true: marchid is implemented, and the value is determined by `ARCH_ID_VALUE`	MCOUNTENABLE_EN	32-element array of boolean	Ua
Indicates which counters can be delegated via mcounteren. An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set MCOUNTENABLE_EN[3] to true. MCOUNTENABLE_EN[0:2] must all be false if Zicntr is not implemented. MCOUNTENABLE_EN[3:31] must all be false if Zihpm is not implemented.	MIMPID_IMPLEMENTED	boolean	Sma
* false: mimpid is not implemented, and must be read-only-0 * true: mimpid is implemented, and the value is determined by `IMP_ID_VALUE`	MISALIGNED_LDST	boolean	Sma
Does the implementation perform non-atomic misaligned loads and stores to main memory (does not affect misaligned support to device memory)? If not, the implementation always throws a misaligned exception.	MISALIGNED_LDST_EXCEPTION_PRIORITY	[low, high]	Sma
The relative priority of a load/store/AMO exception vs. load/store/AMO page-fault or access-fault exceptions. May be one of: [separator="!"] !=== ! low ! Misaligned load/store/AMO exceptions are always lower priority than load/store/AMO page-fault and access-fault exceptions. ! high ! Misaligned load/store/AMO exceptions are always higher priority than load/store/AMO page-fault and access-fault exceptions. !=== MISALIGNED_LDST_EXCEPTION_PRIORITY cannot be "high" when MISALIGNED_MAX_ATOMICITY_GRANULE_SIZE is non-zero, since the atomicity of an access cannot be determined in that case until after address translation.	MISA_CSR_IMPLEMENTED	boolean	Sma
Options: true:: The misa CSR returns a non-zero value. false:: The misa CSR is read-only-0.	MSTATUS_TVM_IMPLEMENTED	boolean	Sa
Whether or not mstatus.TVM is implemented. When not implemented mstatus.TVM will be read-only-zero.	MTVAL_WIDTH	0 to 32 when `MXLEN` == 32	0 to 64 when `MXLEN` == 64
Sma	The number of implemented bits in the mtval CSR. This is the CSR that may be written when a trap is taken into M-mode with exception-specific information to assist software in handling the trap (e.g., address associated with exception). Must be greater than or equal to max(`PHYS_ADDR_WIDTH`, `VA_SIZE`)	MTVEC_ACCESS	[ro, rw]
Sma	Options: ro:: mtvec is read-only. rw:: mtvec is read-write, but may not accept all values.	MTVEC_ILLEGAL_WRITE_BEHAVIOR	[retain, custom]
Sma	Options: retain:: When either mtvec.MODE or mtvec.BASE is illegal, mtvec will retain its current value custom:: When either mtvec.MODE or mtvec.BASE is illegal, mtvec will obtain an unpredictable value Other values may be added over time once other common behaviors are identified.	MTVEC_MODES	1-element to 2-element array of [0, 1]
Sma	Options: 0:: Direct; All traps set `pc` to mtvec.BASE 1:: Vectored; Asynchronous interrupts set `pc` to mtvec.BASE + 4 x cause. If only one mode is given, mtvec.MODE is assumed to be read-only with that value. Otherwise, mtvec.MODE is read-write.	MXLEN	[32, 64]
Sma	XLEN in machine mode, specified in bits	M_MODE_ENDIANNESS	[little, big, dynamic]
Sma	Options: [separator="!"] !=== h! little ! M-mode data is always little endian h! big ! M-mode data is always big endian h! dynamic ! M-mode data can be either little or big endian, depending on the CSR field mstatus.MBE !===	NUM_EXTERNAL_GUEST_INTERRUPTS	1 to 31 when `MXLEN` == 32
1 to 63 when `MXLEN` == 64	Ha	Number of supported virtualized guest interrupts Corresponds to the `GEILEN` parameter in the RVI specs	NUM_PMP_ENTRIES
0 to 64	Smpmpa	Number of implemented PMP entries. Can be any value between 0-64, inclusive. The architecture mandates that the number of implemented PMP registers must appear to be 0, 16, or 64. Therefore, pmp registers will behave as follows according to NUN_PMP_ENTRIES: [separator="!"] !=== ! NUM_PMP_ENTRIES ! pmpaddr<0-15> / pmpcfg<0-3> ! pmpaddr<16-63> / pmpcfg<4-15> ! 0 ! N ! N ! 1-16 ! Y ! N ! 17-64 ! Y ! Y !=== N = Not implemented; access will cause `IllegalInstruction` if TRAP_ON_UNIMPLEMENTED_CSR is true Y = Implemented; access will not cause an exception (from M-mode), but register may be read-only-zero if NUM_PMP_ENTRIES is less than the corresponding register [NOTE] `pmpcfgN` for an odd N never exists when XLEN == 64 When NUM_PMP_ENTRIES is not exactly 0, 16, or 64, some extant pmp registers, and associated pmpNcfg, will be read-only zero (but will never cause an exception).	PHYS_ADDR_WIDTH
1 to 34 when `MXLEN` == 32	1 to 64 when `MXLEN` == 64	Sma	Implementation-defined size of the physical address space.
PMA_GRANULARITY	2 to 66	Sma	Generally, for systems with an MMU, should not be smaller than 12, as that would preclude caching PMA results in the TLB along with virtual memory translations
PMP_GRANULARITY	2 to 66	Smpmpa	log2 of the smallest supported PMP region. Generally, for systems with an MMU, should not be smaller than 12, as that would preclude caching PMP results in the TLB along with virtual memory translations Note that PMP_GRANULARITY is equal to G+2 (not G) as described in the privileged architecture.
PRECISE_SYNCHRONOUS_EXCEPTIONS	boolean	Sma	If false, any exception not otherwise mandated to precise (e.g., PMP violation) will cause execution to enter an unpredictable state.
REPORT_CAUSE_IN_MTVAL_ON_LANDING_PAD_SOFTWARE_CHECK	boolean	Zicfilpa	When true, mtval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into M-mode due to a landing pad error. When false, mtval is written with 0.
REPORT_CAUSE_IN_MTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK	boolean	Zicfissa	When true, mtval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into M-mode due to a shadow stack pop check instruction. When false, mtval is written with 0.
REPORT_CAUSE_IN_STVAL_ON_LANDING_PAD_SOFTWARE_CHECK	boolean	Zicfilpa	When true, stval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into S-mode due to a landing pad error. When false, stval is written with 0.
REPORT_CAUSE_IN_STVAL_ON_SHADOW_STACK_SOFTWARE_CHECK	boolean	Zicfissa	When true, stval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into S-mode due to a shadow stack pop check instruction. When false, stval is written with 0.
REPORT_CAUSE_IN_VSTVAL_ON_LANDING_PAD_SOFTWARE_CHECK	boolean	Zicfilpa	When true, vstval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into VS-mode due to a landing pad error. When false, vstval is written with 0.
REPORT_CAUSE_IN_VSTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK	boolean	Zicfissa	When true, vstval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into VS-mode due to a shadow stack pop check instruction. When false, vstval is written with 0.
REPORT_ENCODING_IN_MTVAL_ON_ILLEGAL_INSTRUCTION	boolean	Sma	Options: * true: mtval is written with the encoding of an instruction causing an IllegalInstruction exception * false: mtval is written with 0 when an instruction causes an IllegalInstruction exception.
REPORT_ENCODING_IN_STVAL_ON_ILLEGAL_INSTRUCTION	boolean	Sa	When true, stval is written with the encoding of an instruction that causes an `IllegalInstruction` exception. When false stval is written with 0 when an `IllegalInstruction` exception occurs.
REPORT_ENCODING_IN_VSTVAL_ON_ILLEGAL_INSTRUCTION	boolean	Ha	When true, vstval is written with the encoding of an instruction that causes an `IllegalInstruction` exception. When false vstval is written with 0 when an `IllegalInstruction` exception occurs.
REPORT_ENCODING_IN_VSTVAL_ON_VIRTUAL_INSTRUCTION	boolean	Ha	When true, vstval is written with the encoding of an instruction that causes an `VirualInstruction` exception. When false vstval is written with 0 when an `VirtualInstruction` exception occurs.
REPORT_GPA_IN_HTVAL_ON_GUEST_PAGE_FAULT	boolean	Ha	When true, htval is written with the Guest Physical Address, shifted right by 2, that caused a `GuestPageFault` exception. When false, htval is written with 0 when a `GuestPageFault` exception occurs.
REPORT_GPA_IN_TVAL_ON_INSTRUCTION_GUEST_PAGE_FAULT	boolean	Ha	Whether or not GPA >> 2 is written into htval/mtval2 when an instruction guest page fault occurs. If false, 0 will be written into htval/mtval2 on an instruction guest page fault.
REPORT_GPA_IN_TVAL_ON_INTERMEDIATE_GUEST_PAGE_FAULT	boolean	Ha	Whether or not GPA >> 2 is written into htval/mtval2 when a guest page fault occurs while walking a VS-mode page table. If false, 0 will be written into htval/mtval2 on an intermediate guest page fault.
REPORT_GPA_IN_TVAL_ON_LOAD_GUEST_PAGE_FAULT	boolean	Ha	Whether or not GPA >> 2 is written into htval/mtval2 when a load guest page fault occurs. If false, 0 will be written into htval/mtval2 on a load guest page fault.
REPORT_GPA_IN_TVAL_ON_STORE_AMO_GUEST_PAGE_FAULT	boolean	Ha	Whether or not GPA >> 2 is written into htval/mtval2 when a store/amo guest page fault occurs. If false, 0 will be written into htval/mtval2 on a store/amo guest page fault.
REPORT_VA_IN_MTVAL_ON_BREAKPOINT	boolean	Sma	Options: * true: mtval is written with the virtual PC of an EBREAK instruction (same information as mepc). * false: mtval is written with 0 on an EBREAK instruction. Regardless, mtval is always written with a virtual PC when an external breakpoint is generated
REPORT_VA_IN_MTVAL_ON_INSTRUCTION_ACCESS_FAULT	boolean	Sma	Options: * true: mtval is written with the virtual address of a fetch causing the access fault * false: mtval is written with 0 when a fetch causes an access fault
REPORT_VA_IN_MTVAL_ON_INSTRUCTION_MISALIGNED	boolean	Sma	Options: * true: mtval is written with the virtual address of a trapping misaligned fetch * false: mtval is written with 0 when a misaligned fetch traps
REPORT_VA_IN_MTVAL_ON_INSTRUCTION_PAGE_FAULT	boolean	Sa	When true, mtval is written with the virtual PC of an instructino when fetch causes an `InstructionPageFault`. WHen false, mtval is written with 0 when an instruction fetch causes an `InstructionPageFault`.
REPORT_VA_IN_MTVAL_ON_LOAD_ACCESS_FAULT	boolean	Sma	Options: * true: mtval is written with the virtual address of a load causing the access fault * false: mtval is written with 0 when a load causes an access fault
REPORT_VA_IN_MTVAL_ON_LOAD_MISALIGNED	boolean	Sma	Options: * true: mtval is written with the virtual address of a trapping misaligned load. * false: mtval is written with 0 when a misaligned load traps.
REPORT_VA_IN_MTVAL_ON_LOAD_PAGE_FAULT	boolean	Sa	When true, mtval is written with the virtual address of a load when it causes a `LoadPageFault`. WHen false, mtval is written with 0 when a load causes a `LoadPageFault`.
REPORT_VA_IN_MTVAL_ON_STORE_AMO_ACCESS_FAULT	boolean	Sma	Options: * true: mtval is written with the virtual address of a store or AMO causing the access fault * false: mtval is written with 0 when a store or AMO causes an access fault
REPORT_VA_IN_MTVAL_ON_STORE_AMO_MISALIGNED	boolean	Sma	Options: * true: mtval is written with the virtual address of a trapping misaligned store or AMO. * false: mtval is written with 0 when a misaligned store or AMO traps.
REPORT_VA_IN_MTVAL_ON_STORE_AMO_PAGE_FAULT	boolean	Sa	When true, mtval is written with the virtual address of a store when it causes a `StoreAmoPageFault`. WHen false, mtval is written with 0 when a store causes a `StoreAmoPageFault`.
REPORT_VA_IN_STVAL_ON_BREAKPOINT	boolean	Sa	When true, stval is written with the virtual PC of the EBREAK instruction (same information as mepc). When false, stval is written with 0 on an EBREAK instruction. Regardless, stval is always written with a virtual PC when an external breakpoint is generated
REPORT_VA_IN_STVAL_ON_INSTRUCTION_ACCESS_FAULT	boolean	Sa	When true, stval is written with the virtual PC of an instructino when fetch causes an `InstructionAccessFault`. WHen false, stval is written with 0 when an instruction fetch causes an `InstructionAccessFault`.
REPORT_VA_IN_STVAL_ON_INSTRUCTION_MISALIGNED	boolean	Sa	When true, stval is written with the virtual PC when an instruction fetch is misaligned. When false, stval is written with 0 when an instruction fetch is misaligned. Note that when IALIGN=16 (i.e., when the C or one of the `Zc*` extensions are implemented), it is impossible to generate a misaligned fetch, and so this parameter has no effect.
REPORT_VA_IN_STVAL_ON_INSTRUCTION_PAGE_FAULT	boolean	Sa	When true, stval is written with the virtual PC of an instructino when fetch causes an `InstructionPageFault`. WHen false, stval is written with 0 when an instruction fetch causes an `InstructionPageFault`.
REPORT_VA_IN_STVAL_ON_LOAD_ACCESS_FAULT	boolean	Sa	When true, stval is written with the virtual address of a load when it causes a `LoadAccessFault`. WHen false, stval is written with 0 when a load causes a `LoadAccessFault`.
REPORT_VA_IN_STVAL_ON_LOAD_MISALIGNED	boolean	Sa	When true, stval is written with the virtual address of a load instruction when the address is misaligned and MISALIGNED_LDST is false. When false, stval is written with 0 when a load address is misaligned and MISALIGNED_LDST is false.
REPORT_VA_IN_STVAL_ON_LOAD_PAGE_FAULT	boolean	Sa	When true, stval is written with the virtual address of a load when it causes a `LoadPageFault`. WHen false, stval is written with 0 when a load causes a `LoadPageFault`.
REPORT_VA_IN_STVAL_ON_STORE_AMO_ACCESS_FAULT	boolean	Sa	When true, stval is written with the virtual address of a store when it causes a `StoreAmoAccessFault`. WHen false, stval is written with 0 when a store causes a `StoreAmoAccessFault`.
REPORT_VA_IN_STVAL_ON_STORE_AMO_MISALIGNED	boolean	Sa	When true, stval is written with the virtual address of a store instruction when the address is misaligned and MISALIGNED_LDST is false. When false, stval is written with 0 when a store address is misaligned and MISALIGNED_LDST is false.
REPORT_VA_IN_STVAL_ON_STORE_AMO_PAGE_FAULT	boolean	Sa	When true, stval is written with the virtual address of a store when it causes a `StoreAmoPageFault`. WHen false, stval is written with 0 when a store causes a `StoreAmoPageFault`.
REPORT_VA_IN_VSTVAL_ON_BREAKPOINT	boolean	Ha	When true, vstval is written with the virtual PC of the EBREAK instruction (same information as mepc). When false, vstval is written with 0 on an EBREAK instruction. Regardless, vstval is always written with a virtual PC when an external breakpoint is generated.
REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_ACCESS_FAULT	boolean	Ha	When true, vstval is written with the virtual PC of an instructino when fetch causes an `InstructionAccessFault`. WHen false, vstval is written with 0 when an instruction fetch causes an `InstructionAccessFault`.
REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_MISALIGNED	boolean	Ha	When true, vstval is written with the virtual PC when an instruction fetch is misaligned. When false, vstval is written with 0 when an instruction fetch is misaligned. Note that when IALIGN=16 (i.e., when the C or one of the `Zc*` extensions are implemented), it is impossible to generate a misaligned fetch, and so this parameter has no effect.
REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_PAGE_FAULT	boolean	Ha	When true, vstval is written with the virtual PC of an instructino when fetch causes an `InstructionPageFault`. WHen false, vstval is written with 0 when an instruction fetch causes an `InstructionPageFault`.
REPORT_VA_IN_VSTVAL_ON_LOAD_ACCESS_FAULT	boolean	Ha	When true, vstval is written with the virtual address of a load when it causes a `LoadAccessFault`. WHen false, vstval is written with 0 when a load causes a `LoadAccessFault`.
REPORT_VA_IN_VSTVAL_ON_LOAD_MISALIGNED	boolean	Ha	When true, vstval is written with the virtual address of a load instruction when the address is misaligned and MISALIGNED_LDST is false. When false, vstval is written with 0 when a load address is misaligned and MISALIGNED_LDST is false.
REPORT_VA_IN_VSTVAL_ON_LOAD_PAGE_FAULT	boolean	Ha	When true, vstval is written with the virtual address of a load when it causes a `LoadPageFault`. WHen false, vstval is written with 0 when a load causes a `LoadPageFault`.
REPORT_VA_IN_VSTVAL_ON_STORE_AMO_ACCESS_FAULT	boolean	Ha	When true, vstval is written with the virtual address of a store when it causes a `StoreAmoAccessFault`. WHen false, vstval is written with 0 when a store causes a `StoreAmoAccessFault`.
REPORT_VA_IN_VSTVAL_ON_STORE_AMO_MISALIGNED	boolean	Ha	When true, vstval is written with the virtual address of a store instruction when the address is misaligned and MISALIGNED_LDST is false. When false, vstval is written with 0 when a store address is misaligned and MISALIGNED_LDST is false.
REPORT_VA_IN_VSTVAL_ON_STORE_AMO_PAGE_FAULT	boolean	Ha	When true, vstval is written with the virtual address of a store when it causes a `StoreAmoPageFault`. WHen false, vstval is written with 0 when a store causes a `StoreAmoPageFault`.
RESERVED_VSET_X0X0_VILL_SET	[never, always, custom]	Zvl32ba	When rs1 = x0 and rd = x0, vset instructions act as if the current vector length in vl is used as the AVL. If `vill` is set or the configuration is reserved, implementations may set `vill` to indicate unsupported use of these encodings.
RESERVED_VSET_X0X0_VLMAX_CHANGE	[never, always, custom]	Zvl32ba	When rs1=x0 and rd=x0, the instructions operate as if the current vector length in vl is used as the AVL. Use of the vset instructions with a new SEW/LMUL ratio that would result in a change of VLMAX is reserved. Implementations may set vill in either case.
RVV_VL_WHEN_AVL_LT_DOUBLE_VLMAX	[ceil(AVL/2), VLMAX, custom]	Zvl32ba	The value assigned to VL when AVL < 2*VLMAX.
SATP_MODE_BARE	boolean	Sa	Whether or not satp.MODE == Bare is supported.
SEW_MIN	[8, 16, 32, 64]	Zvl32ba	Implementations must provide fractional LMUL settings that allow the narrowest supported element width (SEW) to occupy a fractional portion of a vector register relative to the widest supported SEW. In general, implementations must support LMUL >= SEW_MIN/ELEN, where SEW_MIN is the narrowest supported SEW and ELEN is the widest SEW.
STVAL_WIDTH	≤ 0xffffffffffffffff	Sa	The number of implemented bits in stval. Must be greater than or equal to max(`PHYS_ADDR_WIDTH`, `VA_SIZE`)
STVEC_MODE_DIRECT	boolean	Sa	Whether or not stvec.MODE supports Direct (0).
STVEC_MODE_VECTORED	boolean	Sa	Whether or not stvec.MODE supports Vectored (1).
SUPPORT_FRACTIONAL_LMUL_BEYOND_REQUIRED	[no_unrequired_supported, custom]	Zvl32ba	For a given supported fractional LMUL setting, implementations must provide support for SEW settings covering the range from SEW_MIN up to LMUL * ELEN, inclusive. This ensures types narrower than the maximum SEW are supported when fractional LMULs are selected.
SXLEN	1-element to 2-element array of [32, 64]	Sa	Set of XLENs supported in S-mode. Can be one of: * 32: SXLEN is always 32 * 64: SXLEN is always 64 * [32, 64]: SXLEN can be changed (via mstatus.SXL) between 32 and 64
S_MODE_ENDIANNESS	[little, big, dynamic]	Sa	Endianness of data in S-mode. Can be one of: * little: S-mode data is always little endian * big: S-mode data is always big endian * dynamic: S-mode data can be either little or big endian, depending on the CSR field mstatus.SBE
TIME_CSR_IMPLEMENTED	boolean	Zicntra	Whether or not a real hardware time CSR exists. Implementations can either provide a real CSR or emulate access at M-mode. Possible values: true:: time/timeh exists, and accessing it will not cause an IllegalInstruction trap false:: time/timeh does not exist. Accessing the CSR will cause an IllegalInstruction trap or enter an unpredictable state, depending on TRAP_ON_UNIMPLEMENTED_CSR. Privileged software may emulate the time CSR, or may pass the exception to a lower level.
TINST_VALUE_ON_BREAKPOINT	[always zero, custom]	Ha	Value written into htinst/mtinst on a Breakpoint exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_FINAL_INSTRUCTION_GUEST_PAGE_FAULT	[always zero, always pseudoinstruction]	Ha	Value to write into htval/mtval2 when there is a guest page fault on a final translation. Possible values: * "always zero": Always write the value zero * "always pseudoinstruction": Always write the pseudoinstruction
TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT	[always zero, always pseudoinstruction, always transformed standard instruction, custom]	Ha	Value to write into htval/mtval2 when there is a guest page fault on a final translation. Possible values: * "always zero": Always write the value zero * "always pseudoinstruction": Always write the pseudoinstruction * "always transformed standard instruction": Always write the transformation of the standard instruction encoding * "custom": A custom value, which will cause an UNPREDICTABLE event.
TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT	[always zero, always pseudoinstruction, always transformed standard instruction, custom]	Ha	Value to write into htval/mtval2 when there is a guest page fault on a final translation. Possible values: * "always zero": Always write the value zero * "always pseudoinstruction": Always write the pseudoinstruction * "always transformed standard instruction": Always write the transformation of the standard instruction encoding * "custom": A custom value, which will cause an UNPREDICTABLE event.
TINST_VALUE_ON_INSTRUCTION_ADDRESS_MISALIGNED	[always zero, custom]	Ha	Value written into htinst/mtinst when there is an instruction address misaligned exception. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_LOAD_ACCESS_FAULT	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on an AccessFault exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_LOAD_ADDRESS_MISALIGNED	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_LOAD_PAGE_FAULT	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on a LoadPageFault exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_MCALL	[always zero, custom]	Ha	Value written into htinst/mtinst on a MCall exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_SCALL	[always zero, custom]	Ha	Value written into htinst/mtinst on a SCall exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_STORE_AMO_ACCESS_FAULT	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on an AccessFault exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_STORE_AMO_ADDRESS_MISALIGNED	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_STORE_AMO_PAGE_FAULT	[always zero, always transformed standard instruction, custom]	Ha	Value written into htinst/mtinst on a StoreAmoPageFault exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_UCALL	[always zero, custom]	Ha	Value written into htinst/mtinst on a UCall exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_VIRTUAL_INSTRUCTION	[always zero, custom]	Ha	Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TINST_VALUE_ON_VSCALL	[always zero, custom]	Ha	Value written into htinst/mtinst on a VSCall exception from VU/VS-mode. Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE
TRAP_ON_EBREAK	boolean	Sma	The spec states that implementations may handle EBREAKs transparently without raising a trap, in which case the EEI must provide a builtin.
TRAP_ON_ECALL_FROM_M	boolean	Sma	The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.
TRAP_ON_ECALL_FROM_S	boolean	Sa	Whether or not an ECALL-from-S-mode causes a synchronous exception. The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.
TRAP_ON_ECALL_FROM_U	boolean	Ua	Whether or not an ECALL-from-U-mode causes a synchronous exception. The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.
TRAP_ON_ECALL_FROM_VS	boolean	Ha	Whether or not an ECALL-from-VS-mode causes a synchronous exception. The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.
TRAP_ON_ILLEGAL_WLRL	boolean	Sma	Options: * true: Writing an illegal value to a WLRL CSR field will cause an IllegalInstruction exception. * false: Writing an illegal value to a WLRL CSR field causes unpredictable behavior.
TRAP_ON_RESERVED_INSTRUCTION	boolean	Sma	Options: * true: Fetching an unimplemented and/or undefined instruction from the standard/reserved opcode space will cause an IllegalInstruction exception. * false: Fetching an unimplemented and/or undefined instruction from the standard/reserved opcose space causes unpredictable behavior. TRAP_ON_RESERVED_INSTRUCTION may be false while TRAP_ON_UNIMPLEMENTED_INSTRUCTION is true when a custom instruction is implemented in the standard/reserved opcode space.
TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY	boolean	(S && (Sv32 pass:[
] Sv39 pass:[		] Sv48 pass:[
] Sv57))a	For implementations that make satp.MODE read-only zero (always Bare, i.e., no virtual translation is implemented), attempts to execute an SFENCE.VMA instruction might raise an illegal-instruction exception. TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY indicates whether or not that exception occurs. TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY has no effect when some virtual translation mode is supported.	TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY	boolean
(S && (Sv32 pass:[		] Sv39 pass:[
] Sv48 pass:[		] Sv57))a	For implementations that make satp.MODE read-only zero (always Bare, i.e., no virtual translation is implemented), attempts to execute an SFENCE.VMA instruction might raise an illegal-instruction exception. TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY indicates whether or not that exception occurs. TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY has no effect when some virtual translation mode is supported.
TRAP_ON_UNIMPLEMENTED_CSR	boolean	Sma	Options: * true: Accessing an unimplemented CSR (via a Zicsr instruction) will cause an IllegalInstruction exception. * false: Accessing an unimplemented CSR (via a Zicsr instruction) will cause unpredictable behavior.
TRAP_ON_UNIMPLEMENTED_INSTRUCTION	boolean	Sma	Options: * true: Fetching an unimplemented instruction will cause an IllegalInstruction exception. * false: Fetching an unimplemented instruction causes unpredictable behavior. An unimplemented instruction is any instruction encoding that is not defined by the implementation. Custom instructions are considered implemented.
UXLEN	1-element to 2-element array of [32, 64]	Ua	Set of XLENs supported in U-mode. When both 32 and 64 are supported, SXLEN can be changed, via mstatus.UXL, between 32 and 64.
U_MODE_ENDIANNESS	[little, big, dynamic]	Ua	Endianness of data in U-mode. Can be one of: * little: U-mode data is always little endian * big: U-mode data is always big endian * dynamic: U-mode data can be either little or big endian, depending on the CSR field mstatus.UBE
VECTOR_FF_NO_EXCEPTION_TRIM	boolean	Zvl32ba	Implementations may process fewer than vl elements and reduce vl even when no exception occurs. However, if vstart == 0 and vl > 0, at least one element must be processed.
VECTOR_FF_SEG_EXCEPTION_PARTIAL_LOAD	[no_subsegment_loaded, custom]	Zvl32ba	For fault-only-first segment loads, if an exception occurs partway through the zeroth segment, the trap is taken. If it occurs in a subsequent segment, vl may be reduced to the index of that segment. It is implementation-defined whether a partial subset of the segment is loaded before the trap.
VECTOR_FF_UPDATE_PAST_TRIM	[update_none, custom]	Zvl32ba	Fault-only-first (FF) load instructions may update active destination elements beyond the index that causes vector-length trimming, but not past the original vl. These spurious updates need not reflect the true memory contents; non-idempotent memory should only be accessed when the load is guaranteed not to be retried.
VECTOR_LOAD_PAST_TRAP	boolean	Zvl32ba	Vector load instructions may overwrite active destination vector register group elements past the element index where a trap is reported; the behavior for elements beyond the trap index is implementation-defined.
VECTOR_LOAD_SEG_FF_OVERWRITE_ELEMENTS_AFTER_FAULT	[no_overwrite, custom]	Zvl32ba	Fault-only-first segment load instructions may overwrite destination vector register group elements beyond the point where a trap is reported or where vl is trimmed; the exact values written may be implementation-defined.
VECTOR_LS_INDEX_MAX_EEW	[8, 16, 32, 64, XLEN]	Zvl32ba	A profile may place an upper limit on the maximum supported index EEW used by vector load/store indexing. For example, some profiles may limit indexing to sizes no larger than XLEN or a fixed EEW value.
VECTOR_LS_MISALIGNED_LEGAL	boolean	Zvl32ba	If an element accessed by a vector memory instruction is not naturally aligned to the size of the element, either the element is transferred successfully or an address misaligned exception is raised on that element. Support for misaligned vector memory accesses is independent of an implementation’s support for misaligned scalar memory accesses.
VECTOR_LS_SEG_PARTIAL_ACCESS	boolean	Zvl32ba	If a trap occurs during access to a segment, it is implementation-defined whether some, all, or none of that segment’s element accesses are performed before the trap is taken.
VECTOR_LS_WHOLEREG_MISALIGNED_LEGAL	boolean	Zvl32ba	Implementations may raise a misaligned address exception for whole-register loads/stores if the base address is not aligned to the maximum of the encoded EEW size (in bytes) or the implementation’s smallest supported SEW (in bytes).
VENDOR_ID_BANK	25-bit integer	Sma	Encodes the number of one-byte continuation codes in the Bank field of mvendorid. iN JEDEC’s parlance, the bank number is one greater than the number of continuation codes; hence, the mvendorid Bank field encodes a value that is one less than the JEDEC bank number.
VENDOR_ID_OFFSET	7-bit integer	Sma	Encodes the final byte of a JEDEC manufactor ID, discarding the parity bit.
VFREDUSUM_FINAL_NODE_ELEMENT_BEHAVIOR	[additive_identity, copy]	Zvl32ba	Implementations are permitted to insert an additional additive identity into the final reduction result, which may affect the final outcome when no active elements are present.
VFREDUSUM_INACTIVE_NODE_ELEMENT_BEHAVIOR	[additive_identity, copy]	Zvl32ba	A reduction node that receives an input derived solely from masked-off elements or elements beyond vl may either treat that input as the additive identity for the appropriate element width or copy the other input through unchanged to the node output.
VFREDUSUM_NAN	[no_change, custom]	Zvl32ba	The reduction tree structure must be deterministic for a given vtype and vl; as a consequence, implementations need not preserve NaN payloads when no elements are active. If no elements are active and the scalar input is NaN, implementations may canonicalize it (and raise an exception if it is a signaling NaN) or pass it through unchanged.
VFREDUSUM_NODE_ROUNDING_BEHAVIOR	[SEW_precision, custom]	Zvl32ba	Each reduction operator computes an exact sum using an ideal scalar floating-point addition, then converts that result into a floating- point format with range and precision at least as large as the element SEW, rounding with the current dynamic rounding mode and raising exceptions as needed. Implementations may choose the exact range and precision per operator.
VILL_SET_ON_RESERVED_VTYPE	boolean	Zvl32ba	Use of vtype encodings with LMUL < SEW_MIN/ELEN is reserved. Implementations may set the `vill` status bit to indicate such vtype encodings are unsupported, providing a software-visible indication of invalid vtype selections.
VLEN	integer	Zvl32ba	The number of bits in a single vector register.
VMID_WIDTH	3-bit integer when `MXLEN` == 32	0 to 14 when `MXLEN` == 64	Ha
Number of bits supported in hgatp.VMID (i.e., the supported width of a virtual machine ID).	VSSTAGE_MODE_BARE	boolean	Ha
Whether or not writing mode=Bare is supported in the vsatp register.	VSSTATUS_VS_EXISTS	boolean	Zvl32ba
Some implementations provide a vsstatus.VS field even when the misa.V bit is clear. This parameter indicates whether vsstatus.VS exists independently of the misa.V setting.	VSTVEC_MODE_DIRECT	boolean	Ha
Whether or not vstvec.MODE supports Direct (0).	VSTVEC_MODE_VECTORED	boolean	Ha
Whether or not stvec.MODE supports Vectored (1).	VSXLEN	1-element to 2-element array of [32, 64]	Ha
Set of XLENs supported in VS-mode. Can be one of: * [32]: VSXLEN is always 32 * [64]: VSXLEN is always 64 * [32, 64]: VSXLEN can be changed (via hstatus.VSXL) between 32 and 64	VS_MODE_ENDIANNESS	[little, big, dynamic]	Ha
Endianness of data in VS-mode. Can be one of: * little: VS-mode data is always little endian * big: VS-mode data is always big endian * dynamic: VS-mode data can be either little or big endian, depending on the CSR field hstatus.VSBE	VUXLEN	1-element to 2-element array of [32, 64]	Ha
Set of XLENs supported in VU-mode. When both 32 and 64 are supported, VUXLEN can be changed via vsstatus.UXL.	VU_MODE_ENDIANNESS	[little, big, dynamic]	Ha

ASID_WIDTH

0 to 9 when MXLEN == 32

0 to 16 when MXLEN == 64

Number of implemented ASID bits. Maximum is 16 for XLEN==64, and 9 for XLEN==32

CACHE_BLOCK_SIZE

1 to 0xffffffffffffffff

(Zicbom pass:[

] Zicbop pass:[

] Zicboz)a

The observable size of a cache block, in bytes

CACHE_BLOCK_SIZE

1 to 0xffffffffffffffff

(Zicbom pass:[

] Zicbop pass:[

] Zicboz)a

The observable size of a cache block, in bytes

CACHE_BLOCK_SIZE

1 to 0xffffffffffffffff

(Zicbom pass:[

] Zicbop pass:[

] Zicboz)a

The observable size of a cache block, in bytes

COUNTINHIBIT_EN

32-element array where:
  [0] is boolean
  [1] is false
  [2] is boolean
additional items are:
  boolean

Sma

Indicates which hardware performance monitor counters can be disabled from mcountinhibit.

An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set COUNTINHIBIT_EN[3] to true.

COUNTINHIBIT_EN[1] can never be true, since it corresponds to mcountinhibit, which is always read-only-0.

ELEN

integer

Zvl32ba

The maximum size in bits of a vector element that any operation can produce or consume.

FOLLOW_VTYPE_RESET_RECOMMENDATION

boolean

Zvl32ba

It is recommended that at reset, vtype.vill is set, the remaining bits in vtype are zero, and vl is set to zero. If this parameter is set to true, this recommendation is followed. If it is false, at reset the respective fields will be UNDEFINED_LEGAL.

FORCE_UPGRADE_CBO_INVAL_TO_FLUSH

boolean

Zicboma

When true, an implementation prohibits setting menvcfg.CBIE == 11 such that all cbo.inval instructions either trap (when menvcfg.CBIE == '00') or flush (when menvcfg.CBIE == '01').

When false, an implementation allows a true INVAL operation for cbo.inval, and thus supports the setting menvcfg.CBIE == 11.

GSTAGE_MODE_BARE

boolean

Whether or not writing mode=Bare is supported in the hgatp register.

HCOUNTENABLE_EN

32-element array of boolean

Indicates which counters can delegated via hcounteren

An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set HCOUNTENABLE_EN[3] to true.

HCOUNTENABLE_EN[0:2] must all be false if Zicntr is not implemented. HCOUNTENABLE_EN[3:31] must all be false if Zihpm is not implemented.

HPM_COUNTER_EN

32-element array where:
  [0] is false
  [1] is false
  [2] is false
additional items are:
  boolean

Smhpma

List of HPM counters that are enabled. There is one entry for each hpmcounter.

The first three entries must be false (as they correspond to CY, IR, TM in, e.g. mhmpcountinhibit) Index 3 in HPM_COUNTER_EN corresponds to hpmcounter3. Index 31 in HPM_COUNTER_EN corresponds to hpmcounter31.

HPM_EVENTS

array of 58-bit integer

Smhpma

List of defined event numbers that can be written into hpmeventN

IGNORE_INVALID_VSATP_MODE_WRITES_WHEN_V_EQ_ZERO

boolean

Whether writes from M-mode, U-mode, or S-mode to vsatp with an illegal mode setting are ignored (as they are with satp), or if they are treated as WARL, leading to undpredictable behavior.

IMPRECISE_VECTOR_TRAP_SETTABLE

boolean

Zvl32ba

Some profiles may provide a privileged configuration bit that selects between precise and imprecise vector trap behavior, allowing flexibility in how traps and partial updates are reported.

JVT_BASE_TYPE

[mask, custom]

Zcmta

Type of the jvt.BASE CSR field. One of:

* mask: jvt.BASE contains one or more implemented bits, which are indicated by JVT_BASE_MASK. * custom: Custom behavior. Will cause hart to enter 'unpredictable' state on a write to jvt.BASE.

JVT_READ_ONLY

boolean

Zcmta

If Zcmt is implemented, JVT is implemented, but can contain a read-only value

LEGAL_VSTART

[1_stride, 2_stride, 4_stride, custom]

Zvl32ba

Implementations may raise illegal-instruction exceptions for vector instructions that specify a vstart value the implementation can never produce under the same vtype configuration (e.g., due to restrictions on supported strides or alignments).

MARCHID_IMPLEMENTED

boolean

Sma

* false: marchid is not implemented, and must be read-only-0 * true: marchid is implemented, and the value is determined by ARCH_ID_VALUE

MCOUNTENABLE_EN

32-element array of boolean

Indicates which counters can be delegated via mcounteren.

An unimplemented counter cannot be specified, i.e., if HPM_COUNTER_EN[3] is false, it would be illegal to set MCOUNTENABLE_EN[3] to true.

MCOUNTENABLE_EN[0:2] must all be false if Zicntr is not implemented. MCOUNTENABLE_EN[3:31] must all be false if Zihpm is not implemented.

MIMPID_IMPLEMENTED

boolean

Sma

* false: mimpid is not implemented, and must be read-only-0 * true: mimpid is implemented, and the value is determined by IMP_ID_VALUE

MISALIGNED_LDST

boolean

Sma

Does the implementation perform non-atomic misaligned loads and stores to main memory (does not affect misaligned support to device memory)? If not, the implementation always throws a misaligned exception.

MISALIGNED_LDST_EXCEPTION_PRIORITY

[low, high]

Sma

The relative priority of a load/store/AMO exception vs. load/store/AMO page-fault or access-fault exceptions.

May be one of:

[separator="!"] !=== ! low ! Misaligned load/store/AMO exceptions are always lower priority than load/store/AMO page-fault and access-fault exceptions. ! high ! Misaligned load/store/AMO exceptions are always higher priority than load/store/AMO page-fault and access-fault exceptions. !===

MISALIGNED_LDST_EXCEPTION_PRIORITY cannot be "high" when MISALIGNED_MAX_ATOMICITY_GRANULE_SIZE is non-zero, since the atomicity of an access cannot be determined in that case until after address translation.

MISA_CSR_IMPLEMENTED

boolean

Sma

Options:

true:: The misa CSR returns a non-zero value.

false:: The misa CSR is read-only-0.

MSTATUS_TVM_IMPLEMENTED

boolean

Whether or not mstatus.TVM is implemented.

When not implemented mstatus.TVM will be read-only-zero.

MTVAL_WIDTH

0 to 32 when MXLEN == 32

0 to 64 when MXLEN == 64

Sma

The number of implemented bits in the mtval CSR. This is the CSR that may be written when a trap is taken into M-mode with exception-specific information to assist software in handling the trap (e.g., address associated with exception).

Must be greater than or equal to max(PHYS_ADDR_WIDTH, VA_SIZE)

MTVEC_ACCESS

[ro, rw]

Sma

Options:

ro:: mtvec is read-only.

rw:: mtvec is read-write, but may not accept all values.

MTVEC_ILLEGAL_WRITE_BEHAVIOR

[retain, custom]

Sma

Options:

retain:: When either mtvec.MODE or mtvec.BASE is illegal, mtvec will retain its current value

custom:: When either mtvec.MODE or mtvec.BASE is illegal, mtvec will obtain an unpredictable value

Other values may be added over time once other common behaviors are identified.

MTVEC_MODES

1-element to 2-element array of [0, 1]

Sma

Options:

0:: Direct; All traps set pc to mtvec.BASE 1:: Vectored; Asynchronous interrupts set pc to mtvec.BASE + 4 x cause.

If only one mode is given, mtvec.MODE is assumed to be read-only with that value. Otherwise, mtvec.MODE is read-write.

MXLEN

[32, 64]

Sma

XLEN in machine mode, specified in bits

M_MODE_ENDIANNESS

[little, big, dynamic]

Sma

Options:

[separator="!"] !=== h! little ! M-mode data is always little endian h! big ! M-mode data is always big endian h! dynamic ! M-mode data can be either little or big endian, depending on the CSR field mstatus.MBE !===

NUM_EXTERNAL_GUEST_INTERRUPTS

1 to 31 when MXLEN == 32

1 to 63 when MXLEN == 64

Number of supported virtualized guest interrupts

Corresponds to the GEILEN parameter in the RVI specs

NUM_PMP_ENTRIES

0 to 64

Smpmpa

Number of implemented PMP entries. Can be any value between 0-64, inclusive.

The architecture mandates that the number of implemented PMP registers must appear to be 0, 16, or 64.

Therefore, pmp registers will behave as follows according to NUN_PMP_ENTRIES:

[separator="!"] !=== ! NUM_PMP_ENTRIES ! pmpaddr<0-15> / pmpcfg<0-3> ! pmpaddr<16-63> / pmpcfg<4-15> ! 0 ! N ! N ! 1-16 ! Y ! N ! 17-64 ! Y ! Y !===

N = Not implemented; access will cause IllegalInstruction if TRAP_ON_UNIMPLEMENTED_CSR is true Y = Implemented; access will not cause an exception (from M-mode), but register may be read-only-zero if NUM_PMP_ENTRIES is less than the corresponding register

[NOTE] pmpcfgN for an odd N never exists when XLEN == 64

When NUM_PMP_ENTRIES is not exactly 0, 16, or 64, some extant pmp registers, and associated pmpNcfg, will be read-only zero (but will never cause an exception).

PHYS_ADDR_WIDTH

1 to 34 when MXLEN == 32

1 to 64 when MXLEN == 64

Sma

Implementation-defined size of the physical address space.

PMA_GRANULARITY

2 to 66

Sma

Generally, for systems with an MMU, should not be smaller than 12, as that would preclude caching PMA results in the TLB along with virtual memory translations

PMP_GRANULARITY

2 to 66

Smpmpa

log2 of the smallest supported PMP region.

Generally, for systems with an MMU, should not be smaller than 12, as that would preclude caching PMP results in the TLB along with virtual memory translations

Note that PMP_GRANULARITY is equal to G+2 (not G) as described in the privileged architecture.

PRECISE_SYNCHRONOUS_EXCEPTIONS

boolean

Sma

If false, any exception not otherwise mandated to precise (e.g., PMP violation) will cause execution to enter an unpredictable state.

REPORT_CAUSE_IN_MTVAL_ON_LANDING_PAD_SOFTWARE_CHECK

boolean

Zicfilpa

When true, mtval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into M-mode due to a landing pad error.

When false, mtval is written with 0.

REPORT_CAUSE_IN_MTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK

boolean

Zicfissa

When true, mtval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into M-mode due to a shadow stack pop check instruction.

When false, mtval is written with 0.

REPORT_CAUSE_IN_STVAL_ON_LANDING_PAD_SOFTWARE_CHECK

boolean

Zicfilpa

When true, stval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into S-mode due to a landing pad error.

When false, stval is written with 0.

REPORT_CAUSE_IN_STVAL_ON_SHADOW_STACK_SOFTWARE_CHECK

boolean

Zicfissa

When true, stval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into S-mode due to a shadow stack pop check instruction.

When false, stval is written with 0.

REPORT_CAUSE_IN_VSTVAL_ON_LANDING_PAD_SOFTWARE_CHECK

boolean

Zicfilpa

When true, vstval is written with the shadow stack cause (code=18) when a SoftwareCheck exception is raised into VS-mode due to a landing pad error.

When false, vstval is written with 0.

REPORT_CAUSE_IN_VSTVAL_ON_SHADOW_STACK_SOFTWARE_CHECK

boolean

Zicfissa

When true, vstval is written with the shadow stack cause (code=3) when a SoftwareCheck exception is raised into VS-mode due to a shadow stack pop check instruction.

When false, vstval is written with 0.

REPORT_ENCODING_IN_MTVAL_ON_ILLEGAL_INSTRUCTION

boolean

Sma

Options:

* true: mtval is written with the encoding of an instruction causing an IllegalInstruction exception * false: mtval is written with 0 when an instruction causes an IllegalInstruction exception.

REPORT_ENCODING_IN_STVAL_ON_ILLEGAL_INSTRUCTION

boolean

When true, stval is written with the encoding of an instruction that causes an IllegalInstruction exception.

When false stval is written with 0 when an IllegalInstruction exception occurs.

REPORT_ENCODING_IN_VSTVAL_ON_ILLEGAL_INSTRUCTION

boolean

When true, vstval is written with the encoding of an instruction that causes an IllegalInstruction exception.

When false vstval is written with 0 when an IllegalInstruction exception occurs.

REPORT_ENCODING_IN_VSTVAL_ON_VIRTUAL_INSTRUCTION

boolean

When true, vstval is written with the encoding of an instruction that causes an VirualInstruction exception.

When false vstval is written with 0 when an VirtualInstruction exception occurs.

REPORT_GPA_IN_HTVAL_ON_GUEST_PAGE_FAULT

boolean

When true, htval is written with the Guest Physical Address, shifted right by 2, that caused a GuestPageFault exception.

When false, htval is written with 0 when a GuestPageFault exception occurs.

REPORT_GPA_IN_TVAL_ON_INSTRUCTION_GUEST_PAGE_FAULT

boolean

Whether or not GPA >> 2 is written into htval/mtval2 when an instruction guest page fault occurs.

If false, 0 will be written into htval/mtval2 on an instruction guest page fault.

REPORT_GPA_IN_TVAL_ON_INTERMEDIATE_GUEST_PAGE_FAULT

boolean

Whether or not GPA >> 2 is written into htval/mtval2 when a guest page fault occurs while walking a VS-mode page table.

If false, 0 will be written into htval/mtval2 on an intermediate guest page fault.

REPORT_GPA_IN_TVAL_ON_LOAD_GUEST_PAGE_FAULT

boolean

Whether or not GPA >> 2 is written into htval/mtval2 when a load guest page fault occurs.

If false, 0 will be written into htval/mtval2 on a load guest page fault.

REPORT_GPA_IN_TVAL_ON_STORE_AMO_GUEST_PAGE_FAULT

boolean

Whether or not GPA >> 2 is written into htval/mtval2 when a store/amo guest page fault occurs.

If false, 0 will be written into htval/mtval2 on a store/amo guest page fault.

REPORT_VA_IN_MTVAL_ON_BREAKPOINT

boolean

Sma

Options:

* true: mtval is written with the virtual PC of an EBREAK instruction (same information as mepc). * false: mtval is written with 0 on an EBREAK instruction.

Regardless, mtval is always written with a virtual PC when an external breakpoint is generated

REPORT_VA_IN_MTVAL_ON_INSTRUCTION_ACCESS_FAULT

boolean

Sma

Options:

* true: mtval is written with the virtual address of a fetch causing the access fault * false: mtval is written with 0 when a fetch causes an access fault

REPORT_VA_IN_MTVAL_ON_INSTRUCTION_MISALIGNED

boolean

Sma

Options:

* true: mtval is written with the virtual address of a trapping misaligned fetch * false: mtval is written with 0 when a misaligned fetch traps

REPORT_VA_IN_MTVAL_ON_INSTRUCTION_PAGE_FAULT

boolean

When true, mtval is written with the virtual PC of an instructino when fetch causes an InstructionPageFault.

WHen false, mtval is written with 0 when an instruction fetch causes an InstructionPageFault.

REPORT_VA_IN_MTVAL_ON_LOAD_ACCESS_FAULT

boolean

Sma

Options:

* true: mtval is written with the virtual address of a load causing the access fault * false: mtval is written with 0 when a load causes an access fault

REPORT_VA_IN_MTVAL_ON_LOAD_MISALIGNED

boolean

Sma

Options:

* true: mtval is written with the virtual address of a trapping misaligned load. * false: mtval is written with 0 when a misaligned load traps.

REPORT_VA_IN_MTVAL_ON_LOAD_PAGE_FAULT

boolean

When true, mtval is written with the virtual address of a load when it causes a LoadPageFault.

WHen false, mtval is written with 0 when a load causes a LoadPageFault.

REPORT_VA_IN_MTVAL_ON_STORE_AMO_ACCESS_FAULT

boolean

Sma

Options:

* true: mtval is written with the virtual address of a store or AMO causing the access fault * false: mtval is written with 0 when a store or AMO causes an access fault

REPORT_VA_IN_MTVAL_ON_STORE_AMO_MISALIGNED

boolean

Sma

Options:

* true: mtval is written with the virtual address of a trapping misaligned store or AMO. * false: mtval is written with 0 when a misaligned store or AMO traps.

REPORT_VA_IN_MTVAL_ON_STORE_AMO_PAGE_FAULT

boolean

When true, mtval is written with the virtual address of a store when it causes a StoreAmoPageFault.

WHen false, mtval is written with 0 when a store causes a StoreAmoPageFault.

REPORT_VA_IN_STVAL_ON_BREAKPOINT

boolean

When true, stval is written with the virtual PC of the EBREAK instruction (same information as mepc).

When false, stval is written with 0 on an EBREAK instruction.

Regardless, stval is always written with a virtual PC when an external breakpoint is generated

REPORT_VA_IN_STVAL_ON_INSTRUCTION_ACCESS_FAULT

boolean

When true, stval is written with the virtual PC of an instructino when fetch causes an InstructionAccessFault.

WHen false, stval is written with 0 when an instruction fetch causes an InstructionAccessFault.

REPORT_VA_IN_STVAL_ON_INSTRUCTION_MISALIGNED

boolean

When true, stval is written with the virtual PC when an instruction fetch is misaligned.

When false, stval is written with 0 when an instruction fetch is misaligned.

Note that when IALIGN=16 (i.e., when the C or one of the Zc* extensions are implemented), it is impossible to generate a misaligned fetch, and so this parameter has no effect.

REPORT_VA_IN_STVAL_ON_INSTRUCTION_PAGE_FAULT

boolean

When true, stval is written with the virtual PC of an instructino when fetch causes an InstructionPageFault.

WHen false, stval is written with 0 when an instruction fetch causes an InstructionPageFault.

REPORT_VA_IN_STVAL_ON_LOAD_ACCESS_FAULT

boolean

When true, stval is written with the virtual address of a load when it causes a LoadAccessFault.

WHen false, stval is written with 0 when a load causes a LoadAccessFault.

REPORT_VA_IN_STVAL_ON_LOAD_MISALIGNED

boolean

When true, stval is written with the virtual address of a load instruction when the address is misaligned and MISALIGNED_LDST is false.

When false, stval is written with 0 when a load address is misaligned and MISALIGNED_LDST is false.

REPORT_VA_IN_STVAL_ON_LOAD_PAGE_FAULT

boolean

When true, stval is written with the virtual address of a load when it causes a LoadPageFault.

WHen false, stval is written with 0 when a load causes a LoadPageFault.

REPORT_VA_IN_STVAL_ON_STORE_AMO_ACCESS_FAULT

boolean

When true, stval is written with the virtual address of a store when it causes a StoreAmoAccessFault.

WHen false, stval is written with 0 when a store causes a StoreAmoAccessFault.

REPORT_VA_IN_STVAL_ON_STORE_AMO_MISALIGNED

boolean

When true, stval is written with the virtual address of a store instruction when the address is misaligned and MISALIGNED_LDST is false.

When false, stval is written with 0 when a store address is misaligned and MISALIGNED_LDST is false.

REPORT_VA_IN_STVAL_ON_STORE_AMO_PAGE_FAULT

boolean

When true, stval is written with the virtual address of a store when it causes a StoreAmoPageFault.

WHen false, stval is written with 0 when a store causes a StoreAmoPageFault.

REPORT_VA_IN_VSTVAL_ON_BREAKPOINT

boolean

When true, vstval is written with the virtual PC of the EBREAK instruction (same information as mepc).

When false, vstval is written with 0 on an EBREAK instruction.

Regardless, vstval is always written with a virtual PC when an external breakpoint is generated.

REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_ACCESS_FAULT

boolean

When true, vstval is written with the virtual PC of an instructino when fetch causes an InstructionAccessFault.

WHen false, vstval is written with 0 when an instruction fetch causes an InstructionAccessFault.

REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_MISALIGNED

boolean

When true, vstval is written with the virtual PC when an instruction fetch is misaligned.

When false, vstval is written with 0 when an instruction fetch is misaligned.

Note that when IALIGN=16 (i.e., when the C or one of the Zc* extensions are implemented), it is impossible to generate a misaligned fetch, and so this parameter has no effect.

REPORT_VA_IN_VSTVAL_ON_INSTRUCTION_PAGE_FAULT

boolean

When true, vstval is written with the virtual PC of an instructino when fetch causes an InstructionPageFault.

WHen false, vstval is written with 0 when an instruction fetch causes an InstructionPageFault.

REPORT_VA_IN_VSTVAL_ON_LOAD_ACCESS_FAULT

boolean

When true, vstval is written with the virtual address of a load when it causes a LoadAccessFault.

WHen false, vstval is written with 0 when a load causes a LoadAccessFault.

REPORT_VA_IN_VSTVAL_ON_LOAD_MISALIGNED

boolean

When true, vstval is written with the virtual address of a load instruction when the address is misaligned and MISALIGNED_LDST is false.

When false, vstval is written with 0 when a load address is misaligned and MISALIGNED_LDST is false.

REPORT_VA_IN_VSTVAL_ON_LOAD_PAGE_FAULT

boolean

When true, vstval is written with the virtual address of a load when it causes a LoadPageFault.

WHen false, vstval is written with 0 when a load causes a LoadPageFault.

REPORT_VA_IN_VSTVAL_ON_STORE_AMO_ACCESS_FAULT

boolean

When true, vstval is written with the virtual address of a store when it causes a StoreAmoAccessFault.

WHen false, vstval is written with 0 when a store causes a StoreAmoAccessFault.

REPORT_VA_IN_VSTVAL_ON_STORE_AMO_MISALIGNED

boolean

When true, vstval is written with the virtual address of a store instruction when the address is misaligned and MISALIGNED_LDST is false.

When false, vstval is written with 0 when a store address is misaligned and MISALIGNED_LDST is false.

REPORT_VA_IN_VSTVAL_ON_STORE_AMO_PAGE_FAULT

boolean

When true, vstval is written with the virtual address of a store when it causes a StoreAmoPageFault.

WHen false, vstval is written with 0 when a store causes a StoreAmoPageFault.

RESERVED_VSET_X0X0_VILL_SET

[never, always, custom]

Zvl32ba

When rs1 = x0 and rd = x0, vset instructions act as if the current vector length in vl is used as the AVL. If vill is set or the configuration is reserved, implementations may set vill to indicate unsupported use of these encodings.

RESERVED_VSET_X0X0_VLMAX_CHANGE

[never, always, custom]

Zvl32ba

When rs1=x0 and rd=x0, the instructions operate as if the current vector length in vl is used as the AVL. Use of the vset instructions with a new SEW/LMUL ratio that would result in a change of VLMAX is reserved. Implementations may set vill in either case.

RVV_VL_WHEN_AVL_LT_DOUBLE_VLMAX

[ceil(AVL/2), VLMAX, custom]

Zvl32ba

The value assigned to VL when AVL < 2*VLMAX.

SATP_MODE_BARE

boolean

Whether or not satp.MODE == Bare is supported.

SEW_MIN

[8, 16, 32, 64]

Zvl32ba

Implementations must provide fractional LMUL settings that allow the narrowest supported element width (SEW) to occupy a fractional portion of a vector register relative to the widest supported SEW. In general, implementations must support LMUL >= SEW_MIN/ELEN, where SEW_MIN is the narrowest supported SEW and ELEN is the widest SEW.

STVAL_WIDTH

≤ 0xffffffffffffffff

The number of implemented bits in stval.

Must be greater than or equal to max(PHYS_ADDR_WIDTH, VA_SIZE)

STVEC_MODE_DIRECT

boolean

Whether or not stvec.MODE supports Direct (0).

STVEC_MODE_VECTORED

boolean

Whether or not stvec.MODE supports Vectored (1).

SUPPORT_FRACTIONAL_LMUL_BEYOND_REQUIRED

[no_unrequired_supported, custom]

Zvl32ba

For a given supported fractional LMUL setting, implementations must provide support for SEW settings covering the range from SEW_MIN up to LMUL * ELEN, inclusive. This ensures types narrower than the maximum SEW are supported when fractional LMULs are selected.

SXLEN

1-element to 2-element array of [32, 64]

Set of XLENs supported in S-mode. Can be one of:

* 32: SXLEN is always 32 * 64: SXLEN is always 64 * [32, 64]: SXLEN can be changed (via mstatus.SXL) between 32 and 64

S_MODE_ENDIANNESS

[little, big, dynamic]

Endianness of data in S-mode. Can be one of:

* little: S-mode data is always little endian * big: S-mode data is always big endian * dynamic: S-mode data can be either little or big endian, depending on the CSR field mstatus.SBE

TIME_CSR_IMPLEMENTED

boolean

Zicntra

Whether or not a real hardware time CSR exists. Implementations can either provide a real CSR or emulate access at M-mode.

Possible values:

true:: time/timeh exists, and accessing it will not cause an IllegalInstruction trap

false:: time/timeh does not exist. Accessing the CSR will cause an IllegalInstruction trap or enter an unpredictable state, depending on TRAP_ON_UNIMPLEMENTED_CSR. Privileged software may emulate the time CSR, or may pass the exception to a lower level.

TINST_VALUE_ON_BREAKPOINT

[always zero, custom]

Value written into htinst/mtinst on a Breakpoint exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_FINAL_INSTRUCTION_GUEST_PAGE_FAULT

[always zero, always pseudoinstruction]

Value to write into htval/mtval2 when there is a guest page fault on a final translation.

Possible values: * "always zero": Always write the value zero * "always pseudoinstruction": Always write the pseudoinstruction

TINST_VALUE_ON_FINAL_LOAD_GUEST_PAGE_FAULT

[always zero, always pseudoinstruction, always transformed standard instruction, custom]

Value to write into htval/mtval2 when there is a guest page fault on a final translation.

Possible values: * "always zero": Always write the value zero * "always pseudoinstruction": Always write the pseudoinstruction * "always transformed standard instruction": Always write the transformation of the standard instruction encoding * "custom": A custom value, which will cause an UNPREDICTABLE event.

TINST_VALUE_ON_FINAL_STORE_AMO_GUEST_PAGE_FAULT

[always zero, always pseudoinstruction, always transformed standard instruction, custom]

Value to write into htval/mtval2 when there is a guest page fault on a final translation.

TINST_VALUE_ON_INSTRUCTION_ADDRESS_MISALIGNED

[always zero, custom]

Value written into htinst/mtinst when there is an instruction address misaligned exception.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_LOAD_ACCESS_FAULT

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on an AccessFault exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "always transformed standard instruction": Always write a transformed standard instruction as defined by H * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_LOAD_ADDRESS_MISALIGNED

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode.

TINST_VALUE_ON_LOAD_PAGE_FAULT

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on a LoadPageFault exception from VU/VS-mode.

TINST_VALUE_ON_MCALL

[always zero, custom]

Value written into htinst/mtinst on a MCall exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_SCALL

[always zero, custom]

Value written into htinst/mtinst on a SCall exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_STORE_AMO_ACCESS_FAULT

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on an AccessFault exception from VU/VS-mode.

TINST_VALUE_ON_STORE_AMO_ADDRESS_MISALIGNED

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode.

TINST_VALUE_ON_STORE_AMO_PAGE_FAULT

[always zero, always transformed standard instruction, custom]

Value written into htinst/mtinst on a StoreAmoPageFault exception from VU/VS-mode.

TINST_VALUE_ON_UCALL

[always zero, custom]

Value written into htinst/mtinst on a UCall exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_VIRTUAL_INSTRUCTION

[always zero, custom]

Value written into htinst/mtinst on a VirtualInstruction exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TINST_VALUE_ON_VSCALL

[always zero, custom]

Value written into htinst/mtinst on a VSCall exception from VU/VS-mode.

Possible values: * "always zero": Always write the value zero * "custom": Write a custom value, which results in UNPREDICTABLE

TRAP_ON_EBREAK

boolean

Sma

The spec states that implementations may handle EBREAKs transparently without raising a trap, in which case the EEI must provide a builtin.

TRAP_ON_ECALL_FROM_M

boolean

Sma

The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.

TRAP_ON_ECALL_FROM_S

boolean

Whether or not an ECALL-from-S-mode causes a synchronous exception.

The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.

TRAP_ON_ECALL_FROM_U

boolean

Whether or not an ECALL-from-U-mode causes a synchronous exception.

The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.

TRAP_ON_ECALL_FROM_VS

boolean

Whether or not an ECALL-from-VS-mode causes a synchronous exception.

The spec states that implementations may handle ECALLs transparently without raising a trap, in which case the EEI must provide a builtin.

TRAP_ON_ILLEGAL_WLRL

boolean

Sma

Options:

* true: Writing an illegal value to a WLRL CSR field will cause an IllegalInstruction exception. * false: Writing an illegal value to a WLRL CSR field causes unpredictable behavior.

TRAP_ON_RESERVED_INSTRUCTION

boolean

Sma

Options:

* true: Fetching an unimplemented and/or undefined instruction from the standard/reserved opcode space will cause an IllegalInstruction exception. * false: Fetching an unimplemented and/or undefined instruction from the standard/reserved opcose space causes unpredictable behavior.

TRAP_ON_RESERVED_INSTRUCTION may be false while TRAP_ON_UNIMPLEMENTED_INSTRUCTION is true when a custom instruction is implemented in the standard/reserved opcode space.

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY

boolean

(S && (Sv32 pass:[

] Sv39 pass:[

] Sv48 pass:[

] Sv57))a

For implementations that make satp.MODE read-only zero (always Bare, i.e., no virtual translation is implemented), attempts to execute an SFENCE.VMA instruction might raise an illegal-instruction exception.

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY indicates whether or not that exception occurs.

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY has no effect when some virtual translation mode is supported.

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY

boolean

(S && (Sv32 pass:[

] Sv39 pass:[

] Sv48 pass:[

] Sv57))a

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY indicates whether or not that exception occurs.

TRAP_ON_SFENCE_VMA_WHEN_SATP_MODE_IS_READ_ONLY has no effect when some virtual translation mode is supported.

TRAP_ON_UNIMPLEMENTED_CSR

boolean

Sma

Options:

* true: Accessing an unimplemented CSR (via a Zicsr instruction) will cause an IllegalInstruction exception. * false: Accessing an unimplemented CSR (via a Zicsr instruction) will cause unpredictable behavior.

TRAP_ON_UNIMPLEMENTED_INSTRUCTION

boolean

Sma

Options:

* true: Fetching an unimplemented instruction will cause an IllegalInstruction exception. * false: Fetching an unimplemented instruction causes unpredictable behavior.

An unimplemented instruction is any instruction encoding that is not defined by the implementation. Custom instructions are considered implemented.

UXLEN

1-element to 2-element array of [32, 64]

Set of XLENs supported in U-mode. When both 32 and 64 are supported, SXLEN can be changed, via mstatus.UXL, between 32 and 64.

U_MODE_ENDIANNESS

[little, big, dynamic]

Endianness of data in U-mode. Can be one of:

* little: U-mode data is always little endian * big: U-mode data is always big endian * dynamic: U-mode data can be either little or big endian, depending on the CSR field mstatus.UBE

VECTOR_FF_NO_EXCEPTION_TRIM

boolean

Zvl32ba

Implementations may process fewer than vl elements and reduce vl even when no exception occurs. However, if vstart == 0 and vl > 0, at least one element must be processed.

VECTOR_FF_SEG_EXCEPTION_PARTIAL_LOAD

[no_subsegment_loaded, custom]

Zvl32ba

For fault-only-first segment loads, if an exception occurs partway through the zeroth segment, the trap is taken. If it occurs in a subsequent segment, vl may be reduced to the index of that segment. It is implementation-defined whether a partial subset of the segment is loaded before the trap.

VECTOR_FF_UPDATE_PAST_TRIM

[update_none, custom]

Zvl32ba

Fault-only-first (FF) load instructions may update active destination elements beyond the index that causes vector-length trimming, but not past the original vl. These spurious updates need not reflect the true memory contents; non-idempotent memory should only be accessed when the load is guaranteed not to be retried.

VECTOR_LOAD_PAST_TRAP

boolean

Zvl32ba

Vector load instructions may overwrite active destination vector register group elements past the element index where a trap is reported; the behavior for elements beyond the trap index is implementation-defined.

VECTOR_LOAD_SEG_FF_OVERWRITE_ELEMENTS_AFTER_FAULT

[no_overwrite, custom]

Zvl32ba

Fault-only-first segment load instructions may overwrite destination vector register group elements beyond the point where a trap is reported or where vl is trimmed; the exact values written may be implementation-defined.

VECTOR_LS_INDEX_MAX_EEW

[8, 16, 32, 64, XLEN]

Zvl32ba

A profile may place an upper limit on the maximum supported index EEW used by vector load/store indexing. For example, some profiles may limit indexing to sizes no larger than XLEN or a fixed EEW value.

VECTOR_LS_MISALIGNED_LEGAL

boolean

Zvl32ba

If an element accessed by a vector memory instruction is not naturally aligned to the size of the element, either the element is transferred successfully or an address misaligned exception is raised on that element. Support for misaligned vector memory accesses is independent of an implementation’s support for misaligned scalar memory accesses.

VECTOR_LS_SEG_PARTIAL_ACCESS

boolean

Zvl32ba

If a trap occurs during access to a segment, it is implementation-defined whether some, all, or none of that segment’s element accesses are performed before the trap is taken.

VECTOR_LS_WHOLEREG_MISALIGNED_LEGAL

boolean

Zvl32ba

Implementations may raise a misaligned address exception for whole-register loads/stores if the base address is not aligned to the maximum of the encoded EEW size (in bytes) or the implementation’s smallest supported SEW (in bytes).

VENDOR_ID_BANK

25-bit integer

Sma

Encodes the number of one-byte continuation codes in the Bank field of mvendorid.

iN JEDEC’s parlance, the bank number is one greater than the number of continuation codes; hence, the mvendorid Bank field encodes a value that is one less than the JEDEC bank number.

VENDOR_ID_OFFSET

7-bit integer

Sma

Encodes the final byte of a JEDEC manufactor ID, discarding the parity bit.

VFREDUSUM_FINAL_NODE_ELEMENT_BEHAVIOR

[additive_identity, copy]

Zvl32ba

Implementations are permitted to insert an additional additive identity into the final reduction result, which may affect the final outcome when no active elements are present.

VFREDUSUM_INACTIVE_NODE_ELEMENT_BEHAVIOR

[additive_identity, copy]

Zvl32ba

A reduction node that receives an input derived solely from masked-off elements or elements beyond vl may either treat that input as the additive identity for the appropriate element width or copy the other input through unchanged to the node output.

VFREDUSUM_NAN

[no_change, custom]

Zvl32ba

The reduction tree structure must be deterministic for a given vtype and vl; as a consequence, implementations need not preserve NaN payloads when no elements are active. If no elements are active and the scalar input is NaN, implementations may canonicalize it (and raise an exception if it is a signaling NaN) or pass it through unchanged.

VFREDUSUM_NODE_ROUNDING_BEHAVIOR

[SEW_precision, custom]

Zvl32ba

Each reduction operator computes an exact sum using an ideal scalar floating-point addition, then converts that result into a floating- point format with range and precision at least as large as the element SEW, rounding with the current dynamic rounding mode and raising exceptions as needed. Implementations may choose the exact range and precision per operator.

VILL_SET_ON_RESERVED_VTYPE

boolean

Zvl32ba

Use of vtype encodings with LMUL < SEW_MIN/ELEN is reserved. Implementations may set the vill status bit to indicate such vtype encodings are unsupported, providing a software-visible indication of invalid vtype selections.

VLEN

integer

Zvl32ba

The number of bits in a single vector register.

VMID_WIDTH

3-bit integer when MXLEN == 32

0 to 14 when MXLEN == 64

Number of bits supported in hgatp.VMID (i.e., the supported width of a virtual machine ID).

VSSTAGE_MODE_BARE

boolean

Whether or not writing mode=Bare is supported in the vsatp register.

VSSTATUS_VS_EXISTS

boolean

Zvl32ba

Some implementations provide a vsstatus.VS field even when the misa.V bit is clear. This parameter indicates whether vsstatus.VS exists independently of the misa.V setting.

VSTVEC_MODE_DIRECT

boolean

Whether or not vstvec.MODE supports Direct (0).

VSTVEC_MODE_VECTORED

boolean

Whether or not stvec.MODE supports Vectored (1).

VSXLEN

1-element to 2-element array of [32, 64]

Set of XLENs supported in VS-mode. Can be one of:

* [32]: VSXLEN is always 32 * [64]: VSXLEN is always 64 * [32, 64]: VSXLEN can be changed (via hstatus.VSXL) between 32 and 64

VS_MODE_ENDIANNESS

[little, big, dynamic]

Endianness of data in VS-mode. Can be one of:

* little: VS-mode data is always little endian * big: VS-mode data is always big endian * dynamic: VS-mode data can be either little or big endian, depending on the CSR field hstatus.VSBE

VUXLEN

1-element to 2-element array of [32, 64]

Set of XLENs supported in VU-mode. When both 32 and 64 are supported, VUXLEN can be changed via vsstatus.UXL.

VU_MODE_ENDIANNESS

[little, big, dynamic]