Patchwork [v5,5/7] TCG: Use gen_opc_buf from context instead of global variable.

login
register
mail settings
Submitter Evgeny Voevodin
Date Nov. 6, 2012, 4:41 a.m.
Message ID <1352176885-13324-6-git-send-email-e.voevodin@samsung.com>
Download mbox | patch
Permalink /patch/197403/
State New
Headers show

Comments

Evgeny Voevodin - Nov. 6, 2012, 4:41 a.m.
Signed-off-by: Evgeny Voevodin <e.voevodin@samsung.com>
Reviewed-by: Richard Henderson <rth@twiddle.net>
---
 target-alpha/translate.c      |    6 ++--
 target-arm/translate.c        |    6 ++--
 target-cris/translate.c       |    9 +++---
 target-i386/translate.c       |    6 ++--
 target-lm32/translate.c       |    9 +++---
 target-m68k/translate.c       |    6 ++--
 target-microblaze/translate.c |    9 +++---
 target-mips/translate.c       |    6 ++--
 target-openrisc/translate.c   |    9 +++---
 target-ppc/translate.c        |    6 ++--
 target-s390x/translate.c      |    6 ++--
 target-sh4/translate.c        |    6 ++--
 target-sparc/translate.c      |    6 ++--
 target-unicore32/translate.c  |    6 ++--
 target-xtensa/translate.c     |    4 +--
 tcg/optimize.c                |   62 ++++++++++++++++++++---------------------
 tcg/tcg.c                     |   30 ++++++++++----------
 17 files changed, 98 insertions(+), 94 deletions(-)
Blue Swirl - Nov. 10, 2012, 12:39 p.m.
On Tue, Nov 6, 2012 at 4:41 AM, Evgeny Voevodin <e.voevodin@samsung.com> wrote:
> Signed-off-by: Evgeny Voevodin <e.voevodin@samsung.com>
> Reviewed-by: Richard Henderson <rth@twiddle.net>
> ---
>  target-alpha/translate.c      |    6 ++--
>  target-arm/translate.c        |    6 ++--
>  target-cris/translate.c       |    9 +++---
>  target-i386/translate.c       |    6 ++--
>  target-lm32/translate.c       |    9 +++---
>  target-m68k/translate.c       |    6 ++--
>  target-microblaze/translate.c |    9 +++---
>  target-mips/translate.c       |    6 ++--
>  target-openrisc/translate.c   |    9 +++---
>  target-ppc/translate.c        |    6 ++--
>  target-s390x/translate.c      |    6 ++--
>  target-sh4/translate.c        |    6 ++--
>  target-sparc/translate.c      |    6 ++--
>  target-unicore32/translate.c  |    6 ++--
>  target-xtensa/translate.c     |    4 +--
>  tcg/optimize.c                |   62 ++++++++++++++++++++---------------------
>  tcg/tcg.c                     |   30 ++++++++++----------
>  17 files changed, 98 insertions(+), 94 deletions(-)
>
> diff --git a/target-alpha/translate.c b/target-alpha/translate.c
> index 6676cbf..91c761a 100644
> --- a/target-alpha/translate.c
> +++ b/target-alpha/translate.c
> @@ -3373,7 +3373,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>      int max_insns;
>
>      pc_start = tb->pc;
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      ctx.tb = tb;
>      ctx.env = env;
> @@ -3406,7 +3406,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>              }
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -3465,7 +3465,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-arm/translate.c b/target-arm/translate.c
> index ff5d294..0602b31 100644
> --- a/target-arm/translate.c
> +++ b/target-arm/translate.c
> @@ -9727,7 +9727,7 @@ static inline void gen_intermediate_code_internal(CPUARMState *env,
>
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      dc->pc = pc_start;
> @@ -9834,7 +9834,7 @@ static inline void gen_intermediate_code_internal(CPUARMState *env,
>              }
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -9974,7 +9974,7 @@ done_generating:
>      }
>  #endif
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-cris/translate.c b/target-cris/translate.c
> index e34288e..0adc07b 100644
> --- a/target-cris/translate.c
> +++ b/target-cris/translate.c
> @@ -3232,7 +3232,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>      dc->env = env;
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      dc->ppc = pc_start;
> @@ -3297,7 +3297,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>          check_breakpoint(env, dc);
>
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j) {
> @@ -3436,7 +3436,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j) {
>              gen_opc_instr_start[lj++] = 0;
> @@ -3452,7 +3452,8 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>          log_target_disas(pc_start, dc->pc - pc_start,
>                                   dc->env->pregs[PR_VR]);
>          qemu_log("\nisize=%d osize=%td\n",
> -            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - gen_opc_buf);
> +            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - tcg_ctx.gen_opc_buf);
> +            tcg_ctx.gen_opc_buf);


Broken patch:
/src/qemu/target-cris/translate.c:3456: error: statement with no effect
/src/qemu/target-cris/translate.c:3456: error: expected ';' before ')' token
/src/qemu/target-cris/translate.c:3456: error: expected statement
before ')' token

Please compile with no target list to catch bugs like this.

