tcg-i386: Implement small forward branches.
A message that is not in the archive (sent off-list or not yet received): [email protected]
cover tcg conditional set/move, round 2
Quoted 1 line
funny how you seem to follow the same paths I did months ago :-)
Heh. They are the obvious points for improvement in the emulation. Hopefully we can get them finished this time, so that some third person doesn't go through the same thing next year. =)
Quoted 2 lines
- cosmetics: don't use tabs and be sure not to have whitespaces at end of lines
Grr, I thought I'd been extra careful about that. Fixed.
Quoted 1 line
- the changes to
tcg-op.hin patch 6 should go with patch 1
Done.
Quoted 4 lines
- outside of the small parameter handling, I'd prefer you provide a separate patch for
tcg_out_brcond2; I don't think the changes using c1, c2 and c3 really belong to setcond/movcond.
The i386 part has been split into 3 patches, though they are sequentially dependent.
I've left off the sparc backend patch, as well as the patches for the translators. Let's take care of these first.
r~
---
Richard Henderson (6):
tcg: Generic support for conditional set and conditional move.
tcg: Add tcg_invert_cond.
tcg-x86_64: Implement setcond and movcond.
tcg-i386: Implement small forward branches.
tcg-i386: Simplify brcond2.
tcg-i386: Implement setcond, movcond, setcond2.
elf.h | 2 + tcg/README | 26 ++++- tcg/i386/tcg-target.c | 278 ++++++++++++++++++++++++++++++++++++++-------- tcg/tcg-op.h | 91 +++++++++++++++ tcg/tcg-opc.h | 5 + tcg/tcg.c | 23 +++- tcg/tcg.h | 5 + tcg/x86_64/tcg-target.c | 65 +++++++++++- 8 files changed, 436 insertions(+), 59 deletions(-)
PATCH 1/6 tcg: Generic support for conditional set and conditional move.
Defines setcond and movcond for implementing conditional moves at the tcg opcode level. 64-bit-on-32-bit is expanded via a setcond2 primitive plus other operations.
--- tcg/README | 26 +++++++++++++++- tcg/tcg-op.h | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tcg/tcg-opc.h | 5 +++ tcg/tcg.c | 23 ++++++++++---- 4 files changed, 138 insertions(+), 7 deletions(-)
tcg/README +25 -1
@@ -152,6 +152,11 @@ Conditional jump if t0 cond t1 is true. cond can be: TCG_COND_LEU /* unsigned */ TCG_COND_GTU /* unsigned */ +* brcond2_i32 cond, t0_low, t0_high, t1_low, t1_high, label + +Similar to brcond, except that the 64-bit values T0 and T1 +are formed from two 32-bit arguments. + ********* Arithmetic * add_i32/i64 t0, t1, t2
@@ -282,6 +287,25 @@ order bytes must be set to zero. Indicate that the value of t0 won't be used later. It is useful to force dead code elimination. +********* Conditional moves + +* setcond_i32/i64 cond, dest, t1, t2 + +dest = (t1 cond t2) + +Set DEST to 1 if (T1 cond T2) is true, otherwise set to 0. + +* movcond_i32/i64 cond, dest, c1, c2, vtrue, vfalse + +dest= (c1 cond c2 ? vtrue : of) + +Set DEST to VTRUE if (c1 cond c2) is true, otherwise set to VFALSE. + +* setcond2_i32 cond, dest, t1_low, t1_high, t2_low, t2_high + +Similar to setcond, except that the 64-bit values T1 and T2 are +formed from two 32-bit arguments. The result is a 32-bit value. + ********* Type conversions * ext_i32_i64 t0, t1
@@ -375,7 +399,7 @@ The target word size (TCG_TARGET_REG_BITS) is expected to be 32 bit or On a 32 bit target, all 64 bit operations are converted to 32 bits. A few specific operations must be implemented to allow it (see add2_i32, -sub2_i32, brcond2_i32). +sub2_i32, brcond2_i32, setcond2_i32). Floating point operations are not supported in this version. A previous incarnation of the code generator had full support of them,
tcg/tcg-op.h +91 -0
115 lines not on this page · raw message
tcg/tcg-opc.h +5 -0
@@ -42,6 +42,8 @@ DEF2(br, 0, 0, 1, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mov_i32, 1, 1, 0, 0) DEF2(movi_i32, 1, 0, 1, 0) +DEF2(setcond_i32, 1, 2, 1, 0) +DEF2 (movcond_i32,1 ,4 ,1 ,0 ) /* load/store */ DEF2(ld8u_i32, 1, 1, 1, 0)DEF2 (ld8s_i32,1 ,1 ,1 ,0 )
@@ -82,6 +84,7 @@ DEF2(add2_i32, 2, 4, 0, 0) DEF2(sub2_i32, 2, 4, 0, 0) DEF2(brcond2_i32, 0, 4, 2, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mulu2_i32, 2, 2, 0, 0) +DEF2(setcond2_i32, 1, 4, 1, 0)#endif #ifdef TCG_TARGET_HAS_ext8s_i32DEF2 (ext8s_i32,1 ,1 ,0 ,0 )
@@ -111,6 +114,8 @@ DEF2(neg_i32, 1, 1, 0, 0)#if TCG_TARGET_REG_BITS ==64 DEF2(mov_i64, 1, 1, 0, 0) DEF2(movi_i64, 1, 0, 1, 0) +DEF2(setcond_i64, 1, 2, 1, 0) +DEF2 (movcond_i64,1 ,4 ,1 ,0 ) /* load/store */ DEF2(ld8u_i64, 1, 1, 1, 0)DEF2 (ld8s_i64,1 ,1 ,1 ,0 )
tcg/tcg.c +17 -6
@@ -670,6 +670,7 @@ void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, }#endif +static void tcg_reg_alloc_start (TCGContext *s) {int i;
@@ -888,21 +889,31 @@ void tcg_dump_ops(TCGContext *s, FILE *outfile)fprintf (outfile,"%s" ,tcg_get_arg_str_idx (s, buf,sizeof (buf), args[k++])); } -if (c == INDEX_op_brcond_i32 +switch (c) { +case INDEX_op_brcond_i32: +#if TCG_TARGET_REG_BITS ==32 +case INDEX_op_brcond2_i32: +#elif TCG_TARGET_REG_BITS ==64 +case INDEX_op_brcond_i64: +#endif +case INDEX_op_setcond_i32: +case INDEX_op_movcond_i32:#if TCG_TARGET_REG_BITS ==32 - || c == INDEX_op_brcond2_i32 +case INDEX_op_setcond2_i32:#elif TCG_TARGET_REG_BITS ==64 - || c == INDEX_op_brcond_i64 +case INDEX_op_setcond_i64: +case INDEX_op_movcond_i64:#endif - ) {if (args[k] <ARRAY_SIZE (cond_name) && cond_name[args[k]])fprintf (outfile,",%s" , cond_name[args[k++]]);else fprintf (outfile,",$0x%" TCG_PRIlx, args[k++]); i =1 ; - } -else +break ; +default : i =0 ; +break ; + }for (; i < nb_cargs; i++) {if (k !=0 )fprintf (outfile,"," );
Signature · 1 line
1.6.5.2
Re: [Qemu-devel] [PATCH 1/6] tcg: Generic support for conditional set and conditional move.
Quoted 33 lines · Richard Henderson
Defines setcond and movcond for implementing conditional moves at the tcg opcode level. 64-bit-on-32-bit is expanded via a setcond2 primitive plus other operations.
Signed-off-by Richard Henderson <[email protected]>--- tcg/README | 26 +++++++++++++++- tcg/tcg-op.h | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tcg/tcg-opc.h | 5 +++ tcg/tcg.c | 23 ++++++++++---- 4 files changed, 138 insertions(+), 7 deletions(-)tcg/README +6
-0@@ -152,6 +152,11 @@ Conditional jump if t0 cond t1 is true. cond can be: TCG_COND_LEU /* unsigned */ TCG_COND_GTU /* unsigned */ +* brcond2_i32 cond, t0_low, t0_high, t1_low, t1_high, label + +Similar to brcond, except that the 64-bit values T0 and T1 +are formed from two 32-bit arguments. + ********* Arithmetic * add_i32/i64 t0, t1, t2@@ -282,6 +287,25 @@ order bytes must be set to zero. Indicate that the value of t0 won't be used later. It is useful to force dead code elimination. +********* Conditional moves
tcg/README order bytes must be set to zero. · line 300
Quoted 10 lines
tcg/README +10
-0+ +* setcond_i32/i64 cond, dest, t1, t2 + +dest = (t1 cond t2) + +Set DEST to 1 if (T1 cond T2) is true, otherwise set to 0. + +* movcond_i32/i64 cond, dest, c1, c2, vtrue, vfalse + +dest= (c1 cond c2 ? vtrue : of)
Nitpick: no space before '='
tcg/README order bytes must be set to zero. · line 302
Quoted 2 lines
tcg/README +2
-0+ +Set DEST to VTRUE if (c1 cond c2) is true, otherwise set to VFALSE.
But it reads ? vtrue : of'. Should probably be ? vtrue : vfalse`
[..snip..]
Signature · 1 line
mailto:[email protected]
[Qemu-devel] Re: [PATCH 1/6] tcg: Generic support for conditional set and conditional move.
In reply to Richard HendersonQuoted 33 lines · Richard Henderson
Defines setcond and movcond for implementing conditional moves at the tcg opcode level. 64-bit-on-32-bit is expanded via a setcond2 primitive plus other operations.
Signed-off-by Richard Henderson <[email protected]>---
tcg/README | 26 +++++++++++++++-
tcg/tcg-op.h | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++tcg/tcg-opc.h| 5 +++
tcg/tcg.c | 23 ++++++++++----4 files changed, 138 insertions(+), 7 deletions(-)tcg/README +0
-0@@ -152,6 +152,11 @@ Conditional jump if t0 cond t1 is true. cond can be:
TCG_COND_LEU/* unsigned */
TCG_COND_GTU/* unsigned */tcg/README +5
-0+* brcond2_i32 cond, t0_low, t0_high, t1_low, t1_high, label + +Similar to brcond, except that the 64-bit values T0 and T1 +are formed from two 32-bit arguments. +********* Arithmetic
* add_i32/i64 t0, t1, t2
tcg/README +0
-0@@ -282,6 +287,25 @@ order bytes must be set to zero.Indicate that the value of t0 won't be used later. It is useful to force dead code elimination.
tcg/README +1
-0+********* Conditional moves
tcg/README order bytes must be set to zero. · line 300
Quoted 10 lines
tcg/README +10
-0+ +* setcond_i32/i64 cond, dest, t1, t2 + +dest = (t1 cond t2) + +Set DEST to 1 if (T1 cond T2) is true, otherwise set to 0. + +* movcond_i32/i64 cond, dest, c1, c2, vtrue, vfalse + +dest= (c1 cond c2 ? vtrue : of)
As malc already wrote this should be:
dest = (c1 cond c2 ? vtrue : vfalse)
Quoted 110 lines
tcg/README +8
-0+ +Set DEST to VTRUE if (c1 cond c2) is true, otherwise set to VFALSE. + +* setcond2_i32 cond, dest, t1_low, t1_high, t2_low, t2_high + +Similar to setcond, except that the 64-bit values T1 and T2 are +formed from two 32-bit arguments. The result is a 32-bit value. +********* Type conversions
*
ext_i32_i64t0, t1tcg/README +0
-0@@ -375,7 +399,7 @@ The target word size (TCG_TARGET_REG_BITS) is expected to be 32 bit orOn a 32 bit target, all 64 bit operations are converted to 32 bits. A few specific operations must be implemented to allow it (see
add2_i32,tcg/README +1
-1-sub2_i32, brcond2_i32). +sub2_i32, brcond2_i32, setcond2_i32).Floating point operations are not supported in this version. A previous incarnation of the code generator had full support of them,
tcg/tcg-op.h +75
-0@@ -280,6 +280,32 @@ static inline void tcg_gen_op6_i64(int opc, TCGv_i64 arg1, TCGv_i64 arg2, *gen_opparam_ptr++ = GET_TCGV_I64(arg6); } +static inline void tcg_gen_op6i_i32 (int opc,TCGv_i32 arg1,TCGv_i32 arg2, + TCGv_i32 arg3, TCGv_i32 arg4, + TCGv_i32 arg5, TCGArg arg6) +{ + *gen_opc_ptr++ = opc; + *gen_opparam_ptr++ = GET_TCGV_I32(arg1); + *gen_opparam_ptr++ = GET_TCGV_I32(arg2); + *gen_opparam_ptr++ = GET_TCGV_I32(arg3); + *gen_opparam_ptr++ = GET_TCGV_I32(arg4); + *gen_opparam_ptr++ = GET_TCGV_I32(arg5); + *gen_opparam_ptr++ = arg6; +} + +static inline void tcg_gen_op6i_i64 (int opc,TCGv_i64 arg1,TCGv_i64 arg2, + TCGv_i64 arg3, TCGv_i64 arg4, + TCGv_i64 arg5, TCGArg arg6) +{ + *gen_opc_ptr++ = opc; + *gen_opparam_ptr++ = GET_TCGV_I64(arg1); + *gen_opparam_ptr++ = GET_TCGV_I64(arg2); + *gen_opparam_ptr++ = GET_TCGV_I64(arg3); + *gen_opparam_ptr++ = GET_TCGV_I64(arg4); + *gen_opparam_ptr++ = GET_TCGV_I64(arg5); + *gen_opparam_ptr++ = arg6; +} + static inline void tcg_gen_op6ii_i32(int opc, TCGv_i32 arg1, TCGv_i32 arg2, TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5, TCGArg arg6)@@ -1795,6 +1821,67 @@ static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) } } +static inline void tcg_gen_setcond_i32 (int cond,TCGv_i32 ret, + TCGv_i32 arg1, TCGv_i32 arg2) +{ + tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond); +} + +static inline void tcg_gen_setcond_i64 (int cond,TCGv_i64 ret, + TCGv_i64 arg1, TCGv_i64 arg2) +{ +#if TCG_TARGET_REG_BITS ==64 + tcg_gen_op4i_i64(INDEX_op_setcond_i64, ret, arg1, arg2, cond); +#else + tcg_gen_op6i_i32(INDEX_op_setcond2_i32, TCGV_LOW(ret), + TCGV_LOW(arg1), TCGV_HIGH(arg1), + TCGV_LOW(arg2), TCGV_HIGH(arg2), cond); + tcg_gen_movi_i32(TCGV_HIGH(ret), 0); +#endif +} + +static inline void tcg_gen_movcond_i32 (int cond,TCGv_i32 ret, + TCGv_i32 cmp1, TCGv_i32 cmp2, + TCGv_i32 op_t, TCGv_i32 op_f) +{ + if (TCGV_EQUAL_I32(op_t, op_f)) { + tcg_gen_mov_i32(ret, op_t); + return; + } + tcg_gen_op6i_i32(INDEX_op_movcond_i32, ret, cmp1, cmp2, op_t, op_f, cond); +} + +static inline void tcg_gen_movcond_i64 (int cond,TCGv_i64 ret, + TCGv_i64 cmp1, TCGv_i64 cmp2, + TCGv_i64 op_t, TCGv_i64 op_f) +{ + if (TCGV_EQUAL_I64(op_t, op_f)) { + tcg_gen_mov_i64(ret, op_t); + return; + } +#if TCG_TARGET_REG_BITS ==64 + tcg_gen_op6i_i64(INDEX_op_movcond_i64, ret, cmp1, cmp2, op_t, op_f, cond); +#else + { + TCGv_i32 t0 = tcg_temp_new_i32(); + TCGv_i32 zero = tcg_const_i32(0); + + tcg_gen_op6i_i32(INDEX_op_setcond2_i32, t0, + TCGV_LOW(cmp1), TCGV_HIGH(cmp1), + TCGV_LOW(cmp2), TCGV_HIGH(cmp2), cond); +
tcg/tcg-op.h static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2) · line 1882
Quoted 10 lines
tcg/tcg-op.h +10
-0+ /* ??? We could perhaps conditionally define a movcond2_i32. */ + tcg_gen_movcond_i32(TCG_COND_NE, TCGV_LOW(ret), t0, zero, + TCGV_LOW(op_t), TCGV_LOW(op_f)); + tcg_gen_movcond_i32(TCG_COND_NE, TCGV_HIGH(ret), t0, zero, + TCGV_HIGH(op_t), TCGV_HIGH(op_f)); + + tcg_temp_free_i32(t0); + tcg_temp_free_i32(zero); + } +#endif
I agree movcond2 would be handy (though it can be argued that anyway the speed of a 64-bit guest on a 32-bit host, where it would matter the most, is low anyway).
I think it would also be nice to have to have a movtrue helper that'd simply be movcond cond, dest, c1, c2, vtrue, dest.
All that can wait.
Quoted 58 lines
tcg/tcg-op.h +2
-0+} + /***************************************/ /* QEMU specific operations. Their type depend on the QEMU CPUtype. */
tcg/tcg-op.h +4
-0@@ -2067,6 +2154,8 @@ static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index) #define tcg_gen_sari_tl tcg_gen_sari_i64 #define tcg_gen_brcond_tl tcg_gen_brcond_i64 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i64 +#define tcg_gen_setcond_tl tcg_gen_setcond_i64 +#define tcg_gen_movcond_tl tcg_gen_movcond_i64 #define tcg_gen_mul_tl tcg_gen_mul_i64 #define tcg_gen_muli_tl tcg_gen_muli_i64 #define tcg_gen_div_tl tcg_gen_div_i64@@ -2137,6 +2226,8 @@ static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index) #define tcg_gen_sari_tl tcg_gen_sari_i32 #define tcg_gen_brcond_tl tcg_gen_brcond_i32 #define tcg_gen_brcondi_tl tcg_gen_brcondi_i32 +#define tcg_gen_setcond_tl tcg_gen_setcond_i32 +#define tcg_gen_movcond_tl tcg_gen_movcond_i32 #define tcg_gen_mul_tl tcg_gen_mul_i32 #define tcg_gen_muli_tl tcg_gen_muli_i32 #define tcg_gen_div_tl tcg_gen_div_i32tcg/tcg-opc.h +5
-0@@ -42,6 +42,8 @@ DEF2(br, 0, 0, 1, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mov_i32, 1, 1, 0, 0) DEF2(movi_i32, 1, 0, 1, 0) +DEF2(setcond_i32, 1, 2, 1, 0) +DEF2(movcond_i32, 1, 4, 1, 0) /* load/store */ DEF2(ld8u_i32, 1, 1, 1, 0) DEF2(ld8s_i32, 1, 1, 1, 0)@@ -82,6 +84,7 @@ DEF2(add2_i32, 2, 4, 0, 0) DEF2(sub2_i32, 2, 4, 0, 0) DEF2(brcond2_i32, 0, 4, 2, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mulu2_i32, 2, 2, 0, 0) +DEF2(setcond2_i32, 1, 4, 1, 0) #endif #ifdef TCG_TARGET_HAS_ext8s_i32 DEF2(ext8s_i32, 1, 1, 0, 0)@@ -111,6 +114,8 @@ DEF2(neg_i32, 1, 1, 0, 0) #if TCG_TARGET_REG_BITS == 64 DEF2(mov_i64, 1, 1, 0, 0) DEF2(movi_i64, 1, 0, 1, 0) +DEF2(setcond_i64, 1, 2, 1, 0) +DEF2(movcond_i64, 1, 4, 1, 0) /* load/store */ DEF2(ld8u_i64, 1, 1, 1, 0) DEF2(ld8s_i64, 1, 1, 1, 0)tcg/tcg.c +0
-0
tcg/tcg.c void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, · line 673
Quoted 4 lines
tcg/tcg.c +1
-0@@ -670,6 +670,7 @@ void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, } #endif +
Was this really needed? :-)
Laurent
Quoted 45 lines
tcg/tcg.c +12
-4static void tcg_reg_alloc_start(TCGContext *s) { int i;@@ -888,21 +889,31 @@ void tcg_dump_ops(TCGContext *s, FILE *outfile) fprintf(outfile, "%s", tcg_get_arg_str_idx(s, buf, sizeof(buf), args[k++])); } - if (c == INDEX_op_brcond_i32 + switch (c) { + case INDEX_op_brcond_i32: +#if TCG_TARGET_REG_BITS ==32 + case INDEX_op_brcond2_i32: +#elif TCG_TARGET_REG_BITS ==64 + case INDEX_op_brcond_i64: +#endif + case INDEX_op_setcond_i32: + case INDEX_op_movcond_i32: #if TCG_TARGET_REG_BITS == 32 - || c == INDEX_op_brcond2_i32 + case INDEX_op_setcond2_i32: #elif TCG_TARGET_REG_BITS == 64 - || c == INDEX_op_brcond_i64 + case INDEX_op_setcond_i64: + case INDEX_op_movcond_i64: #endif - ) { if (args[k] < ARRAY_SIZE(cond_name) && cond_name[args[k]]) fprintf(outfile, ",%s", cond_name[args[k++]]);else
fprintf(outfile, ",$0x%" TCG_PRIlx, args[k++]); i = 1;
- }
- else
+ break;
+ default:
i = 0;
+ break;
+ }
for(; i < nb_cargs; i++){
if (k != 0)
fprintf(outfile, ",");
--
1.6.5.2
PATCH 2/6 tcg: Add tcg_invert_cond.
In reply to Richard HendersonIt is very handy to have a reliable mapping of a condition to its inverse. This will be used in several patches to follow.
--- tcg/tcg.h | 5 +++++ 1 files changed, 5 insertions(+), 0 deletions(-)
tcg/tcg.h +5 -0
@@ -205,6 +205,11 @@ typedef enum {TCG_COND_GTU , } TCGCond; +static inline TCGCond tcg_invert_cond (TCGCond c) +{ +return (TCGCond)(c ^1 ); +} +#define TEMP_VAL_DEAD 0#define TEMP_VAL_REG 1#define TEMP_VAL_MEM 2
Signature · 1 line
1.6.5.2
[Qemu-devel] Re: [PATCH 2/6] tcg: Add tcg_invert_cond.
Quoted 4 lines · Richard Henderson
It is very handy to have a reliable mapping of a condition to its inverse. This will be used in several patches to follow.
Signed-off-by Richard Henderson <[email protected]>
Laurent
Quoted 24 lines
---
tcg/tcg.h | 5 +++++1 files changed, 5 insertions(+), 0 deletions(-)tcg/tcg.h +5
-1@@ -205,6 +205,11 @@ typedef enum { TCG_COND_GTU, } TCGCond; +static inline TCGCond tcg_invert_cond (TCGCond c) +{ + return (TCGCond)(c ^ 1); +} + #define TEMP_VAL_DEAD 0 #define TEMP_VAL_REG 1 #define TEMP_VAL_MEM 2 --1.6.5.2
PATCH 3/6 tcg-x86_64: Implement setcond and movcond.
In reply to Richard HendersonImplement conditional moves in the x86_64 backend.
--- tcg/x86_64/tcg-target.c | 65 ++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 62 insertions(+), 3 deletions(-)
tcg/x86_64/tcg-target.c +62 -3
@@ -491,9 +491,8 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index) } } -static void tcg_out_brcond (TCGContext *s,int cond, -TCGArg arg1,TCGArg arg2,int const_arg2, -int label_index,int rexw) +static void tcg_out_cond (TCGContext *s,int cond,TCGArg arg1, +TCGArg arg2,int const_arg2,int rexw) {if (const_arg2) {if (arg2 ==0 ) {
@@ -508,9 +507,45 @@ static void tcg_out_brcond(TCGContext *s, int cond, }else {tcg_out_modrm (s,0x01 | (ARITH_CMP <<3 ) | rexw, arg2, arg1); } +} + +static void tcg_out_brcond (TCGContext *s,int cond, +TCGArg arg1,TCGArg arg2,int const_arg2, +int label_index,int rexw) +{ +tcg_out_cond (s, cond, arg1, arg2, const_arg2, rexw);tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_index); } +static void tcg_out_setcond (TCGContext *s,int cond,TCGArg arg0, +TCGArg arg1,TCGArg arg2,int const_arg2,int rexw) +{ +int use_xor = (arg0 != arg1 && (const_arg2 || arg0 != arg2)); + +if (use_xor) +tcg_out_movi (s,TCG_TYPE_I32 , arg0,0 ); +tcg_out_cond (s, cond, arg1, arg2, const_arg2, rexw); +tcg_out_modrm (s,0x90 | tcg_cond_to_jcc[cond] |P_EXT |P_REXB ,0 , arg0); +if (!use_xor) +tgen_arithi32 (s,ARITH_AND , arg0,0xff ); +} + +static void tcg_out_movcond (TCGContext *s,int cond,TCGArg arg0, +TCGArg arg1,TCGArg arg2,int const_arg2, +TCGArg arg3,TCGArg arg4,int rexw) +{ +if (arg0 == arg3) { + cond =tcg_invert_cond (cond); + arg3 = arg4; + arg4 = arg0; + } + +tcg_out_cond (s, cond, arg1, arg2, const_arg2, rexw); +if (arg0 != arg4) +tcg_out_mov (s, arg0, arg4); +tcg_out_modrm (s,0x40 | tcg_cond_to_jcc[cond] |P_EXT | rexw, arg0, arg3); +} +#if defined(CONFIG_SOFTMMU )#include "../../softmmu_defs.h"
@@ -1197,6 +1232,24 @@ static inline void tcg_out_op(TCGContext *s, int opc, const TCGArg *args,tcg_out_modrm (s,0x8b , args[0 ], args[1 ]);break ; +case INDEX_op_setcond_i32: +tcg_out_setcond (s, args[3 ], args[0 ], args[1 ], args[2 ], + const_args[2 ],0 ); +break ; +case INDEX_op_setcond_i64: +tcg_out_setcond (s, args[3 ], args[0 ], args[1 ], args[2 ], + const_args[2 ],P_REXW ); +break ; + +case INDEX_op_movcond_i32: +tcg_out_movcond (s, args[5 ], args[0 ], args[1 ], args[2 ], + const_args[2 ], args[3 ], args[4 ],0 ); +break ; +case INDEX_op_movcond_i64: +tcg_out_movcond (s, args[5 ], args[0 ], args[1 ], args[2 ], + const_args[2 ], args[3 ], args[4 ],P_REXW ); +break ; +case INDEX_op_qemu_ld8u:tcg_out_qemu_ld (s, args,0 );break ;
@@ -1376,6 +1429,12 @@ static const TCGTargetOpDef x86_64_op_defs[] = { { INDEX_op_ext16u_i64, { "r", "r"} }, { INDEX_op_ext32u_i64, { "r", "r"} }, + { INDEX_op_setcond_i32, { "r", "r", "re" } }, + { INDEX_op_setcond_i64, { "r", "r", "re" } }, + + { INDEX_op_movcond_i32, { "r", "r", "re", "r", "r" } }, + { INDEX_op_movcond_i64, { "r", "r", "re", "r", "r" } }, + { INDEX_op_qemu_ld8u, { "r", "L" } }, { INDEX_op_qemu_ld8s, { "r", "L" } }, { INDEX_op_qemu_ld16u, { "r", "L" } },
Signature · 1 line
1.6.5.2
[Qemu-devel] Re: [PATCH 3/6] tcg-x86_64: Implement setcond and movcond.
Quoted 29 lines · Richard Henderson
Implement conditional moves in the
x86_64backend.Signed-off-by Richard Henderson <[email protected]>---
tcg/x86_64/tcg-target.c | 65 ++++++++++++++++++++++++++++++++++++++++++++--1 files changed, 62 insertions(+), 3 deletions(-)tcg/x86_64/tcg-target.c +4
-3@@ -491,9 +491,8 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index) } } -static void tcg_out_brcond (TCGContext *s,int cond, - TCGArg arg1, TCGArg arg2, int const_arg2, - int label_index, int rexw) +static void tcg_out_cond (TCGContext *s,int cond,TCGArg arg1, + TCGArg arg2, int const_arg2, int rexw) { if (const_arg2) { if (arg2 == 0) {@@ -508,9 +507,45 @@ static void tcg_out_brcond(TCGContext *s, int cond, } else { tcg_out_modrm(s, 0x01 | (ARITH_CMP << 3) | rexw, arg2, arg1); } +} +
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 521
Quoted 10 lines
tcg/x86_64/tcg-target.c +7
-0+static void tcg_out_brcond (TCGContext *s,int cond, + TCGArg arg1, TCGArg arg2, int const_arg2, + int label_index, int rexw) +{ + tcg_out_cond(s, cond, arg1, arg2, const_arg2, rexw); tcg_out_jxx(s, tcg_cond_to_jcc[cond], label_index); } +static void tcg_out_setcond (TCGContext *s,int cond,TCGArg arg0, + TCGArg arg1, TCGArg arg2, int const_arg2, int rexw)
Perhaps renaming arg0 to dest would make things slightly more readable.
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 528
Quoted 7 lines
tcg/x86_64/tcg-target.c +7
-0+{ + int use_xor = (arg0 != arg1 && (const_arg2 || arg0 != arg2)); + + if (use_xor) + tcg_out_movi(s, TCG_TYPE_I32, arg0, 0); + tcg_out_cond(s, cond, arg1, arg2, const_arg2, rexw); + tcg_out_modrm(s, 0x90 | tcg_cond_to_jcc[cond] | P_EXT | P_REXB, 0, arg0);
A comment saying this is a setcc would be nice.
Also note that tcg_out_modrm will generate an unneeded prefix for some registers. cf. the patch I sent to the list months ago.
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 530
Quoted 2 lines
tcg/x86_64/tcg-target.c +2
-0+ if (!use_xor) + tgen_arithi32(s, ARITH_AND, arg0, 0xff);
Wouldn't movzbl be better?
Regarding the xor optimization, I tested it on my i7 and it was (very) slightly slower running a 64-bit SPEC2k gcc.
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 535
Quoted 5 lines
tcg/x86_64/tcg-target.c +5
-0+} + +static void tcg_out_movcond (TCGContext *s,int cond,TCGArg arg0, + TCGArg arg1, TCGArg arg2, int const_arg2, + TCGArg arg3, TCGArg arg4, int rexw)
Perhaps renaming arg0 to dest would make things slightly more readable.
You should also add a note stating that arg3 != arg4.
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 546
Quoted 11 lines
tcg/x86_64/tcg-target.c +11
-0+{ + if (arg0 == arg3) { + cond = tcg_invert_cond(cond); + arg3 = arg4; + arg4 = arg0; + } + + tcg_out_cond(s, cond, arg1, arg2, const_arg2, rexw); + if (arg0 != arg4) + tcg_out_mov(s, arg0, arg4); + tcg_out_modrm(s, 0x40 | tcg_cond_to_jcc[cond] | P_EXT | rexw, arg0, arg3);
A comment saying this is cmovcc would be nice.
Note, I didn't check the correctness, though it looks OK. I'll make real tests at the next iteration :-)
Quoted 31 lines
tcg/x86_64/tcg-target.c +20
-0+} + #if defined(CONFIG_SOFTMMU) #include "../../softmmu_defs.h"@@ -1197,6 +1232,24 @@ static inline void tcg_out_op(TCGContext *s, int opc, const TCGArg *args, tcg_out_modrm(s, 0x8b, args[0], args[1]); break; + case INDEX_op_setcond_i32: + tcg_out_setcond(s, args[3], args[0], args[1], args[2], + const_args[2], 0); + break; + case INDEX_op_setcond_i64: + tcg_out_setcond(s, args[3], args[0], args[1], args[2], + const_args[2], P_REXW); + break; + + case INDEX_op_movcond_i32: + tcg_out_movcond(s, args[5], args[0], args[1], args[2], + const_args[2], args[3], args[4], 0); + break; + case INDEX_op_movcond_i64: + tcg_out_movcond(s, args[5], args[0], args[1], args[2], + const_args[2], args[3], args[4], P_REXW); + break; +case
INDEX_op_qemu_ld8u:
tcg_out_qemu_ld(s, args, 0);
break;
tcg/x86_64/tcg-target.c static const TCGTargetOpDef x86_64_op_defs[] = { · line 1436
Quoted 8 lines
tcg/x86_64/tcg-target.c +5
-0@@ -1376,6 +1429,12 @@ static const TCGTargetOpDef x86_64_op_defs[] = { { INDEX_op_ext16u_i64, { "r", "r"} }, { INDEX_op_ext32u_i64, { "r", "r"} }, + { INDEX_op_setcond_i32, { "r", "r", "re" } }, + { INDEX_op_setcond_i64, { "r", "r", "re" } }, + + { INDEX_op_movcond_i32, { "r", "r", "re", "r", "r" } }, + { INDEX_op_movcond_i64, { "r", "r", "re", "r", "r" } },
For the i32 variants, "ri" instead of "re" is enough.
Laurent
Quoted 8 lines
tcg/x86_64/tcg-target.c +1
-1+ { INDEX_op_qemu_ld8u, { "r", "L" } }, { INDEX_op_qemu_ld8s, { "r", "L" } }, { INDEX_op_qemu_ld16u, { "r", "L" } }, --1.6.5.2
Re: [Qemu-devel] Re: [PATCH 3/6] tcg-x86_64: Implement setcond and movcond.
Quoted 5 lines · Laurent Desnogues
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 521
Quoted 2 lines
tcg/x86_64/tcg-target.c +2
-0+static void tcg_out_setcond (TCGContext *s,int cond,TCGArg arg0, +TCGArg arg1,TCGArg arg2,int const_arg2,int rexw)Perhaps renaming arg0 to dest would make things slightly more readable.
Ok.
Quoted 2 lines
Also note that
tcg_out_modrmwill generate an unneeded prefix for some registers. cf. the patch I sent to the list months ago.
Huh. Didn't notice since the disassembler printed what I expected to see. Is fixing this at the same time a requirement for acceptance? I'd prefer to tackle that separately, since no doubt it affects every use of P_REXB.
Quoted 3 lines
Quoted 1 line
+
tgen_arithi32(s, ARITH_AND, arg0, 0xff);Wouldn't movzbl be better?
Handled inside tgen_arithi32:
} else if (c == ARITH_AND && val == 0xffu) {
/* movzbl */
tcg_out_modrm(s, 0xb6 | P_EXT | P_REXB, r0, r0);I didn't feel the need to replicate that.
Quoted 2 lines
Regarding the xor optimization, I tested it on my i7 and it was (very) slightly slower running a 64-bit SPEC2k gcc.
Huh. It used to be recommended. The partial word store used to stall the pipeline until the old value was ready, and the XOR was special-cased as a clear, which broke both the input dependency and also prevented a partial-register stall on the output.
Actually, this recommendation is still present: Section 3.5.1.6 in the November 2009 revision of the Intel Optimization Reference Manual.
If it's all the same, I'd prefer to keep what I have there. All other things being equal, the XOR is 2 bytes and the MOVZBL is 3.
Quoted 6 lines
tcg/x86_64/tcg-target.c static void tcg_out_brcond(TCGContext *s, int cond, · line 535
Quoted 3 lines
tcg/x86_64/tcg-target.c +3
-0+static void tcg_out_movcond (TCGContext *s,int cond,TCGArg arg0, +TCGArg arg1,TCGArg arg2,int const_arg2, +TCGArg arg3,TCGArg arg4,int rexw)Perhaps renaming arg0 to dest would make things slightly more readable.
Ok.
Quoted 1 line
You should also add a note stating that arg3 != arg4.
I don't believe that's true though. It's caught immediately when we emit the movcond opcode, but there's no check later once copy-propagation has been done within TCG.
I check for that in the i386 and sparc backends, because dest==arg3 && dest==arg4 would actually generate incorrect code. Here in the x86_64 backend, where we always use cmov it doesn't generate incorrect code, merely inefficient.
I could add an early out for that case, if you prefer.
Quoted 7 lines
tcg/x86_64/tcg-target.c static const TCGTargetOpDef x86_64_op_defs[] = { · line 1436
Quoted 5 lines
tcg/x86_64/tcg-target.c +5
-0+ { INDEX_op_setcond_i32, { "r", "r", "re" } }, + { INDEX_op_setcond_i64, { "r", "r", "re" } }, + + { INDEX_op_movcond_i32, { "r", "r", "re", "r", "r" } }, + { INDEX_op_movcond_i64, { "r", "r", "re", "r", "r" } },For the i32 variants, "ri" instead of "re" is enough.
Ah, quite right.
r~
Re: [Qemu-devel] Re: [PATCH 3/6] tcg-x86_64: Implement setcond and movcond.
Quoted 7 lines · Richard Henderson
Quoted 2 lines
Also note that
tcg_out_modrmwill generate an unneeded prefix for some registers. cf. the patch I sent to the list months ago.Huh. Didn't notice since the disassembler printed what I expected to see. Is fixing this at the same time a requirement for acceptance? I'd prefer to tackle that separately, since no doubt it affects every use of
P_REXB.
I agree this change can be delayed.
Quoted 11 lines
Quoted 3 lines
Quoted 1 line
+ tgen_arithi32(s,
ARITH_AND, arg0,0xff);Wouldn't movzbl be better?
Handled inside
tgen_arithi32:} else if (c ==
ARITH_AND&& val ==0xffu) { /* movzbl */
tcg_out_modrm(s,0xb6|P_EXT|P_REXB, r0, r0);I didn't feel the need to replicate that.
Oups, I compared with my code which has an explicit mozbl :)
Quoted 8 lines
Quoted 2 lines
Regarding the xor optimization, I tested it on my i7 and it was (very) slightly slower running a 64-bit SPEC2k gcc.
Huh. It used to be recommended. The partial word store used to stall the pipeline until the old value was ready, and the XOR was special-cased as a clear, which broke both the input dependency and also prevented a partial-register stall on the output.
Quoted 5 lines
Actually, this recommendation is still present: Section 3.5.1.6 in the November 2009 revision of the Intel Optimization Reference Manual.
If it's all the same, I'd prefer to keep what I have there. All other things being equal, the XOR is 2 bytes and the MOVZBL is 3.
I agree too. Anyway my measure is not representative enough to mean anything. And in that case I think shorter code is better, so let's go for XOR.
Quoted 15 lines
Quoted 6 lines
Quoted 3 lines
+static void tcg_out_movcond(TCGContext *s, int cond, TCGArg arg0,
+ TCGArg arg1, TCGArg arg2, intconst_arg2,
+ TCGArg arg3, TCGArg arg4, int rexw)Perhaps renaming arg0 to dest would make things slightly more readable.
Ok.
Quoted 1 line
You should also add a note stating that arg3 != arg4.
I don't believe that's true though. It's caught immediately when we emit the movcond opcode, but there's no check later once copy-propagation has been done within TCG.
Quoted 6 lines
I check for that in the i386 and sparc backends, because dest==arg3 && dest==arg4 would actually generate incorrect code. Here in the
x86_64backend, where we always use cmov it doesn't generate incorrect code, merely inefficient.I could add an early out for that case, if you prefer.
No, you can leave it as is unless someone else objects.
Laurent
PATCH 4/6 tcg-i386: Implement small forward branches.
In reply to Richard HendersonThere are places, like brcond2, where we know that the destination of a forward branch will be within 127 bytes. Add the R_386_PC8 relocation type to support this, and add a flag to tcg_out_jxx to generate it. Set the flag in the small forward branches in brcond2.
--- elf.h | 2 ++ tcg/i386/tcg-target.c | 36 +++++++++++++++++++++++++----------- 2 files changed, 27 insertions(+), 11 deletions(-)
elf.h +2 -0
@@ -243,6 +243,8 @@ typedef struct {#define R_386_GOTOFF 9#define R_386_GOTPC 10#define R_386_NUM 11 +/* Not a dynamic reloc, so not included in R_386_NUM. Used in TCG. */ +#define R_386_PC8 23#define R_MIPS_NONE 0#define R_MIPS_16 1
tcg/i386/tcg-target.c +25 -11
@@ -61,6 +61,9 @@ static void patch_reloc(uint8_t *code_ptr, int type,case R_386_PC32 : *(uint32_t *)code_ptr = value - (long )code_ptr;break ; +case R_386_PC8 : + *(uint8_t *)code_ptr = value - (long )code_ptr; +break ;default :tcg_abort (); }
@@ -305,7 +308,8 @@ static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)tgen_arithi (s,ARITH_ADD , reg, val,0 ); } -static void tcg_out_jxx (TCGContext *s,int opc,int label_index) +/* Use SMALL != 0 to force a short forward branch. */ +static void tcg_out_jxx (TCGContext *s,int opc,int label_index,int small) {int32_t val, val1;TCGLabel *l = &s->labels[label_index];
@@ -320,6 +324,7 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index)tcg_out8 (s,0x70 + opc);tcg_out8 (s, val1); }else { +assert (!small);if (opc ==-1 ) {tcg_out8 (s,0xe9 );tcg_out32 (s, val -5 );
@@ -329,6 +334,15 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index)tcg_out32 (s, val -6 ); } } + }else if (small) { +if (opc ==-1 ) { +tcg_out8 (s,0xeb ); + }else { +tcg_out8 (s,0x0f ); +tcg_out8 (s,0x70 + opc); + } +tcg_out_reloc (s, s->code_ptr,R_386_PC8 , label_index,-1 ); + s->code_ptr +=1 ; }else {if (opc ==-1 ) {tcg_out8 (s,0xe9 );
@@ -355,7 +369,7 @@ static void tcg_out_brcond(TCGContext *s, int cond, }else {tcg_out_modrm (s,0x01 | (ARITH_CMP <<3 ), arg2, arg1); } -tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_index); +tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_index,0 ); }/* XXX: we implement it at the target level to avoid having to
@@ -376,42 +390,42 @@ static void tcg_out_brcond2(TCGContext *s,break ;case TCG_COND_LT :tcg_out_brcond (s,TCG_COND_LT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_LTU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_LE :tcg_out_brcond (s,TCG_COND_LT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_LEU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_GT :tcg_out_brcond (s,TCG_COND_GT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_GTU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_GE :tcg_out_brcond (s,TCG_COND_GT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_GEU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_LTU :tcg_out_brcond (s,TCG_COND_LTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_LTU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_LEU :tcg_out_brcond (s,TCG_COND_LTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_LEU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_GTU :tcg_out_brcond (s,TCG_COND_GTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_GTU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;case TCG_COND_GEU :tcg_out_brcond (s,TCG_COND_GTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next); +tcg_out_jxx (s,JCC_JNE , label_next,1 );tcg_out_brcond (s,TCG_COND_GEU , args[0 ], args[2 ], const_args[2 ], args[5 ]);break ;default :
@@ -913,7 +927,7 @@ static inline void tcg_out_op(TCGContext *s, int opc, }break ;case INDEX_op_br: -tcg_out_jxx (s,JCC_JMP , args[0 ]); +tcg_out_jxx (s,JCC_JMP , args[0 ],0 );break ;case INDEX_op_movi_i32:tcg_out_movi (s,TCG_TYPE_I32 , args[0 ], args[1 ]);
Signature · 1 line
1.6.5.2
Quoted 49 lines · Richard Henderson
There are places, like brcond2, where we know that the destination of a forward branch will be within 127 bytes. Add the
R_386_PC8relocation type to support this, and add a flag totcg_out_jxxto generate it. Set the flag in the small forward branches in brcond2.Signed-off-by Richard Henderson <[email protected]>---
elf.h | 2 ++
tcg/i386/tcg-target.c | 36 +++++++++++++++++++++++++-----------2 files changed, 27 insertions(+), 11 deletions(-)elf.h +2
-0@@ -243,6 +243,8 @@ typedef struct { #define R_386_GOTOFF 9 #define R_386_GOTPC 10 #define R_386_NUM 11 +/* Not a dynamic reloc, so not included in R_386_NUM. Used in TCG. */ +#define R_386_PC8 23 #define R_MIPS_NONE 0 #define R_MIPS_16 1tcg/i386/tcg-target.c +0
-0@@ -61,6 +61,9 @@ static void patch_reloc(uint8_t *code_ptr, int type,case
R_386_PC32:
*(uint32_t *)code_ptr = value - (long)code_ptr; break;
+ caseR_386_PC8:
+ *(uint8_t *)code_ptr = value - (long)code_ptr;
+ break;
default:
tcg_abort();
}tcg/i386/tcg-target.c +2
-1@@ -305,7 +308,8 @@ static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val) tgen_arithi(s, ARITH_ADD, reg, val, 0); } -static void tcg_out_jxx (TCGContext *s,int opc,int label_index) +/* Use SMALL != 0 to force a short forward branch. */ +static void tcg_out_jxx (TCGContext *s,int opc,int label_index,int small) { int32_t val, val1; TCGLabel *l = &s->labels[label_index];
tcg/i386/tcg-target.c static void tcg_out_jxx(TCGContext *s, int opc, int label_index) · line 327
Quoted 4 lines
tcg/i386/tcg-target.c +1
-0@@ -320,6 +324,7 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index) tcg_out8(s, 0x70 + opc); tcg_out8(s, val1); } else { + assert (!small);
To be consistent with the rest I'd use:
if (small)
tcg_abort();tcg/i386/tcg-target.c static void tcg_out_jxx(TCGContext *s, int opc, int label_index) · line 341
Quoted 12 lines
tcg/i386/tcg-target.c +5
-0if (opc == -1) { tcg_out8(s, 0xe9); tcg_out32(s, val - 5);@@ -329,6 +334,15 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index) tcg_out32(s, val - 6); } } + } else if (small) { + if (opc == -1) { + tcg_out8(s, 0xeb); + } else { + tcg_out8(s, 0x0f);
I don't think this prefix should be output.
Laurent
Quoted 80 lines
tcg/i386/tcg-target.c +5
-1+ tcg_out8(s, 0x70 + opc); + } + tcg_out_reloc(s, s->code_ptr, R_386_PC8, label_index, -1); + s->code_ptr += 1; } else { if (opc == -1) { tcg_out8(s, 0xe9);@@ -355,7 +369,7 @@ static void tcg_out_brcond(TCGContext *s, int cond, } else { tcg_out_modrm(s, 0x01 | (ARITH_CMP << 3), arg2, arg1); } - tcg_out_jxx(s, tcg_cond_to_jcc[cond], label_index); + tcg_out_jxx(s, tcg_cond_to_jcc[cond], label_index, 0); } /* XXX: we implement it at the target level to avoid having to@@ -376,42 +390,42 @@ static void tcg_out_brcond2(TCGContext *s, break;case
TCG_COND_LT:
tcg_out_brcond(s, TCG_COND_LT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_LTU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_LE:
tcg_out_brcond(s, TCG_COND_LT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_LEU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_GT:
tcg_out_brcond(s, TCG_COND_GT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_GTU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_GE:
tcg_out_brcond(s, TCG_COND_GT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_GEU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_LTU:
tcg_out_brcond(s, TCG_COND_LTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_LTU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_LEU:
tcg_out_brcond(s, TCG_COND_LTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_LEU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_GTU:
tcg_out_brcond(s, TCG_COND_GTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_GTU, args[0], args[2], const_args[2], args[5]); break;
caseTCG_COND_GEU:
tcg_out_brcond(s, TCG_COND_GTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next);
+ tcg_out_jxx(s,JCC_JNE,label_next, 1);
tcg_out_brcond(s, TCG_COND_GEU, args[0], args[2], const_args[2], args[5]); break;
default:tcg/i386/tcg-target.c +0
-0@@ -913,7 +927,7 @@ static inline void tcg_out_op(TCGContext *s, int opc, } break;case
INDEX_op_br:
- tcg_out_jxx(s,JCC_JMP, args[0]);
+ tcg_out_jxx(s,JCC_JMP, args[0], 0); break;
caseINDEX_op_movi_i32:
tcg_out_movi(s, TCG_TYPE_I32, args[0], args[1]); --
1.6.5.2
Quoted 4 lines · Laurent Desnogues
To be consistent with the rest I'd use:
if (small) tcg_abort();
Ok.
Quoted 3 lines
Quoted 1 line
+
tcg_out8(s, 0x0f);I don't think this prefix should be output.
Oops. Paste-o.
r~
PATCH 5/6 tcg-i386: Simplify brcond2.
In reply to Richard HendersonSplit out tcg_out_cond from tcg_out_brcond. Add "small" arguments to all branch functions for completeness. Unify all the calls to generate branches within brcond2 and pass on the small flag.
--- tcg/i386/tcg-target.c | 87 ++++++++++++++++++++++-------------------------- 1 files changed, 40 insertions(+), 47 deletions(-)
tcg/i386/tcg-target.c +40 -47
@@ -355,9 +355,8 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index, int small) } } -static void tcg_out_brcond (TCGContext *s,int cond, -TCGArg arg1,TCGArg arg2,int const_arg2, -int label_index) +static void tcg_out_cond (TCGContext *s,int cond, +TCGArg arg1,TCGArg arg2,int const_arg2) {if (const_arg2) {if (arg2 ==0 ) {
@@ -369,68 +368,61 @@ static void tcg_out_brcond(TCGContext *s, int cond, }else {tcg_out_modrm (s,0x01 | (ARITH_CMP <<3 ), arg2, arg1); } -tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_index,0 ); +} + +static void tcg_out_brcond (TCGContext *s,int cond, +TCGArg arg1,TCGArg arg2,int const_arg2, +int label_index,int small) +{ +tcg_out_cond (s, cond, arg1, arg2, const_arg2); +tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_index, small); }/* XXX: we implement it at the target level to avoid having to handle cross basic blocks temporaries */ -static void tcg_out_brcond2 (TCGContext *s, -const TCGArg *args,const int *const_args) +static void tcg_out_brcond2 (TCGContext *s,const TCGArg *args, +const int *const_args,int small) { -int label_next; - label_next =gen_new_label (); -switch (args[4 ]) { +int label_next =gen_new_label (); +int label_dest = args[5 ]; +int cond = args[4 ], c1, c2, c3; + +switch (cond) {case TCG_COND_EQ : -tcg_out_brcond (s,TCG_COND_NE , args[0 ], args[2 ], const_args[2 ], label_next); -tcg_out_brcond (s,TCG_COND_EQ , args[1 ], args[3 ], const_args[3 ], args[5 ]); + c1 =-1 , c2 =TCG_COND_NE , c3 =TCG_COND_EQ ;break ;case TCG_COND_NE : -tcg_out_brcond (s,TCG_COND_NE , args[0 ], args[2 ], const_args[2 ], args[5 ]); -tcg_out_brcond (s,TCG_COND_NE , args[1 ], args[3 ], const_args[3 ], args[5 ]); + c1 =TCG_COND_NE , c2 =-1 , c3 =TCG_COND_NE ;break ;case TCG_COND_LT : -tcg_out_brcond (s,TCG_COND_LT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_LTU , args[0 ], args[2 ], const_args[2 ], args[5 ]); -break ; -case TCG_COND_LE : -tcg_out_brcond (s,TCG_COND_LT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_LEU , args[0 ], args[2 ], const_args[2 ], args[5 ]); -break ; -case TCG_COND_GT : -tcg_out_brcond (s,TCG_COND_GT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_GTU , args[0 ], args[2 ], const_args[2 ], args[5 ]); -break ; -case TCG_COND_GE : -tcg_out_brcond (s,TCG_COND_GT , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_GEU , args[0 ], args[2 ], const_args[2 ], args[5 ]); -break ;case TCG_COND_LTU : -tcg_out_brcond (s,TCG_COND_LTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_LTU , args[0 ], args[2 ], const_args[2 ], args[5 ]); + c1 = cond, c2 =TCG_COND_NE , c3 =TCG_COND_LTU ;break ; +case TCG_COND_LE :case TCG_COND_LEU : -tcg_out_brcond (s,TCG_COND_LTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_LEU , args[0 ], args[2 ], const_args[2 ], args[5 ]); + c1 = cond, c2 =TCG_COND_NE , c3 =TCG_COND_LEU ;break ; +case TCG_COND_GT :case TCG_COND_GTU : -tcg_out_brcond (s,TCG_COND_GTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_GTU , args[0 ], args[2 ], const_args[2 ], args[5 ]); + c1 = cond, c2 =TCG_COND_NE , c3 =TCG_COND_GTU ;break ; +case TCG_COND_GE :case TCG_COND_GEU : -tcg_out_brcond (s,TCG_COND_GTU , args[1 ], args[3 ], const_args[3 ], args[5 ]); -tcg_out_jxx (s,JCC_JNE , label_next,1 ); -tcg_out_brcond (s,TCG_COND_GEU , args[0 ], args[2 ], const_args[2 ], args[5 ]); + c1 = cond, c2 =TCG_COND_NE , c3 =TCG_COND_GEU ;break ;default : -tcg_abort (); +tcg_abort (); + } + +tcg_out_cond (s, cond, args[1 ], args[3 ], const_args[3 ]); +if (c1 !=-1 ) { +tcg_out_jxx (s, tcg_cond_to_jcc[c1], label_dest, small); } +if (c2 !=-1 ) { +tcg_out_jxx (s, tcg_cond_to_jcc[c2], label_next,1 ); + } +tcg_out_brcond (s, c3, args[0 ], args[2 ], const_args[2 ], label_dest, small); +tcg_out_label (s, label_next, (tcg_target_long )s->code_ptr); }
@@ -1058,10 +1050,11 @@ static inline void tcg_out_op(TCGContext *s, int opc,tcg_out_modrm (s,0x01 | (ARITH_SBB <<3 ), args[5 ], args[1 ]);break ;case INDEX_op_brcond_i32: -tcg_out_brcond (s, args[2 ], args[0 ], args[1 ], const_args[1 ], args[3 ]); +tcg_out_brcond (s, args[2 ], args[0 ], args[1 ], const_args[1 ], + args[3 ],0 );break ;case INDEX_op_brcond2_i32: -tcg_out_brcond2 (s, args, const_args); +tcg_out_brcond2 (s, args, const_args,0 );break ;case INDEX_op_bswap16_i32:
Signature · 1 line
1.6.5.2
[Qemu-devel] Re: [PATCH 5/6] tcg-i386: Simplify brcond2.
Quoted 107 lines · Richard Henderson
Split out
tcg_out_condfromtcg_out_brcond. Add "small" arguments to all branch functions for completeness. Unify all the calls to generate branches within brcond2 and pass on the small flag.Signed-off-by Richard Henderson <[email protected]>---
tcg/i386/tcg-target.c | 87 ++++++++++++++++++++++--------------------------1 files changed, 40 insertions(+), 47 deletions(-)tcg/i386/tcg-target.c +10
-4@@ -355,9 +355,8 @@ static void tcg_out_jxx(TCGContext *s, int opc, int label_index, int small) } } -static void tcg_out_brcond (TCGContext *s,int cond, - TCGArg arg1, TCGArg arg2, int const_arg2, - int label_index) +static void tcg_out_cond (TCGContext *s,int cond, + TCGArg arg1, TCGArg arg2, int const_arg2) { if (const_arg2) { if (arg2 == 0) {@@ -369,68 +368,61 @@ static void tcg_out_brcond(TCGContext *s, int cond, } else { tcg_out_modrm(s, 0x01 | (ARITH_CMP << 3), arg2, arg1); } - tcg_out_jxx(s, tcg_cond_to_jcc[cond], label_index, 0); +} + +static void tcg_out_brcond (TCGContext *s,int cond, + TCGArg arg1, TCGArg arg2, int const_arg2, + int label_index, int small) +{ + tcg_out_cond(s, cond, arg1, arg2, const_arg2); + tcg_out_jxx(s, tcg_cond_to_jcc[cond], label_index, small); } /* XXX: we implement it at the target level to avoid having tohandle cross basic blocks temporaries */
tcg/i386/tcg-target.c +2
-2-static void tcg_out_brcond2 (TCGContext *s, - const TCGArg *args, const int *const_args) +static void tcg_out_brcond2 (TCGContext *s,const TCGArg *args, + const int *const_args, int small){
- intlabel_next;
- label_next =gen_new_label();
- switch(args[4]) {
+ intlabel_next=gen_new_label();
+ intlabel_dest= args[5];
+ int cond = args[4], c1, c2, c3;
+
+ switch (cond) {
caseTCG_COND_EQ:
- tcg_out_brcond(s,TCG_COND_NE, args[0], args[2], const_args[2],label_next);
- tcg_out_brcond(s,TCG_COND_EQ, args[1], args[3], const_args[3], args[5]);
+ c1 = -1, c2 =TCG_COND_NE, c3 =TCG_COND_EQ;
break;
caseTCG_COND_NE:
- tcg_out_brcond(s,TCG_COND_NE, args[0], args[2], const_args[2], args[5]);
- tcg_out_brcond(s,TCG_COND_NE, args[1], args[3], const_args[3], args[5]);
+ c1 =TCG_COND_NE, c2 = -1, c3 =TCG_COND_NE;
break;
caseTCG_COND_LT:
- tcg_out_brcond(s,TCG_COND_LT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_LTU, args[0], args[2], const_args[2], args[5]);
- break;
- caseTCG_COND_LE:
- tcg_out_brcond(s,TCG_COND_LT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_LEU, args[0], args[2], const_args[2], args[5]);
- break;
- caseTCG_COND_GT:
- tcg_out_brcond(s,TCG_COND_GT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_GTU, args[0], args[2], const_args[2], args[5]);
- break;
- caseTCG_COND_GE:
- tcg_out_brcond(s,TCG_COND_GT, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_GEU, args[0], args[2], const_args[2], args[5]);
- break;
caseTCG_COND_LTU:
- tcg_out_brcond(s,TCG_COND_LTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_LTU, args[0], args[2], const_args[2], args[5]);
+ c1 = cond, c2 =TCG_COND_NE, c3 =TCG_COND_LTU;
break;
+ caseTCG_COND_LE:
caseTCG_COND_LEU:
- tcg_out_brcond(s,TCG_COND_LTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_LEU, args[0], args[2], const_args[2], args[5]);
+ c1 = cond, c2 =TCG_COND_NE, c3 =TCG_COND_LEU;
break;
+ caseTCG_COND_GT:
caseTCG_COND_GTU:
- tcg_out_brcond(s,TCG_COND_GTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_GTU, args[0], args[2], const_args[2], args[5]);
+ c1 = cond, c2 =TCG_COND_NE, c3 =TCG_COND_GTU;
break;
+ caseTCG_COND_GE:
caseTCG_COND_GEU:
Quoted 8 lines
- tcg_out_brcond(s,
TCG_COND_GTU, args[1], args[3], const_args[3], args[5]);
- tcg_out_jxx(s,JCC_JNE,label_next, 1);
- tcg_out_brcond(s,TCG_COND_GEU, args[0], args[2], const_args[2], args[5]);
+ c1 = cond, c2 =TCG_COND_NE, c3 =TCG_COND_GEU;
break;
default:
- tcg_abort();
+ tcg_abort ();
This is unwanted :-)
Quoted 5 lines
+ }
+
+ tcg_out_cond(s, cond, args[1], args[3], const_args[3]);
+ if (c1 != -1) {
+ tcg_out_jxx(s, tcg_cond_to_jcc[c1],label_dest, small);
Quoted 8 lines
}
+ if (c2 != -1) {
+ tcg_out_jxx(s, tcg_cond_to_jcc[c2],label_next, 1);
+ }
+ tcg_out_brcond(s, c3, args[0], args[2], const_args[2],label_dest, small); +
tcg_out_label(s, label_next, (tcg_target_long)s->code_ptr);
}
I'm not sure I really like that rewrite, I find it hard to read. Convince me it's better :-)
Laurent
Quoted 18 lines
tcg/i386/tcg-target.c +0
-0@@ -1058,10 +1050,11 @@ static inline void tcg_out_op(TCGContext *s, int opc, tcg_out_modrm(s, 0x01 | (ARITH_SBB << 3), args[5], args[1]); break;case
INDEX_op_brcond_i32:
- tcg_out_brcond(s, args[2], args[0], args[1], const_args[1], args[3]);
+ tcg_out_brcond(s, args[2], args[0], args[1], const_args[1],
+ args[3], 0);
break;
caseINDEX_op_brcond2_i32:
- tcg_out_brcond2(s, args,const_args);
+ tcg_out_brcond2(s, args,const_args, 0);
break;case
INDEX_op_bswap16_i32:
--
1.6.5.2
Re: [Qemu-devel] Re: [PATCH 5/6] tcg-i386: Simplify brcond2.
Quoted 2 lines · Laurent Desnogues
I'm not sure I really like that rewrite, I find it hard to read. Convince me it's better :-)
Would it be more obvious if I used a table instead of a switch? The code size reduction is
Num: Value Size Type Bind Vis Ndx Name
before:
40: 000039a0 793 FUNC LOCAL DEFAULT 1 tcg_out_brcond2
after:
40: 00003a50 412 FUNC LOCAL DEFAULT 1 tcg_out_brcond2
table-ized:
40: 00003a50 224 FUNC LOCAL DEFAULT 1 tcg_out_brcond2But I'm not married to the patch; let's drop it if there's a question of it holding up the rest of the series.
r~
PATCH 6/6 tcg-i386: Implement setcond, movcond, setcond2.
In reply to Richard HendersonImplement conditional moves in the i386 backend.
--- tcg/i386/tcg-target.c | 173 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 173 insertions(+), 0 deletions(-)
tcg/i386/tcg-target.c +173 -0
@@ -426,6 +426,165 @@ static void tcg_out_brcond2(TCGContext *s, const TCGArg *args,tcg_out_label (s, label_next, (tcg_target_long )s->code_ptr); } +static void tcg_out_setcond (TCGContext *s,int cond,TCGArg arg0, +TCGArg arg1,TCGArg arg2,int const_arg2) +{ +int use_xor = (arg0 != arg1 && (const_arg2 || arg0 != arg2)); + +if (use_xor) +tcg_out_movi (s,TCG_TYPE_I32 , arg0,0 ); +tcg_out_cond (s, cond, arg1, arg2, const_arg2); +tcg_out_modrm (s,0x90 | tcg_cond_to_jcc[cond] |P_EXT ,0 , arg0); +if (!use_xor) +tgen_arithi (s,ARITH_AND , arg0,0xff ,0 ); +} + +static void tcg_out_setcond2 (TCGContext *s,const TCGArg *args, +const int *const_args) +{ +TCGArg new_args[6 ]; +int label_true, label_over; + +memcpy (new_args, args+1 ,5 *sizeof (TCGArg)); + +if (args[0 ] == args[1 ] || args[0 ] == args[2 ] + || (!const_args[3 ] && args[0 ] == args[3 ]) + || (!const_args[4 ] && args[0 ] == args[4 ])) { +/* When the destination overlaps with one of the argument +registers, don't do anything tricky. */ + label_true =gen_new_label (); + label_over =gen_new_label (); + + new_args[5 ] = label_true; +tcg_out_brcond2 (s, new_args, const_args+1 ,1 ); + +tcg_out_movi (s,TCG_TYPE_I32 , args[0 ],0 ); +tcg_out_jxx (s,JCC_JMP , label_over,1 ); +tcg_out_label (s, label_true, (tcg_target_long )s->code_ptr); + +tcg_out_movi (s,TCG_TYPE_I32 , args[0 ],1 ); +tcg_out_label (s, label_over, (tcg_target_long )s->code_ptr); + }else { +/* When the destination does not overlap one of the arguments, +clear the destination first, jump if cond false, and emit an +increment in the true case. This results in smaller code. */ + +tcg_out_movi (s,TCG_TYPE_I32 , args[0 ],0 ); + + label_over =gen_new_label (); + new_args[4 ] =tcg_invert_cond (new_args[4 ]); + new_args[5 ] = label_over; +tcg_out_brcond2 (s, new_args, const_args+1 ,1 ); + +tgen_arithi (s,ARITH_ADD , args[0 ],1 ,0 ); +tcg_out_label (s, label_over, (tcg_target_long )s->code_ptr); + } +} + +static inline int have_cmov (void ) +{ +#ifdef __i686__ +/* Compiler options say that cmov is available. */ +return 1 ; +#else +/* ??? Use cpuid or something and figure out what's running. */ +return 0 ; +#endif +} + +static void tcg_out_movcond (TCGContext *s,const TCGArg *args, +const int *const_args) +{ +int vtc, vfc, cond, use_cmov =0 , do_swap =0 ; +TCGArg d, vt, vf; + + d = args[0 ]; + vt = args[3 ]; + vf = args[4 ]; + vtc = const_args[3 ]; + vfc = const_args[4 ]; + +/* ??? The jcc code path below assumes that one mov insn must be skipped. +Rather than complicate the code below, make sure to simplify the +conditional move here. */ +if (vtc == vfc && vt == vf) { +if (vtc) +tcg_out_movi (s,TCG_TYPE_I32 , d, vt); +else +tcg_out_mov (s, d, vt); +return ; + } + + cond = args[5 ]; + +/* If both arguments are constants, we *could* do all the funny bits that +gcc does with sbc, masks, etc. There's likely no point. Just use the +jcc version in this case. We also have to be careful about clobbering +inputs when trying to move constants into position. */ + +if (have_cmov ()) { + use_cmov =1 ; +if (vtc) { +if (vfc || d == vf) + use_cmov =0 ; +else + do_swap =1 ; + }else if (d == vt) { +if (vfc) + use_cmov =0 ; +else + do_swap =1 ; + } + } + +if (!use_cmov) { +/* We're going to follow the lead of cmov and set D=VF first, +which means inverting the condition upon which we jump. */ + cond =tcg_invert_cond (cond); + +/* Don't allow the move we jump over to be a nop. */ + do_swap = (!vtc && d == vt); + } + +if (do_swap) { +TCGArg t; + cond =tcg_invert_cond (cond); + t = vf, vf = vt, vt = t; + t = vfc, vfc = vtc, vtc = t; + } + +/* If possible, set D=0 before the compare, so that we can use XOR. */ +if (vfc && vf ==0 && d != args[1 ] && (const_args[2 ] || d != args[2 ])) { +tcg_out_movi (s,TCG_TYPE_I32 , d,0 ); + vf = d, vfc =0 ; + } + +tcg_out_cond (s, cond, args[1 ], args[2 ], const_args[2 ]); + +if (vfc) { +/* Force the use of "mov $0, d" to avoid clobbering flags. */ +tcg_out8 (s,0xb8 + d); +tcg_out32 (s, vf); + }else { +tcg_out_mov (s, d, vf); + } + +if (use_cmov) { +assert (!vtc); +tcg_out_modrm (s,0x40 | tcg_cond_to_jcc[cond] |P_EXT , d, vt); + }else { +int label_next =gen_new_label (); + +tcg_out_jxx (s, tcg_cond_to_jcc[cond], label_next,1 ); +if (vtc) +tcg_out_movi (s,TCG_TYPE_I32 , d, vt); +else +tcg_out_mov (s, d, vt); + +tcg_out_label (s, label_next, (tcg_target_long )s->code_ptr); + } +} +#if defined(CONFIG_SOFTMMU )#include "../../softmmu_defs.h"
@@ -1087,6 +1246,16 @@ static inline void tcg_out_op(TCGContext *s, int opc,tcg_out_modrm (s,0xb7 |P_EXT , args[0 ], args[1 ]);break ; +case INDEX_op_setcond_i32: +tcg_out_setcond (s, args[3 ], args[0 ], args[1 ], args[2 ], const_args[2 ]); +break ; +case INDEX_op_movcond_i32: +tcg_out_movcond (s, args, const_args); +break ; +case INDEX_op_setcond2_i32: +tcg_out_setcond2 (s, args, const_args); +break ; +case INDEX_op_qemu_ld8u:tcg_out_qemu_ld (s, args,0 );break ;
@@ -1175,6 +1344,10 @@ static const TCGTargetOpDef x86_op_defs[] = { { INDEX_op_ext8u_i32, { "r", "q"} }, { INDEX_op_ext16u_i32, { "r", "r"} }, + { INDEX_op_setcond_i32, { "q", "r", "ri" } }, + { INDEX_op_movcond_i32, { "r", "r", "ri", "ri", "ri" } }, + { INDEX_op_setcond2_i32, { "r", "r", "r", "ri", "ri" } }, + #if TARGET_LONG_BITS == 32 { INDEX_op_qemu_ld8u, { "r", "L" } }, { INDEX_op_qemu_ld8s, { "r", "L" } },
Signature · 1 line
1.6.5.2
[Qemu-devel] Re: [PATCH 0/6] tcg conditional set/move, round 2
In reply to Richard HendersonQuoted 5 lines · Richard Henderson
Quoted 1 line
funny how you seem to follow the same paths I did months ago :-)
Heh. They are the obvious points for improvement in the emulation. Hopefully we can get them finished this time, so that some third person doesn't go through the same thing next year. =)
I agree :-)
Quoted 14 lines
Quoted 2 lines
- cosmetics: don't use tabs and be sure not to have whitespaces at end of lines
Grr, I thought I'd been extra careful about that. Fixed.
Quoted 1 line
- the changes to
tcg-op.hin patch 6 should go with patch 1Done.
Quoted 4 lines
- outside of the small parameter handling, I'd prefer you provide a separate patch for
tcg_out_brcond2; I don't think the changes using c1, c2 and c3 really belong to setcond/movcond.
Quoted 5 lines
The i386 part has been split into 3 patches, though they are sequentially dependent.
I've left off the sparc backend patch, as well as the patches for the translators. Let's take care of these first.
Thanks, that will make things easier.
Quoted 5 lines
r~
---Richard Henderson (6):
This is a first pass of review. It's far complete (in particular no testing was done).
Here is a summary of my comments:
Quoted 1 line
tcg: Generic support for conditional set and conditional move.
Needs cosmetics changes.
Quoted 1 line
tcg: Add
tcg_invert_cond.
OK.
Quoted 1 line
tcg-x86_64: Implement setcond and movcond.
Some cosmetics and comments, but overall good.
Quoted 1 line
tcg-i386: Implement small forward branches.
I think this contains a bug.
Quoted 1 line
tcg-i386: Simplify brcond2.
I don't like the rewrite of brcond2.
Quoted 1 line
tcg-i386: Implement setcond, movcond, setcond2.
Not yet reviewed.
Laurent
Quoted 12 lines
elf.h | 2 +
tcg/README | 26 ++++-
tcg/i386/tcg-target.c | 278 ++++++++++++++++++++++++++++++++++++++--------tcg/tcg-op.h| 91 +++++++++++++++
tcg/tcg-opc.h | 5 +
tcg/tcg.c | 23 +++-
tcg/tcg.h | 5 +
tcg/x86_64/tcg-target.c | 65 +++++++++++-8 files changed, 436 insertions(+), 59 deletions(-)
[Qemu-devel] tcg conditional set/move, round 3
Quoted 3 lines · Laurent Desnogues
Quoted 1 line
tcg: Generic support for conditional set and conditional move.
Needs cosmetics changes.
Fixed, attachment 1.
Quoted 3 lines
Quoted 1 line
tcg-x86_64: Implement setcond and movcond.
Some cosmetics and comments, but overall good.
Fixed, attachment 2.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement small forward branches.
I think this contains a bug.
Fixed, attachment 3. I've added an abort to patch_reloc to verify that the relocation is in range. I've propagated the "small" flag to all of the branch functions so that...
Quoted 3 lines
Quoted 1 line
tcg-i386: Simplify brcond2.
I don't like the rewrite of brcond2.
... this patch is dropped.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement setcond, movcond, setcond2.
Not yet reviewed.
Fixed, attachment 4. Similar changes to the amd64 patch.
r~
commit b89e4fc848abd936554ce48b7f9cf23d27ed9eb5
Author: Richard Henderson <[email protected]> Date: Fri Dec 18 11:02:06 2009 -0800
tcg: Generic support for conditional set and conditional move.
Defines setcond and movcond for implementing conditional moves at the tcg opcode level. 64-bit-on-32-bit is expanded via a setcond2 primitive plus other operations.
tcg/README +25 -1
@@ -152,6 +152,11 @@ Conditional jump if t0 cond t1 is true. cond can be: TCG_COND_LEU /* unsigned */ TCG_COND_GTU /* unsigned */ +* brcond2_i32 cond, t0_low, t0_high, t1_low, t1_high, label + +Similar to brcond, except that the 64-bit values T0 and T1 +are formed from two 32-bit arguments. + ********* Arithmetic * add_i32/i64 t0, t1, t2
@@ -282,6 +287,25 @@ order bytes must be set to zero. Indicate that the value of t0 won't be used later. It is useful to force dead code elimination. +********* Conditional moves + +* setcond_i32/i64 cond, dest, t1, t2 + +dest = (t1 cond t2) + +Set DEST to 1 if (T1 cond T2) is true, otherwise set to 0. + +* movcond_i32/i64 cond, dest, c1, c2, vtrue, vfalse + +dest = (c1 cond c2 ? vtrue : vfalse) + +Set DEST to VTRUE if (C1 cond C2) is true, otherwise set to VFALSE. + +* setcond2_i32 cond, dest, t1_low, t1_high, t2_low, t2_high + +Similar to setcond, except that the 64-bit values T1 and T2 are +formed from two 32-bit arguments. The result is a 32-bit value. + ********* Type conversions * ext_i32_i64 t0, t1
@@ -375,7 +399,7 @@ The target word size (TCG_TARGET_REG_BITS) is expected to be 32 bit or On a 32 bit target, all 64 bit operations are converted to 32 bits. A few specific operations must be implemented to allow it (see add2_i32, -sub2_i32, brcond2_i32). +sub2_i32, brcond2_i32, setcond2_i32). Floating point operations are not supported in this version. A previous incarnation of the code generator had full support of them,
tcg/tcg-op.h +91 -0
115 lines not on this page · raw message
tcg/tcg-opc.h +5 -0
@@ -42,6 +42,8 @@ DEF2(br, 0, 0, 1, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mov_i32, 1, 1, 0, 0) DEF2(movi_i32, 1, 0, 1, 0) +DEF2(setcond_i32, 1, 2, 1, 0) +DEF2 (movcond_i32,1 ,4 ,1 ,0 ) /* load/store */ DEF2(ld8u_i32, 1, 1, 1, 0)DEF2 (ld8s_i32,1 ,1 ,1 ,0 )
@@ -82,6 +84,7 @@ DEF2(add2_i32, 2, 4, 0, 0) DEF2(sub2_i32, 2, 4, 0, 0) DEF2(brcond2_i32, 0, 4, 2, TCG_OPF_BB_END | TCG_OPF_SIDE_EFFECTS) DEF2(mulu2_i32, 2, 2, 0, 0) +DEF2(setcond2_i32, 1, 4, 1, 0)#endif #ifdef TCG_TARGET_HAS_ext8s_i32DEF2 (ext8s_i32,1 ,1 ,0 ,0 )
@@ -111,6 +114,8 @@ DEF2(neg_i32, 1, 1, 0, 0)#if TCG_TARGET_REG_BITS ==64 DEF2(mov_i64, 1, 1, 0, 0) DEF2(movi_i64, 1, 0, 1, 0) +DEF2(setcond_i64, 1, 2, 1, 0) +DEF2 (movcond_i64,1 ,4 ,1 ,0 ) /* load/store */ DEF2(ld8u_i64, 1, 1, 1, 0)DEF2 (ld8s_i64,1 ,1 ,1 ,0 )
tcg/tcg.c +17 -6
@@ -670,6 +670,7 @@ void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1, }#endif +static void tcg_reg_alloc_start (TCGContext *s) {int i;
@@ -888,21 +889,31 @@ void tcg_dump_ops(TCGContext *s, FILE *outfile)fprintf (outfile,"%s" ,tcg_get_arg_str_idx (s, buf,sizeof (buf), args[k++])); } -if (c == INDEX_op_brcond_i32 +switch (c) { +case INDEX_op_brcond_i32: +#if TCG_TARGET_REG_BITS ==32 +case INDEX_op_brcond2_i32: +#elif TCG_TARGET_REG_BITS ==64 +case INDEX_op_brcond_i64: +#endif +case INDEX_op_setcond_i32: +case INDEX_op_movcond_i32:#if TCG_TARGET_REG_BITS ==32 - || c == INDEX_op_brcond2_i32 +case INDEX_op_setcond2_i32:#elif TCG_TARGET_REG_BITS ==64 - || c == INDEX_op_brcond_i64 +case INDEX_op_setcond_i64: +case INDEX_op_movcond_i64:#endif - ) {if (args[k] <ARRAY_SIZE (cond_name) && cond_name[args[k]])fprintf (outfile,",%s" , cond_name[args[k++]]);else fprintf (outfile,",$0x%" TCG_PRIlx, args[k++]); i =1 ; - } -else +break ; +default : i =0 ; +break ; + }for (; i < nb_cargs; i++) {if (k !=0 )fprintf (outfile,"," );
commit eb326c39503ff265dc83e8792e87e6308d9dfd71
Author: Richard Henderson <[email protected]> Date: Fri Dec 18 11:51:35 2009 -0800
tcg-x86_64: Implement setcond and movcond.
Implement conditional moves in the x86_64 backend.
tcg/x86_64/tcg-target.c +68 -3
98 lines not on this page · raw message
commit 798a4a5bfc491fef81cf968cd0039ad60f34366a
Author: Richard Henderson <[email protected]> Date: Fri Dec 18 13:01:30 2009 -0800
tcg-i386: Implement small forward branches.
There are places, like brcond2, where we know that the destination of a forward branch will be within 127 bytes.
Add the R_386_PC8 relocation type to support this. Add a flag to tcg_out_jxx and tcg_out_brcond* to enable it. Set the flag in the brcond2 label_next branches; pass along the input flag otherwise.
elf.h +2 -0
@@ -243,6 +243,8 @@ typedef struct {#define R_386_GOTOFF 9#define R_386_GOTPC 10#define R_386_NUM 11 +/* Not a dynamic reloc, so not included in R_386_NUM. Used in TCG. */ +#define R_386_PC8 23#define R_MIPS_NONE 0#define R_MIPS_16 1
tcg/i386/tcg-target.c +74 -36
187 lines not on this page · raw message
commit b2c6cc4c5efa898b53653a35dd957dc653513a29
Author: Richard Henderson <[email protected]> Date: Fri Dec 18 13:29:53 2009 -0800
tcg-i386: Implement setcond, movcond, setcond2.
Implement conditional moves in the i386 backend.
tcg/i386/tcg-target.c +185 -3
218 lines not on this page · raw message
Laurent Desnogues
Acked-by[Qemu-devel] Re: tcg conditional set/move, round 3
Quoted 26 lines · Richard Henderson
Quoted 4 lines · Laurent Desnogues
Quoted 2 lines
tcg: Generic support for conditional set and conditional move.
Needs cosmetics changes.
Fixed, attachment 1.
Quoted 3 lines
Quoted 1 line
tcg-x86_64: Implement setcond and movcond.
Some cosmetics and comments, but overall good.
Fixed, attachment 2.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement small forward branches.
I think this contains a bug.
Fixed, attachment 3. I've added an abort to
patch_relocto verify that the relocation is in range. I've propagated the "small" flag to all of the branch functions so that...Quoted 3 lines
Quoted 1 line
tcg-i386: Simplify brcond2.
I don't like the rewrite of brcond2.
Quoted 7 lines
... this patch is dropped.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement setcond, movcond, setcond2.
Not yet reviewed.
Fixed, attachment 4. Similar changes to the amd64 patch.
Everything looks good to me, though for i386 I'd not bet my life it's 100% correct. OTOH I think this is good enough to go into mainline, so that people can start adding support in the front-ends.
BTW for compiling to 32-bit on a 64-bit x86, the configure script is broken as it checks gcc before having set -m32, so passing -march=i686 will make it fail (in the end it means I could not convince QEMU to use cmov :-).
Thanks,
Laurent
Re: [Qemu-devel] Re: tcg conditional set/move, round 3
Quoted 4 lines · Laurent Desnogues
BTW for compiling to 32-bit on a 64-bit x86, the configure script is broken as it checks gcc before having set -m32, so passing -march=i686 will make it fail (in the end it means I could not convince QEMU to use cmov :-).
One of my servers has a 32-bit install. I got tired of remembering the moderately long command-line required to configure GCC for a 32-bit build on a 64-bit host. :-)
r~
Re: [Qemu-devel] tcg conditional set/move, round 3
In reply to Richard HendersonHello,
Am 18.12.2009 um 22:38 schrieb Richard Henderson:
Quoted 1 line
<commit-cmov-1.txt><commit-cmov-amd64.txt><commit-cmov-i386-jmps.txt><commit-cmov-i386.txt>
Please send patches inline (and one patch per mail, like your original series), then a) you get more review comments and b) we can apply the patches with git-am (including your description) for testing. You can use git-send-email's --in-reply-to= to make them appear as reply in this thread.
Thanks,
Andreas
Re: [Qemu-devel] tcg conditional set/move, round 3
In reply to Richard HendersonQuoted 25 lines · Richard Henderson
Quoted 3 lines · Laurent Desnogues
Quoted 1 line
tcg: Generic support for conditional set and conditional move.
Needs cosmetics changes.
Fixed, attachment 1.
Quoted 3 lines
Quoted 1 line
tcg-x86_64: Implement setcond and movcond.
Some cosmetics and comments, but overall good.
Fixed, attachment 2.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement small forward branches.
I think this contains a bug.
Fixed, attachment 3. I've added an abort to
patch_relocto verify that the relocation is in range. I've propagated the "small" flag to all of the branch functions so that...Quoted 3 lines
Quoted 1 line
tcg-i386: Simplify brcond2.
I don't like the rewrite of brcond2.
Quoted 8 lines
... this patch is dropped.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement setcond, movcond, setcond2.
Not yet reviewed.
Fixed, attachment 4. Similar changes to the amd64 patch.
Could you please send the patches inline instead. It makes them easier to comment.
Please find my comments here:
- I am fine with the setcond instruction
- For the movcond instruction, is there a real use for vtrue and vfalse values? Most CPU actually implement a version with one value. Implementing it with two values moves complexity within the arch specific tcg code.
- Do we really want to make movcond mandatory? It can be easily implemented using setcond, and, or instructions.
- The cmov instruction is not supported on all i386 CPU. While it is unlikely that someone runs qemu-system on such a CPU, it is not improbable that someone runs qemu-user on such a CPU. We should probably provide an alternative code and a check in configure (e.g. trying to compile asm inline code containing a cmov instruction).
- I am not sure using xor and followed by setcc *conditionally* instead of a movzb after setcc is a good idea. The two instructions are supposed to be executed at the same speed, and time spent in code generation is not negligeable.
- Pay attention to the coding style, there are a few cases of if without {}.
A final comment, would it be possible to split setcond and movcond in different patches? setcond looks ready to go, there are probably some more concerns/comments about movcond.
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
Re: [Qemu-devel] tcg conditional set/move, round 3
Quoted 39 lines · Aurelien Jarno
Quoted 25 lines · Richard Henderson
Quoted 3 lines · Laurent Desnogues
Quoted 1 line
tcg: Generic support for conditional set and conditional move.
Needs cosmetics changes.
Fixed, attachment 1.
Quoted 3 lines
Quoted 1 line
tcg-x86_64: Implement setcond and movcond.
Some cosmetics and comments, but overall good.
Fixed, attachment 2.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement small forward branches.
I think this contains a bug.
Fixed, attachment 3. I've added an abort to
patch_relocto verify that the relocation is in range. I've propagated the "small" flag to all of the branch functions so that...Quoted 3 lines
Quoted 1 line
tcg-i386: Simplify brcond2.
I don't like the rewrite of brcond2.
Quoted 8 lines
... this patch is dropped.
Quoted 3 lines
Quoted 1 line
tcg-i386: Implement setcond, movcond, setcond2.
Not yet reviewed.
Fixed, attachment 4. Similar changes to the amd64 patch.
Could you please send the patches inline instead. It makes them easier to comment.
Quoted 13 lines
Please find my comments here:
- I am fine with the setcond instruction
- For the movcond instruction, is there a real use for vtrue and vfalse values? Most CPU actually implement a version with one value. Implementing it with two values moves complexity within the arch specific tcg code.
- Do we really want to make movcond mandatory? It can be easily implemented using setcond, and, or instructions.
- The cmov instruction is not supported on all i386 CPU. While it is unlikely that someone runs qemu-system on such a CPU, it is not improbable that someone runs qemu-user on such a CPU. We should probably provide an alternative code and a check in configure (e.g. trying to compile asm inline code containing a cmov instruction).
Forget about that, I read the i386 patch to quickly.
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
Re: [Qemu-devel] tcg conditional set/move, round 3
In reply to Aurelien JarnoQuoted 4 lines · Aurelien Jarno
- For the movcond instruction, is there a real use for vtrue and vfalse values? Most CPU actually implement a version with one value. Implementing it with two values moves complexity within the arch specific tcg code.
The reason I added both is that rather than force TCG to insert extra moves in order to always match VFALSE with DEST, I could have the backend invert the condition if VTRUE happened to match DEST already.
I suppose it would be possible to tweek the TCG register allocator to understand such commutative operations. That seemed harder, but perhaps it really isn't considering that inversion code has to be replicated across all the targets. It's certainly something to think about.
Quoted 2 lines
- Do we really want to make movcond mandatory? It can be easily implemented using setcond, and, or instructions.
I think so. In that every host does have something useful to emit that's better than the generic fallback, and we'll quickly have implementations for each.
Quoted 4 lines
- I am not sure using xor and followed by setcc *conditionally* instead of a movzb after setcc is a good idea. The two instructions are supposed to be executed at the same speed, and time spent in code generation is not negligeable.
I can certainly remove that bit if you insist.
Quoted 2 lines
- Pay attention to the coding style, there are a few cases of if without {}.
Ok. I try to remember, but it's at odds with my usual style, so please understand momentary lapses.
Quoted 3 lines
A final comment, would it be possible to split setcond and movcond in different patches? setcond looks ready to go, there are probably some more concerns/comments about movcond.
Ok.
r~
Re: [Qemu-devel] tcg conditional set/move, round 3
Quoted 11 lines · Richard Henderson
Quoted 4 lines · Aurelien Jarno
- For the movcond instruction, is there a real use for vtrue and vfalse values? Most CPU actually implement a version with one value. Implementing it with two values moves complexity within the arch specific tcg code.
The reason I added both is that rather than force TCG to insert extra moves in order to always match VFALSE with DEST, I could have the backend invert the condition if VTRUE happened to match DEST already.
Quoted 6 lines
I suppose it would be possible to tweek the TCG register allocator to understand such commutative operations. That seemed harder, but perhaps it really isn't considering that inversion code has to be replicated across all the targets. It's certainly something to think about.
My main concerns here is that we are introducing a complex code here that has to be multiplied by the number of TCG targets we have. On the other hand I am not sure there are a lot of use cases for the different architectures we support.
In addition I am reserved to make such bug changes given I am not sure it will result in a speed gain. All the previous setcond implementations have been stopped because there was no measurable gain.
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net