motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-11 03:24:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

Hexagon (target/hexagon) remove unnecessary inline directives

Browse source 
Suggested-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Taylor Simpson <tsimpson@quicinc.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <1617930474-31979-4-git-send-email-tsimpson@quicinc.com>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Taylor Simpson 2021-04-08 20:07:31 -05:00 • committed by Richard Henderson
parent edf26ade43
commit 2d27cebbf8
5 changed files with 46 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

9
target/hexagon/cpu.c
View file

@ -69,10 +69,9 @@ const char * const hexagon_regnames[TOTAL_PER_THREAD_REGS] = {
* stacks at different locations. This is used to compensate so the diff is * stacks at different locations. This is used to compensate so the diff is
* cleaner. * cleaner.
*/ */
static inline target_ulong adjust_stack_ptrs(CPUHexagonState *env, static target_ulong adjust_stack_ptrs(CPUHexagonState *env, target_ulong addr)
target_ulong addr)
{ {
HexagonCPU *cpu = container_of(env, HexagonCPU, env); HexagonCPU *cpu = hexagon_env_get_cpu(env);
target_ulong stack_adjust = cpu->lldb_stack_adjust; target_ulong stack_adjust = cpu->lldb_stack_adjust;
target_ulong stack_start = env->stack_start; target_ulong stack_start = env->stack_start;
target_ulong stack_size = 0x10000; target_ulong stack_size = 0x10000;
@ -88,7 +87,7 @@ static inline target_ulong adjust_stack_ptrs(CPUHexagonState *env,
} }
/* HEX_REG_P3_0 (aka C4) is an alias for the predicate registers */ /* HEX_REG_P3_0 (aka C4) is an alias for the predicate registers */
static inline target_ulong read_p3_0(CPUHexagonState *env) static target_ulong read_p3_0(CPUHexagonState *env)
{ {
int32_t control_reg = 0; int32_t control_reg = 0;
int i; int i;
@ -116,7 +115,7 @@ static void print_reg(FILE *f, CPUHexagonState *env, int regnum)
static void hexagon_dump(CPUHexagonState *env, FILE *f) static void hexagon_dump(CPUHexagonState *env, FILE *f)
{ {
HexagonCPU *cpu = container_of(env, HexagonCPU, env); HexagonCPU *cpu = hexagon_env_get_cpu(env);
if (cpu->lldb_compat) { if (cpu->lldb_compat) {
/* /*

6
target/hexagon/decode.c
View file

@ -354,7 +354,7 @@ static void decode_split_cmpjump(Packet *pkt)
} }
} }
static inline int decode_opcode_can_jump(int opcode) static int decode_opcode_can_jump(int opcode)
{ {
if ((GET_ATTRIB(opcode, A_JUMP)) || if ((GET_ATTRIB(opcode, A_JUMP)) ||
(GET_ATTRIB(opcode, A_CALL)) || (GET_ATTRIB(opcode, A_CALL)) ||
@ -370,7 +370,7 @@ static inline int decode_opcode_can_jump(int opcode)
return 0; return 0;
} }
static inline int decode_opcode_ends_loop(int opcode) static int decode_opcode_ends_loop(int opcode)
{ {
return GET_ATTRIB(opcode, A_HWLOOP0_END) || return GET_ATTRIB(opcode, A_HWLOOP0_END) ||
GET_ATTRIB(opcode, A_HWLOOP1_END); GET_ATTRIB(opcode, A_HWLOOP1_END);
@ -764,7 +764,7 @@ static void decode_add_endloop_insn(Insn *insn, int loopnum)
} }
} }
static inline int decode_parsebits_is_loopend(uint32_t encoding32) static int decode_parsebits_is_loopend(uint32_t encoding32)
{ {
uint32_t bits = parse_bits(encoding32); uint32_t bits = parse_bits(encoding32);
return bits == 0x2; return bits == 0x2;

39
target/hexagon/fma_emu.c
View file

@ -64,7 +64,7 @@ typedef union {
}; };
} Float; } Float;
static inline uint64_t float64_getmant(float64 f64) static uint64_t float64_getmant(float64 f64)
{ {
Double a = { .i = f64 }; Double a = { .i = f64 };
if (float64_is_normal(f64)) { if (float64_is_normal(f64)) {
@ -91,7 +91,7 @@ int32_t float64_getexp(float64 f64)
return -1; return -1;
} }
static inline uint64_t float32_getmant(float32 f32) static uint64_t float32_getmant(float32 f32)
{ {
Float a = { .i = f32 }; Float a = { .i = f32 };
if (float32_is_normal(f32)) { if (float32_is_normal(f32)) {
@ -118,17 +118,17 @@ int32_t float32_getexp(float32 f32)
return -1; return -1;
} }
static inline uint32_t int128_getw0(Int128 x) static uint32_t int128_getw0(Int128 x)
{ {
return int128_getlo(x); return int128_getlo(x);
} }
static inline uint32_t int128_getw1(Int128 x) static uint32_t int128_getw1(Int128 x)
{ {
return int128_getlo(x) >> 32; return int128_getlo(x) >> 32;
} }
static inline Int128 int128_mul_6464(uint64_t ai, uint64_t bi) static Int128 int128_mul_6464(uint64_t ai, uint64_t bi)
{ {
Int128 a, b; Int128 a, b;
uint64_t pp0, pp1a, pp1b, pp1s, pp2; uint64_t pp0, pp1a, pp1b, pp1s, pp2;
@ -152,7 +152,7 @@ static inline Int128 int128_mul_6464(uint64_t ai, uint64_t bi)
return int128_make128(ret_low, pp2 + (pp1s >> 32)); return int128_make128(ret_low, pp2 + (pp1s >> 32));
} }
static inline Int128 int128_sub_borrow(Int128 a, Int128 b, int borrow) static Int128 int128_sub_borrow(Int128 a, Int128 b, int borrow)
{ {
Int128 ret = int128_sub(a, b); Int128 ret = int128_sub(a, b);
if (borrow != 0) { if (borrow != 0) {
@ -170,7 +170,7 @@ typedef struct {
uint8_t sticky; uint8_t sticky;
} Accum; } Accum;
static inline void accum_init(Accum *p) static void accum_init(Accum *p)
{ {
p->mant = int128_zero(); p->mant = int128_zero();
p->exp = 0; p->exp = 0;
@ -180,7 +180,7 @@ static inline void accum_init(Accum *p)
p->sticky = 0; p->sticky = 0;
} }
static inline Accum accum_norm_left(Accum a) static Accum accum_norm_left(Accum a)
{ {
a.exp--; a.exp--;
a.mant = int128_lshift(a.mant, 1); a.mant = int128_lshift(a.mant, 1);
@ -190,6 +190,7 @@ static inline Accum accum_norm_left(Accum a)
return a; return a;
} }
/* This function is marked inline for performance reasons */
static inline Accum accum_norm_right(Accum a, int amt) static inline Accum accum_norm_right(Accum a, int amt)
{ {
if (amt > 130) { if (amt > 130) {
@ -226,7 +227,7 @@ static inline Accum accum_norm_right(Accum a, int amt)
*/ */
static Accum accum_add(Accum a, Accum b); static Accum accum_add(Accum a, Accum b);
static inline Accum accum_sub(Accum a, Accum b, int negate) static Accum accum_sub(Accum a, Accum b, int negate)
{ {
Accum ret; Accum ret;
accum_init(&ret); accum_init(&ret);
@ -329,7 +330,7 @@ static Accum accum_add(Accum a, Accum b)
} }
/* Return an infinity with requested sign */ /* Return an infinity with requested sign */
static inline float64 infinite_float64(uint8_t sign) static float64 infinite_float64(uint8_t sign)
{ {
if (sign) { if (sign) {
return make_float64(DF_MINUS_INF); return make_float64(DF_MINUS_INF);
@ -339,7 +340,7 @@ static inline float64 infinite_float64(uint8_t sign)
} }
/* Return a maximum finite value with requested sign */ /* Return a maximum finite value with requested sign */
static inline float64 maxfinite_float64(uint8_t sign) static float64 maxfinite_float64(uint8_t sign)
{ {
if (sign) { if (sign) {
return make_float64(DF_MINUS_MAXF); return make_float64(DF_MINUS_MAXF);
@ -349,7 +350,7 @@ static inline float64 maxfinite_float64(uint8_t sign)
} }
/* Return a zero value with requested sign */ /* Return a zero value with requested sign */
static inline float64 zero_float64(uint8_t sign) static float64 zero_float64(uint8_t sign)
{ {
if (sign) { if (sign) {
return make_float64(0x8000000000000000); return make_float64(0x8000000000000000);
@ -369,7 +370,7 @@ float32 infinite_float32(uint8_t sign)
} }
/* Return a maximum finite value with the requested sign */ /* Return a maximum finite value with the requested sign */
static inline float32 maxfinite_float32(uint8_t sign) static float32 maxfinite_float32(uint8_t sign)
{ {
if (sign) { if (sign) {
return make_float32(SF_MINUS_MAXF); return make_float32(SF_MINUS_MAXF);
@ -379,7 +380,7 @@ static inline float32 maxfinite_float32(uint8_t sign)
} }
/* Return a zero value with requested sign */ /* Return a zero value with requested sign */
static inline float32 zero_float32(uint8_t sign) static float32 zero_float32(uint8_t sign)
{ {
if (sign) { if (sign) {
return make_float32(0x80000000); return make_float32(0x80000000);
@ -389,7 +390,7 @@ static inline float32 zero_float32(uint8_t sign)
} }
#define GEN_XF_ROUND(SUFFIX, MANTBITS, INF_EXP, INTERNAL_TYPE) \ #define GEN_XF_ROUND(SUFFIX, MANTBITS, INF_EXP, INTERNAL_TYPE) \
static inline SUFFIX accum_round_##SUFFIX(Accum a, float_status * fp_status) \ static SUFFIX accum_round_##SUFFIX(Accum a, float_status * fp_status) \
{ \ { \
if ((int128_gethi(a.mant) == 0) && (int128_getlo(a.mant) == 0) \ if ((int128_gethi(a.mant) == 0) && (int128_getlo(a.mant) == 0) \
&& ((a.guard | a.round | a.sticky) == 0)) { \ && ((a.guard | a.round | a.sticky) == 0)) { \
@ -526,8 +527,8 @@ static bool is_inf_prod(float64 a, float64 b)
(float64_is_infinity(b) && is_finite(a) && (!float64_is_zero(a)))); (float64_is_infinity(b) && is_finite(a) && (!float64_is_zero(a))));
} }
static inline float64 special_fma(float64 a, float64 b, float64 c, static float64 special_fma(float64 a, float64 b, float64 c,
float_status *fp_status) float_status *fp_status)
{ {
float64 ret = make_float64(0); float64 ret = make_float64(0);
@ -586,8 +587,8 @@ static inline float64 special_fma(float64 a, float64 b, float64 c,
g_assert_not_reached(); g_assert_not_reached();
} }
static inline float32 special_fmaf(float32 a, float32 b, float32 c, static float32 special_fmaf(float32 a, float32 b, float32 c,
float_status *fp_status) float_status *fp_status)
{ {
float64 aa, bb, cc; float64 aa, bb, cc;
aa = float32_to_float64(a, fp_status); aa = float32_to_float64(a, fp_status);

37
target/hexagon/op_helper.c
View file

@ -46,8 +46,8 @@ void QEMU_NORETURN HELPER(raise_exception)(CPUHexagonState *env, uint32_t excp)
do_raise_exception_err(env, excp, 0); do_raise_exception_err(env, excp, 0);
} }
static inline void log_reg_write(CPUHexagonState *env, int rnum, static void log_reg_write(CPUHexagonState *env, int rnum,
target_ulong val, uint32_t slot) target_ulong val, uint32_t slot)
{ {
HEX_DEBUG_LOG("log_reg_write[%d] = " TARGET_FMT_ld " (0x" TARGET_FMT_lx ")", HEX_DEBUG_LOG("log_reg_write[%d] = " TARGET_FMT_ld " (0x" TARGET_FMT_lx ")",
rnum, val, val); rnum, val, val);
@ -63,8 +63,7 @@ static inline void log_reg_write(CPUHexagonState *env, int rnum,
#endif #endif
} }
static inline void log_pred_write(CPUHexagonState *env, int pnum, static void log_pred_write(CPUHexagonState *env, int pnum, target_ulong val)
target_ulong val)
{ {
HEX_DEBUG_LOG("log_pred_write[%d] = " TARGET_FMT_ld HEX_DEBUG_LOG("log_pred_write[%d] = " TARGET_FMT_ld
" (0x" TARGET_FMT_lx ")\n", " (0x" TARGET_FMT_lx ")\n",
@ -79,8 +78,8 @@ static inline void log_pred_write(CPUHexagonState *env, int pnum,
} }
} }
static inline void log_store32(CPUHexagonState *env, target_ulong addr, static void log_store32(CPUHexagonState *env, target_ulong addr,
target_ulong val, int width, int slot) target_ulong val, int width, int slot)
{ {
HEX_DEBUG_LOG("log_store%d(0x" TARGET_FMT_lx HEX_DEBUG_LOG("log_store%d(0x" TARGET_FMT_lx
", %" PRId32 " [0x08%" PRIx32 "])\n", ", %" PRId32 " [0x08%" PRIx32 "])\n",
@ -90,8 +89,8 @@ static inline void log_store32(CPUHexagonState *env, target_ulong addr,
env->mem_log_stores[slot].data32 = val; env->mem_log_stores[slot].data32 = val;
} }
static inline void log_store64(CPUHexagonState *env, target_ulong addr, static void log_store64(CPUHexagonState *env, target_ulong addr,
int64_t val, int width, int slot) int64_t val, int width, int slot)
{ {
HEX_DEBUG_LOG("log_store%d(0x" TARGET_FMT_lx HEX_DEBUG_LOG("log_store%d(0x" TARGET_FMT_lx
", %" PRId64 " [0x016%" PRIx64 "])\n", ", %" PRId64 " [0x016%" PRIx64 "])\n",
@ -101,7 +100,7 @@ static inline void log_store64(CPUHexagonState *env, target_ulong addr,
env->mem_log_stores[slot].data64 = val; env->mem_log_stores[slot].data64 = val;
} }
static inline void write_new_pc(CPUHexagonState *env, target_ulong addr) static void write_new_pc(CPUHexagonState *env, target_ulong addr)
{ {
HEX_DEBUG_LOG("write_new_pc(0x" TARGET_FMT_lx ")\n", addr); HEX_DEBUG_LOG("write_new_pc(0x" TARGET_FMT_lx ")\n", addr);
@ -132,7 +131,7 @@ void HELPER(debug_start_packet)(CPUHexagonState *env)
} }
#endif #endif
static inline int32_t new_pred_value(CPUHexagonState *env, int pnum) static int32_t new_pred_value(CPUHexagonState *env, int pnum)
{ {
return env->new_pred_value[pnum]; return env->new_pred_value[pnum];
} }
@ -332,8 +331,8 @@ static void check_noshuf(CPUHexagonState *env, uint32_t slot)
} }
} }
static inline uint8_t mem_load1(CPUHexagonState *env, uint32_t slot, static uint8_t mem_load1(CPUHexagonState *env, uint32_t slot,
target_ulong vaddr) target_ulong vaddr)
{ {
uint8_t retval; uint8_t retval;
check_noshuf(env, slot); check_noshuf(env, slot);
@ -341,8 +340,8 @@ static inline uint8_t mem_load1(CPUHexagonState *env, uint32_t slot,
return retval; return retval;
} }
static inline uint16_t mem_load2(CPUHexagonState *env, uint32_t slot, static uint16_t mem_load2(CPUHexagonState *env, uint32_t slot,
target_ulong vaddr) target_ulong vaddr)
{ {
uint16_t retval; uint16_t retval;
check_noshuf(env, slot); check_noshuf(env, slot);
@ -350,8 +349,8 @@ static inline uint16_t mem_load2(CPUHexagonState *env, uint32_t slot,
return retval; return retval;
} }
static inline uint32_t mem_load4(CPUHexagonState *env, uint32_t slot, static uint32_t mem_load4(CPUHexagonState *env, uint32_t slot,
target_ulong vaddr) target_ulong vaddr)
{ {
uint32_t retval; uint32_t retval;
check_noshuf(env, slot); check_noshuf(env, slot);
@ -359,8 +358,8 @@ static inline uint32_t mem_load4(CPUHexagonState *env, uint32_t slot,
return retval; return retval;
} }
static inline uint64_t mem_load8(CPUHexagonState *env, uint32_t slot, static uint64_t mem_load8(CPUHexagonState *env, uint32_t slot,
target_ulong vaddr) target_ulong vaddr)
{ {
uint64_t retval; uint64_t retval;
check_noshuf(env, slot); check_noshuf(env, slot);
@ -939,7 +938,7 @@ float32 HELPER(sffms)(CPUHexagonState *env, float32 RxV,
return RxV; return RxV;
} }
static inline bool is_inf_prod(int32_t a, int32_t b) static bool is_inf_prod(int32_t a, int32_t b)
{ {
return (float32_is_infinity(a) && float32_is_infinity(b)) || return (float32_is_infinity(a) && float32_is_infinity(b)) ||
(float32_is_infinity(a) && is_finite(b) && !float32_is_zero(b)) || (float32_is_infinity(a) && is_finite(b) && !float32_is_zero(b)) ||

2
target/hexagon/translate.c
View file

@ -585,7 +585,7 @@ static void hexagon_tr_translate_packet(DisasContextBase *dcbase, CPUState *cpu)
* The CPU log is used to compare against LLDB single stepping, * The CPU log is used to compare against LLDB single stepping,
* so end the TLB after every packet. * so end the TLB after every packet.
*/ */
HexagonCPU *hex_cpu = container_of(env, HexagonCPU, env); HexagonCPU *hex_cpu = hexagon_env_get_cpu(env);
if (hex_cpu->lldb_compat && qemu_loglevel_mask(CPU_LOG_TB_CPU)) { if (hex_cpu->lldb_compat && qemu_loglevel_mask(CPU_LOG_TB_CPU)) {
ctx->base.is_jmp = DISAS_TOO_MANY; ctx->base.is_jmp = DISAS_TOO_MANY;
} }