yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2025-02-25 16:26:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

tcg: Pass the opcode width to target_parse_constraint

Browse source 
This will let us choose how to interpret a given constraint
depending on whether the opcode is 32- or 64-bit. Which will
let us share more constraint combinations between opcodes.

At the same time, change the interface to return the advanced
pointer instead of passing it in/out by reference.

Backports commit 069ea736b50b75fdec99c9b8cc603b97bd98419e from qemu
This commit is contained in:
Richard Henderson 2018-03-01 15:45:36 -05:00 committed by Lioncash
parent b8c93597b4
commit 3f38611159
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
8 changed files with 43 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
qemu/tcg/aarch64/tcg-target.inc.c
View file

@ -119,12 +119,10 @@ static inline void patch_reloc(tcg_insn_unit *code_ptr, int type,
#define TCG_CT_CONST_MONE 0x800 #define TCG_CT_CONST_MONE 0x800
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, static const char *target_parse_constraint(TCGArgConstraint *ct,
const char **pct_str) const char *ct_str, TCGType type)
{ {
const char *ct_str = *pct_str; switch (*ct_str++) {
switch (ct_str[0]) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set32(ct->u.regs, 0, (1ULL << TCG_TARGET_NB_REGS) - 1); tcg_regset_set32(ct->u.regs, 0, (1ULL << TCG_TARGET_NB_REGS) - 1);
@ -154,12 +152,9 @@ static int target_parse_constraint(TCGArgConstraint *ct,
ct->ct |= TCG_CT_CONST_ZERO; ct->ct |= TCG_CT_CONST_ZERO;
break; break;
default: default:
return -1; return NULL;
} }
return ct_str;
ct_str++;
*pct_str = ct_str;
return 0;
} }
static inline bool is_aimm(uint64_t val) static inline bool is_aimm(uint64_t val)

15
qemu/tcg/arm/tcg-target.inc.c
View file

