openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Extend maximum gvec vector size 

Fix i386 avx2 dupi
 Fix mips host user-only write detection
 Misc cleanups.
 -----BEGIN PGP SIGNATURE-----
 
 iQFRBAABCgA7FiEEekgeeIaLTbaoWgXAZN846K9+IV8FAl9/DDodHHJpY2hhcmQu
 aGVuZGVyc29uQGxpbmFyby5vcmcACgkQZN846K9+IV/Nbgf/eHOncxQwA/eAsiJ3
 Q79LbjXTEYZUfxpO3vuFwB2ZUvrwBS6daPyIskxRAQRdfAfcWV3hDY5G+tcdZyLr
 alMuas1bMyb6x+QxVVDbqmKm81Ky8dTCS+NRDGtBWWnJzStTEER29GSPJbHkVNnl
 IUgPbFdZxVeq1+QwI67ez+hExghirjZK/RoGtO1aU8M5J921v0HZ0rguEc16D3N+
 KMh/4/SZ6ai2GNgcqVhJ2SdUpVr+mmpaw4D+/bJaPVn/Hvct1jMYBXJTpl/Tf9Ac
 FBVZiMDmF3HYSSiEDmzttZiqJwnk+uvaNoN79oJQ/mcXiq6dWkUUG8Eei7KJYwVt
 noLHew==
 =NrIp
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20201008' into staging

Extend maximum gvec vector size
Fix i386 avx2 dupi
Fix mips host user-only write detection
Misc cleanups.

# gpg: Signature made Thu 08 Oct 2020 13:55:22 BST
# gpg:                using RSA key 7A481E78868B4DB6A85A05C064DF38E8AF7E215F
# gpg:                issuer "richard.henderson@linaro.org"
# gpg: Good signature from "Richard Henderson <richard.henderson@linaro.org>" [full]
# Primary key fingerprint: 7A48 1E78 868B 4DB6 A85A  05C0 64DF 38E8 AF7E 215F

* remotes/rth/tags/pull-tcg-20201008:
  accel/tcg: Fix computing of is_write for MIPS
  tcg: Remove TCG_TARGET_HAS_cmp_vec
  tcg/optimize: Fold dup2_vec
  tcg: Fix generation of dupi_vec for 32-bit host
  tcg/i386: Fix dupi for avx2 32-bit hosts
  tcg: Remove TCGOpDef.used
  tcg: Move some TCG_CT_* bits to TCGArgConstraint bitfields
  tcg: Remove TCG_CT_REG
  tcg: Move sorted_args into TCGArgConstraint.sort_index
  tcg: Drop union from TCGArgConstraint
  tcg: Adjust simd_desc size encoding

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2020-10-08 17:18:46 +01:00
parent a1d22c668a 62475e9d00
commit e64cf4d569
19 changed files with 244 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
accel/tcg/user-exec.c
View File

