Linked list for tcg ops
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 functionconsists 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.
Of course this isn't intended for the upcoming 2.2 release.
Comments?
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 | 1941 ++++++++++++++++++++++++++++++++ tcg/tcg-op.h | 2488 ++++++----------------------------------- tcg/tcg-opc.h | 9 - tcg/tcg.c | 535 +++------ tcg/tcg.h | 72 +- tci.c | 13 - 27 files changed, 2761 insertions(+), 2838 deletions(-) create mode 100644 tcg/tcg-op.c
Signature · 1 line
1.9.3
PATCH 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
1.9.3
Part of the diff is not shown here. View the raw message.
Re: [Qemu-devel] [PATCH 2.3 1/8] tcg: Move some opcode generation functions out of line
Quoted 7 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.
Signed-off-by Richard Henderson <[email protected]>
Quoted 10 lines
--- 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
Cheers,
Bastian
PATCH 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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 2/8] tcg: Reduce ifdefs in tcg-op.c
Quoted 7 lines · Richard Henderson
Almost completely eliminates the ifdefs in this file, improving confidence in the lesser used 32-bit builds.
Signed-off-by Richard Henderson <[email protected]>--- tcg/tcg-op.c | 449 +++++++++++++++++++++++++++-------------------------------- 1 file changed, 207 insertions(+), 242 deletions(-)
Cheers,
Bastian
PATCH 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
@@ -11325,7 +11325,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
@@ -3348,7 +3348,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
@@ -8040,7 +8040,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
@@ -19133,7 +19133,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
@@ -11449,7 +11449,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
@@ -5342,7 +5342,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
@@ -2468,7 +2468,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
@@ -3097,7 +3097,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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 3/8] tcg: Move emit of INDEX_op_end into gen_tb_end
Quoted 14 lines · Richard Henderson
Signed-off-by Richard Henderson <[email protected]>--- 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 +-
Quoted 8 lines
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(-)
I'm quiete happy with that change, since this was really confusing, if you were writing a guest, that uses the tcg-fronted.
Cheers,
Bastian
PATCH 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
@@ -10995,7 +10995,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;
@@ -11016,8 +11015,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;
@@ -11150,7 +11147,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)
@@ -11216,7 +11213,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 &&
@@ -11336,7 +11333,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
@@ -3120,7 +3120,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;
@@ -3146,8 +3145,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;
@@ -3211,7 +3208,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) {
@@ -3295,7 +3292,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);
@@ -3350,7 +3347,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 ;
@@ -3365,8 +3362,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
@@ -7901,7 +7901,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;
@@ -7970,8 +7969,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 ;
@@ -7992,7 +7989,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)
@@ -8023,7 +8020,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);
@@ -8043,7 +8040,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
@@ -18984,7 +18984,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;
@@ -18996,7 +18995,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;
@@ -19040,7 +19038,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)
@@ -19098,7 +19096,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 ; }
@@ -19135,7 +19133,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
@@ -11273,14 +11273,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 ;
@@ -11332,8 +11330,7 @@ static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,gen_tb_start ();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) {
@@ -11343,7 +11340,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)
@@ -11451,7 +11448,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 (); -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
@@ -5245,7 +5245,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 ;
@@ -5265,7 +5264,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 ;
@@ -5287,7 +5285,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)
@@ -5320,7 +5318,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);
@@ -5344,7 +5342,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
@@ -2430,7 +2430,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);
@@ -2438,7 +2437,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;
@@ -2454,7 +2452,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
@@ -2987,7 +2987,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 =
@@ -3030,7 +3029,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) {
@@ -3081,7 +3080,7 @@ void gen_intermediate_code_internal(XtensaCPU *cpu, }while (dc.is_jmp ==DISAS_NEXT && insn_count < max_insns && dc.pc < next_page_start && - tcg_ctx.gen_opc_ptr < gen_opc_end); + !tcg_op_buf_full ());reset_litbase (&dc);reset_sar_tracker (&dc);
@@ -3107,7 +3106,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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 4/8] tcg: Introduce tcg_op_buf_count and tcg_op_buf_full
Quoted 17 lines · Richard Henderson
The method by which we count the number of ops emitted is going to change. Abstract that away into some inlines.
Signed-off-by Richard Henderson <[email protected]>--- 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 +++------
Quoted 9 lines
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(-)
Again, I'm quiete happy with that change, since these functions make it really clear what is happening.
Cheers,
Bastian
PATCH 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 | 188 ++++++++++++----------- tcg/tcg.c | 376 +++++++++++++++++++--------------------------- tcg/tcg.h | 58 ++++--- 5 files changed, 431 insertions(+), 499 deletions(-)
include/exec/gen-icount.h +16 -6
@@ -11,8 +11,8 @@ static int exitreq_label;static inline void gen_tb_start (void ) { -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(void)tcg_gen_brcondi_i32 (TCG_COND_NE , flag,0 , exitreq_label);tcg_temp_free_i32 (flag); -if (!use_icount) +if (!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 -87
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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 5/8] tcg: Put opcodes in a linked list
Quoted 8 lines · Richard Henderson
tcg/tcg-op.c +8
-0+static void tcg_gen_op_begin (TCGContext *ctx,TCGOpcode opc,int args) +{ +int oi = ctx->gen_next_op_idx; +int ni = oi +1 ; +int pi = oi -1 ; + +tcg_debug_assert (oi <OPC_BUF_SIZE ); + ctx->gen_last_op_idx = oi;
tcg/tcg-op.c extern TCGv_i32 TCGV_HIGH_link_error(TCGv_i64); · line 59
Quoted 10 lines
tcg/tcg-op.c +10
-0+ ctx->gen_next_op_idx = ni; + + ctx->gen_op_buf[oi] = (TCGOp ){ + .opc = opc, + .args = args, + .prev = pi, + .next = ni + }; +} +
The name of this function says begin while used at the end of each tcg_gen_op. How about tcg_gen_op_list_add?
tcg/tcg.h struct TCGContext { · line 515
Quoted 9 lines
tcg/tcg.h +0
-5@@ -508,14 +521,10 @@ struct TCGContext {int goto_tb_issue_mask;#endif -uint16_t gen_opc_buf[OPC_BUF_SIZE ]; -TCGArg gen_opparam_buf[OPPARAM_BUF_SIZE ]; - -uint16_t *gen_opc_ptr; -TCGArg *gen_opparam_ptr;
You forgot to remove gen_opc_ptr in the dummy function tcg_liveness_analysis, in case USE_LIVENESS_ANALYSIS is not defined.
tcg/tcg.h struct TCGContext { · line 528
Quoted 8 lines
tcg/tcg.h +4
-3-target_ulong gen_opc_pc[OPC_BUF_SIZE ]; -uint16_t gen_opc_icount[OPC_BUF_SIZE ]; -uint8_t gen_opc_instr_start[OPC_BUF_SIZE ]; +int gen_first_op_idx; +int gen_last_op_idx; +int gen_next_op_idx; +int gen_next_parm_idx;
Other than that it looks good to me.
Cheers,
Bastian
PATCH 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
@@ -742,6 +742,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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 6/8] tcg: Remove opcodes instead of noping them out
Quoted 11 lines · Richard Henderson
With the linked list scheme we need not leave nops in the stream that we need to process later.
Signed-off-by Richard Henderson <[email protected]>--- tcg/optimize.c | 14 +++++++------- tcg/tcg.c | 28 ++++++++++++++++++++++++---- tcg/tcg.h | 1 + 3 files changed, 32 insertions(+), 11 deletions(-)
PATCH 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 | 16 ---------------- 2 files changed, 35 insertions(+), 38 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 -16
@@ -571,8 +571,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 +588,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 +604,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 +626,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 +1640,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 +1658,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 +1675,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 +1694,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);
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH 2.3 7/8] tcg: Implement insert_op_before
Quoted 18 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 | 16 ---------------- 2 files changed, 35 insertions(+), 38 deletions(-)tcg/optimize.c +1
-0@@ -67,6 +67,37 @@ static void reset_temp(TCGArg temp) temps[temp].mask =-1 ; } +static TCGOp *insert_op_before(TCGContext *s, TCGOp *old_op,
tcg/optimize.c static void reset_temp(TCGArg temp) · line 80
Quoted 10 lines
tcg/optimize.c +10
-0+ 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 );
I thinks it is better to assure these assertion always hold, e.g.
if (oi < OPC_BUF_SIZE || pi + nargs <= OPPARAM_BUF_SIZE) {
return NULL;
}
...
TCGOp *op2 = insert_op_before(s, op, INDEX_op_movi_i32, 2);
if (op2) {
*args2 = &s->gen_opparam_buf[op2->args];
}Or how do we know they always hold?
tcg/tcg-op.c void tcg_gen_add2_i32(TCGv_i32 rl, TCGv_i32 rh, TCGv_i32 al, · line 574
Quoted 11 lines
tcg/tcg-op.c +0
-2@@ -571,8 +571,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);
All references on tcg_gen_op0 are gone, so lets remove it.
Cheers,
Bastian
Re: [Qemu-devel] [PATCH 2.3 7/8] tcg: Implement insert_op_before
Quoted 40 lines · Bastian Koppelmann
Quoted 17 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 | 16 ---------------- 2 files changed, 35 insertions(+), 38 deletions(-)tcg/optimize.c +0
-0@@ -67,6 +67,37 @@ static void reset_temp(TCGArg temp) temps[temp].mask =-1 ; } +static TCGOp *insert_op_before(TCGContext *s, TCGOp *old_op,tcg/optimize.c static void reset_temp(TCGArg temp) · line 79
Quoted 10 lines
tcg/optimize.c +10
-0+ 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 );I thinks it is better to assure these assertion always hold, e.g.
if (oi < OPC_BUF_SIZE || pi + nargs <= OPPARAM_BUF_SIZE) { return NULL; } ... TCGOp *op2 = insert_op_before(s, op, INDEX_op_movi_i32, 2); if (op2) { *args2 = &s->gen_opparam_buf[op2->args]; }
Quoted 1 line
Or how do we know they always hold?
For the same reason we don't bother checking during initial generation of the opcodes. We simply assume there's enough space. Not a good answer but...
Quoted 1 line
All references on
tcg_gen_op0are gone, so lets remove it.
Fair enough.
r~
PATCH 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 | 10 ++++------ tci.c | 13 ------------- 3 files changed, 4 insertions(+), 28 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 +4 -6
@@ -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,8 +2242,9 @@ static void dump_op_count(void) {int i; -for (i = INDEX_op_end; i <NB_OPS ; i++) { -qemu_log ("%s %" PRId64"\n" , tcg_op_defs[i].name, tcg_table_op_count[i]); +for (i =0 ; i <NB_OPS ; i++) { +qemu_log ("%s %" PRId64"\n" , tcg_op_defs[i].name, + tcg_table_op_count[i]); } }#endif
@@ -2322,7 +2321,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
1.9.3
Re: [Qemu-devel] [PATCH 2.3 8/8] tcg: Remove unused opcodes
Quoted 11 lines · Richard Henderson
tci.c +0
-3@@ -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 ;
tci.c uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr) · line 521
Quoted 10 lines
tci.c +0
-10-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 ;
Why do you remove the TODO notice for INDEX_op_discard/set_label? Is TCI no longer maintained?
tci.c uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr) · line 511
Quoted 3 lines
tci.c +0
-0case INDEX_op_call: t0 =tci_read_ri (&tb_ptr);#if TCG_TARGET_REG_BITS ==32
Other than that,
Cheers,
Bastian
Re: [Qemu-devel] [PATCH 2.3 8/8] tcg: Remove unused opcodes
Quoted 17 lines · Bastian Koppelmann
Quoted 15 lines · Richard Henderson
tci.c +0
-7@@ -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:
Quoted 8 lines
tci.c uintptr_t tcg_qemu_tb_exec(CPUArchState *env, uint8_t *tb_ptr) · line 521
Quoted 6 lines
tci.c +0
-6-case INDEX_op_discard: -TODO (); -break ; -case INDEX_op_set_label: -TODO (); -break ;Why do you remove the TODO notice for INDEX_op_discard/set_label? Is TCI no longer maintained?
Barely. But these opcodes never reach this far anyway, so the todo is bogus.
r~
Quoted 38 lines · Richard Henderson
Richard Henderson (8):
tcg: Move some opcode generation functions out of line
tcg: Reduce ifdefs intcg-op.c
tcg: Move emit ofINDEX_op_endintogen_tb_end
tcg: Introducetcg_op_buf_countandtcg_op_buf_full
tcg: Put opcodes in a linked list
tcg: Remove opcodes instead of noping them out
tcg: Implementinsert_op_before
tcg: Remove unused opcodesMakefile.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 | 1941 ++++++++++++++++++++++++++++++++ tcg/tcg-op.h | 2488 ++++++----------------------------------- tcg/tcg-opc.h | 9 - tcg/tcg.c | 535 +++------ tcg/tcg.h | 72 +- tci.c | 13 - 27 files changed, 2761 insertions(+), 2838 deletions(-)
Quoted 2 lines
create mode 100644
tcg/tcg-op.c
Richard, doing the review for the tcg changes helped me in my understanding on how tcg works. So whenever you have more changes for tcg, feel free to CC me.
Cheers,
Bastian
Quoted 16 lines · Richard Henderson
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.hout 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.hfunctionconsists of a single function call, inline it, otherwise move it out of line.This also removes a bit of boilerplate from each target.
Quoted 8 lines
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.
Of course this isn't intended for the upcoming 2.2 release.
Comments?
Happy new year! :) Are you going to submit this now?
Paolo