Scripted conversion: sed -i "s/CPUState/CPUUniCore32State/g" target-unicore32/*.[hc] sed -i "s/#define CPUUniCore32State/#define CPUState/" target-unicore32/cpu.h Signed-off-by: Andreas Färber <afaerber@suse.de> Acked-by: Anthony Liguori <aliguori@us.ibm.com>
250 lines
5.3 KiB
C
250 lines
5.3 KiB
C
/*
|
|
* UniCore32 helper routines
|
|
*
|
|
* Copyright (C) 2010-2011 GUAN Xue-tao
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#include "cpu.h"
|
|
#include "dyngen-exec.h"
|
|
#include "helper.h"
|
|
|
|
#define SIGNBIT (uint32_t)0x80000000
|
|
#define SIGNBIT64 ((uint64_t)1 << 63)
|
|
|
|
void HELPER(exception)(uint32_t excp)
|
|
{
|
|
env->exception_index = excp;
|
|
cpu_loop_exit(env);
|
|
}
|
|
|
|
static target_ulong asr_read(void)
|
|
{
|
|
int ZF;
|
|
ZF = (env->ZF == 0);
|
|
return env->uncached_asr | (env->NF & 0x80000000) | (ZF << 30) |
|
|
(env->CF << 29) | ((env->VF & 0x80000000) >> 3);
|
|
}
|
|
|
|
target_ulong cpu_asr_read(CPUUniCore32State *env1)
|
|
{
|
|
CPUUniCore32State *saved_env;
|
|
target_ulong ret;
|
|
|
|
saved_env = env;
|
|
env = env1;
|
|
ret = asr_read();
|
|
env = saved_env;
|
|
return ret;
|
|
}
|
|
|
|
target_ulong HELPER(asr_read)(void)
|
|
{
|
|
return asr_read();
|
|
}
|
|
|
|
static void asr_write(target_ulong val, target_ulong mask)
|
|
{
|
|
if (mask & ASR_NZCV) {
|
|
env->ZF = (~val) & ASR_Z;
|
|
env->NF = val;
|
|
env->CF = (val >> 29) & 1;
|
|
env->VF = (val << 3) & 0x80000000;
|
|
}
|
|
|
|
if ((env->uncached_asr ^ val) & mask & ASR_M) {
|
|
switch_mode(env, val & ASR_M);
|
|
}
|
|
mask &= ~ASR_NZCV;
|
|
env->uncached_asr = (env->uncached_asr & ~mask) | (val & mask);
|
|
}
|
|
|
|
void cpu_asr_write(CPUUniCore32State *env1, target_ulong val, target_ulong mask)
|
|
{
|
|
CPUUniCore32State *saved_env;
|
|
|
|
saved_env = env;
|
|
env = env1;
|
|
asr_write(val, mask);
|
|
env = saved_env;
|
|
}
|
|
|
|
void HELPER(asr_write)(target_ulong val, target_ulong mask)
|
|
{
|
|
asr_write(val, mask);
|
|
}
|
|
|
|
/* Access to user mode registers from privileged modes. */
|
|
uint32_t HELPER(get_user_reg)(uint32_t regno)
|
|
{
|
|
uint32_t val;
|
|
|
|
if (regno == 29) {
|
|
val = env->banked_r29[0];
|
|
} else if (regno == 30) {
|
|
val = env->banked_r30[0];
|
|
} else {
|
|
val = env->regs[regno];
|
|
}
|
|
return val;
|
|
}
|
|
|
|
void HELPER(set_user_reg)(uint32_t regno, uint32_t val)
|
|
{
|
|
if (regno == 29) {
|
|
env->banked_r29[0] = val;
|
|
} else if (regno == 30) {
|
|
env->banked_r30[0] = val;
|
|
} else {
|
|
env->regs[regno] = val;
|
|
}
|
|
}
|
|
|
|
/* ??? 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. */
|
|
|
|
uint32_t HELPER(add_cc)(uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t result;
|
|
result = a + b;
|
|
env->NF = env->ZF = result;
|
|
env->CF = result < a;
|
|
env->VF = (a ^ b ^ -1) & (a ^ result);
|
|
return result;
|
|
}
|
|
|
|
uint32_t HELPER(adc_cc)(uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t result;
|
|
if (!env->CF) {
|
|
result = a + b;
|
|
env->CF = result < a;
|
|
} else {
|
|
result = a + b + 1;
|
|
env->CF = result <= a;
|
|
}
|
|
env->VF = (a ^ b ^ -1) & (a ^ result);
|
|
env->NF = env->ZF = result;
|
|
return result;
|
|
}
|
|
|
|
uint32_t HELPER(sub_cc)(uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t result;
|
|
result = a - b;
|
|
env->NF = env->ZF = result;
|
|
env->CF = a >= b;
|
|
env->VF = (a ^ b) & (a ^ result);
|
|
return result;
|
|
}
|
|
|
|
uint32_t HELPER(sbc_cc)(uint32_t a, uint32_t b)
|
|
{
|
|
uint32_t result;
|
|
if (!env->CF) {
|
|
result = a - b - 1;
|
|
env->CF = a > b;
|
|
} else {
|
|
result = a - b;
|
|
env->CF = a >= b;
|
|
}
|
|
env->VF = (a ^ b) & (a ^ result);
|
|
env->NF = env->ZF = result;
|
|
return result;
|
|
}
|
|
|
|
/* Similarly for variable shift instructions. */
|
|
|
|
uint32_t HELPER(shl)(uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
return 0;
|
|
}
|
|
return x << shift;
|
|
}
|
|
|
|
uint32_t HELPER(shr)(uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
return 0;
|
|
}
|
|
return (uint32_t)x >> shift;
|
|
}
|
|
|
|
uint32_t HELPER(sar)(uint32_t x, uint32_t i)
|
|
{
|
|
int shift = i & 0xff;
|
|
if (shift >= 32) {
|
|
shift = 31;
|
|
}
|
|
return (int32_t)x >> shift;
|
|
}
|
|
|
|
uint32_t HELPER(shl_cc)(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)(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)(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)(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));
|
|
}
|
|
}
|