Hexagon system emulation - Part 2/3
v6 cover Hexagon system emulation - Part 2/3
This is Part 2 of the hexagon system emulation (sysemu) patch series, building on the infrastructure from Part 1 to implement the runtime helpers and CPU operations needed for full-system emulation.
This part adds:
- Helper implementations for system instructions: swi, cswi, iassign, start/stop, wait/resume, setprio, resched
- SSR (System Status Register) modification and exe mode support
- TLB operations: tlb_fill, tlb_entry_get_perm
- Interrupt handling: exec_interrupt, set_irq, software interrupt
- Stack overflow exception (fFRAMECHECK / FRAMELIMIT check)
- CPU execution support: cpu_exec_reset, pointer_wrap, sysemu_ops
- Translation support: pkt_ends_tb, implicit sysreg writes, next_PC
- System/guest register name definitions
- TCG overrides for transfer and load_phys instructions
- Guest register reading functionality
Changes since v5:
- Rebased onto Part 1 v8 (no functional changes in Part 2)
Previous versions:
v5: https://lore.kernel.org/qemu-devel/[email protected]/
v4: https://lore.kernel.org/qemu-devel/[email protected]/
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 | 27 +- target/hexagon/helper.h | 3 +- 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 | 456 ++++++++++++++++++++++++++-- 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, 1413 insertions(+), 56 deletions(-)
--
2.34.1
PATCH v6 1/1 target/hexagon: Implement {g,s}etimask helpers
From: 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 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
PATCH v6 1/1 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 v6 1/1 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
PATCH v6 1/1 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
PATCH v6 1/1 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 v6 1/1 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
PATCH v6 1/1 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,#ifndef 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 v6 1/1 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
@@ -220,6 +220,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
PATCH v6 1/1 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 v6 1/1 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 v6 1/1 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
@@ -213,6 +213,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
PATCH v6 1/1 target/hexagon: Implement {c,}swi helpers
In reply to Brian CainFrom: 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 v6 1/1 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 v6 1/1 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 ; } +#ifndef 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) { +#ifndef 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, +#ifndef 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 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 v6 1/1 target/hexagon: Implement modify_ssr, resched, pending_interrupt
In reply to Brian CainFrom: Brian Cain <[email protected]>
--- target/hexagon/op_helper.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
target/hexagon/op_helper.c +14 -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 ();
Signature · 1 line
2.34.1
PATCH v6 1/1 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
@@ -52,6 +52,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 v6 1/1 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
Quoted 3 lines · Brian Cain
This is Part 2 of the hexagon system emulation (sysemu) patch series, building on the infrastructure from Part 1 to implement the runtime helpers and CPU operations needed for full-system emulation.
For some reason this series is missing ordering, but is fully reviewed AFAICT, so good to go?
Quoted 8 lines · Philippe Mathieu-Daudé
Quoted 3 lines · Brian Cain
This is Part 2 of the hexagon system emulation (sysemu) patch series, building on the infrastructure from Part 1 to implement the runtime helpers and CPU operations needed for full-system emulation.
For some reason this series is missing ordering, but is fully reviewed AFAICT, so good to go?
Yeah - sorry about that - I'll fix the ordering next time.
Yes, fully reviewed: just wanted to share the entire series w/rework in context.
Only part 1 has unreviewed patches.
Quoted 9 lines · Brian Cain
Quoted 6 lines · Philippe Mathieu-Daudé
Quoted 3 lines · Brian Cain
This is Part 2 of the hexagon system emulation (sysemu) patch series, building on the infrastructure from Part 1 to implement the runtime helpers and CPU operations needed for full-system emulation.
Quoted 9 lines
Quoted 2 lines
For some reason this series is missing ordering, but is fully reviewed AFAICT, so good to go?
Yeah - sorry about that - I'll fix the ordering next time.
Yes, fully reviewed: just wanted to share the entire series w/rework in context.
Only part 1 has unreviewed patches.
Hi Brian,
May I suggest using b4: it allows you to define series dependencies, so you can keep the series parts that you don't want to change as dependencies and respin only the other ones.
Signature · 2 lines
Manos Pitsidianakis Emulation and Virtualization Engineer at Linaro Ltd
Quoted 18 lines · Manos Pitsidianakis
Quoted 16 lines · Brian Cain
Quoted 8 lines · Philippe Mathieu-Daudé
Quoted 3 lines · Brian Cain
This is Part 2 of the hexagon system emulation (sysemu) patch series, building on the infrastructure from Part 1 to implement the runtime helpers and CPU operations needed for full-system emulation.
For some reason this series is missing ordering, but is fully reviewed AFAICT, so good to go?
Yeah - sorry about that - I'll fix the ordering next time.
Yes, fully reviewed: just wanted to share the entire series w/rework in context.
Quoted 8 lines
Quoted 2 lines
Only part 1 has unreviewed patches.
Hi Brian,
May I suggest using b4: it allows you to define series dependencies, so you can keep the series parts that you don't want to change as dependencies and respin only the other ones.
Yeah - that's a good suggestion, thanks. I've used it for picking commits and trailers but not 'b4 send' yet. I'll take a look.