Hexagon system emulation, Part 2/3
v5 cover Hexagon system emulation, Part 2/3
Hexagon sysemu part 2: runtime helpers -- interrupt delivery, TLB fill, thread scheduling, MMU index, translation changes (pkt_ends_tb, sreg/greg writes, COF decode), and physical memory access.
Changes in v5:
- ctx->pkt-> changed to ctx->pkt. throughout (upstream embedded the Packet struct).
- need_commit optimization in gen_sreg_writes(): skip t_sreg_new_value allocation when !need_commit && reg != SSR.
- Renamed "Add TLB, k0 {un,}lock" -> "Add k0 {un,}lock" (TLB setup is in Part 1 now).
- get_phys_page_debug -> get_phys_addr_debug (upstream rename).
- Format string fixes (%d/%x -> PRId32/PRIx32, uint32_t casts).
- Dropped Qualcomm manual citations from commit messages.
- Rebased onto current staging (cpu-interrupt.h, cpu.c class init context changes).
Patches still needing review:
- 03/28: target/hexagon: Implement start/stop helpers, soft reset
- 08/28: target/hexagon: Implement software interrupt
- 15/28: target/hexagon: Implement setprio, resched
- 21/28: target/hexagon: Add next_PC, {s,g}reg writes
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 | 27 +- 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/hex_mmu.c | 4 +- target/hexagon/hexswi.c | 270 ++++++++++++ target/hexagon/idef-parser/parser-helpers.c | 9 + target/hexagon/op_helper.c | 462 +++++++++++++++++++- target/hexagon/translate.c | 216 ++++++++- 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 + 25 files changed, 1422 insertions(+), 56 deletions(-) create mode 100644 target/hexagon/hexswi.h create mode 100644 target/hexagon/hexswi.c
Signature · 1 line
2.34.1
PATCH v5 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 v5 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 v5 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
@@ -215,6 +215,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 ObjectClass *hexagon_cpu_class_by_name (const char *cpu_model)
@@ -310,6 +311,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);
@@ -339,9 +362,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 v5 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 v5 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 v5 5/28 target/hexagon: Implement wait helper
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/gen_tcg_sys.h | 2 +- target/hexagon/op_helper.c | 60 ++++++++++++++++++++++++++++++++++-- 2 files changed, 59 insertions(+), 3 deletions(-)
target/hexagon/gen_tcg_sys.h +1 -1
@@ -80,7 +80,7 @@#define fGEN_TCG_Y2_wait (SHORTCODE ) \ do { \ RsV = RsV; \ - gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt->pc)); \ + gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt.pc)); \ } while (0)#define fGEN_TCG_Y2_resume (SHORTCODE ) \
target/hexagon/op_helper.c +58 -2
67 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v5 05/28] target/hexagon: Implement wait helper
Hi Brian, Taylor,
(now committed as acd2b7a2f19ac04bd313e816e5f9e7f87adc9858)
Quoted 60 lines · Brian Cain
From: Brian Cain <[email protected]>
Reviewed-by Taylor Simpson <[email protected]>Signed-off-by Brian Cain <[email protected]>--- target/hexagon/gen_tcg_sys.h | 2 +- target/hexagon/op_helper.c | 60 ++++++++++++++++++++++++++++++++++-- 2 files changed, 59 insertions(+), 3 deletions(-)target/hexagon/gen_tcg_sys.h +1
-1@@ -80,7 +80,7 @@#define fGEN_TCG_Y2_wait (SHORTCODE ) \ do { \ RsV = RsV; \ - gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt->pc)); \ + gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt.pc)); \ } while (0)#define fGEN_TCG_Y2_resume (SHORTCODE ) \target/hexagon/op_helper.c +27
-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 ||
target/hexagon/op_helper.c void HELPER(stop)(CPUHexagonState *env) · line 1526
Quoted 10 lines
target/hexagon/op_helper.c +10
-0+ 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
Could you explain this comment?
Quoted 24 lines
target/hexagon/op_helper.c +21
-0+*/ +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)
Re: [PATCH v5 05/28] target/hexagon: Implement wait helper
Quoted 68 lines · Philippe Mathieu-Daudé
Hi Brian, Taylor,
(now committed as
acd2b7a2f19ac04bd313e816e5f9e7f87adc9858)Quoted 63 lines · Brian Cain
From: Brian Cain <[email protected]>
Reviewed-by Taylor Simpson <[email protected]>Signed-off-by Brian Cain <[email protected]>---
target/hexagon/gen_tcg_sys.h| 2 +- target/hexagon/op_helper.c | 60 ++++++++++++++++++++++++++++++++++--2 files changed, 59 insertions(+), 3 deletions(-)target/hexagon/gen_tcg_sys.h +1
-1@@ -80,7 +80,7 @@ #define fGEN_TCG_Y2_wait(SHORTCODE) \ do { \ RsV = RsV; \ - gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt->pc)); \ + gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt.pc)); \ } while (0) #define fGEN_TCG_Y2_resume(SHORTCODE) \target/hexagon/op_helper.c +31
-1@@ -1486,9 +1486,65 @@ void HELPER(stop)(CPUHexagonState *env) hexagon_stop_thread(env); } -void HELPER(wait)(CPUHexagonState *env, target_ulong PC) +static voidset_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"); + }
Quoted 8 lines
target/hexagon/op_helper.c void HELPER(stop)(CPUHexagonState *env) · line 1526
Quoted 6 lines
target/hexagon/op_helper.c +6
-0+ 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 Could you explain this comment?
It's a note that was added to our downstream fork when fixing a bug attributed to hexagon_wait_thread() that was a bit challenging to uncover because none of our existing regression suite detected it. It was only uncovered in a "virtual platform" environment modeling the various cores among the SoC.
We can follow up with a reword/clarification or deletion if you prefer.
Quoted 26 lines
Quoted 25 lines
target/hexagon/op_helper.c +21
-0+*/ + 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_tmask)
Re: [PATCH v5 05/28] target/hexagon: Implement wait helper
Quoted 79 lines · Brian Cain
Quoted 68 lines · Philippe Mathieu-Daudé
Hi Brian, Taylor,
(now committed as
acd2b7a2f19ac04bd313e816e5f9e7f87adc9858)Quoted 63 lines · Brian Cain
From: Brian Cain <[email protected]>
Reviewed-by Taylor Simpson <[email protected]>Signed-off-by Brian Cain <[email protected]>---
target/hexagon/gen_tcg_sys.h| 2 +- target/hexagon/op_helper.c | 60 ++++++++++++++++++++++++++++++++++--2 files changed, 59 insertions(+), 3 deletions(-)target/hexagon/gen_tcg_sys.h +1
-1@@ -80,7 +80,7 @@ #define fGEN_TCG_Y2_wait(SHORTCODE) \ do { \ RsV = RsV; \ - gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt->pc)); \ + gen_helper_wait(tcg_env, tcg_constant_tl(ctx->pkt.pc)); \ } while (0) #define fGEN_TCG_Y2_resume(SHORTCODE) \target/hexagon/op_helper.c +31
-1@@ -1486,9 +1486,65 @@ void HELPER(stop)(CPUHexagonState *env) hexagon_stop_thread(env); } -void HELPER(wait)(CPUHexagonState *env, target_ulong PC) +static voidset_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"); + }Quoted 8 lines
target/hexagon/op_helper.c void HELPER(stop)(CPUHexagonState *env) · line 1526
Quoted 6 lines
target/hexagon/op_helper.c +6
-0+ 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 Could you explain this comment?
Quoted 3 lines
It's a note that was added to our downstream fork when fixing a bug attributed to
hexagon_wait_thread()that was a bit challenging to uncover because none of our existing regression suite detected it. It was only uncovered in a "virtual platform" environment modeling the various cores among the SoC.We can follow up with a reword/clarification or deletion if you prefer.
But you recall the bug? Why isn't this an issue with RISCV?
No urgent need for cleanup, I'll likely rework this area in my generic CPU scheduling work.
Quoted 28 lines
Quoted 27 lines
Quoted 26 lines
target/hexagon/op_helper.c +21
-0+*/ + 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_tmask)
PATCH v5 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 v5 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 v5 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 | 270 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 288 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 ObjectClass *hexagon_cpu_class_by_name (const char *cpu_model)
target/hexagon/hexswi.c new file +270 -0
270 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v5 08/28] target/hexagon: Implement software interrupt
Quoted 4 lines · Brian Cain
From: Brian Cain <[email protected]>
Co-authored-by Mike Lambert <[email protected]>Signed-off-by Brian Cain <[email protected]>
Quoted 8 lines
--- target/hexagon/hexswi.h | 17 +++ target/hexagon/cpu.c | 1 + target/hexagon/hexswi.c | 270 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 288 insertions(+) create mode 100644 target/hexagon/hexswi.h create mode 100644 target/hexagon/hexswi.c
PATCH v5 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
@@ -341,4 +341,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
@@ -893,26 +893,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 v5 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 ObjectClass *hexagon_cpu_class_by_name (const char *cpu_model)
@@ -304,6 +307,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)
@@ -412,10 +445,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 ,
@@ -426,6 +507,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 v5 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
@@ -495,6 +495,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 = {
@@ -509,6 +515,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 v5 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 ObjectClass *hexagon_cpu_class_by_name (const char *cpu_model)
@@ -475,6 +477,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) {
@@ -517,6 +651,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 v5 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 v5 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
@@ -54,6 +54,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 v5 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 %u," +" cur PC 0x%" PRIx32"\n" , + __func__, (unsigned )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 - hardware-assisted scheduler helpers for managing +* the run queue and interrupt steering. +*/ 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 v5 15/28] target/hexagon: Implement setprio, resched
Quoted 32 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(+)target/hexagon/op_helper.c +14
-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);
target/hexagon/op_helper.c static void hexagon_wait_thread(CPUHexagonState *env, uint32_t PC) · line 1615
Quoted 10 lines
target/hexagon/op_helper.c +10
-0+ 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 ; + } +
Is that really a noop in this case?
Or should it trigger an exception if sched is not enabled?
Quoted 65 lines
target/hexagon/op_helper.c +53
-0+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 %u," +" cur PC 0x%" PRIx32"\n" , + __func__, (unsigned )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 - hardware-assisted scheduler helpers for managing +* the run queue and interrupt steering. +*/ 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 (); }
Re: [PATCH v5 15/28] target/hexagon: Implement setprio, resched
Quoted 39 lines · Pierrick Bouvier
Quoted 37 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(+)target/hexagon/op_helper.c +19
-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);
Quoted 8 lines
target/hexagon/op_helper.c static void hexagon_wait_thread(CPUHexagonState *env, uint32_t PC) · line 1615
Quoted 5 lines
target/hexagon/op_helper.c +5
-0+ +if (!schedcfg_en) { +return ; + } +Is that really a noop in this case?
Or should it trigger an exception if sched is not enabled?
It's a noop, the scheduler has no effect when SCHEDCFG_EN is disabled.
Quoted 66 lines
Quoted 65 lines
target/hexagon/op_helper.c +53
-0+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 %u," +" cur PC 0x%" PRIx32"\n" , + __func__, (unsigned )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 - hardware-assisted scheduler helpers for managing +* the run queue and interrupt steering. +*/ 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 (); }
Pierrick Bouvier
Reviewed-byRe: [PATCH v5 15/28] target/hexagon: Implement setprio, resched
Quoted 50 lines · Brian Cain
Quoted 39 lines · Pierrick Bouvier
Quoted 37 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(+)target/hexagon/op_helper.c +19
-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);Quoted 8 lines
target/hexagon/op_helper.c static void hexagon_wait_thread(CPUHexagonState *env, uint32_t PC) · line 1615
Quoted 5 lines
target/hexagon/op_helper.c +5
-0+ +if (!schedcfg_en) { +return ; + } +Is that really a noop in this case?
Or should it trigger an exception if sched is not enabled?
Quoted 2 lines
It's a noop, the scheduler has no effect when
SCHEDCFG_ENis disabled.
Ok.
Quoted 58 lines
Quoted 58 lines
Quoted 58 lines
target/hexagon/op_helper.c +49
-0+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 %u," +" cur PC 0x%" PRIx32"\n" , + __func__, (unsigned )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 - hardware-assisted scheduler helpers for managing +* the run queue and interrupt steering. +*/ 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);
Quoted 8 lines
Quoted 8 lines
target/hexagon/op_helper.c uint64_t HELPER(greg_read_pair)(CPUHexagonState *env, uint32_t reg) · line 1781
Quoted 7 lines
target/hexagon/op_helper.c +4
-0+resched (env); +return ; + } + }g_assert_not_reached (); }
PATCH v5 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"
@@ -503,6 +505,24 @@ static void find_qemu_subpage(vaddr *addr, hwaddr *phys, uint64_t page_size) *phys += offset; } +static hwaddr hexagon_cpu_get_phys_addr_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
@@ -610,6 +630,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_addr_debug = hexagon_cpu_get_phys_addr_debug, +}; +static bool hexagon_cpu_exec_interrupt (CPUState *cs,int interrupt_request) {CPUHexagonState *env =cpu_env (cs);
@@ -652,6 +679,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 */ };
@@ -679,9 +708,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 }static void hexagon_cpu_class_base_init (ObjectClass *c,const void *data)
Signature · 1 line
2.34.1
PATCH v5 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
@@ -446,6 +446,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 v5 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 v5 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 v5 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 | 102 ++++++++++++++++++++++++++++++++++++- 2 files changed, 100 insertions(+), 3 deletions(-)
target/hexagon/translate.h +0 -1
@@ -86,7 +86,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 +100 -2
126 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v5 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 | 77 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 74 insertions(+), 5 deletions(-)
target/hexagon/translate.h +1 -1
@@ -46,7 +46,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 +73 -4
111 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v5 21/28] target/hexagon: Add next_PC, {s,g}reg writes
Quoted 114 lines · Brian Cain
From: Brian Cain <[email protected]>
Signed-off-by Brian Cain <[email protected]>--- target/hexagon/translate.h | 2 +- target/hexagon/translate.c | 77 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 74 insertions(+), 5 deletions(-)target/hexagon/translate.h +1
-1@@ -46,7 +46,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 +67
-0@@ -545,6 +545,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 ;@@ -577,6 +581,25 @@ 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->need_commit || reg_num ==HEX_SREG_SSR )) { + 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 (&ctx->pkt)) {@@ -734,6 +757,50 @@ 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); + }else if ((reg_num ==HEX_SREG_STID ) || + (reg_num ==HEX_SREG_IMASK ) || + (reg_num ==HEX_SREG_IPENDAD )) { +if (ctx->need_commit && reg_num <HEX_SREG_GLB_START ) { +tcg_gen_mov_tl (hex_t_sreg[reg_num], + ctx->t_sreg_new_value[reg_num]); + } +gen_helper_pending_interrupt (tcg_env); + }else if ((reg_num ==HEX_SREG_BESTWAIT ) || + (reg_num ==HEX_SREG_SCHEDCFG )) { +gen_helper_resched (tcg_env); + }else if (ctx->need_commit && 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 */
target/hexagon/translate.c static void gen_commit_packet(DisasContext *ctx) · line 1100
Quoted 4 lines
target/hexagon/translate.c +1
-0@@ -1030,6 +1097,10 @@ static void gen_commit_packet(DisasContext *ctx)process_store_log (ctx);gen_reg_writes (ctx); +#if !defined(CONFIG_USER_ONLY )
ifndef
Quoted 16 lines
target/hexagon/translate.c +5
-0+gen_greg_writes (ctx); +gen_sreg_writes (ctx); +#endif gen_pred_writes (ctx);if (ctx->pkt.pkt_has_hvx) {gen_commit_hvx (ctx);@@ -1242,6 +1313,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 1358
Quoted 8 lines
target/hexagon/translate.c +0
-4@@ -1282,8 +1355,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 }
In general, we should use sized tcg op instead of rely on *_tl, but it can be cleaned up later.
PATCH v5 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
@@ -424,6 +424,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 );
@@ -436,6 +446,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 v5 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
@@ -85,6 +85,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 v5 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/hex_mmu.c | 4 +- target/hexagon/op_helper.c | 119 ++++++++++++++++++++++++++++++++++++ 3 files changed, 124 insertions(+), 2 deletions(-)
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/hex_mmu.c +2 -2
@@ -204,8 +204,8 @@ void hex_tlb_unlock(CPUHexagonState *env) (env->tlb_lock_state != HEX_LOCK_OWNER)) {qemu_log_mask (LOG_GUEST_ERROR ,"thread %" PRIu32" attempted to tlbunlock without having the " -"lock, tlb_lock state = %d\n" , - env->threadId, env->tlb_lock_state); +"lock, tlb_lock state = %u\n" , + env->threadId, (unsigned )env->tlb_lock_state);g_assert (env->tlb_lock_state !=HEX_LOCK_WAITING );return ; }
target/hexagon/op_helper.c +119 -0
131 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v5 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],
@@ -211,8 +219,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 ; }
@@ -226,7 +237,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 v5 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
@@ -95,6 +95,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 v5 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 v5 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
@@ -222,6 +222,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
@@ -769,6 +769,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 +static void hexagon_cpu_class_base_init (ObjectClass *c,const void *data) {HexagonCPUClass *mcc =HEXAGON_CPU_CLASS (c);
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