@ -124,12 +124,10 @@ static void patch_reloc(tcg_insn_unit *code_ptr, int type,
#define TCG_CT_CONST_ZERO 0x800 #define TCG_CT_CONST_ZERO 0x800
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str; switch (*ct_str++) {
ct_str = *pct_str;
switch (ct_str[0]) {
case 'I': case 'I':
ct->ct |= TCG_CT_CONST_ARM; ct->ct |= TCG_CT_CONST_ARM;
break; break;
@ -182,12 +180,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
static inline uint32_t rotl(uint32_t val, int n) static inline uint32_t rotl(uint32_t val, int n)

14
qemu/tcg/i386/tcg-target.inc.c
View file

@ -173,12 +173,10 @@ static void patch_reloc(tcg_insn_unit *code_ptr, int type,
} }
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str; switch(*ct_str++) {
ct_str = *pct_str;
switch(ct_str[0]) {
case 'a': case 'a':
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set_reg(ct->u.regs, TCG_REG_EAX); tcg_regset_set_reg(ct->u.regs, TCG_REG_EAX);
@ -256,11 +254,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
/* test if a constant matches the constraint */ /* test if a constant matches the constraint */

14
qemu/tcg/mips/tcg-target.inc.c
View file

@ -186,12 +186,10 @@ static inline bool is_p2m1(tcg_target_long val)
} }
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str; switch(*ct_str++) {
ct_str = *pct_str;
switch(ct_str[0]) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set(ct->u.regs, 0xffffffff); tcg_regset_set(ct->u.regs, 0xffffffff);
@ -238,11 +236,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
ct->ct |= TCG_CT_CONST_ZERO; ct->ct |= TCG_CT_CONST_ZERO;
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
/* test if a constant matches the constraint */ /* test if a constant matches the constraint */

14
qemu/tcg/ppc/tcg-target.inc.c
View file

@ -265,12 +265,10 @@ static void patch_reloc(tcg_insn_unit *code_ptr, int type,
} }
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str; switch (*ct_str++) {
ct_str = *pct_str;
switch (ct_str[0]) {
case 'A': case 'B': case 'C': case 'D': case 'A': case 'B': case 'C': case 'D':
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set_reg(ct->u.regs, 3 + ct_str[0] - 'A'); tcg_regset_set_reg(ct->u.regs, 3 + ct_str[0] - 'A');
@ -317,11 +315,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
ct->ct |= TCG_CT_CONST_ZERO; ct->ct |= TCG_CT_CONST_ZERO;
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
/* test if a constant matches the constraint */ /* test if a constant matches the constraint */

14
qemu/tcg/s390/tcg-target.inc.c
View file

@ -365,11 +365,10 @@ static void patch_reloc(tcg_insn_unit *code_ptr, int type,
} }
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str = *pct_str; switch (*ct_str++) {
switch (ct_str[0]) {
case 'r': /* all registers */ case 'r': /* all registers */
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set32(ct->u.regs, 0, 0xffff); tcg_regset_set32(ct->u.regs, 0, 0xffff);
@ -410,12 +409,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
ct->ct |= TCG_CT_CONST_ZERO; ct->ct |= TCG_CT_CONST_ZERO;
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
/* Immediates to be used with logical OR. This is an optimization only, /* Immediates to be used with logical OR. This is an optimization only,

14
qemu/tcg/sparc/tcg-target.inc.c
View file

@ -321,12 +321,10 @@ static void patch_reloc(tcg_insn_unit *code_ptr, int type,
} }
/* parse target specific constraints */ /* parse target specific constraints */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str) static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type)
{ {
const char *ct_str; switch (*ct_str++) {
ct_str = *pct_str;
switch (ct_str[0]) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->ct |= TCG_CT_REG;
tcg_regset_set32(ct->u.regs, 0, 0xffffffff); tcg_regset_set32(ct->u.regs, 0, 0xffffffff);
@ -362,11 +360,9 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
ct->ct |= TCG_CT_CONST_ZERO; ct->ct |= TCG_CT_CONST_ZERO;
break; break;
default: default:
return -1; return NULL;
} }
ct_str++; return ct_str;
*pct_str = ct_str;
return 0;
} }
/* test if a constant matches the constraint */ /* test if a constant matches the constraint */

12
qemu/tcg/tcg.c
View file

@ -92,7 +92,8 @@ QEMU_PACK( typedef struct {
}) DebugFrameHeader; }) DebugFrameHeader;
/* Forward declarations for functions declared and used in tcg-target.inc.c. */ /* Forward declarations for functions declared and used in tcg-target.inc.c. */
static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str); static const char *target_parse_constraint(TCGArgConstraint *ct,
const char *ct_str, TCGType type);
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,
intptr_t 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);
@ -1276,7 +1277,8 @@ static void process_op_defs(TCGContext *s)
for (op = 0; op < NB_OPS; op++) { for (op = 0; op < NB_OPS; op++) {
TCGOpDef *def = &s->tcg_op_defs[op]; TCGOpDef *def = &s->tcg_op_defs[op];
const TCGTargetOpDef *tdefs; const TCGTargetOpDef *tdefs;
int i, nb_args, ok; TCGType type;
int i, nb_args;
if (def->flags & TCG_OPF_NOT_PRESENT) { if (def->flags & TCG_OPF_NOT_PRESENT) {
continue; continue;
@ -1291,6 +1293,7 @@ static void process_op_defs(TCGContext *s)
/* Missing TCGTargetOpDef entry. */ /* Missing TCGTargetOpDef entry. */
tcg_debug_assert(tdefs != NULL); tcg_debug_assert(tdefs != NULL);
type = (def->flags & TCG_OPF_64BIT ? TCG_TYPE_I64 : TCG_TYPE_I32);
for (i = 0; i < nb_args; i++) { for (i = 0; i < nb_args; i++) {
const char *ct_str = tdefs->args_ct_str[i]; const char *ct_str = tdefs->args_ct_str[i];
/* Incomplete TCGTargetOpDef entry. */ /* Incomplete TCGTargetOpDef entry. */
@ -1324,9 +1327,10 @@ static void process_op_defs(TCGContext *s)
ct_str++; ct_str++;
break; break;
default: default:
ok = target_parse_constraint(&def->args_ct[i], &ct_str); ct_str = target_parse_constraint(&def->args_ct[i],
ct_str, type);
/* Typo in TCGTargetOpDef constraint. */ /* Typo in TCGTargetOpDef constraint. */
tcg_debug_assert(ok == 0); tcg_debug_assert(ct_str != NULL);
} }
} }
} }