@ -702,16 +702,51 @@ int cpu_signal_handler(int host_signum, void *pinfo,
#elif defined(__mips__) #elif defined(__mips__)
#if defined(__misp16) || defined(__mips_micromips)
#error "Unsupported encoding"
#endif
int cpu_signal_handler(int host_signum, void *pinfo, int cpu_signal_handler(int host_signum, void *pinfo,
void *puc) void *puc)
{ {
siginfo_t *info = pinfo; siginfo_t *info = pinfo;
ucontext_t *uc = puc; ucontext_t *uc = puc;
greg_t pc = uc->uc_mcontext.pc; uintptr_t pc = uc->uc_mcontext.pc;
int is_write; uint32_t insn = *(uint32_t *)pc;
int is_write = 0;
/* Detect all store instructions at program counter. */
switch((insn >> 26) & 077) {
case 050: /* SB */
case 051: /* SH */
case 052: /* SWL */
case 053: /* SW */
case 054: /* SDL */
case 055: /* SDR */
case 056: /* SWR */
case 070: /* SC */
case 071: /* SWC1 */
case 074: /* SCD */
case 075: /* SDC1 */
case 077: /* SD */
#if !defined(__mips_isa_rev) || __mips_isa_rev < 6
case 072: /* SWC2 */
case 076: /* SDC2 */
#endif
is_write = 1;
break;
case 023: /* COP1X */
/* Required in all versions of MIPS64 since
MIPS64r1 and subsequent versions of MIPS32r2. */
switch (insn & 077) {
case 010: /* SWXC1 */
case 011: /* SDXC1 */
case 015: /* SUXC1 */
is_write = 1;
}
break;
}
/* XXX: compute is_write */
is_write = 0;
return handle_cpu_signal(pc, info, is_write, &uc->uc_sigmask); return handle_cpu_signal(pc, info, is_write, &uc->uc_sigmask);
} }

38
include/tcg/tcg-gvec-desc.h
View File

@ -20,29 +20,41 @@
#ifndef TCG_TCG_GVEC_DESC_H #ifndef TCG_TCG_GVEC_DESC_H
#define TCG_TCG_GVEC_DESC_H #define TCG_TCG_GVEC_DESC_H
/* ??? These bit widths are set for ARM SVE, maxing out at 256 byte vectors. */ /*
#define SIMD_OPRSZ_SHIFT 0 * This configuration allows MAXSZ to represent 2048 bytes, and
#define SIMD_OPRSZ_BITS 5 * OPRSZ to match MAXSZ, or represent the smaller values 8, 16, or 32.
*
* Encode this with:
* 0, 1, 3 -> 8, 16, 32
* 2 -> maxsz
*
* This steals the input that would otherwise map to 24 to match maxsz.
*/
#define SIMD_MAXSZ_SHIFT 0
#define SIMD_MAXSZ_BITS 8
#define SIMD_MAXSZ_SHIFT (SIMD_OPRSZ_SHIFT + SIMD_OPRSZ_BITS) #define SIMD_OPRSZ_SHIFT (SIMD_MAXSZ_SHIFT + SIMD_MAXSZ_BITS)
#define SIMD_MAXSZ_BITS 5 #define SIMD_OPRSZ_BITS 2
#define SIMD_DATA_SHIFT (SIMD_MAXSZ_SHIFT + SIMD_MAXSZ_BITS) #define SIMD_DATA_SHIFT (SIMD_OPRSZ_SHIFT + SIMD_OPRSZ_BITS)
#define SIMD_DATA_BITS (32 - SIMD_DATA_SHIFT) #define SIMD_DATA_BITS (32 - SIMD_DATA_SHIFT)
/* Create a descriptor from components. */ /* Create a descriptor from components. */
uint32_t simd_desc(uint32_t oprsz, uint32_t maxsz, int32_t data); uint32_t simd_desc(uint32_t oprsz, uint32_t maxsz, int32_t data);
/* Extract the operation size from a descriptor. */
static inline intptr_t simd_oprsz(uint32_t desc)
{
return (extract32(desc, SIMD_OPRSZ_SHIFT, SIMD_OPRSZ_BITS) + 1) * 8;
}
/* Extract the max vector size from a descriptor. */ /* Extract the max vector size from a descriptor. */
static inline intptr_t simd_maxsz(uint32_t desc) static inline intptr_t simd_maxsz(uint32_t desc)
{ {
return (extract32(desc, SIMD_MAXSZ_SHIFT, SIMD_MAXSZ_BITS) + 1) * 8; return extract32(desc, SIMD_MAXSZ_SHIFT, SIMD_MAXSZ_BITS) * 8 + 8;
}
/* Extract the operation size from a descriptor. */
static inline intptr_t simd_oprsz(uint32_t desc)
{
uint32_t f = extract32(desc, SIMD_OPRSZ_SHIFT, SIMD_OPRSZ_BITS);
intptr_t o = f * 8 + 8;
intptr_t m = simd_maxsz(desc);
return f == 2 ? m : o;
} }
/* Extract the operation-specific data from a descriptor. */ /* Extract the operation-specific data from a descriptor. */

22
include/tcg/tcg.h
View File

@ -976,18 +976,16 @@ int64_t tcg_cpu_exec_time(void);
void tcg_dump_info(void); void tcg_dump_info(void);
void tcg_dump_op_count(void); void tcg_dump_op_count(void);
#define TCG_CT_ALIAS 0x80 #define TCG_CT_CONST 1 /* any constant of register size */
#define TCG_CT_IALIAS 0x40
#define TCG_CT_NEWREG 0x20 /* output requires a new register */
#define TCG_CT_REG 0x01
#define TCG_CT_CONST 0x02 /* any constant of register size */
typedef struct TCGArgConstraint { typedef struct TCGArgConstraint {
uint16_t ct; unsigned ct : 16;
uint8_t alias_index; unsigned alias_index : 4;
union { unsigned sort_index : 4;
TCGRegSet regs; bool oalias : 1;
} u; bool ialias : 1;
bool newreg : 1;
TCGRegSet regs;
} TCGArgConstraint; } TCGArgConstraint;
#define TCG_MAX_OP_ARGS 16 #define TCG_MAX_OP_ARGS 16
@ -1017,10 +1015,6 @@ typedef struct TCGOpDef {
uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args; uint8_t nb_oargs, nb_iargs, nb_cargs, nb_args;
uint8_t flags; uint8_t flags;
TCGArgConstraint *args_ct; TCGArgConstraint *args_ct;
int *sorted_args;
#if defined(CONFIG_DEBUG_TCG)
int used;
#endif
} TCGOpDef; } TCGOpDef;
extern TCGOpDef tcg_op_defs[]; extern TCGOpDef tcg_op_defs[];

17
tcg/aarch64/tcg-target.c.inc
View File

@ -128,23 +128,20 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch (*ct_str++) { switch (*ct_str++) {
case 'r': /* general registers */ case 'r': /* general registers */
ct->ct |= TCG_CT_REG; ct->regs |= 0xffffffffu;
ct->u.regs |= 0xffffffffu;
break; break;
case 'w': /* advsimd registers */ case 'w': /* advsimd registers */
ct->ct |= TCG_CT_REG; ct->regs |= 0xffffffff00000000ull;
ct->u.regs |= 0xffffffff00000000ull;
break; break;
case 'l': /* qemu_ld / qemu_st address, data_reg */ case 'l': /* qemu_ld / qemu_st address, data_reg */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffffu;
ct->u.regs = 0xffffffffu;
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
/* x0 and x1 will be overwritten when reading the tlb entry, /* x0 and x1 will be overwritten when reading the tlb entry,
and x2, and x3 for helper args, better to avoid using them. */ and x2, and x3 for helper args, better to avoid using them. */
tcg_regset_reset_reg(ct->u.regs, TCG_REG_X0); tcg_regset_reset_reg(ct->regs, TCG_REG_X0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_X1); tcg_regset_reset_reg(ct->regs, TCG_REG_X1);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_X2); tcg_regset_reset_reg(ct->regs, TCG_REG_X2);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_X3); tcg_regset_reset_reg(ct->regs, TCG_REG_X3);
#endif #endif
break; break;
case 'A': /* Valid for arithmetic immediate (positive or negative). */ case 'A': /* Valid for arithmetic immediate (positive or negative). */

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

