Architectural Parameters

The following 141 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. COUNTINHIBIT_EN[3:31] must all be false if Zihpm is not implemented.	ELEN	integer	Va
The maximum size in bits of a vector element that any operation can produce or consume.	FOLLOW_VTYPE_RESET_RECOMMENDATION	boolean	Va
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	HW_MSTATUS_FS_DIRTY_UPDATE	[never, precise, imprecise]	Fa
Indicates whether or not hardware will write to mstatus.FS Values are: [separator="!"] !=== h! never ! Hardware never writes mstatus.FS h! precise ! Hardware writes mstatus.FS to the Dirty (3) state precisely when F registers are modified h! imprecise ! Hardware writes mstatus.FS imprecisely. This will result in a call to unpredictable() on any attempt to read mstatus or write FP state. !===	HW_MSTATUS_VS_DIRTY_UPDATE	[never, precise, imprecise]	Va
Indicates whether or not hardware will write to mstatus.VS Values are: [separator="!"] !=== h! never ! Hardware never writes mstatus.VS h! precise ! Hardware writes mstatus.VS to the Dirty (3) state precisely when V registers are modified h! imprecise ! Hardware writes mstatus.VS imprecisely. This will result in a call to unpredictable() on any attempt to read mstatus or write vector state. !===	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.	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	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_FS_LEGAL_VALUES	1-element to 4-element array of [0, 1, 2, 3]	(F pass:[
	] S)a	The set of values that mstatus.FS supports.	MSTATUS_FS_LEGAL_VALUES
1-element to 4-element array of [0, 1, 2, 3]	(F pass:[		] S)a
The set of values that mstatus.FS supports.	MSTATUS_TVM_IMPLEMENTED	boolean	Sa
Whether or not mstatus.TVM is implemented. When not implemented mstatus.TVM will be read-only-zero.	MSTATUS_VS_LEGAL_VALUES	1-element to 4-element array of [0, 1, 2, 3]	(V pass:[
	] S)a	The set of values that mstatus.VS will accept from a software write.	MSTATUS_VS_LEGAL_VALUES
1-element to 4-element array of [0, 1, 2, 3]	(V pass:[		] S)a
The set of values that mstatus.VS will accept from a software write.	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 curent 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.	MUTABLE_MISA_A	boolean
Aa	When the A extensions is supported, indicates whether or not the extension can be disabled in the misa.A bit.	MUTABLE_MISA_B	boolean
Ba	Indicates whether or not the B extension can be disabled with the misa.B bit.	MUTABLE_MISA_C	boolean
Ca	Indicates whether or not the C extension can be disabled with the misa.C bit.	MUTABLE_MISA_D	boolean
Da	Indicates whether or not the D extension can be disabled with the misa.D bit.	MUTABLE_MISA_F	boolean
Fa	Indicates whether or not the F extension can be disabled with the misa.F bit.	MUTABLE_MISA_H	boolean
Ha	Indicates whether or not the H extension can be disabled with the misa.H bit.	MUTABLE_MISA_M	boolean
Ma	Indicates whether or not the M extension can be disabled with the misa.M bit.	MUTABLE_MISA_S	boolean
Sa	Indicates whether or not the S extension can be disabled with the misa.S bit.	MUTABLE_MISA_U	boolean
Ua	Indicates whether or not the U extension can be disabled with the misa.U bit.	MUTABLE_MISA_V	boolean
Va	Indicates whether or not the V extension can be disabled with the misa.V bit.	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`.
RVV_VL_WHEN_AVL_LT_DOUBLE_VLMAX	[ceil(AVL/2), VLMAX, custom]	Va	The value assigned to VL when AVL < 2*VLMAX.
SATP_MODE_BARE	boolean	Sa	Whether or not satp.MODE == Bare is supported.
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).
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_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
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.
VLEN	integer	Va	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.	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.

COUNTINHIBIT_EN[3:31] must all be false if Zihpm is not implemented.

ELEN

integer

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

FOLLOW_VTYPE_RESET_RECOMMENDATION

boolean

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

HW_MSTATUS_FS_DIRTY_UPDATE

[never, precise, imprecise]

Indicates whether or not hardware will write to mstatus.FS

Values are: [separator="!"] !=== h! never ! Hardware never writes mstatus.FS h! precise ! Hardware writes mstatus.FS to the Dirty (3) state precisely when F registers are modified h! imprecise ! Hardware writes mstatus.FS imprecisely. This will result in a call to unpredictable() on any attempt to read mstatus or write FP state. !===

HW_MSTATUS_VS_DIRTY_UPDATE

[never, precise, imprecise]

Indicates whether or not hardware will write to mstatus.VS

Values are: [separator="!"] !=== h! never ! Hardware never writes mstatus.VS h! precise ! Hardware writes mstatus.VS to the Dirty (3) state precisely when V registers are modified h! imprecise ! Hardware writes mstatus.VS imprecisely. This will result in a call to unpredictable() on any attempt to read mstatus or write vector state. !===

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.

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

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_FS_LEGAL_VALUES

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

(F pass:[

] S)a

The set of values that mstatus.FS supports.

MSTATUS_FS_LEGAL_VALUES

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

(F pass:[

] S)a

The set of values that mstatus.FS supports.

MSTATUS_TVM_IMPLEMENTED

boolean

Whether or not mstatus.TVM is implemented.

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

MSTATUS_VS_LEGAL_VALUES

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

(V pass:[

] S)a

The set of values that mstatus.VS will accept from a software write.

MSTATUS_VS_LEGAL_VALUES

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

(V pass:[

] S)a

The set of values that mstatus.VS will accept from a software write.

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 curent 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.

MUTABLE_MISA_A

boolean

When the A extensions is supported, indicates whether or not the extension can be disabled in the misa.A bit.

MUTABLE_MISA_B

boolean

Indicates whether or not the B extension can be disabled with the misa.B bit.

MUTABLE_MISA_C

boolean

Indicates whether or not the C extension can be disabled with the misa.C bit.

MUTABLE_MISA_D

boolean

Indicates whether or not the D extension can be disabled with the misa.D bit.

MUTABLE_MISA_F

boolean

Indicates whether or not the F extension can be disabled with the misa.F bit.

MUTABLE_MISA_H

boolean

Indicates whether or not the H extension can be disabled with the misa.H bit.

MUTABLE_MISA_M

boolean

Indicates whether or not the M extension can be disabled with the misa.M bit.

MUTABLE_MISA_S

boolean

Indicates whether or not the S extension can be disabled with the misa.S bit.

MUTABLE_MISA_U

boolean

Indicates whether or not the U extension can be disabled with the misa.U bit.

MUTABLE_MISA_V

boolean

Indicates whether or not the V extension can be disabled with the misa.V bit.

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.

RVV_VL_WHEN_AVL_LT_DOUBLE_VLMAX

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

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

SATP_MODE_BARE

boolean

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

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).

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_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

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.

VLEN

integer

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.

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]