Hexagon system emulation - Part 2/3
v4 cover Hexagon system emulation - Part 2/3
This is Part 2 of the Hexagon system emulation series. It adds the runtime helpers, CPU operations, and translation support needed for full-system emulation of the Hexagon DSP.
This includes:
- Software interrupt (SWI) and interrupt handling
- TLB fill and permission checking
- System register read/write support in TCG
- Implicit sysreg writes and translation-block termination
- Stack overflow exception support
- Thread scheduling helpers (setprio, resched, resume)
- k0 lock/unlock for kernel mode
- idef-parser support for fFRAMECHECK
- TCG overrides for system transfer instructions
Based on Part 1 v6.
Changes since v3:
- Rebased onto Part 1 v6
- Fixed idef-parser fFRAMECHECK implementation (Taylor)
- Removed pkt_ends_tb from DisasContext, call pkt_ends_tb() directly (Taylor)
- Changed t_sreg_new_value sizing from NUM_SREGS to HEX_SREG_GLB_START (Taylor)
- Removed unnecessary tcg_gen_mov_tl sreg pre-copy in gen_start_packet(); no sreg writes are predicated (Taylor)
- Added continue after STID/IMASK/IPENDAD writeback in gen_sreg_writes() to avoid redundant writeback (Taylor)
- Moved hexagon_greg_read() declaration to correct commit (Taylor)
- Fixed set_enable_mask/clear_enable_mask return type consistency (Taylor)
- Added early return for globalregs==false in set_enable_mask and set_wait_mode (Taylor)
- Fixed bare %x/%d format specifiers across multiple files, using PRIx32/PRIu32/TARGET_FMT_lx as appropriate (Taylor)
- Fixed mid-block variable declarations (C89 style)
- Removed invalid PRM section references from setprio/resched commit message (Taylor)
- Renamed "Add TLB, k0 {un,}lock" to "Add k0 {un,}lock" (Taylor)
- Moved cycle counter/pcycle/modify_ssr commits to Part 1
- All cycle counter code properly guarded by
ifndef CONFIG_USER_ONLY (Taylor)
Previous versions:
- v3: https://lore.kernel.org/qemu-devel/[email protected]/
- v2: https://lore.kernel.org/qemu-devel/[email protected]/
- v1: https://lore.kernel.org/qemu-devel/[email protected]/
Brian Cain (26):
target/hexagon: Implement {c,}swi helpers target/hexagon: Implement iassign{r,w} helpers target/hexagon: Implement start/stop helpers, soft reset target/hexagon: Implement {g,s}etimask helpers target/hexagon: Implement wait helper
target/hexagon: Implement get_exe_mode() target/hexagon: Implement hex_tlb_entry_get_perm() target/hexagon: Implement software interrupt target/hexagon: Implement stack overflow exception target/hexagon: Implement exec_interrupt, set_irq target/hexagon: Implement hexagon_tlb_fill() target/hexagon: Implement siad inst
target/hexagon: Implement hexagon_resume_threads() target/hexagon: Implement setprio, resched target/hexagon: Add sysemu_ops, cpu_get_phys_page_debug() target/hexagon: extend hexagon_cpu_mmu_index() for sysemu target/hexagon: Decode trap1, rte as COF target/hexagon: Implement modify_ssr, resched, pending_interrupt target/hexagon: Add pkt_ends_tb to translation target/hexagon: Add next_PC, {s,g}reg writes target/hexagon: Add implicit sysreg writes target/hexagon: Define system, guest reg names target/hexagon: Add k0 {un,}lock
target/hexagon: Add PC to raise_exception, use fTRAP() helper target/hexagon: Add TCG overrides for transfer insts target/hexagon: Add support for loadw_phys
Matheus Tavares Bernardino (2):
target/hexagon: add simple cpu_exec_reset and pointer_wrap target/hexagon: Add guest reg reading functionality
target/hexagon/cpu.h | 11 + target/hexagon/cpu_helper.h | 8 + target/hexagon/gen_tcg.h | 7 - target/hexagon/gen_tcg_sys.h | 25 ++ target/hexagon/helper.h | 6 +- target/hexagon/hexswi.h | 17 + target/hexagon/idef-parser/parser-helpers.h | 2 + target/hexagon/internal.h | 4 + target/hexagon/macros.h | 3 - target/hexagon/sys_macros.h | 7 + target/hexagon/translate.h | 5 +- target/hexagon/reg_fields_def.h.inc | 11 + linux-user/hexagon/cpu_loop.c | 7 + target/hexagon/cpu.c | 360 ++++++++++++++- target/hexagon/decode.c | 14 + target/hexagon/genptr.c | 18 +- target/hexagon/hexswi.c | 267 +++++++++++ target/hexagon/idef-parser/parser-helpers.c | 9 + target/hexagon/op_helper.c | 462 +++++++++++++++++++- target/hexagon/translate.c | 225 +++++++++- target/hexagon/hex_common.py | 3 + target/hexagon/idef-parser/idef-parser.y | 3 + target/hexagon/imported/encode_pp.def | 1 + target/hexagon/imported/ldst.idef | 3 + 24 files changed, 1425 insertions(+), 53 deletions(-) create mode 100644 target/hexagon/hexswi.h create mode 100644 target/hexagon/hexswi.c
Signature · 1 line
2.34.1
PATCH v4 1/28 target/hexagon: Implement {c,}swi helpers
From: Brian Cain <[email protected]>
{c,}swi are the "software interrupt"/"Cancel pending interrupts" instructions.
--- target/hexagon/op_helper.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
target/hexagon/op_helper.c +6 -2
@@ -23,6 +23,7 @@#include "cpu.h" #include "exec/helper-proto.h" #include "fpu/softfloat.h" +#include "exec/cpu-interrupt.h" #include "internal.h" #include "macros.h" #include "sys_macros.h"
@@ -35,6 +36,7 @@#include "cpu_helper.h" #include "translate.h" #ifndef CONFIG_USER_ONLY +#include "hex_interrupts.h" #include "hexswi.h" #endif
@@ -1402,12 +1404,14 @@ void HELPER(siad)(CPUHexagonState *env, uint32_t mask)void HELPER (swi )(CPUHexagonState *env,uint32_t mask) { -g_assert_not_reached (); +BQL_LOCK_GUARD (); +hex_raise_interrupts (env, mask,CPU_INTERRUPT_SWI ); }void HELPER (cswi )(CPUHexagonState *env,uint32_t mask) { -g_assert_not_reached (); +BQL_LOCK_GUARD (); +hex_clear_interrupts (env, mask,CPU_INTERRUPT_SWI ); }void HELPER (iassignw )(CPUHexagonState *env,uint32_t src)
Signature · 1 line
2.34.1
PATCH v4 2/28 target/hexagon: Implement iassign{r,w} helpers
In reply to Brian CainFrom: Brian Cain <[email protected]>
iassign{r,w} are the "Interrupt to thread assignment {read,write}" instructions.
--- target/hexagon/op_helper.c | 56 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-)
target/hexagon/op_helper.c +54 -2
@@ -1416,12 +1416,64 @@ void HELPER(cswi)(CPUHexagonState *env, uint32_t mask)void HELPER (iassignw )(CPUHexagonState *env,uint32_t src) { -g_assert_not_reached (); +uint32_t modectl; +uint32_t thread_enabled_mask; +CPUState *cpu; +HexagonCPU *hex_cpu; + +BQL_LOCK_GUARD (); + hex_cpu =env_archcpu (env); + modectl = hex_cpu->globalregs ? +hexagon_globalreg_read (hex_cpu->globalregs,HEX_SREG_MODECTL , + env->threadId) :0 ; + thread_enabled_mask =GET_FIELD (MODECTL_E , modectl); + +CPU_FOREACH (cpu) { +CPUHexagonState *thread_env = &(HEXAGON_CPU (cpu)->env); +uint32_t thread_id_mask =0x1 << thread_env->threadId; +if (thread_enabled_mask & thread_id_mask) { +uint32_t imask = thread_env->t_sreg[HEX_SREG_IMASK ]; +uint32_t intbitpos = (src >>16 ) &0xF ; +uint32_t val = (src >> thread_env->threadId) &0x1 ; + imask =deposit32 (imask, intbitpos,1 , val); + thread_env->t_sreg[HEX_SREG_IMASK ] = imask; + +qemu_log_mask (CPU_LOG_INT ,"%s: thread " TARGET_FMT_ld +", new imask 0x%" PRIx32"\n" , __func__, + thread_env->threadId, imask); + } + } +hex_interrupt_update (env); }uint32_t HELPER (iassignr )(CPUHexagonState *env,uint32_t src) { -g_assert_not_reached (); +uint32_t modectl; +uint32_t thread_enabled_mask; +uint32_t intbitpos; +uint32_t dest_reg; +CPUState *cpu; +HexagonCPU *hex_cpu; + +BQL_LOCK_GUARD (); + hex_cpu =env_archcpu (env); + modectl = hex_cpu->globalregs ? +hexagon_globalreg_read (hex_cpu->globalregs,HEX_SREG_MODECTL , + env->threadId) :0 ; + thread_enabled_mask =GET_FIELD (MODECTL_E , modectl); +/* src fields are in same position as modectl, but mean different things */ + intbitpos =GET_FIELD (MODECTL_W , src); + dest_reg =0 ; +CPU_FOREACH (cpu) { +CPUHexagonState *thread_env = &(HEXAGON_CPU (cpu)->env); +uint32_t thread_id_mask =0x1 << thread_env->threadId; +if (thread_enabled_mask & thread_id_mask) { +uint32_t imask = thread_env->t_sreg[HEX_SREG_IMASK ]; + dest_reg |= ((imask >> intbitpos) &0x1 ) << thread_env->threadId; + } + } + +return dest_reg; }void HELPER (start )(CPUHexagonState *env,uint32_t imask)
Signature · 1 line
2.34.1
PATCH v4 3/28 target/hexagon: Implement start/stop helpers, soft reset
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu.h | 9 +++++++++ target/hexagon/cpu.c | 28 ++++++++++++++++++++++++++-- target/hexagon/op_helper.c | 4 ++-- 3 files changed, 37 insertions(+), 4 deletions(-)
target/hexagon/cpu.h +9 -0
@@ -212,6 +212,15 @@ G_NORETURN void hexagon_raise_exception_err(CPUHexagonState *env,uint32_t exception, uintptr_t pc); +#ifndef CONFIG_USER_ONLY +/* +* @return true if the @a thread_env hardware thread is +* not stopped. +*/ +bool hexagon_thread_is_enabled (CPUHexagonState *thread_env); +void hexagon_cpu_soft_reset (CPUHexagonState *env); +#endif +typedef HexagonCPU ArchCPU ;void hexagon_translate_init (void );
target/hexagon/cpu.c +26 -2
@@ -33,6 +33,7 @@#ifndef CONFIG_USER_ONLY #include "sys_macros.h" #include "accel/tcg/cpu-ldst.h" +#include "qemu/main-loop.h" #endif static void hexagon_v66_cpu_init (Object *obj) { }
@@ -315,6 +316,28 @@ static void hexagon_restore_state_to_opc(CPUState *cs, } +#ifndef CONFIG_USER_ONLY +void hexagon_cpu_soft_reset (CPUHexagonState *env) +{ +HexagonCPU *cpu; + +BQL_LOCK_GUARD (); + env->t_sreg[HEX_SREG_SSR ] =0 ; +hexagon_ssr_set_cause (env,HEX_CAUSE_RESET ); + + cpu =env_archcpu (env); +if (cpu->globalregs) { +uint32_t evb = +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_EVB , + env->threadId); + env->gpr[HEX_REG_PC ] = evb; + }else { + env->gpr[HEX_REG_PC ] = cpu->boot_addr; + } +} +#endif + +static void hexagon_cpu_reset_hold (Object *obj,ResetType type) {CPUState *cs =CPU (obj);
@@ -344,9 +367,10 @@ static void hexagon_cpu_reset_hold(Object *obj, ResetType type) env->t_sreg[HEX_SREG_HTID ] = cpu->htid; env->threadId = cpu->htid; - env->gpr[HEX_REG_PC ] = cpu->boot_addr; -#endif +hexagon_cpu_soft_reset (env); env->cause_code =HEX_EVENT_NONE ; + env->gpr[HEX_REG_PC ] = cpu->boot_addr; +#endif } static void hexagon_cpu_disas_set_info(const CPUState *cs,
target/hexagon/op_helper.c +2 -2
@@ -1478,12 +1478,12 @@ uint32_t HELPER(iassignr)(CPUHexagonState *env, uint32_t src)void HELPER (start )(CPUHexagonState *env,uint32_t imask) { -g_assert_not_reached (); +hexagon_start_threads (env, imask); }void HELPER (stop )(CPUHexagonState *env) { -g_assert_not_reached (); +hexagon_stop_thread (env); }void HELPER (wait )(CPUHexagonState *env,target_ulong PC )
Signature · 1 line
2.34.1
Re: [PATCH v4 03/28] target/hexagon: Implement start/stop helpers, soft reset
Quoted 9 lines · Brian Cain
From: Brian Cain <[email protected]>
Signed-off-by Brian Cain <[email protected]>--- target/hexagon/cpu.h | 9 +++++++++ target/hexagon/cpu.c | 28 ++++++++++++++++++++++++++-- target/hexagon/op_helper.c | 4 ++-- 3 files changed, 37 insertions(+), 4 deletions(-)
PATCH v4 4/28 target/hexagon: Implement {g,s}etimask helpers
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/op_helper.c | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-)
target/hexagon/op_helper.c +34 -2
@@ -1498,12 +1498,44 @@ void HELPER(resume)(CPUHexagonState *env, uint32_t mask)uint32_t HELPER (getimask )(CPUHexagonState *env,uint32_t tid) { -g_assert_not_reached (); +CPUState *cs; +BQL_LOCK_GUARD (); +CPU_FOREACH (cs) { +HexagonCPU *found_cpu =HEXAGON_CPU (cs); +CPUHexagonState *found_env = &found_cpu->env; +if (found_env->threadId == tid) { +uint32_t imask = found_env->t_sreg[HEX_SREG_IMASK ]; +qemu_log_mask (CPU_LOG_INT ,"%s: tid " TARGET_FMT_lx +" imask = 0x%" PRIx32"\n" , __func__, + env->threadId, + (uint32_t )GET_FIELD (IMASK_MASK , imask)); +return GET_FIELD (IMASK_MASK , imask); + } + } +return 0 ; }void HELPER (setimask )(CPUHexagonState *env,uint32_t tid,uint32_t imask) { -g_assert_not_reached (); +CPUState *cs; + +BQL_LOCK_GUARD (); +CPU_FOREACH (cs) { +HexagonCPU *found_cpu =HEXAGON_CPU (cs); +CPUHexagonState *found_env = &found_cpu->env; + +if (tid == found_env->threadId) { +SET_SYSTEM_FIELD (found_env,HEX_SREG_IMASK ,IMASK_MASK , imask); +qemu_log_mask (CPU_LOG_INT ,"%s: tid " TARGET_FMT_lx +" imask 0x%" PRIx32"\n" , + __func__, found_env->threadId, imask); +hex_interrupt_update (found_env); +return ; + } + } +qemu_log_mask (LOG_GUEST_ERROR , +"setimask used with an invalid tid near PC: 0x%" + PRIx32"\n" , env->next_PC); }void HELPER (sreg_write_masked )(CPUHexagonState *env,uint32_t reg,uint32_t val)
Signature · 1 line
2.34.1
PATCH v4 5/28 target/hexagon: Implement wait helper
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/op_helper.c | 60 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-)
target/hexagon/op_helper.c +58 -2
@@ -1486,9 +1486,65 @@ void HELPER(stop)(CPUHexagonState *env)hexagon_stop_thread (env); } -void HELPER (wait )(CPUHexagonState *env,target_ulong PC ) +static void set_wait_mode (CPUHexagonState *env) { -g_assert_not_reached (); +HexagonCPU *cpu; +uint32_t modectl; +uint32_t thread_wait_mask; + +g_assert (bql_locked ()); + + cpu =env_archcpu (env); +if (!cpu->globalregs) { +return ; + } + modectl = +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_MODECTL , + env->threadId); + thread_wait_mask =GET_FIELD (MODECTL_W , modectl); + thread_wait_mask |=0x1 << env->threadId; +SET_SYSTEM_FIELD (env,HEX_SREG_MODECTL ,MODECTL_W , thread_wait_mask); +} + +static void hexagon_wait_thread (CPUHexagonState *env,uint32_t PC ) +{ +CPUState *cs; + +g_assert (bql_locked ()); + +if (qemu_loglevel_mask (LOG_GUEST_ERROR ) && + (env->k0_lock_state !=HEX_LOCK_UNLOCKED || + env->tlb_lock_state !=HEX_LOCK_UNLOCKED )) { +qemu_log ("WARNING: executing wait() with acquired lock" +"may lead to deadlock\n" ); + } +g_assert (get_exe_mode (env) !=HEX_EXE_MODE_WAIT ); + + cs =env_cpu (env); +/* +* The addtion of cpu_has_work is borrowed from arm's wfi helper +* and is critical for our stability +*/ +if ((cs->exception_index !=HEX_EVENT_NONE ) || + (cpu_has_work (cs))) { +qemu_log_mask (CPU_LOG_INT , +"%s: thread %" PRIu32" skipping WAIT mode, have some work\n" , + __func__, env->threadId); +return ; + } +set_wait_mode (env); + env->wait_next_pc =PC +4 ; + +cpu_interrupt (cs,CPU_INTERRUPT_HALT ); +} + +void HELPER (wait )(CPUHexagonState *env,uint32_t PC ) +{ +BQL_LOCK_GUARD (); + +if (!fIN_DEBUG_MODE (env->threadId)) { +hexagon_wait_thread (env,PC ); + } }void HELPER (resume )(CPUHexagonState *env,uint32_t mask)
Signature · 1 line
2.34.1
PATCH v4 6/28 target/hexagon: Implement get_exe_mode()
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/reg_fields_def.h.inc | 11 +++++++++++ 1 file changed, 11 insertions(+)
target/hexagon/reg_fields_def.h.inc +11 -0
@@ -135,3 +135,14 @@ DEF_REG_FIELD(CCR_GRE, 27, 1) DEF_REG_FIELD(CCR_VV1, 29, 1) DEF_REG_FIELD(CCR_VV2, 30, 1) DEF_REG_FIELD(CCR_VV3, 31, 1) + +/* ISDB ST fields */ +DEF_REG_FIELD(ISDBST_WAITRUN, 24, 8) +DEF_REG_FIELD(ISDBST_ONOFF, 16, 8) +DEF_REG_FIELD(ISDBST_DEBUGMODE, 8, 8) +DEF_REG_FIELD(ISDBST_STUFFSTATUS, 5, 1) +DEF_REG_FIELD(ISDBST_CMDSTATUS, 4, 1) +DEF_REG_FIELD(ISDBST_PROCMODE, 3, 1) +DEF_REG_FIELD(ISDBST_MBXINSTATUS, 2, 1) +DEF_REG_FIELD(ISDBST_MBXOUTSTATUS, 1, 1) +DEF_REG_FIELD(ISDBST_READY, 0, 1)
Signature · 1 line
2.34.1
PATCH v4 7/28 target/hexagon: Implement hex_tlb_entry_get_perm()
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- linux-user/hexagon/cpu_loop.c | 7 +++++++ 1 file changed, 7 insertions(+)
linux-user/hexagon/cpu_loop.c +7 -0
@@ -63,6 +63,13 @@ void cpu_loop(CPUHexagonState *env)break ;case HEX_EVENT_PRECISE :switch (env->cause_code) { +case HEX_CAUSE_FETCH_NO_UPAGE : +case HEX_CAUSE_PRIV_NO_UREAD : +case HEX_CAUSE_PRIV_NO_UWRITE : +force_sig_fault (TARGET_SIGSEGV ,TARGET_SEGV_MAPERR , + env->gpr[HEX_REG_PC ]); + +break ;case HEX_CAUSE_PRIV_USER_NO_GINSN :case HEX_CAUSE_PRIV_USER_NO_SINSN :case HEX_CAUSE_INVALID_PACKET :
Signature · 1 line
2.34.1
PATCH v4 8/28 target/hexagon: Implement software interrupt
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/hexswi.h | 17 +++ target/hexagon/cpu.c | 1 + target/hexagon/hexswi.c | 267 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 285 insertions(+) create mode 100644 target/hexagon/hexswi.h create mode 100644 target/hexagon/hexswi.c
target/hexagon/hexswi.h new file +17 -0
@@ -0,0 +1,17 @@ +/* +* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#ifndef HEXSWI_H +#define HEXSWI_H + + +#include "cpu.h" + +void hexagon_cpu_do_interrupt (CPUState *cpu); +void register_trap_exception (CPUHexagonState *env,int type,int imm, +uint32_t PC ); + +#endif /* HEXSWI_H */
target/hexagon/cpu.c +1 -0
@@ -34,6 +34,7 @@#include "sys_macros.h" #include "accel/tcg/cpu-ldst.h" #include "qemu/main-loop.h" +#include "hex_interrupts.h" #endif static void hexagon_v66_cpu_init (Object *obj) { }
target/hexagon/hexswi.c new file +267 -0
267 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v4 08/28] target/hexagon: Implement software interrupt
Quoted 272 lines · Brian Cain
From: Brian Cain <[email protected]>
Co-authored-by Mike Lambert <[email protected]>Signed-off-by Brian Cain <[email protected]>--- target/hexagon/hexswi.h | 17 +++ target/hexagon/cpu.c | 1 + target/hexagon/hexswi.c | 267 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 285 insertions(+)create mode 100644
target/hexagon/hexswi.h
create mode 100644target/hexagon/hexswi.ctarget/hexagon/hexswi.h new file +17
-0@@ -0,0 +1,17 @@ +/* +* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#ifndef HEXSWI_H +#define HEXSWI_H + + +#include "cpu.h" + +void hexagon_cpu_do_interrupt (CPUState *cpu); +void register_trap_exception (CPUHexagonState *env,int type,int imm, +uint32_t PC ); + +#endif /* HEXSWI_H */ target/hexagon/cpu.c +1
-0@@ -34,6 +34,7 @@#include "sys_macros.h" #include "accel/tcg/cpu-ldst.h" #include "qemu/main-loop.h" +#include "hex_interrupts.h" #endif static void hexagon_v66_cpu_init (Object *obj) { }target/hexagon/hexswi.c new file +219
-0@@ -0,0 +1,267 @@ +/* +* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#include "qemu/osdep.h" +#include "cpu.h" +#include "cpu_helper.h" +#include "exec/helper-proto.h" +#include "qemu/log.h" +#include "qemu/main-loop.h" +#include "arch.h" +#include "internal.h" +#include "macros.h" +#include "sys_macros.h" +#include "tcg/tcg-op.h" +#include "hex_mmu.h" +#include "hexswi.h" +#include "hw/hexagon/hexagon_globalreg.h" + +#ifdef CONFIG_USER_ONLY +#error "This file is only used in system emulation" +#endif + +static void set_addresses (CPUHexagonState *env,uint32_t pc_offset, +uint32_t exception_index) + +{ +HexagonCPU *cpu =env_archcpu (env); +uint32_t evb = cpu->globalregs ? +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_EVB , + env->threadId) : + cpu->boot_addr; + env->t_sreg[HEX_SREG_ELR ] = env->gpr[HEX_REG_PC ] + pc_offset; + env->gpr[HEX_REG_PC ] = evb | (exception_index <<2 ); +} + +static const char *event_name[] = { + [HEX_EVENT_RESET ] ="HEX_EVENT_RESET" , + [HEX_EVENT_IMPRECISE ] ="HEX_EVENT_IMPRECISE" , + [HEX_EVENT_PRECISE ] ="HEX_EVENT_PRECISE" , + [HEX_EVENT_TLB_MISS_X ] ="HEX_EVENT_TLB_MISS_X" , + [HEX_EVENT_TLB_MISS_RW ] ="HEX_EVENT_TLB_MISS_RW" , + [HEX_EVENT_TRAP0 ] ="HEX_EVENT_TRAP0" , + [HEX_EVENT_TRAP1 ] ="HEX_EVENT_TRAP1" , + [HEX_EVENT_FPTRAP ] ="HEX_EVENT_FPTRAP" , + [HEX_EVENT_DEBUG ] ="HEX_EVENT_DEBUG" , + [HEX_EVENT_INT0 ] ="HEX_EVENT_INT0" , + [HEX_EVENT_INT1 ] ="HEX_EVENT_INT1" , + [HEX_EVENT_INT2 ] ="HEX_EVENT_INT2" , + [HEX_EVENT_INT3 ] ="HEX_EVENT_INT3" , + [HEX_EVENT_INT4 ] ="HEX_EVENT_INT4" , + [HEX_EVENT_INT5 ] ="HEX_EVENT_INT5" , + [HEX_EVENT_INT6 ] ="HEX_EVENT_INT6" , + [HEX_EVENT_INT7 ] ="HEX_EVENT_INT7" , + [HEX_EVENT_INT8 ] ="HEX_EVENT_INT8" , + [HEX_EVENT_INT9 ] ="HEX_EVENT_INT9" , + [HEX_EVENT_INTA ] ="HEX_EVENT_INTA" , + [HEX_EVENT_INTB ] ="HEX_EVENT_INTB" , + [HEX_EVENT_INTC ] ="HEX_EVENT_INTC" , + [HEX_EVENT_INTD ] ="HEX_EVENT_INTD" , + [HEX_EVENT_INTE ] ="HEX_EVENT_INTE" , + [HEX_EVENT_INTF ] ="HEX_EVENT_INTF" +}; + +void hexagon_cpu_do_interrupt (CPUState *cs) + +{ +CPUHexagonState *env =cpu_env (cs); +uint32_t ssr; + +BQL_LOCK_GUARD (); + +qemu_log_mask (CPU_LOG_INT , +"\t%s: event 0x%02x:%s, cause 0x%" PRIx32"(%" PRIu32")\n" , + __func__, (unsigned )cs->exception_index, + event_name[cs->exception_index], env->cause_code, + env->cause_code); + + env->llsc_addr = ~0 ; + + ssr = env->t_sreg[HEX_SREG_SSR ]; +if (GET_SSR_FIELD (SSR_EX , ssr) ==1 ) { +HexagonCPU *cpu =env_archcpu (env); +if (cpu->globalregs) { +hexagon_globalreg_write (cpu->globalregs,HEX_SREG_DIAG , + env->cause_code, env->threadId); + } + env->cause_code =HEX_CAUSE_DOUBLE_EXCEPT ; + cs->exception_index =HEX_EVENT_PRECISE ; + } + +switch (cs->exception_index) { +case HEX_EVENT_TRAP0 : +if (env->cause_code ==0 ) { +qemu_log_mask (LOG_UNIMP , +"trap0 is unhandled, no semihosting available\n" ); + } + +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,4 , cs->exception_index); +break ; + +case HEX_EVENT_TRAP1 : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,4 , cs->exception_index); +break ; + +case HEX_EVENT_TLB_MISS_X : +switch (env->cause_code) { +case HEX_CAUSE_TLBMISSX_CAUSE_NORMAL : +case HEX_CAUSE_TLBMISSX_CAUSE_NEXTPAGE : +qemu_log_mask (CPU_LOG_MMU , +"TLB miss EX exception (0x%02x) caught: " +"Cause code (0x%" PRIx32") " +"TID = 0x%" PRIx32", PC = 0x%" PRIx32 +", BADVA = 0x%" PRIx32"\n" , + (unsigned )cs->exception_index, + env->cause_code, env->threadId, + env->gpr[HEX_REG_PC ], + env->t_sreg[HEX_SREG_BADVA ]); + +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +break ; + +default : +cpu_abort (cs, +"1:Hexagon exception %d/0x%02x: " +"Unknown cause code %" PRIu32"/0x%" PRIx32"\n" , + cs->exception_index, (unsigned )cs->exception_index, + env->cause_code, + env->cause_code); +break ; + } +break ; + +case HEX_EVENT_TLB_MISS_RW : +switch (env->cause_code) { +case HEX_CAUSE_TLBMISSRW_CAUSE_READ : +case HEX_CAUSE_TLBMISSRW_CAUSE_WRITE : +qemu_log_mask (CPU_LOG_MMU , +"TLB miss RW exception (0x%02x) caught: " +"Cause code (0x%" PRIx32") " +"TID = 0x%" PRIx32", PC = 0x%" PRIx32 +", BADVA = 0x%" PRIx32"\n" , + (unsigned )cs->exception_index, + env->cause_code, env->threadId, + env->gpr[HEX_REG_PC ], + env->t_sreg[HEX_SREG_BADVA ]); + +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +/* env->sreg[HEX_SREG_BADVA] is set when the exception is raised */ +break ; + +default : +cpu_abort (cs, +"2:Hexagon exception %d/0x%02x: " +"Unknown cause code %" PRIu32"/0x%" PRIx32"\n" , + cs->exception_index, (unsigned )cs->exception_index, + env->cause_code, + env->cause_code); +break ; + } +break ; + +case HEX_EVENT_FPTRAP : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +break ; + +case HEX_EVENT_DEBUG : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +qemu_log_mask (LOG_UNIMP ,"single-step exception is not handled\n" ); +break ; + +case HEX_EVENT_PRECISE : +switch (env->cause_code) { +case HEX_CAUSE_FETCH_NO_XPAGE : +case HEX_CAUSE_FETCH_NO_UPAGE : +case HEX_CAUSE_PRIV_NO_READ : +case HEX_CAUSE_PRIV_NO_UREAD : +case HEX_CAUSE_PRIV_NO_WRITE : +case HEX_CAUSE_PRIV_NO_UWRITE : +case HEX_CAUSE_MISALIGNED_LOAD : +case HEX_CAUSE_MISALIGNED_STORE : +case HEX_CAUSE_PC_NOT_ALIGNED : +qemu_log_mask (CPU_LOG_MMU , +"MMU permission exception (0x%02x) caught: " +"Cause code (0x%" PRIx32") " +"TID = 0x%" PRIx32", PC = 0x%" PRIx32 +", BADVA = 0x%" PRIx32"\n" , + (unsigned )cs->exception_index, + env->cause_code, env->threadId, + env->gpr[HEX_REG_PC ], + env->t_sreg[HEX_SREG_BADVA ]); + + +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +/* env->sreg[HEX_SREG_BADVA] is set when the exception is raised */ +break ; + +case HEX_CAUSE_DOUBLE_EXCEPT : +case HEX_CAUSE_PRIV_USER_NO_SINSN : +case HEX_CAUSE_PRIV_USER_NO_GINSN : +case HEX_CAUSE_INVALID_OPCODE : +case HEX_CAUSE_NO_COPROC_ENABLE : +case HEX_CAUSE_NO_COPROC2_ENABLE : +case HEX_CAUSE_UNSUPPORTED_HVX_64B : +case HEX_CAUSE_REG_WRITE_CONFLICT : +case HEX_CAUSE_VWCTRL_WINDOW_MISS : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +break ; +
target/hexagon/hexswi.c line 229
Quoted 10 lines
target/hexagon/hexswi.c new file +10
-0+case HEX_CAUSE_COPROC_LDST : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +break ; + +case HEX_CAUSE_STACK_LIMIT : +hexagon_ssr_set_cause (env, env->cause_code); +set_addresses (env,0 , cs->exception_index); +break ; +
Any reason the 3 cases above are not merged together?
Quoted 28 lines
target/hexagon/hexswi.c new file +28
-0+default : +cpu_abort (cs, +"3:Hexagon exception %d/0x%02x: " +"Unknown cause code %" PRIu32"/0x%" PRIx32"\n" , + cs->exception_index, (unsigned )cs->exception_index, + env->cause_code, + env->cause_code); +break ; + } +break ; + +case HEX_EVENT_IMPRECISE : +qemu_log_mask (LOG_UNIMP , +"Imprecise exception: this case is not yet handled" ); +break ; + +default : +qemu_log_mask (LOG_UNIMP , +"Hexagon Unsupported exception 0x%02x/0x%" PRIx32"\n" , + (unsigned )cs->exception_index, env->cause_code); +break ; + } + + cs->exception_index =HEX_EVENT_NONE ; +} + +void register_trap_exception (CPUHexagonState *env,int traptype,int imm, +uint32_t PC )
target/hexagon/hexswi.c line 267
Quoted 10 lines
target/hexagon/hexswi.c new file +10
-0+{ +CPUState *cs =env_cpu (env); + + cs->exception_index = (traptype ==0 ) ?HEX_EVENT_TRAP0 :HEX_EVENT_TRAP1 ; +ASSERT_DIRECT_TO_GUEST_UNSET (env, cs->exception_index); + + env->cause_code = imm; + env->gpr[HEX_REG_PC ] =PC ; +cpu_loop_exit (cs); +}
For the rest, it seems to do what is expected.
PATCH v4 9/28 target/hexagon: Implement stack overflow exception
In reply to Brian CainImplement the frame limit check for system emulation mode. When allocframe computes a new stack pointer below FRAMELIMIT, raise a precise exception (HEX_CAUSE_STACK_LIMIT). The check is skipped in monitor mode.
--- target/hexagon/helper.h | 1 + target/hexagon/idef-parser/parser-helpers.h | 2 ++ target/hexagon/macros.h | 3 -- target/hexagon/sys_macros.h | 4 +++ target/hexagon/translate.h | 2 ++ target/hexagon/genptr.c | 18 +++++++---- target/hexagon/idef-parser/parser-helpers.c | 9 ++++++ target/hexagon/op_helper.c | 36 +++++++++++++++++++++ target/hexagon/idef-parser/idef-parser.y | 3 ++ 9 files changed, 68 insertions(+), 10 deletions(-)
target/hexagon/helper.h +1 -0
@@ -109,6 +109,7 @@ DEF_HELPER_2(probe_hvx_stores, void, env, int) DEF_HELPER_2(probe_pkt_scalar_hvx_stores, void, env, int)#if !defined(CONFIG_USER_ONLY ) +DEF_HELPER_3(raise_stack_overflow, void, env, i32, i32) DEF_HELPER_2(swi, void, env, i32) DEF_HELPER_2(cswi, void, env, i32)DEF_HELPER_2 (ciad, void, env, i32)
target/hexagon/idef-parser/parser-helpers.h +2 -0
@@ -295,6 +295,8 @@ void gen_cancel(Context *c, YYLTYPE *locp);void gen_load_cancel (Context *c,YYLTYPE *locp); +void gen_framecheck (Context *c,YYLTYPE *locp,HexValue *addr,HexValue *ea); +void gen_load (Context *c,YYLTYPE *locp,HexValue *size,HexSignedness signedness,HexValue *ea,HexValue *dst);
target/hexagon/macros.h +0 -3
@@ -538,9 +538,6 @@ static inline TCGv gen_read_ireg(TCGv result, TCGv val, int shift)#ifdef CONFIG_USER_ONLY #define fFRAMECHECK (ADDR ,EA ) do { } while (0)/* Not modelled in linux-user */ -#else -/* System mode not implemented yet */ -#define fFRAMECHECK (ADDR ,EA ) g_assert_not_reached();#endif #ifdef QEMU_GENERATE
target/hexagon/sys_macros.h +4 -0
@@ -95,6 +95,10 @@#define fTRAP (TRAPTYPE ,IMM ) \ register_trap_exception(env, TRAPTYPE, IMM, PC) +#ifdef QEMU_GENERATE +#define fFRAMECHECK (ADDR ,EA ) gen_framecheck(ctx, ADDR, EA) +#endif +#define fVIRTINSN_SPSWAP (IMM ,REG )#define fVIRTINSN_GETIE (IMM ,REG ) { REG = 0xdeafbeef; }#define fVIRTINSN_SETIE (IMM ,REG )
target/hexagon/translate.h +2 -0
@@ -340,4 +340,6 @@ FIELD(PROBE_PKT_SCALAR_HVX_STORES, S0_IS_PRED, 3, 1) FIELD(PROBE_PKT_SCALAR_HVX_STORES, S1_IS_PRED, 4, 1) FIELD(PROBE_PKT_SCALAR_HVX_STORES, MMU_IDX, 5, 2) +void gen_framecheck (DisasContext *ctx,TCGv_i32 addr,TCGv_i32 ea); +#endif
target/hexagon/genptr.c +11 -7
@@ -889,26 +889,30 @@ static void gen_load_frame(DisasContext *ctx, TCGv_i64 frame, TCGv EA)tcg_gen_qemu_ld_i64 (frame,EA , ctx->mem_idx,MO_LE |MO_UQ ); } -#ifndef CONFIG_HEXAGON_IDEF_PARSER /* Stack overflow check */ -static void gen_framecheck (TCGv EA ,int framesize) +void gen_framecheck (DisasContext *ctx,TCGv_i32 addr,TCGv_i32 ea) { -/* Not modelled in linux-user mode */ -/* Placeholder for system mode */ #ifndef CONFIG_USER_ONLY -g_assert_not_reached (); +TCGLabel *ok =gen_new_label (); +tcg_gen_brcond_i32 (TCG_COND_GEU , addr, hex_gpr[HEX_REG_FRAMELIMIT ], ok); +gen_helper_raise_stack_overflow (tcg_env, +tcg_constant_i32 (ctx->insn->slot), ea); +gen_set_label (ok);#endif } +#ifndef CONFIG_HEXAGON_IDEF_PARSER static void gen_allocframe (DisasContext *ctx,TCGv r29,int framesize) {TCGv r30 =get_result_gpr (ctx,HEX_REG_FP ); +TCGv_i32 new_r29 =tcg_temp_new_i32 ();TCGv_i64 frame;tcg_gen_addi_tl (r30, r29,-8 ); frame =gen_frame_scramble ();gen_store8 (tcg_env, r30, frame, ctx->insn->slot); -gen_framecheck (r30, framesize); -tcg_gen_subi_tl (r29, r30, framesize); +tcg_gen_subi_tl (new_r29, r30, framesize); +gen_framecheck (ctx, new_r29, hex_gpr[HEX_REG_PC ]); +tcg_gen_mov_tl (r29, new_r29); }static void gen_deallocframe (DisasContext *ctx,TCGv_i64 r31_30,TCGv r30)
target/hexagon/idef-parser/parser-helpers.c +9 -0
@@ -1731,6 +1731,15 @@ void gen_load_cancel(Context *c, YYLTYPE *locp)OUT (c, locp,"}\n" ); } +void gen_framecheck (Context *c,YYLTYPE *locp,HexValue *addr,HexValue *ea) +{ +HexValue addr_m =rvalue_materialize (c, locp, addr); +HexValue ea_m =rvalue_materialize (c, locp, ea); + addr_m =gen_rvalue_truncate (c, locp, &addr_m); + ea_m =gen_rvalue_truncate (c, locp, &ea_m); +OUT (c, locp,"gen_framecheck(ctx, " , &addr_m,", " , &ea_m,");\n" ); +} +void gen_load (Context *c,YYLTYPE *locp,HexValue *width,HexSignedness signedness,HexValue *ea,HexValue *dst) {
target/hexagon/op_helper.c +36 -0
@@ -1392,6 +1392,42 @@ void HELPER(vwhist128qm)(CPUHexagonState *env, int32_t uiV) }#ifndef CONFIG_USER_ONLY +void HELPER (raise_stack_overflow )(CPUHexagonState *env,uint32_t slot, +uint32_t badva) +{ +/* +* Per section 7.3.1 of the V67 Programmer's Reference, +* stack limit exception isn't raised in monitor mode. +*/ +uint32_t ssr = env->t_sreg[HEX_SREG_SSR ]; +CPUState *cs; + +if (GET_SSR_FIELD (SSR_EX , ssr) || + !GET_SSR_FIELD (SSR_UM , ssr)) { +return ; + } + + cs =env_cpu (env); + cs->exception_index =HEX_EVENT_PRECISE ; + env->cause_code =HEX_CAUSE_STACK_LIMIT ; +ASSERT_DIRECT_TO_GUEST_UNSET (env, cs->exception_index); + +if (slot ==0 ) { + env->t_sreg[HEX_SREG_BADVA0 ] = badva; +SET_SSR_FIELD (env,SSR_V0 ,1 ); +SET_SSR_FIELD (env,SSR_V1 ,0 ); +SET_SSR_FIELD (env,SSR_BVS ,0 ); + }else if (slot ==1 ) { + env->t_sreg[HEX_SREG_BADVA1 ] = badva; +SET_SSR_FIELD (env,SSR_V0 ,0 ); +SET_SSR_FIELD (env,SSR_V1 ,1 ); +SET_SSR_FIELD (env,SSR_BVS ,1 ); + }else { +g_assert_not_reached (); + } +cpu_loop_exit_restore (cs,0 ); +} +void HELPER (ciad )(CPUHexagonState *env,uint32_t mask) {g_assert_not_reached ();
target/hexagon/idef-parser/idef-parser.y +3 -0
@@ -404,6 +404,9 @@ control_statement : frame_check ; frame_check : FCHK '(' rvalue ',' rvalue ')' ';' + { + gen_framecheck(c, &@1, &$3, &$5); + } ; cancel_statement : LOAD_CANCEL
Signature · 1 line
2.34.1
PATCH v4 10/28 target/hexagon: Implement exec_interrupt, set_irq
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu.c | 84 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+)
target/hexagon/cpu.c +84 -0
@@ -16,6 +16,7 @@*/ #include "qemu/osdep.h" +#include "qemu/log.h" #include "qemu/qemu-print.h" #include "cpu.h" #include "internal.h"
@@ -31,10 +32,12 @@#include "hex_mmu.h" #ifndef CONFIG_USER_ONLY +#include "macros.h" #include "sys_macros.h" #include "accel/tcg/cpu-ldst.h" #include "qemu/main-loop.h" #include "hex_interrupts.h" +#include "exec/cpu-interrupt.h" #endif static void hexagon_v66_cpu_init (Object *obj) { }
@@ -309,6 +312,36 @@ static void hexagon_cpu_synchronize_from_tb(CPUState *cs,cpu_env (cs)->gpr[HEX_REG_PC ] = tb->pc; } +#ifndef CONFIG_USER_ONLY +bool hexagon_thread_is_enabled (CPUHexagonState *env) +{ +HexagonCPU *cpu =env_archcpu (env); +uint32_t modectl; +uint32_t thread_enabled_mask; +bool E_bit; + +if (!cpu->globalregs) { +return true; + } + modectl = +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_MODECTL , + env->threadId); + thread_enabled_mask =GET_FIELD (MODECTL_E , modectl); + E_bit = thread_enabled_mask & (0x1 << env->threadId); + +return E_bit; +} + +static bool hexagon_cpu_has_work (CPUState *cs) +{ +CPUHexagonState *env =cpu_env (cs); + +return hexagon_thread_is_enabled (env) && + (cs->interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_SWI + |CPU_INTERRUPT_K0_UNLOCK |CPU_INTERRUPT_TLB_UNLOCK )); +} +#endif +static void hexagon_restore_state_to_opc (CPUState *cs,const TranslationBlock *tb,const uint64_t *data)
@@ -408,10 +441,58 @@ static int hexagon_cpu_mmu_index(CPUState *cs, bool ifetch)return MMU_USER_IDX ; } +#if !defined(CONFIG_USER_ONLY ) +static void hexagon_cpu_set_irq (void *opaque,int irq,int level) +{ +HexagonCPU *cpu =HEXAGON_CPU (opaque); +CPUState *cs =CPU (cpu); +CPUHexagonState *env =cpu_env (cs); + +switch (irq) { + case HEXAGON_CPU_IRQ_0 ... HEXAGON_CPU_IRQ_7: +qemu_log_mask (CPU_LOG_INT ,"%s: irq %d, level %d\n" , + __func__, irq, level); +if (level) { +hex_raise_interrupts (env,1 << irq,CPU_INTERRUPT_HARD ); + } +break ; +default : +g_assert_not_reached (); + } +} +#endif +static void hexagon_cpu_init (Object *obj) { +#if !defined(CONFIG_USER_ONLY ) +HexagonCPU *cpu =HEXAGON_CPU (obj); +qdev_init_gpio_in (DEVICE (cpu), hexagon_cpu_set_irq,8 ); +#endif } +#ifndef CONFIG_USER_ONLY + +static bool hexagon_cpu_exec_interrupt (CPUState *cs,int interrupt_request) +{ +CPUHexagonState *env =cpu_env (cs); +if (interrupt_request &CPU_INTERRUPT_TLB_UNLOCK ) { + cs->halted = false; +cpu_reset_interrupt (cs,CPU_INTERRUPT_TLB_UNLOCK ); +return true; + } +if (interrupt_request &CPU_INTERRUPT_K0_UNLOCK ) { + cs->halted = false; +cpu_reset_interrupt (cs,CPU_INTERRUPT_K0_UNLOCK ); +return true; + } +if (interrupt_request & (CPU_INTERRUPT_HARD |CPU_INTERRUPT_SWI )) { +return hex_check_interrupts (env); + } +return false; +} + +#endif +static const TCGCPUOps hexagon_tcg_ops = {/* MTTCG not yet supported: require strict ordering */ .guest_default_memory_order =TCG_MO_ALL ,
@@ -422,6 +503,9 @@ static const TCGCPUOps hexagon_tcg_ops = { .synchronize_from_tb = hexagon_cpu_synchronize_from_tb, .restore_state_to_opc = hexagon_restore_state_to_opc, .mmu_index = hexagon_cpu_mmu_index, +#if !defined(CONFIG_USER_ONLY ) + .cpu_exec_interrupt = hexagon_cpu_exec_interrupt, +#endif /* !CONFIG_USER_ONLY */ };static void hexagon_cpu_class_init (ObjectClass *c,const void *data)
Signature · 1 line
2.34.1
PATCH v4 11/28 target/hexagon: add simple cpu_exec_reset and pointer_wrap
In reply to Brian CainFrom: Matheus Tavares Bernardino <[email protected]>
--- target/hexagon/cpu.c | 8 ++++++++ 1 file changed, 8 insertions(+)
target/hexagon/cpu.c +8 -0
@@ -491,6 +491,12 @@ static bool hexagon_cpu_exec_interrupt(CPUState *cs, int interrupt_request)return false; } +static vaddr hexagon_pointer_wrap (CPUState *cs,int mmu_idx, +vaddr result,vaddr base) +{ +return result; +} +#endif static const TCGCPUOps hexagon_tcg_ops = {
@@ -505,6 +511,8 @@ static const TCGCPUOps hexagon_tcg_ops = { .mmu_index = hexagon_cpu_mmu_index,#if !defined(CONFIG_USER_ONLY ) .cpu_exec_interrupt = hexagon_cpu_exec_interrupt, + .pointer_wrap = hexagon_pointer_wrap, + .cpu_exec_reset = cpu_reset,#endif /* !CONFIG_USER_ONLY */ };
Signature · 1 line
2.34.1
PATCH v4 12/28 target/hexagon: Implement hexagon_tlb_fill()
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu.c | 135 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+)
target/hexagon/cpu.c +135 -0
@@ -38,6 +38,8 @@#include "qemu/main-loop.h" #include "hex_interrupts.h" #include "exec/cpu-interrupt.h" +#include "exec/target_page.h" +#include "hw/hexagon/hexagon_globalreg.h" #endif static void hexagon_v66_cpu_init (Object *obj) { }
@@ -471,6 +473,138 @@ static void hexagon_cpu_init(Object *obj) }#ifndef CONFIG_USER_ONLY +static bool get_physical_address (CPUHexagonState *env,hwaddr *phys,int *prot, +uint64_t *size,int32_t *excp, +uint32_t address, +MMUAccessType access_type,int mmu_idx) + +{ +if (hexagon_cpu_mmu_enabled (env)) { +return hex_tlb_find_match (env, address, access_type, phys, prot, size, + excp, mmu_idx); + }else { + *phys = address &0xFFFFFFFF ; + *prot =PAGE_VALID |PAGE_READ |PAGE_WRITE |PAGE_EXEC ; + *size =TARGET_PAGE_SIZE ; +return true; + } +} + +/* qemu seems to only want to know about TARGET_PAGE_SIZE pages */ +static void find_qemu_subpage (vaddr *addr,hwaddr *phys,uint64_t page_size) +{ +vaddr page_start = *addr & ~((vaddr)(page_size -1 )); +vaddr offset = ((*addr - page_start) /TARGET_PAGE_SIZE ) *TARGET_PAGE_SIZE ; + *addr = page_start + offset; + *phys += offset; +} + + +#define INVALID_BADVA 0xbadabada + +static void set_badva_regs (CPUHexagonState *env,uint32_t VA ,int slot, +MMUAccessType access_type) +{ + env->t_sreg[HEX_SREG_BADVA ] =VA ; + +if (access_type ==MMU_INST_FETCH || slot ==0 ) { + env->t_sreg[HEX_SREG_BADVA0 ] =VA ; + env->t_sreg[HEX_SREG_BADVA1 ] =INVALID_BADVA ; +SET_SSR_FIELD (env,SSR_V0 ,1 ); +SET_SSR_FIELD (env,SSR_V1 ,0 ); +SET_SSR_FIELD (env,SSR_BVS ,0 ); + }else if (slot ==1 ) { + env->t_sreg[HEX_SREG_BADVA0 ] =INVALID_BADVA ; + env->t_sreg[HEX_SREG_BADVA1 ] =VA ; +SET_SSR_FIELD (env,SSR_V0 ,0 ); +SET_SSR_FIELD (env,SSR_V1 ,1 ); +SET_SSR_FIELD (env,SSR_BVS ,1 ); + }else { +g_assert_not_reached (); + } +} + +static void raise_tlbmiss_exception (CPUState *cs,uint32_t VA ,int slot, +MMUAccessType access_type) +{ +CPUHexagonState *env =cpu_env (cs); + +set_badva_regs (env,VA , slot, access_type); + +switch (access_type) { +case MMU_INST_FETCH : + cs->exception_index =HEX_EVENT_TLB_MISS_X ; +if ((VA & ~TARGET_PAGE_MASK ) ==0 ) { + env->cause_code =HEX_CAUSE_TLBMISSX_CAUSE_NEXTPAGE ; + }else { + env->cause_code =HEX_CAUSE_TLBMISSX_CAUSE_NORMAL ; + } +break ; +case MMU_DATA_LOAD : + cs->exception_index =HEX_EVENT_TLB_MISS_RW ; + env->cause_code =HEX_CAUSE_TLBMISSRW_CAUSE_READ ; +break ; +case MMU_DATA_STORE : + cs->exception_index =HEX_EVENT_TLB_MISS_RW ; + env->cause_code =HEX_CAUSE_TLBMISSRW_CAUSE_WRITE ; +break ; + } +} + +static void raise_perm_exception (CPUState *cs,uint32_t VA ,int slot, +MMUAccessType access_type,int32_t excp) +{ +CPUHexagonState *env =cpu_env (cs); + +set_badva_regs (env,VA , slot, access_type); + cs->exception_index = excp; +} + +static const char *access_type_names[] = {"MMU_DATA_LOAD " ,"MMU_DATA_STORE" , +"MMU_INST_FETCH" }; + +static const char *mmu_idx_names[] = {"MMU_USER_IDX" ,"MMU_GUEST_IDX" , +"MMU_KERNEL_IDX" }; + +static bool hexagon_tlb_fill (CPUState *cs,vaddr address,int size, +MMUAccessType access_type,int mmu_idx,bool probe, +uintptr_t retaddr) +{ +CPUHexagonState *env =cpu_env (cs); +int slot =0 ; +hwaddr phys; +int prot =0 ; +uint64_t page_size =0 ; +int32_t excp =0 ; +bool ret =0 ; + +qemu_log_mask ( +CPU_LOG_MMU , +"%s: tid = 0x%" PRIx32", pc = 0x%08" PRIx32", vaddr = 0x%08" VADDR_PRIx +", size = %d, %s,\tprobe = %d, %s\n" , + __func__, env->threadId, env->gpr[HEX_REG_PC ], address, size, + access_type_names[access_type], probe, mmu_idx_names[mmu_idx]); + ret =get_physical_address (env, &phys, &prot, &page_size, &excp, address, + access_type, mmu_idx); +if (ret) { +if (!excp) { +find_qemu_subpage (&address, &phys, page_size); +tlb_set_page (cs, address, phys, prot, mmu_idx,TARGET_PAGE_SIZE ); +return ret; + } +if (probe) { +return false; + } +raise_perm_exception (cs, address, slot, access_type, excp); +do_raise_exception (env, cs->exception_index, env->gpr[HEX_REG_PC ], + retaddr); + } +if (probe) { +return false; + } +raise_tlbmiss_exception (cs, address, slot, access_type); +do_raise_exception (env, cs->exception_index, env->gpr[HEX_REG_PC ], retaddr); +}static bool hexagon_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {
@@ -513,6 +647,7 @@ static const TCGCPUOps hexagon_tcg_ops = { .cpu_exec_interrupt = hexagon_cpu_exec_interrupt, .pointer_wrap = hexagon_pointer_wrap, .cpu_exec_reset = cpu_reset, + .tlb_fill = hexagon_tlb_fill,#endif /* !CONFIG_USER_ONLY */ };
Signature · 1 line
2.34.1
PATCH v4 13/28 target/hexagon: Implement siad inst
In reply to Brian CainFrom: Brian Cain <[email protected]>
siad is the 'Set interrupt auto disable' instruction.
--- target/hexagon/op_helper.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-)
target/hexagon/op_helper.c +16 -1
@@ -1435,7 +1435,22 @@ void HELPER(ciad)(CPUHexagonState *env, uint32_t mask)void HELPER (siad )(CPUHexagonState *env,uint32_t mask) { -g_assert_not_reached (); +uint32_t ipendad; +uint32_t iad; +HexagonCPU *cpu; + +BQL_LOCK_GUARD (); + cpu =env_archcpu (env); + ipendad = cpu->globalregs ? +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_IPENDAD , + env->threadId) :0 ; + iad =fGET_FIELD (ipendad,IPENDAD_IAD ); +fSET_FIELD (ipendad,IPENDAD_IAD , iad | mask); +if (cpu->globalregs) { +hexagon_globalreg_write (cpu->globalregs,HEX_SREG_IPENDAD , + ipendad, env->threadId); + } +hex_interrupt_update (env); }void HELPER (swi )(CPUHexagonState *env,uint32_t mask)
Signature · 1 line
2.34.1
PATCH v4 14/28 target/hexagon: Implement hexagon_resume_threads()
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu.h | 1 + target/hexagon/op_helper.c | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-)
target/hexagon/cpu.h +1 -0
@@ -53,6 +53,7 @@ typedef struct HexagonGlobalRegState HexagonGlobalRegState;#define PRED_WRITES_MAX 5/* 4 insns + endloop */ #define VSTORES_MAX 2#define MAX_TLB_ENTRIES 1024 +#define THREADS_MAX 8#define CPU_RESOLVING_TYPE TYPE_HEXAGON_CPU#ifndef CONFIG_USER_ONLY
target/hexagon/op_helper.c +2 -1
@@ -1600,7 +1600,8 @@ void HELPER(wait)(CPUHexagonState *env, uint32_t PC)void HELPER (resume )(CPUHexagonState *env,uint32_t mask) { -g_assert_not_reached (); +BQL_LOCK_GUARD (); +hexagon_resume_threads (env, mask); }uint32_t HELPER (getimask )(CPUHexagonState *env,uint32_t tid)
Signature · 1 line
2.34.1
PATCH v4 15/28 target/hexagon: Implement setprio, resched
In reply to Brian CainFrom: Brian Cain <[email protected]>
The hardware-assisted scheduler helps manage tasks on the run queue and interrupt steering.
--- target/hexagon/op_helper.c | 77 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+)
target/hexagon/op_helper.c +77 -0
@@ -1589,6 +1589,64 @@ static void hexagon_wait_thread(CPUHexagonState *env, uint32_t PC)cpu_interrupt (cs,CPU_INTERRUPT_HALT ); } +static inline QEMU_ALWAYS_INLINE void resched(CPUHexagonState *env) +{ +uint32_t schedcfg; +uint32_t schedcfg_en; +int int_number; +CPUState *cs; +uint32_t lowest_th_prio =0 ;/* 0 is highest prio */ +uint32_t bestwait_reg; +uint32_t best_prio; +HexagonCPU *cpu; + +BQL_LOCK_GUARD (); +qemu_log_mask (CPU_LOG_INT ,"%s: check resched\n" , __func__); + cpu =env_archcpu (env); + schedcfg = cpu->globalregs ? +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_SCHEDCFG , + env->threadId) :0 ; + schedcfg_en =GET_FIELD (SCHEDCFG_EN , schedcfg); + int_number =GET_FIELD (SCHEDCFG_INTNO , schedcfg); + +if (!schedcfg_en) { +return ; + } + +CPU_FOREACH (cs) { +HexagonCPU *thread =HEXAGON_CPU (cs); +CPUHexagonState *thread_env = &(thread->env); +uint32_t th_prio =GET_FIELD ( +STID_PRIO , thread_env->t_sreg[HEX_SREG_STID ]); +if (!hexagon_thread_is_enabled (thread_env)) { +continue ; + } + + lowest_th_prio = (lowest_th_prio > th_prio) + ? lowest_th_prio + : th_prio; + } + + bestwait_reg = cpu->globalregs ? +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_BESTWAIT , + env->threadId) :0 ; + best_prio =GET_FIELD (BESTWAIT_PRIO , bestwait_reg); + +/* +* If the lowest priority thread is lower priority than the +* value in the BESTWAIT register, we must raise the reschedule +* interrupt on the lowest priority thread. +*/ +if (lowest_th_prio > best_prio) { +qemu_log_mask (CPU_LOG_INT , +"%s: raising resched int %d," +" cur PC 0x%" PRIx32"\n" , + __func__, int_number, env->gpr[HEX_REG_PC ]); +SET_SYSTEM_FIELD (env,HEX_SREG_BESTWAIT ,BESTWAIT_PRIO , ~0 ); +hex_raise_interrupts (env,1 << int_number,CPU_INTERRUPT_SWI ); + } +} +void HELPER (wait )(CPUHexagonState *env,uint32_t PC ) {BQL_LOCK_GUARD ();
@@ -1697,8 +1755,27 @@ uint64_t HELPER(greg_read_pair)(CPUHexagonState *env, uint32_t reg)g_assert_not_reached (); } +/* +* setprio/resched - See the Hexagon V73 Programmer's Reference Manual, +* Section 6.4 "Interrupt and Thread Scheduling" +*/ void HELPER (setprio )(CPUHexagonState *env,uint32_t thread,uint32_t prio) { +CPUState *cs; + +BQL_LOCK_GUARD (); +CPU_FOREACH (cs) { +HexagonCPU *found_cpu =HEXAGON_CPU (cs); +CPUHexagonState *found_env = &found_cpu->env; +if (thread == found_env->threadId) { +SET_SYSTEM_FIELD (found_env,HEX_SREG_STID ,STID_PRIO , prio); +qemu_log_mask (CPU_LOG_INT , +"%s: tid %" PRIu32" prio = 0x%" PRIx32"\n" , + __func__, found_env->threadId, prio); +resched (env); +return ; + } + }g_assert_not_reached (); }
Signature · 1 line
2.34.1
Re: [PATCH v4 15/28] target/hexagon: Implement setprio, resched
Quoted 10 lines · Brian Cain
From: Brian Cain <[email protected]>
The hardware-assisted scheduler helps manage tasks on the run queue and interrupt steering.
Signed-off-by Brian Cain <[email protected]>--- target/hexagon/op_helper.c | 77 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+)
PATCH v4 16/28 target/hexagon: Add sysemu_ops, cpu_get_phys_page_debug()
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)
target/hexagon/cpu.c +32 -0
@@ -20,6 +20,7 @@#include "qemu/qemu-print.h" #include "cpu.h" #include "internal.h" +#include "exec/cputlb.h" #include "exec/translation-block.h" #include "qapi/error.h" #include "hw/core/qdev-properties.h"
@@ -37,6 +38,7 @@#include "accel/tcg/cpu-ldst.h" #include "qemu/main-loop.h" #include "hex_interrupts.h" +#include "hexswi.h" #include "exec/cpu-interrupt.h" #include "exec/target_page.h" #include "hw/hexagon/hexagon_globalreg.h"
@@ -499,6 +501,24 @@ static void find_qemu_subpage(vaddr *addr, hwaddr *phys, uint64_t page_size) *phys += offset; } +static hwaddr hexagon_cpu_get_phys_page_debug (CPUState *cs,vaddr addr) +{ +CPUHexagonState *env =cpu_env (cs); +hwaddr phys_addr; +int prot; +uint64_t page_size =0 ; +int32_t excp =0 ; +int mmu_idx =MMU_KERNEL_IDX ; + +if (get_physical_address (env, &phys_addr, &prot, &page_size, &excp, + addr,0 , mmu_idx)) { +find_qemu_subpage (&addr, &phys_addr, page_size); +return phys_addr; + } + +return -1 ; +} +#define INVALID_BADVA 0xbadabada
@@ -606,6 +626,13 @@ static bool hexagon_tlb_fill(CPUState *cs, vaddr address, int size,do_raise_exception (env, cs->exception_index, env->gpr[HEX_REG_PC ], retaddr); } +#include "hw/core/sysemu-cpu-ops.h" + +static const struct SysemuCPUOps hexagon_sysemu_ops = { + .has_work = hexagon_cpu_has_work, + .get_phys_page_debug = hexagon_cpu_get_phys_page_debug, +}; +static bool hexagon_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {CPUHexagonState *env =cpu_env (cs);
@@ -648,6 +675,8 @@ static const TCGCPUOps hexagon_tcg_ops = { .pointer_wrap = hexagon_pointer_wrap, .cpu_exec_reset = cpu_reset, .tlb_fill = hexagon_tlb_fill, + .cpu_exec_halt = hexagon_cpu_has_work, + .do_interrupt = hexagon_cpu_do_interrupt,#endif /* !CONFIG_USER_ONLY */ };
@@ -675,9 +704,12 @@ static void hexagon_cpu_class_init(ObjectClass *c, const void *data) cc->gdb_core_xml_file ="hexagon-core.xml" ; cc->disas_set_info = hexagon_cpu_disas_set_info;#ifndef CONFIG_USER_ONLY + cc->sysemu_ops = &hexagon_sysemu_ops; dc->vmsd = &vmstate_hexagon_cpu;#endif +#ifdef CONFIG_TCG cc->tcg_ops = &hexagon_tcg_ops; +#endif }#define DEFINE_CPU (type_name, initfn) \
Signature · 1 line
2.34.1
PATCH v4 17/28 target/hexagon: extend hexagon_cpu_mmu_index() for sysemu
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/cpu_helper.h | 8 ++++++++ target/hexagon/cpu.c | 24 ++++++++++++++++++++++++ 2 files changed, 32 insertions(+)
target/hexagon/cpu_helper.h +8 -0
@@ -8,6 +8,14 @@#define HEXAGON_CPU_HELPER_H uint32_t hexagon_get_pmu_counter (CPUHexagonState *cur_env,int index); +void hexagon_modify_ssr (CPUHexagonState *env,uint32_t new,uint32_t old); +int get_cpu_mode (CPUHexagonState *env); +int get_exe_mode (CPUHexagonState *env); +void clear_wait_mode (CPUHexagonState *env); +void hexagon_ssr_set_cause (CPUHexagonState *env,uint32_t cause); +void hexagon_start_threads (CPUHexagonState *env,uint32_t mask); +void hexagon_stop_thread (CPUHexagonState *env); +void hexagon_resume_threads (CPUHexagonState *env,uint32_t mask);uint64_t hexagon_get_sys_pcycle_count (CPUHexagonState *env);uint32_t hexagon_get_sys_pcycle_count_high (CPUHexagonState *env);uint32_t hexagon_get_sys_pcycle_count_low (CPUHexagonState *env);
target/hexagon/cpu.c +24 -0
@@ -442,6 +442,30 @@ static void hexagon_cpu_realize(DeviceState *dev, Error **errp)static int hexagon_cpu_mmu_index (CPUState *cs,bool ifetch) { +#ifndef CONFIG_USER_ONLY +CPUHexagonState *env =cpu_env (cs); +HexagonCPU *cpu =HEXAGON_CPU (cs); +int cpu_mode; + +BQL_LOCK_GUARD (); +if (cpu->globalregs) { +uint32_t syscfg = +hexagon_globalreg_read (cpu->globalregs,HEX_SREG_SYSCFG , + env->threadId); +uint8_t mmuen =GET_SYSCFG_FIELD (SYSCFG_MMUEN , syscfg); +if (!mmuen) { +return MMU_KERNEL_IDX ; + } + } + + cpu_mode =get_cpu_mode (env); +if (cpu_mode ==HEX_CPU_MODE_MONITOR ) { +return MMU_KERNEL_IDX ; + }else if (cpu_mode ==HEX_CPU_MODE_GUEST ) { +return MMU_GUEST_IDX ; + } +#endif +return MMU_USER_IDX ; }
Signature · 1 line
2.34.1
PATCH v4 18/28 target/hexagon: Decode trap1, rte as COF
In reply to Brian CainFrom: Brian Cain <[email protected]>
Also: handle rte instructions at the end of the packet.
--- target/hexagon/decode.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
target/hexagon/decode.c +14 -0
@@ -185,6 +185,8 @@ static bool decode_opcode_can_jump(int opcode)if ((GET_ATTRIB (opcode,A_JUMP )) || (GET_ATTRIB (opcode,A_CALL )) || (opcode == J2_trap0) || + (opcode == J2_trap1) || + (opcode == J2_rte) || (opcode == J2_pause)) {/* Exception to A_JUMP attribute */ if (opcode == J4_hintjumpr) {
@@ -363,6 +365,18 @@ static void decode_shuffle_for_execution(Packet *packet)break ; } } +/* +* And at the very very very end, move any RTE's, since they update +* user/supervisor mode. +*/ +#if !defined(CONFIG_USER_ONLY ) +for (i =0 ; i < last_insn; i++) { +if (packet->insn[i].opcode == J2_rte) { +decode_send_insn_to (packet, i, last_insn); +break ; + } + } +#endif } static void
Signature · 1 line
2.34.1
PATCH v4 19/28 target/hexagon: Implement modify_ssr, resched, pending_interrupt
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/helper.h | 3 +++ target/hexagon/op_helper.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+)
target/hexagon/helper.h +3 -0
@@ -129,4 +129,7 @@ DEF_HELPER_1(stop, void, env) DEF_HELPER_2(wait, void, env, i32) DEF_HELPER_2(resume, void, env, i32) DEF_HELPER_2(nmi, void, env, i32) +DEF_HELPER_1(resched, void, env) +DEF_HELPER_3(modify_ssr, void, env, i32, i32) +DEF_HELPER_1(pending_interrupt, void, env)#endif
target/hexagon/op_helper.c +20 -0
@@ -1226,6 +1226,15 @@ float64 HELPER(dfmpyhh)(CPUHexagonState *env, float64 RxxV,return RxxV; } +#ifndef CONFIG_USER_ONLY +void HELPER (modify_ssr )(CPUHexagonState *env,uint32_t new,uint32_t old) +{ +BQL_LOCK_GUARD (); +hexagon_modify_ssr (env, new, old); +} +#endif + +/* Histogram instructions */ void HELPER (vhist )(CPUHexagonState *env)
@@ -1647,6 +1656,11 @@ static inline QEMU_ALWAYS_INLINE void resched(CPUHexagonState *env) } } +void HELPER (resched )(CPUHexagonState *env) +{ +resched (env); +} +void HELPER (wait )(CPUHexagonState *env,uint32_t PC ) {BQL_LOCK_GUARD ();
@@ -1783,6 +1797,12 @@ void HELPER(nmi)(CPUHexagonState *env, uint32_t thread_mask) {g_assert_not_reached (); } + +void HELPER (pending_interrupt )(CPUHexagonState *env) +{ +BQL_LOCK_GUARD (); +hex_interrupt_update (env); +}#endif
Signature · 1 line
2.34.1
PATCH v4 20/28 target/hexagon: Add pkt_ends_tb to translation
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/translate.h | 1 - target/hexagon/translate.c | 101 ++++++++++++++++++++++++++++++++++++- 2 files changed, 99 insertions(+), 3 deletions(-)
target/hexagon/translate.h +0 -1
@@ -85,7 +85,6 @@ typedef struct DisasContext {TCGv branch_taken;TCGv dczero_addr;bool pcycle_enabled; -bool pkt_ends_tb;uint32_t num_cycles; } DisasContext;
target/hexagon/translate.c +99 -2
125 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v4 21/28 target/hexagon: Add next_PC, {s,g}reg writes
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/translate.h | 2 +- target/hexagon/translate.c | 87 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 84 insertions(+), 5 deletions(-)
target/hexagon/translate.h +1 -1
@@ -45,7 +45,7 @@ typedef struct DisasContext {int greg_log_idx;int sreg_log[SREG_WRITES_MAX ];int sreg_log_idx; -TCGv_i32 t_sreg_new_value[NUM_SREGS ]; +TCGv_i32 t_sreg_new_value[HEX_SREG_GLB_START ];TCGv_i32 greg_new_value[NUM_GREGS ];#endif int preg_log[PRED_WRITES_MAX ];
target/hexagon/translate.c +83 -4
121 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v4 21/28] target/hexagon: Add next_PC, {s,g}reg writes
Quoted 144 lines · Brian Cain
From: Brian Cain <[email protected]>
Signed-off-by Brian Cain <[email protected]>--- target/hexagon/translate.h | 2 +- target/hexagon/translate.c | 87 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 84 insertions(+), 5 deletions(-)target/hexagon/translate.h +1
-1@@ -45,7 +45,7 @@ typedef struct DisasContext {int greg_log_idx;int sreg_log[SREG_WRITES_MAX ];int sreg_log_idx; -TCGv_i32 t_sreg_new_value[NUM_SREGS ]; +TCGv_i32 t_sreg_new_value[HEX_SREG_GLB_START ];TCGv_i32 greg_new_value[NUM_GREGS ];#endif int preg_log[PRED_WRITES_MAX ];target/hexagon/translate.c +83
-0@@ -552,6 +552,10 @@ static void gen_start_packet(DisasContext *ctx) ctx->reg_log_idx =0 ;bitmap_zero (ctx->regs_written,TOTAL_PER_THREAD_REGS );bitmap_zero (ctx->predicated_regs,TOTAL_PER_THREAD_REGS ); +#ifndef CONFIG_USER_ONLY + ctx->greg_log_idx =0 ; + ctx->sreg_log_idx =0 ; +#endif ctx->preg_log_idx =0 ;bitmap_zero (ctx->pregs_written,NUM_PREGS ); ctx->future_vregs_idx =0 ;@@ -584,6 +588,24 @@ static void gen_start_packet(DisasContext *ctx)* gen phase, so clear it again. */ bitmap_zero (ctx->pregs_written,NUM_PREGS ); +#ifndef CONFIG_USER_ONLY +for (i =0 ; i <HEX_SREG_GLB_START ; i++) { + ctx->t_sreg_new_value[i] =NULL ; + } +for (i =0 ; i < ctx->sreg_log_idx; i++) { +int reg_num = ctx->sreg_log[i]; +if (reg_num <HEX_SREG_GLB_START ) { + ctx->t_sreg_new_value[reg_num] =tcg_temp_new (); + } + } +for (i =0 ; i <NUM_GREGS ; i++) { + ctx->greg_new_value[i] =NULL ; + } +for (i =0 ; i < ctx->greg_log_idx; i++) { +int reg_num = ctx->greg_log[i]; + ctx->greg_new_value[reg_num] =tcg_temp_new (); + } +#endif /* Initialize the runtime state for packet semantics */ if (need_slot_cancelled (pkt)) {@@ -743,6 +765,61 @@ static void gen_reg_writes(DisasContext *ctx) } } +#ifndef CONFIG_USER_ONLY +static void gen_greg_writes (DisasContext *ctx) +{ +int i; + +for (i =0 ; i < ctx->greg_log_idx; i++) { +int reg_num = ctx->greg_log[i]; + +tcg_gen_mov_tl (hex_greg[reg_num], ctx->greg_new_value[reg_num]); + } +} + + +static void gen_sreg_writes (DisasContext *ctx) +{ +int i; + +TCGv_i32 old_reg =tcg_temp_new_i32 (); +for (i =0 ; i < ctx->sreg_log_idx; i++) { +int reg_num = ctx->sreg_log[i]; + +if (reg_num ==HEX_SREG_SSR ) { +tcg_gen_mov_tl (old_reg, hex_t_sreg[reg_num]); +tcg_gen_mov_tl (hex_t_sreg[reg_num], ctx->t_sreg_new_value[reg_num]); +gen_helper_modify_ssr (tcg_env, ctx->t_sreg_new_value[reg_num], + old_reg); +/* This can change processor state, so end the TB */ + ctx->base.is_jmp =DISAS_NORETURN ; +continue ; + }else if ((reg_num ==HEX_SREG_STID ) || + (reg_num ==HEX_SREG_IMASK ) || + (reg_num ==HEX_SREG_IPENDAD )) { +if (reg_num <HEX_SREG_GLB_START ) { +tcg_gen_mov_tl (old_reg, hex_t_sreg[reg_num]); +tcg_gen_mov_tl (hex_t_sreg[reg_num], + ctx->t_sreg_new_value[reg_num]); + } +/* This can change the interrupt state, so end the TB */ +gen_helper_pending_interrupt (tcg_env); + ctx->base.is_jmp =DISAS_NORETURN ; +continue ; + }else if ((reg_num ==HEX_SREG_BESTWAIT ) || + (reg_num ==HEX_SREG_SCHEDCFG )) { +/* This can trigger resched interrupt, so end the TB */ +gen_helper_resched (tcg_env); + ctx->base.is_jmp =DISAS_NORETURN ; + } + +if (reg_num <HEX_SREG_GLB_START ) { +tcg_gen_mov_tl (hex_t_sreg[reg_num], ctx->t_sreg_new_value[reg_num]); + } + } +} +#endif +static void gen_pred_writes (DisasContext *ctx) {/* Early exit if not needed or the log is empty */ @@ -1044,6 +1121,10 @@ static void gen_commit_packet(DisasContext *ctx)process_store_log (ctx);gen_reg_writes (ctx); +#if !defined(CONFIG_USER_ONLY ) +gen_greg_writes (ctx); +gen_sreg_writes (ctx); +#endif gen_pred_writes (ctx);if (pkt->pkt_has_hvx) {gen_commit_hvx (ctx);@@ -1256,6 +1337,8 @@ void hexagon_translate_init(void) hex_llsc_val_i64 =tcg_global_mem_new_i64 (tcg_env, offsetof(CPUHexagonState , llsc_val_i64),"llsc_val_i64" );#ifndef CONFIG_USER_ONLY + hex_cause_code =tcg_global_mem_new_i32 (tcg_env, + offsetof(CPUHexagonState , cause_code),"cause_code" ); hex_cycle_count =tcg_global_mem_new_i64 (tcg_env, offsetof(CPUHexagonState , t_cycle_count),"t_cycle_count" );#endif
target/hexagon/translate.c void hexagon_translate_init(void) · line 1382
Quoted 8 lines
target/hexagon/translate.c +0
-4@@ -1296,8 +1379,4 @@ void hexagon_translate_init(void) offsetof(CPUHexagonState, vstore_pending[i]), vstore_pending_names[i]); } -#ifndef CONFIG_USER_ONLY - hex_cause_code =tcg_global_mem_new (tcg_env, - offsetof(CPUHexagonState , cause_code),"cause_code" ); -#endif }
Use tcg_gen_mov_i32 instead of tcg_gen_mov_tl?
PATCH v4 22/28 target/hexagon: Add implicit sysreg writes
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/translate.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
target/hexagon/translate.c +16 -0
@@ -428,6 +428,16 @@ static void mark_implicit_usr_write(DisasContext *ctx, int attrib) } } +#ifndef CONFIG_USER_ONLY +static void mark_implicit_sreg_write (DisasContext *ctx,int attrib,int snum) +{ +uint16_t opcode = ctx->insn->opcode; +if (GET_ATTRIB (opcode, attrib)) { +ctx_log_sreg_write (ctx, snum); + } +} +#endif +static void mark_implicit_reg_writes (DisasContext *ctx) {mark_implicit_reg_write (ctx,A_IMPLICIT_WRITES_FP ,HEX_REG_FP );
@@ -440,6 +450,12 @@ static void mark_implicit_reg_writes(DisasContext *ctx)mark_implicit_usr_write (ctx,A_IMPLICIT_WRITES_USR );mark_implicit_usr_write (ctx,A_FPOP ); + +#ifndef CONFIG_USER_ONLY +mark_implicit_sreg_write (ctx,A_IMPLICIT_WRITES_SGP0 ,HEX_SREG_SGP0 ); +mark_implicit_sreg_write (ctx,A_IMPLICIT_WRITES_SGP1 ,HEX_SREG_SGP1 ); +mark_implicit_sreg_write (ctx,A_IMPLICIT_WRITES_SSR ,HEX_SREG_SSR ); +#endif }static void mark_implicit_pred_write (DisasContext *ctx,int attrib,int pnum)
Signature · 1 line
2.34.1
PATCH v4 23/28 target/hexagon: Define system, guest reg names
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/internal.h | 4 ++++ target/hexagon/cpu.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+)
target/hexagon/internal.h +4 -0
@@ -30,6 +30,10 @@ void hexagon_debug_qreg(CPUHexagonState *env, int regnum);void hexagon_debug (CPUHexagonState *env);extern const char *const hexagon_regnames[TOTAL_PER_THREAD_REGS ]; +#ifndef CONFIG_USER_ONLY +extern const char *const hexagon_sregnames[]; +extern const char *const hexagon_gregnames[]; +#endif void G_NORETURN do_raise_exception(CPUHexagonState *env, uint32_t exception,
target/hexagon/cpu.c +29 -0
@@ -90,6 +90,35 @@ const char * const hexagon_regnames[TOTAL_PER_THREAD_REGS] = { "c24", "c25", "c26", "c27", "c28", "c29", "c30", "c31", }; +#ifndef CONFIG_USER_ONLY +const char *const hexagon_sregnames[] = { +"sgp0" ,"sgp1" ,"stid" ,"elr" ,"badva0" , +"badva1" ,"ssr" ,"ccr" ,"htid" ,"badva" , +"imask" ,"gevb" ,"vwctrl" ,"s13" ,"s14" , +"s15" ,"evb" ,"modectl" ,"syscfg" ,"segment" , +"ipendad" ,"vid" ,"vid1" ,"bestwait" ,"s24" , +"schedcfg" ,"s26" ,"cfgbase" ,"diag" ,"rev" , +"pcyclelo" ,"pcyclehi" ,"isdbst" ,"isdbcfg0" ,"isdbcfg1" , +"livelock" ,"brkptpc0" ,"brkptcfg0" ,"brkptpc1" ,"brkptcfg1" , +"isdbmbxin" ,"isdbmbxout" ,"isdben" ,"isdbgpr" ,"pmucnt4" , +"pmucnt5" ,"pmucnt6" ,"pmucnt7" ,"pmucnt0" ,"pmucnt1" , +"pmucnt2" ,"pmucnt3" ,"pmuevtcfg" ,"pmustid0" ,"pmuevtcfg1" , +"pmustid1" ,"timerlo" ,"timerhi" ,"pmucfg" ,"s59" , +"s60" ,"s61" ,"s62" ,"s63" , +}; + +G_STATIC_ASSERT (NUM_SREGS ==ARRAY_SIZE (hexagon_sregnames)); + +const char *const hexagon_gregnames[] = { +"gelr" ,"gsr" ,"gosp" ,"gbadva" ,"gcommit1t" , +"gcommit2t" ,"gcommit3t" ,"gcommit4t" ,"gcommit5t" ,"gcommit6t" , +"gpcycle1t" ,"gpcycle2t" ,"gpcycle3t" ,"gpcycle4t" ,"gpcycle5t" , +"gpcycle6t" ,"gpmucnt4" ,"gpmucnt5" ,"gpmucnt6" ,"gpmucnt7" , +"gcommit7t" ,"gcommit8t" ,"gpcycle7t" ,"gpcycle8t" ,"gpcyclelo" , +"gpcyclehi" ,"gpmucnt0" ,"gpmucnt1" ,"gpmucnt2" ,"gpmucnt3" , +"g30" ,"g31" , +}; +#endif /* * One of the main debugging techniques is to use "-d cpu" and compare against * LLDB output when single stepping. However, the target and qemu put the
Signature · 1 line
2.34.1
PATCH v4 24/28 target/hexagon: Add k0 {un,}lock
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/sys_macros.h | 3 + target/hexagon/op_helper.c | 119 ++++++++++++++++++++++++++++++++++++ 2 files changed, 122 insertions(+)
target/hexagon/sys_macros.h +3 -0
@@ -146,6 +146,9 @@#define fSET_TLB_LOCK () hex_tlb_lock(env);#define fCLEAR_TLB_LOCK () hex_tlb_unlock(env); +#define fSET_K0_LOCK () hex_k0_lock(env); +#define fCLEAR_K0_LOCK () hex_k0_unlock(env); +#define fTLB_IDXMASK (INDEX ) \ ((INDEX) & (fPOW2_ROUNDUP( \ fCAST4u(hexagon_tlb_get_num_entries(env_archcpu(env)->tlb))) - 1))
target/hexagon/op_helper.c +119 -0
131 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v4 25/28 target/hexagon: Add PC to raise_exception, use fTRAP() helper
In reply to Brian CainFrom: Brian Cain <[email protected]>
Add PC to raise_exception helper
Replace the fGEN_TCG_J2_trap0 macro override with the fTRAP()-generated system helper instead.
--- target/hexagon/gen_tcg.h | 7 ------- target/hexagon/helper.h | 2 +- target/hexagon/op_helper.c | 10 ++++------ target/hexagon/translate.c | 21 ++++++++++++++++----- 4 files changed, 21 insertions(+), 19 deletions(-)
target/hexagon/gen_tcg.h +0 -7
@@ -1349,13 +1349,6 @@#define fGEN_TCG_S2_storew_rl_st_vi (SHORTCODE ) SHORTCODE#define fGEN_TCG_S4_stored_rl_st_vi (SHORTCODE ) SHORTCODE -#define fGEN_TCG_J2_trap0 (SHORTCODE ) \ - do { \ - uiV = uiV; \ - tcg_gen_movi_tl(hex_gpr[HEX_REG_PC], ctx->pkt->pc); \ - TCGv excp = tcg_constant_tl(HEX_EVENT_TRAP0); \ - gen_helper_raise_exception(tcg_env, excp); \ - } while (0)#endif #define fGEN_TCG_A2_nop (SHORTCODE ) do { } while (0)
target/hexagon/helper.h +1 -1
@@ -18,7 +18,7 @@#include "internal.h" #include "helper_protos_generated.h.inc" -DEF_HELPER_FLAGS_2(raise_exception, TCG_CALL_NO_RETURN, noreturn, env, i32) +DEF_HELPER_FLAGS_3(raise_exception, TCG_CALL_NO_RETURN, noreturn, env, i32, i32) DEF_HELPER_2(commit_store, void, env, int) DEF_HELPER_3(gather_store, void, env, i32, int)DEF_HELPER_1 (commit_hvx_stores, void, env)
target/hexagon/op_helper.c +4 -6
@@ -65,15 +65,13 @@ G_NORETURN void hexagon_raise_exception_err(CPUHexagonState *env,uint32_t exception, uintptr_t pc) { -CPUState *cs =env_cpu (env); -qemu_log_mask (CPU_LOG_INT ,"%s: %d\n" , __func__, exception); - cs->exception_index = exception; -cpu_loop_exit_restore (cs, pc); + do_raise_exception(env, exception, pc, 0); } -G_NORETURN void HELPER(raise_exception)(CPUHexagonState *env, uint32_t excp) +G_NORETURN void HELPER(raise_exception)(CPUHexagonState *env, uint32_t excp, +uint32_t PC ) { -hexagon_raise_exception_err (env, excp,0 ); +hexagon_raise_exception_err (env, excp,PC ); } void log_store32(CPUHexagonState *env, target_ulong addr,
target/hexagon/translate.c +16 -5
@@ -126,12 +126,19 @@ intptr_t ctx_tmp_vreg_off(DisasContext *ctx, int regnum,return offset; } -static void gen_exception_raw (int excp) +static void gen_exception (int excp,uint32_t PC ) { -gen_helper_raise_exception (tcg_env,tcg_constant_i32 (excp)); +gen_helper_raise_exception (tcg_env,tcg_constant_i32 (excp), +tcg_constant_i32 (PC )); }#ifndef CONFIG_USER_ONLY +static inline void gen_precise_exception (int excp,uint32_t PC ) +{ +tcg_gen_movi_i32 (hex_cause_code, excp); +gen_exception (HEX_EVENT_PRECISE ,PC ); +} +static void gen_pcycle_counters (DisasContext *ctx) {if (ctx->pcycle_enabled) {
@@ -140,6 +147,7 @@ static void gen_pcycle_counters(DisasContext *ctx) }#endif +static void gen_exec_counters (DisasContext *ctx) { tcg_gen_addi_tl(hex_gpr[HEX_REG_QEMU_PKT_CNT],
@@ -213,8 +221,11 @@ static void gen_end_tb(DisasContext *ctx)void hex_gen_exception_end_tb (DisasContext *ctx,int excp) {gen_exec_counters (ctx); -tcg_gen_movi_tl (hex_gpr[HEX_REG_PC ], ctx->next_PC); -gen_exception_raw (excp); +#ifdef CONFIG_USER_ONLY +gen_exception (excp, ctx->pkt->pc); +#else +gen_precise_exception (excp, ctx->pkt->pc); +#endif ctx->base.is_jmp =DISAS_NORETURN ; }
@@ -228,7 +239,7 @@ static void gen_exception_decode_fail(DisasContext *ctx, int nwords, int excp)gen_exec_counters (ctx);tcg_gen_movi_tl (hex_gpr[HEX_REG_PC ], fail_pc); -gen_exception_raw (excp); +gen_exception (excp, fail_pc); ctx->base.is_jmp =DISAS_NORETURN ; ctx->base.pc_next = fail_pc; }
Signature · 1 line
2.34.1
PATCH v4 26/28 target/hexagon: Add TCG overrides for transfer insts
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/gen_tcg_sys.h | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
target/hexagon/gen_tcg_sys.h +25 -0
@@ -80,6 +80,31 @@gen_helper_stop (tcg_env); \ } while (0) +#define fGEN_TCG_Y2_tfrscrr (SHORTCODE ) \ + tcg_gen_mov_tl(RdV, SsV) + +#define fGEN_TCG_Y2_tfrsrcr (SHORTCODE ) \ + tcg_gen_mov_tl(SdV, RsV) + +#define fGEN_TCG_Y4_tfrscpp (SHORTCODE ) \ + tcg_gen_mov_i64(RddV, SssV) + +#define fGEN_TCG_Y4_tfrspcp (SHORTCODE ) \ + tcg_gen_mov_i64(SddV, RssV) + +#define fGEN_TCG_G4_tfrgcrr (SHORTCODE ) \ + tcg_gen_mov_tl(RdV, GsV) + +#define fGEN_TCG_G4_tfrgrcr (SHORTCODE ) \ + tcg_gen_mov_tl(GdV, RsV) + +#define fGEN_TCG_G4_tfrgcpp (SHORTCODE ) \ + tcg_gen_mov_i64(RddV, GssV) + +#define fGEN_TCG_G4_tfrgpcp (SHORTCODE ) \ + tcg_gen_mov_i64(GddV, RssV) + +/* * rte (return from exception) * Clear the EX bit in SSR
Signature · 1 line
2.34.1
PATCH v4 27/28 target/hexagon: Add support for loadw_phys
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/hex_common.py | 3 +++ target/hexagon/imported/encode_pp.def | 1 + target/hexagon/imported/ldst.idef | 3 +++ 3 files changed, 7 insertions(+)
target/hexagon/hex_common.py +3 -0
@@ -264,6 +264,9 @@ def need_slot(tag): and "A_CVI_GATHER" not in attribdict[tag] and ("A_STORE" in attribdict[tag] or "A_LOAD" in attribdict[tag]) + and tag != "L4_loadw_phys" + and tag != "L6_memcpy" + and tag != "Y6_dmlink" ): return 1 else:
target/hexagon/imported/encode_pp.def +1 -0
@@ -384,6 +384,7 @@ DEF_ENC32(L4_return_fnew_pnt, ICLASS_LD" 011 0 000 sssss PP1010vv ---ddddd") /** Load Acquire Store Release Encoding **/ +DEF_ENC32(L4_loadw_phys, ICLASS_LD" 001 0 000 sssss PP1ttttt -00ddddd") DEF_ENC32(L2_loadw_locked, ICLASS_LD" 001 0 000 sssss PP000--- 000ddddd") DEF_ENC32(L4_loadd_locked, ICLASS_LD" 001 0 000 sssss PP010--- 000ddddd")
target/hexagon/imported/ldst.idef +3 -0
@@ -203,6 +203,9 @@ Q6INSN(S2_storew_locked,"memw_locked(Rs32,Pd4)=Rt32", ATTRIBS(A_REGWRSIZE_4B,A_M Q6INSN(L4_loadd_locked,"Rdd32=memd_locked(Rs32)", ATTRIBS(A_REGWRSIZE_8B,A_MEMSIZE_8B,A_LOAD,A_RESTRICT_SLOT0ONLY,A_RESTRICT_PACKET_AXOK,A_NOTE_AXOK), "Load double with lock", { fEA_REG(RsV); fLOAD_LOCKED(1,8,u,EA,RddV) }) +Q6INSN(L4_loadw_phys,"Rd32=memw_phys(Rs32,Rt32)", ATTRIBS(A_REGWRSIZE_4B,A_PRIV,A_RESTRICT_SLOT0ONLY,A_NOTE_PRIV,A_MEMSIZE_4B,A_LOAD,A_NOTE_NOPACKET,A_RESTRICT_NOPACKET), "Load word from physical address", +{ fLOAD_PHYS(1,4,u,RsV,RtV,RdV); }) + Q6INSN(S4_stored_locked,"memd_locked(Rs32,Pd4)=Rtt32", ATTRIBS(A_REGWRSIZE_8B,A_MEMSIZE_8B,A_STORE,A_RESTRICT_SLOT0ONLY,A_RESTRICT_PACKET_AXOK,A_NOTE_AXOK,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED), "Store word with lock", { fEA_REG(RsV); fSTORE_LOCKED(1,8,EA,RttV,PdV) })
Signature · 1 line
2.34.1
PATCH v4 28/28 target/hexagon: Add guest reg reading functionality
In reply to Brian CainFrom: Matheus Tavares Bernardino <[email protected]>
--- target/hexagon/cpu.h | 1 + target/hexagon/cpu.c | 19 +++++++++++++++++++ target/hexagon/op_helper.c | 16 ++++++++++++++-- 3 files changed, 34 insertions(+), 2 deletions(-)
target/hexagon/cpu.h +1 -0
@@ -219,6 +219,7 @@ G_NORETURN void hexagon_raise_exception_err(CPUHexagonState *env,* not stopped. */ bool hexagon_thread_is_enabled (CPUHexagonState *thread_env); +uint32_t hexagon_greg_read (CPUHexagonState *env,uint32_t reg);void hexagon_cpu_soft_reset (CPUHexagonState *env);#endif
target/hexagon/cpu.c +19 -0
@@ -765,6 +765,25 @@ static void hexagon_cpu_class_init(ObjectClass *c, const void *data)#endif } +#ifndef CONFIG_USER_ONLY +uint32_t hexagon_greg_read (CPUHexagonState *env,uint32_t reg) +{ +if (reg <=HEX_GREG_G3 ) { +return env->greg[reg]; + } +switch (reg) { +case HEX_GREG_GPCYCLELO : +return hexagon_get_sys_pcycle_count_low (env); +case HEX_GREG_GPCYCLEHI : +return hexagon_get_sys_pcycle_count_high (env); +default : +qemu_log_mask (LOG_UNIMP ,"reading greg %" PRId32 +" not yet supported.\n" , reg); +return 0 ; + } +} +#endif +#define DEFINE_CPU (type_name, initfn) \ { \ .name = type_name, \
target/hexagon/op_helper.c +14 -2
@@ -1877,13 +1877,25 @@ uint64_t HELPER(sreg_read_pair)(CPUHexagonState *env, uint32_t reg) }uint32_t HELPER (greg_read )(CPUHexagonState *env,uint32_t reg) + { -g_assert_not_reached (); +return hexagon_greg_read (env, reg); }uint64_t HELPER (greg_read_pair )(CPUHexagonState *env,uint32_t reg) + { -g_assert_not_reached (); +if (reg ==HEX_GREG_G0 || reg ==HEX_GREG_G2 ) { +return (uint64_t )(env->greg[reg]) | + (((uint64_t )(env->greg[reg +1 ])) <<32 ); + } +switch (reg) { +case HEX_GREG_GPCYCLELO : +return hexagon_get_sys_pcycle_count (env); +default : +return (uint64_t )hexagon_greg_read (env, reg) | + ((uint64_t )(hexagon_greg_read (env, reg +1 )) <<32 ); + } }/*
Signature · 1 line
2.34.1