@ -139,7 +139,6 @@ typedef enum {
#define TCG_TARGET_HAS_shi_vec 1 #define TCG_TARGET_HAS_shi_vec 1
#define TCG_TARGET_HAS_shs_vec 0 #define TCG_TARGET_HAS_shs_vec 0
#define TCG_TARGET_HAS_shv_vec 1 #define TCG_TARGET_HAS_shv_vec 1
#define TCG_TARGET_HAS_cmp_vec 1
#define TCG_TARGET_HAS_mul_vec 1 #define TCG_TARGET_HAS_mul_vec 1
#define TCG_TARGET_HAS_sat_vec 1 #define TCG_TARGET_HAS_sat_vec 1
#define TCG_TARGET_HAS_minmax_vec 1 #define TCG_TARGET_HAS_minmax_vec 1

29
tcg/arm/tcg-target.c.inc
View File

@ -253,41 +253,38 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
break; break;
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->regs = 0xffff;
ct->u.regs = 0xffff;
break; break;
/* qemu_ld address */ /* qemu_ld address */
case 'l': case 'l':
ct->ct |= TCG_CT_REG; ct->regs = 0xffff;
ct->u.regs = 0xffff;
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
/* r0-r2,lr will be overwritten when reading the tlb entry, /* r0-r2,lr will be overwritten when reading the tlb entry,
so don't use these. */ so don't use these. */
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0); tcg_regset_reset_reg(ct->regs, TCG_REG_R0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1); tcg_regset_reset_reg(ct->regs, TCG_REG_R1);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R2); tcg_regset_reset_reg(ct->regs, TCG_REG_R2);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3); tcg_regset_reset_reg(ct->regs, TCG_REG_R3);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R14); tcg_regset_reset_reg(ct->regs, TCG_REG_R14);
#endif #endif
break; break;
/* qemu_st address & data */ /* qemu_st address & data */
case 's': case 's':
ct->ct |= TCG_CT_REG; ct->regs = 0xffff;
ct->u.regs = 0xffff;
/* r0-r2 will be overwritten when reading the tlb entry (softmmu only) /* r0-r2 will be overwritten when reading the tlb entry (softmmu only)
and r0-r1 doing the byte swapping, so don't use these. */ and r0-r1 doing the byte swapping, so don't use these. */
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R0); tcg_regset_reset_reg(ct->regs, TCG_REG_R0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R1); tcg_regset_reset_reg(ct->regs, TCG_REG_R1);
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
/* Avoid clashes with registers being used for helper args */ /* Avoid clashes with registers being used for helper args */
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R2); tcg_regset_reset_reg(ct->regs, TCG_REG_R2);
#if TARGET_LONG_BITS == 64 #if TARGET_LONG_BITS == 64
/* Avoid clashes with registers being used for helper args */ /* Avoid clashes with registers being used for helper args */
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3); tcg_regset_reset_reg(ct->regs, TCG_REG_R3);
#endif #endif
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R14); tcg_regset_reset_reg(ct->regs, TCG_REG_R14);
#endif #endif
break; break;

39
tcg/i386/tcg-target.c.inc
View File

