david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'tcg-next' of git://github.com/rth7680/qemu

Browse Source 
* 'tcg-next' of git://github.com/rth7680/qemu: (29 commits)
  tcg-i386: Make use of zero-extended memory helper routines
  tcg: Introduce zero and sign-extended versions of load helpers
  exec: Split softmmu_defs.h
  target: Include softmmu_exec.h where forgotten
  exec: Rename USUFFIX to LSUFFIX
  tcg-i386: Don't perform GETPC adjustment in TCG code
  exec: Reorganize the GETRA/GETPC macros
  configure: Allow x32 as a host
  tcg-i386: Adjust tcg_out_tlb_load for x32
  tcg-i386: Use intptr_t appropriately
  tcg: Fix jit debug for x32
  tcg: Use appropriate types in tcg_reg_alloc_call
  tcg: Change tcg_out_ld/st offset to intptr_t
  tcg: Change tcg_gen_exit_tb argument to uintptr_t
  tcg: Use uintptr_t in TCGHelperInfo
  tcg: Change relocation offsets to intptr_t
  tcg: Change memory offsets to intptr_t
  tcg: Change frame pointer offsets to intptr_t
  tcg: Define TCG_ptr properly
  tcg: Define TCG_TYPE_PTR properly
  ...
This commit is contained in:
Aurelien Jarno 2013-09-03 01:35:43 +02:00
commit 545825d4cd
57 changed files with 619 additions and 446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
configure vendored
View File

@ -362,7 +362,11 @@ if test ! -z "$cpu" ; then
elif check_define __i386__ ; then elif check_define __i386__ ; then
cpu="i386" cpu="i386"
elif check_define __x86_64__ ; then elif check_define __x86_64__ ; then
if check_define __ILP32__ ; then
cpu="x32"
else
cpu="x86_64" cpu="x86_64"
fi
elif check_define __sparc__ ; then elif check_define __sparc__ ; then
if check_define __arch64__ ; then if check_define __arch64__ ; then
cpu="sparc64" cpu="sparc64"
@ -399,7 +403,7 @@ ARCH=
# Normalise host CPU name and set ARCH. # Normalise host CPU name and set ARCH.
# Note that this case should only have supported host CPUs, not guests. # Note that this case should only have supported host CPUs, not guests.
case "$cpu" in case "$cpu" in
ia64|ppc|ppc64|s390|s390x|sparc64) ia64|ppc|ppc64|s390|s390x|sparc64|x32)
cpu="$cpu" cpu="$cpu"
;; ;;
i386|i486|i586|i686|i86pc|BePC) i386|i486|i586|i686|i86pc|BePC)
@ -550,7 +554,7 @@ Haiku)
kvm="yes" kvm="yes"
vhost_net="yes" vhost_net="yes"
vhost_scsi="yes" vhost_scsi="yes"
if [ "$cpu" = "i386" -o "$cpu" = "x86_64" ] ; then if [ "$cpu" = "i386" -o "$cpu" = "x86_64" -o "$cpu" = "x32" ] ; then
audio_possible_drivers="$audio_possible_drivers fmod" audio_possible_drivers="$audio_possible_drivers fmod"
fi fi
QEMU_INCLUDES="-I\$(SRC_PATH)/linux-headers -I$(pwd)/linux-headers $QEMU_INCLUDES" QEMU_INCLUDES="-I\$(SRC_PATH)/linux-headers -I$(pwd)/linux-headers $QEMU_INCLUDES"
@ -977,6 +981,11 @@ case "$cpu" in
LDFLAGS="-m64 $LDFLAGS" LDFLAGS="-m64 $LDFLAGS"
cc_i386='$(CC) -m32' cc_i386='$(CC) -m32'
;; ;;
x32)
CPU_CFLAGS="-mx32"
LDFLAGS="-mx32 $LDFLAGS"
cc_i386='$(CC) -m32'
;;
# No special flags required for other host CPUs # No special flags required for other host CPUs
esac esac
@ -1251,7 +1260,7 @@ fi
if test "$pie" = ""; then if test "$pie" = ""; then
case "$cpu-$targetos" in case "$cpu-$targetos" in
i386-Linux|x86_64-Linux|i386-OpenBSD|x86_64-OpenBSD) i386-Linux|x86_64-Linux|x32-Linux|i386-OpenBSD|x86_64-OpenBSD)
;; ;;
*) *)
pie="no" pie="no"
@ -3506,7 +3515,7 @@ fi
if test "$pie" = "no" ; then if test "$pie" = "no" ; then
textseg_addr= textseg_addr=
case "$cpu" in case "$cpu" in
arm | hppa | i386 | m68k | ppc | ppc64 | s390* | sparc | sparc64 | x86_64) arm | hppa | i386 | m68k | ppc | ppc64 | s390* | sparc | sparc64 | x86_64 | x32)
textseg_addr=0x60000000 textseg_addr=0x60000000
;; ;;
mips) mips)
@ -3681,7 +3690,7 @@ echo "libs_softmmu=$libs_softmmu" >> $config_host_mak
echo "ARCH=$ARCH" >> $config_host_mak echo "ARCH=$ARCH" >> $config_host_mak
case "$cpu" in case "$cpu" in
arm|i386|x86_64|ppc|aarch64) arm|i386|x86_64|x32|ppc|aarch64)
# The TCG interpreter currently does not support ld/st optimization. # The TCG interpreter currently does not support ld/st optimization.
if test "$tcg_interpreter" = "no" ; then if test "$tcg_interpreter" = "no" ; then
echo "CONFIG_QEMU_LDST_OPTIMIZATION=y" >> $config_host_mak echo "CONFIG_QEMU_LDST_OPTIMIZATION=y" >> $config_host_mak
@ -4116,7 +4125,7 @@ elif test "$ARCH" = "sparc64" ; then
QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/sparc $QEMU_INCLUDES" QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/sparc $QEMU_INCLUDES"
elif test "$ARCH" = "s390x" ; then elif test "$ARCH" = "s390x" ; then
QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/s390 $QEMU_INCLUDES" QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/s390 $QEMU_INCLUDES"
elif test "$ARCH" = "x86_64" ; then elif test "$ARCH" = "x86_64" -o "$ARCH" = "x32" ; then
QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/i386 $QEMU_INCLUDES" QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/i386 $QEMU_INCLUDES"
else else
QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/\$(ARCH) $QEMU_INCLUDES" QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/\$(ARCH) $QEMU_INCLUDES"
@ -4178,7 +4187,7 @@ fi
if test "$linux" = "yes" ; then if test "$linux" = "yes" ; then
mkdir -p linux-headers mkdir -p linux-headers
case "$cpu" in case "$cpu" in
i386|x86_64) i386|x86_64|x32)
linux_arch=x86 linux_arch=x86
;; ;;
ppcemb|ppc|ppc64) ppcemb|ppc|ppc64)
@ -4444,7 +4453,7 @@ for i in $ARCH $TARGET_BASE_ARCH ; do
echo "CONFIG_HPPA_DIS=y" >> $config_target_mak echo "CONFIG_HPPA_DIS=y" >> $config_target_mak
echo "CONFIG_HPPA_DIS=y" >> config-all-disas.mak echo "CONFIG_HPPA_DIS=y" >> config-all-disas.mak
;; ;;
i386|x86_64) i386|x86_64|x32)
echo "CONFIG_I386_DIS=y" >> $config_target_mak echo "CONFIG_I386_DIS=y" >> $config_target_mak
echo "CONFIG_I386_DIS=y" >> config-all-disas.mak echo "CONFIG_I386_DIS=y" >> config-all-disas.mak
;; ;;

4
cpu-exec.c
View File

