motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-09 18:44:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

cpus: Prefer cached CpuClass over CPU_GET_CLASS() macro

Browse source 
CpuState caches its CPUClass since commit 6fbdff8706
("cpu: cache CPUClass in CPUState for hot code paths"),
use it.

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20250122093028.52416-5-philmd@linaro.org>
This commit is contained in:
Philippe Mathieu-Daudé 2025-01-21 12:12:35 +01:00
parent 43610f3184
commit 30e76638eb
4 changed files with 33 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

10
cpu-common.c
View file

@ -388,11 +388,10 @@ void process_queued_cpu_work(CPUState *cpu)
int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags, int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags,
CPUBreakpoint **breakpoint) CPUBreakpoint **breakpoint)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu);
CPUBreakpoint *bp; CPUBreakpoint *bp;
if (cc->gdb_adjust_breakpoint) { if (cpu->cc->gdb_adjust_breakpoint) {
pc = cc->gdb_adjust_breakpoint(cpu, pc); pc = cpu->cc->gdb_adjust_breakpoint(cpu, pc);
} }
bp = g_malloc(sizeof(*bp)); bp = g_malloc(sizeof(*bp));
@ -418,11 +417,10 @@ int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags,
/* Remove a specific breakpoint. */ /* Remove a specific breakpoint. */
int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags) int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu);
CPUBreakpoint *bp; CPUBreakpoint *bp;
if (cc->gdb_adjust_breakpoint) { if (cpu->cc->gdb_adjust_breakpoint) {
pc = cc->gdb_adjust_breakpoint(cpu, pc); pc = cpu->cc->gdb_adjust_breakpoint(cpu, pc);
} }
QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) { QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {

13
hw/core/cpu-common.c
View file

@ -40,9 +40,7 @@ CPUState *cpu_by_arch_id(int64_t id)
CPUState *cpu; CPUState *cpu;
CPU_FOREACH(cpu) { CPU_FOREACH(cpu) {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->get_arch_id(cpu) == id) {
if (cc->get_arch_id(cpu) == id) {
return cpu; return cpu;
} }
} }
@ -101,11 +99,9 @@ static int cpu_common_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg)
void cpu_dump_state(CPUState *cpu, FILE *f, int flags) void cpu_dump_state(CPUState *cpu, FILE *f, int flags)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->dump_state) {
if (cc->dump_state) {
cpu_synchronize_state(cpu); cpu_synchronize_state(cpu);
cc->dump_state(cpu, f, flags); cpu->cc->dump_state(cpu, f, flags);
} }
} }
@ -119,11 +115,10 @@ void cpu_reset(CPUState *cpu)
static void cpu_common_reset_hold(Object *obj, ResetType type) static void cpu_common_reset_hold(Object *obj, ResetType type)
{ {
CPUState *cpu = CPU(obj); CPUState *cpu = CPU(obj);
CPUClass *cc = CPU_GET_CLASS(cpu);
if (qemu_loglevel_mask(CPU_LOG_RESET)) { if (qemu_loglevel_mask(CPU_LOG_RESET)) {
qemu_log("CPU Reset (CPU %d)\n", cpu->cpu_index); qemu_log("CPU Reset (CPU %d)\n", cpu->cpu_index);
log_cpu_state(cpu, cc->reset_dump_flags); log_cpu_state(cpu, cpu->cc->reset_dump_flags);
} }
cpu->interrupt_request = 0; cpu->interrupt_request = 0;

61
hw/core/cpu-system.c
View file

@ -33,10 +33,8 @@
bool cpu_paging_enabled(const CPUState *cpu) bool cpu_paging_enabled(const CPUState *cpu)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->sysemu_ops->get_paging_enabled) {
return cpu->cc->sysemu_ops->get_paging_enabled(cpu);
if (cc->sysemu_ops->get_paging_enabled) {
return cc->sysemu_ops->get_paging_enabled(cpu);
} }
return false; return false;
@ -45,10 +43,8 @@ bool cpu_paging_enabled(const CPUState *cpu)
bool cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list, bool cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list,
Error **errp) Error **errp)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->sysemu_ops->get_memory_mapping) {
return cpu->cc->sysemu_ops->get_memory_mapping(cpu, list, errp);
if (cc->sysemu_ops->get_memory_mapping) {
return cc->sysemu_ops->get_memory_mapping(cpu, list, errp);
} }
error_setg(errp, "Obtaining memory mappings is unsupported on this CPU."); error_setg(errp, "Obtaining memory mappings is unsupported on this CPU.");
@ -58,15 +54,15 @@ bool cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list,
hwaddr cpu_get_phys_page_attrs_debug(CPUState *cpu, vaddr addr, hwaddr cpu_get_phys_page_attrs_debug(CPUState *cpu, vaddr addr,
MemTxAttrs *attrs) MemTxAttrs *attrs)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu);
hwaddr paddr; hwaddr paddr;
if (cc->sysemu_ops->get_phys_page_attrs_debug) { if (cpu->cc->sysemu_ops->get_phys_page_attrs_debug) {
paddr = cc->sysemu_ops->get_phys_page_attrs_debug(cpu, addr, attrs); paddr = cpu->cc->sysemu_ops->get_phys_page_attrs_debug(cpu, addr,
attrs);
} else { } else {
/* Fallback for CPUs which don't implement the _attrs_ hook */ /* Fallback for CPUs which don't implement the _attrs_ hook */
*attrs = MEMTXATTRS_UNSPECIFIED; *attrs = MEMTXATTRS_UNSPECIFIED;
paddr = cc->sysemu_ops->get_phys_page_debug(cpu, addr); paddr = cpu->cc->sysemu_ops->get_phys_page_debug(cpu, addr);
} }
/* Indicate that this is a debug access. */ /* Indicate that this is a debug access. */
attrs->debug = 1; attrs->debug = 1;
@ -94,64 +90,53 @@ int cpu_asidx_from_attrs(CPUState *cpu, MemTxAttrs attrs)
int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu, int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque) void *opaque)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (!cpu->cc->sysemu_ops->write_elf32_qemunote) {
if (!cc->sysemu_ops->write_elf32_qemunote) {
return 0; return 0;
} }
return (*cc->sysemu_ops->write_elf32_qemunote)(f, cpu, opaque); return (*cpu->cc->sysemu_ops->write_elf32_qemunote)(f, cpu, opaque);
} }
int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu, int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque) int cpuid, void *opaque)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (!cpu->cc->sysemu_ops->write_elf32_note) {
if (!cc->sysemu_ops->write_elf32_note) {
return -1; return -1;
} }
return (*cc->sysemu_ops->write_elf32_note)(f, cpu, cpuid, opaque); return (*cpu->cc->sysemu_ops->write_elf32_note)(f, cpu, cpuid, opaque);
} }
int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu, int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque) void *opaque)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (!cpu->cc->sysemu_ops->write_elf64_qemunote) {
if (!cc->sysemu_ops->write_elf64_qemunote) {
return 0; return 0;
} }
return (*cc->sysemu_ops->write_elf64_qemunote)(f, cpu, opaque); return (*cpu->cc->sysemu_ops->write_elf64_qemunote)(f, cpu, opaque);
} }
int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu, int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque) int cpuid, void *opaque)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (!cpu->cc->sysemu_ops->write_elf64_note) {
if (!cc->sysemu_ops->write_elf64_note) {
return -1; return -1;
} }
return (*cc->sysemu_ops->write_elf64_note)(f, cpu, cpuid, opaque); return (*cpu->cc->sysemu_ops->write_elf64_note)(f, cpu, cpuid, opaque);
} }
bool cpu_virtio_is_big_endian(CPUState *cpu) bool cpu_virtio_is_big_endian(CPUState *cpu)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->sysemu_ops->virtio_is_big_endian) {
return cpu->cc->sysemu_ops->virtio_is_big_endian(cpu);
if (cc->sysemu_ops->virtio_is_big_endian) {
return cc->sysemu_ops->virtio_is_big_endian(cpu);
} }
return target_words_bigendian(); return target_words_bigendian();
} }
GuestPanicInformation *cpu_get_crash_info(CPUState *cpu) GuestPanicInformation *cpu_get_crash_info(CPUState *cpu)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu);
GuestPanicInformation *res = NULL; GuestPanicInformation *res = NULL;
if (cc->sysemu_ops->get_crash_info) { if (cpu->cc->sysemu_ops->get_crash_info) {
res = cc->sysemu_ops->get_crash_info(cpu); res = cpu->cc->sysemu_ops->get_crash_info(cpu);
} }
return res; return res;
} }
@ -300,10 +285,8 @@ void cpu_vmstate_register(CPUState *cpu)
void cpu_vmstate_unregister(CPUState *cpu) void cpu_vmstate_unregister(CPUState *cpu)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); if (cpu->cc->sysemu_ops->legacy_vmsd != NULL) {
vmstate_unregister(NULL, cpu->cc->sysemu_ops->legacy_vmsd, cpu);
if (cc->sysemu_ops->legacy_vmsd != NULL) {
vmstate_unregister(NULL, cc->sysemu_ops->legacy_vmsd, cpu);
} }
if (qdev_get_vmsd(DEVICE(cpu)) == NULL) { if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {
vmstate_unregister(NULL, &vmstate_cpu_common, cpu); vmstate_unregister(NULL, &vmstate_cpu_common, cpu);

10
include/hw/core/cpu.h
View file

@ -826,10 +826,8 @@ const char *parse_cpu_option(const char *cpu_option);
*/ */
static inline bool cpu_has_work(CPUState *cpu) static inline bool cpu_has_work(CPUState *cpu)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); g_assert(cpu->cc->has_work);
return cpu->cc->has_work(cpu);
g_assert(cc->has_work);
return cc->has_work(cpu);
} }
/** /**
@ -968,9 +966,7 @@ void cpu_interrupt(CPUState *cpu, int mask);
*/ */
static inline void cpu_set_pc(CPUState *cpu, vaddr addr) static inline void cpu_set_pc(CPUState *cpu, vaddr addr)
{ {
CPUClass *cc = CPU_GET_CLASS(cpu); cpu->cc->set_pc(cpu, addr);
cc->set_pc(cpu, addr);
} }
/** /**