@ -208,43 +208,34 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch(*ct_str++) { switch(*ct_str++) {
case 'a': case 'a':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_EAX);
tcg_regset_set_reg(ct->u.regs, TCG_REG_EAX);
break; break;
case 'b': case 'b':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_EBX);
tcg_regset_set_reg(ct->u.regs, TCG_REG_EBX);
break; break;
case 'c': case 'c':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_ECX);
tcg_regset_set_reg(ct->u.regs, TCG_REG_ECX);
break; break;
case 'd': case 'd':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_EDX);
tcg_regset_set_reg(ct->u.regs, TCG_REG_EDX);
break; break;
case 'S': case 'S':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_ESI);
tcg_regset_set_reg(ct->u.regs, TCG_REG_ESI);
break; break;
case 'D': case 'D':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, TCG_REG_EDI);
tcg_regset_set_reg(ct->u.regs, TCG_REG_EDI);
break; break;
case 'q': case 'q':
/* A register that can be used as a byte operand. */ /* A register that can be used as a byte operand. */
ct->ct |= TCG_CT_REG; ct->regs = TCG_TARGET_REG_BITS == 64 ? 0xffff : 0xf;
ct->u.regs = TCG_TARGET_REG_BITS == 64 ? 0xffff : 0xf;
break; break;
case 'Q': case 'Q':
/* A register with an addressable second byte (e.g. %ah). */ /* A register with an addressable second byte (e.g. %ah). */
ct->ct |= TCG_CT_REG; ct->regs = 0xf;
ct->u.regs = 0xf;
break; break;
case 'r': case 'r':
/* A general register. */ /* A general register. */
ct->ct |= TCG_CT_REG; ct->regs |= ALL_GENERAL_REGS;
ct->u.regs |= ALL_GENERAL_REGS;
break; break;
case 'W': case 'W':
/* With TZCNT/LZCNT, we can have operand-size as an input. */ /* With TZCNT/LZCNT, we can have operand-size as an input. */
@ -252,16 +243,14 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
break; break;
case 'x': case 'x':
/* A vector register. */ /* A vector register. */
ct->ct |= TCG_CT_REG; ct->regs |= ALL_VECTOR_REGS;
ct->u.regs |= ALL_VECTOR_REGS;
break; break;
/* qemu_ld/st address constraint */ /* qemu_ld/st address constraint */
case 'L': case 'L':
ct->ct |= TCG_CT_REG; ct->regs = TCG_TARGET_REG_BITS == 64 ? 0xffff : 0xff;
ct->u.regs = TCG_TARGET_REG_BITS == 64 ? 0xffff : 0xff; tcg_regset_reset_reg(ct->regs, TCG_REG_L0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_L0); tcg_regset_reset_reg(ct->regs, TCG_REG_L1);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_L1);
break; break;
case 'e': case 'e':
@ -969,7 +958,7 @@ static void tcg_out_dupi_vec(TCGContext *s, TCGType type,
new_pool_label(s, arg, R_386_PC32, s->code_ptr - 4, -4); new_pool_label(s, arg, R_386_PC32, s->code_ptr - 4, -4);
} else { } else {
if (have_avx2) { if (have_avx2) {
tcg_out_vex_modrm_pool(s, OPC_VPBROADCASTW + vex_l, ret); tcg_out_vex_modrm_pool(s, OPC_VPBROADCASTD + vex_l, ret);
} else { } else {
tcg_out_vex_modrm_pool(s, OPC_VBROADCASTSS, ret); tcg_out_vex_modrm_pool(s, OPC_VBROADCASTSS, ret);
} }

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

@ -189,7 +189,6 @@ extern bool have_avx2;
#define TCG_TARGET_HAS_shi_vec 1 #define TCG_TARGET_HAS_shi_vec 1
#define TCG_TARGET_HAS_shs_vec 1 #define TCG_TARGET_HAS_shs_vec 1
#define TCG_TARGET_HAS_shv_vec have_avx2 #define TCG_TARGET_HAS_shv_vec have_avx2
#define TCG_TARGET_HAS_cmp_vec 1
#define TCG_TARGET_HAS_mul_vec 1 #define TCG_TARGET_HAS_mul_vec 1
#define TCG_TARGET_HAS_sat_vec 1 #define TCG_TARGET_HAS_sat_vec 1
#define TCG_TARGET_HAS_minmax_vec 1 #define TCG_TARGET_HAS_minmax_vec 1

21
tcg/mips/tcg-target.c.inc
View File

@ -195,29 +195,26 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch(*ct_str++) { switch(*ct_str++) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
break; break;
case 'L': /* qemu_ld input arg constraint */ case 'L': /* qemu_ld input arg constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff; tcg_regset_reset_reg(ct->regs, TCG_REG_A0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A0);
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) { if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A2); tcg_regset_reset_reg(ct->regs, TCG_REG_A2);
} }
#endif #endif
break; break;
case 'S': /* qemu_st constraint */ case 'S': /* qemu_st constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff; tcg_regset_reset_reg(ct->regs, TCG_REG_A0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A0);
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) { if (TCG_TARGET_REG_BITS < TARGET_LONG_BITS) {
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A2); tcg_regset_reset_reg(ct->regs, TCG_REG_A2);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A3); tcg_regset_reset_reg(ct->regs, TCG_REG_A3);
} else { } else {
tcg_regset_reset_reg(ct->u.regs, TCG_REG_A1); tcg_regset_reset_reg(ct->regs, TCG_REG_A1);
} }
#endif #endif
break; break;

15
tcg/optimize.c
View File

@ -1109,6 +1109,21 @@ void tcg_optimize(TCGContext *s)
} }
goto do_default; goto do_default;
case INDEX_op_dup2_vec:
assert(TCG_TARGET_REG_BITS == 32);
if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
tmp = arg_info(op->args[1])->val;
if (tmp == arg_info(op->args[2])->val) {
tcg_opt_gen_movi(s, op, op->args[0], tmp);
break;
}
} else if (args_are_copies(op->args[1], op->args[2])) {
op->opc = INDEX_op_dup_vec;
TCGOP_VECE(op) = MO_32;
nb_iargs = 1;
}
goto do_default;
CASE_OP_32_64(not): CASE_OP_32_64(not):
CASE_OP_32_64(neg): CASE_OP_32_64(neg):
CASE_OP_32_64(ext8s): CASE_OP_32_64(ext8s):

29
tcg/ppc/tcg-target.c.inc
View File

@ -224,34 +224,29 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch (*ct_str++) { switch (*ct_str++) {
case 'A': case 'B': case 'C': case 'D': case 'A': case 'B': case 'C': case 'D':
ct->ct |= TCG_CT_REG; tcg_regset_set_reg(ct->regs, 3 + ct_str[0] - 'A');
tcg_regset_set_reg(ct->u.regs, 3 + ct_str[0] - 'A');
break; break;
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
break; break;
case 'v': case 'v':
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff00000000ull;
ct->u.regs = 0xffffffff00000000ull;
break; break;
case 'L': /* qemu_ld constraint */ case 'L': /* qemu_ld constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff; tcg_regset_reset_reg(ct->regs, TCG_REG_R3);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4); tcg_regset_reset_reg(ct->regs, TCG_REG_R4);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); tcg_regset_reset_reg(ct->regs, TCG_REG_R5);
#endif #endif
break; break;
case 'S': /* qemu_st constraint */ case 'S': /* qemu_st constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff; tcg_regset_reset_reg(ct->regs, TCG_REG_R3);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3);
#ifdef CONFIG_SOFTMMU #ifdef CONFIG_SOFTMMU
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4); tcg_regset_reset_reg(ct->regs, TCG_REG_R4);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R5); tcg_regset_reset_reg(ct->regs, TCG_REG_R5);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R6); tcg_regset_reset_reg(ct->regs, TCG_REG_R6);
#endif #endif
break; break;
case 'I': case 'I':

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

@ -169,7 +169,6 @@ extern bool have_vsx;
#define TCG_TARGET_HAS_shi_vec 0 #define TCG_TARGET_HAS_shi_vec 0
#define TCG_TARGET_HAS_shs_vec 0 #define TCG_TARGET_HAS_shs_vec 0
#define TCG_TARGET_HAS_shv_vec 1 #define TCG_TARGET_HAS_shv_vec 1
#define TCG_TARGET_HAS_cmp_vec 1
#define TCG_TARGET_HAS_mul_vec 1 #define TCG_TARGET_HAS_mul_vec 1
#define TCG_TARGET_HAS_sat_vec 1 #define TCG_TARGET_HAS_sat_vec 1
#define TCG_TARGET_HAS_minmax_vec 1 #define TCG_TARGET_HAS_minmax_vec 1

16
tcg/riscv/tcg-target.c.inc
View File

@ -137,20 +137,18 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch (*ct_str++) { switch (*ct_str++) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
break; break;
case 'L': case 'L':
/* qemu_ld/qemu_st constraint */ /* qemu_ld/qemu_st constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
/* qemu_ld/qemu_st uses TCG_REG_TMP0 */ /* qemu_ld/qemu_st uses TCG_REG_TMP0 */
#if defined(CONFIG_SOFTMMU) #if defined(CONFIG_SOFTMMU)
tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[0]); tcg_regset_reset_reg(ct->regs, tcg_target_call_iarg_regs[0]);
tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[1]); tcg_regset_reset_reg(ct->regs, tcg_target_call_iarg_regs[1]);
tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[2]); tcg_regset_reset_reg(ct->regs, tcg_target_call_iarg_regs[2]);
tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[3]); tcg_regset_reset_reg(ct->regs, tcg_target_call_iarg_regs[3]);
tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[4]); tcg_regset_reset_reg(ct->regs, tcg_target_call_iarg_regs[4]);
#endif #endif
break; break;
case 'I': case 'I':