>      }
>  #endif
>  #endif
> diff --git a/target-i386/translate.c b/target-i386/translate.c
> index 5f977d9..1563677 100644
> --- a/target-i386/translate.c
> +++ b/target-i386/translate.c
> @@ -7958,7 +7958,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>      cpu_ptr0 = tcg_temp_new_ptr();
>      cpu_ptr1 = tcg_temp_new_ptr();
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      pc_ptr = pc_start;
> @@ -7980,7 +7980,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>              }
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -8030,7 +8030,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>      *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 - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-lm32/translate.c b/target-lm32/translate.c
> index 7446a50..9a01b9f 100644
> --- a/target-lm32/translate.c
> +++ b/target-lm32/translate.c
> @@ -1018,7 +1018,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>      dc->env = env;
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      dc->pc = pc_start;
> @@ -1047,7 +1047,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>          check_breakpoint(env, dc);
>
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j) {
> @@ -1107,7 +1107,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j) {
>              gen_opc_instr_start[lj++] = 0;
> @@ -1122,7 +1122,8 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>          qemu_log("\n");
>          log_target_disas(pc_start, dc->pc - pc_start, 0);
>          qemu_log("\nisize=%d osize=%td\n",
> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
> +            tcg_ctx.gen_opc_buf);
>      }
>  #endif
>  }
> diff --git a/target-m68k/translate.c b/target-m68k/translate.c
> index 568e187..e9f5b27 100644
> --- a/target-m68k/translate.c
> +++ b/target-m68k/translate.c
> @@ -2982,7 +2982,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->env = env;
>      dc->is_jmp = DISAS_NEXT;
> @@ -3015,7 +3015,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>                  break;
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -3075,7 +3075,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>      }
>  #endif
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-microblaze/translate.c b/target-microblaze/translate.c
> index a3bd799..b5d72fe 100644
> --- a/target-microblaze/translate.c
> +++ b/target-microblaze/translate.c
> @@ -1741,7 +1741,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>      dc->tb = tb;
>      org_flags = dc->synced_flags = dc->tb_flags = tb->flags;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      dc->jmp = 0;
> @@ -1784,7 +1784,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>          check_breakpoint(env, dc);
>
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -1899,7 +1899,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> @@ -1916,7 +1916,8 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>          log_target_disas(pc_start, dc->pc - pc_start, 0);
>  #endif
>          qemu_log("\nisize=%d osize=%td\n",
> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
> +            tcg_ctx.gen_opc_buf);
>      }
>  #endif
>  #endif
> diff --git a/target-mips/translate.c b/target-mips/translate.c
> index c86e16e..ade3fd6 100644
> --- a/target-mips/translate.c
> +++ b/target-mips/translate.c
> @@ -15509,7 +15509,7 @@ gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
>          qemu_log("search pc %d\n", search_pc);
>
>      pc_start = tb->pc;
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>      ctx.pc = pc_start;
>      ctx.saved_pc = -1;
>      ctx.singlestep_enabled = env->singlestep_enabled;
> @@ -15545,7 +15545,7 @@ gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
>          }
>
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -15629,7 +15629,7 @@ done_generating:
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-openrisc/translate.c b/target-openrisc/translate.c
> index db977ca..06723b8 100644
> --- a/target-openrisc/translate.c
> +++ b/target-openrisc/translate.c
> @@ -1675,7 +1675,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>      pc_start = tb->pc;
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>      dc->is_jmp = DISAS_NEXT;
>      dc->ppc = pc_start;
>      dc->pc = pc_start;
> @@ -1703,7 +1703,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>      do {
>          check_breakpoint(cpu, dc);
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (k < j) {
>                  k++;
>                  while (k < j) {
> @@ -1784,7 +1784,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          k++;
>          while (k <= j) {
>              gen_opc_instr_start[k++] = 0;
> @@ -1799,7 +1799,8 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>          qemu_log("\n");
>          log_target_disas(pc_start, dc->pc - pc_start, 0);
>          qemu_log("\nisize=%d osize=%td\n",
> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
> +            tcg_ctx.gen_opc_buf);
>      }
>  #endif
>  }
> diff --git a/target-ppc/translate.c b/target-ppc/translate.c
> index d30abd0..66fb0f9 100644
> --- a/target-ppc/translate.c
> +++ b/target-ppc/translate.c
> @@ -9624,7 +9624,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>      int max_insns;
>
>      pc_start = tb->pc;
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>      ctx.nip = pc_start;
>      ctx.tb = tb;
>      ctx.exception = POWERPC_EXCP_NONE;
> @@ -9675,7 +9675,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>              }
>          }
>          if (unlikely(search_pc)) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -9777,7 +9777,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (unlikely(search_pc)) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-s390x/translate.c b/target-s390x/translate.c
> index 85ba318..503855a 100644
> --- a/target-s390x/translate.c
> +++ b/target-s390x/translate.c
> @@ -5134,7 +5134,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>      dc.tb = tb;
>      dc.cc_op = CC_OP_DYNAMIC;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
>
> @@ -5156,7 +5156,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>              }
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j) {
> @@ -5209,7 +5209,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j) {
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-sh4/translate.c b/target-sh4/translate.c
> index 4521c1c..cb465dd 100644
> --- a/target-sh4/translate.c
> +++ b/target-sh4/translate.c
> @@ -1967,7 +1967,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>      int max_insns;
>
>      pc_start = tb->pc;
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    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;
> @@ -1999,7 +1999,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>             }
>         }
>          if (search_pc) {
> -            i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (ii < i) {
>                  ii++;
>                  while (ii < i)
> @@ -2058,7 +2058,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (search_pc) {
> -        i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          ii++;
>          while (ii <= i)
>              gen_opc_instr_start[ii++] = 0;
> diff --git a/target-sparc/translate.c b/target-sparc/translate.c
> index d179675..bfd9203 100644
> --- a/target-sparc/translate.c
> +++ b/target-sparc/translate.c
> @@ -5257,7 +5257,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>      dc->fpu_enabled = tb_fpu_enabled(tb->flags);
>      dc->address_mask_32bit = tb_am_enabled(tb->flags);
>      dc->singlestep = (env->singlestep_enabled || singlestep);
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      num_insns = 0;
>      max_insns = tb->cflags & CF_COUNT_MASK;
> @@ -5279,7 +5279,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>          }
>          if (spc) {
>              qemu_log("Search PC...\n");
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j)
> @@ -5336,7 +5336,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>      gen_icount_end(tb, num_insns);
>      *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>      if (spc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j)
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-unicore32/translate.c b/target-unicore32/translate.c
> index 79bc431..bbb4763 100644
> --- a/target-unicore32/translate.c
> +++ b/target-unicore32/translate.c
> @@ -1956,7 +1956,7 @@ static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
>
>      dc->tb = tb;
>
> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>
>      dc->is_jmp = DISAS_NEXT;
>      dc->pc = pc_start;
> @@ -1999,7 +1999,7 @@ static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
>              }
>          }
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j) {
> @@ -2114,7 +2114,7 @@ done_generating:
>      }
>  #endif
>      if (search_pc) {
> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>          lj++;
>          while (lj <= j) {
>              gen_opc_instr_start[lj++] = 0;
> diff --git a/target-xtensa/translate.c b/target-xtensa/translate.c
> index c7971bc..13d8620 100644
> --- a/target-xtensa/translate.c
> +++ b/target-xtensa/translate.c
> @@ -2849,7 +2849,7 @@ static void gen_intermediate_code_internal(
>      DisasContext dc;
>      int insn_count = 0;
>      int j, lj = -1;
> -    uint16_t *gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
> +    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 =
> @@ -2893,7 +2893,7 @@ static void gen_intermediate_code_internal(
>          check_breakpoint(env, &dc);
>
>          if (search_pc) {
> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>              if (lj < j) {
>                  lj++;
>                  while (lj < j) {
> diff --git a/tcg/optimize.c b/tcg/optimize.c
> index 8e5d918..9109b81 100644
> --- a/tcg/optimize.c
> +++ b/tcg/optimize.c
> @@ -484,10 +484,10 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>      nb_globals = s->nb_globals;
>      memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
>
> -    nb_ops = tcg_opc_ptr - gen_opc_buf;
> +    nb_ops = tcg_opc_ptr - s->gen_opc_buf;
>      gen_args = args;
>      for (op_index = 0; op_index < nb_ops; op_index++) {
> -        op = gen_opc_buf[op_index];
> +        op = s->gen_opc_buf[op_index];
>          def = &tcg_op_defs[op];
>          /* Do copy propagation */
>          if (op == INDEX_op_call) {
> @@ -569,7 +569,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(rotr):
>              if (temps[args[1]].state == TCG_TEMP_CONST
>                  && temps[args[1]].val == 0) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tcg_opt_gen_movi(gen_args, args[0], 0);
>                  args += 3;
>                  gen_args += 2;
> @@ -598,9 +598,9 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>              if (temps[args[2]].state == TCG_TEMP_CONST
>                  && temps[args[2]].val == 0) {
>                  if (temps_are_copies(args[0], args[1])) {
> -                    gen_opc_buf[op_index] = INDEX_op_nop;
> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  } else {
> -                    gen_opc_buf[op_index] = op_to_mov(op);
> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>                      tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
>                      gen_args += 2;
>                  }
> @@ -618,7 +618,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(mul):
>              if ((temps[args[2]].state == TCG_TEMP_CONST
>                  && temps[args[2]].val == 0)) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tcg_opt_gen_movi(gen_args, args[0], 0);
>                  args += 3;
>                  gen_args += 2;
> @@ -635,9 +635,9 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(and):
>              if (temps_are_copies(args[1], args[2])) {
>                  if (temps_are_copies(args[0], args[1])) {
> -                    gen_opc_buf[op_index] = INDEX_op_nop;
> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  } else {
> -                    gen_opc_buf[op_index] = op_to_mov(op);
> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>                      tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
>                      gen_args += 2;
>                  }
> @@ -654,7 +654,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(sub):
>          CASE_OP_32_64(xor):
>              if (temps_are_copies(args[1], args[2])) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tcg_opt_gen_movi(gen_args, args[0], 0);
>                  gen_args += 2;
>                  args += 3;
> @@ -672,7 +672,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(mov):
>              if (temps_are_copies(args[0], args[1])) {
>                  args += 2;
> -                gen_opc_buf[op_index] = INDEX_op_nop;
> +                s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  break;
>              }
>              if (temps[args[1]].state != TCG_TEMP_CONST) {
> @@ -684,7 +684,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>              /* Source argument is constant.  Rewrite the operation and
>                 let movi case handle it. */
>              op = op_to_movi(op);
> -            gen_opc_buf[op_index] = op;
> +            s->gen_opc_buf[op_index] = op;
>              args[1] = temps[args[1]].val;
>              /* fallthrough */
>          CASE_OP_32_64(movi):
> @@ -702,7 +702,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          case INDEX_op_ext32s_i64:
>          case INDEX_op_ext32u_i64:
>              if (temps[args[1]].state == TCG_TEMP_CONST) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tmp = do_constant_folding(op, temps[args[1]].val, 0);
>                  tcg_opt_gen_movi(gen_args, args[0], tmp);
>                  gen_args += 2;
> @@ -729,7 +729,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(nor):
>              if (temps[args[1]].state == TCG_TEMP_CONST
>                  && temps[args[2]].state == TCG_TEMP_CONST) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tmp = do_constant_folding(op, temps[args[1]].val,
>                                            temps[args[2]].val);
>                  tcg_opt_gen_movi(gen_args, args[0], tmp);
> @@ -742,7 +742,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(deposit):
>              if (temps[args[1]].state == TCG_TEMP_CONST
>                  && temps[args[2]].state == TCG_TEMP_CONST) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tmp = ((1ull << args[4]) - 1);
>                  tmp = (temps[args[1]].val & ~(tmp << args[3]))
>                        | ((temps[args[2]].val & tmp) << args[3]);
> @@ -756,7 +756,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          CASE_OP_32_64(setcond):
>              tmp = do_constant_folding_cond(op, args[1], args[2], args[3]);
>              if (tmp != 2) {
> -                gen_opc_buf[op_index] = op_to_movi(op);
> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>                  tcg_opt_gen_movi(gen_args, args[0], tmp);
>                  gen_args += 2;
>                  args += 4;
> @@ -769,11 +769,11 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>              if (tmp != 2) {
>                  if (tmp) {
>                      memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
> -                    gen_opc_buf[op_index] = INDEX_op_br;
> +                    s->gen_opc_buf[op_index] = INDEX_op_br;
>                      gen_args[0] = args[3];
>                      gen_args += 1;
>                  } else {
> -                    gen_opc_buf[op_index] = INDEX_op_nop;
> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  }
>                  args += 4;
>                  break;
> @@ -784,13 +784,13 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>              tmp = do_constant_folding_cond(op, args[1], args[2], args[5]);
>              if (tmp != 2) {
>                  if (temps_are_copies(args[0], args[4-tmp])) {
> -                    gen_opc_buf[op_index] = INDEX_op_nop;
> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  } else if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {
> -                    gen_opc_buf[op_index] = op_to_movi(op);
> +                    s->gen_opc_buf[op_index] = op_to_movi(op);
>                      tcg_opt_gen_movi(gen_args, args[0], temps[args[4-tmp]].val);
>                      gen_args += 2;
>                  } else {
> -                    gen_opc_buf[op_index] = op_to_mov(op);
> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>                      tcg_opt_gen_mov(s, gen_args, args[0], args[4-tmp]);
>                      gen_args += 2;
>                  }
> @@ -820,12 +820,12 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>                  }
>
>                  /* We emit the extra nop when we emit the add2/sub2.  */
> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>
>                  rl = args[0];
>                  rh = args[1];
> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
> -                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
> +                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>                  tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)a);
>                  tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(a >> 32));
>                  gen_args += 4;
> @@ -843,12 +843,12 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>                  TCGArg rl, rh;
>
>                  /* We emit the extra nop when we emit the mulu2.  */
> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>
>                  rl = args[0];
>                  rh = args[1];
> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
> -                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
> +                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>                  tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)r);
>                  tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(r >> 32));
>                  gen_args += 4;
> @@ -862,11 +862,11 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>              if (tmp != 2) {
>                  if (tmp) {
>                      memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
> -                    gen_opc_buf[op_index] = INDEX_op_br;
> +                    s->gen_opc_buf[op_index] = INDEX_op_br;
>                      gen_args[0] = args[5];
>                      gen_args += 1;
>                  } else {
> -                    gen_opc_buf[op_index] = INDEX_op_nop;
> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>                  }
>              } else if ((args[4] == TCG_COND_LT || args[4] == TCG_COND_GE)
>                         && temps[args[2]].state == TCG_TEMP_CONST
> @@ -876,7 +876,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>                  /* Simplify LT/GE comparisons vs zero to a single compare
>                     vs the high word of the input.  */
>                  memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
> -                gen_opc_buf[op_index] = INDEX_op_brcond_i32;
> +                s->gen_opc_buf[op_index] = INDEX_op_brcond_i32;
>                  gen_args[0] = args[1];
>                  gen_args[1] = args[3];
>                  gen_args[2] = args[4];
> @@ -891,7 +891,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>          case INDEX_op_setcond2_i32:
>              tmp = do_constant_folding_cond2(&args[1], &args[3], args[5]);
>              if (tmp != 2) {
> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
>                  tcg_opt_gen_movi(gen_args, args[0], tmp);
>                  gen_args += 2;
>              } else if ((args[5] == TCG_COND_LT || args[5] == TCG_COND_GE)
> @@ -901,7 +901,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>                         && temps[args[4]].val == 0) {
>                  /* Simplify LT/GE comparisons vs zero to a single compare
>                     vs the high word of the input.  */
> -                gen_opc_buf[op_index] = INDEX_op_setcond_i32;
> +                s->gen_opc_buf[op_index] = INDEX_op_setcond_i32;
>                  gen_args[0] = args[0];
>                  gen_args[1] = args[2];
>                  gen_args[2] = args[4];
> diff --git a/tcg/tcg.c b/tcg/tcg.c
> index 4e650c8..ea27bd4 100644
> --- a/tcg/tcg.c
> +++ b/tcg/tcg.c
> @@ -297,7 +297,7 @@ void tcg_func_start(TCGContext *s)
>      s->goto_tb_issue_mask = 0;
>  #endif
>
> -    s->gen_opc_ptr = gen_opc_buf;
> +    s->gen_opc_ptr = s->gen_opc_buf;
>      s->gen_opparam_ptr = gen_opparam_buf;
>
>  #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
> @@ -896,7 +896,7 @@ void tcg_dump_ops(TCGContext *s)
>      char buf[128];
>
>      first_insn = 1;
> -    opc_ptr = gen_opc_buf;
> +    opc_ptr = s->gen_opc_buf;
>      args = gen_opparam_buf;
>      while (opc_ptr < s->gen_opc_ptr) {
>          c = *opc_ptr++;
> @@ -1231,7 +1231,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>
>      s->gen_opc_ptr++; /* skip end */
>
> -    nb_ops = s->gen_opc_ptr - gen_opc_buf;
> +    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
>
>      s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
>      s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t));
> @@ -1243,7 +1243,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>      args = s->gen_opparam_ptr;
>      op_index = nb_ops - 1;
>      while (op_index >= 0) {
> -        op = gen_opc_buf[op_index];
> +        op = s->gen_opc_buf[op_index];
>          def = &tcg_op_defs[op];
>          switch(op) {
>          case INDEX_op_call:
> @@ -1266,7 +1266,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>                              goto do_not_remove_call;
>                          }
>                      }
> -                    tcg_set_nop(s, gen_opc_buf + op_index,
> +                    tcg_set_nop(s, s->gen_opc_buf + op_index,
>                                  args - 1, nb_args);
>                  } else {
>                  do_not_remove_call:
> @@ -1347,11 +1347,11 @@ static void tcg_liveness_analysis(TCGContext *s)
>                  } else {
>                      op = INDEX_op_sub_i32;
>                  }
> -                gen_opc_buf[op_index] = op;
> +                s->gen_opc_buf[op_index] = op;
>                  args[1] = args[2];
>                  args[2] = args[4];
> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
> -                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 3);
> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
> +                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3);
>                  /* Fall through and mark the single-word operation live.  */
>                  nb_iargs = 2;
>                  nb_oargs = 1;
> @@ -1367,11 +1367,11 @@ static void tcg_liveness_analysis(TCGContext *s)
>                  if (dead_temps[args[0]] && !mem_temps[0]) {
>                      goto do_remove;
>                  }
> -                gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
> +                s->gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
>                  args[1] = args[2];
>                  args[2] = args[3];
> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
> -                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 1);
> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
> +                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1);
>                  /* Fall through and mark the single-word operation live.  */
>                  nb_oargs = 1;
>              }
> @@ -1394,7 +1394,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>                      }
>                  }
>              do_remove:
> -                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
> +                tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args);
>  #ifdef CONFIG_PROFILER
>                  s->del_op_count++;
>  #endif
> @@ -1448,7 +1448,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>  static void tcg_liveness_analysis(TCGContext *s)
>  {
>      int nb_ops;
> -    nb_ops = s->gen_opc_ptr - gen_opc_buf;
> +    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
>
>      s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
>      memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t));
> @@ -2253,7 +2253,7 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
>      op_index = 0;
>
>      for(;;) {
> -        opc = gen_opc_buf[op_index];
> +        opc = s->gen_opc_buf[op_index];
>  #ifdef CONFIG_PROFILER
>          tcg_table_op_count[opc]++;
>  #endif
> @@ -2334,7 +2334,7 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
>  #ifdef CONFIG_PROFILER
>      {
>          int n;
> -        n = (s->gen_opc_ptr - gen_opc_buf);
> +        n = (s->gen_opc_ptr - s->gen_opc_buf);
>          s->op_count += n;
>          if (n > s->op_count_max)
>              s->op_count_max = n;
> --
> 1.7.9.5
>
Evgeny Voevodin - Nov. 12, 2012, 7:33 a.m.
On 11/10/2012 04:39 PM, Blue Swirl wrote:
> On Tue, Nov 6, 2012 at 4:41 AM, Evgeny Voevodin <e.voevodin@samsung.com> wrote:
>> Signed-off-by: Evgeny Voevodin <e.voevodin@samsung.com>
>> Reviewed-by: Richard Henderson <rth@twiddle.net>
>> ---
>>   target-alpha/translate.c      |    6 ++--
>>   target-arm/translate.c        |    6 ++--
>>   target-cris/translate.c       |    9 +++---
>>   target-i386/translate.c       |    6 ++--
>>   target-lm32/translate.c       |    9 +++---
>>   target-m68k/translate.c       |    6 ++--
>>   target-microblaze/translate.c |    9 +++---
>>   target-mips/translate.c       |    6 ++--
>>   target-openrisc/translate.c   |    9 +++---
>>   target-ppc/translate.c        |    6 ++--
>>   target-s390x/translate.c      |    6 ++--
>>   target-sh4/translate.c        |    6 ++--
>>   target-sparc/translate.c      |    6 ++--
>>   target-unicore32/translate.c  |    6 ++--
>>   target-xtensa/translate.c     |    4 +--
>>   tcg/optimize.c                |   62 ++++++++++++++++++++---------------------
>>   tcg/tcg.c                     |   30 ++++++++++----------
>>   17 files changed, 98 insertions(+), 94 deletions(-)
>>
>> diff --git a/target-alpha/translate.c b/target-alpha/translate.c
>> index 6676cbf..91c761a 100644
>> --- a/target-alpha/translate.c
>> +++ b/target-alpha/translate.c
>> @@ -3373,7 +3373,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>>       int max_insns;
>>
>>       pc_start = tb->pc;
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       ctx.tb = tb;
>>       ctx.env = env;
>> @@ -3406,7 +3406,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>>               }
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -3465,7 +3465,7 @@ static inline void gen_intermediate_code_internal(CPUAlphaState *env,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-arm/translate.c b/target-arm/translate.c
>> index ff5d294..0602b31 100644
>> --- a/target-arm/translate.c
>> +++ b/target-arm/translate.c
>> @@ -9727,7 +9727,7 @@ static inline void gen_intermediate_code_internal(CPUARMState *env,
>>
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->pc = pc_start;
>> @@ -9834,7 +9834,7 @@ static inline void gen_intermediate_code_internal(CPUARMState *env,
>>               }
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -9974,7 +9974,7 @@ done_generating:
>>       }
>>   #endif
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-cris/translate.c b/target-cris/translate.c
>> index e34288e..0adc07b 100644
>> --- a/target-cris/translate.c
>> +++ b/target-cris/translate.c
>> @@ -3232,7 +3232,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>>       dc->env = env;
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->ppc = pc_start;
>> @@ -3297,7 +3297,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>>           check_breakpoint(env, dc);
>>
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j) {
>> @@ -3436,7 +3436,7 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j) {
>>               gen_opc_instr_start[lj++] = 0;
>> @@ -3452,7 +3452,8 @@ gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
>>           log_target_disas(pc_start, dc->pc - pc_start,
>>                                    dc->env->pregs[PR_VR]);
>>           qemu_log("\nisize=%d osize=%td\n",
>> -            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - gen_opc_buf);
>> +            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - tcg_ctx.gen_opc_buf);
>> +            tcg_ctx.gen_opc_buf);
>
> Broken patch:
> /src/qemu/target-cris/translate.c:3456: error: statement with no effect
> /src/qemu/target-cris/translate.c:3456: error: expected ';' before ')' token
> /src/qemu/target-cris/translate.c:3456: error: expected statement
> before ')' token
>
> Please compile with no target list to catch bugs like this.
>

