2011-09-27 08:30:58 +04:00
|
|
|
/*
|
|
|
|
|
* Tiny Code Interpreter for QEMU
|
|
|
|
|
*
|
2016-04-05 23:24:51 +03:00
|
|
|
* Copyright (c) 2009, 2011, 2016 Stefan Weil
|
2011-09-27 08:30:58 +04:00
|
|
|
*
|
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-01-29 20:50:05 +03:00
|
|
|
#include "qemu/osdep.h"
|
2011-09-27 08:30:58 +04:00
|
|
|
|
2016-04-05 23:24:51 +03:00
|
|
|
/* Enable TCI assertions only when debugging TCG (and without NDEBUG defined).
|
|
|
|
|
* Without assertions, the interpreter runs much faster. */
|
|
|
|
|
#if defined(CONFIG_DEBUG_TCG)
|
|
|
|
|
# define tci_assert(cond) assert(cond)
|
|
|
|
|
#else
|
|
|
|
|
# define tci_assert(cond) ((void)0)
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include "qemu-common.h"
|
2016-05-20 14:57:31 +03:00
|
|
|
#include "tcg/tcg.h" /* MAX_OPC_PARAM_IARGS */
|
2014-03-28 22:42:10 +04:00
|
|
|
#include "exec/cpu_ldst.h"
|
2020-01-01 14:23:00 +03:00
|
|
|
#include "tcg/tcg-op.h"
|
cfi: Initial support for cfi-icall in QEMU
LLVM/Clang, supports runtime checks for forward-edge Control-Flow
Integrity (CFI).
CFI on indirect function calls (cfi-icall) ensures that, in indirect
function calls, the function called is of the right signature for the
pointer type defined at compile time.
For this check to work, the code must always respect the function
signature when using function pointer, the function must be defined
at compile time, and be compiled with link-time optimization.
This rules out, for example, shared libraries that are dynamically loaded
(given that functions are not known at compile time), and code that is
dynamically generated at run-time.
This patch:
1) Introduces the CONFIG_CFI flag to support cfi in QEMU
2) Introduces a decorator to allow the definition of "sensitive"
functions, where a non-instrumented function may be called at runtime
through a pointer. The decorator will take care of disabling cfi-icall
checks on such functions, when cfi is enabled.
3) Marks functions currently in QEMU that exhibit such behavior,
in particular:
- The function in TCG that calls pre-compiled TBs
- The function in TCI that interprets instructions
- Functions in the plugin infrastructures that jump to callbacks
- Functions in util that directly call a signal handler
Signed-off-by: Daniele Buono <dbuono@linux.vnet.ibm.com>
Acked-by: Alex Bennée <alex.bennee@linaro.org
Message-Id: <20201204230615.2392-3-dbuono@linux.vnet.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-12-05 02:06:12 +03:00
|
|
|
#include "qemu/compiler.h"
|
2011-09-27 08:30:58 +04:00
|
|
|
|
2017-12-14 01:52:57 +03:00
|
|
|
#if MAX_OPC_PARAM_IARGS != 6
|
2011-09-27 08:30:58 +04:00
|
|
|
# error Fix needed, number of supported input arguments changed!
|
|
|
|
|
#endif
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
|
2012-09-19 00:43:38 +04:00
|
|
|
tcg_target_ulong, tcg_target_ulong,
|
2011-09-27 08:30:58 +04:00
|
|
|
tcg_target_ulong, tcg_target_ulong,
|
|
|
|
|
tcg_target_ulong, tcg_target_ulong,
|
2017-12-14 01:52:57 +03:00
|
|
|
tcg_target_ulong, tcg_target_ulong,
|
2011-09-27 08:30:58 +04:00
|
|
|
tcg_target_ulong, tcg_target_ulong);
|
|
|
|
|
#else
|
|
|
|
|
typedef uint64_t (*helper_function)(tcg_target_ulong, tcg_target_ulong,
|
2012-09-19 00:43:38 +04:00
|
|
|
tcg_target_ulong, tcg_target_ulong,
|
2017-12-14 01:52:57 +03:00
|
|
|
tcg_target_ulong, tcg_target_ulong);
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
|
2021-01-24 23:57:01 +03:00
|
|
|
__thread uintptr_t tci_tb_ptr;
|
|
|
|
|
|
2017-07-14 00:10:31 +03:00
|
|
|
static tcg_target_ulong tci_read_reg(const tcg_target_ulong *regs, TCGReg index)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_assert(index < TCG_TARGET_NB_REGS);
|
|
|
|
|
return regs[index];
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
|
2017-07-14 00:10:31 +03:00
|
|
|
static void
|
|
|
|
|
tci_write_reg(tcg_target_ulong *regs, TCGReg index, tcg_target_ulong value)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_assert(index < TCG_TARGET_NB_REGS);
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(index != TCG_AREG0);
|
|
|
|
|
tci_assert(index != TCG_REG_CALL_STACK);
|
2017-07-14 00:10:31 +03:00
|
|
|
regs[index] = value;
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
2017-07-14 00:10:31 +03:00
|
|
|
static void tci_write_reg64(tcg_target_ulong *regs, uint32_t high_index,
|
|
|
|
|
uint32_t low_index, uint64_t value)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, low_index, value);
|
|
|
|
|
tci_write_reg(regs, high_index, value >> 32);
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
/* Create a 64 bit value from two 32 bit values. */
|
|
|
|
|
static uint64_t tci_uint64(uint32_t high, uint32_t low)
|
|
|
|
|
{
|
|
|
|
|
return ((uint64_t)high << 32) + low;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Read constant (native size) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static tcg_target_ulong tci_read_i(const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2020-11-01 01:18:58 +03:00
|
|
|
tcg_target_ulong value = *(const tcg_target_ulong *)(*tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*tb_ptr += sizeof(value);
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-28 09:37:51 +04:00
|
|
|
/* Read unsigned constant (32 bit) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static uint32_t tci_read_i32(const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2020-11-01 01:18:58 +03:00
|
|
|
uint32_t value = *(const uint32_t *)(*tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*tb_ptr += sizeof(value);
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-28 09:37:51 +04:00
|
|
|
/* Read signed constant (32 bit) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static int32_t tci_read_s32(const uint8_t **tb_ptr)
|
2013-03-28 09:37:51 +04:00
|
|
|
{
|
2020-11-01 01:18:58 +03:00
|
|
|
int32_t value = *(const int32_t *)(*tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
*tb_ptr += sizeof(value);
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 08:30:58 +04:00
|
|
|
#if TCG_TARGET_REG_BITS == 64
|
|
|
|
|
/* Read constant (64 bit) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static uint64_t tci_read_i64(const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2020-11-01 01:18:58 +03:00
|
|
|
uint64_t value = *(const uint64_t *)(*tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*tb_ptr += sizeof(value);
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Read indexed register (native size) from bytecode. */
|
2017-07-14 00:10:31 +03:00
|
|
|
static tcg_target_ulong
|
2020-11-01 01:18:58 +03:00
|
|
|
tci_read_r(const tcg_target_ulong *regs, const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2017-07-14 00:10:31 +03:00
|
|
|
tcg_target_ulong value = tci_read_reg(regs, **tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*tb_ptr += 1;
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
/* Read two indexed registers (2 * 32 bit) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static uint64_t tci_read_r64(const tcg_target_ulong *regs,
|
|
|
|
|
const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2021-01-30 00:28:43 +03:00
|
|
|
uint32_t low = tci_read_r(regs, tb_ptr);
|
|
|
|
|
return tci_uint64(tci_read_r(regs, tb_ptr), low);
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
#elif TCG_TARGET_REG_BITS == 64
|
|
|
|
|
/* Read indexed register (64 bit) from bytecode. */
|
2020-11-01 01:18:58 +03:00
|
|
|
static uint64_t tci_read_r64(const tcg_target_ulong *regs,
|
|
|
|
|
const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2021-01-30 00:50:07 +03:00
|
|
|
return tci_read_r(regs, tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Read indexed register(s) with target address from bytecode. */
|
2017-07-14 00:10:31 +03:00
|
|
|
static target_ulong
|
2020-11-01 01:18:58 +03:00
|
|
|
tci_read_ulong(const tcg_target_ulong *regs, const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2017-07-14 00:10:31 +03:00
|
|
|
target_ulong taddr = tci_read_r(regs, tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
|
2017-07-14 00:10:31 +03:00
|
|
|
taddr += (uint64_t)tci_read_r(regs, tb_ptr) << 32;
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
return taddr;
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-01 01:18:58 +03:00
|
|
|
static tcg_target_ulong tci_read_label(const uint8_t **tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2012-11-20 00:43:14 +04:00
|
|
|
tcg_target_ulong label = tci_read_i(tb_ptr);
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(label != 0);
|
2011-09-27 08:30:58 +04:00
|
|
|
return label;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool tci_compare32(uint32_t u0, uint32_t u1, TCGCond condition)
|
|
|
|
|
{
|
|
|
|
|
bool result = false;
|
|
|
|
|
int32_t i0 = u0;
|
|
|
|
|
int32_t i1 = u1;
|
|
|
|
|
switch (condition) {
|
|
|
|
|
case TCG_COND_EQ:
|
|
|
|
|
result = (u0 == u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_NE:
|
|
|
|
|
result = (u0 != u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LT:
|
|
|
|
|
result = (i0 < i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GE:
|
|
|
|
|
result = (i0 >= i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LE:
|
|
|
|
|
result = (i0 <= i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GT:
|
|
|
|
|
result = (i0 > i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LTU:
|
|
|
|
|
result = (u0 < u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GEU:
|
|
|
|
|
result = (u0 >= u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LEU:
|
|
|
|
|
result = (u0 <= u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GTU:
|
|
|
|
|
result = (u0 > u1);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
|
|
|
|
|
{
|
|
|
|
|
bool result = false;
|
|
|
|
|
int64_t i0 = u0;
|
|
|
|
|
int64_t i1 = u1;
|
|
|
|
|
switch (condition) {
|
|
|
|
|
case TCG_COND_EQ:
|
|
|
|
|
result = (u0 == u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_NE:
|
|
|
|
|
result = (u0 != u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LT:
|
|
|
|
|
result = (i0 < i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GE:
|
|
|
|
|
result = (i0 >= i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LE:
|
|
|
|
|
result = (i0 <= i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GT:
|
|
|
|
|
result = (i0 > i1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LTU:
|
|
|
|
|
result = (u0 < u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GEU:
|
|
|
|
|
result = (u0 >= u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_LEU:
|
|
|
|
|
result = (u0 <= u1);
|
|
|
|
|
break;
|
|
|
|
|
case TCG_COND_GTU:
|
|
|
|
|
result = (u0 > u1);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-17 21:30:27 +03:00
|
|
|
#define qemu_ld_ub \
|
|
|
|
|
cpu_ldub_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_leuw \
|
|
|
|
|
cpu_lduw_le_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_leul \
|
|
|
|
|
cpu_ldl_le_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_leq \
|
|
|
|
|
cpu_ldq_le_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_beuw \
|
|
|
|
|
cpu_lduw_be_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_beul \
|
|
|
|
|
cpu_ldl_be_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_ld_beq \
|
|
|
|
|
cpu_ldq_be_mmuidx_ra(env, taddr, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_b(X) \
|
|
|
|
|
cpu_stb_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_lew(X) \
|
|
|
|
|
cpu_stw_le_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_lel(X) \
|
|
|
|
|
cpu_stl_le_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_leq(X) \
|
|
|
|
|
cpu_stq_le_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_bew(X) \
|
|
|
|
|
cpu_stw_be_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_bel(X) \
|
|
|
|
|
cpu_stl_be_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
|
|
|
|
#define qemu_st_beq(X) \
|
|
|
|
|
cpu_stq_be_mmuidx_ra(env, taddr, X, get_mmuidx(oi), (uintptr_t)tb_ptr)
|
2014-05-27 07:59:16 +04:00
|
|
|
|
2021-01-28 08:37:55 +03:00
|
|
|
#if TCG_TARGET_REG_BITS == 64
|
|
|
|
|
# define CASE_32_64(x) \
|
|
|
|
|
case glue(glue(INDEX_op_, x), _i64): \
|
|
|
|
|
case glue(glue(INDEX_op_, x), _i32):
|
|
|
|
|
# define CASE_64(x) \
|
|
|
|
|
case glue(glue(INDEX_op_, x), _i64):
|
|
|
|
|
#else
|
|
|
|
|
# define CASE_32_64(x) \
|
|
|
|
|
case glue(glue(INDEX_op_, x), _i32):
|
|
|
|
|
# define CASE_64(x)
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-09-27 08:30:58 +04:00
|
|
|
/* Interpret pseudo code in tb. */
|
cfi: Initial support for cfi-icall in QEMU
LLVM/Clang, supports runtime checks for forward-edge Control-Flow
Integrity (CFI).
CFI on indirect function calls (cfi-icall) ensures that, in indirect
function calls, the function called is of the right signature for the
pointer type defined at compile time.
For this check to work, the code must always respect the function
signature when using function pointer, the function must be defined
at compile time, and be compiled with link-time optimization.
This rules out, for example, shared libraries that are dynamically loaded
(given that functions are not known at compile time), and code that is
dynamically generated at run-time.
This patch:
1) Introduces the CONFIG_CFI flag to support cfi in QEMU
2) Introduces a decorator to allow the definition of "sensitive"
functions, where a non-instrumented function may be called at runtime
through a pointer. The decorator will take care of disabling cfi-icall
checks on such functions, when cfi is enabled.
3) Marks functions currently in QEMU that exhibit such behavior,
in particular:
- The function in TCG that calls pre-compiled TBs
- The function in TCI that interprets instructions
- Functions in the plugin infrastructures that jump to callbacks
- Functions in util that directly call a signal handler
Signed-off-by: Daniele Buono <dbuono@linux.vnet.ibm.com>
Acked-by: Alex Bennée <alex.bennee@linaro.org
Message-Id: <20201204230615.2392-3-dbuono@linux.vnet.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-12-05 02:06:12 +03:00
|
|
|
/*
|
|
|
|
|
* Disable CFI checks.
|
|
|
|
|
* One possible operation in the pseudo code is a call to binary code.
|
|
|
|
|
* Therefore, disable CFI checks in the interpreter function
|
|
|
|
|
*/
|
2020-10-28 22:05:44 +03:00
|
|
|
uintptr_t QEMU_DISABLE_CFI tcg_qemu_tb_exec(CPUArchState *env,
|
|
|
|
|
const void *v_tb_ptr)
|
2011-09-27 08:30:58 +04:00
|
|
|
{
|
2020-11-01 01:18:58 +03:00
|
|
|
const uint8_t *tb_ptr = v_tb_ptr;
|
2017-07-14 00:10:31 +03:00
|
|
|
tcg_target_ulong regs[TCG_TARGET_NB_REGS];
|
2013-03-28 09:37:55 +04:00
|
|
|
long tcg_temps[CPU_TEMP_BUF_NLONGS];
|
|
|
|
|
uintptr_t sp_value = (uintptr_t)(tcg_temps + CPU_TEMP_BUF_NLONGS);
|
2016-04-21 15:58:23 +03:00
|
|
|
uintptr_t ret = 0;
|
2011-09-27 08:30:58 +04:00
|
|
|
|
2017-07-14 00:10:31 +03:00
|
|
|
regs[TCG_AREG0] = (tcg_target_ulong)env;
|
|
|
|
|
regs[TCG_REG_CALL_STACK] = sp_value;
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
TCGOpcode opc = tb_ptr[0];
|
2016-04-05 23:24:51 +03:00
|
|
|
#if defined(CONFIG_DEBUG_TCG) && !defined(NDEBUG)
|
2011-09-27 08:30:58 +04:00
|
|
|
uint8_t op_size = tb_ptr[1];
|
2020-11-01 01:18:58 +03:00
|
|
|
const uint8_t *old_code_ptr = tb_ptr;
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
tcg_target_ulong t0;
|
|
|
|
|
tcg_target_ulong t1;
|
|
|
|
|
tcg_target_ulong t2;
|
|
|
|
|
tcg_target_ulong label;
|
|
|
|
|
TCGCond condition;
|
|
|
|
|
target_ulong taddr;
|
|
|
|
|
uint8_t tmp8;
|
|
|
|
|
uint16_t tmp16;
|
|
|
|
|
uint32_t tmp32;
|
|
|
|
|
uint64_t tmp64;
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
uint64_t v64;
|
|
|
|
|
#endif
|
2015-05-12 21:51:44 +03:00
|
|
|
TCGMemOpIdx oi;
|
2011-09-27 08:30:58 +04:00
|
|
|
|
|
|
|
|
/* Skip opcode and size entry. */
|
|
|
|
|
tb_ptr += 2;
|
|
|
|
|
|
|
|
|
|
switch (opc) {
|
|
|
|
|
case INDEX_op_call:
|
2021-01-29 04:07:41 +03:00
|
|
|
t0 = tci_read_i(&tb_ptr);
|
2021-01-24 23:57:01 +03:00
|
|
|
tci_tb_ptr = (uintptr_t)tb_ptr;
|
2011-09-27 08:30:58 +04:00
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = ((helper_function)t0)(tci_read_reg(regs, TCG_REG_R0),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R1),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R2),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R3),
|
2021-01-29 03:55:57 +03:00
|
|
|
tci_read_reg(regs, TCG_REG_R4),
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_read_reg(regs, TCG_REG_R5),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R6),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R7),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R8),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R9),
|
2017-12-14 01:52:57 +03:00
|
|
|
tci_read_reg(regs, TCG_REG_R10),
|
2021-01-29 03:55:57 +03:00
|
|
|
tci_read_reg(regs, TCG_REG_R11));
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, TCG_REG_R0, tmp64);
|
|
|
|
|
tci_write_reg(regs, TCG_REG_R1, tmp64 >> 32);
|
2011-09-27 08:30:58 +04:00
|
|
|
#else
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = ((helper_function)t0)(tci_read_reg(regs, TCG_REG_R0),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R1),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R2),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R3),
|
2021-01-29 03:55:57 +03:00
|
|
|
tci_read_reg(regs, TCG_REG_R4),
|
|
|
|
|
tci_read_reg(regs, TCG_REG_R5));
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, TCG_REG_R0, tmp64);
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
case INDEX_op_br:
|
|
|
|
|
label = tci_read_label(&tb_ptr);
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
tb_ptr = (uint8_t *)label;
|
|
|
|
|
continue;
|
|
|
|
|
case INDEX_op_setcond_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, tci_compare32(t1, t2, condition));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
case INDEX_op_setcond2_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = tci_read_r64(regs, &tb_ptr);
|
2021-01-29 04:07:41 +03:00
|
|
|
v64 = tci_read_r64(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, tci_compare64(tmp64, v64, condition));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#elif TCG_TARGET_REG_BITS == 64
|
|
|
|
|
case INDEX_op_setcond_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, tci_compare64(t1, t2, condition));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:29:22 +03:00
|
|
|
CASE_32_64(mov)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2020-04-17 23:19:47 +03:00
|
|
|
case INDEX_op_tci_movi_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = tci_read_i32(&tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Load/store operations (32 bit). */
|
|
|
|
|
|
2021-01-28 08:37:55 +03:00
|
|
|
CASE_32_64(ld8u)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2021-01-28 08:23:55 +03:00
|
|
|
tci_write_reg(regs, t0, *(uint8_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-28 08:39:39 +03:00
|
|
|
CASE_32_64(ld8s)
|
|
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, *(int8_t *)(t1 + t2));
|
2019-04-10 22:48:38 +03:00
|
|
|
break;
|
2021-01-28 08:41:17 +03:00
|
|
|
CASE_32_64(ld16u)
|
|
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, *(uint16_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-28 08:42:42 +03:00
|
|
|
CASE_32_64(ld16s)
|
2021-01-28 05:48:14 +03:00
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, *(int16_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_ld_i32:
|
2021-01-28 08:44:01 +03:00
|
|
|
CASE_64(ld32u)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, *(uint32_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-28 08:47:02 +03:00
|
|
|
CASE_32_64(st8)
|
2021-01-30 00:21:08 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*(uint8_t *)(t1 + t2) = t0;
|
|
|
|
|
break;
|
2021-01-28 08:49:37 +03:00
|
|
|
CASE_32_64(st16)
|
2021-01-30 00:26:34 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*(uint16_t *)(t1 + t2) = t0;
|
|
|
|
|
break;
|
|
|
|
|
case INDEX_op_st_i32:
|
2021-01-28 08:53:59 +03:00
|
|
|
CASE_64(st32)
|
2021-01-30 00:28:43 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*(uint32_t *)(t1 + t2) = t0;
|
|
|
|
|
break;
|
|
|
|
|
|
2021-01-30 01:15:58 +03:00
|
|
|
/* Arithmetic operations (mixed 32/64 bit). */
|
2011-09-27 08:30:58 +04:00
|
|
|
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(add)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, t1 + t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(sub)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, t1 - t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(mul)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, t1 * t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(and)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, t1 & t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(or)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, t1 | t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
CASE_32_64(xor)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, t1 ^ t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
|
|
|
|
|
/* Arithmetic operations (32 bit). */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_div_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, (int32_t)t1 / (int32_t)t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
case INDEX_op_divu_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, (uint32_t)t1 / (uint32_t)t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
case INDEX_op_rem_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, (int32_t)t1 % (int32_t)t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2021-01-30 01:15:58 +03:00
|
|
|
case INDEX_op_remu_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-30 01:15:58 +03:00
|
|
|
tci_write_reg(regs, t0, (uint32_t)t1 % (uint32_t)t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Shift/rotate operations (32 bit). */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_shl_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (uint32_t)t1 << (t2 & 31));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_shr_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (uint32_t)t1 >> (t2 & 31));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_sar_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (int32_t)t1 >> (t2 & 31));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_HAS_rot_i32
|
|
|
|
|
case INDEX_op_rotl_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, rol32(t1, t2 & 31));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_rotr_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, ror32(t1, t2 & 31));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2012-09-19 00:52:14 +04:00
|
|
|
#endif
|
|
|
|
|
#if TCG_TARGET_HAS_deposit_i32
|
|
|
|
|
case INDEX_op_deposit_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2012-09-19 00:52:14 +04:00
|
|
|
tmp16 = *tb_ptr++;
|
|
|
|
|
tmp8 = *tb_ptr++;
|
|
|
|
|
tmp32 = (((1 << tmp8) - 1) << tmp16);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, (t1 & ~tmp32) | ((t2 << tmp16) & tmp32));
|
2012-09-19 00:52:14 +04:00
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
case INDEX_op_brcond_i32:
|
2021-01-30 00:28:43 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
|
|
|
|
label = tci_read_label(&tb_ptr);
|
|
|
|
|
if (tci_compare32(t0, t1, condition)) {
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
tb_ptr = (uint8_t *)label;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 32
|
|
|
|
|
case INDEX_op_add2_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = tci_read_r64(regs, &tb_ptr);
|
|
|
|
|
tmp64 += tci_read_r64(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg64(regs, t1, t0, tmp64);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_sub2_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = tci_read_r64(regs, &tb_ptr);
|
|
|
|
|
tmp64 -= tci_read_r64(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg64(regs, t1, t0, tmp64);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_brcond2_i32:
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = tci_read_r64(regs, &tb_ptr);
|
2021-01-29 04:07:41 +03:00
|
|
|
v64 = tci_read_r64(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
|
|
|
|
label = tci_read_label(&tb_ptr);
|
|
|
|
|
if (tci_compare64(tmp64, v64, condition)) {
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
tb_ptr = (uint8_t *)label;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case INDEX_op_mulu2_i32:
|
|
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tmp64 = (uint32_t)tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg64(regs, t1, t0, (uint32_t)t2 * tmp64);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif /* TCG_TARGET_REG_BITS == 32 */
|
2021-01-30 01:21:18 +03:00
|
|
|
#if TCG_TARGET_HAS_ext8s_i32 || TCG_TARGET_HAS_ext8s_i64
|
|
|
|
|
CASE_32_64(ext8s)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:24:01 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (int8_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:21:18 +03:00
|
|
|
#if TCG_TARGET_HAS_ext16s_i32 || TCG_TARGET_HAS_ext16s_i64
|
|
|
|
|
CASE_32_64(ext16s)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-02-07 23:26:41 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (int16_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:21:18 +03:00
|
|
|
#if TCG_TARGET_HAS_ext8u_i32 || TCG_TARGET_HAS_ext8u_i64
|
|
|
|
|
CASE_32_64(ext8u)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:21:08 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (uint8_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:21:18 +03:00
|
|
|
#if TCG_TARGET_HAS_ext16u_i32 || TCG_TARGET_HAS_ext16u_i64
|
|
|
|
|
CASE_32_64(ext16u)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:26:34 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (uint16_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:27:20 +03:00
|
|
|
#if TCG_TARGET_HAS_bswap16_i32 || TCG_TARGET_HAS_bswap16_i64
|
|
|
|
|
CASE_32_64(bswap16)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:26:34 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, bswap16(t1));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:27:20 +03:00
|
|
|
#if TCG_TARGET_HAS_bswap32_i32 || TCG_TARGET_HAS_bswap32_i64
|
|
|
|
|
CASE_32_64(bswap32)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, bswap32(t1));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:29:22 +03:00
|
|
|
#if TCG_TARGET_HAS_not_i32 || TCG_TARGET_HAS_not_i64
|
|
|
|
|
CASE_32_64(not)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, ~t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
2021-01-30 01:29:22 +03:00
|
|
|
#if TCG_TARGET_HAS_neg_i32 || TCG_TARGET_HAS_neg_i64
|
|
|
|
|
CASE_32_64(neg)
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:31:49 +03:00
|
|
|
tci_write_reg(regs, t0, -t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#if TCG_TARGET_REG_BITS == 64
|
2020-04-17 23:19:47 +03:00
|
|
|
case INDEX_op_tci_movi_i64:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
|
|
|
|
t1 = tci_read_i64(&tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Load/store operations (64 bit). */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_ld32s_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2021-01-28 08:21:10 +03:00
|
|
|
tci_write_reg(regs, t0, *(int32_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_ld_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, *(uint64_t *)(t1 + t2));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_st_i64:
|
2021-01-30 00:50:07 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
2017-07-14 00:10:31 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2013-03-28 09:37:51 +04:00
|
|
|
t2 = tci_read_s32(&tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
*(uint64_t *)(t1 + t2) = t0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Arithmetic operations (64 bit). */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_div_i64:
|
2021-01-28 09:30:00 +03:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 09:30:00 +03:00
|
|
|
tci_write_reg(regs, t0, (int64_t)t1 / (int64_t)t2);
|
|
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
case INDEX_op_divu_i64:
|
2021-01-28 09:30:00 +03:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 09:30:00 +03:00
|
|
|
tci_write_reg(regs, t0, (uint64_t)t1 / (uint64_t)t2);
|
|
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
case INDEX_op_rem_i64:
|
2021-01-28 09:30:00 +03:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 09:30:00 +03:00
|
|
|
tci_write_reg(regs, t0, (int64_t)t1 % (int64_t)t2);
|
|
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
case INDEX_op_remu_i64:
|
2021-01-28 09:30:00 +03:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 09:30:00 +03:00
|
|
|
tci_write_reg(regs, t0, (uint64_t)t1 % (uint64_t)t2);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Shift/rotate operations (64 bit). */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_shl_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, t1 << (t2 & 63));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_shr_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, t1 >> (t2 & 63));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
case INDEX_op_sar_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, ((int64_t)t1 >> (t2 & 63)));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_HAS_rot_i64
|
|
|
|
|
case INDEX_op_rotl_i64:
|
2013-09-12 23:13:11 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, rol64(t1, t2 & 63));
|
2013-09-12 23:13:11 +04:00
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
case INDEX_op_rotr_i64:
|
2013-09-12 23:13:11 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, ror64(t1, t2 & 63));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2012-09-19 00:52:14 +04:00
|
|
|
#endif
|
|
|
|
|
#if TCG_TARGET_HAS_deposit_i64
|
|
|
|
|
case INDEX_op_deposit_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t2 = tci_read_r(regs, &tb_ptr);
|
2012-09-19 00:52:14 +04:00
|
|
|
tmp16 = *tb_ptr++;
|
|
|
|
|
tmp8 = *tb_ptr++;
|
|
|
|
|
tmp64 = (((1ULL << tmp8) - 1) << tmp16);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, (t1 & ~tmp64) | ((t2 << tmp16) & tmp64));
|
2012-09-19 00:52:14 +04:00
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
#endif
|
|
|
|
|
case INDEX_op_brcond_i64:
|
2021-01-30 00:50:07 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2011-09-27 08:30:58 +04:00
|
|
|
condition = *tb_ptr++;
|
|
|
|
|
label = tci_read_label(&tb_ptr);
|
|
|
|
|
if (tci_compare64(t0, t1, condition)) {
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
tb_ptr = (uint8_t *)label;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_HAS_ext32s_i64
|
|
|
|
|
case INDEX_op_ext32s_i64:
|
2015-07-27 13:41:45 +03:00
|
|
|
#endif
|
|
|
|
|
case INDEX_op_ext_i32_i64:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:41:09 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (int32_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_HAS_ext32u_i64
|
|
|
|
|
case INDEX_op_ext32u_i64:
|
2015-07-27 13:41:45 +03:00
|
|
|
#endif
|
|
|
|
|
case INDEX_op_extu_i32_i64:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:28:43 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
tci_write_reg(regs, t0, (uint32_t)t1);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#if TCG_TARGET_HAS_bswap64_i64
|
|
|
|
|
case INDEX_op_bswap64_i64:
|
|
|
|
|
t0 = *tb_ptr++;
|
2021-01-30 00:50:07 +03:00
|
|
|
t1 = tci_read_r(regs, &tb_ptr);
|
2021-01-28 08:35:07 +03:00
|
|
|
tci_write_reg(regs, t0, bswap64(t1));
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#endif /* TCG_TARGET_REG_BITS == 64 */
|
|
|
|
|
|
|
|
|
|
/* QEMU specific operations. */
|
|
|
|
|
|
|
|
|
|
case INDEX_op_exit_tb:
|
2016-04-21 15:58:23 +03:00
|
|
|
ret = *(uint64_t *)tb_ptr;
|
2011-09-27 08:30:58 +04:00
|
|
|
goto exit;
|
|
|
|
|
break;
|
|
|
|
|
case INDEX_op_goto_tb:
|
2016-04-22 19:08:45 +03:00
|
|
|
/* Jump address is aligned */
|
|
|
|
|
tb_ptr = QEMU_ALIGN_PTR_UP(tb_ptr, 4);
|
2020-09-23 13:56:46 +03:00
|
|
|
t0 = qatomic_read((int32_t *)tb_ptr);
|
2016-04-22 19:08:45 +03:00
|
|
|
tb_ptr += sizeof(int32_t);
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
tb_ptr += (int32_t)t0;
|
|
|
|
|
continue;
|
2014-05-27 07:59:16 +04:00
|
|
|
case INDEX_op_qemu_ld_i32:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2017-07-14 00:10:31 +03:00
|
|
|
taddr = tci_read_ulong(regs, &tb_ptr);
|
2015-05-12 21:51:44 +03:00
|
|
|
oi = tci_read_i(&tb_ptr);
|
2015-05-29 19:16:51 +03:00
|
|
|
switch (get_memop(oi) & (MO_BSWAP | MO_SSIZE)) {
|
2014-05-27 07:59:16 +04:00
|
|
|
case MO_UB:
|
|
|
|
|
tmp32 = qemu_ld_ub;
|
|
|
|
|
break;
|
|
|
|
|
case MO_SB:
|
|
|
|
|
tmp32 = (int8_t)qemu_ld_ub;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUW:
|
|
|
|
|
tmp32 = qemu_ld_leuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LESW:
|
|
|
|
|
tmp32 = (int16_t)qemu_ld_leuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUL:
|
|
|
|
|
tmp32 = qemu_ld_leul;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUW:
|
|
|
|
|
tmp32 = qemu_ld_beuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BESW:
|
|
|
|
|
tmp32 = (int16_t)qemu_ld_beuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUL:
|
|
|
|
|
tmp32 = qemu_ld_beul;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2014-05-27 07:59:16 +04:00
|
|
|
}
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, t0, tmp32);
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2014-05-27 07:59:16 +04:00
|
|
|
case INDEX_op_qemu_ld_i64:
|
2011-09-27 08:30:58 +04:00
|
|
|
t0 = *tb_ptr++;
|
2014-05-27 07:59:16 +04:00
|
|
|
if (TCG_TARGET_REG_BITS == 32) {
|
|
|
|
|
t1 = *tb_ptr++;
|
|
|
|
|
}
|
2017-07-14 00:10:31 +03:00
|
|
|
taddr = tci_read_ulong(regs, &tb_ptr);
|
2015-05-12 21:51:44 +03:00
|
|
|
oi = tci_read_i(&tb_ptr);
|
2015-05-29 19:16:51 +03:00
|
|
|
switch (get_memop(oi) & (MO_BSWAP | MO_SSIZE)) {
|
2014-05-27 07:59:16 +04:00
|
|
|
case MO_UB:
|
|
|
|
|
tmp64 = qemu_ld_ub;
|
|
|
|
|
break;
|
|
|
|
|
case MO_SB:
|
|
|
|
|
tmp64 = (int8_t)qemu_ld_ub;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUW:
|
|
|
|
|
tmp64 = qemu_ld_leuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LESW:
|
|
|
|
|
tmp64 = (int16_t)qemu_ld_leuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUL:
|
|
|
|
|
tmp64 = qemu_ld_leul;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LESL:
|
|
|
|
|
tmp64 = (int32_t)qemu_ld_leul;
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEQ:
|
|
|
|
|
tmp64 = qemu_ld_leq;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUW:
|
|
|
|
|
tmp64 = qemu_ld_beuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BESW:
|
|
|
|
|
tmp64 = (int16_t)qemu_ld_beuw;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUL:
|
|
|
|
|
tmp64 = qemu_ld_beul;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BESL:
|
|
|
|
|
tmp64 = (int32_t)qemu_ld_beul;
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEQ:
|
|
|
|
|
tmp64 = qemu_ld_beq;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2014-05-27 07:59:16 +04:00
|
|
|
}
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, t0, tmp64);
|
2014-05-27 07:59:16 +04:00
|
|
|
if (TCG_TARGET_REG_BITS == 32) {
|
2017-07-14 00:10:31 +03:00
|
|
|
tci_write_reg(regs, t1, tmp64 >> 32);
|
2014-05-27 07:59:16 +04:00
|
|
|
}
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2014-05-27 07:59:16 +04:00
|
|
|
case INDEX_op_qemu_st_i32:
|
2017-07-14 00:10:31 +03:00
|
|
|
t0 = tci_read_r(regs, &tb_ptr);
|
|
|
|
|
taddr = tci_read_ulong(regs, &tb_ptr);
|
2015-05-12 21:51:44 +03:00
|
|
|
oi = tci_read_i(&tb_ptr);
|
2015-05-29 19:16:51 +03:00
|
|
|
switch (get_memop(oi) & (MO_BSWAP | MO_SIZE)) {
|
2014-05-27 07:59:16 +04:00
|
|
|
case MO_UB:
|
|
|
|
|
qemu_st_b(t0);
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUW:
|
|
|
|
|
qemu_st_lew(t0);
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUL:
|
|
|
|
|
qemu_st_lel(t0);
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUW:
|
|
|
|
|
qemu_st_bew(t0);
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUL:
|
|
|
|
|
qemu_st_bel(t0);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2014-05-27 07:59:16 +04:00
|
|
|
}
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2014-05-27 07:59:16 +04:00
|
|
|
case INDEX_op_qemu_st_i64:
|
2017-07-14 00:10:31 +03:00
|
|
|
tmp64 = tci_read_r64(regs, &tb_ptr);
|
|
|
|
|
taddr = tci_read_ulong(regs, &tb_ptr);
|
2015-05-12 21:51:44 +03:00
|
|
|
oi = tci_read_i(&tb_ptr);
|
2015-05-29 19:16:51 +03:00
|
|
|
switch (get_memop(oi) & (MO_BSWAP | MO_SIZE)) {
|
2014-05-27 07:59:16 +04:00
|
|
|
case MO_UB:
|
|
|
|
|
qemu_st_b(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUW:
|
|
|
|
|
qemu_st_lew(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEUL:
|
|
|
|
|
qemu_st_lel(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_LEQ:
|
|
|
|
|
qemu_st_leq(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUW:
|
|
|
|
|
qemu_st_bew(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEUL:
|
|
|
|
|
qemu_st_bel(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
case MO_BEQ:
|
|
|
|
|
qemu_st_beq(tmp64);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2014-05-27 07:59:16 +04:00
|
|
|
}
|
2011-09-27 08:30:58 +04:00
|
|
|
break;
|
2016-07-14 23:20:22 +03:00
|
|
|
case INDEX_op_mb:
|
|
|
|
|
/* Ensure ordering for all kinds */
|
|
|
|
|
smp_mb();
|
|
|
|
|
break;
|
2011-09-27 08:30:58 +04:00
|
|
|
default:
|
2021-01-28 09:11:11 +03:00
|
|
|
g_assert_not_reached();
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
2016-04-05 23:24:51 +03:00
|
|
|
tci_assert(tb_ptr == old_code_ptr + op_size);
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|
|
|
|
|
exit:
|
2016-04-21 15:58:23 +03:00
|
|
|
return ret;
|
2011-09-27 08:30:58 +04:00
|
|
|
}
|