Linked list for tcg ops
v3 cover Linked list for tcg ops
Currently tcg ops are simply placed in a buffer in order. Which is fine until we want to actually do something with the opcode stream, such as optimize them. Note the horrible things like call opcodes needing their argument count both prefixed and postfixed so that we can iterate across the call either forward or backward.
While I'm changing this, I also move quite a lot of tcg-op.h out of line. There is very little benefit to having most of them be inline, since their arguments are extracted from the guest instructions being translated, and thus their values are not really predictable.
I chose a cutoff of one function call. If a tcg-op.h function consists of a single function call, inline it, otherwise move it out of line.
This also removes a bit of boilerplate from each target.
I haven't been able to measure a performance difference with this patch set. I wouldn't really expect any, as the complexity level remains the same. I simply find the link list significantly more maintainable.
Changes v2-v3:
* Parameter order bug affecting 32-bit hosts fixed (thanks Peter).
r~
Richard Henderson (8):
tcg: Move some opcode generation functions out of line
tcg: Reduce ifdefs in tcg-op.c
tcg: Move emit of INDEX_op_end into gen_tb_end
tcg: Introduce tcg_op_buf_count and tcg_op_buf_full
tcg: Put opcodes in a linked list
tcg: Remove opcodes instead of noping them out
tcg: Implement insert_op_before
tcg: Remove unused opcodes
Makefile.target | 2 +- include/exec/gen-icount.h | 22 +- target-alpha/translate.c | 16 +- target-arm/translate-a64.c | 10 +- target-arm/translate.c | 10 +- target-cris/translate.c | 15 +- target-i386/translate.c | 11 +- target-lm32/translate.c | 16 +- target-m68k/translate.c | 10 +- target-microblaze/translate.c | 22 +- target-mips/translate.c | 10 +- target-moxie/translate.c | 10 +- target-openrisc/translate.c | 15 +- target-ppc/translate.c | 11 +- target-s390x/translate.c | 11 +- target-sh4/translate.c | 10 +- target-sparc/translate.c | 10 +- target-tricore/translate.c | 5 +- target-unicore32/translate.c | 10 +- target-xtensa/translate.c | 8 +- tcg/optimize.c | 307 +++-- tcg/tcg-op.c | 1934 ++++++++++++++++++++++++++++++++ tcg/tcg-op.h | 2487 ++++++----------------------------------- tcg/tcg-opc.h | 9 - tcg/tcg.c | 532 +++------ tcg/tcg.h | 72 +- tci.c | 13 - 27 files changed, 2751 insertions(+), 2837 deletions(-) create mode 100644 tcg/tcg-op.c
Signature · 1 line
2.1.0
PATCH v3 1/8 tcg: Move some opcode generation functions out of line
Some of these functions are really quite large. We have a number of things that ought to be circularly dependent, but we duplicated code to break that chain for the inlines.
This saved 25% of the code size of one of the translators I examined.
--- Makefile.target | 2 +- tcg/tcg-op.c | 1978 +++++++++++++++++++++++++++++++++++++++++++ tcg/tcg-op.h | 2488 ++++++++----------------------------------------------- tcg/tcg.c | 137 --- tcg/tcg.h | 3 - 5 files changed, 2339 insertions(+), 2269 deletions(-) create mode 100644 tcg/tcg-op.c
Makefile.target +1 -1
@@ -83,7 +83,7 @@ all: $(PROGS) stap ######################################################### # cpu emulator library obj-y = exec.o translate-all.o cpu-exec.o -obj-y += tcg/tcg.o tcg/optimize.o +obj-y += tcg/tcg.o tcg/tcg-op.o tcg/optimize.o obj-$(CONFIG_TCG_INTERPRETER) += tci.o obj-$(CONFIG_TCG_INTERPRETER) += disas/tci.o obj-y += fpu/softfloat.o
tcg/tcg-op.c new file +1978 -0
1,978 lines not on this page · raw message
tcg/tcg-op.h +360 -2128
1,014 lines not on this page · raw message
tcg/tcg.c +0 -137
137 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.1.0
Part of the diff is not shown here. View the raw message.
Re: [Qemu-devel] [PATCH v3 1/8] tcg: Move some opcode generation functions out of line
Quoted 31 lines · Richard Henderson
Some of these functions are really quite large. We have a number of things that ought to be circularly dependent, but we duplicated code to break that chain for the inlines.
This saved 25% of the code size of one of the translators I examined.
Reviewed-by Bastian Koppelmann<[email protected]>Signed-off-by Richard Henderson<[email protected]>--- Makefile.target | 2 +- tcg/tcg-op.c | 1978 +++++++++++++++++++++++++++++++++++++++++++ tcg/tcg-op.h | 2488 ++++++++----------------------------------------------- tcg/tcg.c | 137 --- tcg/tcg.h | 3 - 5 files changed, 2339 insertions(+), 2269 deletions(-)create mode 100644
tcg/tcg-op.ctcg/tcg-op.c new file +13
-0+static inline TCGMemOp tcg_canonicalize_memop (TCGMemOp op,bool is64,bool st) +{ +switch (op &MO_SIZE ) { +case MO_8 : + op &= ~MO_BSWAP ; +break ; +case MO_16 : +break ; +case MO_32 : +if (!is64) { + op &= ~MO_SIGN ; + } +break ;
tcg/tcg-op.c line 1892
Quoted 10 lines
tcg/tcg-op.c new file +9
-0+case MO_64 : +if (!is64) { +tcg_abort (); + } +break ; + } +if (st) { + op &= ~MO_SIGN ; + }
I've got some weird trailing whitespace here, but maybe it's just my mail client.
Cheers,
Bastian
Re: [Qemu-devel] [PATCH v3 1/8] tcg: Move some opcode generation functions out of line
Quoted 1 line · Bastian Koppelmann
I've got some weird trailing whitespace here, but maybe it's just my mail client.
I guess so; checkpatch doesn't see any on the actual patch.
r~
PATCH v3 2/8 tcg: Reduce ifdefs in tcg-op.c
In reply to Richard HendersonAlmost completely eliminates the ifdefs in this file, improving confidence in the lesser used 32-bit builds.
--- tcg/tcg-op.c | 449 +++++++++++++++++++++++++++-------------------------------- 1 file changed, 207 insertions(+), 242 deletions(-)
tcg/tcg-op.c +207 -242
@@ -25,6 +25,15 @@#include "tcg.h" #include "tcg-op.h" +/* Reduce the number of ifdefs below. This assumes that all uses of +TCGV_HIGH and TCGV_LOW are properly protected by a conditional that +the compiler can eliminate. */ +#if TCG_TARGET_REG_BITS ==64 +extern TCGv_i32 TCGV_LOW_link_error (TCGv_i64 ); +extern TCGv_i32 TCGV_HIGH_link_error (TCGv_i64 ); +#define TCGV_LOW TCGV_LOW_link_error +#define TCGV_HIGH TCGV_HIGH_link_error +#endif void tcg_gen_op0 (TCGContext *ctx,TCGOpcode opc) {
@@ -901,11 +910,14 @@ void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)void tcg_gen_andi_i64 (TCGv_i64 ret,TCGv_i64 arg1,uint64_t arg2) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_andi_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); -tcg_gen_andi_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); -#else TCGv_i64 t0; + +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_andi_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); +tcg_gen_andi_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); +return ; + } +/* Some cases can be optimized here. */ switch (arg2) {case 0 :
@@ -937,15 +949,15 @@ void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, uint64_t arg2) t0 =tcg_const_i64 (arg2);tcg_gen_and_i64 (ret, arg1, t0);tcg_temp_free_i64 (t0); -#endif }void tcg_gen_ori_i64 (TCGv_i64 ret,TCGv_i64 arg1,int64_t arg2) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_ori_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); -tcg_gen_ori_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); -#else +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_ori_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); +tcg_gen_ori_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); +return ; + }/* Some cases can be optimized here. */ if (arg2 ==-1 ) {tcg_gen_movi_i64 (ret,-1 );
@@ -956,15 +968,15 @@ void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)tcg_gen_or_i64 (ret, arg1, t0);tcg_temp_free_i64 (t0); } -#endif }void tcg_gen_xori_i64 (TCGv_i64 ret,TCGv_i64 arg1,int64_t arg2) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_xori_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); -tcg_gen_xori_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); -#else +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_xori_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), arg2); +tcg_gen_xori_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), arg2 >>32 ); +return ; + }/* Some cases can be optimized here. */ if (arg2 ==0 ) {tcg_gen_mov_i64 (ret, arg1);
@@ -976,10 +988,8 @@ void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)tcg_gen_xor_i64 (ret, arg1, t0);tcg_temp_free_i64 (t0); } -#endif } -#if TCG_TARGET_REG_BITS ==32 static inline void tcg_gen_shifti_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned c,bool right,bool arith) {
@@ -1031,23 +1041,10 @@ static inline void tcg_gen_shifti_i64(TCGv_i64 ret, TCGv_i64 arg1,void tcg_gen_shli_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) { -tcg_gen_shifti_i64 (ret, arg1, arg2,0 ,0 ); -} - -void tcg_gen_shri_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) -{ -tcg_gen_shifti_i64 (ret, arg1, arg2,1 ,0 ); -} - -void tcg_gen_sari_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) -{ -tcg_gen_shifti_i64 (ret, arg1, arg2,1 ,1 ); -} -#else /* TCG_TARGET_REG_SIZE == 64 */ -void tcg_gen_shli_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) -{tcg_debug_assert (arg2 <64 ); -if (arg2 ==0 ) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_shifti_i64 (ret, arg1, arg2,0 ,0 ); + }else if (arg2 ==0 ) {tcg_gen_mov_i64 (ret, arg1); }else {TCGv_i64 t0 =tcg_const_i64 (arg2);
@@ -1059,7 +1056,9 @@ void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, unsigned arg2)void tcg_gen_shri_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) {tcg_debug_assert (arg2 <64 ); -if (arg2 ==0 ) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_shifti_i64 (ret, arg1, arg2,1 ,0 ); + }else if (arg2 ==0 ) {tcg_gen_mov_i64 (ret, arg1); }else {TCGv_i64 t0 =tcg_const_i64 (arg2);
@@ -1071,7 +1070,9 @@ void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, unsigned arg2)void tcg_gen_sari_i64 (TCGv_i64 ret,TCGv_i64 arg1,unsigned arg2) {tcg_debug_assert (arg2 <64 ); -if (arg2 ==0 ) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_shifti_i64 (ret, arg1, arg2,1 ,1 ); + }else if (arg2 ==0 ) {tcg_gen_mov_i64 (ret, arg1); }else {TCGv_i64 t0 =tcg_const_i64 (arg2);
@@ -1079,20 +1080,19 @@ void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, unsigned arg2)tcg_temp_free_i64 (t0); } } -#endif /* TCG_TARGET_REG_SIZE */ void tcg_gen_brcond_i64 (TCGCond cond,TCGv_i64 arg1,TCGv_i64 arg2,int label) {if (cond ==TCG_COND_ALWAYS ) {tcg_gen_br (label); }else if (cond !=TCG_COND_NEVER ) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_op6ii_i32 (INDEX_op_brcond2_i32,TCGV_LOW (arg1), -TCGV_HIGH (arg1),TCGV_LOW (arg2), -TCGV_HIGH (arg2), cond, label); -#else -tcg_gen_op4ii_i64 (INDEX_op_brcond_i64, arg1, arg2, cond, label); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_op6ii_i32 (INDEX_op_brcond2_i32,TCGV_LOW (arg1), +TCGV_HIGH (arg1),TCGV_LOW (arg2), +TCGV_HIGH (arg2), cond, label); + }else { +tcg_gen_op4ii_i64 (INDEX_op_brcond_i64, arg1, arg2, cond, label); + } } }
@@ -1115,14 +1115,14 @@ void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret, }else if (cond ==TCG_COND_NEVER ) {tcg_gen_movi_i64 (ret,0 ); }else { -#if TCG_TARGET_REG_BITS ==32 -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 ); -#else -tcg_gen_op4i_i64 (INDEX_op_setcond_i64, ret, arg1, arg2, cond); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { +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 ); + }else { +tcg_gen_op4i_i64 (INDEX_op_setcond_i64, ret, arg1, arg2, cond); + } } }
@@ -1211,99 +1211,86 @@ void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)void tcg_gen_ext8s_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_ext8s_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); -#else -if (TCG_TARGET_HAS_ext8s_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_ext8s_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); + }else if (TCG_TARGET_HAS_ext8s_i64) {tcg_gen_op2_i64 (INDEX_op_ext8s_i64, ret, arg); }else {tcg_gen_shli_i64 (ret, arg,56 );tcg_gen_sari_i64 (ret, ret,56 ); } -#endif }void tcg_gen_ext16s_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_ext16s_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); -#else -if (TCG_TARGET_HAS_ext16s_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_ext16s_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); + }else if (TCG_TARGET_HAS_ext16s_i64) {tcg_gen_op2_i64 (INDEX_op_ext16s_i64, ret, arg); }else {tcg_gen_shli_i64 (ret, arg,48 );tcg_gen_sari_i64 (ret, ret,48 ); } -#endif }void tcg_gen_ext32s_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); -#else -if (TCG_TARGET_HAS_ext32s_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); + }else if (TCG_TARGET_HAS_ext32s_i64) {tcg_gen_op2_i64 (INDEX_op_ext32s_i64, ret, arg); }else {tcg_gen_shli_i64 (ret, arg,32 );tcg_gen_sari_i64 (ret, ret,32 ); } -#endif }void tcg_gen_ext8u_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_ext8u_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -if (TCG_TARGET_HAS_ext8u_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_ext8u_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else if (TCG_TARGET_HAS_ext8u_i64) {tcg_gen_op2_i64 (INDEX_op_ext8u_i64, ret, arg); }else {tcg_gen_andi_i64 (ret, arg,0xffu ); } -#endif }void tcg_gen_ext16u_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_ext16u_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -if (TCG_TARGET_HAS_ext16u_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_ext16u_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else if (TCG_TARGET_HAS_ext16u_i64) {tcg_gen_op2_i64 (INDEX_op_ext16u_i64, ret, arg); }else {tcg_gen_andi_i64 (ret, arg,0xffffu ); } -#endif }void tcg_gen_ext32u_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -if (TCG_TARGET_HAS_ext32u_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else if (TCG_TARGET_HAS_ext32u_i64) {tcg_gen_op2_i64 (INDEX_op_ext32u_i64, ret, arg); }else {tcg_gen_andi_i64 (ret, arg,0xffffffffu ); } -#endif }/* Note: we assume the six high bytes are set to zero */ void tcg_gen_bswap16_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_bswap16_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -if (TCG_TARGET_HAS_bswap16_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_bswap16_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else if (TCG_TARGET_HAS_bswap16_i64) {tcg_gen_op2_i64 (INDEX_op_bswap16_i64, ret, arg); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();
@@ -1314,17 +1301,15 @@ void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)tcg_gen_or_i64 (ret, ret, t0);tcg_temp_free_i64 (t0); } -#endif }/* Note: we assume the four high bytes are set to zero */ void tcg_gen_bswap32_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_bswap32_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -if (TCG_TARGET_HAS_bswap32_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_bswap32_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else if (TCG_TARGET_HAS_bswap32_i64) {tcg_gen_op2_i64 (INDEX_op_bswap32_i64, ret, arg); }else {TCGv_i64 t0, t1;
@@ -1347,24 +1332,22 @@ void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)tcg_temp_free_i64 (t0);tcg_temp_free_i64 (t1); } -#endif }void tcg_gen_bswap64_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -TCGv_i32 t0, t1; - t0 =tcg_temp_new_i32 (); - t1 =tcg_temp_new_i32 (); +if (TCG_TARGET_REG_BITS ==32 ) { +TCGv_i32 t0, t1; + t0 =tcg_temp_new_i32 (); + t1 =tcg_temp_new_i32 (); -tcg_gen_bswap32_i32 (t0,TCGV_LOW (arg)); -tcg_gen_bswap32_i32 (t1,TCGV_HIGH (arg)); -tcg_gen_mov_i32 (TCGV_LOW (ret), t1); -tcg_gen_mov_i32 (TCGV_HIGH (ret), t0); -tcg_temp_free_i32 (t0); -tcg_temp_free_i32 (t1); -#else -if (TCG_TARGET_HAS_bswap64_i64) { +tcg_gen_bswap32_i32 (t0,TCGV_LOW (arg)); +tcg_gen_bswap32_i32 (t1,TCGV_HIGH (arg)); +tcg_gen_mov_i32 (TCGV_LOW (ret), t1); +tcg_gen_mov_i32 (TCGV_HIGH (ret), t0); +tcg_temp_free_i32 (t0); +tcg_temp_free_i32 (t1); + }else if (TCG_TARGET_HAS_bswap64_i64) {tcg_gen_op2_i64 (INDEX_op_bswap64_i64, ret, arg); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();
@@ -1401,27 +1384,26 @@ void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)tcg_temp_free_i64 (t0);tcg_temp_free_i64 (t1); } -#endif }void tcg_gen_not_i64 (TCGv_i64 ret,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_not_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_not_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); +tcg_gen_not_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg)); + }else if (TCG_TARGET_HAS_not_i64) {tcg_gen_op2_i64 (INDEX_op_not_i64, ret, arg); }else {tcg_gen_xori_i64 (ret, arg,-1 ); } -#else -tcg_gen_not_i32 (TCGV_LOW (ret),TCGV_LOW (arg)); -tcg_gen_not_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg)); -#endif }void tcg_gen_andc_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_andc_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_andc_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); +tcg_gen_andc_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); + }else if (TCG_TARGET_HAS_andc_i64) {tcg_gen_op3_i64 (INDEX_op_andc_i64, ret, arg1, arg2); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();
@@ -1429,61 +1411,53 @@ void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)tcg_gen_and_i64 (ret, arg1, t0);tcg_temp_free_i64 (t0); } -#else -tcg_gen_andc_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); -tcg_gen_andc_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); -#endif }void tcg_gen_eqv_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_eqv_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_eqv_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); +tcg_gen_eqv_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); + }else if (TCG_TARGET_HAS_eqv_i64) {tcg_gen_op3_i64 (INDEX_op_eqv_i64, ret, arg1, arg2); }else {tcg_gen_xor_i64 (ret, arg1, arg2);tcg_gen_not_i64 (ret, ret); } -#else -tcg_gen_eqv_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); -tcg_gen_eqv_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); -#endif }void tcg_gen_nand_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_nand_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_nand_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); +tcg_gen_nand_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); + }else if (TCG_TARGET_HAS_nand_i64) {tcg_gen_op3_i64 (INDEX_op_nand_i64, ret, arg1, arg2); }else {tcg_gen_and_i64 (ret, arg1, arg2);tcg_gen_not_i64 (ret, ret); } -#else -tcg_gen_nand_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); -tcg_gen_nand_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); -#endif }void tcg_gen_nor_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_nor_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_nor_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); +tcg_gen_nor_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); + }else if (TCG_TARGET_HAS_nor_i64) {tcg_gen_op3_i64 (INDEX_op_nor_i64, ret, arg1, arg2); }else {tcg_gen_or_i64 (ret, arg1, arg2);tcg_gen_not_i64 (ret, ret); } -#else -tcg_gen_nor_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); -tcg_gen_nor_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); -#endif }void tcg_gen_orc_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2) { -#if TCG_TARGET_REG_BITS ==64 -if (TCG_TARGET_HAS_orc_i64) { +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_orc_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); +tcg_gen_orc_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); + }else if (TCG_TARGET_HAS_orc_i64) {tcg_gen_op3_i64 (INDEX_op_orc_i64, ret, arg1, arg2); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();
@@ -1491,10 +1465,6 @@ void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)tcg_gen_or_i64 (ret, arg1, t0);tcg_temp_free_i64 (t0); } -#else -tcg_gen_orc_i32 (TCGV_LOW (ret),TCGV_LOW (arg1),TCGV_LOW (arg2)); -tcg_gen_orc_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1),TCGV_HIGH (arg2)); -#endif }void tcg_gen_rotl_i64 (TCGv_i64 ret,TCGv_i64 arg1,TCGv_i64 arg2)
@@ -1583,20 +1553,20 @@ void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2,return ; } -#if TCG_TARGET_REG_BITS ==32 -if (ofs >=32 ) { -tcg_gen_deposit_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), -TCGV_LOW (arg2), ofs -32 , len); -tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg1)); -return ; - } -if (ofs + len <=32 ) { -tcg_gen_deposit_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), -TCGV_LOW (arg2), ofs, len); -tcg_gen_mov_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1)); -return ; +if (TCG_TARGET_REG_BITS ==32 ) { +if (ofs >=32 ) { +tcg_gen_deposit_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1), +TCGV_LOW (arg2), ofs -32 , len); +tcg_gen_mov_i32 (TCGV_LOW (ret),TCGV_LOW (arg1)); +return ; + } +if (ofs + len <=32 ) { +tcg_gen_deposit_i32 (TCGV_LOW (ret),TCGV_LOW (arg1), +TCGV_LOW (arg2), ofs, len); +tcg_gen_mov_i32 (TCGV_HIGH (ret),TCGV_HIGH (arg1)); +return ; + } } -#endif mask = (1ull << len) -1 ; t1 =tcg_temp_new_i64 ();
@@ -1616,34 +1586,33 @@ void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2,void tcg_gen_movcond_i64 (TCGCond cond,TCGv_i64 ret,TCGv_i64 c1,TCGv_i64 c2,TCGv_i64 v1,TCGv_i64 v2) { -#if TCG_TARGET_REG_BITS ==32 -TCGv_i32 t0 =tcg_temp_new_i32 (); -TCGv_i32 t1 =tcg_temp_new_i32 (); -tcg_gen_op6i_i32 (INDEX_op_setcond2_i32, t0, -TCGV_LOW (c1),TCGV_HIGH (c1), -TCGV_LOW (c2),TCGV_HIGH (c2), cond); - -if (TCG_TARGET_HAS_movcond_i32) { -tcg_gen_movi_i32 (t1,0 ); -tcg_gen_movcond_i32 (TCG_COND_NE ,TCGV_LOW (ret), t0, t1, -TCGV_LOW (v1),TCGV_LOW (v2)); -tcg_gen_movcond_i32 (TCG_COND_NE ,TCGV_HIGH (ret), t0, t1, -TCGV_HIGH (v1),TCGV_HIGH (v2)); - }else { -tcg_gen_neg_i32 (t0, t0); +if (TCG_TARGET_REG_BITS ==32 ) { +TCGv_i32 t0 =tcg_temp_new_i32 (); +TCGv_i32 t1 =tcg_temp_new_i32 (); +tcg_gen_op6i_i32 (INDEX_op_setcond2_i32, t0, +TCGV_LOW (c1),TCGV_HIGH (c1), +TCGV_LOW (c2),TCGV_HIGH (c2), cond); + +if (TCG_TARGET_HAS_movcond_i32) { +tcg_gen_movi_i32 (t1,0 ); +tcg_gen_movcond_i32 (TCG_COND_NE ,TCGV_LOW (ret), t0, t1, +TCGV_LOW (v1),TCGV_LOW (v2)); +tcg_gen_movcond_i32 (TCG_COND_NE ,TCGV_HIGH (ret), t0, t1, +TCGV_HIGH (v1),TCGV_HIGH (v2)); + }else { +tcg_gen_neg_i32 (t0, t0); -tcg_gen_and_i32 (t1,TCGV_LOW (v1), t0); -tcg_gen_andc_i32 (TCGV_LOW (ret),TCGV_LOW (v2), t0); -tcg_gen_or_i32 (TCGV_LOW (ret),TCGV_LOW (ret), t1); +tcg_gen_and_i32 (t1,TCGV_LOW (v1), t0); +tcg_gen_andc_i32 (TCGV_LOW (ret),TCGV_LOW (v2), t0); +tcg_gen_or_i32 (TCGV_LOW (ret),TCGV_LOW (ret), t1); -tcg_gen_and_i32 (t1,TCGV_HIGH (v1), t0); -tcg_gen_andc_i32 (TCGV_HIGH (ret),TCGV_HIGH (v2), t0); -tcg_gen_or_i32 (TCGV_HIGH (ret),TCGV_HIGH (ret), t1); - } -tcg_temp_free_i32 (t0); -tcg_temp_free_i32 (t1); -#else -if (TCG_TARGET_HAS_movcond_i64) { +tcg_gen_and_i32 (t1,TCGV_HIGH (v1), t0); +tcg_gen_andc_i32 (TCGV_HIGH (ret),TCGV_HIGH (v2), t0); +tcg_gen_or_i32 (TCGV_HIGH (ret),TCGV_HIGH (ret), t1); + } +tcg_temp_free_i32 (t0); +tcg_temp_free_i32 (t1); + }else if (TCG_TARGET_HAS_movcond_i64) {tcg_gen_op6i_i64 (INDEX_op_movcond_i64, ret, c1, c2, v1, v2, cond); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();
@@ -1656,7 +1625,6 @@ void tcg_gen_movcond_i64(TCGCond cond, TCGv_i64 ret, TCGv_i64 c1,tcg_temp_free_i64 (t0);tcg_temp_free_i64 (t1); } -#endif } void tcg_gen_add2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al,
@@ -1764,19 +1732,18 @@ void tcg_gen_muls2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2)void tcg_gen_trunc_shr_i64_i32 (TCGv_i32 ret,TCGv_i64 arg,unsigned count) {tcg_debug_assert (count <64 ); -#if TCG_TARGET_REG_BITS ==32 -if (count >=32 ) { -tcg_gen_shri_i32 (ret,TCGV_HIGH (arg), count -32 ); - }else if (count ==0 ) { -tcg_gen_mov_i32 (ret,TCGV_LOW (arg)); - }else { -TCGv_i64 t =tcg_temp_new_i64 (); -tcg_gen_shri_i64 (t, arg, count); -tcg_gen_mov_i32 (ret,TCGV_LOW (t)); -tcg_temp_free_i64 (t); - } -#else -if (TCG_TARGET_HAS_trunc_shr_i32) { +if (TCG_TARGET_REG_BITS ==32 ) { +if (count >=32 ) { +tcg_gen_shri_i32 (ret,TCGV_HIGH (arg), count -32 ); + }else if (count ==0 ) { +tcg_gen_mov_i32 (ret,TCGV_LOW (arg)); + }else { +TCGv_i64 t =tcg_temp_new_i64 (); +tcg_gen_shri_i64 (t, arg, count); +tcg_gen_mov_i32 (ret,TCGV_LOW (t)); +tcg_temp_free_i64 (t); + } + }else if (TCG_TARGET_HAS_trunc_shr_i32) {tcg_gen_op3i_i32 (INDEX_op_trunc_shr_i32, ret,MAKE_TCGV_I32 (GET_TCGV_I64 (arg)), count); }else if (count ==0 ) {
@@ -1787,40 +1754,43 @@ void tcg_gen_trunc_shr_i64_i32(TCGv_i32 ret, TCGv_i64 arg, unsigned count)tcg_gen_mov_i32 (ret,MAKE_TCGV_I32 (GET_TCGV_I64 (t)));tcg_temp_free_i64 (t); } -#endif }void tcg_gen_extu_i32_i64 (TCGv_i64 ret,TCGv_i32 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (TCGV_LOW (ret), arg); -tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); -#else -/* Note: we assume the target supports move between -32 and 64 bit registers. */ -tcg_gen_ext32u_i64 (ret,MAKE_TCGV_I64 (GET_TCGV_I32 (arg))); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (TCGV_LOW (ret), arg); +tcg_gen_movi_i32 (TCGV_HIGH (ret),0 ); + }else { +/* Note: we assume the target supports move between +32 and 64 bit registers. */ +tcg_gen_ext32u_i64 (ret,MAKE_TCGV_I64 (GET_TCGV_I32 (arg))); + } }void tcg_gen_ext_i32_i64 (TCGv_i64 ret,TCGv_i32 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (TCGV_LOW (ret), arg); -tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); -#else -/* Note: we assume the target supports move between -32 and 64 bit registers. */ -tcg_gen_ext32s_i64 (ret,MAKE_TCGV_I64 (GET_TCGV_I32 (arg))); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (TCGV_LOW (ret), arg); +tcg_gen_sari_i32 (TCGV_HIGH (ret),TCGV_LOW (ret),31 ); + }else { +/* Note: we assume the target supports move between +32 and 64 bit registers. */ +tcg_gen_ext32s_i64 (ret,MAKE_TCGV_I64 (GET_TCGV_I32 (arg))); + } }void tcg_gen_concat_i32_i64 (TCGv_i64 dest,TCGv_i32 low,TCGv_i32 high) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (TCGV_LOW (dest), low); -tcg_gen_mov_i32 (TCGV_HIGH (dest), high); -#else -TCGv_i64 tmp =tcg_temp_new_i64 (); +TCGv_i64 tmp; + +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (TCGV_LOW (dest), low); +tcg_gen_mov_i32 (TCGV_HIGH (dest), high); +return ; + } + + tmp =tcg_temp_new_i64 ();/* These extensions are only needed for type correctness. We may be able to do better given target specific information. */ tcg_gen_extu_i32_i64 (tmp, high);
@@ -1834,18 +1804,17 @@ void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high)tcg_gen_or_i64 (dest, dest, tmp); }tcg_temp_free_i64 (tmp); -#endif }void tcg_gen_extr_i64_i32 (TCGv_i32 lo,TCGv_i32 hi,TCGv_i64 arg) { -#if TCG_TARGET_REG_BITS ==32 -tcg_gen_mov_i32 (lo,TCGV_LOW (arg)); -tcg_gen_mov_i32 (hi,TCGV_HIGH (arg)); -#else -tcg_gen_trunc_shr_i64_i32 (lo, arg,0 ); -tcg_gen_trunc_shr_i64_i32 (hi, arg,32 ); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { +tcg_gen_mov_i32 (lo,TCGV_LOW (arg)); +tcg_gen_mov_i32 (hi,TCGV_HIGH (arg)); + }else { +tcg_gen_trunc_shr_i64_i32 (lo, arg,0 ); +tcg_gen_trunc_shr_i64_i32 (hi, arg,32 ); + } }void tcg_gen_extr32_i64 (TCGv_i64 lo,TCGv_i64 hi,TCGv_i64 arg)
@@ -1900,12 +1869,12 @@ static inline void tcg_add_param_i32(TCGv_i32 val)static inline void tcg_add_param_i64 (TCGv_i64 val) { -#if TCG_TARGET_REG_BITS ==32 - *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I32 (TCGV_LOW (val)); - *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I32 (TCGV_HIGH (val)); -#else - *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I64 (val); -#endif +if (TCG_TARGET_REG_BITS ==32 ) { + *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I32 (TCGV_LOW (val)); + *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I32 (TCGV_HIGH (val)); + }else { + *tcg_ctx.gen_opparam_ptr++ =GET_TCGV_I64 (val); + } }#if TARGET_LONG_BITS ==32
@@ -1940,8 +1909,7 @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) { memop =tcg_canonicalize_memop (memop,1 ,0 ); -#if TCG_TARGET_REG_BITS ==32 -if ((memop &MO_SIZE ) <MO_64 ) { +if (TCG_TARGET_REG_BITS ==32 && (memop &MO_SIZE ) <MO_64 ) {tcg_gen_qemu_ld_i32 (TCGV_LOW (val), addr, idx, memop);if (memop &MO_SIGN ) {tcg_gen_sari_i32 (TCGV_HIGH (val),TCGV_LOW (val),31 );
@@ -1950,7 +1918,6 @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) }return ; } -#endif *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_ld_i64;tcg_add_param_i64 (val);
@@ -1963,12 +1930,10 @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop) { memop =tcg_canonicalize_memop (memop,1 ,1 ); -#if TCG_TARGET_REG_BITS ==32 -if ((memop &MO_SIZE ) <MO_64 ) { +if (TCG_TARGET_REG_BITS ==32 && (memop &MO_SIZE ) <MO_64 ) {tcg_gen_qemu_st_i32 (TCGV_LOW (val), addr, idx, memop);return ; } -#endif *tcg_ctx.gen_opc_ptr++ = INDEX_op_qemu_st_i64;tcg_add_param_i64 (val);
Signature · 1 line
2.1.0
PATCH v3 3/8 tcg: Move emit of INDEX_op_end into gen_tb_end
In reply to Richard Henderson--- include/exec/gen-icount.h | 2 ++ target-alpha/translate.c | 2 +- target-arm/translate-a64.c | 1 - target-arm/translate.c | 1 - target-cris/translate.c | 2 +- target-i386/translate.c | 2 +- target-lm32/translate.c | 2 +- target-m68k/translate.c | 1 - target-microblaze/translate.c | 2 +- target-mips/translate.c | 2 +- target-moxie/translate.c | 2 +- target-openrisc/translate.c | 2 +- target-ppc/translate.c | 2 +- target-s390x/translate.c | 2 +- target-sh4/translate.c | 2 +- target-sparc/translate.c | 2 +- target-tricore/translate.c | 1 - target-unicore32/translate.c | 1 - target-xtensa/translate.c | 1 - 19 files changed, 14 insertions(+), 18 deletions(-)
include/exec/gen-icount.h +2 -0
@@ -48,6 +48,8 @@ static void gen_tb_end(TranslationBlock *tb, int num_insns)gen_set_label (icount_label);tcg_gen_exit_tb ((uintptr_t )tb +TB_EXIT_ICOUNT_EXPIRED ); } + + *tcg_ctx.gen_opc_ptr = INDEX_op_end; }static inline void gen_io_start (void )
target-alpha/translate.c +1 -1
@@ -2912,7 +2912,7 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-arm/translate-a64.c +0 -1
@@ -11090,7 +11090,6 @@ void gen_intermediate_code_internal_a64(ARMCPU *cpu, done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;#ifdef DEBUG_DISAS if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {
target-arm/translate.c +0 -1
@@ -11330,7 +11330,6 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu, done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;#ifdef DEBUG_DISAS if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {
target-cris/translate.c +1 -1
@@ -3344,7 +3344,7 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb, } }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-i386/translate.c +1 -1
@@ -8077,7 +8077,7 @@ static inline void gen_intermediate_code_internal(X86CPU *cpu,gen_io_end (); done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +/* we don't forget to fill the last values */ if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
target-lm32/translate.c +1 -1
@@ -1158,7 +1158,7 @@ void gen_intermediate_code_internal(LM32CPU *cpu, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-m68k/translate.c +0 -1
@@ -3075,7 +3075,6 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb, } }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;#ifdef DEBUG_DISAS if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {
target-microblaze/translate.c +1 -1
@@ -1846,7 +1846,7 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb, } }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-mips/translate.c +1 -1
@@ -19240,7 +19240,7 @@ gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb, } done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-moxie/translate.c +1 -1
@@ -900,7 +900,7 @@ gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb, } done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-openrisc/translate.c +1 -1
@@ -1759,7 +1759,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; k++;
target-ppc/translate.c +1 -1
@@ -11598,7 +11598,7 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,tcg_gen_exit_tb (0 ); }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (unlikely (search_pc)) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-s390x/translate.c +1 -1
@@ -4856,7 +4856,7 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-sh4/translate.c +1 -1
@@ -1962,7 +1962,7 @@ gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (search_pc) { i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; ii++;
target-sparc/translate.c +1 -1
@@ -5320,7 +5320,7 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu, } }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +if (spc) { j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; lj++;
target-tricore/translate.c +0 -1
@@ -5538,7 +5538,6 @@ gen_intermediate_code_internal(TriCoreCPU *cpu, struct TranslationBlock *tb, }gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;if (search_pc) {printf ("done_generating search pc\n" ); }else {
target-unicore32/translate.c +0 -1
@@ -2037,7 +2037,6 @@ static inline void gen_intermediate_code_internal(UniCore32CPU *cpu, done_generating:gen_tb_end (tb, num_insns); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;#ifdef DEBUG_DISAS if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {
target-xtensa/translate.c +0 -1
@@ -3133,7 +3133,6 @@ void gen_intermediate_code_internal(XtensaCPU *cpu,gen_jumpi (&dc, dc.pc,0 ); }gen_tb_end (tb, insn_count); - *tcg_ctx.gen_opc_ptr = INDEX_op_end;#ifdef DEBUG_DISAS if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {
Signature · 1 line
2.1.0
PATCH v3 4/8 tcg: Introduce tcg_op_buf_count and tcg_op_buf_full
In reply to Richard HendersonThe method by which we count the number of ops emitted is going to change. Abstract that away into some inlines.
--- target-alpha/translate.c | 14 +++++++------- target-arm/translate-a64.c | 9 +++------ target-arm/translate.c | 9 +++------ target-cris/translate.c | 13 +++++-------- target-i386/translate.c | 9 +++------ target-lm32/translate.c | 14 +++++--------- target-m68k/translate.c | 9 +++------ target-microblaze/translate.c | 20 ++++++++------------ target-mips/translate.c | 8 +++----- target-moxie/translate.c | 8 +++----- target-openrisc/translate.c | 13 +++++-------- target-ppc/translate.c | 9 +++------ target-s390x/translate.c | 9 +++------ target-sh4/translate.c | 8 +++----- target-sparc/translate.c | 8 +++----- target-tricore/translate.c | 4 +--- target-unicore32/translate.c | 9 +++------ target-xtensa/translate.c | 7 +++---- tcg/tcg.h | 12 ++++++++++++ 19 files changed, 79 insertions(+), 113 deletions(-)
target-alpha/translate.c +7 -7
@@ -2790,7 +2790,6 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu,target_ulong pc_start;target_ulong pc_mask;uint32_t insn; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj =-1 ;ExitStatus ret;
@@ -2798,7 +2797,6 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu,int max_insns; pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.tb = tb; ctx.pc = pc_start;
@@ -2839,11 +2837,12 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu, } }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++; -while (lj < j) +while (lj < j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ; + } } tcg_ctx.gen_opc_pc[lj] = ctx.pc; tcg_ctx.gen_opc_instr_start[lj] =1 ;
@@ -2881,7 +2880,7 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu,or exhaust instruction count, stop generation. */ if (ret ==NO_EXIT && ((ctx.pc & pc_mask) ==0 - || tcg_ctx.gen_opc_ptr >= gen_opc_end + ||tcg_op_buf_full () || num_insns >= max_insns || singlestep || ctx.singlestep_enabled)) {
@@ -2914,10 +2913,11 @@ static inline void gen_intermediate_code_internal(AlphaCPU *cpu,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++; -while (lj <= j) +while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ; + } }else { tb->size = ctx.pc - pc_start; tb->icount = num_insns;
target-arm/translate-a64.c +3 -6
@@ -10899,7 +10899,6 @@ void gen_intermediate_code_internal_a64(ARMCPU *cpu,CPUARMState *env = &cpu->env;DisasContext dc1, *dc = &dc1;CPUBreakpoint *bp; -uint16_t *gen_opc_end;int j, lj;target_ulong pc_start;target_ulong next_page_start;
@@ -10910,8 +10909,6 @@ void gen_intermediate_code_internal_a64(ARMCPU *cpu, dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->pc = pc_start; dc->singlestep_enabled = cs->singlestep_enabled;
@@ -10980,7 +10977,7 @@ void gen_intermediate_code_internal_a64(ARMCPU *cpu, }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -11030,7 +11027,7 @@ void gen_intermediate_code_internal_a64(ARMCPU *cpu,* ensures prefetch aborts occur at the right place. */ num_insns++; - } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end && + } while (!dc->is_jmp && !tcg_op_buf_full() && !cs->singlestep_enabled && !singlestep && !dc->ss_active &&
@@ -11101,7 +11098,7 @@ done_generating: }#endif if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-arm/translate.c +3 -6
@@ -10999,7 +10999,6 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu,CPUARMState *env = &cpu->env;DisasContext dc1, *dc = &dc1;CPUBreakpoint *bp; -uint16_t *gen_opc_end;int j, lj;target_ulong pc_start;target_ulong next_page_start;
@@ -11020,8 +11019,6 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu, dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->pc = pc_start; dc->singlestep_enabled = cs->singlestep_enabled;
@@ -11155,7 +11152,7 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu, } }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -11221,7 +11218,7 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu,* Also stop translation when a page boundary is reached. This * ensures prefetch aborts occur at the right place. */ num_insns ++; - } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end && + } while (!dc->is_jmp && !tcg_op_buf_full() && !cs->singlestep_enabled && !singlestep && !dc->ss_active &&
@@ -11341,7 +11338,7 @@ done_generating: }#endif if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-cris/translate.c +5 -8
@@ -3116,7 +3116,6 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb, {CPUState *cs =CPU (cpu);CPUCRISState *env = &cpu->env; -uint16_t *gen_opc_end;uint32_t pc_start;unsigned int insn_len;int j, lj;
@@ -3142,8 +3141,6 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb, dc->cpu = cpu; dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->ppc = pc_start; dc->pc = pc_start;
@@ -3207,7 +3204,7 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb,check_breakpoint (env, dc);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -3291,7 +3288,7 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb,break ; } }while (!dc->is_jmp && !dc->cpustate_changed - && tcg_ctx.gen_opc_ptr < gen_opc_end + && !tcg_op_buf_full () && !singlestep && (dc->pc < next_page_start) && num_insns < max_insns);
@@ -3346,7 +3343,7 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
@@ -3361,8 +3358,8 @@ gen_intermediate_code_internal(CRISCPU *cpu, TranslationBlock *tb,if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {log_target_disas (env, pc_start, dc->pc - pc_start, env->pregs[PR_VR ]); -qemu_log ("\nisize=%d osize=%td\n" , - dc->pc - pc_start, tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf); +qemu_log ("\nisize=%d osize=%d\n" , + dc->pc - pc_start,tcg_op_buf_count ()); }#endif #endif
target-i386/translate.c +3 -6
@@ -7913,7 +7913,6 @@ static inline void gen_intermediate_code_internal(X86CPU *cpu,CPUX86State *env = &cpu->env;DisasContext dc1, *dc = &dc1;target_ulong pc_ptr; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj;uint64_t flags;
@@ -7993,8 +7992,6 @@ static inline void gen_intermediate_code_internal(X86CPU *cpu, cpu_ptr1 =tcg_temp_new_ptr (); cpu_cc_srcT =tcg_temp_local_new (); - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; pc_ptr = pc_start; lj =-1 ;
@@ -8015,7 +8012,7 @@ static inline void gen_intermediate_code_internal(X86CPU *cpu, } }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -8060,7 +8057,7 @@ static inline void gen_intermediate_code_internal(X86CPU *cpu,break ; }/* if too long translation, stop generation too */ -if (tcg_ctx.gen_opc_ptr >= gen_opc_end || +if (tcg_op_buf_full () || (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE -32 ) || num_insns >= max_insns) {gen_jmp_im (pc_ptr - dc->cs_base);
@@ -8080,7 +8077,7 @@ done_generating:/* we don't forget to fill the last values */ if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-lm32/translate.c +5 -9
@@ -1062,7 +1062,6 @@ void gen_intermediate_code_internal(LM32CPU *cpu,CPUState *cs =CPU (cpu);CPULM32State *env = &cpu->env;struct DisasContext ctx, *dc = &ctx; -uint16_t *gen_opc_end;uint32_t pc_start;int j, lj;uint32_t next_page_start;
@@ -1075,8 +1074,6 @@ void gen_intermediate_code_internal(LM32CPU *cpu, dc->num_watchpoints = cpu->num_watchpoints; dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->pc = pc_start; dc->singlestep_enabled = cs->singlestep_enabled;
@@ -1100,7 +1097,7 @@ void gen_intermediate_code_internal(LM32CPU *cpu,check_breakpoint (env, dc);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -1124,7 +1121,7 @@ void gen_intermediate_code_internal(LM32CPU *cpu, num_insns++; }while (!dc->is_jmp - && tcg_ctx.gen_opc_ptr < gen_opc_end + && !tcg_op_buf_full () && !cs->singlestep_enabled && !singlestep && (dc->pc < next_page_start)
@@ -1160,7 +1157,7 @@ void gen_intermediate_code_internal(LM32CPU *cpu,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
@@ -1174,9 +1171,8 @@ void gen_intermediate_code_internal(LM32CPU *cpu,if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {qemu_log ("\n" );log_target_disas (env, pc_start, dc->pc - pc_start,0 ); -qemu_log ("\nisize=%d osize=%td\n" , - dc->pc - pc_start, tcg_ctx.gen_opc_ptr - - tcg_ctx.gen_opc_buf); +qemu_log ("\nisize=%d osize=%d\n" , + dc->pc - pc_start,tcg_op_buf_count ()); }#endif }
target-m68k/translate.c +3 -6
@@ -2980,7 +2980,6 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb,CPUState *cs =CPU (cpu);CPUM68KState *env = &cpu->env;DisasContext dc1, *dc = &dc1; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj;target_ulong pc_start;
@@ -2993,8 +2992,6 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb, dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->env = env; dc->is_jmp =DISAS_NEXT ; dc->pc = pc_start;
@@ -3026,7 +3023,7 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb,break ; }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -3041,7 +3038,7 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb, dc->insn_pc = dc->pc;disas_m68k_insn (env, dc); num_insns++; - } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end && + } while (!dc->is_jmp && !tcg_op_buf_full() && !cs->singlestep_enabled && !singlestep && (pc_offset) < (TARGET_PAGE_SIZE - 32) &&
@@ -3085,7 +3082,7 @@ gen_intermediate_code_internal(M68kCPU *cpu, TranslationBlock *tb, }#endif if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-microblaze/translate.c +8 -12
@@ -1673,7 +1673,6 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb, {CPUState *cs =CPU (cpu);CPUMBState *env = &cpu->env; -uint16_t *gen_opc_end;uint32_t pc_start;int j, lj;struct DisasContext ctx;
@@ -1688,8 +1687,6 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb, dc->tb = tb; org_flags = dc->synced_flags = dc->tb_flags = tb->flags; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->jmp =0 ; dc->delayed_branch = !!(dc->tb_flags &D_FLAG );
@@ -1732,7 +1729,7 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb,check_breakpoint (env, dc);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -1795,10 +1792,10 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb,break ; } }while (!dc->is_jmp && !dc->cpustate_changed - && tcg_ctx.gen_opc_ptr < gen_opc_end - && !singlestep - && (dc->pc < next_page_start) - && num_insns < max_insns); + && !tcg_op_buf_full () + && !singlestep + && (dc->pc < next_page_start) + && num_insns < max_insns); npc = dc->pc;if (dc->jmp ==JMP_DIRECT || dc->jmp ==JMP_DIRECT_CC ) {
@@ -1848,7 +1845,7 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
@@ -1864,9 +1861,8 @@ gen_intermediate_code_internal(MicroBlazeCPU *cpu, TranslationBlock *tb,#if DISAS_GNU log_target_disas (env, pc_start, dc->pc - pc_start,0 );#endif -qemu_log ("\nisize=%d osize=%td\n" , - dc->pc - pc_start, tcg_ctx.gen_opc_ptr - - tcg_ctx.gen_opc_buf); +qemu_log ("\nisize=%d osize=%d\n" , + dc->pc - pc_start,tcg_op_buf_count ()); }#endif #endif
target-mips/translate.c +3 -5
@@ -19091,7 +19091,6 @@ gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb,CPUMIPSState *env = &cpu->env;DisasContext ctx;target_ulong pc_start; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj =-1 ;int num_insns;
@@ -19103,7 +19102,6 @@ gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb,qemu_log ("search pc %d\n" , search_pc); pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.pc = pc_start; ctx.saved_pc =-1 ; ctx.singlestep_enabled = cs->singlestep_enabled;
@@ -19147,7 +19145,7 @@ gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb, }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -19205,7 +19203,7 @@ gen_intermediate_code_internal(MIPSCPU *cpu, TranslationBlock *tb,if ((ctx.pc & (TARGET_PAGE_SIZE -1 )) ==0 )break ; -if (tcg_ctx.gen_opc_ptr >= gen_opc_end) { +if (tcg_op_buf_full ()) {break ; }
@@ -19242,7 +19240,7 @@ done_generating:gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-moxie/translate.c +3 -5
@@ -827,14 +827,12 @@ gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb,CPUState *cs =CPU (cpu);DisasContext ctx;target_ulong pc_start; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj =-1 ;CPUMoxieState *env = &cpu->env;int num_insns; pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.pc = pc_start; ctx.saved_pc =-1 ; ctx.tb = tb;
@@ -857,7 +855,7 @@ gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb, }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -879,7 +877,7 @@ gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb,if ((ctx.pc & (TARGET_PAGE_SIZE -1 )) ==0 ) {break ; } - }while (ctx.bstate ==BS_NONE && tcg_ctx.gen_opc_ptr < gen_opc_end); + }while (ctx.bstate ==BS_NONE && !tcg_op_buf_full ());if (cs->singlestep_enabled) {tcg_gen_movi_tl (cpu_pc, ctx.pc);
@@ -902,7 +900,7 @@ gen_intermediate_code_internal(MoxieCPU *cpu, TranslationBlock *tb,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-openrisc/translate.c +5 -8
@@ -1642,7 +1642,6 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu, {CPUState *cs =CPU (cpu);struct DisasContext ctx, *dc = &ctx; -uint16_t *gen_opc_end;uint32_t pc_start;int j, k;uint32_t next_page_start;
@@ -1652,7 +1651,6 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu, pc_start = tb->pc; dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; dc->is_jmp =DISAS_NEXT ; dc->ppc = pc_start; dc->pc = pc_start;
@@ -1680,7 +1678,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu, do { check_breakpoint(cpu, dc); if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j = tcg_op_buf_count(); if (k < j) { k++; while (k < j) {
@@ -1721,7 +1719,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu, } } }while (!dc->is_jmp - && tcg_ctx.gen_opc_ptr < gen_opc_end + && !tcg_op_buf_full () && !cs->singlestep_enabled && !singlestep && (dc->pc < next_page_start)
@@ -1761,7 +1759,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); k++;while (k <= j) { tcg_ctx.gen_opc_instr_start[k++] =0 ;
@@ -1775,9 +1773,8 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,if (qemu_loglevel_mask (CPU_LOG_TB_IN_ASM )) {qemu_log ("\n" );log_target_disas (&cpu->env, pc_start, dc->pc - pc_start,0 ); -qemu_log ("\nisize=%d osize=%td\n" , - dc->pc - pc_start, tcg_ctx.gen_opc_ptr - - tcg_ctx.gen_opc_buf); +qemu_log ("\nisize=%d osize=%d\n" , + dc->pc - pc_start,tcg_op_buf_count ()); }#endif }
target-ppc/translate.c +3 -6
@@ -11415,14 +11415,12 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,DisasContext ctx, *ctxp = &ctx;opc_handler_t **table, *handler;target_ulong pc_start; -uint16_t *gen_opc_end;CPUBreakpoint *bp;int j, lj =-1 ;int num_insns;int max_insns; pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.nip = pc_start; ctx.tb = tb; ctx.exception =POWERPC_EXCP_NONE ;
@@ -11481,8 +11479,7 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,gen_tb_start (tb);tcg_clear_temp_count ();/* Set env in case of segfault during code fetch */ -while (ctx.exception ==POWERPC_EXCP_NONE - && tcg_ctx.gen_opc_ptr < gen_opc_end) { +while (ctx.exception ==POWERPC_EXCP_NONE && !tcg_op_buf_full ()) {if (unlikely (!QTAILQ_EMPTY (&cs->breakpoints))) { QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {if (bp->pc == ctx.nip) {
@@ -11492,7 +11489,7 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu, } }if (unlikely (search_pc)) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -11600,7 +11597,7 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,gen_tb_end (tb, num_insns);if (unlikely (search_pc)) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-s390x/translate.c +3 -6
@@ -4750,7 +4750,6 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu,DisasContext dc;target_ulong pc_start;uint64_t next_page_start; -uint16_t *gen_opc_end;int j, lj =-1 ;int num_insns, max_insns;CPUBreakpoint *bp;
@@ -4769,8 +4768,6 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu, dc.cc_op =CC_OP_DYNAMIC ; do_debug = dc.singlestep_enabled = cs->singlestep_enabled; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - next_page_start = (pc_start &TARGET_PAGE_MASK ) +TARGET_PAGE_SIZE ; num_insns =0 ;
@@ -4783,7 +4780,7 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu, do { if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j = tcg_op_buf_count(); if (lj < j) { lj++; while (lj < j) {
@@ -4821,7 +4818,7 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu,or exhaust instruction count, stop generation. */ if (status ==NO_EXIT && (dc.pc >= next_page_start - || tcg_ctx.gen_opc_ptr >= gen_opc_end + ||tcg_op_buf_full () || num_insns >= max_insns || singlestep || cs->singlestep_enabled)) {
@@ -4858,7 +4855,7 @@ static inline void gen_intermediate_code_internal(S390CPU *cpu,gen_tb_end (tb, num_insns);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-sh4/translate.c +3 -5
@@ -1865,14 +1865,12 @@ gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb,CPUSH4State *env = &cpu->env;DisasContext ctx;target_ulong pc_start; -static uint16_t *gen_opc_end;CPUBreakpoint *bp;int i, ii;int num_insns;int max_insns; pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.pc = pc_start; ctx.flags = (uint32_t )tb->flags; ctx.bstate =BS_NONE ;
@@ -1891,7 +1889,7 @@ gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb,if (max_insns ==0 ) max_insns =CF_COUNT_MASK ;gen_tb_start (tb); -while (ctx.bstate ==BS_NONE && tcg_ctx.gen_opc_ptr < gen_opc_end) { +while (ctx.bstate ==BS_NONE && !tcg_op_buf_full ()) {if (unlikely (!QTAILQ_EMPTY (&cs->breakpoints))) { QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {if (ctx.pc == bp->pc) {
@@ -1904,7 +1902,7 @@ gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb, } }if (search_pc) { - i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + i =tcg_op_buf_count ();if (ii < i) { ii++;while (ii < i)
@@ -1964,7 +1962,7 @@ gen_intermediate_code_internal(SuperHCPU *cpu, TranslationBlock *tb,gen_tb_end (tb, num_insns);if (search_pc) { - i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + i =tcg_op_buf_count (); ii++;while (ii <= i) tcg_ctx.gen_opc_instr_start[ii++] =0 ;
target-sparc/translate.c +3 -5
@@ -5223,7 +5223,6 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu,CPUState *cs =CPU (cpu);CPUSPARCState *env = &cpu->env;target_ulong pc_start, last_pc; -uint16_t *gen_opc_end;DisasContext dc1, *dc = &dc1;CPUBreakpoint *bp;int j, lj =-1 ;
@@ -5243,7 +5242,6 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu, dc->fpu_enabled =tb_fpu_enabled (tb->flags); dc->address_mask_32bit =tb_am_enabled (tb->flags); dc->singlestep = (cs->singlestep_enabled || singlestep); - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; num_insns =0 ; max_insns = tb->cflags &CF_COUNT_MASK ;
@@ -5265,7 +5263,7 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu, }if (spc) {qemu_log ("Search PC...\n" ); - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j)
@@ -5298,7 +5296,7 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu,if (dc->singlestep) {break ; } - }while ((tcg_ctx.gen_opc_ptr < gen_opc_end) && + }while (!tcg_op_buf_full () && (dc->pc - pc_start) < (TARGET_PAGE_SIZE -32 ) && num_insns < max_insns);
@@ -5322,7 +5320,7 @@ static inline void gen_intermediate_code_internal(SPARCCPU *cpu,gen_tb_end (tb, num_insns);if (spc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-tricore/translate.c +1 -3
@@ -5500,7 +5500,6 @@ gen_intermediate_code_internal(TriCoreCPU *cpu, struct TranslationBlock *tb,DisasContext ctx;target_ulong pc_start;int num_insns; -uint16_t *gen_opc_end;if (search_pc) {qemu_log ("search pc %d\n" , search_pc);
@@ -5508,7 +5507,6 @@ gen_intermediate_code_internal(TriCoreCPU *cpu, struct TranslationBlock *tb, num_insns =0 ; pc_start = tb->pc; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; ctx.pc = pc_start; ctx.saved_pc =-1 ; ctx.tb = tb;
@@ -5524,7 +5522,7 @@ gen_intermediate_code_internal(TriCoreCPU *cpu, struct TranslationBlock *tb, num_insns++; -if (tcg_ctx.gen_opc_ptr >= gen_opc_end) { +if (tcg_op_buf_full ()) {gen_save_pc (ctx.next_pc);tcg_gen_exit_tb (0 );break ;
target-unicore32/translate.c +3 -6
@@ -1877,7 +1877,6 @@ static inline void gen_intermediate_code_internal(UniCore32CPU *cpu,CPUUniCore32State *env = &cpu->env;DisasContext dc1, *dc = &dc1;CPUBreakpoint *bp; -uint16_t *gen_opc_end;int j, lj;target_ulong pc_start;uint32_t next_page_start;
@@ -1891,8 +1890,6 @@ static inline void gen_intermediate_code_internal(UniCore32CPU *cpu, dc->tb = tb; - gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ; - dc->is_jmp =DISAS_NEXT ; dc->pc = pc_start; dc->singlestep_enabled = cs->singlestep_enabled;
@@ -1933,7 +1930,7 @@ static inline void gen_intermediate_code_internal(UniCore32CPU *cpu, } }if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -1965,7 +1962,7 @@ static inline void gen_intermediate_code_internal(UniCore32CPU *cpu,* Also stop translation when a page boundary is reached. This * ensures prefetch aborts occur at the right place. */ num_insns++; - } while (!dc->is_jmp && tcg_ctx.gen_opc_ptr < gen_opc_end && + } while (!dc->is_jmp && !tcg_op_buf_full() && !cs->singlestep_enabled && !singlestep && dc->pc < next_page_start &&
@@ -2047,7 +2044,7 @@ done_generating: }#endif if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count (); lj++;while (lj <= j) { tcg_ctx.gen_opc_instr_start[lj++] =0 ;
target-xtensa/translate.c +3 -4
@@ -3021,7 +3021,6 @@ void gen_intermediate_code_internal(XtensaCPU *cpu,DisasContext dc;int insn_count =0 ;int j, lj =-1 ; -uint16_t *gen_opc_end = tcg_ctx.gen_opc_buf +OPC_MAX_SIZE ;int max_insns = tb->cflags &CF_COUNT_MASK ;uint32_t pc_start = tb->pc; uint32_t next_page_start =
@@ -3065,7 +3064,7 @@ void gen_intermediate_code_internal(XtensaCPU *cpu,check_breakpoint (env, &dc);if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();if (lj < j) { lj++;while (lj < j) {
@@ -3117,7 +3116,7 @@ void gen_intermediate_code_internal(XtensaCPU *cpu, insn_count < max_insns && dc.pc < next_page_start && dc.pc +xtensa_insn_len (env, &dc) <= next_page_start && - tcg_ctx.gen_opc_ptr < gen_opc_end); + !tcg_op_buf_full());reset_litbase (&dc);reset_sar_tracker (&dc);
@@ -3143,7 +3142,7 @@ void gen_intermediate_code_internal(XtensaCPU *cpu, }#endif if (search_pc) { - j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; + j =tcg_op_buf_count ();memset (tcg_ctx.gen_opc_instr_start + lj +1 ,0 , (j - lj) *sizeof (tcg_ctx.gen_opc_instr_start[0 ])); }else {
tcg/tcg.h +12 -0
@@ -537,6 +537,18 @@ struct TCGContext {extern TCGContext tcg_ctx; +/* The number of opcodes emitted so far. */ +static inline int tcg_op_buf_count (void ) +{ +return tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; +} + +/* Test for whether to terminate the TB for using too many opcodes. */ +static inline bool tcg_op_buf_full (void ) +{ +return tcg_op_buf_count () >=OPC_MAX_SIZE ; +} +/* pool based memory allocation */ void *tcg_malloc_internal (TCGContext *s,int size);
Signature · 1 line
2.1.0
PATCH v3 5/8 tcg: Put opcodes in a linked list
In reply to Richard HendersonThe previous setup required ops and args to be completely sequential, and was error prone when it came to both iteration and optimization.
--- include/exec/gen-icount.h | 22 ++- tcg/optimize.c | 286 ++++++++++++++--------------------- tcg/tcg-op.c | 190 ++++++++++++----------- tcg/tcg.c | 376 +++++++++++++++++++--------------------------- tcg/tcg.h | 58 ++++--- 5 files changed, 431 insertions(+), 501 deletions(-)
include/exec/gen-icount.h +16 -6
@@ -11,8 +11,8 @@ static int exitreq_label;static inline void gen_tb_start (TranslationBlock *tb) { -TCGv_i32 count; -TCGv_i32 flag; +TCGv_i32 count, flag, imm; +int i; exitreq_label =gen_new_label (); flag =tcg_temp_new_i32 ();
@@ -21,16 +21,25 @@ static inline void gen_tb_start(TranslationBlock *tb)tcg_gen_brcondi_i32 (TCG_COND_NE , flag,0 , exitreq_label);tcg_temp_free_i32 (flag); -if (!(tb->cflags &CF_USE_ICOUNT )) +if (!(tb->cflags &CF_USE_ICOUNT )) {return ; + } icount_label =gen_new_label (); count =tcg_temp_local_new_i32 ();tcg_gen_ld_i32 (count, cpu_env, -ENV_OFFSET + offsetof(CPUState, icount_decr.u32)); + + imm =tcg_temp_new_i32 (); +tcg_gen_movi_i32 (imm,0xdeadbeef ); +/* This is a horrid hack to allow fixing up the value later. */ - icount_arg = tcg_ctx.gen_opparam_ptr +1 ; -tcg_gen_subi_i32 (count, count,0xdeadbeef ); + i = tcg_ctx.gen_last_op_idx; + i = tcg_ctx.gen_op_buf[i].args; + icount_arg = &tcg_ctx.gen_opparam_buf[i +1 ]; + +tcg_gen_sub_i32 (count, count, imm); +tcg_temp_free_i32 (imm);tcg_gen_brcondi_i32 (TCG_COND_LT , count,0 , icount_label); tcg_gen_st16_i32(count, cpu_env,
@@ -49,7 +58,8 @@ static void gen_tb_end(TranslationBlock *tb, int num_insns)tcg_gen_exit_tb ((uintptr_t )tb +TB_EXIT_ICOUNT_EXPIRED ); } - *tcg_ctx.gen_opc_ptr = INDEX_op_end; +/* Terminate the linked list. */ + tcg_ctx.gen_op_buf[tcg_ctx.gen_last_op_idx].next =-1 ; }static inline void gen_io_start (void )
tcg/optimize.c +116 -170
598 lines not on this page · raw message
tcg/tcg-op.c +101 -89
279 lines not on this page · raw message
tcg/tcg.c +157 -219
712 lines not on this page · raw message
tcg/tcg.h +41 -17
103 lines not on this page · raw message
Signature · 1 line
2.1.0
Re: [Qemu-devel] [PATCH v3 5/8] tcg: Put opcodes in a linked list
Quoted 12 lines · Richard Henderson
The previous setup required ops and args to be completely sequential, and was error prone when it came to both iteration and optimization.
Signed-off-by Richard Henderson <[email protected]>--- include/exec/gen-icount.h | 22 ++- tcg/optimize.c | 286 ++++++++++++++--------------------- tcg/tcg-op.c | 190 ++++++++++++----------- tcg/tcg.c | 376 +++++++++++++++++++--------------------------- tcg/tcg.h | 58 ++++--- 5 files changed, 431 insertions(+), 501 deletions(-)
PATCH v3 6/8 tcg: Remove opcodes instead of noping them out
In reply to Richard HendersonWith the linked list scheme we need not leave nops in the stream that we need to process later.
--- tcg/optimize.c | 14 +++++++------- tcg/tcg.c | 28 ++++++++++++++++++++++++---- tcg/tcg.h | 1 + 3 files changed, 32 insertions(+), 11 deletions(-)
tcg/optimize.c +7 -7
@@ -758,7 +758,7 @@ static void tcg_constant_folding(TCGContext *s)break ; do_mov3:if (temps_are_copies (args[0 ], args[1 ])) { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); }else {tcg_opt_gen_mov (s, op, args, opc, args[0 ], args[1 ]); }
@@ -916,7 +916,7 @@ static void tcg_constant_folding(TCGContext *s)if (affected ==0 ) {assert (nb_oargs ==1 );if (temps_are_copies (args[0 ], args[1 ])) { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); }else if (temps[args[1 ]].state !=TCG_TEMP_CONST ) {tcg_opt_gen_mov (s, op, args, opc, args[0 ], args[1 ]); }else {
@@ -948,7 +948,7 @@ static void tcg_constant_folding(TCGContext *s) CASE_OP_32_64(and): if (temps_are_copies(args[1], args[2])) {if (temps_are_copies (args[0 ], args[1 ])) { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); }else {tcg_opt_gen_mov (s, op, args, opc, args[0 ], args[1 ]); }
@@ -979,7 +979,7 @@ static void tcg_constant_folding(TCGContext *s)switch (opc) { CASE_OP_32_64(mov): if (temps_are_copies(args[0], args[1])) { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op);break ; }if (temps[args[1 ]].state !=TCG_TEMP_CONST ) {
@@ -1074,7 +1074,7 @@ static void tcg_constant_folding(TCGContext *s) op->opc = INDEX_op_br; args[0 ] = args[3 ]; }else { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); }break ; }
@@ -1084,7 +1084,7 @@ static void tcg_constant_folding(TCGContext *s) tmp =do_constant_folding_cond (opc, args[1 ], args[2 ], args[5 ]);if (tmp !=2 ) {if (temps_are_copies (args[0 ], args[4 -tmp])) { - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); }else if (temps[args[4 -tmp]].state ==TCG_TEMP_CONST ) {tcg_opt_gen_movi (s, op, args, opc, args[0 ], temps[args[4 -tmp]].val);
@@ -1177,7 +1177,7 @@ static void tcg_constant_folding(TCGContext *s) args[0 ] = args[5 ]; }else { do_brcond_false: - op->opc = INDEX_op_nop; +tcg_op_remove (s, op); } }else if ((args[4 ] ==TCG_COND_LT || args[4 ] ==TCG_COND_GE ) && temps[args[2]].state == TCG_TEMP_CONST
tcg/tcg.c +24 -4
@@ -1244,6 +1244,29 @@ void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs)#endif } +void tcg_op_remove (TCGContext *s,TCGOp *op) +{ +int next = op->next; +int prev = op->prev; + +if (next >=0 ) { + s->gen_op_buf[next].prev = prev; + }else { + s->gen_last_op_idx = prev; + } +if (prev >=0 ) { + s->gen_op_buf[prev].next = next; + }else { + s->gen_first_op_idx = next; + } + + *op = (TCGOp ){ .opc = INDEX_op_nop, .next =-1 , .prev =-1 }; + +#ifdef CONFIG_PROFILER + s->del_op_count++; +#endif +} +#ifdef USE_LIVENESS_ANALYSIS /* liveness analysis: end of function: all temps are dead, and globals should be in memory. */
@@ -1466,10 +1489,7 @@ static void tcg_liveness_analysis(TCGContext *s) } } do_remove: - op->opc = INDEX_op_nop; -#ifdef CONFIG_PROFILER - s->del_op_count++; -#endif +tcg_op_remove (s, op); }else { do_not_remove:/* output args are dead */
tcg/tcg.h +1 -0
@@ -743,6 +743,7 @@ void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs);void tcg_gen_callN (TCGContext *s,void *func,TCGArg ret,int nargs,TCGArg *args); +void tcg_op_remove (TCGContext *s,TCGOp *op);void tcg_optimize (TCGContext *s);/* only used for debugging purposes */
Signature · 1 line
2.1.0
PATCH v3 7/8 tcg: Implement insert_op_before
In reply to Richard HendersonRather reserving space in the op stream for optimization, let the optimizer add ops as necessary.
--- tcg/optimize.c | 57 +++++++++++++++++++++++++++++++++++---------------------- tcg/tcg-op.c | 21 --------------------- tcg/tcg-op.h | 1 - 3 files changed, 35 insertions(+), 44 deletions(-)
tcg/optimize.c +35 -22
@@ -67,6 +67,37 @@ static void reset_temp(TCGArg temp) temps[temp].mask =-1 ; } +static TCGOp *insert_op_before (TCGContext *s,TCGOp *old_op, +TCGOpcode opc,int nargs) +{ +int oi = s->gen_next_op_idx; +int pi = s->gen_next_parm_idx; +int prev = old_op->prev; +int next = old_op - s->gen_op_buf; +TCGOp *new_op; + +tcg_debug_assert (oi <OPC_BUF_SIZE ); +tcg_debug_assert (pi + nargs <=OPPARAM_BUF_SIZE ); + s->gen_next_op_idx = oi +1 ; + s->gen_next_parm_idx = pi + nargs; + + new_op = &s->gen_op_buf[oi]; + *new_op = (TCGOp ){ + .opc = opc, + .args = pi, + .prev = prev, + .next = next + }; +if (prev >=0 ) { + s->gen_op_buf[prev].next = oi; + }else { + s->gen_first_op_idx = oi; + } + old_op->prev = oi; + +return new_op; +} +/* Reset all temporaries, given that there are NB_TEMPS of them. */ static void reset_all_temps (int nb_temps) {
@@ -1108,8 +1139,8 @@ static void tcg_constant_folding(TCGContext *s)uint64_t a = ((uint64_t )ah <<32 ) | al;uint64_t b = ((uint64_t )bh <<32 ) | bl;TCGArg rl, rh; -TCGOp *op2; -TCGArg *args2; +TCGOp *op2 =insert_op_before (s, op, INDEX_op_movi_i32,2 ); +TCGArg *args2 = &s->gen_opparam_buf[op2->args];if (opc == INDEX_op_add2_i32) { a += b;
@@ -1117,15 +1148,6 @@ static void tcg_constant_folding(TCGContext *s) a -= b; } -/* We emit the extra nop when we emit the add2/sub2. */ - op2 = &s->gen_op_buf[oi_next]; -assert (op2->opc == INDEX_op_nop); - -/* But we still have to allocate args for the op. */ - op2->args = s->gen_next_parm_idx; - s->gen_next_parm_idx +=2 ; - args2 = &s->gen_opparam_buf[op2->args]; - rl = args[0 ]; rh = args[1 ];tcg_opt_gen_movi (s, op, args, opc, rl, (uint32_t )a);
@@ -1144,17 +1166,8 @@ static void tcg_constant_folding(TCGContext *s)uint32_t b = temps[args[3 ]].val;uint64_t r = (uint64_t )a * b;TCGArg rl, rh; -TCGOp *op2; -TCGArg *args2; - -/* We emit the extra nop when we emit the mulu2. */ - op2 = &s->gen_op_buf[oi_next]; -assert (op2->opc == INDEX_op_nop); - -/* But we still have to allocate args for the op. */ - op2->args = s->gen_next_parm_idx; - s->gen_next_parm_idx +=2 ; - args2 = &s->gen_opparam_buf[op2->args]; +TCGOp *op2 =insert_op_before (s, op, INDEX_op_movi_i32,2 ); +TCGArg *args2 = &s->gen_opparam_buf[op2->args]; rl = args[0 ]; rh = args[1 ];
tcg/tcg-op.c +0 -21
@@ -57,11 +57,6 @@ static void tcg_emit_op(TCGContext *ctx, TCGOpcode opc, int args) }; } -void tcg_gen_op0 (TCGContext *ctx,TCGOpcode opc) -{ -tcg_emit_op (ctx, opc,-1 ); -} -void tcg_gen_op1 (TCGContext *ctx,TCGOpcode opc,TCGArg a1) {int pi = ctx->gen_next_parm_idx;
@@ -571,8 +566,6 @@ void tcg_gen_add2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al, {if (TCG_TARGET_HAS_add2_i32) {tcg_gen_op6_i32 (INDEX_op_add2_i32, rl, rh, al, ah, bl, bh); -/* Allow the optimizer room to replace add2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();TCGv_i64 t1 =tcg_temp_new_i64 ();
@@ -590,8 +583,6 @@ void tcg_gen_sub2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al, {if (TCG_TARGET_HAS_sub2_i32) {tcg_gen_op6_i32 (INDEX_op_sub2_i32, rl, rh, al, ah, bl, bh); -/* Allow the optimizer room to replace sub2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();TCGv_i64 t1 =tcg_temp_new_i64 ();
@@ -608,8 +599,6 @@ void tcg_gen_mulu2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 arg1, TCGv_i32 arg2) {if (TCG_TARGET_HAS_mulu2_i32) {tcg_gen_op4_i32 (INDEX_op_mulu2_i32, rl, rh, arg1, arg2); -/* Allow the optimizer room to replace mulu2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else if (TCG_TARGET_HAS_muluh_i32) {TCGv_i32 t =tcg_temp_new_i32 ();tcg_gen_op3_i32 (INDEX_op_mul_i32, t, arg1, arg2);
@@ -632,8 +621,6 @@ void tcg_gen_muls2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 arg1, TCGv_i32 arg2) {if (TCG_TARGET_HAS_muls2_i32) {tcg_gen_op4_i32 (INDEX_op_muls2_i32, rl, rh, arg1, arg2); -/* Allow the optimizer room to replace muls2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else if (TCG_TARGET_HAS_mulsh_i32) {TCGv_i32 t =tcg_temp_new_i32 ();tcg_gen_op3_i32 (INDEX_op_mul_i32, t, arg1, arg2);
@@ -1648,8 +1635,6 @@ void tcg_gen_add2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al, {if (TCG_TARGET_HAS_add2_i64) {tcg_gen_op6_i64 (INDEX_op_add2_i64, rl, rh, al, ah, bl, bh); -/* Allow the optimizer room to replace add2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();TCGv_i64 t1 =tcg_temp_new_i64 ();
@@ -1668,8 +1653,6 @@ void tcg_gen_sub2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 al, {if (TCG_TARGET_HAS_sub2_i64) {tcg_gen_op6_i64 (INDEX_op_sub2_i64, rl, rh, al, ah, bl, bh); -/* Allow the optimizer room to replace sub2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else {TCGv_i64 t0 =tcg_temp_new_i64 ();TCGv_i64 t1 =tcg_temp_new_i64 ();
@@ -1687,8 +1670,6 @@ void tcg_gen_mulu2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2) {if (TCG_TARGET_HAS_mulu2_i64) {tcg_gen_op4_i64 (INDEX_op_mulu2_i64, rl, rh, arg1, arg2); -/* Allow the optimizer room to replace mulu2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else if (TCG_TARGET_HAS_muluh_i64) {TCGv_i64 t =tcg_temp_new_i64 ();tcg_gen_op3_i64 (INDEX_op_mul_i64, t, arg1, arg2);
@@ -1708,8 +1689,6 @@ void tcg_gen_muls2_i64(TCGv_i64 rl, TCGv_i64 rh, TCGv_i64 arg1, TCGv_i64 arg2) {if (TCG_TARGET_HAS_muls2_i64) {tcg_gen_op4_i64 (INDEX_op_muls2_i64, rl, rh, arg1, arg2); -/* Allow the optimizer room to replace muls2 with two moves. */ -tcg_gen_op0 (&tcg_ctx, INDEX_op_nop); }else if (TCG_TARGET_HAS_mulsh_i64) {TCGv_i64 t =tcg_temp_new_i64 ();tcg_gen_op3_i64 (INDEX_op_mul_i64, t, arg1, arg2);
tcg/tcg-op.h +0 -1
@@ -28,7 +28,6 @@/* Basic output routines. Not for general consumption. */ -void tcg_gen_op0 (TCGContext *,TCGOpcode );void tcg_gen_op1 (TCGContext *,TCGOpcode ,TCGArg );void tcg_gen_op2 (TCGContext *,TCGOpcode ,TCGArg ,TCGArg );void tcg_gen_op3 (TCGContext *,TCGOpcode ,TCGArg ,TCGArg ,TCGArg );
Signature · 1 line
2.1.0
Re: [Qemu-devel] [PATCH v3 7/8] tcg: Implement insert_op_before
Quoted 11 lines · Richard Henderson
Rather reserving space in the op stream for optimization, let the optimizer add ops as necessary.
Signed-off-by Richard Henderson <[email protected]>--- tcg/optimize.c | 57 +++++++++++++++++++++++++++++++++++---------------------- tcg/tcg-op.c | 21 --------------------- tcg/tcg-op.h | 1 - 3 files changed, 35 insertions(+), 44 deletions(-)
PATCH v3 8/8 tcg: Remove unused opcodes
In reply to Richard HendersonWe no longer need INDEX_op_end to terminate the list, nor do we need 5 forms of nop, since we just remove the TCGOp instead.
--- tcg/tcg-opc.h | 9 --------- tcg/tcg.c | 7 ++----- tci.c | 13 ------------- 3 files changed, 2 insertions(+), 27 deletions(-)
tcg/tcg-opc.h +0 -9
@@ -27,15 +27,6 @@*/ /* predefined ops */ -DEF(end, 0, 0, 0, TCG_OPF_NOT_PRESENT) /* must be kept first */ -DEF(nop, 0, 0, 0, TCG_OPF_NOT_PRESENT) -DEF(nop1, 0, 0, 1, TCG_OPF_NOT_PRESENT) -DEF(nop2, 0, 0, 2, TCG_OPF_NOT_PRESENT) -DEF (nop3,0 ,0 ,3 ,TCG_OPF_NOT_PRESENT ) - -/* variable number of parameters */ -DEF(nopn, 0, 0, 1, TCG_OPF_NOT_PRESENT) - DEF(discard, 1, 0, 0, TCG_OPF_NOT_PRESENT)DEF (set_label,0 ,0 ,1 ,TCG_OPF_BB_END |TCG_OPF_NOT_PRESENT )
tcg/tcg.c +2 -5
@@ -1260,7 +1260,7 @@ void tcg_op_remove(TCGContext *s, TCGOp *op) s->gen_first_op_idx = next; } - *op = (TCGOp ){ .opc = INDEX_op_nop, .next =-1 , .prev =-1 }; +memset (op,-1 ,sizeof (*op));#ifdef CONFIG_PROFILER s->del_op_count++;
@@ -1385,8 +1385,6 @@ static void tcg_liveness_analysis(TCGContext *s) }break ;case INDEX_op_debug_insn_start: -case INDEX_op_nop: -case INDEX_op_end:break ;case INDEX_op_discard:/* mark the temporary as dead */
@@ -2244,7 +2242,7 @@ void tcg_dump_op_count(FILE *f, fprintf_function cpu_fprintf) {int i; -for (i = INDEX_op_end; i <NB_OPS ; i++) { +for (i =0 ; i <NB_OPS ; i++) {cpu_fprintf (f,"%s %" PRId64"\n" , tcg_op_defs[i].name, tcg_table_op_count[i]); }
@@ -2328,7 +2326,6 @@ static inline int tcg_gen_code_common(TCGContext *s,tcg_reg_alloc_movi (s, args, dead_args, sync_args);break ;case INDEX_op_debug_insn_start: -case INDEX_op_nop:break ;case INDEX_op_discard:temp_dead (s, args[0 ]);
tci.c +0 -13
@@ -506,19 +506,6 @@ uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr) tb_ptr +=2 ;switch (opc) { -case INDEX_op_end: -case INDEX_op_nop: -break ; -case INDEX_op_nop1: -case INDEX_op_nop2: -case INDEX_op_nop3: -case INDEX_op_nopn: -case INDEX_op_discard: -TODO (); -break ; -case INDEX_op_set_label: -TODO (); -break ;case INDEX_op_call: t0 =tci_read_ri (&tb_ptr);#if TCG_TARGET_REG_BITS ==32
Signature · 1 line
2.1.0