Oh, sorry. Don't know how I missed this...

>>       }
>>   #endif
>>   #endif
>> diff --git a/target-i386/translate.c b/target-i386/translate.c
>> index 5f977d9..1563677 100644
>> --- a/target-i386/translate.c
>> +++ b/target-i386/translate.c
>> @@ -7958,7 +7958,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>>       cpu_ptr0 = tcg_temp_new_ptr();
>>       cpu_ptr1 = tcg_temp_new_ptr();
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       pc_ptr = pc_start;
>> @@ -7980,7 +7980,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>>               }
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -8030,7 +8030,7 @@ static inline void gen_intermediate_code_internal(CPUX86State *env,
>>       *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 - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-lm32/translate.c b/target-lm32/translate.c
>> index 7446a50..9a01b9f 100644
>> --- a/target-lm32/translate.c
>> +++ b/target-lm32/translate.c
>> @@ -1018,7 +1018,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>>       dc->env = env;
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->pc = pc_start;
>> @@ -1047,7 +1047,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>>           check_breakpoint(env, dc);
>>
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j) {
>> @@ -1107,7 +1107,7 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j) {
>>               gen_opc_instr_start[lj++] = 0;
>> @@ -1122,7 +1122,8 @@ static void gen_intermediate_code_internal(CPULM32State *env,
>>           qemu_log("\n");
>>           log_target_disas(pc_start, dc->pc - pc_start, 0);
>>           qemu_log("\nisize=%d osize=%td\n",
>> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
>> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
>> +            tcg_ctx.gen_opc_buf);
>>       }
>>   #endif
>>   }
>> diff --git a/target-m68k/translate.c b/target-m68k/translate.c
>> index 568e187..e9f5b27 100644
>> --- a/target-m68k/translate.c
>> +++ b/target-m68k/translate.c
>> @@ -2982,7 +2982,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>>
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->env = env;
>>       dc->is_jmp = DISAS_NEXT;
>> @@ -3015,7 +3015,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>>                   break;
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -3075,7 +3075,7 @@ gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
>>       }
>>   #endif
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-microblaze/translate.c b/target-microblaze/translate.c
>> index a3bd799..b5d72fe 100644
>> --- a/target-microblaze/translate.c
>> +++ b/target-microblaze/translate.c
>> @@ -1741,7 +1741,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>>       dc->tb = tb;
>>       org_flags = dc->synced_flags = dc->tb_flags = tb->flags;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->jmp = 0;
>> @@ -1784,7 +1784,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>>           check_breakpoint(env, dc);
>>
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -1899,7 +1899,7 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> @@ -1916,7 +1916,8 @@ gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
>>           log_target_disas(pc_start, dc->pc - pc_start, 0);
>>   #endif
>>           qemu_log("\nisize=%d osize=%td\n",
>> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
>> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
>> +            tcg_ctx.gen_opc_buf);
>>       }
>>   #endif
>>   #endif
>> diff --git a/target-mips/translate.c b/target-mips/translate.c
>> index c86e16e..ade3fd6 100644
>> --- a/target-mips/translate.c
>> +++ b/target-mips/translate.c
>> @@ -15509,7 +15509,7 @@ gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
>>           qemu_log("search pc %d\n", search_pc);
>>
>>       pc_start = tb->pc;
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>       ctx.pc = pc_start;
>>       ctx.saved_pc = -1;
>>       ctx.singlestep_enabled = env->singlestep_enabled;
>> @@ -15545,7 +15545,7 @@ gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
>>           }
>>
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -15629,7 +15629,7 @@ done_generating:
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-openrisc/translate.c b/target-openrisc/translate.c
>> index db977ca..06723b8 100644
>> --- a/target-openrisc/translate.c
>> +++ b/target-openrisc/translate.c
>> @@ -1675,7 +1675,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>>       pc_start = tb->pc;
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->ppc = pc_start;
>>       dc->pc = pc_start;
>> @@ -1703,7 +1703,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>>       do {
>>           check_breakpoint(cpu, dc);
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (k < j) {
>>                   k++;
>>                   while (k < j) {
>> @@ -1784,7 +1784,7 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           k++;
>>           while (k <= j) {
>>               gen_opc_instr_start[k++] = 0;
>> @@ -1799,7 +1799,8 @@ static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
>>           qemu_log("\n");
>>           log_target_disas(pc_start, dc->pc - pc_start, 0);
>>           qemu_log("\nisize=%d osize=%td\n",
>> -            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
>> +            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
>> +            tcg_ctx.gen_opc_buf);
>>       }
>>   #endif
>>   }
>> diff --git a/target-ppc/translate.c b/target-ppc/translate.c
>> index d30abd0..66fb0f9 100644
>> --- a/target-ppc/translate.c
>> +++ b/target-ppc/translate.c
>> @@ -9624,7 +9624,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>>       int max_insns;
>>
>>       pc_start = tb->pc;
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>       ctx.nip = pc_start;
>>       ctx.tb = tb;
>>       ctx.exception = POWERPC_EXCP_NONE;
>> @@ -9675,7 +9675,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>>               }
>>           }
>>           if (unlikely(search_pc)) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -9777,7 +9777,7 @@ static inline void gen_intermediate_code_internal(CPUPPCState *env,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (unlikely(search_pc)) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-s390x/translate.c b/target-s390x/translate.c
>> index 85ba318..503855a 100644
>> --- a/target-s390x/translate.c
>> +++ b/target-s390x/translate.c
>> @@ -5134,7 +5134,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>>       dc.tb = tb;
>>       dc.cc_op = CC_OP_DYNAMIC;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
>>
>> @@ -5156,7 +5156,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>>               }
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j) {
>> @@ -5209,7 +5209,7 @@ static inline void gen_intermediate_code_internal(CPUS390XState *env,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j) {
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-sh4/translate.c b/target-sh4/translate.c
>> index 4521c1c..cb465dd 100644
>> --- a/target-sh4/translate.c
>> +++ b/target-sh4/translate.c
>> @@ -1967,7 +1967,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>>       int max_insns;
>>
>>       pc_start = tb->pc;
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    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;
>> @@ -1999,7 +1999,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>>              }
>>          }
>>           if (search_pc) {
>> -            i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (ii < i) {
>>                   ii++;
>>                   while (ii < i)
>> @@ -2058,7 +2058,7 @@ gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (search_pc) {
>> -        i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           ii++;
>>           while (ii <= i)
>>               gen_opc_instr_start[ii++] = 0;
>> diff --git a/target-sparc/translate.c b/target-sparc/translate.c
>> index d179675..bfd9203 100644
>> --- a/target-sparc/translate.c
>> +++ b/target-sparc/translate.c
>> @@ -5257,7 +5257,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>>       dc->fpu_enabled = tb_fpu_enabled(tb->flags);
>>       dc->address_mask_32bit = tb_am_enabled(tb->flags);
>>       dc->singlestep = (env->singlestep_enabled || singlestep);
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       num_insns = 0;
>>       max_insns = tb->cflags & CF_COUNT_MASK;
>> @@ -5279,7 +5279,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>>           }
>>           if (spc) {
>>               qemu_log("Search PC...\n");
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j)
>> @@ -5336,7 +5336,7 @@ static inline void gen_intermediate_code_internal(TranslationBlock * tb,
>>       gen_icount_end(tb, num_insns);
>>       *tcg_ctx.gen_opc_ptr = INDEX_op_end;
>>       if (spc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j)
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-unicore32/translate.c b/target-unicore32/translate.c
>> index 79bc431..bbb4763 100644
>> --- a/target-unicore32/translate.c
>> +++ b/target-unicore32/translate.c
>> @@ -1956,7 +1956,7 @@ static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
>>
>>       dc->tb = tb;
>>
>> -    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
>>
>>       dc->is_jmp = DISAS_NEXT;
>>       dc->pc = pc_start;
>> @@ -1999,7 +1999,7 @@ static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
>>               }
>>           }
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j) {
>> @@ -2114,7 +2114,7 @@ done_generating:
>>       }
>>   #endif
>>       if (search_pc) {
>> -        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>           lj++;
>>           while (lj <= j) {
>>               gen_opc_instr_start[lj++] = 0;
>> diff --git a/target-xtensa/translate.c b/target-xtensa/translate.c
>> index c7971bc..13d8620 100644
>> --- a/target-xtensa/translate.c
>> +++ b/target-xtensa/translate.c
>> @@ -2849,7 +2849,7 @@ static void gen_intermediate_code_internal(
>>       DisasContext dc;
>>       int insn_count = 0;
>>       int j, lj = -1;
>> -    uint16_t *gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
>> +    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 =
>> @@ -2893,7 +2893,7 @@ static void gen_intermediate_code_internal(
>>           check_breakpoint(env, &dc);
>>
>>           if (search_pc) {
>> -            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
>> +            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
>>               if (lj < j) {
>>                   lj++;
>>                   while (lj < j) {
>> diff --git a/tcg/optimize.c b/tcg/optimize.c
>> index 8e5d918..9109b81 100644
>> --- a/tcg/optimize.c
>> +++ b/tcg/optimize.c
>> @@ -484,10 +484,10 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>       nb_globals = s->nb_globals;
>>       memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
>>
>> -    nb_ops = tcg_opc_ptr - gen_opc_buf;
>> +    nb_ops = tcg_opc_ptr - s->gen_opc_buf;
>>       gen_args = args;
>>       for (op_index = 0; op_index < nb_ops; op_index++) {
>> -        op = gen_opc_buf[op_index];
>> +        op = s->gen_opc_buf[op_index];
>>           def = &tcg_op_defs[op];
>>           /* Do copy propagation */
>>           if (op == INDEX_op_call) {
>> @@ -569,7 +569,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(rotr):
>>               if (temps[args[1]].state == TCG_TEMP_CONST
>>                   && temps[args[1]].val == 0) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tcg_opt_gen_movi(gen_args, args[0], 0);
>>                   args += 3;
>>                   gen_args += 2;
>> @@ -598,9 +598,9 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>               if (temps[args[2]].state == TCG_TEMP_CONST
>>                   && temps[args[2]].val == 0) {
>>                   if (temps_are_copies(args[0], args[1])) {
>> -                    gen_opc_buf[op_index] = INDEX_op_nop;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   } else {
>> -                    gen_opc_buf[op_index] = op_to_mov(op);
>> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>>                       tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
>>                       gen_args += 2;
>>                   }
>> @@ -618,7 +618,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(mul):
>>               if ((temps[args[2]].state == TCG_TEMP_CONST
>>                   && temps[args[2]].val == 0)) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tcg_opt_gen_movi(gen_args, args[0], 0);
>>                   args += 3;
>>                   gen_args += 2;
>> @@ -635,9 +635,9 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(and):
>>               if (temps_are_copies(args[1], args[2])) {
>>                   if (temps_are_copies(args[0], args[1])) {
>> -                    gen_opc_buf[op_index] = INDEX_op_nop;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   } else {
>> -                    gen_opc_buf[op_index] = op_to_mov(op);
>> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>>                       tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
>>                       gen_args += 2;
>>                   }
>> @@ -654,7 +654,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(sub):
>>           CASE_OP_32_64(xor):
>>               if (temps_are_copies(args[1], args[2])) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tcg_opt_gen_movi(gen_args, args[0], 0);
>>                   gen_args += 2;
>>                   args += 3;
>> @@ -672,7 +672,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(mov):
>>               if (temps_are_copies(args[0], args[1])) {
>>                   args += 2;
>> -                gen_opc_buf[op_index] = INDEX_op_nop;
>> +                s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   break;
>>               }
>>               if (temps[args[1]].state != TCG_TEMP_CONST) {
>> @@ -684,7 +684,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>               /* Source argument is constant.  Rewrite the operation and
>>                  let movi case handle it. */
>>               op = op_to_movi(op);
>> -            gen_opc_buf[op_index] = op;
>> +            s->gen_opc_buf[op_index] = op;
>>               args[1] = temps[args[1]].val;
>>               /* fallthrough */
>>           CASE_OP_32_64(movi):
>> @@ -702,7 +702,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           case INDEX_op_ext32s_i64:
>>           case INDEX_op_ext32u_i64:
>>               if (temps[args[1]].state == TCG_TEMP_CONST) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tmp = do_constant_folding(op, temps[args[1]].val, 0);
>>                   tcg_opt_gen_movi(gen_args, args[0], tmp);
>>                   gen_args += 2;
>> @@ -729,7 +729,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(nor):
>>               if (temps[args[1]].state == TCG_TEMP_CONST
>>                   && temps[args[2]].state == TCG_TEMP_CONST) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tmp = do_constant_folding(op, temps[args[1]].val,
>>                                             temps[args[2]].val);
>>                   tcg_opt_gen_movi(gen_args, args[0], tmp);
>> @@ -742,7 +742,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(deposit):
>>               if (temps[args[1]].state == TCG_TEMP_CONST
>>                   && temps[args[2]].state == TCG_TEMP_CONST) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tmp = ((1ull << args[4]) - 1);
>>                   tmp = (temps[args[1]].val & ~(tmp << args[3]))
>>                         | ((temps[args[2]].val & tmp) << args[3]);
>> @@ -756,7 +756,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           CASE_OP_32_64(setcond):
>>               tmp = do_constant_folding_cond(op, args[1], args[2], args[3]);
>>               if (tmp != 2) {
>> -                gen_opc_buf[op_index] = op_to_movi(op);
>> +                s->gen_opc_buf[op_index] = op_to_movi(op);
>>                   tcg_opt_gen_movi(gen_args, args[0], tmp);
>>                   gen_args += 2;
>>                   args += 4;
>> @@ -769,11 +769,11 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>               if (tmp != 2) {
>>                   if (tmp) {
>>                       memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
>> -                    gen_opc_buf[op_index] = INDEX_op_br;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_br;
>>                       gen_args[0] = args[3];
>>                       gen_args += 1;
>>                   } else {
>> -                    gen_opc_buf[op_index] = INDEX_op_nop;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   }
>>                   args += 4;
>>                   break;
>> @@ -784,13 +784,13 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>               tmp = do_constant_folding_cond(op, args[1], args[2], args[5]);
>>               if (tmp != 2) {
>>                   if (temps_are_copies(args[0], args[4-tmp])) {
>> -                    gen_opc_buf[op_index] = INDEX_op_nop;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   } else if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {
>> -                    gen_opc_buf[op_index] = op_to_movi(op);
>> +                    s->gen_opc_buf[op_index] = op_to_movi(op);
>>                       tcg_opt_gen_movi(gen_args, args[0], temps[args[4-tmp]].val);
>>                       gen_args += 2;
>>                   } else {
>> -                    gen_opc_buf[op_index] = op_to_mov(op);
>> +                    s->gen_opc_buf[op_index] = op_to_mov(op);
>>                       tcg_opt_gen_mov(s, gen_args, args[0], args[4-tmp]);
>>                       gen_args += 2;
>>                   }
>> @@ -820,12 +820,12 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>                   }
>>
>>                   /* We emit the extra nop when we emit the add2/sub2.  */
>> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>>
>>                   rl = args[0];
>>                   rh = args[1];
>> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
>> -                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
>> +                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>>                   tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)a);
>>                   tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(a >> 32));
>>                   gen_args += 4;
>> @@ -843,12 +843,12 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>                   TCGArg rl, rh;
>>
>>                   /* We emit the extra nop when we emit the mulu2.  */
>> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>>
>>                   rl = args[0];
>>                   rh = args[1];
>> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
>> -                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
>> +                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
>>                   tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)r);
>>                   tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(r >> 32));
>>                   gen_args += 4;
>> @@ -862,11 +862,11 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>               if (tmp != 2) {
>>                   if (tmp) {
>>                       memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
>> -                    gen_opc_buf[op_index] = INDEX_op_br;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_br;
>>                       gen_args[0] = args[5];
>>                       gen_args += 1;
>>                   } else {
>> -                    gen_opc_buf[op_index] = INDEX_op_nop;
>> +                    s->gen_opc_buf[op_index] = INDEX_op_nop;
>>                   }
>>               } else if ((args[4] == TCG_COND_LT || args[4] == TCG_COND_GE)
>>                          && temps[args[2]].state == TCG_TEMP_CONST
>> @@ -876,7 +876,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>                   /* Simplify LT/GE comparisons vs zero to a single compare
>>                      vs the high word of the input.  */
>>                   memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
>> -                gen_opc_buf[op_index] = INDEX_op_brcond_i32;
>> +                s->gen_opc_buf[op_index] = INDEX_op_brcond_i32;
>>                   gen_args[0] = args[1];
>>                   gen_args[1] = args[3];
>>                   gen_args[2] = args[4];
>> @@ -891,7 +891,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>           case INDEX_op_setcond2_i32:
>>               tmp = do_constant_folding_cond2(&args[1], &args[3], args[5]);
>>               if (tmp != 2) {
>> -                gen_opc_buf[op_index] = INDEX_op_movi_i32;
>> +                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
>>                   tcg_opt_gen_movi(gen_args, args[0], tmp);
>>                   gen_args += 2;
>>               } else if ((args[5] == TCG_COND_LT || args[5] == TCG_COND_GE)
>> @@ -901,7 +901,7 @@ static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
>>                          && temps[args[4]].val == 0) {
>>                   /* Simplify LT/GE comparisons vs zero to a single compare
>>                      vs the high word of the input.  */
>> -                gen_opc_buf[op_index] = INDEX_op_setcond_i32;
>> +                s->gen_opc_buf[op_index] = INDEX_op_setcond_i32;
>>                   gen_args[0] = args[0];
>>                   gen_args[1] = args[2];
>>                   gen_args[2] = args[4];
>> diff --git a/tcg/tcg.c b/tcg/tcg.c
>> index 4e650c8..ea27bd4 100644
>> --- a/tcg/tcg.c
>> +++ b/tcg/tcg.c
>> @@ -297,7 +297,7 @@ void tcg_func_start(TCGContext *s)
>>       s->goto_tb_issue_mask = 0;
>>   #endif
>>
>> -    s->gen_opc_ptr = gen_opc_buf;
>> +    s->gen_opc_ptr = s->gen_opc_buf;
>>       s->gen_opparam_ptr = gen_opparam_buf;
>>
>>   #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
>> @@ -896,7 +896,7 @@ void tcg_dump_ops(TCGContext *s)
>>       char buf[128];
>>
>>       first_insn = 1;
>> -    opc_ptr = gen_opc_buf;
>> +    opc_ptr = s->gen_opc_buf;
>>       args = gen_opparam_buf;
>>       while (opc_ptr < s->gen_opc_ptr) {
>>           c = *opc_ptr++;
>> @@ -1231,7 +1231,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>>
>>       s->gen_opc_ptr++; /* skip end */
>>
>> -    nb_ops = s->gen_opc_ptr - gen_opc_buf;
>> +    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
>>
>>       s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
>>       s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t));
>> @@ -1243,7 +1243,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>>       args = s->gen_opparam_ptr;
>>       op_index = nb_ops - 1;
>>       while (op_index >= 0) {
>> -        op = gen_opc_buf[op_index];
>> +        op = s->gen_opc_buf[op_index];
>>           def = &tcg_op_defs[op];
>>           switch(op) {
>>           case INDEX_op_call:
>> @@ -1266,7 +1266,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>>                               goto do_not_remove_call;
>>                           }
>>                       }
>> -                    tcg_set_nop(s, gen_opc_buf + op_index,
>> +                    tcg_set_nop(s, s->gen_opc_buf + op_index,
>>                                   args - 1, nb_args);
>>                   } else {
>>                   do_not_remove_call:
>> @@ -1347,11 +1347,11 @@ static void tcg_liveness_analysis(TCGContext *s)
>>                   } else {
>>                       op = INDEX_op_sub_i32;
>>                   }
>> -                gen_opc_buf[op_index] = op;
>> +                s->gen_opc_buf[op_index] = op;
>>                   args[1] = args[2];
>>                   args[2] = args[4];
>> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> -                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 3);
>> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> +                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3);
>>                   /* Fall through and mark the single-word operation live.  */
>>                   nb_iargs = 2;
>>                   nb_oargs = 1;
>> @@ -1367,11 +1367,11 @@ static void tcg_liveness_analysis(TCGContext *s)
>>                   if (dead_temps[args[0]] && !mem_temps[0]) {
>>                       goto do_remove;
>>                   }
>> -                gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
>> +                s->gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
>>                   args[1] = args[2];
>>                   args[2] = args[3];
>> -                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> -                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 1);
>> +                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
>> +                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1);
>>                   /* Fall through and mark the single-word operation live.  */
>>                   nb_oargs = 1;
>>               }
>> @@ -1394,7 +1394,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>>                       }
>>                   }
>>               do_remove:
>> -                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
>> +                tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args);
>>   #ifdef CONFIG_PROFILER
>>                   s->del_op_count++;
>>   #endif
>> @@ -1448,7 +1448,7 @@ static void tcg_liveness_analysis(TCGContext *s)
>>   static void tcg_liveness_analysis(TCGContext *s)
>>   {
>>       int nb_ops;
>> -    nb_ops = s->gen_opc_ptr - gen_opc_buf;
>> +    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
>>
>>       s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
>>       memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t));
>> @@ -2253,7 +2253,7 @@ static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
>>       op_index = 0;
>>
>>       for(;;) {
>> -        opc = gen_opc_buf[op_index];
>> +        opc = s->gen_opc_buf[op_index];
>>   #ifdef CONFIG_PROFILER
>>           tcg_table_op_count[opc]++;
>>   #endif
>> @@ -2334,7 +2334,7 @@ int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
>>   #ifdef CONFIG_PROFILER
>>       {
>>           int n;
>> -        n = (s->gen_opc_ptr - gen_opc_buf);
>> +        n = (s->gen_opc_ptr - s->gen_opc_buf);
>>           s->op_count += n;
>>           if (n > s->op_count_max)
>>               s->op_count_max = n;
>> --
>> 1.7.9.5
>>

Patch

diff --git a/target-alpha/translate.c b/target-alpha/translate.c
index 6676cbf..91c761a 100644
--- a/target-alpha/translate.c
+++ b/target-alpha/translate.c
@@ -3373,7 +3373,7 @@  static inline void gen_intermediate_code_internal(CPUAlphaState *env,
     int max_insns;
 
     pc_start = tb->pc;
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     ctx.tb = tb;
     ctx.env = env;
@@ -3406,7 +3406,7 @@  static inline void gen_intermediate_code_internal(CPUAlphaState *env,
             }
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -3465,7 +3465,7 @@  static inline void gen_intermediate_code_internal(CPUAlphaState *env,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-arm/translate.c b/target-arm/translate.c
index ff5d294..0602b31 100644
--- a/target-arm/translate.c
+++ b/target-arm/translate.c
@@ -9727,7 +9727,7 @@  static inline void gen_intermediate_code_internal(CPUARMState *env,
 
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     dc->pc = pc_start;
@@ -9834,7 +9834,7 @@  static inline void gen_intermediate_code_internal(CPUARMState *env,
             }
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -9974,7 +9974,7 @@  done_generating:
     }
 #endif
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-cris/translate.c b/target-cris/translate.c
index e34288e..0adc07b 100644
--- a/target-cris/translate.c
+++ b/target-cris/translate.c
@@ -3232,7 +3232,7 @@  gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
     dc->env = env;
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     dc->ppc = pc_start;
@@ -3297,7 +3297,7 @@  gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
         check_breakpoint(env, dc);
 
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j) {
@@ -3436,7 +3436,7 @@  gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j) {
             gen_opc_instr_start[lj++] = 0;
@@ -3452,7 +3452,8 @@  gen_intermediate_code_internal(CPUCRISState *env, TranslationBlock *tb,
         log_target_disas(pc_start, dc->pc - pc_start,
                                  dc->env->pregs[PR_VR]);
         qemu_log("\nisize=%d osize=%td\n",
-            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - gen_opc_buf);
+            dc->pc - pc_start, gtcg_ctx.en_opc_ptr - tcg_ctx.gen_opc_buf);
+            tcg_ctx.gen_opc_buf);
     }
 #endif
 #endif
diff --git a/target-i386/translate.c b/target-i386/translate.c
index 5f977d9..1563677 100644
--- a/target-i386/translate.c
+++ b/target-i386/translate.c
@@ -7958,7 +7958,7 @@  static inline void gen_intermediate_code_internal(CPUX86State *env,
     cpu_ptr0 = tcg_temp_new_ptr();
     cpu_ptr1 = tcg_temp_new_ptr();
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     pc_ptr = pc_start;
@@ -7980,7 +7980,7 @@  static inline void gen_intermediate_code_internal(CPUX86State *env,
             }
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -8030,7 +8030,7 @@  static inline void gen_intermediate_code_internal(CPUX86State *env,
     *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 - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-lm32/translate.c b/target-lm32/translate.c
index 7446a50..9a01b9f 100644
--- a/target-lm32/translate.c
+++ b/target-lm32/translate.c
@@ -1018,7 +1018,7 @@  static void gen_intermediate_code_internal(CPULM32State *env,
     dc->env = env;
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     dc->pc = pc_start;
@@ -1047,7 +1047,7 @@  static void gen_intermediate_code_internal(CPULM32State *env,
         check_breakpoint(env, dc);
 
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j) {
@@ -1107,7 +1107,7 @@  static void gen_intermediate_code_internal(CPULM32State *env,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j) {
             gen_opc_instr_start[lj++] = 0;
@@ -1122,7 +1122,8 @@  static void gen_intermediate_code_internal(CPULM32State *env,
         qemu_log("\n");
         log_target_disas(pc_start, dc->pc - pc_start, 0);
         qemu_log("\nisize=%d osize=%td\n",
-            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
+            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
+            tcg_ctx.gen_opc_buf);
     }
 #endif
 }
diff --git a/target-m68k/translate.c b/target-m68k/translate.c
index 568e187..e9f5b27 100644
--- a/target-m68k/translate.c
+++ b/target-m68k/translate.c
@@ -2982,7 +2982,7 @@  gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
 
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->env = env;
     dc->is_jmp = DISAS_NEXT;
@@ -3015,7 +3015,7 @@  gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
                 break;
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -3075,7 +3075,7 @@  gen_intermediate_code_internal(CPUM68KState *env, TranslationBlock *tb,
     }
 #endif
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-microblaze/translate.c b/target-microblaze/translate.c
index a3bd799..b5d72fe 100644
--- a/target-microblaze/translate.c
+++ b/target-microblaze/translate.c
@@ -1741,7 +1741,7 @@  gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
     dc->tb = tb;
     org_flags = dc->synced_flags = dc->tb_flags = tb->flags;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     dc->jmp = 0;
@@ -1784,7 +1784,7 @@  gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
         check_breakpoint(env, dc);
 
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -1899,7 +1899,7 @@  gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
@@ -1916,7 +1916,8 @@  gen_intermediate_code_internal(CPUMBState *env, TranslationBlock *tb,
         log_target_disas(pc_start, dc->pc - pc_start, 0);
 #endif
         qemu_log("\nisize=%d osize=%td\n",
-            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
+            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
+            tcg_ctx.gen_opc_buf);
     }
 #endif
 #endif
diff --git a/target-mips/translate.c b/target-mips/translate.c
index c86e16e..ade3fd6 100644
--- a/target-mips/translate.c
+++ b/target-mips/translate.c
@@ -15509,7 +15509,7 @@  gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
         qemu_log("search pc %d\n", search_pc);
 
     pc_start = tb->pc;
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
     ctx.pc = pc_start;
     ctx.saved_pc = -1;
     ctx.singlestep_enabled = env->singlestep_enabled;
@@ -15545,7 +15545,7 @@  gen_intermediate_code_internal (CPUMIPSState *env, TranslationBlock *tb,
         }
 
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -15629,7 +15629,7 @@  done_generating:
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-openrisc/translate.c b/target-openrisc/translate.c
index db977ca..06723b8 100644
--- a/target-openrisc/translate.c
+++ b/target-openrisc/translate.c
@@ -1675,7 +1675,7 @@  static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
     pc_start = tb->pc;
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
     dc->is_jmp = DISAS_NEXT;
     dc->ppc = pc_start;
     dc->pc = pc_start;
@@ -1703,7 +1703,7 @@  static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
     do {
         check_breakpoint(cpu, dc);
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (k < j) {
                 k++;
                 while (k < j) {
@@ -1784,7 +1784,7 @@  static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         k++;
         while (k <= j) {
             gen_opc_instr_start[k++] = 0;
@@ -1799,7 +1799,8 @@  static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
         qemu_log("\n");
         log_target_disas(pc_start, dc->pc - pc_start, 0);
         qemu_log("\nisize=%d osize=%td\n",
-            dc->pc - pc_start, tcg_ctx.gen_opc_ptr - gen_opc_buf);
+            dc->pc - pc_start, tcg_ctx.gen_opc_ptr -
+            tcg_ctx.gen_opc_buf);
     }
 #endif
 }
diff --git a/target-ppc/translate.c b/target-ppc/translate.c
index d30abd0..66fb0f9 100644
--- a/target-ppc/translate.c
+++ b/target-ppc/translate.c
@@ -9624,7 +9624,7 @@  static inline void gen_intermediate_code_internal(CPUPPCState *env,
     int max_insns;
 
     pc_start = tb->pc;
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
     ctx.nip = pc_start;
     ctx.tb = tb;
     ctx.exception = POWERPC_EXCP_NONE;
@@ -9675,7 +9675,7 @@  static inline void gen_intermediate_code_internal(CPUPPCState *env,
             }
         }
         if (unlikely(search_pc)) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -9777,7 +9777,7 @@  static inline void gen_intermediate_code_internal(CPUPPCState *env,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (unlikely(search_pc)) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-s390x/translate.c b/target-s390x/translate.c
index 85ba318..503855a 100644
--- a/target-s390x/translate.c
+++ b/target-s390x/translate.c
@@ -5134,7 +5134,7 @@  static inline void gen_intermediate_code_internal(CPUS390XState *env,
     dc.tb = tb;
     dc.cc_op = CC_OP_DYNAMIC;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     next_page_start = (pc_start & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE;
 
@@ -5156,7 +5156,7 @@  static inline void gen_intermediate_code_internal(CPUS390XState *env,
             }
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j) {
@@ -5209,7 +5209,7 @@  static inline void gen_intermediate_code_internal(CPUS390XState *env,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j) {
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-sh4/translate.c b/target-sh4/translate.c
index 4521c1c..cb465dd 100644
--- a/target-sh4/translate.c
+++ b/target-sh4/translate.c
@@ -1967,7 +1967,7 @@  gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
     int max_insns;
 
     pc_start = tb->pc;
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    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;
@@ -1999,7 +1999,7 @@  gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
 	    }
 	}
         if (search_pc) {
-            i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (ii < i) {
                 ii++;
                 while (ii < i)
@@ -2058,7 +2058,7 @@  gen_intermediate_code_internal(CPUSH4State * env, TranslationBlock * tb,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (search_pc) {
-        i = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         ii++;
         while (ii <= i)
             gen_opc_instr_start[ii++] = 0;
diff --git a/target-sparc/translate.c b/target-sparc/translate.c
index d179675..bfd9203 100644
--- a/target-sparc/translate.c
+++ b/target-sparc/translate.c
@@ -5257,7 +5257,7 @@  static inline void gen_intermediate_code_internal(TranslationBlock * tb,
     dc->fpu_enabled = tb_fpu_enabled(tb->flags);
     dc->address_mask_32bit = tb_am_enabled(tb->flags);
     dc->singlestep = (env->singlestep_enabled || singlestep);
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     num_insns = 0;
     max_insns = tb->cflags & CF_COUNT_MASK;
@@ -5279,7 +5279,7 @@  static inline void gen_intermediate_code_internal(TranslationBlock * tb,
         }
         if (spc) {
             qemu_log("Search PC...\n");
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j)
@@ -5336,7 +5336,7 @@  static inline void gen_intermediate_code_internal(TranslationBlock * tb,
     gen_icount_end(tb, num_insns);
     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
     if (spc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j)
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-unicore32/translate.c b/target-unicore32/translate.c
index 79bc431..bbb4763 100644
--- a/target-unicore32/translate.c
+++ b/target-unicore32/translate.c
@@ -1956,7 +1956,7 @@  static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
 
     dc->tb = tb;
 
-    gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
 
     dc->is_jmp = DISAS_NEXT;
     dc->pc = pc_start;
@@ -1999,7 +1999,7 @@  static inline void gen_intermediate_code_internal(CPUUniCore32State *env,
             }
         }
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j) {
@@ -2114,7 +2114,7 @@  done_generating:
     }
 #endif
     if (search_pc) {
-        j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+        j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
         lj++;
         while (lj <= j) {
             gen_opc_instr_start[lj++] = 0;
diff --git a/target-xtensa/translate.c b/target-xtensa/translate.c
index c7971bc..13d8620 100644
--- a/target-xtensa/translate.c
+++ b/target-xtensa/translate.c
@@ -2849,7 +2849,7 @@  static void gen_intermediate_code_internal(
     DisasContext dc;
     int insn_count = 0;
     int j, lj = -1;
-    uint16_t *gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
+    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 =
@@ -2893,7 +2893,7 @@  static void gen_intermediate_code_internal(
         check_breakpoint(env, &dc);
 
         if (search_pc) {
-            j = tcg_ctx.gen_opc_ptr - gen_opc_buf;
+            j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
             if (lj < j) {
                 lj++;
                 while (lj < j) {
diff --git a/tcg/optimize.c b/tcg/optimize.c
index 8e5d918..9109b81 100644
--- a/tcg/optimize.c
+++ b/tcg/optimize.c
@@ -484,10 +484,10 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
     nb_globals = s->nb_globals;
     memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
 
-    nb_ops = tcg_opc_ptr - gen_opc_buf;
+    nb_ops = tcg_opc_ptr - s->gen_opc_buf;
     gen_args = args;
     for (op_index = 0; op_index < nb_ops; op_index++) {
-        op = gen_opc_buf[op_index];
+        op = s->gen_opc_buf[op_index];
         def = &tcg_op_defs[op];
         /* Do copy propagation */
         if (op == INDEX_op_call) {
@@ -569,7 +569,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(rotr):
             if (temps[args[1]].state == TCG_TEMP_CONST
                 && temps[args[1]].val == 0) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tcg_opt_gen_movi(gen_args, args[0], 0);
                 args += 3;
                 gen_args += 2;
@@ -598,9 +598,9 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
             if (temps[args[2]].state == TCG_TEMP_CONST
                 && temps[args[2]].val == 0) {
                 if (temps_are_copies(args[0], args[1])) {
-                    gen_opc_buf[op_index] = INDEX_op_nop;
+                    s->gen_opc_buf[op_index] = INDEX_op_nop;
                 } else {
-                    gen_opc_buf[op_index] = op_to_mov(op);
+                    s->gen_opc_buf[op_index] = op_to_mov(op);
                     tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
                     gen_args += 2;
                 }
@@ -618,7 +618,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(mul):
             if ((temps[args[2]].state == TCG_TEMP_CONST
                 && temps[args[2]].val == 0)) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tcg_opt_gen_movi(gen_args, args[0], 0);
                 args += 3;
                 gen_args += 2;
@@ -635,9 +635,9 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(and):
             if (temps_are_copies(args[1], args[2])) {
                 if (temps_are_copies(args[0], args[1])) {
-                    gen_opc_buf[op_index] = INDEX_op_nop;
+                    s->gen_opc_buf[op_index] = INDEX_op_nop;
                 } else {
-                    gen_opc_buf[op_index] = op_to_mov(op);
+                    s->gen_opc_buf[op_index] = op_to_mov(op);
                     tcg_opt_gen_mov(s, gen_args, args[0], args[1]);
                     gen_args += 2;
                 }
@@ -654,7 +654,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(sub):
         CASE_OP_32_64(xor):
             if (temps_are_copies(args[1], args[2])) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tcg_opt_gen_movi(gen_args, args[0], 0);
                 gen_args += 2;
                 args += 3;
@@ -672,7 +672,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(mov):
             if (temps_are_copies(args[0], args[1])) {
                 args += 2;
-                gen_opc_buf[op_index] = INDEX_op_nop;
+                s->gen_opc_buf[op_index] = INDEX_op_nop;
                 break;
             }
             if (temps[args[1]].state != TCG_TEMP_CONST) {
@@ -684,7 +684,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
             /* Source argument is constant.  Rewrite the operation and
                let movi case handle it. */
             op = op_to_movi(op);
-            gen_opc_buf[op_index] = op;
+            s->gen_opc_buf[op_index] = op;
             args[1] = temps[args[1]].val;
             /* fallthrough */
         CASE_OP_32_64(movi):
@@ -702,7 +702,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         case INDEX_op_ext32s_i64:
         case INDEX_op_ext32u_i64:
             if (temps[args[1]].state == TCG_TEMP_CONST) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tmp = do_constant_folding(op, temps[args[1]].val, 0);
                 tcg_opt_gen_movi(gen_args, args[0], tmp);
                 gen_args += 2;
@@ -729,7 +729,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(nor):
             if (temps[args[1]].state == TCG_TEMP_CONST
                 && temps[args[2]].state == TCG_TEMP_CONST) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tmp = do_constant_folding(op, temps[args[1]].val,
                                           temps[args[2]].val);
                 tcg_opt_gen_movi(gen_args, args[0], tmp);
@@ -742,7 +742,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(deposit):
             if (temps[args[1]].state == TCG_TEMP_CONST
                 && temps[args[2]].state == TCG_TEMP_CONST) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tmp = ((1ull << args[4]) - 1);
                 tmp = (temps[args[1]].val & ~(tmp << args[3]))
                       | ((temps[args[2]].val & tmp) << args[3]);
@@ -756,7 +756,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         CASE_OP_32_64(setcond):
             tmp = do_constant_folding_cond(op, args[1], args[2], args[3]);
             if (tmp != 2) {
-                gen_opc_buf[op_index] = op_to_movi(op);
+                s->gen_opc_buf[op_index] = op_to_movi(op);
                 tcg_opt_gen_movi(gen_args, args[0], tmp);
                 gen_args += 2;
                 args += 4;
@@ -769,11 +769,11 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
             if (tmp != 2) {
                 if (tmp) {
                     memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
-                    gen_opc_buf[op_index] = INDEX_op_br;
+                    s->gen_opc_buf[op_index] = INDEX_op_br;
                     gen_args[0] = args[3];
                     gen_args += 1;
                 } else {
-                    gen_opc_buf[op_index] = INDEX_op_nop;
+                    s->gen_opc_buf[op_index] = INDEX_op_nop;
                 }
                 args += 4;
                 break;
@@ -784,13 +784,13 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
             tmp = do_constant_folding_cond(op, args[1], args[2], args[5]);
             if (tmp != 2) {
                 if (temps_are_copies(args[0], args[4-tmp])) {
-                    gen_opc_buf[op_index] = INDEX_op_nop;
+                    s->gen_opc_buf[op_index] = INDEX_op_nop;
                 } else if (temps[args[4-tmp]].state == TCG_TEMP_CONST) {
-                    gen_opc_buf[op_index] = op_to_movi(op);
+                    s->gen_opc_buf[op_index] = op_to_movi(op);
                     tcg_opt_gen_movi(gen_args, args[0], temps[args[4-tmp]].val);
                     gen_args += 2;
                 } else {
-                    gen_opc_buf[op_index] = op_to_mov(op);
+                    s->gen_opc_buf[op_index] = op_to_mov(op);
                     tcg_opt_gen_mov(s, gen_args, args[0], args[4-tmp]);
                     gen_args += 2;
                 }
@@ -820,12 +820,12 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
                 }
 
                 /* We emit the extra nop when we emit the add2/sub2.  */
-                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
+                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
 
                 rl = args[0];
                 rh = args[1];
-                gen_opc_buf[op_index] = INDEX_op_movi_i32;
-                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
+                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
+                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
                 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)a);
                 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(a >> 32));
                 gen_args += 4;
@@ -843,12 +843,12 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
                 TCGArg rl, rh;
 
                 /* We emit the extra nop when we emit the mulu2.  */
-                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
+                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
 
                 rl = args[0];
                 rh = args[1];
-                gen_opc_buf[op_index] = INDEX_op_movi_i32;
-                gen_opc_buf[++op_index] = INDEX_op_movi_i32;
+                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
+                s->gen_opc_buf[++op_index] = INDEX_op_movi_i32;
                 tcg_opt_gen_movi(&gen_args[0], rl, (uint32_t)r);
                 tcg_opt_gen_movi(&gen_args[2], rh, (uint32_t)(r >> 32));
                 gen_args += 4;
@@ -862,11 +862,11 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
             if (tmp != 2) {
                 if (tmp) {
                     memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
-                    gen_opc_buf[op_index] = INDEX_op_br;
+                    s->gen_opc_buf[op_index] = INDEX_op_br;
                     gen_args[0] = args[5];
                     gen_args += 1;
                 } else {
-                    gen_opc_buf[op_index] = INDEX_op_nop;
+                    s->gen_opc_buf[op_index] = INDEX_op_nop;
                 }
             } else if ((args[4] == TCG_COND_LT || args[4] == TCG_COND_GE)
                        && temps[args[2]].state == TCG_TEMP_CONST
@@ -876,7 +876,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
                 /* Simplify LT/GE comparisons vs zero to a single compare
                    vs the high word of the input.  */
                 memset(temps, 0, nb_temps * sizeof(struct tcg_temp_info));
-                gen_opc_buf[op_index] = INDEX_op_brcond_i32;
+                s->gen_opc_buf[op_index] = INDEX_op_brcond_i32;
                 gen_args[0] = args[1];
                 gen_args[1] = args[3];
                 gen_args[2] = args[4];
@@ -891,7 +891,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
         case INDEX_op_setcond2_i32:
             tmp = do_constant_folding_cond2(&args[1], &args[3], args[5]);
             if (tmp != 2) {
-                gen_opc_buf[op_index] = INDEX_op_movi_i32;
+                s->gen_opc_buf[op_index] = INDEX_op_movi_i32;
                 tcg_opt_gen_movi(gen_args, args[0], tmp);
                 gen_args += 2;
             } else if ((args[5] == TCG_COND_LT || args[5] == TCG_COND_GE)
@@ -901,7 +901,7 @@  static TCGArg *tcg_constant_folding(TCGContext *s, uint16_t *tcg_opc_ptr,
                        && temps[args[4]].val == 0) {
                 /* Simplify LT/GE comparisons vs zero to a single compare
                    vs the high word of the input.  */
-                gen_opc_buf[op_index] = INDEX_op_setcond_i32;
+                s->gen_opc_buf[op_index] = INDEX_op_setcond_i32;
                 gen_args[0] = args[0];
                 gen_args[1] = args[2];
                 gen_args[2] = args[4];
diff --git a/tcg/tcg.c b/tcg/tcg.c
index 4e650c8..ea27bd4 100644
--- a/tcg/tcg.c
+++ b/tcg/tcg.c
@@ -297,7 +297,7 @@  void tcg_func_start(TCGContext *s)
     s->goto_tb_issue_mask = 0;
 #endif
 
-    s->gen_opc_ptr = gen_opc_buf;
+    s->gen_opc_ptr = s->gen_opc_buf;
     s->gen_opparam_ptr = gen_opparam_buf;
 
 #if defined(CONFIG_QEMU_LDST_OPTIMIZATION) && defined(CONFIG_SOFTMMU)
@@ -896,7 +896,7 @@  void tcg_dump_ops(TCGContext *s)
     char buf[128];
 
     first_insn = 1;
-    opc_ptr = gen_opc_buf;
+    opc_ptr = s->gen_opc_buf;
     args = gen_opparam_buf;
     while (opc_ptr < s->gen_opc_ptr) {
         c = *opc_ptr++;
@@ -1231,7 +1231,7 @@  static void tcg_liveness_analysis(TCGContext *s)
     
     s->gen_opc_ptr++; /* skip end */
 
-    nb_ops = s->gen_opc_ptr - gen_opc_buf;
+    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
 
     s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
     s->op_sync_args = tcg_malloc(nb_ops * sizeof(uint8_t));
@@ -1243,7 +1243,7 @@  static void tcg_liveness_analysis(TCGContext *s)
     args = s->gen_opparam_ptr;
     op_index = nb_ops - 1;
     while (op_index >= 0) {
-        op = gen_opc_buf[op_index];
+        op = s->gen_opc_buf[op_index];
         def = &tcg_op_defs[op];
         switch(op) {
         case INDEX_op_call:
@@ -1266,7 +1266,7 @@  static void tcg_liveness_analysis(TCGContext *s)
                             goto do_not_remove_call;
                         }
                     }
-                    tcg_set_nop(s, gen_opc_buf + op_index, 
+                    tcg_set_nop(s, s->gen_opc_buf + op_index,
                                 args - 1, nb_args);
                 } else {
                 do_not_remove_call:
@@ -1347,11 +1347,11 @@  static void tcg_liveness_analysis(TCGContext *s)
                 } else {
                     op = INDEX_op_sub_i32;
                 }
-                gen_opc_buf[op_index] = op;
+                s->gen_opc_buf[op_index] = op;
                 args[1] = args[2];
                 args[2] = args[4];
-                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
-                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 3);
+                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
+                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 3);
                 /* Fall through and mark the single-word operation live.  */
                 nb_iargs = 2;
                 nb_oargs = 1;
@@ -1367,11 +1367,11 @@  static void tcg_liveness_analysis(TCGContext *s)
                 if (dead_temps[args[0]] && !mem_temps[0]) {
                     goto do_remove;
                 }
-                gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
+                s->gen_opc_buf[op_index] = op = INDEX_op_mul_i32;
                 args[1] = args[2];
                 args[2] = args[3];
-                assert(gen_opc_buf[op_index + 1] == INDEX_op_nop);
-                tcg_set_nop(s, gen_opc_buf + op_index + 1, args + 3, 1);
+                assert(s->gen_opc_buf[op_index + 1] == INDEX_op_nop);
+                tcg_set_nop(s, s->gen_opc_buf + op_index + 1, args + 3, 1);
                 /* Fall through and mark the single-word operation live.  */
                 nb_oargs = 1;
             }
@@ -1394,7 +1394,7 @@  static void tcg_liveness_analysis(TCGContext *s)
                     }
                 }
             do_remove:
-                tcg_set_nop(s, gen_opc_buf + op_index, args, def->nb_args);
+                tcg_set_nop(s, s->gen_opc_buf + op_index, args, def->nb_args);
 #ifdef CONFIG_PROFILER
                 s->del_op_count++;
 #endif
@@ -1448,7 +1448,7 @@  static void tcg_liveness_analysis(TCGContext *s)
 static void tcg_liveness_analysis(TCGContext *s)
 {
     int nb_ops;
-    nb_ops = s->gen_opc_ptr - gen_opc_buf;
+    nb_ops = s->gen_opc_ptr - s->gen_opc_buf;
 
     s->op_dead_args = tcg_malloc(nb_ops * sizeof(uint16_t));
     memset(s->op_dead_args, 0, nb_ops * sizeof(uint16_t));
@@ -2253,7 +2253,7 @@  static inline int tcg_gen_code_common(TCGContext *s, uint8_t *gen_code_buf,
     op_index = 0;
 
     for(;;) {
-        opc = gen_opc_buf[op_index];
+        opc = s->gen_opc_buf[op_index];
 #ifdef CONFIG_PROFILER
         tcg_table_op_count[opc]++;
 #endif
@@ -2334,7 +2334,7 @@  int tcg_gen_code(TCGContext *s, uint8_t *gen_code_buf)
 #ifdef CONFIG_PROFILER
     {
         int n;
-        n = (s->gen_opc_ptr - gen_opc_buf);
+        n = (s->gen_opc_ptr - s->gen_opc_buf);
         s->op_count += n;
         if (n > s->op_count_max)
             s->op_count_max = n;