@ -53,7 +53,7 @@ void cpu_resume_from_signal(CPUArchState *env, void *puc)
static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, uint8_t *tb_ptr) static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, uint8_t *tb_ptr)
{ {
CPUArchState *env = cpu->env_ptr; CPUArchState *env = cpu->env_ptr;
tcg_target_ulong next_tb = tcg_qemu_tb_exec(env, tb_ptr); uintptr_t next_tb = tcg_qemu_tb_exec(env, tb_ptr);
if ((next_tb & TB_EXIT_MASK) > TB_EXIT_IDX1) { if ((next_tb & TB_EXIT_MASK) > TB_EXIT_IDX1) {
/* We didn't start executing this TB (eg because the instruction /* We didn't start executing this TB (eg because the instruction
* counter hit zero); we must restore the guest PC to the address * counter hit zero); we must restore the guest PC to the address
@ -209,7 +209,7 @@ int cpu_exec(CPUArchState *env)
int ret, interrupt_request; int ret, interrupt_request;
TranslationBlock *tb; TranslationBlock *tb;
uint8_t *tc_ptr; uint8_t *tc_ptr;
tcg_target_ulong next_tb; uintptr_t next_tb;
if (cpu->halted) { if (cpu->halted) {
if (!cpu_has_work(cpu)) { if (!cpu_has_work(cpu)) {

89
include/exec/exec-all.h
View File

@ -295,47 +295,42 @@ static inline void tb_add_jump(TranslationBlock *tb, int n,
} }
} }
/* The return address may point to the start of the next instruction. /* GETRA is the true target of the return instruction that we'll execute,
Subtracting one gets us the call instruction itself. */ defined here for simplicity of defining the follow-up macros. */
#if defined(CONFIG_TCG_INTERPRETER) #if defined(CONFIG_TCG_INTERPRETER)
extern uintptr_t tci_tb_ptr; extern uintptr_t tci_tb_ptr;
# define GETPC() tci_tb_ptr # define GETRA() tci_tb_ptr
#elif defined(__s390__) && !defined(__s390x__)
# define GETPC() \
(((uintptr_t)__builtin_return_address(0) & 0x7fffffffUL) - 1)
#elif defined(__arm__)
/* Thumb return addresses have the low bit set, so we need to subtract two.
This is still safe in ARM mode because instructions are 4 bytes. */
# define GETPC() ((uintptr_t)__builtin_return_address(0) - 2)
#else #else
# define GETPC() ((uintptr_t)__builtin_return_address(0) - 1) # define GETRA() \
((uintptr_t)__builtin_extract_return_addr(__builtin_return_address(0)))
#endif #endif
#if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU) /* The true return address will often point to a host insn that is part of
/* qemu_ld/st optimization split code generation to fast and slow path, thus, the next translated guest insn. Adjust the address backward to point to
it needs special handling for an MMU helper which is called from the slow the middle of the call insn. Subtracting one would do the job except for
path, to get the fast path's pc without any additional argument. several compressed mode architectures (arm, mips) which set the low bit
It uses a tricky solution which embeds the fast path pc into the slow path. to indicate the compressed mode; subtracting two works around that. It
is also the case that there are no host isas that contain a call insn
smaller than 4 bytes, so we don't worry about special-casing this. */
#if defined(CONFIG_TCG_INTERPRETER)
# define GETPC_ADJ 0
#else
# define GETPC_ADJ 2
#endif
Code flow in slow path: #define GETPC() (GETRA() - GETPC_ADJ)
(1) pre-process
(2) call MMU helper /* The LDST optimizations splits code generation into fast and slow path.
(3) jump to (5) In some implementations, we pass the "logical" return address manually;
(4) fast path information (implementation specific) in others, we must infer the logical return from the true return. */
(5) post-process (e.g. stack adjust) #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
(6) jump to corresponding code of the next of fast path # if defined (_ARCH_PPC) && !defined (_ARCH_PPC64)
*/ # define GETRA_LDST(RA) (*(int32_t *)((RA) - 4))
# if defined(__i386__) || defined(__x86_64__)
# define GETPC_EXT() GETPC()
# elif defined (_ARCH_PPC) && !defined (_ARCH_PPC64)
# define GETRA() ((uintptr_t)__builtin_return_address(0))
# define GETPC_LDST() ((uintptr_t) ((*(int32_t *)(GETRA() - 4)) - 1))
# elif defined(__arm__) # elif defined(__arm__)
/* We define two insns between the return address and the branch back to /* We define two insns between the return address and the branch back to
straight-line. Find and decode that branch insn. */ straight-line. Find and decode that branch insn. */
# define GETRA() ((uintptr_t)__builtin_return_address(0)) # define GETRA_LDST(RA) tcg_getra_ldst(RA)
# define GETPC_LDST() tcg_getpc_ldst(GETRA()) static inline uintptr_t tcg_getra_ldst(uintptr_t ra)
static inline uintptr_t tcg_getpc_ldst(uintptr_t ra)
{ {
int32_t b; int32_t b;
ra += 8; /* skip the two insns */ ra += 8; /* skip the two insns */
@ -343,33 +338,32 @@ static inline uintptr_t tcg_getpc_ldst(uintptr_t ra)
b = (b << 8) >> (8 - 2); /* extract the displacement */ b = (b << 8) >> (8 - 2); /* extract the displacement */
ra += 8; /* branches are relative to pc+8 */ ra += 8; /* branches are relative to pc+8 */
ra += b; /* apply the displacement */ ra += b; /* apply the displacement */
ra -= 4; /* return a pointer into the current opcode,
not the start of the next opcode */
return ra; return ra;
} }
# elif defined(__aarch64__) # elif defined(__aarch64__)
# define GETRA() ((uintptr_t)__builtin_return_address(0)) # define GETRA_LDST(RA) tcg_getra_ldst(RA)
# define GETPC_LDST() tcg_getpc_ldst(GETRA()) static inline uintptr_t tcg_getra_ldst(uintptr_t ra)
static inline uintptr_t tcg_getpc_ldst(uintptr_t ra)
{ {
int32_t b; int32_t b;
ra += 4; /* skip one instruction */ ra += 4; /* skip one instruction */
b = *(int32_t *)ra; /* load the branch insn */ b = *(int32_t *)ra; /* load the branch insn */
b = (b << 6) >> (6 - 2); /* extract the displacement */ b = (b << 6) >> (6 - 2); /* extract the displacement */
ra += b; /* apply the displacement */ ra += b; /* apply the displacement */
ra -= 4; /* return a pointer into the current opcode,
not the start of the next opcode */
return ra; return ra;
} }
# else
# error "CONFIG_QEMU_LDST_OPTIMIZATION needs GETPC_LDST() implementation!"
# endif # endif
#endif /* CONFIG_QEMU_LDST_OPTIMIZATION */
/* ??? Delete these once they are no longer used. */
bool is_tcg_gen_code(uintptr_t pc_ptr); bool is_tcg_gen_code(uintptr_t pc_ptr);
# ifndef GETPC_EXT #ifdef GETRA_LDST
# define GETPC_EXT() (is_tcg_gen_code(GETRA()) ? GETPC_LDST() : GETPC()) # define GETRA_EXT() tcg_getra_ext(GETRA())
# endif static inline uintptr_t tcg_getra_ext(uintptr_t ra)
{
return is_tcg_gen_code(ra) ? GETRA_LDST(ra) : ra;
}
#else #else
# define GETPC_EXT() GETPC() # define GETRA_EXT() GETRA()
#endif #endif
#if !defined(CONFIG_USER_ONLY) #if !defined(CONFIG_USER_ONLY)
@ -383,7 +377,10 @@ bool io_mem_write(struct MemoryRegion *mr, hwaddr addr,
void tlb_fill(CPUArchState *env1, target_ulong addr, int is_write, int mmu_idx, void tlb_fill(CPUArchState *env1, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr); uintptr_t retaddr);
#include "exec/softmmu_defs.h" uint8_t helper_ldb_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint16_t helper_ldw_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint32_t helper_ldl_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint64_t helper_ldq_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
#define ACCESS_TYPE (NB_MMU_MODES + 1) #define ACCESS_TYPE (NB_MMU_MODES + 1)
#define MEMSUFFIX _code #define MEMSUFFIX _code

4
include/exec/gen-icount.h
View File

@ -39,12 +39,12 @@ static inline void gen_tb_start(void)
static void gen_tb_end(TranslationBlock *tb, int num_insns) static void gen_tb_end(TranslationBlock *tb, int num_insns)
{ {
gen_set_label(exitreq_label); gen_set_label(exitreq_label);
tcg_gen_exit_tb((tcg_target_long)tb + TB_EXIT_REQUESTED); tcg_gen_exit_tb((uintptr_t)tb + TB_EXIT_REQUESTED);
if (use_icount) { if (use_icount) {
*icount_arg = num_insns; *icount_arg = num_insns;
gen_set_label(icount_label); gen_set_label(icount_label);
tcg_gen_exit_tb((tcg_target_long)tb + TB_EXIT_ICOUNT_EXPIRED); tcg_gen_exit_tb((uintptr_t)tb + TB_EXIT_ICOUNT_EXPIRED);
} }
} }

49
include/exec/softmmu_defs.h
View File

@ -1,49 +0,0 @@
/*
* Software MMU support
*
* Declare helpers used by TCG for qemu_ld/st ops.
*
* Used by softmmu_exec.h, TCG targets and exec-all.h.
*
*/
#ifndef SOFTMMU_DEFS_H
#define SOFTMMU_DEFS_H
uint8_t helper_ret_ldb_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
uint16_t helper_ret_ldw_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
uint32_t helper_ret_ldl_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
uint64_t helper_ret_ldq_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
int mmu_idx, uintptr_t retaddr);
uint8_t helper_ldb_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint16_t helper_ldw_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint32_t helper_ldl_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint64_t helper_ldq_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
void helper_stb_mmu(CPUArchState *env, target_ulong addr,
uint8_t val, int mmu_idx);
void helper_stw_mmu(CPUArchState *env, target_ulong addr,
uint16_t val, int mmu_idx);
void helper_stl_mmu(CPUArchState *env, target_ulong addr,
uint32_t val, int mmu_idx);
void helper_stq_mmu(CPUArchState *env, target_ulong addr,
uint64_t val, int mmu_idx);
uint8_t helper_ldb_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint16_t helper_ldw_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint32_t helper_ldl_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint64_t helper_ldq_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
#endif /* SOFTMMU_DEFS_H */

3
include/exec/softmmu_exec.h
View File

@ -19,7 +19,8 @@
#define ldul_executive ldl_executive #define ldul_executive ldl_executive
#define ldul_supervisor ldl_supervisor #define ldul_supervisor ldl_supervisor
#include "exec/softmmu_defs.h" /* The memory helpers for tcg-generated code need tcg_target_long etc. */
#include "tcg.h"
#define ACCESS_TYPE 0 #define ACCESS_TYPE 0
#define MEMSUFFIX MMU_MODE0_SUFFIX #define MEMSUFFIX MMU_MODE0_SUFFIX

84
include/exec/softmmu_template.h
View File

@ -28,24 +28,40 @@
#if DATA_SIZE == 8 #if DATA_SIZE == 8
#define SUFFIX q #define SUFFIX q
#define USUFFIX q #define LSUFFIX q
#define DATA_TYPE uint64_t #define SDATA_TYPE int64_t
#elif DATA_SIZE == 4 #elif DATA_SIZE == 4
#define SUFFIX l #define SUFFIX l
#define USUFFIX l #define LSUFFIX l
#define DATA_TYPE uint32_t #define SDATA_TYPE int32_t
#elif DATA_SIZE == 2 #elif DATA_SIZE == 2
#define SUFFIX w #define SUFFIX w
#define USUFFIX uw #define LSUFFIX uw
#define DATA_TYPE uint16_t #define SDATA_TYPE int16_t
#elif DATA_SIZE == 1 #elif DATA_SIZE == 1
#define SUFFIX b #define SUFFIX b
#define USUFFIX ub #define LSUFFIX ub
#define DATA_TYPE uint8_t #define SDATA_TYPE int8_t
#else #else
#error unsupported data size #error unsupported data size
#endif #endif
#define DATA_TYPE glue(u, SDATA_TYPE)
/* For the benefit of TCG generated code, we want to avoid the complication
of ABI-specific return type promotion and always return a value extended
to the register size of the host. This is tcg_target_long, except in the
case of a 32-bit host and 64-bit data, and for that we always have
uint64_t. Don't bother with this widened value for SOFTMMU_CODE_ACCESS. */
#if defined(SOFTMMU_CODE_ACCESS) || DATA_SIZE == 8
# define WORD_TYPE DATA_TYPE
# define USUFFIX SUFFIX
#else
# define WORD_TYPE tcg_target_ulong
# define USUFFIX glue(u, SUFFIX)
# define SSUFFIX glue(s, SUFFIX)
#endif
#ifdef SOFTMMU_CODE_ACCESS #ifdef SOFTMMU_CODE_ACCESS
#define READ_ACCESS_TYPE 2 #define READ_ACCESS_TYPE 2
#define ADDR_READ addr_code #define ADDR_READ addr_code
@ -77,8 +93,8 @@ static inline DATA_TYPE glue(io_read, SUFFIX)(CPUArchState *env,
#ifdef SOFTMMU_CODE_ACCESS #ifdef SOFTMMU_CODE_ACCESS
static static
#endif #endif
DATA_TYPE WORD_TYPE
glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env, glue(glue(helper_ret_ld, USUFFIX), MMUSUFFIX)(CPUArchState *env,
target_ulong addr, int mmu_idx, target_ulong addr, int mmu_idx,
uintptr_t retaddr) uintptr_t retaddr)
{ {
@ -86,6 +102,9 @@ glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env,
target_ulong tlb_addr = env->tlb_table[mmu_idx][index].ADDR_READ; target_ulong tlb_addr = env->tlb_table[mmu_idx][index].ADDR_READ;
uintptr_t haddr; uintptr_t haddr;
/* Adjust the given return address. */
retaddr -= GETPC_ADJ;
/* If the TLB entry is for a different page, reload and try again. */ /* If the TLB entry is for a different page, reload and try again. */
if ((addr & TARGET_PAGE_MASK) if ((addr & TARGET_PAGE_MASK)
!= (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) { != (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
@ -121,10 +140,12 @@ glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env,
#endif #endif
addr1 = addr & ~(DATA_SIZE - 1); addr1 = addr & ~(DATA_SIZE - 1);
addr2 = addr1 + DATA_SIZE; addr2 = addr1 + DATA_SIZE;
res1 = glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(env, addr1, /* Note the adjustment at the beginning of the function.
mmu_idx, retaddr); Undo that for the recursion. */
res2 = glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(env, addr2, res1 = glue(glue(helper_ret_ld, USUFFIX), MMUSUFFIX)
mmu_idx, retaddr); (env, addr1, mmu_idx, retaddr + GETPC_ADJ);
res2 = glue(glue(helper_ret_ld, USUFFIX), MMUSUFFIX)
(env, addr2, mmu_idx, retaddr + GETPC_ADJ);
shift = (addr & (DATA_SIZE - 1)) * 8; shift = (addr & (DATA_SIZE - 1)) * 8;
#ifdef TARGET_WORDS_BIGENDIAN #ifdef TARGET_WORDS_BIGENDIAN
res = (res1 << shift) | (res2 >> ((DATA_SIZE * 8) - shift)); res = (res1 << shift) | (res2 >> ((DATA_SIZE * 8) - shift));
@ -142,19 +163,33 @@ glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env,
#endif #endif
haddr = addr + env->tlb_table[mmu_idx][index].addend; haddr = addr + env->tlb_table[mmu_idx][index].addend;
return glue(glue(ld, USUFFIX), _raw)((uint8_t *)haddr); /* Note that ldl_raw is defined with type "int". */
return (DATA_TYPE) glue(glue(ld, LSUFFIX), _raw)((uint8_t *)haddr);
} }
DATA_TYPE DATA_TYPE
glue(glue(helper_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env, target_ulong addr, glue(glue(helper_ld, SUFFIX), MMUSUFFIX)(CPUArchState *env, target_ulong addr,
int mmu_idx) int mmu_idx)
{ {
return glue(glue(helper_ret_ld, SUFFIX), MMUSUFFIX)(env, addr, mmu_idx, return glue(glue(helper_ret_ld, USUFFIX), MMUSUFFIX)(env, addr, mmu_idx,
GETPC_EXT()); GETRA_EXT());
} }
#ifndef SOFTMMU_CODE_ACCESS #ifndef SOFTMMU_CODE_ACCESS
/* Provide signed versions of the load routines as well. We can of course
avoid this for 64-bit data, or for 32-bit data on 32-bit host. */
#if DATA_SIZE * 8 < TCG_TARGET_REG_BITS
WORD_TYPE
glue(glue(helper_ret_ld, SSUFFIX), MMUSUFFIX)(CPUArchState *env,
target_ulong addr, int mmu_idx,
uintptr_t retaddr)
{
return (SDATA_TYPE) glue(glue(helper_ret_ld, USUFFIX), MMUSUFFIX)
(env, addr, mmu_idx, retaddr);
}
#endif
static inline void glue(io_write, SUFFIX)(CPUArchState *env, static inline void glue(io_write, SUFFIX)(CPUArchState *env,
hwaddr physaddr, hwaddr physaddr,
DATA_TYPE val, DATA_TYPE val,
@ -182,6 +217,9 @@ glue(glue(helper_ret_st, SUFFIX), MMUSUFFIX)(CPUArchState *env,
target_ulong tlb_addr = env->tlb_table[mmu_idx][index].addr_write; target_ulong tlb_addr = env->tlb_table[mmu_idx][index].addr_write;
uintptr_t haddr; uintptr_t haddr;
/* Adjust the given return address. */
retaddr -= GETPC_ADJ;
/* If the TLB entry is for a different page, reload and try again. */ /* If the TLB entry is for a different page, reload and try again. */
if ((addr & TARGET_PAGE_MASK) if ((addr & TARGET_PAGE_MASK)
!= (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) { != (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
@ -223,8 +261,10 @@ glue(glue(helper_ret_st, SUFFIX), MMUSUFFIX)(CPUArchState *env,
#else #else
uint8_t val8 = val >> (i * 8); uint8_t val8 = val >> (i * 8);
#endif #endif
/* Note the adjustment at the beginning of the function.
Undo that for the recursion. */
glue(helper_ret_stb, MMUSUFFIX)(env, addr + i, val8, glue(helper_ret_stb, MMUSUFFIX)(env, addr + i, val8,
mmu_idx, retaddr); mmu_idx, retaddr + GETPC_ADJ);
} }
return; return;
} }
@ -245,7 +285,7 @@ glue(glue(helper_st, SUFFIX), MMUSUFFIX)(CPUArchState *env, target_ulong addr,
DATA_TYPE val, int mmu_idx) DATA_TYPE val, int mmu_idx)
{ {
glue(glue(helper_ret_st, SUFFIX), MMUSUFFIX)(env, addr, val, mmu_idx, glue(glue(helper_ret_st, SUFFIX), MMUSUFFIX)(env, addr, val, mmu_idx,
GETPC_EXT()); GETRA_EXT());
} }
#endif /* !defined(SOFTMMU_CODE_ACCESS) */ #endif /* !defined(SOFTMMU_CODE_ACCESS) */
@ -254,6 +294,10 @@ glue(glue(helper_st, SUFFIX), MMUSUFFIX)(CPUArchState *env, target_ulong addr,
#undef SHIFT #undef SHIFT
#undef DATA_TYPE #undef DATA_TYPE
#undef SUFFIX #undef SUFFIX
#undef USUFFIX #undef LSUFFIX
#undef DATA_SIZE #undef DATA_SIZE
#undef ADDR_READ #undef ADDR_READ
#undef WORD_TYPE
#undef SDATA_TYPE
#undef USUFFIX
#undef SSUFFIX

8
qtest.c
View File

@ -177,7 +177,7 @@ static void qtest_send_prefix(CharDriverState *chr)
qtest_get_time(&tv); qtest_get_time(&tv);
fprintf(qtest_log_fp, "[S +" FMT_timeval "] ", fprintf(qtest_log_fp, "[S +" FMT_timeval "] ",
tv.tv_sec, (long) tv.tv_usec); (long) tv.tv_sec, (long) tv.tv_usec);
} }
static void GCC_FMT_ATTR(2, 3) qtest_send(CharDriverState *chr, static void GCC_FMT_ATTR(2, 3) qtest_send(CharDriverState *chr,
@ -225,7 +225,7 @@ static void qtest_process_command(CharDriverState *chr, gchar **words)
qtest_get_time(&tv); qtest_get_time(&tv);
fprintf(qtest_log_fp, "[R +" FMT_timeval "]", fprintf(qtest_log_fp, "[R +" FMT_timeval "]",
tv.tv_sec, (long) tv.tv_usec); (long) tv.tv_sec, (long) tv.tv_usec);
for (i = 0; words[i]; i++) { for (i = 0; words[i]; i++) {
fprintf(qtest_log_fp, " %s", words[i]); fprintf(qtest_log_fp, " %s", words[i]);
} }
@ -485,7 +485,7 @@ static void qtest_event(void *opaque, int event)
qtest_opened = true; qtest_opened = true;
if (qtest_log_fp) { if (qtest_log_fp) {
fprintf(qtest_log_fp, "[I " FMT_timeval "] OPENED\n", fprintf(qtest_log_fp, "[I " FMT_timeval "] OPENED\n",
start_time.tv_sec, (long) start_time.tv_usec); (long) start_time.tv_sec, (long) start_time.tv_usec);
} }
break; break;
case CHR_EVENT_CLOSED: case CHR_EVENT_CLOSED:
@ -494,7 +494,7 @@ static void qtest_event(void *opaque, int event)
qemu_timeval tv; qemu_timeval tv;
qtest_get_time(&tv); qtest_get_time(&tv);
fprintf(qtest_log_fp, "[I +" FMT_timeval "] CLOSED\n", fprintf(qtest_log_fp, "[I +" FMT_timeval "] CLOSED\n",
tv.tv_sec, (long) tv.tv_usec); (long) tv.tv_sec, (long) tv.tv_usec);
} }
break; break;
default: default:

8
target-alpha/translate.c
View File

@ -415,7 +415,7 @@ static ExitStatus gen_bdirect(DisasContext *ctx, int ra, int32_t disp)
} else if (use_goto_tb(ctx, dest)) { } else if (use_goto_tb(ctx, dest)) {
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_movi_i64(cpu_pc, dest); tcg_gen_movi_i64(cpu_pc, dest);
tcg_gen_exit_tb((tcg_target_long)ctx->tb); tcg_gen_exit_tb((uintptr_t)ctx->tb);
return EXIT_GOTO_TB; return EXIT_GOTO_TB;
} else { } else {
tcg_gen_movi_i64(cpu_pc, dest); tcg_gen_movi_i64(cpu_pc, dest);
@ -434,12 +434,12 @@ static ExitStatus gen_bcond_internal(DisasContext *ctx, TCGCond cond,
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_movi_i64(cpu_pc, ctx->pc); tcg_gen_movi_i64(cpu_pc, ctx->pc);
tcg_gen_exit_tb((tcg_target_long)ctx->tb); tcg_gen_exit_tb((uintptr_t)ctx->tb);
gen_set_label(lab_true); gen_set_label(lab_true);
tcg_gen_goto_tb(1); tcg_gen_goto_tb(1);
tcg_gen_movi_i64(cpu_pc, dest); tcg_gen_movi_i64(cpu_pc, dest);
tcg_gen_exit_tb((tcg_target_long)ctx->tb + 1); tcg_gen_exit_tb((uintptr_t)ctx->tb + 1);
return EXIT_GOTO_TB; return EXIT_GOTO_TB;
} else { } else {
@ -1629,7 +1629,7 @@ static ExitStatus gen_call_pal(DisasContext *ctx, int palcode)
we change the PAL base register. */ we change the PAL base register. */
if (!ctx->singlestep_enabled && !(ctx->tb->cflags & CF_LAST_IO)) { if (!ctx->singlestep_enabled && !(ctx->tb->cflags & CF_LAST_IO)) {
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_exit_tb((tcg_target_long)ctx->tb); tcg_gen_exit_tb((uintptr_t)ctx->tb);
return EXIT_GOTO_TB; return EXIT_GOTO_TB;
} }

2
target-arm/translate.c
View File

@ -3356,7 +3356,7 @@ static inline void gen_goto_tb(DisasContext *s, int n, uint32_t dest)
if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) { if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
gen_set_pc_im(dest); gen_set_pc_im(dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
gen_set_pc_im(dest); gen_set_pc_im(dest);
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);

2
target-cris/translate.c
View File

@ -558,7 +558,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) { if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_tl(env_pc, dest); tcg_gen_movi_tl(env_pc, dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_tl(env_pc, dest); tcg_gen_movi_tl(env_pc, dest);
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);

2
target-i386/translate.c
View File

@ -2413,7 +2413,7 @@ static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
/* jump to same page: we can use a direct jump */ /* jump to same page: we can use a direct jump */
tcg_gen_goto_tb(tb_num); tcg_gen_goto_tb(tb_num);
gen_jmp_im(eip); gen_jmp_im(eip);
tcg_gen_exit_tb((tcg_target_long)tb + tb_num); tcg_gen_exit_tb((uintptr_t)tb + tb_num);
} else { } else {
/* jump to another page: currently not optimized */ /* jump to another page: currently not optimized */
gen_jmp_im(eip); gen_jmp_im(eip);

2
target-lm32/op_helper.c
View File

@ -6,6 +6,8 @@
#include "hw/lm32/lm32_pic.h" #include "hw/lm32/lm32_pic.h"
#include "hw/char/lm32_juart.h" #include "hw/char/lm32_juart.h"
#include "exec/softmmu_exec.h"
#if !defined(CONFIG_USER_ONLY) #if !defined(CONFIG_USER_ONLY)
#define MMUSUFFIX _mmu #define MMUSUFFIX _mmu
#define SHIFT 0 #define SHIFT 0

2
target-lm32/translate.c
View File

@ -129,7 +129,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
likely(!dc->singlestep_enabled)) { likely(!dc->singlestep_enabled)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_tl(cpu_pc, dest); tcg_gen_movi_tl(cpu_pc, dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_tl(cpu_pc, dest); tcg_gen_movi_tl(cpu_pc, dest);
if (dc->singlestep_enabled) { if (dc->singlestep_enabled) {

2
target-m68k/translate.c
View File

@ -869,7 +869,7 @@ static void gen_jmp_tb(DisasContext *s, int n, uint32_t dest)
(s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) { (s->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_i32(QREG_PC, dest); tcg_gen_movi_i32(QREG_PC, dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
gen_jmp_im(s, dest); gen_jmp_im(s, dest);
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);

2
target-microblaze/translate.c
View File

@ -138,7 +138,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) { if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_tl(cpu_SR[SR_PC], dest); tcg_gen_movi_tl(cpu_SR[SR_PC], dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_tl(cpu_SR[SR_PC], dest); tcg_gen_movi_tl(cpu_SR[SR_PC], dest);
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);

2
target-mips/translate.c
View File

@ -3581,7 +3581,7 @@ static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
likely(!ctx->singlestep_enabled)) { likely(!ctx->singlestep_enabled)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
gen_save_pc(dest); gen_save_pc(dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
gen_save_pc(dest); gen_save_pc(dest);
if (ctx->singlestep_enabled) { if (ctx->singlestep_enabled) {

1
target-moxie/helper.c
View File

@ -25,6 +25,7 @@
#include "cpu.h" #include "cpu.h"
#include "mmu.h" #include "mmu.h"
#include "exec/exec-all.h" #include "exec/exec-all.h"
#include "exec/softmmu_exec.h"
#include "qemu/host-utils.h" #include "qemu/host-utils.h"
#include "helper.h" #include "helper.h"

2
target-moxie/translate.c
View File

@ -135,7 +135,7 @@ static inline void gen_goto_tb(CPUMoxieState *env, DisasContext *ctx,
!ctx->singlestep_enabled) { !ctx->singlestep_enabled) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_i32(cpu_pc, dest); tcg_gen_movi_i32(cpu_pc, dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_i32(cpu_pc, dest); tcg_gen_movi_i32(cpu_pc, dest);
if (ctx->singlestep_enabled) { if (ctx->singlestep_enabled) {

2
target-openrisc/translate.c
View File

@ -198,7 +198,7 @@ static void gen_goto_tb(DisasContext *dc, int n, target_ulong dest)
likely(!dc->singlestep_enabled)) { likely(!dc->singlestep_enabled)) {
tcg_gen_movi_tl(cpu_pc, dest); tcg_gen_movi_tl(cpu_pc, dest);
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_tl(cpu_pc, dest); tcg_gen_movi_tl(cpu_pc, dest);
if (dc->singlestep_enabled) { if (dc->singlestep_enabled) {

2
target-ppc/mmu_helper.c
View File

@ -2871,6 +2871,8 @@ void helper_booke206_tlbflush(CPUPPCState *env, uint32_t type)
/*****************************************************************************/ /*****************************************************************************/
#include "exec/softmmu_exec.h"
#define MMUSUFFIX _mmu #define MMUSUFFIX _mmu
#define SHIFT 0 #define SHIFT 0

2
target-ppc/translate.c
View File

@ -3551,7 +3551,7 @@ static inline void gen_goto_tb(DisasContext *ctx, int n, target_ulong dest)
likely(!ctx->singlestep_enabled)) { likely(!ctx->singlestep_enabled)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_tl(cpu_nip, dest & ~3); tcg_gen_movi_tl(cpu_nip, dest & ~3);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_tl(cpu_nip, dest & ~3); tcg_gen_movi_tl(cpu_nip, dest & ~3);
if (unlikely(ctx->singlestep_enabled)) { if (unlikely(ctx->singlestep_enabled)) {

8
target-s390x/translate.c
View File

@ -1169,7 +1169,7 @@ static ExitStatus help_goto_direct(DisasContext *s, uint64_t dest)
update_cc_op(s); update_cc_op(s);
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_movi_i64(psw_addr, dest); tcg_gen_movi_i64(psw_addr, dest);
tcg_gen_exit_tb((tcg_target_long)s->tb); tcg_gen_exit_tb((uintptr_t)s->tb);
return EXIT_GOTO_TB; return EXIT_GOTO_TB;
} else { } else {
tcg_gen_movi_i64(psw_addr, dest); tcg_gen_movi_i64(psw_addr, dest);
@ -1227,13 +1227,13 @@ static ExitStatus help_branch(DisasContext *s, DisasCompare *c,
/* Branch not taken. */ /* Branch not taken. */
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_movi_i64(psw_addr, s->next_pc); tcg_gen_movi_i64(psw_addr, s->next_pc);
tcg_gen_exit_tb((tcg_target_long)s->tb + 0); tcg_gen_exit_tb((uintptr_t)s->tb + 0);
/* Branch taken. */ /* Branch taken. */
gen_set_label(lab); gen_set_label(lab);
tcg_gen_goto_tb(1); tcg_gen_goto_tb(1);
tcg_gen_movi_i64(psw_addr, dest); tcg_gen_movi_i64(psw_addr, dest);
tcg_gen_exit_tb((tcg_target_long)s->tb + 1); tcg_gen_exit_tb((uintptr_t)s->tb + 1);
ret = EXIT_GOTO_TB; ret = EXIT_GOTO_TB;
} else { } else {
@ -1256,7 +1256,7 @@ static ExitStatus help_branch(DisasContext *s, DisasCompare *c,
update_cc_op(s); update_cc_op(s);
tcg_gen_goto_tb(0); tcg_gen_goto_tb(0);
tcg_gen_movi_i64(psw_addr, s->next_pc); tcg_gen_movi_i64(psw_addr, s->next_pc);
tcg_gen_exit_tb((tcg_target_long)s->tb + 0); tcg_gen_exit_tb((uintptr_t)s->tb + 0);
gen_set_label(lab); gen_set_label(lab);
if (is_imm) { if (is_imm) {

2
target-sh4/translate.c
View File

@ -186,7 +186,7 @@ static void gen_goto_tb(DisasContext * ctx, int n, target_ulong dest)
/* Use a direct jump if in same page and singlestep not enabled */ /* Use a direct jump if in same page and singlestep not enabled */
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
tcg_gen_movi_i32(cpu_pc, dest); tcg_gen_movi_i32(cpu_pc, dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
tcg_gen_movi_i32(cpu_pc, dest); tcg_gen_movi_i32(cpu_pc, dest);
if (ctx->singlestep_enabled) if (ctx->singlestep_enabled)

2
target-sparc/translate.c
View File

@ -322,7 +322,7 @@ static inline void gen_goto_tb(DisasContext *s, int tb_num,
tcg_gen_goto_tb(tb_num); tcg_gen_goto_tb(tb_num);
tcg_gen_movi_tl(cpu_pc, pc); tcg_gen_movi_tl(cpu_pc, pc);
tcg_gen_movi_tl(cpu_npc, npc); tcg_gen_movi_tl(cpu_npc, npc);
tcg_gen_exit_tb((tcg_target_long)tb + tb_num); tcg_gen_exit_tb((uintptr_t)tb + tb_num);
} else { } else {
/* jump to another page: currently not optimized */ /* jump to another page: currently not optimized */
tcg_gen_movi_tl(cpu_pc, pc); tcg_gen_movi_tl(cpu_pc, pc);

2
target-unicore32/op_helper.c
View File

@ -239,6 +239,8 @@ uint32_t HELPER(ror_cc)(CPUUniCore32State *env, uint32_t x, uint32_t i)
} }
#ifndef CONFIG_USER_ONLY #ifndef CONFIG_USER_ONLY
#include "exec/softmmu_exec.h"
#define MMUSUFFIX _mmu #define MMUSUFFIX _mmu
#define SHIFT 0 #define SHIFT 0

2
target-unicore32/translate.c
View File

@ -1100,7 +1100,7 @@ static inline void gen_goto_tb(DisasContext *s, int n, uint32_t dest)
if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) { if ((tb->pc & TARGET_PAGE_MASK) == (dest & TARGET_PAGE_MASK)) {
tcg_gen_goto_tb(n); tcg_gen_goto_tb(n);
gen_set_pc_im(dest); gen_set_pc_im(dest);
tcg_gen_exit_tb((tcg_target_long)tb + n); tcg_gen_exit_tb((uintptr_t)tb + n);
} else { } else {
gen_set_pc_im(dest); gen_set_pc_im(dest);
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);

1
target-xtensa/op_helper.c
View File

@ -28,6 +28,7 @@
#include "cpu.h" #include "cpu.h"
#include "helper.h" #include "helper.h"
#include "qemu/host-utils.h" #include "qemu/host-utils.h"
#include "exec/softmmu_exec.h"
static void do_unaligned_access(CPUXtensaState *env, static void do_unaligned_access(CPUXtensaState *env,
target_ulong addr, int is_write, int is_user, uintptr_t retaddr); target_ulong addr, int is_write, int is_user, uintptr_t retaddr);

2
target-xtensa/translate.c
View File

@ -400,7 +400,7 @@ static void gen_jump_slot(DisasContext *dc, TCGv dest, int slot)
} else { } else {
if (slot >= 0) { if (slot >= 0) {
tcg_gen_goto_tb(slot); tcg_gen_goto_tb(slot);
tcg_gen_exit_tb((tcg_target_long)dc->tb + slot); tcg_gen_exit_tb((uintptr_t)dc->tb + slot);
} else { } else {
tcg_gen_exit_tb(0); tcg_gen_exit_tb(0);
} }

8
tcg/aarch64/tcg-target.c
View File

@ -88,7 +88,7 @@ static inline void reloc_pc19(void *code_ptr, tcg_target_long target)
} }
static inline void patch_reloc(uint8_t *code_ptr, int type, static inline void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
@ -423,14 +423,14 @@ static inline void tcg_out_mov(TCGContext *s,
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, (type == TCG_TYPE_I64) ? LDST_64 : LDST_32, LDST_LD, tcg_out_ldst(s, (type == TCG_TYPE_I64) ? LDST_64 : LDST_32, LDST_LD,
arg, arg1, arg2); arg, arg1, arg2);
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, (type == TCG_TYPE_I64) ? LDST_64 : LDST_32, LDST_ST, tcg_out_ldst(s, (type == TCG_TYPE_I64) ? LDST_64 : LDST_32, LDST_ST,
arg, arg1, arg2); arg, arg1, arg2);
@ -778,8 +778,6 @@ static inline void tcg_out_nop(TCGContext *s)
} }
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {

7
tcg/aarch64/tcg-target.h
View File

@ -61,6 +61,8 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i32 0 #define TCG_TARGET_HAS_sub2_i32 0
#define TCG_TARGET_HAS_mulu2_i32 0 #define TCG_TARGET_HAS_mulu2_i32 0
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_TARGET_HAS_div_i64 0 #define TCG_TARGET_HAS_div_i64 0
#define TCG_TARGET_HAS_rem_i64 0 #define TCG_TARGET_HAS_rem_i64 0
@ -87,13 +89,14 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i64 0 #define TCG_TARGET_HAS_sub2_i64 0
#define TCG_TARGET_HAS_mulu2_i64 0 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
enum { enum {
TCG_AREG0 = TCG_REG_X19, TCG_AREG0 = TCG_REG_X19,
}; };
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
__builtin___clear_cache((char *)start, (char *)stop); __builtin___clear_cache((char *)start, (char *)stop);
} }

14
tcg/arm/tcg-target.c
View File

@ -108,21 +108,21 @@ static const int tcg_target_call_oarg_regs[2] = {
#define TCG_REG_TMP TCG_REG_R12 #define TCG_REG_TMP TCG_REG_R12
static inline void reloc_abs32(void *code_ptr, tcg_target_long target) static inline void reloc_abs32(void *code_ptr, intptr_t target)
{ {
*(uint32_t *) code_ptr = target; *(uint32_t *) code_ptr = target;
} }
static inline void reloc_pc24(void *code_ptr, tcg_target_long target) static inline void reloc_pc24(void *code_ptr, intptr_t target)
{ {
uint32_t offset = ((target - ((tcg_target_long) code_ptr + 8)) >> 2); uint32_t offset = ((target - ((intptr_t)code_ptr + 8)) >> 2);
*(uint32_t *) code_ptr = ((*(uint32_t *) code_ptr) & ~0xffffff) *(uint32_t *) code_ptr = ((*(uint32_t *) code_ptr) & ~0xffffff)
| (offset & 0xffffff); | (offset & 0xffffff);
} }
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
switch (type) { switch (type) {
case R_ARM_ABS32: case R_ARM_ABS32:
@ -1058,8 +1058,6 @@ static inline void tcg_out_goto_label(TCGContext *s, int cond, int label_index)
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
@ -2065,13 +2063,13 @@ static void tcg_target_init(TCGContext *s)
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ld32u(s, COND_AL, arg, arg1, arg2); tcg_out_ld32u(s, COND_AL, arg, arg1, arg2);
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_st32(s, COND_AL, arg, arg1, arg2); tcg_out_st32(s, COND_AL, arg, arg1, arg2);
} }

11
tcg/arm/tcg-target.h
View File

@ -80,6 +80,8 @@ extern bool use_idiv_instructions;
#define TCG_TARGET_HAS_deposit_i32 1 #define TCG_TARGET_HAS_deposit_i32 1
#define TCG_TARGET_HAS_movcond_i32 1 #define TCG_TARGET_HAS_movcond_i32 1
#define TCG_TARGET_HAS_muls2_i32 1 #define TCG_TARGET_HAS_muls2_i32 1
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_TARGET_HAS_div_i32 use_idiv_instructions #define TCG_TARGET_HAS_div_i32 use_idiv_instructions
#define TCG_TARGET_HAS_rem_i32 0 #define TCG_TARGET_HAS_rem_i32 0
@ -90,15 +92,14 @@ enum {
TCG_AREG0 = TCG_REG_R6, TCG_AREG0 = TCG_REG_R6,
}; };
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
#if QEMU_GNUC_PREREQ(4, 1) #if QEMU_GNUC_PREREQ(4, 1)
__builtin___clear_cache((char *) start, (char *) stop); __builtin___clear_cache((char *) start, (char *) stop);
#else #else
register unsigned long _beg __asm ("a1") = start; register uintptr_t _beg __asm("a1") = start;
register unsigned long _end __asm ("a2") = stop; register uintptr_t _end __asm("a2") = stop;
register unsigned long _flg __asm ("a3") = 0; register uintptr_t _flg __asm("a3") = 0;
__asm __volatile__ ("swi 0x9f0002" : : "r" (_beg), "r" (_end), "r" (_flg)); __asm __volatile__ ("swi 0x9f0002" : : "r" (_beg), "r" (_end), "r" (_flg));
#endif #endif
} }

16
tcg/hppa/tcg-target.c
View File

@ -22,6 +22,10 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#if TCG_TARGET_REG_BITS != 32
#error unsupported
#endif
#ifndef NDEBUG #ifndef NDEBUG
static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = { static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
"%r0", "%r1", "%rp", "%r3", "%r4", "%r5", "%r6", "%r7", "%r0", "%r1", "%rp", "%r3", "%r4", "%r5", "%r6", "%r7",
@ -145,14 +149,14 @@ static int reassemble_21(int as21)
#define R_PARISC_PCREL12F R_PARISC_NONE #define R_PARISC_PCREL12F R_PARISC_NONE
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
uint32_t *insn_ptr = (uint32_t *)code_ptr; uint32_t *insn_ptr = (uint32_t *)code_ptr;
uint32_t insn = *insn_ptr; uint32_t insn = *insn_ptr;
tcg_target_long pcrel; intptr_t pcrel;
value += addend; value += addend;
pcrel = (value - ((tcg_target_long)code_ptr + 8)) >> 2; pcrel = (value - ((intptr_t)code_ptr + 8)) >> 2;
switch (type) { switch (type) {
case R_PARISC_PCREL12F: case R_PARISC_PCREL12F:
@ -388,14 +392,14 @@ static void tcg_out_ldst(TCGContext *s, int ret, int addr,
/* This function is required by tcg.c. */ /* This function is required by tcg.c. */
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, ret, arg1, arg2, INSN_LDW); tcg_out_ldst(s, ret, arg1, arg2, INSN_LDW);
} }
/* This function is required by tcg.c. */ /* This function is required by tcg.c. */
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg ret, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg ret,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, ret, arg1, arg2, INSN_STW); tcg_out_ldst(s, ret, arg1, arg2, INSN_STW);
} }
@ -906,8 +910,6 @@ static void tcg_out_movcond(TCGContext *s, int cond, TCGArg ret,
} }
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {

9
tcg/hppa/tcg-target.h
View File

@ -25,10 +25,6 @@
#ifndef TCG_TARGET_HPPA #ifndef TCG_TARGET_HPPA
#define TCG_TARGET_HPPA 1 #define TCG_TARGET_HPPA 1
#if TCG_TARGET_REG_BITS != 32
#error unsupported
#endif
#define TCG_TARGET_WORDS_BIGENDIAN #define TCG_TARGET_WORDS_BIGENDIAN
#define TCG_TARGET_NB_REGS 32 #define TCG_TARGET_NB_REGS 32
@ -100,6 +96,8 @@ typedef enum {
#define TCG_TARGET_HAS_deposit_i32 1 #define TCG_TARGET_HAS_deposit_i32 1
#define TCG_TARGET_HAS_movcond_i32 1 #define TCG_TARGET_HAS_movcond_i32 1
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
/* optional instructions automatically implemented */ /* optional instructions automatically implemented */
#define TCG_TARGET_HAS_neg_i32 0 /* sub rd, 0, rs */ #define TCG_TARGET_HAS_neg_i32 0 /* sub rd, 0, rs */
@ -109,8 +107,7 @@ typedef enum {
#define TCG_AREG0 TCG_REG_R17 #define TCG_AREG0 TCG_REG_R17
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
start &= ~31; start &= ~31;
while (start <= stop) { while (start <= stop) {

141
tcg/i386/tcg-target.c
View File

@ -112,7 +112,7 @@ static bool have_cmov;
static uint8_t *tb_ret_addr; static uint8_t *tb_ret_addr;
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
switch(type) { switch(type) {
@ -430,8 +430,7 @@ static void tcg_out_modrm(TCGContext *s, int opc, int r, int rm)
that will follow the instruction. */ that will follow the instruction. */
static void tcg_out_modrm_sib_offset(TCGContext *s, int opc, int r, int rm, static void tcg_out_modrm_sib_offset(TCGContext *s, int opc, int r, int rm,
int index, int shift, int index, int shift, intptr_t offset)
tcg_target_long offset)
{ {
int mod, len; int mod, len;
@ -439,8 +438,8 @@ static void tcg_out_modrm_sib_offset(TCGContext *s, int opc, int r, int rm,
if (TCG_TARGET_REG_BITS == 64) { if (TCG_TARGET_REG_BITS == 64) {
/* Try for a rip-relative addressing mode. This has replaced /* Try for a rip-relative addressing mode. This has replaced
the 32-bit-mode absolute addressing encoding. */ the 32-bit-mode absolute addressing encoding. */
tcg_target_long pc = (tcg_target_long)s->code_ptr + 5 + ~rm; intptr_t pc = (intptr_t)s->code_ptr + 5 + ~rm;
tcg_target_long disp = offset - pc; intptr_t disp = offset - pc;
if (disp == (int32_t)disp) { if (disp == (int32_t)disp) {
tcg_out_opc(s, opc, r, 0, 0); tcg_out_opc(s, opc, r, 0, 0);
tcg_out8(s, (LOWREGMASK(r) << 3) | 5); tcg_out8(s, (LOWREGMASK(r) << 3) | 5);
@ -514,7 +513,7 @@ static void tcg_out_modrm_sib_offset(TCGContext *s, int opc, int r, int rm,
/* A simplification of the above with no index or shift. */ /* A simplification of the above with no index or shift. */
static inline void tcg_out_modrm_offset(TCGContext *s, int opc, int r, static inline void tcg_out_modrm_offset(TCGContext *s, int opc, int r,
int rm, tcg_target_long offset) int rm, intptr_t offset)
{ {
tcg_out_modrm_sib_offset(s, opc, r, rm, -1, 0, offset); tcg_out_modrm_sib_offset(s, opc, r, rm, -1, 0, offset);
} }
@ -559,7 +558,7 @@ static void tcg_out_movi(TCGContext *s, TCGType type,
} }
/* Try a 7 byte pc-relative lea before the 10 byte movq. */ /* Try a 7 byte pc-relative lea before the 10 byte movq. */
diff = arg - ((tcg_target_long)s->code_ptr + 7); diff = arg - ((uintptr_t)s->code_ptr + 7);
if (diff == (int32_t)diff) { if (diff == (int32_t)diff) {
tcg_out_opc(s, OPC_LEA | P_REXW, ret, 0, 0); tcg_out_opc(s, OPC_LEA | P_REXW, ret, 0, 0);
tcg_out8(s, (LOWREGMASK(ret) << 3) | 5); tcg_out8(s, (LOWREGMASK(ret) << 3) | 5);
@ -595,14 +594,14 @@ static inline void tcg_out_pop(TCGContext *s, int reg)
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
int opc = OPC_MOVL_GvEv + (type == TCG_TYPE_I64 ? P_REXW : 0); int opc = OPC_MOVL_GvEv + (type == TCG_TYPE_I64 ? P_REXW : 0);
tcg_out_modrm_offset(s, opc, ret, arg1, arg2); tcg_out_modrm_offset(s, opc, ret, arg1, arg2);
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
int opc = OPC_MOVL_EvGv + (type == TCG_TYPE_I64 ? P_REXW : 0); int opc = OPC_MOVL_EvGv + (type == TCG_TYPE_I64 ? P_REXW : 0);
tcg_out_modrm_offset(s, opc, arg, arg1, arg2); tcg_out_modrm_offset(s, opc, arg, arg1, arg2);
@ -757,7 +756,7 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index, int small)
TCGLabel *l = &s->labels[label_index]; TCGLabel *l = &s->labels[label_index];
if (l->has_value) { if (l->has_value) {
val = l->u.value - (tcg_target_long)s->code_ptr; val = l->u.value - (intptr_t)s->code_ptr;
val1 = val - 2; val1 = val - 2;
if ((int8_t)val1 == val1) { if ((int8_t)val1 == val1) {
if (opc == -1) { if (opc == -1) {
@ -997,9 +996,9 @@ static void tcg_out_movcond64(TCGContext *s, TCGCond cond, TCGArg dest,
} }
#endif #endif
static void tcg_out_branch(TCGContext *s, int call, tcg_target_long dest) static void tcg_out_branch(TCGContext *s, int call, uintptr_t dest)
{ {
tcg_target_long disp = dest - (tcg_target_long)s->code_ptr - 5; intptr_t disp = dest - (intptr_t)s->code_ptr - 5;
if (disp == (int32_t)disp) { if (disp == (int32_t)disp) {
tcg_out_opc(s, call ? OPC_CALL_Jz : OPC_JMP_long, 0, 0, 0); tcg_out_opc(s, call ? OPC_CALL_Jz : OPC_JMP_long, 0, 0, 0);
@ -1011,27 +1010,24 @@ static void tcg_out_branch(TCGContext *s, int call, tcg_target_long dest)
} }
} }
static inline void tcg_out_calli(TCGContext *s, tcg_target_long dest) static inline void tcg_out_calli(TCGContext *s, uintptr_t dest)
{ {
tcg_out_branch(s, 1, dest); tcg_out_branch(s, 1, dest);
} }
static void tcg_out_jmp(TCGContext *s, tcg_target_long dest) static void tcg_out_jmp(TCGContext *s, uintptr_t dest)
{ {
tcg_out_branch(s, 0, dest); tcg_out_branch(s, 0, dest);
} }
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
* int mmu_idx, uintptr_t ra) * int mmu_idx, uintptr_t ra)
*/ */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
helper_ret_ldb_mmu, helper_ret_ldub_mmu,
helper_ret_ldw_mmu, helper_ret_lduw_mmu,
helper_ret_ldl_mmu, helper_ret_ldul_mmu,
helper_ret_ldq_mmu, helper_ret_ldq_mmu,
}; };
@ -1086,33 +1082,46 @@ static inline void tcg_out_tlb_load(TCGContext *s, int addrlo_idx,
const int addrlo = args[addrlo_idx]; const int addrlo = args[addrlo_idx];
const int r0 = TCG_REG_L0; const int r0 = TCG_REG_L0;
const int r1 = TCG_REG_L1; const int r1 = TCG_REG_L1;
TCGType type = TCG_TYPE_I32; TCGType ttype = TCG_TYPE_I32;
int rexw = 0; TCGType htype = TCG_TYPE_I32;
int trexw = 0, hrexw = 0;
if (TCG_TARGET_REG_BITS == 64 && TARGET_LONG_BITS == 64) { if (TCG_TARGET_REG_BITS == 64) {
type = TCG_TYPE_I64; if (TARGET_LONG_BITS == 64) {
rexw = P_REXW; ttype = TCG_TYPE_I64;
trexw = P_REXW;
}
if (TCG_TYPE_PTR == TCG_TYPE_I64) {
htype = TCG_TYPE_I64;
hrexw = P_REXW;
}
} }
tcg_out_mov(s, type, r0, addrlo); tcg_out_mov(s, htype, r0, addrlo);
tcg_out_mov(s, type, r1, addrlo); tcg_out_mov(s, ttype, r1, addrlo);
tcg_out_shifti(s, SHIFT_SHR + rexw, r0, tcg_out_shifti(s, SHIFT_SHR + hrexw, r0,
TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS); TARGET_PAGE_BITS - CPU_TLB_ENTRY_BITS);
tgen_arithi(s, ARITH_AND + rexw, r1, tgen_arithi(s, ARITH_AND + trexw, r1,
TARGET_PAGE_MASK | ((1 << s_bits) - 1), 0); TARGET_PAGE_MASK | ((1 << s_bits) - 1), 0);
tgen_arithi(s, ARITH_AND + rexw, r0, tgen_arithi(s, ARITH_AND + hrexw, r0,
(CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS, 0); (CPU_TLB_SIZE - 1) << CPU_TLB_ENTRY_BITS, 0);
tcg_out_modrm_sib_offset(s, OPC_LEA + P_REXW, r0, TCG_AREG0, r0, 0, tcg_out_modrm_sib_offset(s, OPC_LEA + hrexw, r0, TCG_AREG0, r0, 0,
offsetof(CPUArchState, tlb_table[mem_index][0]) offsetof(CPUArchState, tlb_table[mem_index][0])
+ which); + which);
/* cmp 0(r0), r1 */ /* cmp 0(r0), r1 */
tcg_out_modrm_offset(s, OPC_CMP_GvEv + rexw, r1, r0, 0); tcg_out_modrm_offset(s, OPC_CMP_GvEv + trexw, r1, r0, 0);
tcg_out_mov(s, type, r1, addrlo); /* Prepare for both the fast path add of the tlb addend, and the slow
path function argument setup. There are two cases worth note:
For 32-bit guest and x86_64 host, MOVL zero-extends the guest address
before the fastpath ADDQ below. For 64-bit guest and x32 host, MOVQ
copies the entire guest address for the slow path, while truncation
for the 32-bit host happens with the fastpath ADDL below. */
tcg_out_mov(s, ttype, r1, addrlo);
/* jne slow_path */ /* jne slow_path */
tcg_out_opc(s, OPC_JCC_long + JCC_JNE, 0, 0, 0); tcg_out_opc(s, OPC_JCC_long + JCC_JNE, 0, 0, 0);
@ -1132,7 +1141,7 @@ static inline void tcg_out_tlb_load(TCGContext *s, int addrlo_idx,
/* TLB Hit. */ /* TLB Hit. */
/* add addend(r0), r1 */ /* add addend(r0), r1 */
tcg_out_modrm_offset(s, OPC_ADD_GvEv + P_REXW, r1, r0, tcg_out_modrm_offset(s, OPC_ADD_GvEv + hrexw, r1, r0,
offsetof(CPUTLBEntry, addend) - which); offsetof(CPUTLBEntry, addend) - which);
} }
#elif defined(__x86_64__) && defined(__linux__) #elif defined(__x86_64__) && defined(__linux__)
@ -1154,8 +1163,7 @@ static inline void setup_guest_base_seg(void) { }
#endif /* SOFTMMU */ #endif /* SOFTMMU */
static void tcg_out_qemu_ld_direct(TCGContext *s, int datalo, int datahi, static void tcg_out_qemu_ld_direct(TCGContext *s, int datalo, int datahi,
int base, tcg_target_long ofs, int seg, int base, intptr_t ofs, int seg, int sizeop)
int sizeop)
{ {
#ifdef TARGET_WORDS_BIGENDIAN #ifdef TARGET_WORDS_BIGENDIAN
const int bswap = 1; const int bswap = 1;
@ -1305,7 +1313,7 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args,
} }
static void tcg_out_qemu_st_direct(TCGContext *s, int datalo, int datahi, static void tcg_out_qemu_st_direct(TCGContext *s, int datalo, int datahi,
int base, tcg_target_long ofs, int seg, int base, intptr_t ofs, int seg,
int sizeop) int sizeop)
{ {
#ifdef TARGET_WORDS_BIGENDIAN #ifdef TARGET_WORDS_BIGENDIAN
@ -1470,12 +1478,6 @@ static void add_qemu_ldst_label(TCGContext *s,
} }
} }
/* See the GETPC definition in include/exec/exec-all.h. */
static inline uintptr_t do_getpc(uint8_t *raddr)
{
return (uintptr_t)raddr - 1;
}
/* /*
* Generate code for the slow path for a load at the end of block * Generate code for the slow path for a load at the end of block
*/ */
@ -1509,17 +1511,17 @@ static void tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, l->mem_index); tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, l->mem_index);
ofs += 4; ofs += 4;
tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, do_getpc(l->raddr)); tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, (uintptr_t)l->raddr);
} else { } else {
tcg_out_mov(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], TCG_AREG0); tcg_out_mov(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], TCG_AREG0);
/* The second argument is already loaded with addrlo. */ /* The second argument is already loaded with addrlo. */
tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2], tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2],
l->mem_index); l->mem_index);
tcg_out_movi(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[3], tcg_out_movi(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[3],
do_getpc(l->raddr)); (uintptr_t)l->raddr);
} }
tcg_out_calli(s, (tcg_target_long)qemu_ld_helpers[s_bits]); tcg_out_calli(s, (uintptr_t)qemu_ld_helpers[s_bits]);
data_reg = l->datalo_reg; data_reg = l->datalo_reg;
switch(opc) { switch(opc) {
@ -1529,20 +1531,17 @@ static void tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
case 1 | 4: case 1 | 4:
tcg_out_ext16s(s, data_reg, TCG_REG_EAX, P_REXW); tcg_out_ext16s(s, data_reg, TCG_REG_EAX, P_REXW);
break; break;
case 0:
tcg_out_ext8u(s, data_reg, TCG_REG_EAX);
break;
case 1:
tcg_out_ext16u(s, data_reg, TCG_REG_EAX);
break;
case 2:
tcg_out_mov(s, TCG_TYPE_I32, data_reg, TCG_REG_EAX);
break;
#if TCG_TARGET_REG_BITS == 64 #if TCG_TARGET_REG_BITS == 64
case 2 | 4: case 2 | 4:
tcg_out_ext32s(s, data_reg, TCG_REG_EAX); tcg_out_ext32s(s, data_reg, TCG_REG_EAX);
break; break;
#endif #endif
case 0:
case 1:
/* Note that the helpers have zero-extended to tcg_target_long. */
case 2:
tcg_out_mov(s, TCG_TYPE_I32, data_reg, TCG_REG_EAX);
break;
case 3: case 3:
if (TCG_TARGET_REG_BITS == 64) { if (TCG_TARGET_REG_BITS == 64) {
tcg_out_mov(s, TCG_TYPE_I64, data_reg, TCG_REG_RAX); tcg_out_mov(s, TCG_TYPE_I64, data_reg, TCG_REG_RAX);
@ -1560,7 +1559,7 @@ static void tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
} }
/* Jump to the code corresponding to next IR of qemu_st */ /* Jump to the code corresponding to next IR of qemu_st */
tcg_out_jmp(s, (tcg_target_long)l->raddr); tcg_out_jmp(s, (uintptr_t)l->raddr);
} }
/* /*
@ -1571,6 +1570,7 @@ static void tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
int opc = l->opc; int opc = l->opc;
int s_bits = opc & 3; int s_bits = opc & 3;
uint8_t **label_ptr = &l->label_ptr[0]; uint8_t **label_ptr = &l->label_ptr[0];
TCGReg retaddr;
/* resolve label address */ /* resolve label address */
*(uint32_t *)label_ptr[0] = (uint32_t)(s->code_ptr - label_ptr[0] - 4); *(uint32_t *)label_ptr[0] = (uint32_t)(s->code_ptr - label_ptr[0] - 4);
@ -1603,10 +1603,10 @@ static void tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, l->mem_index); tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, l->mem_index);
ofs += 4; ofs += 4;
tcg_out_sti(s, TCG_TYPE_I32, TCG_REG_ESP, ofs, do_getpc(l->raddr)); retaddr = TCG_REG_EAX;
tcg_out_movi(s, TCG_TYPE_I32, retaddr, (uintptr_t)l->raddr);
tcg_out_st(s, TCG_TYPE_I32, retaddr, TCG_REG_ESP, ofs);
} else { } else {
uintptr_t pc;
tcg_out_mov(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], TCG_AREG0); tcg_out_mov(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[0], TCG_AREG0);
/* The second argument is already loaded with addrlo. */ /* The second argument is already loaded with addrlo. */
tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32), tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),
@ -1614,20 +1614,19 @@ static void tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[3], tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[3],
l->mem_index); l->mem_index);
pc = do_getpc(l->raddr);
if (ARRAY_SIZE(tcg_target_call_iarg_regs) > 4) { if (ARRAY_SIZE(tcg_target_call_iarg_regs) > 4) {
tcg_out_movi(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[4], pc); retaddr = tcg_target_call_iarg_regs[4];
} else if (pc == (int32_t)pc) { tcg_out_movi(s, TCG_TYPE_PTR, retaddr, (uintptr_t)l->raddr);
tcg_out_sti(s, TCG_TYPE_PTR, TCG_REG_ESP, 0, pc);
} else { } else {
tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_RAX, pc); retaddr = TCG_REG_RAX;
tcg_out_st(s, TCG_TYPE_PTR, TCG_REG_RAX, TCG_REG_ESP, 0); tcg_out_movi(s, TCG_TYPE_PTR, retaddr, (uintptr_t)l->raddr);
tcg_out_st(s, TCG_TYPE_PTR, retaddr, TCG_REG_ESP, 0);
} }
} }
tcg_out_calli(s, (tcg_target_long)qemu_st_helpers[s_bits]); /* "Tail call" to the helper, with the return address back inline. */
tcg_out_push(s, retaddr);
tcg_out_jmp(s, (tcg_target_long)l->raddr); tcg_out_jmp(s, (uintptr_t)qemu_st_helpers[s_bits]);
} }
/* /*
@ -1668,7 +1667,7 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
switch(opc) { switch(opc) {
case INDEX_op_exit_tb: case INDEX_op_exit_tb:
tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_EAX, args[0]); tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_EAX, args[0]);
tcg_out_jmp(s, (tcg_target_long) tb_ret_addr); tcg_out_jmp(s, (uintptr_t)tb_ret_addr);
break; break;
case INDEX_op_goto_tb: case INDEX_op_goto_tb:
if (s->tb_jmp_offset) { if (s->tb_jmp_offset) {
@ -1679,7 +1678,7 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
} else { } else {
/* indirect jump method */ /* indirect jump method */
tcg_out_modrm_offset(s, OPC_GRP5, EXT5_JMPN_Ev, -1, tcg_out_modrm_offset(s, OPC_GRP5, EXT5_JMPN_Ev, -1,
(tcg_target_long)(s->tb_next + args[0])); (intptr_t)(s->tb_next + args[0]));
} }
s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf; s->tb_next_offset[args[0]] = s->code_ptr - s->code_buf;
break; break;
@ -2372,7 +2371,7 @@ static DebugFrame debug_frame = {
#if defined(ELF_HOST_MACHINE) #if defined(ELF_HOST_MACHINE)
void tcg_register_jit(void *buf, size_t buf_size) void tcg_register_jit(void *buf, size_t buf_size)
{ {
debug_frame.fde.func_start = (tcg_target_long) buf; debug_frame.fde.func_start = (uintptr_t)buf;
debug_frame.fde.func_len = buf_size; debug_frame.fde.func_len = buf_size;
tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame)); tcg_register_jit_int(buf, buf_size, &debug_frame, sizeof(debug_frame));

13
tcg/i386/tcg-target.h
View File

@ -24,11 +24,13 @@
#ifndef TCG_TARGET_I386 #ifndef TCG_TARGET_I386
#define TCG_TARGET_I386 1 #define TCG_TARGET_I386 1
//#define TCG_TARGET_WORDS_BIGENDIAN #undef TCG_TARGET_WORDS_BIGENDIAN
#if TCG_TARGET_REG_BITS == 64 #ifdef __x86_64__
# define TCG_TARGET_REG_BITS 64
# define TCG_TARGET_NB_REGS 16 # define TCG_TARGET_NB_REGS 16
#else #else
# define TCG_TARGET_REG_BITS 32
# define TCG_TARGET_NB_REGS 8 # define TCG_TARGET_NB_REGS 8
#endif #endif
@ -96,6 +98,8 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i32 1 #define TCG_TARGET_HAS_sub2_i32 1
#define TCG_TARGET_HAS_mulu2_i32 1 #define TCG_TARGET_HAS_mulu2_i32 1
#define TCG_TARGET_HAS_muls2_i32 1 #define TCG_TARGET_HAS_muls2_i32 1
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#if TCG_TARGET_REG_BITS == 64 #if TCG_TARGET_REG_BITS == 64
#define TCG_TARGET_HAS_div2_i64 1 #define TCG_TARGET_HAS_div2_i64 1
@ -122,6 +126,8 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i64 1 #define TCG_TARGET_HAS_sub2_i64 1
#define TCG_TARGET_HAS_mulu2_i64 1 #define TCG_TARGET_HAS_mulu2_i64 1
#define TCG_TARGET_HAS_muls2_i64 1 #define TCG_TARGET_HAS_muls2_i64 1
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
#endif #endif
#define TCG_TARGET_deposit_i32_valid(ofs, len) \ #define TCG_TARGET_deposit_i32_valid(ofs, len) \
@ -135,8 +141,7 @@ typedef enum {
# define TCG_AREG0 TCG_REG_EBP # define TCG_AREG0 TCG_REG_EBP
#endif #endif
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
} }

21
tcg/ia64/tcg-target.c
View File

@ -668,16 +668,16 @@ static inline uint64_t tcg_opc_x3(int qp, uint64_t opc, uint64_t imm)
* Relocations * Relocations
*/ */
static inline void reloc_pcrel21b (void *pc, tcg_target_long target) static inline void reloc_pcrel21b(void *pc, intptr_t target)
{ {
uint64_t imm; uint64_t imm;
int64_t disp; int64_t disp;
int slot; int slot;
slot = (tcg_target_long) pc & 3; slot = (intptr_t)pc & 3;
pc = (void *)((tcg_target_long) pc & ~3); pc = (void *)((intptr_t)pc & ~3);
disp = target - (tcg_target_long) pc; disp = target - (intptr_t)pc;
imm = (uint64_t) disp >> 4; imm = (uint64_t) disp >> 4;
switch(slot) { switch(slot) {
@ -728,12 +728,12 @@ static inline uint64_t get_reloc_pcrel21b (void *pc)
} }
} }
static inline void reloc_pcrel60b (void *pc, tcg_target_long target) static inline void reloc_pcrel60b(void *pc, intptr_t target)
{ {
int64_t disp; int64_t disp;
uint64_t imm; uint64_t imm;
disp = target - (tcg_target_long) pc; disp = target - (intptr_t)pc;
imm = (uint64_t) disp >> 4; imm = (uint64_t) disp >> 4;
*(uint64_t *)(pc + 8) = (*(uint64_t *)(pc + 8) & 0xf700000fff800000ull) *(uint64_t *)(pc + 8) = (*(uint64_t *)(pc + 8) & 0xf700000fff800000ull)
@ -759,7 +759,7 @@ static inline uint64_t get_reloc_pcrel60b (void *pc)
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
switch (type) { switch (type) {
@ -993,7 +993,7 @@ static inline void tcg_out_st_rel(TCGContext *s, uint64_t opc_m4, TCGArg arg,
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {
tcg_out_ld_rel(s, OPC_LD4_M1, arg, arg1, arg2); tcg_out_ld_rel(s, OPC_LD4_M1, arg, arg1, arg2);
@ -1003,7 +1003,7 @@ static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {
tcg_out_st_rel(s, OPC_ST4_M4, arg, arg1, arg2); tcg_out_st_rel(s, OPC_ST4_M4, arg, arg1, arg2);
@ -1490,9 +1490,6 @@ static inline void tcg_out_movcond(TCGContext *s, TCGCond cond, TCGArg ret,
} }
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* Load and compare a TLB entry, and return the result in (p6, p7). /* Load and compare a TLB entry, and return the result in (p6, p7).
R2 is loaded with the address of the addend TLB entry. R2 is loaded with the address of the addend TLB entry.
R57 is loaded with the address, zero extented on 32-bit targets. */ R57 is loaded with the address, zero extented on 32-bit targets. */

7
tcg/ia64/tcg-target.h
View File

@ -146,6 +146,10 @@ typedef enum {
#define TCG_TARGET_HAS_mulu2_i64 0 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_TARGET_HAS_mulsh_i64 0
#define TCG_TARGET_deposit_i32_valid(ofs, len) ((len) <= 16) #define TCG_TARGET_deposit_i32_valid(ofs, len) ((len) <= 16)
#define TCG_TARGET_deposit_i64_valid(ofs, len) ((len) <= 16) #define TCG_TARGET_deposit_i64_valid(ofs, len) ((len) <= 16)
@ -158,8 +162,7 @@ typedef enum {
#define TCG_AREG0 TCG_REG_R7 #define TCG_AREG0 TCG_REG_R7
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
start = start & ~(32UL - 1UL); start = start & ~(32UL - 1UL);
stop = (stop + (32UL - 1UL)) & ~(32UL - 1UL); stop = (stop + (32UL - 1UL)) & ~(32UL - 1UL);

33
tcg/mips/tcg-target.c
View File

@ -108,33 +108,33 @@ static const TCGReg tcg_target_call_oarg_regs[2] = {
static uint8_t *tb_ret_addr; static uint8_t *tb_ret_addr;
static inline uint32_t reloc_lo16_val (void *pc, tcg_target_long target) static inline uint32_t reloc_lo16_val(void *pc, intptr_t target)
{ {
return target & 0xffff; return target & 0xffff;
} }
static inline void reloc_lo16 (void *pc, tcg_target_long target) static inline void reloc_lo16(void *pc, intptr_t target)
{ {
*(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff) *(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff)
| reloc_lo16_val(pc, target); | reloc_lo16_val(pc, target);
} }
static inline uint32_t reloc_hi16_val (void *pc, tcg_target_long target) static inline uint32_t reloc_hi16_val(void *pc, intptr_t target)
{ {
return (target >> 16) & 0xffff; return (target >> 16) & 0xffff;
} }
static inline void reloc_hi16 (void *pc, tcg_target_long target) static inline void reloc_hi16(void *pc, intptr_t target)
{ {
*(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff) *(uint32_t *) pc = (*(uint32_t *) pc & ~0xffff)
| reloc_hi16_val(pc, target); | reloc_hi16_val(pc, target);
} }
static inline uint32_t reloc_pc16_val (void *pc, tcg_target_long target) static inline uint32_t reloc_pc16_val(void *pc, intptr_t target)
{ {
int32_t disp; int32_t disp;
disp = target - (tcg_target_long) pc - 4; disp = target - (intptr_t)pc - 4;
if (disp != (disp << 14) >> 14) { if (disp != (disp << 14) >> 14) {
tcg_abort (); tcg_abort ();
} }
@ -157,14 +157,14 @@ static inline uint32_t reloc_26_val (void *pc, tcg_target_long target)
return (target >> 2) & 0x3ffffff; return (target >> 2) & 0x3ffffff;
} }
static inline void reloc_pc26 (void *pc, tcg_target_long target) static inline void reloc_pc26(void *pc, intptr_t target)
{ {
*(uint32_t *) pc = (*(uint32_t *) pc & ~0x3ffffff) *(uint32_t *) pc = (*(uint32_t *) pc & ~0x3ffffff)
| reloc_26_val(pc, target); | reloc_26_val(pc, target);
} }
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
switch(type) { switch(type) {
@ -514,13 +514,13 @@ static inline void tcg_out_ldst(TCGContext *s, int opc, TCGArg arg,
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, OPC_LW, arg, arg1, arg2); tcg_out_ldst(s, OPC_LW, arg, arg1, arg2);
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, OPC_SW, arg, arg1, arg2); tcg_out_ldst(s, OPC_SW, arg, arg1, arg2);
} }
@ -919,9 +919,6 @@ static void tcg_out_setcond2(TCGContext *s, TCGCond cond, TCGReg ret,
} }
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
@ -1423,6 +1420,14 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0); tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
tcg_out_opc_reg(s, OPC_MFHI, args[1], 0, 0); tcg_out_opc_reg(s, OPC_MFHI, args[1], 0, 0);
break; break;
case INDEX_op_mulsh_i32:
tcg_out_opc_reg(s, OPC_MULT, 0, args[1], args[2]);
tcg_out_opc_reg(s, OPC_MFHI, args[0], 0, 0);
break;
case INDEX_op_muluh_i32:
tcg_out_opc_reg(s, OPC_MULTU, 0, args[1], args[2]);
tcg_out_opc_reg(s, OPC_MFHI, args[0], 0, 0);
break;
case INDEX_op_div_i32: case INDEX_op_div_i32:
tcg_out_opc_reg(s, OPC_DIV, 0, args[1], args[2]); tcg_out_opc_reg(s, OPC_DIV, 0, args[1], args[2]);
tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0); tcg_out_opc_reg(s, OPC_MFLO, args[0], 0, 0);
@ -1601,6 +1606,8 @@ static const TCGTargetOpDef mips_op_defs[] = {
{ INDEX_op_mul_i32, { "r", "rZ", "rZ" } }, { INDEX_op_mul_i32, { "r", "rZ", "rZ" } },
{ INDEX_op_muls2_i32, { "r", "r", "rZ", "rZ" } }, { INDEX_op_muls2_i32, { "r", "r", "rZ", "rZ" } },
{ INDEX_op_mulu2_i32, { "r", "r", "rZ", "rZ" } }, { INDEX_op_mulu2_i32, { "r", "r", "rZ", "rZ" } },
{ INDEX_op_mulsh_i32, { "r", "rZ", "rZ" } },
{ INDEX_op_muluh_i32, { "r", "rZ", "rZ" } },
{ INDEX_op_div_i32, { "r", "rZ", "rZ" } }, { INDEX_op_div_i32, { "r", "rZ", "rZ" } },
{ INDEX_op_divu_i32, { "r", "rZ", "rZ" } }, { INDEX_op_divu_i32, { "r", "rZ", "rZ" } },
{ INDEX_op_rem_i32, { "r", "rZ", "rZ" } }, { INDEX_op_rem_i32, { "r", "rZ", "rZ" } },

5
tcg/mips/tcg-target.h
View File

@ -110,6 +110,8 @@ extern bool use_mips32r2_instructions;
#define TCG_TARGET_HAS_eqv_i32 0 #define TCG_TARGET_HAS_eqv_i32 0
#define TCG_TARGET_HAS_nand_i32 0 #define TCG_TARGET_HAS_nand_i32 0
#define TCG_TARGET_HAS_muls2_i32 1 #define TCG_TARGET_HAS_muls2_i32 1
#define TCG_TARGET_HAS_muluh_i32 1
#define TCG_TARGET_HAS_mulsh_i32 1
/* optional instructions detected at runtime */ /* optional instructions detected at runtime */
#define TCG_TARGET_HAS_movcond_i32 use_movnz_instructions #define TCG_TARGET_HAS_movcond_i32 use_movnz_instructions
@ -133,8 +135,7 @@ extern bool use_mips32r2_instructions;
#include <sys/cachectl.h> #include <sys/cachectl.h>
#endif #endif
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
cacheflush ((void *)start, stop-start, ICACHE); cacheflush ((void *)start, stop-start, ICACHE);
} }

43
tcg/optimize.c
View File

@ -198,6 +198,8 @@ static TCGOpcode op_to_mov(TCGOpcode op)
static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y) static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
{ {
uint64_t l64, h64;
switch (op) { switch (op) {
CASE_OP_32_64(add): CASE_OP_32_64(add):
return x + y; return x + y;
@ -290,6 +292,37 @@ static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
case INDEX_op_ext32u_i64: case INDEX_op_ext32u_i64:
return (uint32_t)x; return (uint32_t)x;
case INDEX_op_muluh_i32:
return ((uint64_t)(uint32_t)x * (uint32_t)y) >> 32;
case INDEX_op_mulsh_i32:
return ((int64_t)(int32_t)x * (int32_t)y) >> 32;
case INDEX_op_muluh_i64:
mulu64(&l64, &h64, x, y);
return h64;
case INDEX_op_mulsh_i64:
muls64(&l64, &h64, x, y);
return h64;
case INDEX_op_div_i32:
/* Avoid crashing on divide by zero, otherwise undefined. */
return (int32_t)x / ((int32_t)y ? : 1);
case INDEX_op_divu_i32:
return (uint32_t)x / ((uint32_t)y ? : 1);
case INDEX_op_div_i64:
return (int64_t)x / ((int64_t)y ? : 1);
case INDEX_op_divu_i64:
return (uint64_t)x / ((uint64_t)y ? : 1);
case INDEX_op_rem_i32:
return (int32_t)x % ((int32_t)y ? : 1);
case INDEX_op_remu_i32:
return (uint32_t)x % ((uint32_t)y ? : 1);
case INDEX_op_rem_i64:
return (int64_t)x % ((int64_t)y ? : 1);
case INDEX_op_remu_i64:
return (uint64_t)x % ((uint64_t)y ? : 1);
default: default:
fprintf(stderr, fprintf(stderr,
"Unrecognized operation %d in do_constant_folding.\n", op); "Unrecognized operation %d in do_constant_folding.\n", op);
@ -531,6 +564,8 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
CASE_OP_32_64(eqv): CASE_OP_32_64(eqv):
CASE_OP_32_64(nand): CASE_OP_32_64(nand):
CASE_OP_32_64(nor): CASE_OP_32_64(nor):
CASE_OP_32_64(muluh):
CASE_OP_32_64(mulsh):
swap_commutative(args[0], &args[1], &args[2]); swap_commutative(args[0], &args[1], &args[2]);
break; break;
CASE_OP_32_64(brcond): CASE_OP_32_64(brcond):
@ -771,6 +806,8 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
switch (op) { switch (op) {
CASE_OP_32_64(and): CASE_OP_32_64(and):
CASE_OP_32_64(mul): CASE_OP_32_64(mul):
CASE_OP_32_64(muluh):
CASE_OP_32_64(mulsh):
if ((temps[args[2]].state == TCG_TEMP_CONST if ((temps[args[2]].state == TCG_TEMP_CONST
&& temps[args[2]].val == 0)) { && temps[args[2]].val == 0)) {
s->gen_opc_buf[op_index] = op_to_movi(op); s->gen_opc_buf[op_index] = op_to_movi(op);
@ -882,6 +919,12 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
CASE_OP_32_64(eqv): CASE_OP_32_64(eqv):
CASE_OP_32_64(nand): CASE_OP_32_64(nand):
CASE_OP_32_64(nor): CASE_OP_32_64(nor):
CASE_OP_32_64(muluh):
CASE_OP_32_64(mulsh):
CASE_OP_32_64(div):
CASE_OP_32_64(divu):
CASE_OP_32_64(rem):
CASE_OP_32_64(remu):
if (temps[args[1]].state == TCG_TEMP_CONST if (temps[args[1]].state == TCG_TEMP_CONST
&& temps[args[2]].state == TCG_TEMP_CONST) { && temps[args[2]].state == TCG_TEMP_CONST) {
s->gen_opc_buf[op_index] = op_to_movi(op); s->gen_opc_buf[op_index] = op_to_movi(op);

12
tcg/ppc/tcg-target.c
View File

@ -204,7 +204,7 @@ static void reloc_pc14 (void *pc, tcg_target_long target)
} }
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
switch (type) { switch (type) {
@ -549,8 +549,6 @@ static void add_qemu_ldst_label (TCGContext *s,
label->label_ptr[0] = label_ptr; label->label_ptr[0] = label_ptr;
} }
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
@ -1062,14 +1060,14 @@ static void tcg_target_qemu_prologue (TCGContext *s)
#endif #endif
} }
static void tcg_out_ld (TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
tcg_out_ldst (s, ret, arg1, arg2, LWZ, LWZX); tcg_out_ldst (s, ret, arg1, arg2, LWZ, LWZX);
} }
static void tcg_out_st (TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
tcg_out_ldst (s, arg, arg1, arg2, STW, STWX); tcg_out_ldst (s, arg, arg1, arg2, STW, STWX);
} }

4
tcg/ppc/tcg-target.h
View File

@ -96,11 +96,13 @@ typedef enum {
#define TCG_TARGET_HAS_deposit_i32 1 #define TCG_TARGET_HAS_deposit_i32 1
#define TCG_TARGET_HAS_movcond_i32 1 #define TCG_TARGET_HAS_movcond_i32 1
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_AREG0 TCG_REG_R27 #define TCG_AREG0 TCG_REG_R27
#define tcg_qemu_tb_exec(env, tb_ptr) \ #define tcg_qemu_tb_exec(env, tb_ptr) \
((long __attribute__ ((longcall)) \ ((uintptr_t __attribute__ ((longcall)) \
(*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr) (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr)
#endif #endif

45
tcg/ppc64/tcg-target.c
View File

@ -208,7 +208,7 @@ static void reloc_pc14 (void *pc, tcg_target_long target)
} }
static void patch_reloc (uint8_t *code_ptr, int type, static void patch_reloc (uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
value += addend; value += addend;
switch (type) { switch (type) {
@ -750,9 +750,6 @@ static void tcg_out_ldsta(TCGContext *s, TCGReg ret, TCGReg addr,
} }
#if defined (CONFIG_SOFTMMU) #if defined (CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
@ -1072,8 +1069,8 @@ static void tcg_target_qemu_prologue (TCGContext *s)
tcg_out32(s, BCLR | BO_ALWAYS); tcg_out32(s, BCLR | BO_ALWAYS);
} }
static void tcg_out_ld (TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
if (type == TCG_TYPE_I32) if (type == TCG_TYPE_I32)
tcg_out_ldst (s, ret, arg1, arg2, LWZ, LWZX); tcg_out_ldst (s, ret, arg1, arg2, LWZ, LWZX);
@ -1081,8 +1078,8 @@ static void tcg_out_ld (TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
tcg_out_ldsta (s, ret, arg1, arg2, LD, LDX); tcg_out_ldsta (s, ret, arg1, arg2, LD, LDX);
} }
static void tcg_out_st (TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
if (type == TCG_TYPE_I32) if (type == TCG_TYPE_I32)
tcg_out_ldst (s, arg, arg1, arg2, STW, STWX); tcg_out_ldst (s, arg, arg1, arg2, STW, STWX);
@ -1975,29 +1972,11 @@ static void tcg_out_op (TCGContext *s, TCGOpcode opc, const TCGArg *args,
} }
break; break;
case INDEX_op_mulu2_i64: case INDEX_op_muluh_i64:
case INDEX_op_muls2_i64: tcg_out32(s, MULHDU | TAB(args[0], args[1], args[2]));
{ break;
int oph = (opc == INDEX_op_mulu2_i64 ? MULHDU : MULHD); case INDEX_op_mulsh_i64:
TCGReg outl = args[0], outh = args[1]; tcg_out32(s, MULHD | TAB(args[0], args[1], args[2]));
a0 = args[2], a1 = args[3];
if (outl == a0 || outl == a1) {
if (outh == a0 || outh == a1) {
outl = TCG_REG_R0;
} else {
tcg_out32(s, oph | TAB(outh, a0, a1));
oph = 0;
}
}
tcg_out32(s, MULLD | TAB(outl, a0, a1));
if (oph != 0) {
tcg_out32(s, oph | TAB(outh, a0, a1));
}
if (outl != args[0]) {
tcg_out_mov(s, TCG_TYPE_I64, args[0], outl);
}
}
break; break;
default: default:
@ -2124,8 +2103,8 @@ static const TCGTargetOpDef ppc_op_defs[] = {
{ INDEX_op_add2_i64, { "r", "r", "r", "r", "rI", "rZM" } }, { INDEX_op_add2_i64, { "r", "r", "r", "r", "rI", "rZM" } },
{ INDEX_op_sub2_i64, { "r", "r", "rI", "r", "rZM", "r" } }, { INDEX_op_sub2_i64, { "r", "r", "rI", "r", "rZM", "r" } },
{ INDEX_op_muls2_i64, { "r", "r", "r", "r" } }, { INDEX_op_mulsh_i64, { "r", "r", "r" } },
{ INDEX_op_mulu2_i64, { "r", "r", "r", "r" } }, { INDEX_op_muluh_i64, { "r", "r", "r" } },
{ -1 }, { -1 },
}; };

8
tcg/ppc64/tcg-target.h
View File

@ -95,6 +95,8 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i32 0 #define TCG_TARGET_HAS_sub2_i32 0
#define TCG_TARGET_HAS_mulu2_i32 0 #define TCG_TARGET_HAS_mulu2_i32 0
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_TARGET_HAS_div_i64 1 #define TCG_TARGET_HAS_div_i64 1
#define TCG_TARGET_HAS_rem_i64 0 #define TCG_TARGET_HAS_rem_i64 0
@ -116,8 +118,10 @@ typedef enum {
#define TCG_TARGET_HAS_movcond_i64 1 #define TCG_TARGET_HAS_movcond_i64 1
#define TCG_TARGET_HAS_add2_i64 1 #define TCG_TARGET_HAS_add2_i64 1
#define TCG_TARGET_HAS_sub2_i64 1 #define TCG_TARGET_HAS_sub2_i64 1
#define TCG_TARGET_HAS_mulu2_i64 1 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muls2_i64 1 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i64 1
#define TCG_TARGET_HAS_mulsh_i64 1
#define TCG_AREG0 TCG_REG_R27 #define TCG_AREG0 TCG_REG_R27

13
tcg/s390/tcg-target.c
View File

@ -315,9 +315,6 @@ static const uint8_t tcg_cond_to_ltr_cond[] = {
}; };
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {
@ -351,10 +348,10 @@ static uint8_t *tb_ret_addr;
static uint64_t facilities; static uint64_t facilities;
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
tcg_target_long code_ptr_tl = (tcg_target_long)code_ptr; intptr_t code_ptr_tl = (intptr_t)code_ptr;
tcg_target_long pcrel2; intptr_t pcrel2;
/* ??? Not the usual definition of "addend". */ /* ??? Not the usual definition of "addend". */
pcrel2 = (value - (code_ptr_tl + addend)) >> 1; pcrel2 = (value - (code_ptr_tl + addend)) >> 1;
@ -771,7 +768,7 @@ static void tcg_out_mem(TCGContext *s, S390Opcode opc_rx, S390Opcode opc_rxy,
/* load data without address translation or endianness conversion */ /* load data without address translation or endianness conversion */
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data,
TCGReg base, tcg_target_long ofs) TCGReg base, intptr_t ofs)
{ {
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {
tcg_out_mem(s, RX_L, RXY_LY, data, base, TCG_REG_NONE, ofs); tcg_out_mem(s, RX_L, RXY_LY, data, base, TCG_REG_NONE, ofs);
@ -781,7 +778,7 @@ static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data,
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg data, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg data,
TCGReg base, tcg_target_long ofs) TCGReg base, intptr_t ofs)
{ {
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {
tcg_out_mem(s, RX_ST, RXY_STY, data, base, TCG_REG_NONE, ofs); tcg_out_mem(s, RX_ST, RXY_STY, data, base, TCG_REG_NONE, ofs);

7
tcg/s390/tcg-target.h
View File

@ -69,6 +69,8 @@ typedef enum TCGReg {
#define TCG_TARGET_HAS_sub2_i32 1 #define TCG_TARGET_HAS_sub2_i32 1
#define TCG_TARGET_HAS_mulu2_i32 0 #define TCG_TARGET_HAS_mulu2_i32 0
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#define TCG_TARGET_HAS_div2_i64 1 #define TCG_TARGET_HAS_div2_i64 1
#define TCG_TARGET_HAS_rot_i64 1 #define TCG_TARGET_HAS_rot_i64 1
@ -94,6 +96,8 @@ typedef enum TCGReg {
#define TCG_TARGET_HAS_sub2_i64 1 #define TCG_TARGET_HAS_sub2_i64 1
#define TCG_TARGET_HAS_mulu2_i64 1 #define TCG_TARGET_HAS_mulu2_i64 1
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
extern bool tcg_target_deposit_valid(int ofs, int len); extern bool tcg_target_deposit_valid(int ofs, int len);
#define TCG_TARGET_deposit_i32_valid tcg_target_deposit_valid #define TCG_TARGET_deposit_i32_valid tcg_target_deposit_valid
@ -110,8 +114,7 @@ enum {
TCG_AREG0 = TCG_REG_R10, TCG_AREG0 = TCG_REG_R10,
}; };
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
} }

12
tcg/sparc/tcg-target.c
View File

@ -252,7 +252,7 @@ static inline int check_fit_i32(uint32_t val, unsigned int bits)
} }
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
uint32_t insn; uint32_t insn;
value += addend; value += addend;
@ -264,7 +264,7 @@ static void patch_reloc(uint8_t *code_ptr, int type,
*(uint32_t *)code_ptr = value; *(uint32_t *)code_ptr = value;
break; break;
case R_SPARC_WDISP16: case R_SPARC_WDISP16:
value -= (long)code_ptr; value -= (intptr_t)code_ptr;
if (!check_fit_tl(value >> 2, 16)) { if (!check_fit_tl(value >> 2, 16)) {
tcg_abort(); tcg_abort();
} }
@ -274,7 +274,7 @@ static void patch_reloc(uint8_t *code_ptr, int type,
*(uint32_t *)code_ptr = insn; *(uint32_t *)code_ptr = insn;
break; break;
case R_SPARC_WDISP19: case R_SPARC_WDISP19:
value -= (long)code_ptr; value -= (intptr_t)code_ptr;
if (!check_fit_tl(value >> 2, 19)) { if (!check_fit_tl(value >> 2, 19)) {
tcg_abort(); tcg_abort();
} }
@ -436,13 +436,13 @@ static inline void tcg_out_ldst(TCGContext *s, int ret, int addr,
} }
static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, ret, arg1, arg2, (type == TCG_TYPE_I32 ? LDUW : LDX)); tcg_out_ldst(s, ret, arg1, arg2, (type == TCG_TYPE_I32 ? LDUW : LDX));
} }
static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg,
TCGReg arg1, tcg_target_long arg2) TCGReg arg1, intptr_t arg2)
{ {
tcg_out_ldst(s, arg, arg1, arg2, (type == TCG_TYPE_I32 ? STW : STX)); tcg_out_ldst(s, arg, arg1, arg2, (type == TCG_TYPE_I32 ? STW : STX));
} }
@ -831,8 +831,6 @@ static void tcg_target_qemu_prologue(TCGContext *s)
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
#include "exec/softmmu_defs.h"
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr, /* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
int mmu_idx) */ int mmu_idx) */
static const void * const qemu_ld_helpers[4] = { static const void * const qemu_ld_helpers[4] = {

24
tcg/sparc/tcg-target.h
View File

@ -24,6 +24,14 @@
#ifndef TCG_TARGET_SPARC #ifndef TCG_TARGET_SPARC
#define TCG_TARGET_SPARC 1 #define TCG_TARGET_SPARC 1
#if UINTPTR_MAX == UINT32_MAX
# define TCG_TARGET_REG_BITS 32
#elif UINTPTR_MAX == UINT64_MAX
# define TCG_TARGET_REG_BITS 64
#else
# error Unknown pointer size for tcg target
#endif
#define TCG_TARGET_WORDS_BIGENDIAN #define TCG_TARGET_WORDS_BIGENDIAN
#define TCG_TARGET_NB_REGS 32 #define TCG_TARGET_NB_REGS 32
@ -107,6 +115,8 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i32 1 #define TCG_TARGET_HAS_sub2_i32 1
#define TCG_TARGET_HAS_mulu2_i32 1 #define TCG_TARGET_HAS_mulu2_i32 1
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#if TCG_TARGET_REG_BITS == 64 #if TCG_TARGET_REG_BITS == 64
#define TCG_TARGET_HAS_div_i64 1 #define TCG_TARGET_HAS_div_i64 1
@ -134,20 +144,18 @@ typedef enum {
#define TCG_TARGET_HAS_sub2_i64 0 #define TCG_TARGET_HAS_sub2_i64 0
#define TCG_TARGET_HAS_mulu2_i64 0 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
#endif #endif
#define TCG_AREG0 TCG_REG_I0 #define TCG_AREG0 TCG_REG_I0
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
unsigned long p; uintptr_t p;
for (p = start & -8; p < (stop + 7) & -8; p += 8) {
p = start & ~(8UL - 1UL);
stop = (stop + (8UL - 1UL)) & ~(8UL - 1UL);
for (; p < stop; p += 8)
__asm__ __volatile__("flush\t%0" : : "r" (p)); __asm__ __volatile__("flush\t%0" : : "r" (p));
}
} }
#endif #endif

34
tcg/tcg-op.h
View File

@ -1039,10 +1039,18 @@ static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
t0 = tcg_temp_new_i64(); t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i32(); t1 = tcg_temp_new_i32();
if (TCG_TARGET_HAS_mulu2_i32) {
tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0), tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0),
TCGV_LOW(arg1), TCGV_LOW(arg2)); TCGV_LOW(arg1), TCGV_LOW(arg2));
/* Allow the optimizer room to replace mulu2 with two moves. */ /* Allow the optimizer room to replace mulu2 with two moves. */
tcg_gen_op0(INDEX_op_nop); tcg_gen_op0(INDEX_op_nop);
} else {
tcg_debug_assert(TCG_TARGET_HAS_muluh_i32);
tcg_gen_op3_i32(INDEX_op_mul_i32, TCGV_LOW(t0),
TCGV_LOW(arg1), TCGV_LOW(arg2));
tcg_gen_op3_i32(INDEX_op_muluh_i32, TCGV_HIGH(t0),
TCGV_LOW(arg1), TCGV_LOW(arg2));
}
tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2)); tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2));
tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1); tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
@ -2401,6 +2409,12 @@ static inline void tcg_gen_mulu2_i32(TCGv_i32 rl, TCGv_i32 rh,
tcg_gen_op4_i32(INDEX_op_mulu2_i32, rl, rh, arg1, arg2); tcg_gen_op4_i32(INDEX_op_mulu2_i32, rl, rh, arg1, arg2);
/* Allow the optimizer room to replace mulu2 with two moves. */ /* Allow the optimizer room to replace mulu2 with two moves. */
tcg_gen_op0(INDEX_op_nop); tcg_gen_op0(INDEX_op_nop);
} else if (TCG_TARGET_HAS_muluh_i32) {
TCGv_i32 t = tcg_temp_new_i32();
tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2);
tcg_gen_op3_i32(INDEX_op_muluh_i32, rh, arg1, arg2);
tcg_gen_mov_i32(rl, t);
tcg_temp_free_i32(t);
} else { } else {
TCGv_i64 t0 = tcg_temp_new_i64(); TCGv_i64 t0 = tcg_temp_new_i64();
TCGv_i64 t1 = tcg_temp_new_i64(); TCGv_i64 t1 = tcg_temp_new_i64();
@ -2420,6 +2434,12 @@ static inline void tcg_gen_muls2_i32(TCGv_i32 rl, TCGv_i32 rh,
tcg_gen_op4_i32(INDEX_op_muls2_i32, rl, rh, arg1, arg2); tcg_gen_op4_i32(INDEX_op_muls2_i32, rl, rh, arg1, arg2);
/* Allow the optimizer room to replace muls2 with two moves. */ /* Allow the optimizer room to replace muls2 with two moves. */
tcg_gen_op0(INDEX_op_nop); tcg_gen_op0(INDEX_op_nop);
} else if (TCG_TARGET_HAS_mulsh_i32) {
TCGv_i32 t = tcg_temp_new_i32();
tcg_gen_op3_i32(INDEX_op_mul_i32, t, arg1, arg2);
tcg_gen_op3_i32(INDEX_op_mulsh_i32, rh, arg1, arg2);
tcg_gen_mov_i32(rl, t);
tcg_temp_free_i32(t);
} else if (TCG_TARGET_REG_BITS == 32 && TCG_TARGET_HAS_mulu2_i32) { } else if (TCG_TARGET_REG_BITS == 32 && TCG_TARGET_HAS_mulu2_i32) {
TCGv_i32 t0 = tcg_temp_new_i32(); TCGv_i32 t0 = tcg_temp_new_i32();
TCGv_i32 t1 = tcg_temp_new_i32(); TCGv_i32 t1 = tcg_temp_new_i32();
@ -2499,6 +2519,12 @@ static inline void tcg_gen_mulu2_i64(TCGv_i64 rl, TCGv_i64 rh,
tcg_gen_op4_i64(INDEX_op_mulu2_i64, rl, rh, arg1, arg2); tcg_gen_op4_i64(INDEX_op_mulu2_i64, rl, rh, arg1, arg2);
/* Allow the optimizer room to replace mulu2 with two moves. */ /* Allow the optimizer room to replace mulu2 with two moves. */
tcg_gen_op0(INDEX_op_nop); tcg_gen_op0(INDEX_op_nop);
} else if (TCG_TARGET_HAS_muluh_i64) {
TCGv_i64 t = tcg_temp_new_i64();
tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2);
tcg_gen_op3_i64(INDEX_op_muluh_i64, rh, arg1, arg2);
tcg_gen_mov_i64(rl, t);
tcg_temp_free_i64(t);
} else if (TCG_TARGET_HAS_mulu2_i64) { } else if (TCG_TARGET_HAS_mulu2_i64) {
TCGv_i64 t0 = tcg_temp_new_i64(); TCGv_i64 t0 = tcg_temp_new_i64();
TCGv_i64 t1 = tcg_temp_new_i64(); TCGv_i64 t1 = tcg_temp_new_i64();
@ -2540,6 +2566,12 @@ static inline void tcg_gen_muls2_i64(TCGv_i64 rl, TCGv_i64 rh,
tcg_gen_op4_i64(INDEX_op_muls2_i64, rl, rh, arg1, arg2); tcg_gen_op4_i64(INDEX_op_muls2_i64, rl, rh, arg1, arg2);
/* Allow the optimizer room to replace muls2 with two moves. */ /* Allow the optimizer room to replace muls2 with two moves. */
tcg_gen_op0(INDEX_op_nop); tcg_gen_op0(INDEX_op_nop);
} else if (TCG_TARGET_HAS_mulsh_i64) {
TCGv_i64 t = tcg_temp_new_i64();
tcg_gen_op3_i64(INDEX_op_mul_i64, t, arg1, arg2);
tcg_gen_op3_i64(INDEX_op_mulsh_i64, rh, arg1, arg2);
tcg_gen_mov_i64(rl, t);
tcg_temp_free_i64(t);
} else { } else {
TCGv_i64 t0 = tcg_temp_new_i64(); TCGv_i64 t0 = tcg_temp_new_i64();
int sizemask = 0; int sizemask = 0;
@ -2599,7 +2631,7 @@ static inline void tcg_gen_debug_insn_start(uint64_t pc)
#endif #endif
} }
static inline void tcg_gen_exit_tb(tcg_target_long val) static inline void tcg_gen_exit_tb(uintptr_t val)
{ {
tcg_gen_op1i(INDEX_op_exit_tb, val); tcg_gen_op1i(INDEX_op_exit_tb, val);
} }

4
tcg/tcg-opc.h
View File

@ -91,6 +91,8 @@ DEF(add2_i32, 2, 4, 0, IMPL(TCG_TARGET_HAS_add2_i32))
DEF(sub2_i32, 2, 4, 0, IMPL(TCG_TARGET_HAS_sub2_i32)) DEF(sub2_i32, 2, 4, 0, IMPL(TCG_TARGET_HAS_sub2_i32))
DEF(mulu2_i32, 2, 2, 0, IMPL(TCG_TARGET_HAS_mulu2_i32)) DEF(mulu2_i32, 2, 2, 0, IMPL(TCG_TARGET_HAS_mulu2_i32))
DEF(muls2_i32, 2, 2, 0, IMPL(TCG_TARGET_HAS_muls2_i32)) DEF(muls2_i32, 2, 2, 0, IMPL(TCG_TARGET_HAS_muls2_i32))
DEF(muluh_i32, 1, 2, 0, IMPL(TCG_TARGET_HAS_muluh_i32))
DEF(mulsh_i32, 1, 2, 0, IMPL(TCG_TARGET_HAS_mulsh_i32))
DEF(brcond2_i32, 0, 4, 2, TCG_OPF_BB_END | IMPL(TCG_TARGET_REG_BITS == 32)) DEF(brcond2_i32, 0, 4, 2, TCG_OPF_BB_END | IMPL(TCG_TARGET_REG_BITS == 32))
DEF(setcond2_i32, 1, 4, 1, IMPL(TCG_TARGET_REG_BITS == 32)) DEF(setcond2_i32, 1, 4, 1, IMPL(TCG_TARGET_REG_BITS == 32))
@ -167,6 +169,8 @@ DEF(add2_i64, 2, 4, 0, IMPL64 | IMPL(TCG_TARGET_HAS_add2_i64))
DEF(sub2_i64, 2, 4, 0, IMPL64 | IMPL(TCG_TARGET_HAS_sub2_i64)) DEF(sub2_i64, 2, 4, 0, IMPL64 | IMPL(TCG_TARGET_HAS_sub2_i64))
DEF(mulu2_i64, 2, 2, 0, IMPL64 | IMPL(TCG_TARGET_HAS_mulu2_i64)) DEF(mulu2_i64, 2, 2, 0, IMPL64 | IMPL(TCG_TARGET_HAS_mulu2_i64))
DEF(muls2_i64, 2, 2, 0, IMPL64 | IMPL(TCG_TARGET_HAS_muls2_i64)) DEF(muls2_i64, 2, 2, 0, IMPL64 | IMPL(TCG_TARGET_HAS_muls2_i64))
DEF(muluh_i64, 1, 2, 0, IMPL(TCG_TARGET_HAS_muluh_i64))
DEF(mulsh_i64, 1, 2, 0, IMPL(TCG_TARGET_HAS_mulsh_i64))
/* QEMU specific */ /* QEMU specific */
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS #if TARGET_LONG_BITS > TCG_TARGET_REG_BITS

92
tcg/tcg.c
View File

@ -49,10 +49,10 @@
#include "tcg-op.h" #include "tcg-op.h"
#if TCG_TARGET_REG_BITS == 64 #if UINTPTR_MAX == UINT32_MAX
# define ELF_CLASS ELFCLASS64
#else
# define ELF_CLASS ELFCLASS32 # define ELF_CLASS ELFCLASS32
#else
# define ELF_CLASS ELFCLASS64
#endif #endif
#ifdef HOST_WORDS_BIGENDIAN #ifdef HOST_WORDS_BIGENDIAN
# define ELF_DATA ELFDATA2MSB # define ELF_DATA ELFDATA2MSB
@ -66,7 +66,7 @@
static void tcg_target_init(TCGContext *s); static void tcg_target_init(TCGContext *s);
static void tcg_target_qemu_prologue(TCGContext *s); static void tcg_target_qemu_prologue(TCGContext *s);
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend); intptr_t value, intptr_t addend);
/* The CIE and FDE header definitions will be common to all hosts. */ /* The CIE and FDE header definitions will be common to all hosts. */
typedef struct { typedef struct {
@ -82,8 +82,8 @@ typedef struct {
typedef struct QEMU_PACKED { typedef struct QEMU_PACKED {
uint32_t len __attribute__((aligned((sizeof(void *))))); uint32_t len __attribute__((aligned((sizeof(void *)))));
uint32_t cie_offset; uint32_t cie_offset;
tcg_target_long func_start; uintptr_t func_start;
tcg_target_long func_len; uintptr_t func_len;
} DebugFrameFDEHeader; } DebugFrameFDEHeader;
static void tcg_register_jit_int(void *buf, size_t size, static void tcg_register_jit_int(void *buf, size_t size,
@ -93,14 +93,14 @@ static void tcg_register_jit_int(void *buf, size_t size,
/* Forward declarations for functions declared and used in tcg-target.c. */ /* Forward declarations for functions declared and used in tcg-target.c. */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str);
static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
tcg_target_long arg2); intptr_t arg2);
static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg); static void tcg_out_mov(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg);
static void tcg_out_movi(TCGContext *s, TCGType type, static void tcg_out_movi(TCGContext *s, TCGType type,
TCGReg ret, tcg_target_long arg); TCGReg ret, tcg_target_long arg);
static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args, static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
const int *const_args); const int *const_args);
static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
tcg_target_long arg2); intptr_t arg2);
static int tcg_target_const_match(tcg_target_long val, static int tcg_target_const_match(tcg_target_long val,
const TCGArgConstraint *arg_ct); const TCGArgConstraint *arg_ct);
@ -143,7 +143,7 @@ static inline void tcg_out64(TCGContext *s, uint64_t v)
/* label relocation processing */ /* label relocation processing */
static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type, static void tcg_out_reloc(TCGContext *s, uint8_t *code_ptr, int type,
int label_index, long addend) int label_index, intptr_t addend)
{ {
TCGLabel *l; TCGLabel *l;
TCGRelocation *r; TCGRelocation *r;
@ -169,11 +169,12 @@ static void tcg_out_label(TCGContext *s, int label_index, void *ptr)
{ {
TCGLabel *l; TCGLabel *l;
TCGRelocation *r; TCGRelocation *r;
tcg_target_long value = (tcg_target_long)ptr; intptr_t value = (intptr_t)ptr;
l = &s->labels[label_index]; l = &s->labels[label_index];
if (l->has_value) if (l->has_value) {
tcg_abort(); tcg_abort();
}
r = l->u.first_reloc; r = l->u.first_reloc;
while (r != NULL) { while (r != NULL) {
patch_reloc(r->ptr, r->type, value, r->addend); patch_reloc(r->ptr, r->type, value, r->addend);
@ -293,8 +294,7 @@ void tcg_prologue_init(TCGContext *s)
s->code_buf = s->code_gen_prologue; s->code_buf = s->code_gen_prologue;
s->code_ptr = s->code_buf; s->code_ptr = s->code_buf;
tcg_target_qemu_prologue(s); tcg_target_qemu_prologue(s);
flush_icache_range((tcg_target_ulong)s->code_buf, flush_icache_range((uintptr_t)s->code_buf, (uintptr_t)s->code_ptr);
(tcg_target_ulong)s->code_ptr);
#ifdef DEBUG_DISAS #ifdef DEBUG_DISAS
if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) { if (qemu_loglevel_mask(CPU_LOG_TB_OUT_ASM)) {
@ -307,8 +307,7 @@ void tcg_prologue_init(TCGContext *s)
#endif #endif
} }
void tcg_set_frame(TCGContext *s, int reg, void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size)
tcg_target_long start, tcg_target_long size)
{ {
s->frame_start = start; s->frame_start = start;
s->frame_end = start + size; s->frame_end = start + size;
@ -391,7 +390,7 @@ TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)
} }
static inline int tcg_global_mem_new_internal(TCGType type, int reg, static inline int tcg_global_mem_new_internal(TCGType type, int reg,
tcg_target_long offset, intptr_t offset,
const char *name) const char *name)
{ {
TCGContext *s = &tcg_ctx; TCGContext *s = &tcg_ctx;
@ -451,21 +450,15 @@ static inline int tcg_global_mem_new_internal(TCGType type, int reg,
return idx; return idx;
} }
TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name)
const char *name)
{ {
int idx; int idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
idx = tcg_global_mem_new_internal(TCG_TYPE_I32, reg, offset, name);
return MAKE_TCGV_I32(idx); return MAKE_TCGV_I32(idx);
} }
TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name)
const char *name)
{ {
int idx; int idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
idx = tcg_global_mem_new_internal(TCG_TYPE_I64, reg, offset, name);
return MAKE_TCGV_I64(idx); return MAKE_TCGV_I64(idx);
} }
@ -641,7 +634,7 @@ void tcg_register_helper(void *func, const char *name)
s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo)); s->helpers = realloc(s->helpers, n * sizeof(TCGHelperInfo));
s->allocated_helpers = n; s->allocated_helpers = n;
} }
s->helpers[s->nb_helpers].func = (tcg_target_ulong)func; s->helpers[s->nb_helpers].func = (uintptr_t)func;
s->helpers[s->nb_helpers].name = name; s->helpers[s->nb_helpers].name = name;
s->nb_helpers++; s->nb_helpers++;
} }
@ -871,11 +864,11 @@ static int helper_cmp(const void *p1, const void *p2)
} }
/* find helper definition (Note: A hash table would be better) */ /* find helper definition (Note: A hash table would be better) */
static TCGHelperInfo *tcg_find_helper(TCGContext *s, tcg_target_ulong val) static TCGHelperInfo *tcg_find_helper(TCGContext *s, uintptr_t val)
{ {
int m, m_min, m_max; int m, m_min, m_max;
TCGHelperInfo *th; TCGHelperInfo *th;
tcg_target_ulong v; uintptr_t v;
if (unlikely(!s->helpers_sorted)) { if (unlikely(!s->helpers_sorted)) {
qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo), qsort(s->helpers, s->nb_helpers, sizeof(TCGHelperInfo),
@ -1252,12 +1245,13 @@ static inline void tcg_la_bb_end(TCGContext *s, uint8_t *dead_temps,
static void tcg_liveness_analysis(TCGContext *s) static void tcg_liveness_analysis(TCGContext *s)
{ {
int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops; int i, op_index, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
TCGOpcode op, op_new; TCGOpcode op, op_new, op_new2;
TCGArg *args; TCGArg *args;
const TCGOpDef *def; const TCGOpDef *def;
uint8_t *dead_temps, *mem_temps; uint8_t *dead_temps, *mem_temps;
uint16_t dead_args; uint16_t dead_args;
uint8_t sync_args; uint8_t sync_args;
bool have_op_new2;
s->gen_opc_ptr++; /* skip end */ s->gen_opc_ptr++; /* skip end */
@ -1394,29 +1388,52 @@ static void tcg_liveness_analysis(TCGContext *s)
goto do_not_remove; goto do_not_remove;
case INDEX_op_mulu2_i32: case INDEX_op_mulu2_i32:
op_new = INDEX_op_mul_i32;
op_new2 = INDEX_op_muluh_i32;
have_op_new2 = TCG_TARGET_HAS_muluh_i32;
goto do_mul2;
case INDEX_op_muls2_i32: case INDEX_op_muls2_i32:
op_new = INDEX_op_mul_i32; op_new = INDEX_op_mul_i32;
op_new2 = INDEX_op_mulsh_i32;
have_op_new2 = TCG_TARGET_HAS_mulsh_i32;
goto do_mul2; goto do_mul2;
case INDEX_op_mulu2_i64: case INDEX_op_mulu2_i64:
op_new = INDEX_op_mul_i64;
op_new2 = INDEX_op_muluh_i64;
have_op_new2 = TCG_TARGET_HAS_muluh_i64;
goto do_mul2;
case INDEX_op_muls2_i64: case INDEX_op_muls2_i64:
op_new = INDEX_op_mul_i64; op_new = INDEX_op_mul_i64;
op_new2 = INDEX_op_mulsh_i64;
have_op_new2 = TCG_TARGET_HAS_mulsh_i64;
goto do_mul2;
do_mul2: do_mul2:
args -= 4; args -= 4;
nb_iargs = 2; nb_iargs = 2;
nb_oargs = 2; nb_oargs = 2;
/* Likewise, test for the high part of the operation dead. */
if (dead_temps[args[1]] && !mem_temps[args[1]]) { if (dead_temps[args[1]] && !mem_temps[args[1]]) {
if (dead_temps[args[0]] && !mem_temps[args[0]]) { if (dead_temps[args[0]] && !mem_temps[args[0]]) {
/* Both parts of the operation are dead. */
goto do_remove; goto do_remove;
} }
/* The high part of the operation is dead; generate the low. */
s->gen_opc_buf[op_index] = op = op_new; s->gen_opc_buf[op_index] = op = op_new;
args[1] = args[2]; args[1] = args[2];
args[2] = args[3]; args[2] = args[3];
} else if (have_op_new2 && dead_temps[args[0]]
&& !mem_temps[args[0]]) {
/* The low part of the operation is dead; generate the high. */
s->gen_opc_buf[op_index] = op = op_new2;
args[0] = args[1];
args[1] = args[2];
args[2] = args[3];
} else {
goto do_not_remove;
}
assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop); assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1); tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1);
/* Fall through and mark the single-word operation live. */ /* Mark the single-word operation live. */
nb_oargs = 1; nb_oargs = 1;
}
goto do_not_remove; goto do_not_remove;
default: default:
@ -1590,7 +1607,7 @@ static void temp_allocate_frame(TCGContext *s, int temp)
ts->mem_offset = s->current_frame_offset; ts->mem_offset = s->current_frame_offset;
ts->mem_reg = s->frame_reg; ts->mem_reg = s->frame_reg;
ts->mem_allocated = 1; ts->mem_allocated = 1;
s->current_frame_offset += (tcg_target_long)sizeof(tcg_target_long); s->current_frame_offset += sizeof(tcg_target_long);
} }
/* sync register 'reg' by saving it to the corresponding temporary */ /* sync register 'reg' by saving it to the corresponding temporary */
@ -2053,7 +2070,9 @@ static int tcg_reg_alloc_call(TCGContext *s, const TCGOpDef *def,
int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params; int nb_iargs, nb_oargs, flags, nb_regs, i, reg, nb_params;
TCGArg arg, func_arg; TCGArg arg, func_arg;
TCGTemp *ts; TCGTemp *ts;
tcg_target_long stack_offset, call_stack_size, func_addr; intptr_t stack_offset;
size_t call_stack_size;
uintptr_t func_addr;
int const_func_arg, allocate_args; int const_func_arg, allocate_args;
TCGRegSet allocated_regs; TCGRegSet allocated_regs;
const TCGArgConstraint *arg_ct; const TCGArgConstraint *arg_ct;
@ -2391,8 +2410,7 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
tcg_gen_code_common(s, gen_code_buf, -1); tcg_gen_code_common(s, gen_code_buf, -1);
/* flush instruction cache */ /* flush instruction cache */
flush_icache_range((tcg_target_ulong)gen_code_buf, flush_icache_range((uintptr_t)gen_code_buf, (uintptr_t)s->code_ptr);
(tcg_target_ulong)s->code_ptr);
return s->code_ptr - gen_code_buf; return s->code_ptr - gen_code_buf;
} }

108
tcg/tcg.h
View File

@ -21,15 +21,23 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#ifndef TCG_H
#define TCG_H
#include "qemu-common.h" #include "qemu-common.h"
/* Target word size (must be identical to pointer size). */ #include "tcg-target.h"
#if UINTPTR_MAX == UINT32_MAX
/* Default target word size to pointer size. */
#ifndef TCG_TARGET_REG_BITS
# if UINTPTR_MAX == UINT32_MAX
# define TCG_TARGET_REG_BITS 32 # define TCG_TARGET_REG_BITS 32
#elif UINTPTR_MAX == UINT64_MAX # elif UINTPTR_MAX == UINT64_MAX
# define TCG_TARGET_REG_BITS 64 # define TCG_TARGET_REG_BITS 64
#else # else
# error Unknown pointer size for tcg target # error Unknown pointer size for tcg target
# endif
#endif #endif
#if TCG_TARGET_REG_BITS == 32 #if TCG_TARGET_REG_BITS == 32
@ -46,7 +54,6 @@ typedef uint64_t tcg_target_ulong;
#error unsupported #error unsupported
#endif #endif
#include "tcg-target.h"
#include "tcg-runtime.h" #include "tcg-runtime.h"
#if TCG_TARGET_NB_REGS <= 32 #if TCG_TARGET_NB_REGS <= 32
@ -85,6 +92,8 @@ typedef uint64_t TCGRegSet;
#define TCG_TARGET_HAS_sub2_i64 0 #define TCG_TARGET_HAS_sub2_i64 0
#define TCG_TARGET_HAS_mulu2_i64 0 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
/* Turn some undef macros into true macros. */ /* Turn some undef macros into true macros. */
#define TCG_TARGET_HAS_add2_i32 1 #define TCG_TARGET_HAS_add2_i32 1
#define TCG_TARGET_HAS_sub2_i32 1 #define TCG_TARGET_HAS_sub2_i32 1
@ -134,13 +143,13 @@ typedef struct TCGRelocation {
struct TCGRelocation *next; struct TCGRelocation *next;
int type; int type;
uint8_t *ptr; uint8_t *ptr;
tcg_target_long addend; intptr_t addend;
} TCGRelocation; } TCGRelocation;
typedef struct TCGLabel { typedef struct TCGLabel {
int has_value; int has_value;
union { union {
tcg_target_ulong value; uintptr_t value;
TCGRelocation *first_reloc; TCGRelocation *first_reloc;
} u; } u;
} TCGLabel; } TCGLabel;
@ -173,9 +182,12 @@ typedef enum TCGType {
TCG_TYPE_REG = TCG_TYPE_I64, TCG_TYPE_REG = TCG_TYPE_I64,
#endif #endif
/* An alias for the size of the native pointer. We don't currently /* An alias for the size of the native pointer. */
support any hosts with 64-bit registers and 32-bit pointers. */ #if UINTPTR_MAX == UINT32_MAX
TCG_TYPE_PTR = TCG_TYPE_REG, TCG_TYPE_PTR = TCG_TYPE_I32,
#else
TCG_TYPE_PTR = TCG_TYPE_I64,
#endif
/* An alias for the size of the target "long", aka register. */ /* An alias for the size of the target "long", aka register. */
#if TARGET_LONG_BITS == 64 #if TARGET_LONG_BITS == 64
@ -380,7 +392,7 @@ typedef struct TCGTemp {
int reg; int reg;
tcg_target_long val; tcg_target_long val;
int mem_reg; int mem_reg;
tcg_target_long mem_offset; intptr_t mem_offset;
unsigned int fixed_reg:1; unsigned int fixed_reg:1;
unsigned int mem_coherent:1; unsigned int mem_coherent:1;
unsigned int mem_allocated:1; unsigned int mem_allocated:1;
@ -394,7 +406,7 @@ typedef struct TCGTemp {
} TCGTemp; } TCGTemp;
typedef struct TCGHelperInfo { typedef struct TCGHelperInfo {
tcg_target_ulong func; uintptr_t func;
const char *name; const char *name;
} TCGHelperInfo; } TCGHelperInfo;
@ -427,9 +439,9 @@ struct TCGContext {
into account fixed registers */ into account fixed registers */
int reg_to_temp[TCG_TARGET_NB_REGS]; int reg_to_temp[TCG_TARGET_NB_REGS];
TCGRegSet reserved_regs; TCGRegSet reserved_regs;
tcg_target_long current_frame_offset; intptr_t current_frame_offset;
tcg_target_long frame_start; intptr_t frame_start;
tcg_target_long frame_end; intptr_t frame_end;
int frame_reg; int frame_reg;
uint8_t *code_ptr; uint8_t *code_ptr;
@ -522,12 +534,10 @@ void tcg_func_start(TCGContext *s);
int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf); int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf);
int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset); int tcg_gen_code_search_pc(TCGContext *s, uint8_t *gen_code_buf, long offset);
void tcg_set_frame(TCGContext *s, int reg, void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size);
tcg_target_long start, tcg_target_long size);
TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name); TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name);
TCGv_i32 tcg_global_mem_new_i32(int reg, tcg_target_long offset, TCGv_i32 tcg_global_mem_new_i32(int reg, intptr_t offset, const char *name);
const char *name);
TCGv_i32 tcg_temp_new_internal_i32(int temp_local); TCGv_i32 tcg_temp_new_internal_i32(int temp_local);
static inline TCGv_i32 tcg_temp_new_i32(void) static inline TCGv_i32 tcg_temp_new_i32(void)
{ {
@ -541,8 +551,7 @@ void tcg_temp_free_i32(TCGv_i32 arg);
char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg); char *tcg_get_arg_str_i32(TCGContext *s, char *buf, int buf_size, TCGv_i32 arg);
TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name); TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name);
TCGv_i64 tcg_global_mem_new_i64(int reg, tcg_target_long offset, TCGv_i64 tcg_global_mem_new_i64(int reg, intptr_t offset, const char *name);
const char *name);
TCGv_i64 tcg_temp_new_internal_i64(int temp_local); TCGv_i64 tcg_temp_new_internal_i64(int temp_local);
static inline TCGv_i64 tcg_temp_new_i64(void) static inline TCGv_i64 tcg_temp_new_i64(void)
{ {
@ -637,11 +646,11 @@ do {\
void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs); void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
#if TCG_TARGET_REG_BITS == 32 #if UINTPTR_MAX == UINT32_MAX
#define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n)) #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I32(n))
#define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n)) #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I32(GET_TCGV_PTR(n))
#define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((tcg_target_long)(V))) #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i32((intptr_t)(V)))
#define tcg_global_reg_new_ptr(R, N) \ #define tcg_global_reg_new_ptr(R, N) \
TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N))) TCGV_NAT_TO_PTR(tcg_global_reg_new_i32((R), (N)))
#define tcg_global_mem_new_ptr(R, O, N) \ #define tcg_global_mem_new_ptr(R, O, N) \
@ -652,7 +661,7 @@ void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);
#define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n)) #define TCGV_NAT_TO_PTR(n) MAKE_TCGV_PTR(GET_TCGV_I64(n))
#define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n)) #define TCGV_PTR_TO_NAT(n) MAKE_TCGV_I64(GET_TCGV_PTR(n))
#define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((tcg_target_long)(V))) #define tcg_const_ptr(V) TCGV_NAT_TO_PTR(tcg_const_i64((intptr_t)(V)))
#define tcg_global_reg_new_ptr(R, N) \ #define tcg_global_reg_new_ptr(R, N) \
TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N))) TCGV_NAT_TO_PTR(tcg_global_reg_new_i64((R), (N)))
#define tcg_global_mem_new_ptr(R, O, N) \ #define tcg_global_mem_new_ptr(R, O, N) \
@ -731,8 +740,7 @@ TCGv_i64 tcg_const_local_i64(int64_t val);
#if !defined(tcg_qemu_tb_exec) #if !defined(tcg_qemu_tb_exec)
# define tcg_qemu_tb_exec(env, tb_ptr) \ # define tcg_qemu_tb_exec(env, tb_ptr) \
((tcg_target_ulong (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, \ ((uintptr_t (*)(void *, void *))tcg_ctx.code_gen_prologue)(env, tb_ptr)
tb_ptr)
#endif #endif
void tcg_register_jit(void *buf, size_t buf_size); void tcg_register_jit(void *buf, size_t buf_size);
@ -741,3 +749,51 @@ void tcg_register_jit(void *buf, size_t buf_size);
/* Generate TB finalization at the end of block */ /* Generate TB finalization at the end of block */
void tcg_out_tb_finalize(TCGContext *s); void tcg_out_tb_finalize(TCGContext *s);
#endif #endif
/*
* Memory helpers that will be used by TCG generated code.
*/
#ifdef CONFIG_SOFTMMU
/* Value zero-extended to tcg register size. */
tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
tcg_target_ulong helper_ret_lduw_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
tcg_target_ulong helper_ret_ldul_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
uint64_t helper_ret_ldq_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
/* Value sign-extended to tcg register size. */
tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
tcg_target_ulong helper_ret_ldsw_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
tcg_target_ulong helper_ret_ldsl_mmu(CPUArchState *env, target_ulong addr,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
int mmu_idx, uintptr_t retaddr);
void helper_ret_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
int mmu_idx, uintptr_t retaddr);
uint8_t helper_ldb_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint16_t helper_ldw_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint32_t helper_ldl_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
uint64_t helper_ldq_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
void helper_stb_mmu(CPUArchState *env, target_ulong addr,
uint8_t val, int mmu_idx);
void helper_stw_mmu(CPUArchState *env, target_ulong addr,
uint16_t val, int mmu_idx);
void helper_stl_mmu(CPUArchState *env, target_ulong addr,
uint32_t val, int mmu_idx);
void helper_stq_mmu(CPUArchState *env, target_ulong addr,
uint64_t val, int mmu_idx);
#endif /* CONFIG_SOFTMMU */
#endif /* TCG_H */

6
tcg/tci/tcg-target.c
View File

@ -370,7 +370,7 @@ static const char *const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
#endif #endif
static void patch_reloc(uint8_t *code_ptr, int type, static void patch_reloc(uint8_t *code_ptr, int type,
tcg_target_long value, tcg_target_long addend) intptr_t value, intptr_t addend)
{ {
/* tcg_out_reloc always uses the same type, addend. */ /* tcg_out_reloc always uses the same type, addend. */
assert(type == sizeof(tcg_target_long)); assert(type == sizeof(tcg_target_long));
@ -488,7 +488,7 @@ static void tci_out_label(TCGContext *s, TCGArg arg)
} }
static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1, static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg ret, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
uint8_t *old_code_ptr = s->code_ptr; uint8_t *old_code_ptr = s->code_ptr;
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {
@ -842,7 +842,7 @@ static void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,
} }
static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1, static void tcg_out_st(TCGContext *s, TCGType type, TCGReg arg, TCGReg arg1,
tcg_target_long arg2) intptr_t arg2)
{ {
uint8_t *old_code_ptr = s->code_ptr; uint8_t *old_code_ptr = s->code_ptr;
if (type == TCG_TYPE_I32) { if (type == TCG_TYPE_I32) {

18
tcg/tci/tcg-target.h
View File

@ -44,6 +44,14 @@
#define TCG_TARGET_INTERPRETER 1 #define TCG_TARGET_INTERPRETER 1
#if UINTPTR_MAX == UINT32_MAX
# define TCG_TARGET_REG_BITS 32
#elif UINTPTR_MAX == UINT64_MAX
# define TCG_TARGET_REG_BITS 64
#else
# error Unknown pointer size for tci target
#endif
#ifdef CONFIG_DEBUG_TCG #ifdef CONFIG_DEBUG_TCG
/* Enable debug output. */ /* Enable debug output. */
#define CONFIG_DEBUG_TCG_INTERPRETER #define CONFIG_DEBUG_TCG_INTERPRETER
@ -76,6 +84,8 @@
#define TCG_TARGET_HAS_rot_i32 1 #define TCG_TARGET_HAS_rot_i32 1
#define TCG_TARGET_HAS_movcond_i32 0 #define TCG_TARGET_HAS_movcond_i32 0
#define TCG_TARGET_HAS_muls2_i32 0 #define TCG_TARGET_HAS_muls2_i32 0
#define TCG_TARGET_HAS_muluh_i32 0
#define TCG_TARGET_HAS_mulsh_i32 0
#if TCG_TARGET_REG_BITS == 64 #if TCG_TARGET_REG_BITS == 64
#define TCG_TARGET_HAS_bswap16_i64 1 #define TCG_TARGET_HAS_bswap16_i64 1
@ -100,13 +110,14 @@
#define TCG_TARGET_HAS_rot_i64 1 #define TCG_TARGET_HAS_rot_i64 1
#define TCG_TARGET_HAS_movcond_i64 0 #define TCG_TARGET_HAS_movcond_i64 0
#define TCG_TARGET_HAS_muls2_i64 0 #define TCG_TARGET_HAS_muls2_i64 0
#define TCG_TARGET_HAS_add2_i32 0 #define TCG_TARGET_HAS_add2_i32 0
#define TCG_TARGET_HAS_sub2_i32 0 #define TCG_TARGET_HAS_sub2_i32 0
#define TCG_TARGET_HAS_mulu2_i32 0 #define TCG_TARGET_HAS_mulu2_i32 0
#define TCG_TARGET_HAS_add2_i64 0 #define TCG_TARGET_HAS_add2_i64 0
#define TCG_TARGET_HAS_sub2_i64 0 #define TCG_TARGET_HAS_sub2_i64 0
#define TCG_TARGET_HAS_mulu2_i64 0 #define TCG_TARGET_HAS_mulu2_i64 0
#define TCG_TARGET_HAS_muluh_i64 0
#define TCG_TARGET_HAS_mulsh_i64 0
#endif /* TCG_TARGET_REG_BITS == 64 */ #endif /* TCG_TARGET_REG_BITS == 64 */
/* Number of registers available. /* Number of registers available.
@ -166,11 +177,10 @@ typedef enum {
void tci_disas(uint8_t opc); void tci_disas(uint8_t opc);
tcg_target_ulong tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr); uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr);
#define tcg_qemu_tb_exec tcg_qemu_tb_exec #define tcg_qemu_tb_exec tcg_qemu_tb_exec
static inline void flush_icache_range(tcg_target_ulong start, static inline void flush_icache_range(uintptr_t start, uintptr_t stop)
tcg_target_ulong stop)
{ {
} }

4
tci.c
View File

@ -434,11 +434,11 @@ static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
} }
/* Interpret pseudo code in tb. */ /* Interpret pseudo code in tb. */
tcg_target_ulong tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr) uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr)
{ {
long tcg_temps[CPU_TEMP_BUF_NLONGS]; long tcg_temps[CPU_TEMP_BUF_NLONGS];
uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS); uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS);
tcg_target_ulong next_tb = 0; uintptr_t next_tb = 0;
tci_reg[TCG_AREG0] = (tcg_target_ulong)env; tci_reg[TCG_AREG0] = (tcg_target_ulong)env;
tci_reg[TCG_REG_CALL_STACK] = sp_value; tci_reg[TCG_REG_CALL_STACK] = sp_value;