22
tcg/s390/tcg-target.c.inc
View File

@ -408,25 +408,21 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch (*ct_str++) { switch (*ct_str++) {
case 'r': /* all registers */ case 'r': /* all registers */
ct->ct |= TCG_CT_REG; ct->regs = 0xffff;
ct->u.regs = 0xffff;
break; break;
case 'L': /* qemu_ld/st constraint */ case 'L': /* qemu_ld/st constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffff;
ct->u.regs = 0xffff; tcg_regset_reset_reg(ct->regs, TCG_REG_R2);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R2); tcg_regset_reset_reg(ct->regs, TCG_REG_R3);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R3); tcg_regset_reset_reg(ct->regs, TCG_REG_R4);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_R4);
break; break;
case 'a': /* force R2 for division */ case 'a': /* force R2 for division */
ct->ct |= TCG_CT_REG; ct->regs = 0;
ct->u.regs = 0; tcg_regset_set_reg(ct->regs, TCG_REG_R2);
tcg_regset_set_reg(ct->u.regs, TCG_REG_R2);
break; break;
case 'b': /* force R3 for division */ case 'b': /* force R3 for division */
ct->ct |= TCG_CT_REG; ct->regs = 0;
ct->u.regs = 0; tcg_regset_set_reg(ct->regs, TCG_REG_R3);
tcg_regset_set_reg(ct->u.regs, TCG_REG_R3);
break; break;
case 'A': case 'A':
ct->ct |= TCG_CT_CONST_S33; ct->ct |= TCG_CT_CONST_S33;

21
tcg/sparc/tcg-target.c.inc
View File

@ -325,28 +325,23 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
{ {
switch (*ct_str++) { switch (*ct_str++) {
case 'r': case 'r':
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
break; break;
case 'R': case 'R':
ct->ct |= TCG_CT_REG; ct->regs = ALL_64;
ct->u.regs = ALL_64;
break; break;
case 'A': /* qemu_ld/st address constraint */ case 'A': /* qemu_ld/st address constraint */
ct->ct |= TCG_CT_REG; ct->regs = TARGET_LONG_BITS == 64 ? ALL_64 : 0xffffffff;
ct->u.regs = TARGET_LONG_BITS == 64 ? ALL_64 : 0xffffffff;
reserve_helpers: reserve_helpers:
tcg_regset_reset_reg(ct->u.regs, TCG_REG_O0); tcg_regset_reset_reg(ct->regs, TCG_REG_O0);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_O1); tcg_regset_reset_reg(ct->regs, TCG_REG_O1);
tcg_regset_reset_reg(ct->u.regs, TCG_REG_O2); tcg_regset_reset_reg(ct->regs, TCG_REG_O2);
break; break;
case 's': /* qemu_st data 32-bit constraint */ case 's': /* qemu_st data 32-bit constraint */
ct->ct |= TCG_CT_REG; ct->regs = 0xffffffff;
ct->u.regs = 0xffffffff;
goto reserve_helpers; goto reserve_helpers;
case 'S': /* qemu_st data 64-bit constraint */ case 'S': /* qemu_st data 64-bit constraint */
ct->ct |= TCG_CT_REG; ct->regs = ALL_64;
ct->u.regs = ALL_64;
goto reserve_helpers; goto reserve_helpers;
case 'I': case 'I':
ct->ct |= TCG_CT_CONST_S11; ct->ct |= TCG_CT_CONST_S11;

35
tcg/tcg-op-gvec.c
View File

@ -37,11 +37,21 @@ static const TCGOpcode vecop_list_empty[1] = { 0 };
of the operand offsets so that we can check them all at once. */ of the operand offsets so that we can check them all at once. */
static void check_size_align(uint32_t oprsz, uint32_t maxsz, uint32_t ofs) static void check_size_align(uint32_t oprsz, uint32_t maxsz, uint32_t ofs)
{ {
uint32_t opr_align = oprsz >= 16 ? 15 : 7; uint32_t max_align;
uint32_t max_align = maxsz >= 16 || oprsz >= 16 ? 15 : 7;
tcg_debug_assert(oprsz > 0); switch (oprsz) {
tcg_debug_assert(oprsz <= maxsz); case 8:
tcg_debug_assert((oprsz & opr_align) == 0); case 16:
case 32:
tcg_debug_assert(oprsz <= maxsz);
break;
default:
tcg_debug_assert(oprsz == maxsz);
break;
}
tcg_debug_assert(maxsz <= (8 << SIMD_MAXSZ_BITS));
max_align = maxsz >= 16 ? 15 : 7;
tcg_debug_assert((maxsz & max_align) == 0); tcg_debug_assert((maxsz & max_align) == 0);
tcg_debug_assert((ofs & max_align) == 0); tcg_debug_assert((ofs & max_align) == 0);
} }
@ -77,12 +87,21 @@ uint32_t simd_desc(uint32_t oprsz, uint32_t maxsz, int32_t data)
{ {
uint32_t desc = 0; uint32_t desc = 0;
assert(oprsz % 8 == 0 && oprsz <= (8 << SIMD_OPRSZ_BITS)); check_size_align(oprsz, maxsz, 0);
assert(maxsz % 8 == 0 && maxsz <= (8 << SIMD_MAXSZ_BITS)); tcg_debug_assert(data == sextract32(data, 0, SIMD_DATA_BITS));
assert(data == sextract32(data, 0, SIMD_DATA_BITS));
oprsz = (oprsz / 8) - 1; oprsz = (oprsz / 8) - 1;
maxsz = (maxsz / 8) - 1; maxsz = (maxsz / 8) - 1;
/*
* We have just asserted in check_size_align that either
* oprsz is {8,16,32} or matches maxsz. Encode the final
* case with '2', as that would otherwise map to 24.
*/
if (oprsz == maxsz) {
oprsz = 2;
}
desc = deposit32(desc, SIMD_OPRSZ_SHIFT, SIMD_OPRSZ_BITS, oprsz); desc = deposit32(desc, SIMD_OPRSZ_SHIFT, SIMD_OPRSZ_BITS, oprsz);
desc = deposit32(desc, SIMD_MAXSZ_SHIFT, SIMD_MAXSZ_BITS, maxsz); desc = deposit32(desc, SIMD_MAXSZ_SHIFT, SIMD_MAXSZ_BITS, maxsz);
desc = deposit32(desc, SIMD_DATA_SHIFT, SIMD_DATA_BITS, data); desc = deposit32(desc, SIMD_DATA_SHIFT, SIMD_DATA_BITS, data);

12
tcg/tcg-op-vec.c
View File

@ -252,10 +252,10 @@ TCGv_vec tcg_const_ones_vec_matching(TCGv_vec m)
void tcg_gen_dup64i_vec(TCGv_vec r, uint64_t a) void tcg_gen_dup64i_vec(TCGv_vec r, uint64_t a)
{ {
if (TCG_TARGET_REG_BITS == 32 && a == deposit64(a, 32, 32, a)) { if (TCG_TARGET_REG_BITS == 64) {
do_dupi_vec(r, MO_32, a);
} else if (TCG_TARGET_REG_BITS == 64 || a == (uint64_t)(int32_t)a) {
do_dupi_vec(r, MO_64, a); do_dupi_vec(r, MO_64, a);
} else if (a == dup_const(MO_32, a)) {
do_dupi_vec(r, MO_32, a);
} else { } else {
TCGv_i64 c = tcg_const_i64(a); TCGv_i64 c = tcg_const_i64(a);
tcg_gen_dup_i64_vec(MO_64, r, c); tcg_gen_dup_i64_vec(MO_64, r, c);
@ -280,7 +280,11 @@ void tcg_gen_dup8i_vec(TCGv_vec r, uint32_t a)
void tcg_gen_dupi_vec(unsigned vece, TCGv_vec r, uint64_t a) void tcg_gen_dupi_vec(unsigned vece, TCGv_vec r, uint64_t a)
{ {
do_dupi_vec(r, MO_REG, dup_const(vece, a)); if (vece == MO_64) {
tcg_gen_dup64i_vec(r, a);
} else {
do_dupi_vec(r, MO_REG, dup_const(vece, a));
}
} }
void tcg_gen_dup_i64_vec(unsigned vece, TCGv_vec r, TCGv_i64 a) void tcg_gen_dup_i64_vec(unsigned vece, TCGv_vec r, TCGv_i64 a)

96
tcg/tcg.c
View File

@ -944,7 +944,6 @@ void tcg_context_init(TCGContext *s)
int op, total_args, n, i; int op, total_args, n, i;
TCGOpDef *def; TCGOpDef *def;
TCGArgConstraint *args_ct; TCGArgConstraint *args_ct;
int *sorted_args;
TCGTemp *ts; TCGTemp *ts;
memset(s, 0, sizeof(*s)); memset(s, 0, sizeof(*s));
@ -959,15 +958,12 @@ void tcg_context_init(TCGContext *s)
total_args += n; total_args += n;
} }
args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); args_ct = g_new0(TCGArgConstraint, total_args);
sorted_args = g_malloc(sizeof(int) * total_args);
for(op = 0; op < NB_OPS; op++) { for(op = 0; op < NB_OPS; op++) {
def = &tcg_op_defs[op]; def = &tcg_op_defs[op];
def->args_ct = args_ct; def->args_ct = args_ct;
def->sorted_args = sorted_args;
n = def->nb_iargs + def->nb_oargs; n = def->nb_iargs + def->nb_oargs;
sorted_args += n;
args_ct += n; args_ct += n;
} }
@ -2198,21 +2194,14 @@ static void tcg_dump_ops(TCGContext *s, bool have_prefs)
/* we give more priority to constraints with less registers */ /* we give more priority to constraints with less registers */
static int get_constraint_priority(const TCGOpDef *def, int k) static int get_constraint_priority(const TCGOpDef *def, int k)
{ {
const TCGArgConstraint *arg_ct; const TCGArgConstraint *arg_ct = &def->args_ct[k];
int n;
int i, n; if (arg_ct->oalias) {
arg_ct = &def->args_ct[k];
if (arg_ct->ct & TCG_CT_ALIAS) {
/* an alias is equivalent to a single register */ /* an alias is equivalent to a single register */
n = 1; n = 1;
} else { } else {
if (!(arg_ct->ct & TCG_CT_REG)) n = ctpop64(arg_ct->regs);
return 0;
n = 0;
for(i = 0; i < TCG_TARGET_NB_REGS; i++) {
if (tcg_regset_test_reg(arg_ct->u.regs, i))
n++;
}
} }
return TCG_TARGET_NB_REGS - n + 1; return TCG_TARGET_NB_REGS - n + 1;
} }
@ -2220,20 +2209,23 @@ static int get_constraint_priority(const TCGOpDef *def, int k)
/* sort from highest priority to lowest */ /* sort from highest priority to lowest */
static void sort_constraints(TCGOpDef *def, int start, int n) static void sort_constraints(TCGOpDef *def, int start, int n)
{ {
int i, j, p1, p2, tmp; int i, j;
TCGArgConstraint *a = def->args_ct;
for(i = 0; i < n; i++) for (i = 0; i < n; i++) {
def->sorted_args[start + i] = start + i; a[start + i].sort_index = start + i;
if (n <= 1) }
if (n <= 1) {
return; return;
for(i = 0; i < n - 1; i++) { }
for(j = i + 1; j < n; j++) { for (i = 0; i < n - 1; i++) {
p1 = get_constraint_priority(def, def->sorted_args[start + i]); for (j = i + 1; j < n; j++) {
p2 = get_constraint_priority(def, def->sorted_args[start + j]); int p1 = get_constraint_priority(def, a[start + i].sort_index);
int p2 = get_constraint_priority(def, a[start + j].sort_index);
if (p1 < p2) { if (p1 < p2) {
tmp = def->sorted_args[start + i]; int tmp = a[start + i].sort_index;
def->sorted_args[start + i] = def->sorted_args[start + j]; a[start + i].sort_index = a[start + j].sort_index;
def->sorted_args[start + j] = tmp; a[start + j].sort_index = tmp;
} }
} }
} }
@ -2268,8 +2260,6 @@ static void process_op_defs(TCGContext *s)
/* Incomplete TCGTargetOpDef entry. */ /* Incomplete TCGTargetOpDef entry. */
tcg_debug_assert(ct_str != NULL); tcg_debug_assert(ct_str != NULL);
def->args_ct[i].u.regs = 0;
def->args_ct[i].ct = 0;
while (*ct_str != '\0') { while (*ct_str != '\0') {
switch(*ct_str) { switch(*ct_str) {
case '0' ... '9': case '0' ... '9':
@ -2277,19 +2267,19 @@ static void process_op_defs(TCGContext *s)
int oarg = *ct_str - '0'; int oarg = *ct_str - '0';
tcg_debug_assert(ct_str == tdefs->args_ct_str[i]); tcg_debug_assert(ct_str == tdefs->args_ct_str[i]);
tcg_debug_assert(oarg < def->nb_oargs); tcg_debug_assert(oarg < def->nb_oargs);
tcg_debug_assert(def->args_ct[oarg].ct & TCG_CT_REG); tcg_debug_assert(def->args_ct[oarg].regs != 0);
/* TCG_CT_ALIAS is for the output arguments.
The input is tagged with TCG_CT_IALIAS. */
def->args_ct[i] = def->args_ct[oarg]; def->args_ct[i] = def->args_ct[oarg];
def->args_ct[oarg].ct |= TCG_CT_ALIAS; /* The output sets oalias. */
def->args_ct[oarg].oalias = true;
def->args_ct[oarg].alias_index = i; def->args_ct[oarg].alias_index = i;
def->args_ct[i].ct |= TCG_CT_IALIAS; /* The input sets ialias. */
def->args_ct[i].ialias = true;
def->args_ct[i].alias_index = oarg; def->args_ct[i].alias_index = oarg;
} }
ct_str++; ct_str++;
break; break;
case '&': case '&':
def->args_ct[i].ct |= TCG_CT_NEWREG; def->args_ct[i].newreg = true;
ct_str++; ct_str++;
break; break;
case 'i': case 'i':
@ -2855,13 +2845,13 @@ static void liveness_pass_1(TCGContext *s)
pset = la_temp_pref(ts); pset = la_temp_pref(ts);
set = *pset; set = *pset;
set &= ct->u.regs; set &= ct->regs;
if (ct->ct & TCG_CT_IALIAS) { if (ct->ialias) {
set &= op->output_pref[ct->alias_index]; set &= op->output_pref[ct->alias_index];
} }
/* If the combination is not possible, restart. */ /* If the combination is not possible, restart. */
if (set == 0) { if (set == 0) {
set = ct->u.regs; set = ct->regs;
} }
*pset = set; *pset = set;
} }
@ -3551,8 +3541,8 @@ static void tcg_reg_alloc_dup(TCGContext *s, const TCGOp *op)
return; return;
} }
dup_out_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[0].u.regs; dup_out_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[0].regs;
dup_in_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[1].u.regs; dup_in_regs = tcg_op_defs[INDEX_op_dup_vec].args_ct[1].regs;
/* Allocate the output register now. */ /* Allocate the output register now. */
if (ots->val_type != TEMP_VAL_REG) { if (ots->val_type != TEMP_VAL_REG) {
@ -3659,7 +3649,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
for (k = 0; k < nb_iargs; k++) { for (k = 0; k < nb_iargs; k++) {
TCGRegSet i_preferred_regs, o_preferred_regs; TCGRegSet i_preferred_regs, o_preferred_regs;
i = def->sorted_args[nb_oargs + k]; i = def->args_ct[nb_oargs + k].sort_index;
arg = op->args[i]; arg = op->args[i];
arg_ct = &def->args_ct[i]; arg_ct = &def->args_ct[i];
ts = arg_temp(arg); ts = arg_temp(arg);
@ -3673,7 +3663,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
} }
i_preferred_regs = o_preferred_regs = 0; i_preferred_regs = o_preferred_regs = 0;
if (arg_ct->ct & TCG_CT_IALIAS) { if (arg_ct->ialias) {
o_preferred_regs = op->output_pref[arg_ct->alias_index]; o_preferred_regs = op->output_pref[arg_ct->alias_index];
if (ts->fixed_reg) { if (ts->fixed_reg) {
/* if fixed register, we must allocate a new register /* if fixed register, we must allocate a new register
@ -3695,9 +3685,8 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
int k2, i2; int k2, i2;
reg = ts->reg; reg = ts->reg;
for (k2 = 0 ; k2 < k ; k2++) { for (k2 = 0 ; k2 < k ; k2++) {
i2 = def->sorted_args[nb_oargs + k2]; i2 = def->args_ct[nb_oargs + k2].sort_index;
if ((def->args_ct[i2].ct & TCG_CT_IALIAS) && if (def->args_ct[i2].ialias && reg == new_args[i2]) {
reg == new_args[i2]) {
goto allocate_in_reg; goto allocate_in_reg;
} }
} }
@ -3706,10 +3695,10 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
} }
} }
temp_load(s, ts, arg_ct->u.regs, i_allocated_regs, i_preferred_regs); temp_load(s, ts, arg_ct->regs, i_allocated_regs, i_preferred_regs);
reg = ts->reg; reg = ts->reg;
if (tcg_regset_test_reg(arg_ct->u.regs, reg)) { if (tcg_regset_test_reg(arg_ct->regs, reg)) {
/* nothing to do : the constraint is satisfied */ /* nothing to do : the constraint is satisfied */
} else { } else {
allocate_in_reg: allocate_in_reg:
@ -3717,7 +3706,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
and move the temporary register into it */ and move the temporary register into it */
temp_load(s, ts, tcg_target_available_regs[ts->type], temp_load(s, ts, tcg_target_available_regs[ts->type],
i_allocated_regs, 0); i_allocated_regs, 0);
reg = tcg_reg_alloc(s, arg_ct->u.regs, i_allocated_regs, reg = tcg_reg_alloc(s, arg_ct->regs, i_allocated_regs,
o_preferred_regs, ts->indirect_base); o_preferred_regs, ts->indirect_base);
if (!tcg_out_mov(s, ts->type, reg, ts->reg)) { if (!tcg_out_mov(s, ts->type, reg, ts->reg)) {
/* /*
@ -3760,7 +3749,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
/* satisfy the output constraints */ /* satisfy the output constraints */
for(k = 0; k < nb_oargs; k++) { for(k = 0; k < nb_oargs; k++) {
i = def->sorted_args[k]; i = def->args_ct[k].sort_index;
arg = op->args[i]; arg = op->args[i];
arg_ct = &def->args_ct[i]; arg_ct = &def->args_ct[i];
ts = arg_temp(arg); ts = arg_temp(arg);
@ -3768,15 +3757,14 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
/* ENV should not be modified. */ /* ENV should not be modified. */
tcg_debug_assert(!ts->fixed_reg); tcg_debug_assert(!ts->fixed_reg);
if ((arg_ct->ct & TCG_CT_ALIAS) if (arg_ct->oalias && !const_args[arg_ct->alias_index]) {
&& !const_args[arg_ct->alias_index]) {
reg = new_args[arg_ct->alias_index]; reg = new_args[arg_ct->alias_index];
} else if (arg_ct->ct & TCG_CT_NEWREG) { } else if (arg_ct->newreg) {
reg = tcg_reg_alloc(s, arg_ct->u.regs, reg = tcg_reg_alloc(s, arg_ct->regs,
i_allocated_regs | o_allocated_regs, i_allocated_regs | o_allocated_regs,
op->output_pref[k], ts->indirect_base); op->output_pref[k], ts->indirect_base);
} else { } else {
reg = tcg_reg_alloc(s, arg_ct->u.regs, o_allocated_regs, reg = tcg_reg_alloc(s, arg_ct->regs, o_allocated_regs,
op->output_pref[k], ts->indirect_base); op->output_pref[k], ts->indirect_base);
} }
tcg_regset_set_reg(o_allocated_regs, reg); tcg_regset_set_reg(o_allocated_regs, reg);

3
tcg/tci/tcg-target.c.inc
View File

@ -392,8 +392,7 @@ static const char *target_parse_constraint(TCGArgConstraint *ct,
case 'r': case 'r':
case 'L': /* qemu_ld constraint */ case 'L': /* qemu_ld constraint */
case 'S': /* qemu_st constraint */ case 'S': /* qemu_st constraint */
ct->ct |= TCG_CT_REG; ct->regs = BIT(TCG_TARGET_NB_REGS) - 1;
ct->u.regs = BIT(TCG_TARGET_NB_REGS) - 1;
break; break;
default: default:
return NULL; return NULL;