target/riscv: fix RV32 henvcfg/stateen CSR handling
cover target/riscv: fix RV32 henvcfg/stateen CSR handling
This series fixes two RV32-specific CSR handling issues in target/riscv.
The first patch fixes write_henvcfg() so that an RV32 write to henvcfg does not clear the upper-half bits implemented in henvcfgh.
The second patch fixes the RV32 split handling of the stateen CSRs by rejecting the xH CSRs on RV64, placing the upper-half mask bits in the *stateen0h write paths on RV32, and dropping the unsupported writable bits from sstateen0.
Bruno Sa (2):
target/riscv: preserve RV32 henvcfgh on henvcfg writes target/riscv: fix RV32 stateen CSR handling
target/riscv/csr.c | 122 ++++++++++++++++++++++++++++++++------------- 1 file changed, 86 insertions(+), 36 deletions(-)
Signature · 1 line
2.43.0
PATCH 1/2 target/riscv: preserve RV32 henvcfgh on henvcfg writes
On RV32, STCE/ADUE/PBMTE/DTE are implemented in henvcfgh. A write to henvcfg should therefore only update the low 32 bits of env->henvcfg.
The current write_henvcfg() path overwrites env->henvcfg with the low-half value and clears any bits previously written via henvcfgh.
Preserve the upper 32 bits on RV32 henvcfg writes and keep the existing RV64 behaviour unchanged.
--- target/riscv/csr.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
target/riscv/csr.c +9 -1
@@ -3326,7 +3326,15 @@ static RISCVException write_henvcfg(CPURISCVState *env, int csrno, } } - env->henvcfg = val & mask; +if (riscv_cpu_mxl (env) ==MXL_RV32 ) { +/* +* RV32 stores STCE/ADUE/PBMTE/DTE in henvcfgh, so a low-half henvcfg +* write must not clobber the upper 32 bits. +*/ + env->henvcfg = (env->henvcfg & ~0xFFFFFFFFULL ) | (val & mask); + }else { + env->henvcfg = val & mask; + }if ((env->henvcfg &HENVCFG_DTE ) ==0 ) { env->vsstatus &= ~MSTATUS_SDT ; }
Signature · 1 line
2.43.0
Re: [PATCH 1/2] target/riscv: preserve RV32 henvcfgh on henvcfg writes
Quoted 11 lines · Bruno Sa
On RV32, STCE/ADUE/PBMTE/DTE are implemented in henvcfgh. A write to henvcfg should therefore only update the low 32 bits of
env->henvcfg.The current
write_henvcfg()path overwritesenv->henvcfgwith the low-half value and clears any bits previously written via henvcfgh.Preserve the upper 32 bits on RV32 henvcfg writes and keep the existing RV64 behaviour unchanged.
Signed-off-by Bruno Sa <[email protected]>
Alistair
Quoted 29 lines
--- target/riscv/csr.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)target/riscv/csr.c +9
-2@@ -3326,7 +3326,15 @@ static RISCVException write_henvcfg(CPURISCVState *env, int csrno, } } - env->henvcfg = val & mask; +if (riscv_cpu_mxl (env) ==MXL_RV32 ) { +/* +* RV32 stores STCE/ADUE/PBMTE/DTE in henvcfgh, so a low-half henvcfg +* write must not clobber the upper 32 bits. +*/ + env->henvcfg = (env->henvcfg & ~0xFFFFFFFFULL ) | (val & mask); + }else { + env->henvcfg = val & mask; + }if ((env->henvcfg &HENVCFG_DTE ) ==0 ) { env->vsstatus &= ~MSTATUS_SDT ; } --2.43.0
PATCH 2/2 target/riscv: fix RV32 stateen CSR handling
In reply to Bruno SaThe RV32 stateen CSRs are split between the low-half CSR and the corresponding xH CSR, but the current implementation still handles some upper-half bits through the low-half write paths and also accepts the xH CSRs on RV64.
Fix this by:
- rejecting mstateen*h and hstateen*h accesses on RV64
- keeping the RV64-only writable bits in the low-half write paths
- handling the RV32 upper-half writable bits in write_mstateen0h() and write_hstateen0h()
- dropping unsupported writable bits from write_sstateen0()
--- target/riscv/csr.c | 112 +++++++++++++++++++++++++++++++-------------- 1 file changed, 77 insertions(+), 35 deletions(-)
target/riscv/csr.c +77 -35
@@ -497,6 +497,15 @@ static RISCVException mstateen(CPURISCVState *env, int csrno)return any (env, csrno); } +static RISCVException mstateen_32 (CPURISCVState *env,int csrno) +{ +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } + +return mstateen (env, csrno); +} +static RISCVException hstateen_pred (CPURISCVState *env,int csrno,int base) {if (!riscv_cpu_cfg (env)->ext_smstateen) {
@@ -528,6 +537,10 @@ static RISCVException hstateen(CPURISCVState *env, int csrno)static RISCVException hstateenh (CPURISCVState *env,int csrno) { +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } +return hstateen_pred (env, csrno,CSR_HSTATEEN0H ); }
@@ -3403,25 +3416,27 @@ static RISCVException write_mstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { - wr_mask |=SMSTATEEN0_P1P13 ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { + wr_mask |=SMSTATEEN0_P1P13 ; + } -if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Smaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_smaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_mstateen (env, csrno, wr_mask, new_val);
@@ -3463,6 +3478,19 @@ static RISCVException write_mstateen0h(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_P1P13 ; } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }
@@ -3507,22 +3535,23 @@ static RISCVException write_hstateen0(CPURISCVState *env, int csrno,if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ; } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } - -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Ssaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_ssaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_hstateen (env, csrno, wr_mask, new_val);
@@ -3564,6 +3593,19 @@ static RISCVException write_hstateen0h(CPURISCVState *env, int csrno, {uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }
@@ -3613,7 +3655,7 @@ static RISCVException write_sstateen(CPURISCVState *env, int csrno,static RISCVException write_sstateen0 (CPURISCVState *env,int csrno,target_ulong new_val) { -uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +uint64_t wr_mask =0 ;if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ;
@@ -5861,25 +5903,25 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { /* Smstateen extension CSRs */ [CSR_MSTATEEN0] = { "mstateen0", mstateen, read_mstateen, write_mstateen0, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN0H] = { "mstateen0h", mstateen, read_mstateenh, + [CSR_MSTATEEN0H] = { "mstateen0h", mstateen_32, read_mstateenh, write_mstateen0h, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN1] = { "mstateen1", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN1H] = { "mstateen1h", mstateen, read_mstateenh, + [CSR_MSTATEEN1H] = { "mstateen1h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN2] = { "mstateen2", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN2H] = { "mstateen2h", mstateen, read_mstateenh, + [CSR_MSTATEEN2H] = { "mstateen2h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN3] = { "mstateen3", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN3H] = { "mstateen3h", mstateen, read_mstateenh, + [CSR_MSTATEEN3H] = { "mstateen3h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_HSTATEEN0] = { "hstateen0", hstateen, read_hstateen, write_hstateen0,
Signature · 1 line
2.43.0
Re: [PATCH 2/2] target/riscv: fix RV32 stateen CSR handling
Quoted 6 lines · Bruno Sa
The RV32 stateen CSRs are split between the low-half CSR and the corresponding xH CSR, but the current implementation still handles some upper-half bits through the low-half write paths and also accepts the xH CSRs on RV64.
Quoted 8 lines
Fix this by:
- rejecting mstateen*h and hstateen*h accesses on RV64
- keeping the RV64-only writable bits in the low-half write paths
- handling the RV32 upper-half writable bits inwrite_mstateen0h()andwrite_hstateen0h()
- dropping unsupported writable bits fromwrite_sstateen0()Signed-off-by Bruno Sa <[email protected]>
Alistair
Quoted 200 lines
--- target/riscv/csr.c | 112 +++++++++++++++++++++++++++++++-------------- 1 file changed, 77 insertions(+), 35 deletions(-)target/riscv/csr.c +77
-36@@ -497,6 +497,15 @@ static RISCVException mstateen(CPURISCVState *env, int csrno)return any (env, csrno); } +static RISCVException mstateen_32 (CPURISCVState *env,int csrno) +{ +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } + +return mstateen (env, csrno); +} +static RISCVException hstateen_pred (CPURISCVState *env,int csrno,int base) {if (!riscv_cpu_cfg (env)->ext_smstateen) {@@ -528,6 +537,10 @@ static RISCVException hstateen(CPURISCVState *env, int csrno)static RISCVException hstateenh (CPURISCVState *env,int csrno) { +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } +return hstateen_pred (env, csrno,CSR_HSTATEEN0H ); }@@ -3403,25 +3416,27 @@ static RISCVException write_mstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { - wr_mask |=SMSTATEEN0_P1P13 ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { + wr_mask |=SMSTATEEN0_P1P13 ; + } -if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Smaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_smaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_mstateen (env, csrno, wr_mask, new_val);@@ -3463,6 +3478,19 @@ static RISCVException write_mstateen0h(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_P1P13 ; } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }@@ -3507,22 +3535,23 @@ static RISCVException write_hstateen0(CPURISCVState *env, int csrno,if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ; } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } - -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Ssaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_ssaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_hstateen (env, csrno, wr_mask, new_val);@@ -3564,6 +3593,19 @@ static RISCVException write_hstateen0h(CPURISCVState *env, int csrno, {uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is +* implemented. However, that information is with MachineState and we can't +* figure that out in csr.c. Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }@@ -3613,7 +3655,7 @@ static RISCVException write_sstateen(CPURISCVState *env, int csrno,static RISCVException write_sstateen0 (CPURISCVState *env,int csrno,target_ulong new_val) { -uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +uint64_t wr_mask =0 ;if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ;@@ -5861,25 +5903,25 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { /* Smstateen extension CSRs */ [CSR_MSTATEEN0] = { "mstateen0", mstateen, read_mstateen, write_mstateen0, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN0H ] = {"mstateen0h" , mstateen, read_mstateenh, + [CSR_MSTATEEN0H] = { "mstateen0h", mstateen_32, read_mstateenh, write_mstateen0h, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN1] = { "mstateen1", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN1H ] = {"mstateen1h" , mstateen, read_mstateenh, + [CSR_MSTATEEN1H] = { "mstateen1h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN2] = { "mstateen2", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN2H ] = {"mstateen2h" , mstateen, read_mstateenh, + [CSR_MSTATEEN2H] = { "mstateen2h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN3] = { "mstateen3", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN3H ] = {"mstateen3h" , mstateen, read_mstateenh, + [CSR_MSTATEEN3H] = { "mstateen3h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_HSTATEEN0] = { "hstateen0", hstateen, read_hstateen, write_hstateen0, --2.43.0
Quoted 6 lines · Bruno Sa
This series fixes two RV32-specific CSR handling issues in target/riscv.
The first patch fixes
write_henvcfg()so that an RV32 write to henvcfg does not clear the upper-half bits implemented in henvcfgh.
Quoted 8 lines
The second patch fixes the RV32 split handling of the stateen CSRs by rejecting the xH CSRs on RV64, placing the upper-half mask bits in the *stateen0h write paths on RV32, and dropping the unsupported writable bits from sstateen0.
Bruno Sa (2):
target/riscv: preserve RV32 henvcfgh on henvcfg writes target/riscv: fix RV32 stateen CSR handling
Thanks for the patches.
I have applied patch 1 to my tree, but patch 2 doesn't seem to apply. Do you mind rebasing it on
https://github.com/alistair23/qemu/tree/riscv-to-apply.next and resending a v2
Alistair
Quoted 7 lines
target/riscv/csr.c | 122 ++++++++++++++++++++++++++++++++------------- 1 file changed, 86 insertions(+), 36 deletions(-)--
2.43.0
PATCH v2 1/1 target/riscv: fix RV32 stateen CSR handling
In reply to Bruno SaThe RV32 stateen CSRs are split between the low-half CSR and the corresponding xH CSR, but the current implementation still handles some upper-half bits through the low-half write paths and also accepts the xH CSRs on RV64.
Fix this by:
- rejecting mstateen*h and hstateen*h accesses on RV64
- keeping the RV64-only writable bits in the low-half write paths
- handling the RV32 upper-half writable bits in write_mstateen0h() and write_hstateen0h()
- dropping unsupported writable bits from write_sstateen0()
---
v2:
- rebase on riscv-to-apply.next
- resend only patch 2 after patch 1 was applied
- wrap the AIA comment text to keep checkpatch clean
target/riscv/csr.c | 117 ++++++++++++++++++++++++++++++++------------- 1 file changed, 83 insertions(+), 34 deletions(-)
target/riscv/csr.c +83 -34
@@ -502,6 +502,15 @@ static RISCVException mstateen(CPURISCVState *env, int csrno)return any (env, csrno); } +static RISCVException mstateen_32 (CPURISCVState *env,int csrno) +{ +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } + +return mstateen (env, csrno); +} +static RISCVException hstateen_pred (CPURISCVState *env,int csrno,int base) {if (!riscv_cpu_cfg (env)->ext_smstateen) {
@@ -533,6 +542,10 @@ static RISCVException hstateen(CPURISCVState *env, int csrno)static RISCVException hstateenh (CPURISCVState *env,int csrno) { +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } +return hstateen_pred (env, csrno,CSR_HSTATEEN0H ); }
@@ -3447,25 +3460,29 @@ static RISCVException write_mstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { - wr_mask |=SMSTATEEN0_P1P13 ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { + wr_mask |=SMSTATEEN0_P1P13 ; + } -if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_cfg (env)->ext_smaia || +riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Smaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_smaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid +* only if IMSIC is implemented. However, that information is +* with MachineState and we can't figure that out in csr.c. +* Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_mstateen (env, csrno, wr_mask, new_val);
@@ -3507,6 +3524,20 @@ static RISCVException write_mstateen0h(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_P1P13 ; } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if +* IMSIC is implemented. However, that information is with +* MachineState and we can't figure that out in csr.c. Just enable +* if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }
@@ -3552,21 +3583,25 @@ static RISCVException write_hstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (riscv_cpu_cfg (env)->ext_ssaia || +riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Ssaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_ssaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid +* only if IMSIC is implemented. However, that information is +* with MachineState and we can't figure that out in csr.c. +* Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_hstateen (env, csrno, wr_mask, new_val);
@@ -3608,6 +3643,20 @@ static RISCVException write_hstateen0h(CPURISCVState *env, int csrno, {uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if +* IMSIC is implemented. However, that information is with +* MachineState and we can't figure that out in csr.c. Just enable +* if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }
@@ -3657,7 +3706,7 @@ static RISCVException write_sstateen(CPURISCVState *env, int csrno,static RISCVException write_sstateen0 (CPURISCVState *env,int csrno,target_ulong new_val,uintptr_t ra) { -uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +uint64_t wr_mask =0 ;if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ;
@@ -5937,25 +5986,25 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { /* Smstateen extension CSRs */ [CSR_MSTATEEN0] = { "mstateen0", mstateen, read_mstateen, write_mstateen0, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN0H] = { "mstateen0h", mstateen, read_mstateenh, + [CSR_MSTATEEN0H] = { "mstateen0h", mstateen_32, read_mstateenh, write_mstateen0h, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN1] = { "mstateen1", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN1H] = { "mstateen1h", mstateen, read_mstateenh, + [CSR_MSTATEEN1H] = { "mstateen1h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN2] = { "mstateen2", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN2H] = { "mstateen2h", mstateen, read_mstateenh, + [CSR_MSTATEEN2H] = { "mstateen2h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN3] = { "mstateen3", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN3H] = { "mstateen3h", mstateen, read_mstateenh, + [CSR_MSTATEEN3H] = { "mstateen3h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_HSTATEEN0] = { "hstateen0", hstateen, read_hstateen, write_hstateen0,
Signature · 7 lines
2.43.0 Rebased on riscv-to-apply.next as requested. Patch 1 was already applied, so this v2 resends only patch 2. Thanks, Bruno
Re: [PATCH v2] target/riscv: fix RV32 stateen CSR handling
Quoted 6 lines · Bruno Sa
The RV32 stateen CSRs are split between the low-half CSR and the corresponding xH CSR, but the current implementation still handles some upper-half bits through the low-half write paths and also accepts the xH CSRs on RV64.
Quoted 8 lines
Fix this by:
- rejecting mstateen*h and hstateen*h accesses on RV64
- keeping the RV64-only writable bits in the low-half write paths
- handling the RV32 upper-half writable bits inwrite_mstateen0h()andwrite_hstateen0h()
- dropping unsupported writable bits fromwrite_sstateen0()Signed-off-by Bruno Sa <[email protected]>
Thanks!
Applied to riscv-to-apply.next
Alistair
Quoted 215 lines
---
v2:
- rebase on riscv-to-apply.next
- resend only patch 2 after patch 1 was applied
- wrap the AIA comment text to keep checkpatch cleantarget/riscv/csr.c | 117 ++++++++++++++++++++++++++++++++------------- 1 file changed, 83 insertions(+), 34 deletions(-)target/riscv/csr.c +83
-35@@ -502,6 +502,15 @@ static RISCVException mstateen(CPURISCVState *env, int csrno)return any (env, csrno); } +static RISCVException mstateen_32 (CPURISCVState *env,int csrno) +{ +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } + +return mstateen (env, csrno); +} +static RISCVException hstateen_pred (CPURISCVState *env,int csrno,int base) {if (!riscv_cpu_cfg (env)->ext_smstateen) {@@ -533,6 +542,10 @@ static RISCVException hstateen(CPURISCVState *env, int csrno)static RISCVException hstateenh (CPURISCVState *env,int csrno) { +if (riscv_cpu_mxl (env) !=MXL_RV32 ) { +return RISCV_EXCP_ILLEGAL_INST ; + } +return hstateen_pred (env, csrno,CSR_HSTATEEN0H ); }@@ -3447,25 +3460,29 @@ static RISCVException write_mstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { - wr_mask |=SMSTATEEN0_P1P13 ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (env->priv_ver >=PRIV_VERSION_1_13_0 ) { + wr_mask |=SMSTATEEN0_P1P13 ; + } -if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_cfg (env)->ext_smaia || +riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Smaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_smaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid +* only if IMSIC is implemented. However, that information is +* with MachineState and we can't figure that out in csr.c. +* Just enable if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_mstateen (env, csrno, wr_mask, new_val);@@ -3507,6 +3524,20 @@ static RISCVException write_mstateen0h(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_P1P13 ; } +if (riscv_cpu_cfg (env)->ext_smaia ||riscv_cpu_cfg (env)->ext_smcsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if +* IMSIC is implemented. However, that information is with +* MachineState and we can't figure that out in csr.c. Just enable +* if Smaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_smaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }@@ -3552,21 +3583,25 @@ static RISCVException write_hstateen0(CPURISCVState *env, int csrno, wr_mask |=SMSTATEEN0_FCSR ; } -if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { - wr_mask |=SMSTATEEN0_SVSLCT ; - } +if (riscv_cpu_mxl (env) ==MXL_RV64 ) { +if (riscv_cpu_cfg (env)->ext_ssaia || +riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } -/* -* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if IMSIC is -* implemented. However, that information is with MachineState and we can't -* figure that out in csr.c. Just enable if Ssaia is available. -*/ -if (riscv_cpu_cfg (env)->ext_ssaia) { - wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); - } +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid +* only if IMSIC is implemented. However, that information is +* with MachineState and we can't figure that out in csr.c. +* Just enable if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } -if (riscv_cpu_cfg (env)->ext_ssctr) { - wr_mask |=SMSTATEEN0_CTR ; +if (riscv_cpu_cfg (env)->ext_ssctr) { + wr_mask |=SMSTATEEN0_CTR ; + } }return write_hstateen (env, csrno, wr_mask, new_val);@@ -3608,6 +3643,20 @@ static RISCVException write_hstateen0h(CPURISCVState *env, int csrno, {uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +if (riscv_cpu_cfg (env)->ext_ssaia ||riscv_cpu_cfg (env)->ext_sscsrind) { + wr_mask |=SMSTATEEN0_SVSLCT ; + } + +/* +* As per the AIA specification, SMSTATEEN0_IMSIC is valid only if +* IMSIC is implemented. However, that information is with +* MachineState and we can't figure that out in csr.c. Just enable +* if Ssaia is available. +*/ +if (riscv_cpu_cfg (env)->ext_ssaia) { + wr_mask |= (SMSTATEEN0_AIA |SMSTATEEN0_IMSIC ); + } +if (riscv_cpu_cfg (env)->ext_ssctr) { wr_mask |=SMSTATEEN0_CTR ; }@@ -3657,7 +3706,7 @@ static RISCVException write_sstateen(CPURISCVState *env, int csrno,static RISCVException write_sstateen0 (CPURISCVState *env,int csrno,target_ulong new_val,uintptr_t ra) { -uint64_t wr_mask =SMSTATEEN_STATEEN |SMSTATEEN0_HSENVCFG ; +uint64_t wr_mask =0 ;if (!riscv_has_ext (env,RVF )) { wr_mask |=SMSTATEEN0_FCSR ;@@ -5937,25 +5986,25 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = { /* Smstateen extension CSRs */ [CSR_MSTATEEN0] = { "mstateen0", mstateen, read_mstateen, write_mstateen0, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN0H ] = {"mstateen0h" , mstateen, read_mstateenh, + [CSR_MSTATEEN0H] = { "mstateen0h", mstateen_32, read_mstateenh, write_mstateen0h, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN1] = { "mstateen1", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN1H ] = {"mstateen1h" , mstateen, read_mstateenh, + [CSR_MSTATEEN1H] = { "mstateen1h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN2] = { "mstateen2", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN2H ] = {"mstateen2h" , mstateen, read_mstateenh, + [CSR_MSTATEEN2H] = { "mstateen2h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_MSTATEEN3] = { "mstateen3", mstateen, read_mstateen, write_mstateen_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, - [CSR_MSTATEEN3H ] = {"mstateen3h" , mstateen, read_mstateenh, + [CSR_MSTATEEN3H] = { "mstateen3h", mstateen_32, read_mstateenh, write_mstateenh_1_3, .min_priv_ver = PRIV_VERSION_1_12_0 }, [CSR_HSTATEEN0] = { "hstateen0", hstateen, read_hstateen, write_hstateen0, --2.43.0
Rebased on riscv-to-apply.next as requested.Patch 1 was already applied, so this v2 resends only patch 2.
Thanks,
Bruno