* [PATCH v3 01/10] target/ppc: use locally stored msr and avoid indirect access
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-09-13 12:33 ` BALATON Zoltan
2024-09-13 4:13 ` [PATCH v3 02/10] target/ppc: optimize hreg_compute_pmu_hflags_value Harsh Prateek Bora
` (8 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
hreg_compute_hflags_value already stores msr locally to be used in most
of the logic in the routine however some instances are still using
env->msr which is unnecessary. Use locally stored value as available.
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/helper_regs.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/target/ppc/helper_regs.c b/target/ppc/helper_regs.c
index 02076e96fb..fe543ab3b8 100644
--- a/target/ppc/helper_regs.c
+++ b/target/ppc/helper_regs.c
@@ -143,10 +143,10 @@ static uint32_t hreg_compute_hflags_value(CPUPPCState *env)
if (ppc_flags & POWERPC_FLAG_DE) {
target_ulong dbcr0 = env->spr[SPR_BOOKE_DBCR0];
- if ((dbcr0 & DBCR0_ICMP) && FIELD_EX64(env->msr, MSR, DE)) {
+ if ((dbcr0 & DBCR0_ICMP) && FIELD_EX64(msr, MSR, DE)) {
hflags |= 1 << HFLAGS_SE;
}
- if ((dbcr0 & DBCR0_BRT) && FIELD_EX64(env->msr, MSR, DE)) {
+ if ((dbcr0 & DBCR0_BRT) && FIELD_EX64(msr, MSR, DE)) {
hflags |= 1 << HFLAGS_BE;
}
} else {
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 01/10] target/ppc: use locally stored msr and avoid indirect access
2024-09-13 4:13 ` [PATCH v3 01/10] target/ppc: use locally stored msr and avoid indirect access Harsh Prateek Bora
@ 2024-09-13 12:33 ` BALATON Zoltan
0 siblings, 0 replies; 21+ messages in thread
From: BALATON Zoltan @ 2024-09-13 12:33 UTC (permalink / raw)
To: Harsh Prateek Bora; +Cc: qemu-ppc, qemu-devel, npiggin, danielhb413
On Fri, 13 Sep 2024, Harsh Prateek Bora wrote:
> hreg_compute_hflags_value already stores msr locally to be used in most
> of the logic in the routine however some instances are still using
> env->msr which is unnecessary. Use locally stored value as available.
>
> Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Reviewed-by: BALATON Zoltan <balaton@eik.bme.hu>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> target/ppc/helper_regs.c | 4 ++--
> 1 file changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/target/ppc/helper_regs.c b/target/ppc/helper_regs.c
> index 02076e96fb..fe543ab3b8 100644
> --- a/target/ppc/helper_regs.c
> +++ b/target/ppc/helper_regs.c
> @@ -143,10 +143,10 @@ static uint32_t hreg_compute_hflags_value(CPUPPCState *env)
>
> if (ppc_flags & POWERPC_FLAG_DE) {
> target_ulong dbcr0 = env->spr[SPR_BOOKE_DBCR0];
> - if ((dbcr0 & DBCR0_ICMP) && FIELD_EX64(env->msr, MSR, DE)) {
> + if ((dbcr0 & DBCR0_ICMP) && FIELD_EX64(msr, MSR, DE)) {
> hflags |= 1 << HFLAGS_SE;
> }
> - if ((dbcr0 & DBCR0_BRT) && FIELD_EX64(env->msr, MSR, DE)) {
> + if ((dbcr0 & DBCR0_BRT) && FIELD_EX64(msr, MSR, DE)) {
> hflags |= 1 << HFLAGS_BE;
> }
> } else {
>
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 02/10] target/ppc: optimize hreg_compute_pmu_hflags_value
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 01/10] target/ppc: use locally stored msr and avoid indirect access Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 03/10] " Harsh Prateek Bora
` (7 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Cache env->spr[SPR_POWER_MMCR0] in a local variable as used in multiple
conditions to avoid multiple indirect accesses.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
---
target/ppc/helper_regs.c | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/target/ppc/helper_regs.c b/target/ppc/helper_regs.c
index fe543ab3b8..7b23e5ef0e 100644
--- a/target/ppc/helper_regs.c
+++ b/target/ppc/helper_regs.c
@@ -83,15 +83,16 @@ static bool hreg_check_bhrb_enable(CPUPPCState *env)
static uint32_t hreg_compute_pmu_hflags_value(CPUPPCState *env)
{
uint32_t hflags = 0;
-
#if defined(TARGET_PPC64)
- if (env->spr[SPR_POWER_MMCR0] & MMCR0_PMCC0) {
+ target_ulong mmcr0 = env->spr[SPR_POWER_MMCR0];
+
+ if (mmcr0 & MMCR0_PMCC0) {
hflags |= 1 << HFLAGS_PMCC0;
}
- if (env->spr[SPR_POWER_MMCR0] & MMCR0_PMCC1) {
+ if (mmcr0 & MMCR0_PMCC1) {
hflags |= 1 << HFLAGS_PMCC1;
}
- if (env->spr[SPR_POWER_MMCR0] & MMCR0_PMCjCE) {
+ if (mmcr0 & MMCR0_PMCjCE) {
hflags |= 1 << HFLAGS_PMCJCE;
}
if (hreg_check_bhrb_enable(env)) {
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v3 03/10] target/ppc: optimize hreg_compute_pmu_hflags_value
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 01/10] target/ppc: use locally stored msr and avoid indirect access Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 02/10] target/ppc: optimize hreg_compute_pmu_hflags_value Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 04/10] target/ppc: optimize p9 exception handling routines Harsh Prateek Bora
` (6 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
The second if-condition can be true only if the first one above is true.
Enclose the latter into the former to avoid un-necessary check if first
condition fails.
Reviewed-by: BALATON Zoltan <balaton@eik.bme.hu>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/helper_regs.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/target/ppc/helper_regs.c b/target/ppc/helper_regs.c
index 7b23e5ef0e..42c681ca4a 100644
--- a/target/ppc/helper_regs.c
+++ b/target/ppc/helper_regs.c
@@ -102,9 +102,9 @@ static uint32_t hreg_compute_pmu_hflags_value(CPUPPCState *env)
#ifndef CONFIG_USER_ONLY
if (env->pmc_ins_cnt) {
hflags |= 1 << HFLAGS_INSN_CNT;
- }
- if (env->pmc_ins_cnt & 0x1e) {
- hflags |= 1 << HFLAGS_PMC_OTHER;
+ if (env->pmc_ins_cnt & 0x1e) {
+ hflags |= 1 << HFLAGS_PMC_OTHER;
+ }
}
#endif
#endif
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v3 04/10] target/ppc: optimize p9 exception handling routines
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (2 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 03/10] " Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 05/10] target/ppc: optimize p9 exception handling routines for lpcr Harsh Prateek Bora
` (5 subsequent siblings)
9 siblings, 0 replies; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Currently, p9 exception handling has multiple if-condition checks where
it does an indirect access to pending_interrupts via env. Pass the
value during entry to avoid multiple indirect accesses.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 47 +++++++++++++++++++++-------------------
1 file changed, 25 insertions(+), 22 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index 2029144622..31c1653e2b 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -1872,10 +1872,12 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
PPC_INTERRUPT_WDT | PPC_INTERRUPT_CDOORBELL | PPC_INTERRUPT_FIT | \
PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
-static int p9_interrupt_powersave(CPUPPCState *env)
+static int p9_interrupt_powersave(CPUPPCState *env,
+ uint32_t pending_interrupts)
{
+
/* External Exception */
- if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
+ if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
(env->spr[SPR_LPCR] & LPCR_EEE)) {
bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
if (!heic || !FIELD_EX64_HV(env->msr) ||
@@ -1884,48 +1886,49 @@ static int p9_interrupt_powersave(CPUPPCState *env)
}
}
/* Decrementer Exception */
- if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
+ if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
(env->spr[SPR_LPCR] & LPCR_DEE)) {
return PPC_INTERRUPT_DECR;
}
/* Machine Check or Hypervisor Maintenance Exception */
if (env->spr[SPR_LPCR] & LPCR_OEE) {
- if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+ if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
- if (env->pending_interrupts & PPC_INTERRUPT_HMI) {
+ if (pending_interrupts & PPC_INTERRUPT_HMI) {
return PPC_INTERRUPT_HMI;
}
}
/* Privileged Doorbell Exception */
- if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
+ if ((pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
(env->spr[SPR_LPCR] & LPCR_PDEE)) {
return PPC_INTERRUPT_DOORBELL;
}
/* Hypervisor Doorbell Exception */
- if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
+ if ((pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
(env->spr[SPR_LPCR] & LPCR_HDEE)) {
return PPC_INTERRUPT_HDOORBELL;
}
/* Hypervisor virtualization exception */
- if ((env->pending_interrupts & PPC_INTERRUPT_HVIRT) &&
+ if ((pending_interrupts & PPC_INTERRUPT_HVIRT) &&
(env->spr[SPR_LPCR] & LPCR_HVEE)) {
return PPC_INTERRUPT_HVIRT;
}
- if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+ if (pending_interrupts & PPC_INTERRUPT_RESET) {
return PPC_INTERRUPT_RESET;
}
return 0;
}
-static int p9_next_unmasked_interrupt(CPUPPCState *env)
+static int p9_next_unmasked_interrupt(CPUPPCState *env,
+ uint32_t pending_interrupts)
{
CPUState *cs = env_cpu(env);
/* Ignore MSR[EE] when coming out of some power management states */
bool msr_ee = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
- assert((env->pending_interrupts & P9_UNUSED_INTERRUPTS) == 0);
+ assert((pending_interrupts & P9_UNUSED_INTERRUPTS) == 0);
if (cs->halted) {
if (env->spr[SPR_PSSCR] & PSSCR_EC) {
@@ -1933,7 +1936,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env)
* When PSSCR[EC] is set, LPCR[PECE] controls which interrupts can
* wakeup the processor
*/
- return p9_interrupt_powersave(env);
+ return p9_interrupt_powersave(env, pending_interrupts);
} else {
/*
* When it's clear, any system-caused exception exits power-saving
@@ -1944,12 +1947,12 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env)
}
/* Machine check exception */
- if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+ if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
/* Hypervisor decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
+ if (pending_interrupts & PPC_INTERRUPT_HDECR) {
/* LPCR will be clear when not supported so this will work */
bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
@@ -1959,7 +1962,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env)
}
/* Hypervisor virtualization interrupt */
- if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
+ if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
/* LPCR will be clear when not supported so this will work */
bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hvice) {
@@ -1968,7 +1971,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env)
}
/* External interrupt can ignore MSR:EE under some circumstances */
- if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
+ if (pending_interrupts & PPC_INTERRUPT_EXT) {
bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
/* HEIC blocks delivery to the hypervisor */
@@ -1980,20 +1983,20 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env)
}
if (msr_ee != 0) {
/* Decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
+ if (pending_interrupts & PPC_INTERRUPT_DECR) {
return PPC_INTERRUPT_DECR;
}
- if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
return PPC_INTERRUPT_DOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
return PPC_INTERRUPT_HDOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
+ if (pending_interrupts & PPC_INTERRUPT_PERFM) {
return PPC_INTERRUPT_PERFM;
}
/* EBB exception */
- if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
+ if (pending_interrupts & PPC_INTERRUPT_EBB) {
/*
* EBB exception must be taken in problem state and
* with BESCR_GE set.
@@ -2020,7 +2023,7 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
case POWERPC_EXCP_POWER9:
case POWERPC_EXCP_POWER10:
case POWERPC_EXCP_POWER11:
- return p9_next_unmasked_interrupt(env);
+ return p9_next_unmasked_interrupt(env, env->pending_interrupts);
default:
break;
}
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* [PATCH v3 05/10] target/ppc: optimize p9 exception handling routines for lpcr
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (3 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 04/10] target/ppc: optimize p9 exception handling routines Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-10-08 6:47 ` Nicholas Piggin
2024-09-13 4:13 ` [PATCH v3 06/10] target/ppc: reduce duplicate code between init_proc_POWER{9, 10} Harsh Prateek Bora
` (4 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Like pending_interrupts, env->spr[SPR_LPCR] is being used at multiple
places across p9 exception handlers. Pass the value during entry and
avoid multiple indirect accesses.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 33 ++++++++++++++++++---------------
1 file changed, 18 insertions(+), 15 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index 31c1653e2b..c7641898ca 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -1873,13 +1873,14 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
static int p9_interrupt_powersave(CPUPPCState *env,
- uint32_t pending_interrupts)
+ uint32_t pending_interrupts,
+ target_ulong lpcr)
{
/* External Exception */
if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
- (env->spr[SPR_LPCR] & LPCR_EEE)) {
- bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+ (lpcr & LPCR_EEE)) {
+ bool heic = !!(lpcr & LPCR_HEIC);
if (!heic || !FIELD_EX64_HV(env->msr) ||
FIELD_EX64(env->msr, MSR, PR)) {
return PPC_INTERRUPT_EXT;
@@ -1887,11 +1888,11 @@ static int p9_interrupt_powersave(CPUPPCState *env,
}
/* Decrementer Exception */
if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
- (env->spr[SPR_LPCR] & LPCR_DEE)) {
+ (lpcr & LPCR_DEE)) {
return PPC_INTERRUPT_DECR;
}
/* Machine Check or Hypervisor Maintenance Exception */
- if (env->spr[SPR_LPCR] & LPCR_OEE) {
+ if (lpcr & LPCR_OEE) {
if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
@@ -1901,17 +1902,17 @@ static int p9_interrupt_powersave(CPUPPCState *env,
}
/* Privileged Doorbell Exception */
if ((pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
- (env->spr[SPR_LPCR] & LPCR_PDEE)) {
+ (lpcr & LPCR_PDEE)) {
return PPC_INTERRUPT_DOORBELL;
}
/* Hypervisor Doorbell Exception */
if ((pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
- (env->spr[SPR_LPCR] & LPCR_HDEE)) {
+ (lpcr & LPCR_HDEE)) {
return PPC_INTERRUPT_HDOORBELL;
}
/* Hypervisor virtualization exception */
if ((pending_interrupts & PPC_INTERRUPT_HVIRT) &&
- (env->spr[SPR_LPCR] & LPCR_HVEE)) {
+ (lpcr & LPCR_HVEE)) {
return PPC_INTERRUPT_HVIRT;
}
if (pending_interrupts & PPC_INTERRUPT_RESET) {
@@ -1921,7 +1922,8 @@ static int p9_interrupt_powersave(CPUPPCState *env,
}
static int p9_next_unmasked_interrupt(CPUPPCState *env,
- uint32_t pending_interrupts)
+ uint32_t pending_interrupts,
+ target_ulong lpcr)
{
CPUState *cs = env_cpu(env);
@@ -1936,7 +1938,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
* When PSSCR[EC] is set, LPCR[PECE] controls which interrupts can
* wakeup the processor
*/
- return p9_interrupt_powersave(env, pending_interrupts);
+ return p9_interrupt_powersave(env, pending_interrupts, lpcr);
} else {
/*
* When it's clear, any system-caused exception exits power-saving
@@ -1954,7 +1956,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
/* Hypervisor decrementer exception */
if (pending_interrupts & PPC_INTERRUPT_HDECR) {
/* LPCR will be clear when not supported so this will work */
- bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
+ bool hdice = !!(lpcr & LPCR_HDICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
/* HDEC clears on delivery */
return PPC_INTERRUPT_HDECR;
@@ -1964,7 +1966,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
/* Hypervisor virtualization interrupt */
if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
/* LPCR will be clear when not supported so this will work */
- bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
+ bool hvice = !!(lpcr & LPCR_HVICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hvice) {
return PPC_INTERRUPT_HVIRT;
}
@@ -1972,8 +1974,8 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
/* External interrupt can ignore MSR:EE under some circumstances */
if (pending_interrupts & PPC_INTERRUPT_EXT) {
- bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
- bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+ bool lpes0 = !!(lpcr & LPCR_LPES0);
+ bool heic = !!(lpcr & LPCR_HEIC);
/* HEIC blocks delivery to the hypervisor */
if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
!FIELD_EX64(env->msr, MSR, PR))) ||
@@ -2023,7 +2025,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
case POWERPC_EXCP_POWER9:
case POWERPC_EXCP_POWER10:
case POWERPC_EXCP_POWER11:
- return p9_next_unmasked_interrupt(env, env->pending_interrupts);
+ return p9_next_unmasked_interrupt(env, env->pending_interrupts,
+ env->spr[SPR_LPCR]);
default:
break;
}
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 05/10] target/ppc: optimize p9 exception handling routines for lpcr
2024-09-13 4:13 ` [PATCH v3 05/10] target/ppc: optimize p9 exception handling routines for lpcr Harsh Prateek Bora
@ 2024-10-08 6:47 ` Nicholas Piggin
0 siblings, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:47 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> Like pending_interrupts, env->spr[SPR_LPCR] is being used at multiple
> places across p9 exception handlers. Pass the value during entry and
> avoid multiple indirect accesses.
Could this be merged with patch 4 to do pending_interrupts and lpcr
at once, to match p7 and p8? Otherwise,
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Thanks,
Nick
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> target/ppc/excp_helper.c | 33 ++++++++++++++++++---------------
> 1 file changed, 18 insertions(+), 15 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index 31c1653e2b..c7641898ca 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -1873,13 +1873,14 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
> PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
>
> static int p9_interrupt_powersave(CPUPPCState *env,
> - uint32_t pending_interrupts)
> + uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
>
> /* External Exception */
> if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
> - (env->spr[SPR_LPCR] & LPCR_EEE)) {
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + (lpcr & LPCR_EEE)) {
> + bool heic = !!(lpcr & LPCR_HEIC);
> if (!heic || !FIELD_EX64_HV(env->msr) ||
> FIELD_EX64(env->msr, MSR, PR)) {
> return PPC_INTERRUPT_EXT;
> @@ -1887,11 +1888,11 @@ static int p9_interrupt_powersave(CPUPPCState *env,
> }
> /* Decrementer Exception */
> if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
> - (env->spr[SPR_LPCR] & LPCR_DEE)) {
> + (lpcr & LPCR_DEE)) {
> return PPC_INTERRUPT_DECR;
> }
> /* Machine Check or Hypervisor Maintenance Exception */
> - if (env->spr[SPR_LPCR] & LPCR_OEE) {
> + if (lpcr & LPCR_OEE) {
> if (pending_interrupts & PPC_INTERRUPT_MCK) {
> return PPC_INTERRUPT_MCK;
> }
> @@ -1901,17 +1902,17 @@ static int p9_interrupt_powersave(CPUPPCState *env,
> }
> /* Privileged Doorbell Exception */
> if ((pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> - (env->spr[SPR_LPCR] & LPCR_PDEE)) {
> + (lpcr & LPCR_PDEE)) {
> return PPC_INTERRUPT_DOORBELL;
> }
> /* Hypervisor Doorbell Exception */
> if ((pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> - (env->spr[SPR_LPCR] & LPCR_HDEE)) {
> + (lpcr & LPCR_HDEE)) {
> return PPC_INTERRUPT_HDOORBELL;
> }
> /* Hypervisor virtualization exception */
> if ((pending_interrupts & PPC_INTERRUPT_HVIRT) &&
> - (env->spr[SPR_LPCR] & LPCR_HVEE)) {
> + (lpcr & LPCR_HVEE)) {
> return PPC_INTERRUPT_HVIRT;
> }
> if (pending_interrupts & PPC_INTERRUPT_RESET) {
> @@ -1921,7 +1922,8 @@ static int p9_interrupt_powersave(CPUPPCState *env,
> }
>
> static int p9_next_unmasked_interrupt(CPUPPCState *env,
> - uint32_t pending_interrupts)
> + uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
> CPUState *cs = env_cpu(env);
>
> @@ -1936,7 +1938,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
> * When PSSCR[EC] is set, LPCR[PECE] controls which interrupts can
> * wakeup the processor
> */
> - return p9_interrupt_powersave(env, pending_interrupts);
> + return p9_interrupt_powersave(env, pending_interrupts, lpcr);
> } else {
> /*
> * When it's clear, any system-caused exception exits power-saving
> @@ -1954,7 +1956,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
> /* Hypervisor decrementer exception */
> if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> /* LPCR will be clear when not supported so this will work */
> - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> + bool hdice = !!(lpcr & LPCR_HDICE);
> if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
> /* HDEC clears on delivery */
> return PPC_INTERRUPT_HDECR;
> @@ -1964,7 +1966,7 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
> /* Hypervisor virtualization interrupt */
> if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
> /* LPCR will be clear when not supported so this will work */
> - bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
> + bool hvice = !!(lpcr & LPCR_HVICE);
> if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hvice) {
> return PPC_INTERRUPT_HVIRT;
> }
> @@ -1972,8 +1974,8 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
>
> /* External interrupt can ignore MSR:EE under some circumstances */
> if (pending_interrupts & PPC_INTERRUPT_EXT) {
> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + bool lpes0 = !!(lpcr & LPCR_LPES0);
> + bool heic = !!(lpcr & LPCR_HEIC);
> /* HEIC blocks delivery to the hypervisor */
> if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
> !FIELD_EX64(env->msr, MSR, PR))) ||
> @@ -2023,7 +2025,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> case POWERPC_EXCP_POWER9:
> case POWERPC_EXCP_POWER10:
> case POWERPC_EXCP_POWER11:
> - return p9_next_unmasked_interrupt(env, env->pending_interrupts);
> + return p9_next_unmasked_interrupt(env, env->pending_interrupts,
> + env->spr[SPR_LPCR]);
> default:
> break;
> }
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 06/10] target/ppc: reduce duplicate code between init_proc_POWER{9, 10}
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (4 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 05/10] target/ppc: optimize p9 exception handling routines for lpcr Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-10-08 6:49 ` Nicholas Piggin
2024-09-13 4:13 ` [PATCH v3 07/10] target/ppc: optimize p8 exception handling routines Harsh Prateek Bora
` (3 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Historically, the registration of sprs have been inherited alongwith
every new Power arch support being added leading to a lot of code
duplication. It's time to do necessary cleanups now to avoid further
duplication with newer arch support being added.
Signed-off-by: Harsh Prateek Bora <harshb@linux.ibm.com>
---
target/ppc/cpu_init.c | 58 +++++++++----------------------------------
1 file changed, 12 insertions(+), 46 deletions(-)
diff --git a/target/ppc/cpu_init.c b/target/ppc/cpu_init.c
index 9cb5dd4596..de1dd63bf7 100644
--- a/target/ppc/cpu_init.c
+++ b/target/ppc/cpu_init.c
@@ -6410,7 +6410,7 @@ static struct ppc_radix_page_info POWER9_radix_page_info = {
#endif /* CONFIG_USER_ONLY */
#define POWER9_BHRB_ENTRIES_LOG2 5
-static void init_proc_POWER9(CPUPPCState *env)
+static void register_power9_common_sprs(CPUPPCState *env)
{
/* Common Registers */
init_proc_book3s_common(env);
@@ -6429,7 +6429,6 @@ static void init_proc_POWER9(CPUPPCState *env)
register_power5p_ear_sprs(env);
register_power5p_tb_sprs(env);
register_power6_common_sprs(env);
- register_HEIR32_spr(env);
register_power6_dbg_sprs(env);
register_power7_common_sprs(env);
register_power8_tce_address_control_sprs(env);
@@ -6447,16 +6446,21 @@ static void init_proc_POWER9(CPUPPCState *env)
register_power8_rpr_sprs(env);
register_power9_mmu_sprs(env);
- /* POWER9 Specific registers */
- spr_register_kvm(env, SPR_TIDR, "TIDR", NULL, NULL,
- spr_read_generic, spr_write_generic,
- KVM_REG_PPC_TIDR, 0);
-
/* FIXME: Filter fields properly based on privilege level */
spr_register_kvm_hv(env, SPR_PSSCR, "PSSCR", NULL, NULL, NULL, NULL,
spr_read_generic, spr_write_generic,
KVM_REG_PPC_PSSCR, 0);
+}
+
+static void init_proc_POWER9(CPUPPCState *env)
+{
+ register_power9_common_sprs(env);
+ register_HEIR32_spr(env);
+ /* POWER9 Specific registers */
+ spr_register_kvm(env, SPR_TIDR, "TIDR", NULL, NULL,
+ spr_read_generic, spr_write_generic,
+ KVM_REG_PPC_TIDR, 0);
/* env variables */
env->dcache_line_size = 128;
env->icache_line_size = 128;
@@ -6562,50 +6566,12 @@ static struct ppc_radix_page_info POWER10_radix_page_info = {
#define POWER10_BHRB_ENTRIES_LOG2 5
static void init_proc_POWER10(CPUPPCState *env)
{
- /* Common Registers */
- init_proc_book3s_common(env);
- register_book3s_207_dbg_sprs(env);
-
- /* Common TCG PMU */
- init_tcg_pmu_power8(env);
-
- /* POWER8 Specific Registers */
- register_book3s_ids_sprs(env);
- register_amr_sprs(env);
- register_iamr_sprs(env);
- register_book3s_purr_sprs(env);
- register_power5p_common_sprs(env);
- register_power5p_lpar_sprs(env);
- register_power5p_ear_sprs(env);
- register_power5p_tb_sprs(env);
- register_power6_common_sprs(env);
+ register_power9_common_sprs(env);
register_HEIR64_spr(env);
- register_power6_dbg_sprs(env);
- register_power7_common_sprs(env);
- register_power8_tce_address_control_sprs(env);
- register_power8_ids_sprs(env);
- register_power8_ebb_sprs(env);
- register_power8_fscr_sprs(env);
- register_power8_pmu_sup_sprs(env);
- register_power8_pmu_user_sprs(env);
- register_power8_tm_sprs(env);
- register_power8_pspb_sprs(env);
- register_power8_dpdes_sprs(env);
- register_vtb_sprs(env);
- register_power8_ic_sprs(env);
- register_power9_book4_sprs(env);
- register_power8_rpr_sprs(env);
- register_power9_mmu_sprs(env);
register_power10_hash_sprs(env);
register_power10_dexcr_sprs(env);
register_power10_pmu_sup_sprs(env);
register_power10_pmu_user_sprs(env);
-
- /* FIXME: Filter fields properly based on privilege level */
- spr_register_kvm_hv(env, SPR_PSSCR, "PSSCR", NULL, NULL, NULL, NULL,
- spr_read_generic, spr_write_generic,
- KVM_REG_PPC_PSSCR, 0);
-
/* env variables */
env->dcache_line_size = 128;
env->icache_line_size = 128;
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 06/10] target/ppc: reduce duplicate code between init_proc_POWER{9, 10}
2024-09-13 4:13 ` [PATCH v3 06/10] target/ppc: reduce duplicate code between init_proc_POWER{9, 10} Harsh Prateek Bora
@ 2024-10-08 6:49 ` Nicholas Piggin
0 siblings, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:49 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> Historically, the registration of sprs have been inherited alongwith
> every new Power arch support being added leading to a lot of code
> duplication. It's time to do necessary cleanups now to avoid further
> duplication with newer arch support being added.
Looks okay.
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
Nit, could you move this out to the end of the series, since it is in
the middle of several other patches that deal with interrupt delivery.
Thanks,
Nick
>
> Signed-off-by: Harsh Prateek Bora <harshb@linux.ibm.com>
> ---
> target/ppc/cpu_init.c | 58 +++++++++----------------------------------
> 1 file changed, 12 insertions(+), 46 deletions(-)
>
> diff --git a/target/ppc/cpu_init.c b/target/ppc/cpu_init.c
> index 9cb5dd4596..de1dd63bf7 100644
> --- a/target/ppc/cpu_init.c
> +++ b/target/ppc/cpu_init.c
> @@ -6410,7 +6410,7 @@ static struct ppc_radix_page_info POWER9_radix_page_info = {
> #endif /* CONFIG_USER_ONLY */
>
> #define POWER9_BHRB_ENTRIES_LOG2 5
> -static void init_proc_POWER9(CPUPPCState *env)
> +static void register_power9_common_sprs(CPUPPCState *env)
> {
> /* Common Registers */
> init_proc_book3s_common(env);
> @@ -6429,7 +6429,6 @@ static void init_proc_POWER9(CPUPPCState *env)
> register_power5p_ear_sprs(env);
> register_power5p_tb_sprs(env);
> register_power6_common_sprs(env);
> - register_HEIR32_spr(env);
> register_power6_dbg_sprs(env);
> register_power7_common_sprs(env);
> register_power8_tce_address_control_sprs(env);
> @@ -6447,16 +6446,21 @@ static void init_proc_POWER9(CPUPPCState *env)
> register_power8_rpr_sprs(env);
> register_power9_mmu_sprs(env);
>
> - /* POWER9 Specific registers */
> - spr_register_kvm(env, SPR_TIDR, "TIDR", NULL, NULL,
> - spr_read_generic, spr_write_generic,
> - KVM_REG_PPC_TIDR, 0);
> -
> /* FIXME: Filter fields properly based on privilege level */
> spr_register_kvm_hv(env, SPR_PSSCR, "PSSCR", NULL, NULL, NULL, NULL,
> spr_read_generic, spr_write_generic,
> KVM_REG_PPC_PSSCR, 0);
>
> +}
> +
> +static void init_proc_POWER9(CPUPPCState *env)
> +{
> + register_power9_common_sprs(env);
> + register_HEIR32_spr(env);
> + /* POWER9 Specific registers */
> + spr_register_kvm(env, SPR_TIDR, "TIDR", NULL, NULL,
> + spr_read_generic, spr_write_generic,
> + KVM_REG_PPC_TIDR, 0);
> /* env variables */
> env->dcache_line_size = 128;
> env->icache_line_size = 128;
> @@ -6562,50 +6566,12 @@ static struct ppc_radix_page_info POWER10_radix_page_info = {
> #define POWER10_BHRB_ENTRIES_LOG2 5
> static void init_proc_POWER10(CPUPPCState *env)
> {
> - /* Common Registers */
> - init_proc_book3s_common(env);
> - register_book3s_207_dbg_sprs(env);
> -
> - /* Common TCG PMU */
> - init_tcg_pmu_power8(env);
> -
> - /* POWER8 Specific Registers */
> - register_book3s_ids_sprs(env);
> - register_amr_sprs(env);
> - register_iamr_sprs(env);
> - register_book3s_purr_sprs(env);
> - register_power5p_common_sprs(env);
> - register_power5p_lpar_sprs(env);
> - register_power5p_ear_sprs(env);
> - register_power5p_tb_sprs(env);
> - register_power6_common_sprs(env);
> + register_power9_common_sprs(env);
> register_HEIR64_spr(env);
> - register_power6_dbg_sprs(env);
> - register_power7_common_sprs(env);
> - register_power8_tce_address_control_sprs(env);
> - register_power8_ids_sprs(env);
> - register_power8_ebb_sprs(env);
> - register_power8_fscr_sprs(env);
> - register_power8_pmu_sup_sprs(env);
> - register_power8_pmu_user_sprs(env);
> - register_power8_tm_sprs(env);
> - register_power8_pspb_sprs(env);
> - register_power8_dpdes_sprs(env);
> - register_vtb_sprs(env);
> - register_power8_ic_sprs(env);
> - register_power9_book4_sprs(env);
> - register_power8_rpr_sprs(env);
> - register_power9_mmu_sprs(env);
> register_power10_hash_sprs(env);
> register_power10_dexcr_sprs(env);
> register_power10_pmu_sup_sprs(env);
> register_power10_pmu_user_sprs(env);
> -
> - /* FIXME: Filter fields properly based on privilege level */
> - spr_register_kvm_hv(env, SPR_PSSCR, "PSSCR", NULL, NULL, NULL, NULL,
> - spr_read_generic, spr_write_generic,
> - KVM_REG_PPC_PSSCR, 0);
> -
> /* env variables */
> env->dcache_line_size = 128;
> env->icache_line_size = 128;
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 07/10] target/ppc: optimize p8 exception handling routines
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (5 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 06/10] target/ppc: reduce duplicate code between init_proc_POWER{9, 10} Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-10-08 6:50 ` Nicholas Piggin
2024-09-13 4:13 ` [PATCH v3 08/10] target/ppc: optimize p7 " Harsh Prateek Bora
` (2 subsequent siblings)
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Most of the p8 exception handling accesses env->pending_interrupts and
env->spr[SPR_LPCR] at multiple places. Passing it directly as local
variables simplifies the code and avoids multiple indirect accesses.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 60 +++++++++++++++++++++-------------------
1 file changed, 32 insertions(+), 28 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index c7641898ca..c0828aac88 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -1765,39 +1765,42 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
PPC_INTERRUPT_CEXT | PPC_INTERRUPT_WDT | PPC_INTERRUPT_CDOORBELL | \
PPC_INTERRUPT_FIT | PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
-static int p8_interrupt_powersave(CPUPPCState *env)
+static int p8_interrupt_powersave(uint32_t pending_interrupts,
+ target_ulong lpcr)
{
- if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
+ if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
+ (lpcr & LPCR_P8_PECE2)) {
return PPC_INTERRUPT_EXT;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
+ if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
+ (lpcr & LPCR_P8_PECE3)) {
return PPC_INTERRUPT_DECR;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
+ if ((pending_interrupts & PPC_INTERRUPT_MCK) &&
+ (lpcr & LPCR_P8_PECE4)) {
return PPC_INTERRUPT_MCK;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
+ if ((pending_interrupts & PPC_INTERRUPT_HMI) &&
+ (lpcr & LPCR_P8_PECE4)) {
return PPC_INTERRUPT_HMI;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
+ if ((pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
+ (lpcr & LPCR_P8_PECE0)) {
return PPC_INTERRUPT_DOORBELL;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
- (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
+ if ((pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
+ (lpcr & LPCR_P8_PECE1)) {
return PPC_INTERRUPT_HDOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+ if (pending_interrupts & PPC_INTERRUPT_RESET) {
return PPC_INTERRUPT_RESET;
}
return 0;
}
-static int p8_next_unmasked_interrupt(CPUPPCState *env)
+static int p8_next_unmasked_interrupt(CPUPPCState *env,
+ uint32_t pending_interrupts,
+ target_ulong lpcr)
{
CPUState *cs = env_cpu(env);
@@ -1808,18 +1811,18 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
if (cs->halted) {
/* LPCR[PECE] controls which interrupts can exit power-saving mode */
- return p8_interrupt_powersave(env);
+ return p8_interrupt_powersave(pending_interrupts, lpcr);
}
/* Machine check exception */
- if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+ if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
/* Hypervisor decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
+ if (pending_interrupts & PPC_INTERRUPT_HDECR) {
/* LPCR will be clear when not supported so this will work */
- bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
+ bool hdice = !!(lpcr & LPCR_HDICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
/* HDEC clears on delivery */
return PPC_INTERRUPT_HDECR;
@@ -1827,9 +1830,9 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
}
/* External interrupt can ignore MSR:EE under some circumstances */
- if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
- bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
- bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+ if (pending_interrupts & PPC_INTERRUPT_EXT) {
+ bool lpes0 = !!(lpcr & LPCR_LPES0);
+ bool heic = !!(lpcr & LPCR_HEIC);
/* HEIC blocks delivery to the hypervisor */
if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
!FIELD_EX64(env->msr, MSR, PR))) ||
@@ -1839,20 +1842,20 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
}
if (msr_ee != 0) {
/* Decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
+ if (pending_interrupts & PPC_INTERRUPT_DECR) {
return PPC_INTERRUPT_DECR;
}
- if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
return PPC_INTERRUPT_DOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
return PPC_INTERRUPT_HDOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
+ if (pending_interrupts & PPC_INTERRUPT_PERFM) {
return PPC_INTERRUPT_PERFM;
}
/* EBB exception */
- if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
+ if (pending_interrupts & PPC_INTERRUPT_EBB) {
/*
* EBB exception must be taken in problem state and
* with BESCR_GE set.
@@ -2021,7 +2024,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
case POWERPC_EXCP_POWER7:
return p7_next_unmasked_interrupt(env);
case POWERPC_EXCP_POWER8:
- return p8_next_unmasked_interrupt(env);
+ return p8_next_unmasked_interrupt(env, env->pending_interrupts,
+ env->spr[SPR_LPCR]);
case POWERPC_EXCP_POWER9:
case POWERPC_EXCP_POWER10:
case POWERPC_EXCP_POWER11:
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 07/10] target/ppc: optimize p8 exception handling routines
2024-09-13 4:13 ` [PATCH v3 07/10] target/ppc: optimize p8 exception handling routines Harsh Prateek Bora
@ 2024-10-08 6:50 ` Nicholas Piggin
0 siblings, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:50 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> Most of the p8 exception handling accesses env->pending_interrupts and
> env->spr[SPR_LPCR] at multiple places. Passing it directly as local
> variables simplifies the code and avoids multiple indirect accesses.
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> target/ppc/excp_helper.c | 60 +++++++++++++++++++++-------------------
> 1 file changed, 32 insertions(+), 28 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index c7641898ca..c0828aac88 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -1765,39 +1765,42 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
> PPC_INTERRUPT_CEXT | PPC_INTERRUPT_WDT | PPC_INTERRUPT_CDOORBELL | \
> PPC_INTERRUPT_FIT | PPC_INTERRUPT_PIT | PPC_INTERRUPT_THERM)
>
> -static int p8_interrupt_powersave(CPUPPCState *env)
> +static int p8_interrupt_powersave(uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
> - if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE2)) {
> + if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
> + (lpcr & LPCR_P8_PECE2)) {
> return PPC_INTERRUPT_EXT;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE3)) {
> + if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
> + (lpcr & LPCR_P8_PECE3)) {
> return PPC_INTERRUPT_DECR;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> + if ((pending_interrupts & PPC_INTERRUPT_MCK) &&
> + (lpcr & LPCR_P8_PECE4)) {
> return PPC_INTERRUPT_MCK;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE4)) {
> + if ((pending_interrupts & PPC_INTERRUPT_HMI) &&
> + (lpcr & LPCR_P8_PECE4)) {
> return PPC_INTERRUPT_HMI;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE0)) {
> + if ((pending_interrupts & PPC_INTERRUPT_DOORBELL) &&
> + (lpcr & LPCR_P8_PECE0)) {
> return PPC_INTERRUPT_DOORBELL;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> - (env->spr[SPR_LPCR] & LPCR_P8_PECE1)) {
> + if ((pending_interrupts & PPC_INTERRUPT_HDOORBELL) &&
> + (lpcr & LPCR_P8_PECE1)) {
> return PPC_INTERRUPT_HDOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> + if (pending_interrupts & PPC_INTERRUPT_RESET) {
> return PPC_INTERRUPT_RESET;
> }
> return 0;
> }
>
> -static int p8_next_unmasked_interrupt(CPUPPCState *env)
> +static int p8_next_unmasked_interrupt(CPUPPCState *env,
> + uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
> CPUState *cs = env_cpu(env);
>
> @@ -1808,18 +1811,18 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
>
> if (cs->halted) {
> /* LPCR[PECE] controls which interrupts can exit power-saving mode */
> - return p8_interrupt_powersave(env);
> + return p8_interrupt_powersave(pending_interrupts, lpcr);
> }
>
> /* Machine check exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> + if (pending_interrupts & PPC_INTERRUPT_MCK) {
> return PPC_INTERRUPT_MCK;
> }
>
> /* Hypervisor decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
> + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> /* LPCR will be clear when not supported so this will work */
> - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> + bool hdice = !!(lpcr & LPCR_HDICE);
> if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
> /* HDEC clears on delivery */
> return PPC_INTERRUPT_HDECR;
> @@ -1827,9 +1830,9 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
> }
>
> /* External interrupt can ignore MSR:EE under some circumstances */
> - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + if (pending_interrupts & PPC_INTERRUPT_EXT) {
> + bool lpes0 = !!(lpcr & LPCR_LPES0);
> + bool heic = !!(lpcr & LPCR_HEIC);
> /* HEIC blocks delivery to the hypervisor */
> if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
> !FIELD_EX64(env->msr, MSR, PR))) ||
> @@ -1839,20 +1842,20 @@ static int p8_next_unmasked_interrupt(CPUPPCState *env)
> }
> if (msr_ee != 0) {
> /* Decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
> + if (pending_interrupts & PPC_INTERRUPT_DECR) {
> return PPC_INTERRUPT_DECR;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> return PPC_INTERRUPT_DOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> return PPC_INTERRUPT_HDOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
> + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
> return PPC_INTERRUPT_PERFM;
> }
> /* EBB exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
> + if (pending_interrupts & PPC_INTERRUPT_EBB) {
> /*
> * EBB exception must be taken in problem state and
> * with BESCR_GE set.
> @@ -2021,7 +2024,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> case POWERPC_EXCP_POWER7:
> return p7_next_unmasked_interrupt(env);
> case POWERPC_EXCP_POWER8:
> - return p8_next_unmasked_interrupt(env);
> + return p8_next_unmasked_interrupt(env, env->pending_interrupts,
> + env->spr[SPR_LPCR]);
> case POWERPC_EXCP_POWER9:
> case POWERPC_EXCP_POWER10:
> case POWERPC_EXCP_POWER11:
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 08/10] target/ppc: optimize p7 exception handling routines
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (6 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 07/10] target/ppc: optimize p8 exception handling routines Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-10-08 6:50 ` Nicholas Piggin
2024-09-13 4:13 ` [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt Harsh Prateek Bora
2024-09-13 4:13 ` [PATCH v3 10/10] target/ppc: combine multiple ail checks into one Harsh Prateek Bora
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
Like p8 and p9, simplifying p7 exception handling rotuines to avoid
un-necessary multiple indirect accesses to env->pending_interrupts and
env->spr[SPR_LPCR].
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 46 ++++++++++++++++++++++------------------
1 file changed, 25 insertions(+), 21 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index c0828aac88..d0e0f609a0 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -1683,51 +1683,54 @@ void ppc_cpu_do_interrupt(CPUState *cs)
PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL | PPC_INTERRUPT_HDOORBELL | \
PPC_INTERRUPT_THERM | PPC_INTERRUPT_EBB)
-static int p7_interrupt_powersave(CPUPPCState *env)
+static int p7_interrupt_powersave(uint32_t pending_interrupts,
+ target_ulong lpcr)
{
- if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
- (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
+ if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
+ (lpcr & LPCR_P7_PECE0)) {
return PPC_INTERRUPT_EXT;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
- (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
+ if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
+ (lpcr & LPCR_P7_PECE1)) {
return PPC_INTERRUPT_DECR;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
- (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
+ if ((pending_interrupts & PPC_INTERRUPT_MCK) &&
+ (lpcr & LPCR_P7_PECE2)) {
return PPC_INTERRUPT_MCK;
}
- if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
- (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
+ if ((pending_interrupts & PPC_INTERRUPT_HMI) &&
+ (lpcr & LPCR_P7_PECE2)) {
return PPC_INTERRUPT_HMI;
}
- if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+ if (pending_interrupts & PPC_INTERRUPT_RESET) {
return PPC_INTERRUPT_RESET;
}
return 0;
}
-static int p7_next_unmasked_interrupt(CPUPPCState *env)
+static int p7_next_unmasked_interrupt(CPUPPCState *env,
+ uint32_t pending_interrupts,
+ target_ulong lpcr)
{
CPUState *cs = env_cpu(env);
/* Ignore MSR[EE] when coming out of some power management states */
bool msr_ee = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
- assert((env->pending_interrupts & P7_UNUSED_INTERRUPTS) == 0);
+ assert((pending_interrupts & P7_UNUSED_INTERRUPTS) == 0);
if (cs->halted) {
/* LPCR[PECE] controls which interrupts can exit power-saving mode */
- return p7_interrupt_powersave(env);
+ return p7_interrupt_powersave(pending_interrupts, lpcr);
}
/* Machine check exception */
- if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+ if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
/* Hypervisor decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
+ if (pending_interrupts & PPC_INTERRUPT_HDECR) {
/* LPCR will be clear when not supported so this will work */
bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
@@ -1737,9 +1740,9 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
}
/* External interrupt can ignore MSR:EE under some circumstances */
- if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
- bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
- bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+ if (pending_interrupts & PPC_INTERRUPT_EXT) {
+ bool lpes0 = !!(lpcr & LPCR_LPES0);
+ bool heic = !!(lpcr & LPCR_HEIC);
/* HEIC blocks delivery to the hypervisor */
if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
!FIELD_EX64(env->msr, MSR, PR))) ||
@@ -1749,10 +1752,10 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
}
if (msr_ee != 0) {
/* Decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
+ if (pending_interrupts & PPC_INTERRUPT_DECR) {
return PPC_INTERRUPT_DECR;
}
- if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
+ if (pending_interrupts & PPC_INTERRUPT_PERFM) {
return PPC_INTERRUPT_PERFM;
}
}
@@ -2022,7 +2025,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
#ifdef TARGET_PPC64
switch (env->excp_model) {
case POWERPC_EXCP_POWER7:
- return p7_next_unmasked_interrupt(env);
+ return p7_next_unmasked_interrupt(env, env->pending_interrupts,
+ env->spr[SPR_LPCR]);
case POWERPC_EXCP_POWER8:
return p8_next_unmasked_interrupt(env, env->pending_interrupts,
env->spr[SPR_LPCR]);
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 08/10] target/ppc: optimize p7 exception handling routines
2024-09-13 4:13 ` [PATCH v3 08/10] target/ppc: optimize p7 " Harsh Prateek Bora
@ 2024-10-08 6:50 ` Nicholas Piggin
0 siblings, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:50 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> Like p8 and p9, simplifying p7 exception handling rotuines to avoid
> un-necessary multiple indirect accesses to env->pending_interrupts and
> env->spr[SPR_LPCR].
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> target/ppc/excp_helper.c | 46 ++++++++++++++++++++++------------------
> 1 file changed, 25 insertions(+), 21 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index c0828aac88..d0e0f609a0 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -1683,51 +1683,54 @@ void ppc_cpu_do_interrupt(CPUState *cs)
> PPC_INTERRUPT_PIT | PPC_INTERRUPT_DOORBELL | PPC_INTERRUPT_HDOORBELL | \
> PPC_INTERRUPT_THERM | PPC_INTERRUPT_EBB)
>
> -static int p7_interrupt_powersave(CPUPPCState *env)
> +static int p7_interrupt_powersave(uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
> - if ((env->pending_interrupts & PPC_INTERRUPT_EXT) &&
> - (env->spr[SPR_LPCR] & LPCR_P7_PECE0)) {
> + if ((pending_interrupts & PPC_INTERRUPT_EXT) &&
> + (lpcr & LPCR_P7_PECE0)) {
> return PPC_INTERRUPT_EXT;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_DECR) &&
> - (env->spr[SPR_LPCR] & LPCR_P7_PECE1)) {
> + if ((pending_interrupts & PPC_INTERRUPT_DECR) &&
> + (lpcr & LPCR_P7_PECE1)) {
> return PPC_INTERRUPT_DECR;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_MCK) &&
> - (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> + if ((pending_interrupts & PPC_INTERRUPT_MCK) &&
> + (lpcr & LPCR_P7_PECE2)) {
> return PPC_INTERRUPT_MCK;
> }
> - if ((env->pending_interrupts & PPC_INTERRUPT_HMI) &&
> - (env->spr[SPR_LPCR] & LPCR_P7_PECE2)) {
> + if ((pending_interrupts & PPC_INTERRUPT_HMI) &&
> + (lpcr & LPCR_P7_PECE2)) {
> return PPC_INTERRUPT_HMI;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> + if (pending_interrupts & PPC_INTERRUPT_RESET) {
> return PPC_INTERRUPT_RESET;
> }
> return 0;
> }
>
> -static int p7_next_unmasked_interrupt(CPUPPCState *env)
> +static int p7_next_unmasked_interrupt(CPUPPCState *env,
> + uint32_t pending_interrupts,
> + target_ulong lpcr)
> {
> CPUState *cs = env_cpu(env);
>
> /* Ignore MSR[EE] when coming out of some power management states */
> bool msr_ee = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
>
> - assert((env->pending_interrupts & P7_UNUSED_INTERRUPTS) == 0);
> + assert((pending_interrupts & P7_UNUSED_INTERRUPTS) == 0);
>
> if (cs->halted) {
> /* LPCR[PECE] controls which interrupts can exit power-saving mode */
> - return p7_interrupt_powersave(env);
> + return p7_interrupt_powersave(pending_interrupts, lpcr);
> }
>
> /* Machine check exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> + if (pending_interrupts & PPC_INTERRUPT_MCK) {
> return PPC_INTERRUPT_MCK;
> }
>
> /* Hypervisor decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
> + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> /* LPCR will be clear when not supported so this will work */
> bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> if ((msr_ee || !FIELD_EX64_HV(env->msr)) && hdice) {
> @@ -1737,9 +1740,9 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
> }
>
> /* External interrupt can ignore MSR:EE under some circumstances */
> - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + if (pending_interrupts & PPC_INTERRUPT_EXT) {
> + bool lpes0 = !!(lpcr & LPCR_LPES0);
> + bool heic = !!(lpcr & LPCR_HEIC);
> /* HEIC blocks delivery to the hypervisor */
> if ((msr_ee && !(heic && FIELD_EX64_HV(env->msr) &&
> !FIELD_EX64(env->msr, MSR, PR))) ||
> @@ -1749,10 +1752,10 @@ static int p7_next_unmasked_interrupt(CPUPPCState *env)
> }
> if (msr_ee != 0) {
> /* Decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
> + if (pending_interrupts & PPC_INTERRUPT_DECR) {
> return PPC_INTERRUPT_DECR;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
> + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
> return PPC_INTERRUPT_PERFM;
> }
> }
> @@ -2022,7 +2025,8 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> #ifdef TARGET_PPC64
> switch (env->excp_model) {
> case POWERPC_EXCP_POWER7:
> - return p7_next_unmasked_interrupt(env);
> + return p7_next_unmasked_interrupt(env, env->pending_interrupts,
> + env->spr[SPR_LPCR]);
> case POWERPC_EXCP_POWER8:
> return p8_next_unmasked_interrupt(env, env->pending_interrupts,
> env->spr[SPR_LPCR]);
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (7 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 08/10] target/ppc: optimize p7 " Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-09-13 12:50 ` BALATON Zoltan
2024-10-08 6:51 ` Nicholas Piggin
2024-09-13 4:13 ` [PATCH v3 10/10] target/ppc: combine multiple ail checks into one Harsh Prateek Bora
9 siblings, 2 replies; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
As previously done for arch specific handlers, simplify var usage in
ppc_next_unmasked_interrupt by caching the env->pending_interrupts and
env->spr[SPR_LPCR] in local vars and using it later at multiple places.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 54 ++++++++++++++++++++--------------------
1 file changed, 27 insertions(+), 27 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index d0e0f609a0..4eeeedff5b 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -2022,31 +2022,31 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
static int ppc_next_unmasked_interrupt(CPUPPCState *env)
{
+ uint32_t pending_interrupts = env->pending_interrupts;
+ target_ulong lpcr = env->spr[SPR_LPCR];
+ bool async_deliver;
+
#ifdef TARGET_PPC64
switch (env->excp_model) {
case POWERPC_EXCP_POWER7:
- return p7_next_unmasked_interrupt(env, env->pending_interrupts,
- env->spr[SPR_LPCR]);
+ return p7_next_unmasked_interrupt(env, pending_interrupts, lpcr);
case POWERPC_EXCP_POWER8:
- return p8_next_unmasked_interrupt(env, env->pending_interrupts,
- env->spr[SPR_LPCR]);
+ return p8_next_unmasked_interrupt(env, pending_interrupts, lpcr);
case POWERPC_EXCP_POWER9:
case POWERPC_EXCP_POWER10:
case POWERPC_EXCP_POWER11:
- return p9_next_unmasked_interrupt(env, env->pending_interrupts,
- env->spr[SPR_LPCR]);
+ return p9_next_unmasked_interrupt(env, pending_interrupts, lpcr);
default:
break;
}
#endif
- bool async_deliver;
/* External reset */
- if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
+ if (pending_interrupts & PPC_INTERRUPT_RESET) {
return PPC_INTERRUPT_RESET;
}
/* Machine check exception */
- if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
+ if (pending_interrupts & PPC_INTERRUPT_MCK) {
return PPC_INTERRUPT_MCK;
}
#if 0 /* TODO */
@@ -2065,9 +2065,9 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
async_deliver = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
/* Hypervisor decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
+ if (pending_interrupts & PPC_INTERRUPT_HDECR) {
/* LPCR will be clear when not supported so this will work */
- bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
+ bool hdice = !!(lpcr & LPCR_HDICE);
if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hdice) {
/* HDEC clears on delivery */
return PPC_INTERRUPT_HDECR;
@@ -2075,18 +2075,18 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
}
/* Hypervisor virtualization interrupt */
- if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
+ if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
/* LPCR will be clear when not supported so this will work */
- bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
+ bool hvice = !!(lpcr & LPCR_HVICE);
if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hvice) {
return PPC_INTERRUPT_HVIRT;
}
}
/* External interrupt can ignore MSR:EE under some circumstances */
- if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
- bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
- bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
+ if (pending_interrupts & PPC_INTERRUPT_EXT) {
+ bool lpes0 = !!(lpcr & LPCR_LPES0);
+ bool heic = !!(lpcr & LPCR_HEIC);
/* HEIC blocks delivery to the hypervisor */
if ((async_deliver && !(heic && FIELD_EX64_HV(env->msr) &&
!FIELD_EX64(env->msr, MSR, PR))) ||
@@ -2096,45 +2096,45 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
}
if (FIELD_EX64(env->msr, MSR, CE)) {
/* External critical interrupt */
- if (env->pending_interrupts & PPC_INTERRUPT_CEXT) {
+ if (pending_interrupts & PPC_INTERRUPT_CEXT) {
return PPC_INTERRUPT_CEXT;
}
}
if (async_deliver != 0) {
/* Watchdog timer on embedded PowerPC */
- if (env->pending_interrupts & PPC_INTERRUPT_WDT) {
+ if (pending_interrupts & PPC_INTERRUPT_WDT) {
return PPC_INTERRUPT_WDT;
}
- if (env->pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
return PPC_INTERRUPT_CDOORBELL;
}
/* Fixed interval timer on embedded PowerPC */
- if (env->pending_interrupts & PPC_INTERRUPT_FIT) {
+ if (pending_interrupts & PPC_INTERRUPT_FIT) {
return PPC_INTERRUPT_FIT;
}
/* Programmable interval timer on embedded PowerPC */
- if (env->pending_interrupts & PPC_INTERRUPT_PIT) {
+ if (pending_interrupts & PPC_INTERRUPT_PIT) {
return PPC_INTERRUPT_PIT;
}
/* Decrementer exception */
- if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
+ if (pending_interrupts & PPC_INTERRUPT_DECR) {
return PPC_INTERRUPT_DECR;
}
- if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
return PPC_INTERRUPT_DOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
+ if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
return PPC_INTERRUPT_HDOORBELL;
}
- if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
+ if (pending_interrupts & PPC_INTERRUPT_PERFM) {
return PPC_INTERRUPT_PERFM;
}
/* Thermal interrupt */
- if (env->pending_interrupts & PPC_INTERRUPT_THERM) {
+ if (pending_interrupts & PPC_INTERRUPT_THERM) {
return PPC_INTERRUPT_THERM;
}
/* EBB exception */
- if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
+ if (pending_interrupts & PPC_INTERRUPT_EBB) {
/*
* EBB exception must be taken in problem state and
* with BESCR_GE set.
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt
2024-09-13 4:13 ` [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt Harsh Prateek Bora
@ 2024-09-13 12:50 ` BALATON Zoltan
2024-09-17 4:40 ` Harsh Prateek Bora
2024-10-08 6:53 ` Nicholas Piggin
2024-10-08 6:51 ` Nicholas Piggin
1 sibling, 2 replies; 21+ messages in thread
From: BALATON Zoltan @ 2024-09-13 12:50 UTC (permalink / raw)
To: Harsh Prateek Bora; +Cc: qemu-ppc, qemu-devel, npiggin, danielhb413
On Fri, 13 Sep 2024, Harsh Prateek Bora wrote:
> As previously done for arch specific handlers, simplify var usage in
> ppc_next_unmasked_interrupt by caching the env->pending_interrupts and
> env->spr[SPR_LPCR] in local vars and using it later at multiple places.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> ---
> target/ppc/excp_helper.c | 54 ++++++++++++++++++++--------------------
> 1 file changed, 27 insertions(+), 27 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index d0e0f609a0..4eeeedff5b 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -2022,31 +2022,31 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
>
> static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> {
> + uint32_t pending_interrupts = env->pending_interrupts;
> + target_ulong lpcr = env->spr[SPR_LPCR];
> + bool async_deliver;
Maybe easier to review if split into one patch for each variable added so
it's easier to see what's replaced and that nothing is missed.
Regards,
BALATON Zoltan
> +
> #ifdef TARGET_PPC64
> switch (env->excp_model) {
> case POWERPC_EXCP_POWER7:
> - return p7_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p7_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> case POWERPC_EXCP_POWER8:
> - return p8_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p8_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> case POWERPC_EXCP_POWER9:
> case POWERPC_EXCP_POWER10:
> case POWERPC_EXCP_POWER11:
> - return p9_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p9_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> default:
> break;
> }
> #endif
> - bool async_deliver;
>
> /* External reset */
> - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> + if (pending_interrupts & PPC_INTERRUPT_RESET) {
> return PPC_INTERRUPT_RESET;
> }
> /* Machine check exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> + if (pending_interrupts & PPC_INTERRUPT_MCK) {
> return PPC_INTERRUPT_MCK;
> }
> #if 0 /* TODO */
> @@ -2065,9 +2065,9 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> async_deliver = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
>
> /* Hypervisor decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
> + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> /* LPCR will be clear when not supported so this will work */
> - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> + bool hdice = !!(lpcr & LPCR_HDICE);
> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hdice) {
> /* HDEC clears on delivery */
> return PPC_INTERRUPT_HDECR;
> @@ -2075,18 +2075,18 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> }
>
> /* Hypervisor virtualization interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
> + if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
> /* LPCR will be clear when not supported so this will work */
> - bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
> + bool hvice = !!(lpcr & LPCR_HVICE);
> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hvice) {
> return PPC_INTERRUPT_HVIRT;
> }
> }
>
> /* External interrupt can ignore MSR:EE under some circumstances */
> - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + if (pending_interrupts & PPC_INTERRUPT_EXT) {
> + bool lpes0 = !!(lpcr & LPCR_LPES0);
> + bool heic = !!(lpcr & LPCR_HEIC);
> /* HEIC blocks delivery to the hypervisor */
> if ((async_deliver && !(heic && FIELD_EX64_HV(env->msr) &&
> !FIELD_EX64(env->msr, MSR, PR))) ||
> @@ -2096,45 +2096,45 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> }
> if (FIELD_EX64(env->msr, MSR, CE)) {
> /* External critical interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_CEXT) {
> + if (pending_interrupts & PPC_INTERRUPT_CEXT) {
> return PPC_INTERRUPT_CEXT;
> }
> }
> if (async_deliver != 0) {
> /* Watchdog timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_WDT) {
> + if (pending_interrupts & PPC_INTERRUPT_WDT) {
> return PPC_INTERRUPT_WDT;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> return PPC_INTERRUPT_CDOORBELL;
> }
> /* Fixed interval timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_FIT) {
> + if (pending_interrupts & PPC_INTERRUPT_FIT) {
> return PPC_INTERRUPT_FIT;
> }
> /* Programmable interval timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_PIT) {
> + if (pending_interrupts & PPC_INTERRUPT_PIT) {
> return PPC_INTERRUPT_PIT;
> }
> /* Decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
> + if (pending_interrupts & PPC_INTERRUPT_DECR) {
> return PPC_INTERRUPT_DECR;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> return PPC_INTERRUPT_DOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> return PPC_INTERRUPT_HDOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
> + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
> return PPC_INTERRUPT_PERFM;
> }
> /* Thermal interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_THERM) {
> + if (pending_interrupts & PPC_INTERRUPT_THERM) {
> return PPC_INTERRUPT_THERM;
> }
> /* EBB exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
> + if (pending_interrupts & PPC_INTERRUPT_EBB) {
> /*
> * EBB exception must be taken in problem state and
> * with BESCR_GE set.
>
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt
2024-09-13 12:50 ` BALATON Zoltan
@ 2024-09-17 4:40 ` Harsh Prateek Bora
2024-10-08 6:53 ` Nicholas Piggin
1 sibling, 0 replies; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-17 4:40 UTC (permalink / raw)
To: BALATON Zoltan; +Cc: qemu-ppc, qemu-devel, npiggin, danielhb413
On 9/13/24 18:20, BALATON Zoltan wrote:
> On Fri, 13 Sep 2024, Harsh Prateek Bora wrote:
>> As previously done for arch specific handlers, simplify var usage in
>> ppc_next_unmasked_interrupt by caching the env->pending_interrupts and
>> env->spr[SPR_LPCR] in local vars and using it later at multiple places.
>>
>> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
>> ---
>> target/ppc/excp_helper.c | 54 ++++++++++++++++++++--------------------
>> 1 file changed, 27 insertions(+), 27 deletions(-)
>>
>> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
>> index d0e0f609a0..4eeeedff5b 100644
>> --- a/target/ppc/excp_helper.c
>> +++ b/target/ppc/excp_helper.c
>> @@ -2022,31 +2022,31 @@ static int
>> p9_next_unmasked_interrupt(CPUPPCState *env,
>>
>> static int ppc_next_unmasked_interrupt(CPUPPCState *env)
>> {
>> + uint32_t pending_interrupts = env->pending_interrupts;
>> + target_ulong lpcr = env->spr[SPR_LPCR];
>> + bool async_deliver;
>
> Maybe easier to review if split into one patch for each variable added
> so it's easier to see what's replaced and that nothing is missed.
>
Thanks for the reviews. I shall split as suggested in v4.
regards,
Harsh
> Regards,
> BALATON Zoltan
>
>> +
>> #ifdef TARGET_PPC64
>> switch (env->excp_model) {
>> case POWERPC_EXCP_POWER7:
>> - return p7_next_unmasked_interrupt(env, env->pending_interrupts,
>> - env->spr[SPR_LPCR]);
>> + return p7_next_unmasked_interrupt(env, pending_interrupts,
>> lpcr);
>> case POWERPC_EXCP_POWER8:
>> - return p8_next_unmasked_interrupt(env, env->pending_interrupts,
>> - env->spr[SPR_LPCR]);
>> + return p8_next_unmasked_interrupt(env, pending_interrupts,
>> lpcr);
>> case POWERPC_EXCP_POWER9:
>> case POWERPC_EXCP_POWER10:
>> case POWERPC_EXCP_POWER11:
>> - return p9_next_unmasked_interrupt(env, env->pending_interrupts,
>> - env->spr[SPR_LPCR]);
>> + return p9_next_unmasked_interrupt(env, pending_interrupts,
>> lpcr);
>> default:
>> break;
>> }
>> #endif
>> - bool async_deliver;
>>
>> /* External reset */
>> - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
>> + if (pending_interrupts & PPC_INTERRUPT_RESET) {
>> return PPC_INTERRUPT_RESET;
>> }
>> /* Machine check exception */
>> - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
>> + if (pending_interrupts & PPC_INTERRUPT_MCK) {
>> return PPC_INTERRUPT_MCK;
>> }
>> #if 0 /* TODO */
>> @@ -2065,9 +2065,9 @@ static int
>> ppc_next_unmasked_interrupt(CPUPPCState *env)
>> async_deliver = FIELD_EX64(env->msr, MSR, EE) ||
>> env->resume_as_sreset;
>>
>> /* Hypervisor decrementer exception */
>> - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
>> + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
>> /* LPCR will be clear when not supported so this will work */
>> - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
>> + bool hdice = !!(lpcr & LPCR_HDICE);
>> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hdice) {
>> /* HDEC clears on delivery */
>> return PPC_INTERRUPT_HDECR;
>> @@ -2075,18 +2075,18 @@ static int
>> ppc_next_unmasked_interrupt(CPUPPCState *env)
>> }
>>
>> /* Hypervisor virtualization interrupt */
>> - if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
>> + if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
>> /* LPCR will be clear when not supported so this will work */
>> - bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
>> + bool hvice = !!(lpcr & LPCR_HVICE);
>> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hvice) {
>> return PPC_INTERRUPT_HVIRT;
>> }
>> }
>>
>> /* External interrupt can ignore MSR:EE under some circumstances */
>> - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
>> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
>> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
>> + if (pending_interrupts & PPC_INTERRUPT_EXT) {
>> + bool lpes0 = !!(lpcr & LPCR_LPES0);
>> + bool heic = !!(lpcr & LPCR_HEIC);
>> /* HEIC blocks delivery to the hypervisor */
>> if ((async_deliver && !(heic && FIELD_EX64_HV(env->msr) &&
>> !FIELD_EX64(env->msr, MSR, PR))) ||
>> @@ -2096,45 +2096,45 @@ static int
>> ppc_next_unmasked_interrupt(CPUPPCState *env)
>> }
>> if (FIELD_EX64(env->msr, MSR, CE)) {
>> /* External critical interrupt */
>> - if (env->pending_interrupts & PPC_INTERRUPT_CEXT) {
>> + if (pending_interrupts & PPC_INTERRUPT_CEXT) {
>> return PPC_INTERRUPT_CEXT;
>> }
>> }
>> if (async_deliver != 0) {
>> /* Watchdog timer on embedded PowerPC */
>> - if (env->pending_interrupts & PPC_INTERRUPT_WDT) {
>> + if (pending_interrupts & PPC_INTERRUPT_WDT) {
>> return PPC_INTERRUPT_WDT;
>> }
>> - if (env->pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
>> + if (pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
>> return PPC_INTERRUPT_CDOORBELL;
>> }
>> /* Fixed interval timer on embedded PowerPC */
>> - if (env->pending_interrupts & PPC_INTERRUPT_FIT) {
>> + if (pending_interrupts & PPC_INTERRUPT_FIT) {
>> return PPC_INTERRUPT_FIT;
>> }
>> /* Programmable interval timer on embedded PowerPC */
>> - if (env->pending_interrupts & PPC_INTERRUPT_PIT) {
>> + if (pending_interrupts & PPC_INTERRUPT_PIT) {
>> return PPC_INTERRUPT_PIT;
>> }
>> /* Decrementer exception */
>> - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
>> + if (pending_interrupts & PPC_INTERRUPT_DECR) {
>> return PPC_INTERRUPT_DECR;
>> }
>> - if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
>> + if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
>> return PPC_INTERRUPT_DOORBELL;
>> }
>> - if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
>> + if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
>> return PPC_INTERRUPT_HDOORBELL;
>> }
>> - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
>> + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
>> return PPC_INTERRUPT_PERFM;
>> }
>> /* Thermal interrupt */
>> - if (env->pending_interrupts & PPC_INTERRUPT_THERM) {
>> + if (pending_interrupts & PPC_INTERRUPT_THERM) {
>> return PPC_INTERRUPT_THERM;
>> }
>> /* EBB exception */
>> - if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
>> + if (pending_interrupts & PPC_INTERRUPT_EBB) {
>> /*
>> * EBB exception must be taken in problem state and
>> * with BESCR_GE set.
>>
^ permalink raw reply [flat|nested] 21+ messages in thread* Re: [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt
2024-09-13 12:50 ` BALATON Zoltan
2024-09-17 4:40 ` Harsh Prateek Bora
@ 2024-10-08 6:53 ` Nicholas Piggin
1 sibling, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:53 UTC (permalink / raw)
To: BALATON Zoltan, Harsh Prateek Bora; +Cc: qemu-ppc, qemu-devel, danielhb413
On Fri Sep 13, 2024 at 10:50 PM AEST, BALATON Zoltan wrote:
> On Fri, 13 Sep 2024, Harsh Prateek Bora wrote:
> > As previously done for arch specific handlers, simplify var usage in
> > ppc_next_unmasked_interrupt by caching the env->pending_interrupts and
> > env->spr[SPR_LPCR] in local vars and using it later at multiple places.
> >
> > Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
> > ---
> > target/ppc/excp_helper.c | 54 ++++++++++++++++++++--------------------
> > 1 file changed, 27 insertions(+), 27 deletions(-)
> >
> > diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> > index d0e0f609a0..4eeeedff5b 100644
> > --- a/target/ppc/excp_helper.c
> > +++ b/target/ppc/excp_helper.c
> > @@ -2022,31 +2022,31 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
> >
> > static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> > {
> > + uint32_t pending_interrupts = env->pending_interrupts;
> > + target_ulong lpcr = env->spr[SPR_LPCR];
> > + bool async_deliver;
>
> Maybe easier to review if split into one patch for each variable added so
> it's easier to see what's replaced and that nothing is missed.
I'm happy to leave squashed since it's pretty simple search/replace
with no logic change, and touching the same lines.
Thanks,
Nick
>
> Regards,
> BALATON Zoltan
>
> > +
> > #ifdef TARGET_PPC64
> > switch (env->excp_model) {
> > case POWERPC_EXCP_POWER7:
> > - return p7_next_unmasked_interrupt(env, env->pending_interrupts,
> > - env->spr[SPR_LPCR]);
> > + return p7_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> > case POWERPC_EXCP_POWER8:
> > - return p8_next_unmasked_interrupt(env, env->pending_interrupts,
> > - env->spr[SPR_LPCR]);
> > + return p8_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> > case POWERPC_EXCP_POWER9:
> > case POWERPC_EXCP_POWER10:
> > case POWERPC_EXCP_POWER11:
> > - return p9_next_unmasked_interrupt(env, env->pending_interrupts,
> > - env->spr[SPR_LPCR]);
> > + return p9_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> > default:
> > break;
> > }
> > #endif
> > - bool async_deliver;
> >
> > /* External reset */
> > - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> > + if (pending_interrupts & PPC_INTERRUPT_RESET) {
> > return PPC_INTERRUPT_RESET;
> > }
> > /* Machine check exception */
> > - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> > + if (pending_interrupts & PPC_INTERRUPT_MCK) {
> > return PPC_INTERRUPT_MCK;
> > }
> > #if 0 /* TODO */
> > @@ -2065,9 +2065,9 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> > async_deliver = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
> >
> > /* Hypervisor decrementer exception */
> > - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
> > + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> > /* LPCR will be clear when not supported so this will work */
> > - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> > + bool hdice = !!(lpcr & LPCR_HDICE);
> > if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hdice) {
> > /* HDEC clears on delivery */
> > return PPC_INTERRUPT_HDECR;
> > @@ -2075,18 +2075,18 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> > }
> >
> > /* Hypervisor virtualization interrupt */
> > - if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
> > + if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
> > /* LPCR will be clear when not supported so this will work */
> > - bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
> > + bool hvice = !!(lpcr & LPCR_HVICE);
> > if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hvice) {
> > return PPC_INTERRUPT_HVIRT;
> > }
> > }
> >
> > /* External interrupt can ignore MSR:EE under some circumstances */
> > - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
> > - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> > - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> > + if (pending_interrupts & PPC_INTERRUPT_EXT) {
> > + bool lpes0 = !!(lpcr & LPCR_LPES0);
> > + bool heic = !!(lpcr & LPCR_HEIC);
> > /* HEIC blocks delivery to the hypervisor */
> > if ((async_deliver && !(heic && FIELD_EX64_HV(env->msr) &&
> > !FIELD_EX64(env->msr, MSR, PR))) ||
> > @@ -2096,45 +2096,45 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> > }
> > if (FIELD_EX64(env->msr, MSR, CE)) {
> > /* External critical interrupt */
> > - if (env->pending_interrupts & PPC_INTERRUPT_CEXT) {
> > + if (pending_interrupts & PPC_INTERRUPT_CEXT) {
> > return PPC_INTERRUPT_CEXT;
> > }
> > }
> > if (async_deliver != 0) {
> > /* Watchdog timer on embedded PowerPC */
> > - if (env->pending_interrupts & PPC_INTERRUPT_WDT) {
> > + if (pending_interrupts & PPC_INTERRUPT_WDT) {
> > return PPC_INTERRUPT_WDT;
> > }
> > - if (env->pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> > + if (pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> > return PPC_INTERRUPT_CDOORBELL;
> > }
> > /* Fixed interval timer on embedded PowerPC */
> > - if (env->pending_interrupts & PPC_INTERRUPT_FIT) {
> > + if (pending_interrupts & PPC_INTERRUPT_FIT) {
> > return PPC_INTERRUPT_FIT;
> > }
> > /* Programmable interval timer on embedded PowerPC */
> > - if (env->pending_interrupts & PPC_INTERRUPT_PIT) {
> > + if (pending_interrupts & PPC_INTERRUPT_PIT) {
> > return PPC_INTERRUPT_PIT;
> > }
> > /* Decrementer exception */
> > - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
> > + if (pending_interrupts & PPC_INTERRUPT_DECR) {
> > return PPC_INTERRUPT_DECR;
> > }
> > - if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> > + if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> > return PPC_INTERRUPT_DOORBELL;
> > }
> > - if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> > + if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> > return PPC_INTERRUPT_HDOORBELL;
> > }
> > - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
> > + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
> > return PPC_INTERRUPT_PERFM;
> > }
> > /* Thermal interrupt */
> > - if (env->pending_interrupts & PPC_INTERRUPT_THERM) {
> > + if (pending_interrupts & PPC_INTERRUPT_THERM) {
> > return PPC_INTERRUPT_THERM;
> > }
> > /* EBB exception */
> > - if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
> > + if (pending_interrupts & PPC_INTERRUPT_EBB) {
> > /*
> > * EBB exception must be taken in problem state and
> > * with BESCR_GE set.
> >
^ permalink raw reply [flat|nested] 21+ messages in thread
* Re: [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt
2024-09-13 4:13 ` [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt Harsh Prateek Bora
2024-09-13 12:50 ` BALATON Zoltan
@ 2024-10-08 6:51 ` Nicholas Piggin
1 sibling, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:51 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> As previously done for arch specific handlers, simplify var usage in
> ppc_next_unmasked_interrupt by caching the env->pending_interrupts and
> env->spr[SPR_LPCR] in local vars and using it later at multiple places.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> target/ppc/excp_helper.c | 54 ++++++++++++++++++++--------------------
> 1 file changed, 27 insertions(+), 27 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index d0e0f609a0..4eeeedff5b 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -2022,31 +2022,31 @@ static int p9_next_unmasked_interrupt(CPUPPCState *env,
>
> static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> {
> + uint32_t pending_interrupts = env->pending_interrupts;
> + target_ulong lpcr = env->spr[SPR_LPCR];
> + bool async_deliver;
> +
> #ifdef TARGET_PPC64
> switch (env->excp_model) {
> case POWERPC_EXCP_POWER7:
> - return p7_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p7_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> case POWERPC_EXCP_POWER8:
> - return p8_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p8_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> case POWERPC_EXCP_POWER9:
> case POWERPC_EXCP_POWER10:
> case POWERPC_EXCP_POWER11:
> - return p9_next_unmasked_interrupt(env, env->pending_interrupts,
> - env->spr[SPR_LPCR]);
> + return p9_next_unmasked_interrupt(env, pending_interrupts, lpcr);
> default:
> break;
> }
> #endif
> - bool async_deliver;
>
> /* External reset */
> - if (env->pending_interrupts & PPC_INTERRUPT_RESET) {
> + if (pending_interrupts & PPC_INTERRUPT_RESET) {
> return PPC_INTERRUPT_RESET;
> }
> /* Machine check exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_MCK) {
> + if (pending_interrupts & PPC_INTERRUPT_MCK) {
> return PPC_INTERRUPT_MCK;
> }
> #if 0 /* TODO */
> @@ -2065,9 +2065,9 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> async_deliver = FIELD_EX64(env->msr, MSR, EE) || env->resume_as_sreset;
>
> /* Hypervisor decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_HDECR) {
> + if (pending_interrupts & PPC_INTERRUPT_HDECR) {
> /* LPCR will be clear when not supported so this will work */
> - bool hdice = !!(env->spr[SPR_LPCR] & LPCR_HDICE);
> + bool hdice = !!(lpcr & LPCR_HDICE);
> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hdice) {
> /* HDEC clears on delivery */
> return PPC_INTERRUPT_HDECR;
> @@ -2075,18 +2075,18 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> }
>
> /* Hypervisor virtualization interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_HVIRT) {
> + if (pending_interrupts & PPC_INTERRUPT_HVIRT) {
> /* LPCR will be clear when not supported so this will work */
> - bool hvice = !!(env->spr[SPR_LPCR] & LPCR_HVICE);
> + bool hvice = !!(lpcr & LPCR_HVICE);
> if ((async_deliver || !FIELD_EX64_HV(env->msr)) && hvice) {
> return PPC_INTERRUPT_HVIRT;
> }
> }
>
> /* External interrupt can ignore MSR:EE under some circumstances */
> - if (env->pending_interrupts & PPC_INTERRUPT_EXT) {
> - bool lpes0 = !!(env->spr[SPR_LPCR] & LPCR_LPES0);
> - bool heic = !!(env->spr[SPR_LPCR] & LPCR_HEIC);
> + if (pending_interrupts & PPC_INTERRUPT_EXT) {
> + bool lpes0 = !!(lpcr & LPCR_LPES0);
> + bool heic = !!(lpcr & LPCR_HEIC);
> /* HEIC blocks delivery to the hypervisor */
> if ((async_deliver && !(heic && FIELD_EX64_HV(env->msr) &&
> !FIELD_EX64(env->msr, MSR, PR))) ||
> @@ -2096,45 +2096,45 @@ static int ppc_next_unmasked_interrupt(CPUPPCState *env)
> }
> if (FIELD_EX64(env->msr, MSR, CE)) {
> /* External critical interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_CEXT) {
> + if (pending_interrupts & PPC_INTERRUPT_CEXT) {
> return PPC_INTERRUPT_CEXT;
> }
> }
> if (async_deliver != 0) {
> /* Watchdog timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_WDT) {
> + if (pending_interrupts & PPC_INTERRUPT_WDT) {
> return PPC_INTERRUPT_WDT;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_CDOORBELL) {
> return PPC_INTERRUPT_CDOORBELL;
> }
> /* Fixed interval timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_FIT) {
> + if (pending_interrupts & PPC_INTERRUPT_FIT) {
> return PPC_INTERRUPT_FIT;
> }
> /* Programmable interval timer on embedded PowerPC */
> - if (env->pending_interrupts & PPC_INTERRUPT_PIT) {
> + if (pending_interrupts & PPC_INTERRUPT_PIT) {
> return PPC_INTERRUPT_PIT;
> }
> /* Decrementer exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_DECR) {
> + if (pending_interrupts & PPC_INTERRUPT_DECR) {
> return PPC_INTERRUPT_DECR;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_DOORBELL) {
> return PPC_INTERRUPT_DOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> + if (pending_interrupts & PPC_INTERRUPT_HDOORBELL) {
> return PPC_INTERRUPT_HDOORBELL;
> }
> - if (env->pending_interrupts & PPC_INTERRUPT_PERFM) {
> + if (pending_interrupts & PPC_INTERRUPT_PERFM) {
> return PPC_INTERRUPT_PERFM;
> }
> /* Thermal interrupt */
> - if (env->pending_interrupts & PPC_INTERRUPT_THERM) {
> + if (pending_interrupts & PPC_INTERRUPT_THERM) {
> return PPC_INTERRUPT_THERM;
> }
> /* EBB exception */
> - if (env->pending_interrupts & PPC_INTERRUPT_EBB) {
> + if (pending_interrupts & PPC_INTERRUPT_EBB) {
> /*
> * EBB exception must be taken in problem state and
> * with BESCR_GE set.
^ permalink raw reply [flat|nested] 21+ messages in thread
* [PATCH v3 10/10] target/ppc: combine multiple ail checks into one
2024-09-13 4:13 [PATCH v3 00/10] misc ppc improvements/optimizations Harsh Prateek Bora
` (8 preceding siblings ...)
2024-09-13 4:13 ` [PATCH v3 09/10] target/ppc: simplify var usage in ppc_next_unmasked_interrupt Harsh Prateek Bora
@ 2024-09-13 4:13 ` Harsh Prateek Bora
2024-10-08 6:52 ` Nicholas Piggin
9 siblings, 1 reply; 21+ messages in thread
From: Harsh Prateek Bora @ 2024-09-13 4:13 UTC (permalink / raw)
To: qemu-ppc, qemu-devel; +Cc: npiggin, balaton, danielhb413
ppc_excp_apply_ail has multiple if-checks for ail which is un-necessary.
Combine them as appropriate.
Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
---
target/ppc/excp_helper.c | 10 ++--------
1 file changed, 2 insertions(+), 8 deletions(-)
diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
index 4eeeedff5b..a8bd537a18 100644
--- a/target/ppc/excp_helper.c
+++ b/target/ppc/excp_helper.c
@@ -324,10 +324,7 @@ static void ppc_excp_apply_ail(PowerPCCPU *cpu, int excp, target_ulong msr,
}
ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
- if (ail == 0) {
- return;
- }
- if (ail == 1) {
+ if (ail == 0 || ail == 1) {
/* AIL=1 is reserved, treat it like AIL=0 */
return;
}
@@ -351,10 +348,7 @@ static void ppc_excp_apply_ail(PowerPCCPU *cpu, int excp, target_ulong msr,
} else {
ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
}
- if (ail == 0) {
- return;
- }
- if (ail == 1 || ail == 2) {
+ if (ail == 0 || ail == 1 || ail == 2) {
/* AIL=1 and AIL=2 are reserved, treat them like AIL=0 */
return;
}
--
2.45.2
^ permalink raw reply related [flat|nested] 21+ messages in thread* Re: [PATCH v3 10/10] target/ppc: combine multiple ail checks into one
2024-09-13 4:13 ` [PATCH v3 10/10] target/ppc: combine multiple ail checks into one Harsh Prateek Bora
@ 2024-10-08 6:52 ` Nicholas Piggin
0 siblings, 0 replies; 21+ messages in thread
From: Nicholas Piggin @ 2024-10-08 6:52 UTC (permalink / raw)
To: Harsh Prateek Bora, qemu-ppc, qemu-devel; +Cc: balaton, danielhb413
On Fri Sep 13, 2024 at 2:13 PM AEST, Harsh Prateek Bora wrote:
> ppc_excp_apply_ail has multiple if-checks for ail which is un-necessary.
> Combine them as appropriate.
>
> Signed-off-by: Harsh Prateek Bora <harshpb@linux.ibm.com>
This looks okay. I was kind of trying to make the reserved cases
separate from the non-reserved, but in hindsight I don't think it
really improved things and the comment is enough in each case.
Reviewed-by: Nicholas Piggin <npiggin@gmail.com>
> ---
> target/ppc/excp_helper.c | 10 ++--------
> 1 file changed, 2 insertions(+), 8 deletions(-)
>
> diff --git a/target/ppc/excp_helper.c b/target/ppc/excp_helper.c
> index 4eeeedff5b..a8bd537a18 100644
> --- a/target/ppc/excp_helper.c
> +++ b/target/ppc/excp_helper.c
> @@ -324,10 +324,7 @@ static void ppc_excp_apply_ail(PowerPCCPU *cpu, int excp, target_ulong msr,
> }
>
> ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
> - if (ail == 0) {
> - return;
> - }
> - if (ail == 1) {
> + if (ail == 0 || ail == 1) {
> /* AIL=1 is reserved, treat it like AIL=0 */
> return;
> }
> @@ -351,10 +348,7 @@ static void ppc_excp_apply_ail(PowerPCCPU *cpu, int excp, target_ulong msr,
> } else {
> ail = (env->spr[SPR_LPCR] & LPCR_AIL) >> LPCR_AIL_SHIFT;
> }
> - if (ail == 0) {
> - return;
> - }
> - if (ail == 1 || ail == 2) {
> + if (ail == 0 || ail == 1 || ail == 2) {
> /* AIL=1 and AIL=2 are reserved, treat them like AIL=0 */
> return;
> }
^ permalink raw reply [flat|nested] 21+ messages in thread