mirror of
https://github.com/qemu/qemu.git
synced 2024-11-24 11:23:43 +08:00
f502cfc207
Implement handling for the AArch64 SP_EL0 system register. This holds the EL0 stack pointer, and is only accessible when it's not being used as the stack pointer, ie when we're in EL1 and EL1 is using its own stack pointer. We also provide a definition of the SP_EL1 register; this isn't guest visible as a system register for an implementation like QEMU which doesn't provide EL2 or EL3; however it is useful for ensuring the underlying state is migrated. We need to update the state fields in the CPU state whenever we switch stack pointers; this happens when we take an exception and also when SPSEL is used to change the bit in PSTATE which indicates which stack pointer EL1 should use. Signed-off-by: Peter Maydell <peter.maydell@linaro.org> Reviewed-by: Peter Crosthwaite <peter.crosthwaite@xilinx.com>
452 lines
11 KiB
C
452 lines
11 KiB
C
/*
|
|
* ARM helper routines
|
|
*
|
|
* Copyright (c) 2005-2007 CodeSourcery, LLC
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include "cpu.h"
|
|
#include "helper.h"
|
|
#include "internals.h"
|
|
|
|
#define SIGNBIT (uint32_t)0x80000000
|
|
#define SIGNBIT64 ((uint64_t)1 << 63)
|
|
|
|
static void raise_exception(CPUARMState *env, int tt)
|
|
{
|
|
ARMCPU *cpu = arm_env_get_cpu(env);
|
|
CPUState *cs = CPU(cpu);
|
|
|
|
cs->exception_index = tt;
|
|
cpu_loop_exit(cs);
|
|
}
|
|
|
|
uint32_t HELPER(neon_tbl)(CPUARMState *env, uint32_t ireg, uint32_t def,
|
|
uint32_t rn, uint32_t maxindex)
|
|
{
|
|
uint32_t val;
|
|
uint32_t tmp;
|
|
int index;
|
|
int shift;
|
|
uint64_t *table;
|
|
table = (uint64_t *)&env->vfp.regs[rn];
|
|
val = 0;
|
|
for (shift = 0; shift < 32; shift += 8) {
|
|
index = (ireg >> shift) & 0xff;
|
|
if (index < maxindex) {
|
|
tmp = (table[index >> 3] >> ((index & 7) << 3)) & 0xff;
|
|
val |= tmp << shift;
|
|
} else {
|
|
val |= def & (0xff << shift);
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
#include "exec/softmmu_exec.h"
|
|
|
|
#define MMUSUFFIX _mmu
|
|
|
|
#define SHIFT 0
|
|
#include "exec/softmmu_template.h"
|
|
|
|
#define SHIFT 1
|
|
#include "exec/softmmu_template.h"
|
|
|
|
#define SHIFT 2
|
|
#include "exec/softmmu_template.h"
|
|
|
|
#define SHIFT 3
|
|
#include "exec/softmmu_template.h"
|
|
|
|
/* try to fill the TLB and return an exception if error. If retaddr is
|
|
* NULL, it means that the function was called in C code (i.e. not
|
|
* from generated code or from helper.c)
|
|
*/
|
|
void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
|
|
uintptr_t retaddr)
|
|
{
|
|
int ret;
|
|
|
|
ret = arm_cpu_handle_mmu_fault(cs, addr, is_write, mmu_idx);
|
|
if (unlikely(ret)) {
|
|
ARMCPU *cpu = ARM_CPU(cs);
|
|
CPUARMState *env = &cpu->env;
|
|
|
|
if (retaddr) {
|
|
/* now we have a real cpu fault */
|
|
cpu_restore_state(cs, retaddr);
|
|
}
|
|
raise_exception(env, cs->exception_index);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
uint32_t HELPER(add_setq)(CPUARMState *env, uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t res = a + b;
|
|
if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT))
|
|
env->QF = 1;
|
|
return res;
|
|
}
|
|
|
|
uint32_t HELPER(add_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t res = a + b;
|
|
if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT)) {
|
|
env->QF = 1;
|
|
res = ~(((int32_t)a >> 31) ^ SIGNBIT);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
uint32_t HELPER(sub_saturate)(CPUARMState *env, uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t res = a - b;
|
|
if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) {
|
|
env->QF = 1;
|
|
res = ~(((int32_t)a >> 31) ^ SIGNBIT);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
uint32_t HELPER(double_saturate)(CPUARMState *env, int32_t val)
|
|
{
|
|
uint32_t res;
|
|
if (val >= 0x40000000) {
|
|
res = ~SIGNBIT;
|
|
env->QF = 1;
|
|
} else if (val <= (int32_t)0xc0000000) {
|
|
res = SIGNBIT;
|
|
env->QF = 1;
|
|
} else {
|
|
res = val << 1;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
uint32_t HELPER(add_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t res = a + b;
|
|
if (res < a) {
|
|
env->QF = 1;
|
|
res = ~0;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
uint32_t HELPER(sub_usaturate)(CPUARMState *env, uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t res = a - b;
|
|
if (res > a) {
|
|
env->QF = 1;
|
|
res = 0;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* Signed saturation. */
|
|
static inline uint32_t do_ssat(CPUARMState *env, int32_t val, int shift)
|
|
{
|
|
int32_t top;
|
|
uint32_t mask;
|
|
|
|
top = val >> shift;
|
|
mask = (1u << shift) - 1;
|
|
if (top > 0) {
|
|
env->QF = 1;
|
|
return mask;
|
|
} else if (top < -1) {
|
|
env->QF = 1;
|
|
return ~mask;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
/* Unsigned saturation. */
|
|
static inline uint32_t do_usat(CPUARMState *env, int32_t val, int shift)
|
|
{
|
|
uint32_t max;
|
|
|
|
max = (1u << shift) - 1;
|
|
if (val < 0) {
|
|
env->QF = 1;
|
|
return 0;
|
|
} else if (val > max) {
|
|
env->QF = 1;
|
|
return max;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
/* Signed saturate. */
|
|
uint32_t HELPER(ssat)(CPUARMState *env, uint32_t x, uint32_t shift)
|
|
{
|
|
return do_ssat(env, x, shift);
|
|
}
|
|
|
|
/* Dual halfword signed saturate. */
|
|
uint32_t HELPER(ssat16)(CPUARMState *env, uint32_t x, uint32_t shift)
|
|
{
|
|
uint32_t res;
|
|
|
|
res = (uint16_t)do_ssat(env, (int16_t)x, shift);
|
|
res |= do_ssat(env, ((int32_t)x) >> 16, shift) << 16;
|
|
return res;
|
|
}
|
|
|
|
/* Unsigned saturate. */
|
|
uint32_t HELPER(usat)(CPUARMState *env, uint32_t x, uint32_t shift)
|
|
{
|
|
return do_usat(env, x, shift);
|
|
}
|
|
|
|
/* Dual halfword unsigned saturate. */
|
|
uint32_t HELPER(usat16)(CPUARMState *env, uint32_t x, uint32_t shift)
|
|
{
|
|
uint32_t res;
|
|
|
|
res = (uint16_t)do_usat(env, (int16_t)x, shift);
|
|
res |= do_usat(env, ((int32_t)x) >> 16, shift) << 16;
|
|
return res;
|
|
}
|
|
|
|
void HELPER(wfi)(CPUARMState *env)
|
|
{
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
|
|
|
cs->exception_index = EXCP_HLT;
|
|
cs->halted = 1;
|
|
cpu_loop_exit(cs);
|
|
}
|
|
|
|
void HELPER(wfe)(CPUARMState *env)
|
|
{
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
|
|
|
/* Don't actually halt the CPU, just yield back to top
|
|
* level loop
|
|
*/
|
|
cs->exception_index = EXCP_YIELD;
|
|
cpu_loop_exit(cs);
|
|
}
|
|
|
|
/* Raise an internal-to-QEMU exception. This is limited to only
|
|
* those EXCP values which are special cases for QEMU to interrupt
|
|
* execution and not to be used for exceptions which are passed to
|
|
* the guest (those must all have syndrome information and thus should
|
|
* use exception_with_syndrome).
|
|
*/
|
|
void HELPER(exception_internal)(CPUARMState *env, uint32_t excp)
|
|
{
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
|
|
|
assert(excp_is_internal(excp));
|
|
cs->exception_index = excp;
|
|
cpu_loop_exit(cs);
|
|
}
|
|
|
|
/* Raise an exception with the specified syndrome register value */
|
|
void HELPER(exception_with_syndrome)(CPUARMState *env, uint32_t excp,
|
|
uint32_t syndrome)
|
|
{
|
|
CPUState *cs = CPU(arm_env_get_cpu(env));
|
|
|
|
assert(!excp_is_internal(excp));
|
|
cs->exception_index = excp;
|
|
env->exception.syndrome = syndrome;
|
|
cpu_loop_exit(cs);
|
|
}
|
|
|
|
uint32_t HELPER(cpsr_read)(CPUARMState *env)
|
|
{
|
|
return cpsr_read(env) & ~CPSR_EXEC;
|
|
}
|
|
|
|
void HELPER(cpsr_write)(CPUARMState *env, uint32_t val, uint32_t mask)
|
|
{
|
|
cpsr_write(env, val, mask);
|
|
}
|
|
|
|
/* Access to user mode registers from privileged modes. */
|
|
uint32_t HELPER(get_user_reg)(CPUARMState *env, uint32_t regno)
|
|
{
|
|
uint32_t val;
|
|
|
|
if (regno == 13) {
|
|
val = env->banked_r13[0];
|
|
} else if (regno == 14) {
|
|
val = env->banked_r14[0];
|
|
} else if (regno >= 8
|
|
&& (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
|
|
val = env->usr_regs[regno - 8];
|
|
} else {
|
|
val = env->regs[regno];
|
|
}
|
|
return val;
|
|
}
|
|
|
|
void HELPER(set_user_reg)(CPUARMState *env, uint32_t regno, uint32_t val)
|
|
{
|
|
if (regno == 13) {
|
|
env->banked_r13[0] = val;
|
|
} else if (regno == 14) {
|
|
env->banked_r14[0] = val;
|
|
} else if (regno >= 8
|
|
&& (env->uncached_cpsr & 0x1f) == ARM_CPU_MODE_FIQ) {
|
|
env->usr_regs[regno - 8] = val;
|
|
} else {
|
|
env->regs[regno] = val;
|
|
}
|
|
}
|
|
|
|
void HELPER(access_check_cp_reg)(CPUARMState *env, void *rip, uint32_t syndrome)
|
|
{
|
|
const ARMCPRegInfo *ri = rip;
|
|
switch (ri->accessfn(env, ri)) {
|
|
case CP_ACCESS_OK:
|
|
return;
|
|
case CP_ACCESS_TRAP:
|
|
env->exception.syndrome = syndrome;
|
|
break;
|
|
case CP_ACCESS_TRAP_UNCATEGORIZED:
|
|
env->exception.syndrome = syn_uncategorized();
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
raise_exception(env, EXCP_UDEF);
|
|
}
|
|
|
|
void HELPER(set_cp_reg)(CPUARMState *env, void *rip, uint32_t value)
|
|
{
|
|
const ARMCPRegInfo *ri = rip;
|
|
|
|
ri->writefn(env, ri, value);
|
|
}
|
|
|
|
uint32_t HELPER(get_cp_reg)(CPUARMState *env, void *rip)
|
|
{
|
|
const ARMCPRegInfo *ri = rip;
|
|
|
|
return ri->readfn(env, ri);
|
|
}
|
|
|
|
void HELPER(set_cp_reg64)(CPUARMState *env, void *rip, uint64_t value)
|
|
{
|
|
const ARMCPRegInfo *ri = rip;
|
|
|
|
ri->writefn(env, ri, value);
|
|
}
|
|
|
|
uint64_t HELPER(get_cp_reg64)(CPUARMState *env, void *rip)
|
|
{
|
|
const ARMCPRegInfo *ri = rip;
|
|
|
|
return ri->readfn(env, ri);
|
|
}
|
|
|
|
void HELPER(msr_i_pstate)(CPUARMState *env, uint32_t op, uint32_t imm)
|
|
{
|
|
/* MSR_i to update PSTATE. This is OK from EL0 only if UMA is set.
|
|
* Note that SPSel is never OK from EL0; we rely on handle_msr_i()
|
|
* to catch that case at translate time.
|
|
*/
|
|
if (arm_current_pl(env) == 0 && !(env->cp15.c1_sys & SCTLR_UMA)) {
|
|
raise_exception(env, EXCP_UDEF);
|
|
}
|
|
|
|
switch (op) {
|
|
case 0x05: /* SPSel */
|
|
update_spsel(env, imm);
|
|
break;
|
|
case 0x1e: /* DAIFSet */
|
|
env->daif |= (imm << 6) & PSTATE_DAIF;
|
|
break;
|
|
case 0x1f: /* DAIFClear */
|
|
env->daif &= ~((imm << 6) & PSTATE_DAIF);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
}
|
|
|
|
/* ??? Flag setting arithmetic is awkward because we need to do comparisons.
|
|
The only way to do that in TCG is a conditional branch, which clobbers
|
|
all our temporaries. For now implement these as helper functions. */
|
|
|
|
/* Similarly for variable shift instructions. */
|
|
|
|
uint32_t HELPER(shl_cc)(CPUARMState *env, uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
if (shift == 32)
|
|
env->CF = x & 1;
|
|
else
|
|
env->CF = 0;
|
|
return 0;
|
|
} else if (shift != 0) {
|
|
env->CF = (x >> (32 - shift)) & 1;
|
|
return x << shift;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
uint32_t HELPER(shr_cc)(CPUARMState *env, uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
if (shift == 32)
|
|
env->CF = (x >> 31) & 1;
|
|
else
|
|
env->CF = 0;
|
|
return 0;
|
|
} else if (shift != 0) {
|
|
env->CF = (x >> (shift - 1)) & 1;
|
|
return x >> shift;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
uint32_t HELPER(sar_cc)(CPUARMState *env, uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
env->CF = (x >> 31) & 1;
|
|
return (int32_t)x >> 31;
|
|
} else if (shift != 0) {
|
|
env->CF = (x >> (shift - 1)) & 1;
|
|
return (int32_t)x >> shift;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
uint32_t HELPER(ror_cc)(CPUARMState *env, uint32_t x, uint32_t i)
|
|
{
|
|
int shift1, shift;
|
|
shift1 = i & 0xff;
|
|
shift = shift1 & 0x1f;
|
|
if (shift == 0) {
|
|
if (shift1 != 0)
|
|
env->CF = (x >> 31) & 1;
|
|
return x;
|
|
} else {
|
|
env->CF = (x >> (shift - 1)) & 1;
|
|
return ((uint32_t)x >> shift) | (x << (32 - shift));
|
|
}
|
|
}
|