Diff for /qemu/translate-all.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 16:44:52 version 1.1.1.4, 2018/04/24 16:47:16
Line 1 Line 1
 /*  /*
  *  Host code generation   *  Host code generation
  *    *
  *  Copyright (c) 2003 Fabrice Bellard   *  Copyright (c) 2003 Fabrice Bellard
  *   *
  * This library is free software; you can redistribute it and/or   * This library is free software; you can redistribute it and/or
Line 53  uint8_t gen_opc_cc_op[OPC_BUF_SIZE]; Line 53  uint8_t gen_opc_cc_op[OPC_BUF_SIZE];
 #elif defined(TARGET_SPARC)  #elif defined(TARGET_SPARC)
 target_ulong gen_opc_npc[OPC_BUF_SIZE];  target_ulong gen_opc_npc[OPC_BUF_SIZE];
 target_ulong gen_opc_jump_pc[2];  target_ulong gen_opc_jump_pc[2];
 #elif defined(TARGET_MIPS)  #elif defined(TARGET_MIPS) || defined(TARGET_SH4)
 uint32_t gen_opc_hflags[OPC_BUF_SIZE];  uint32_t gen_opc_hflags[OPC_BUF_SIZE];
 #endif  #endif
   
Line 89  void dump_ops(const uint16_t *opc_buf, c Line 89  void dump_ops(const uint16_t *opc_buf, c
     for(;;) {      for(;;) {
         c = *opc_ptr++;          c = *opc_ptr++;
         n = op_nb_args[c];          n = op_nb_args[c];
         fprintf(logfile, "0x%04x: %s",           fprintf(logfile, "0x%04x: %s",
                 (int)(opc_ptr - opc_buf - 1), op_str[c]);                  (int)(opc_ptr - opc_buf - 1), op_str[c]);
         for(i = 0; i < n; i++) {          for(i = 0; i < n; i++) {
             fprintf(logfile, " 0x%x", opparam_ptr[i]);              fprintf(logfile, " 0x%x", opparam_ptr[i]);
Line 110  static void dyngen_labels(long *gen_labe Line 110  static void dyngen_labels(long *gen_labe
     uint8_t *gen_code_ptr;      uint8_t *gen_code_ptr;
     int c, i;      int c, i;
     unsigned long gen_code_addr[OPC_BUF_SIZE];      unsigned long gen_code_addr[OPC_BUF_SIZE];
       
     if (nb_gen_labels == 0)      if (nb_gen_labels == 0)
         return;          return;
     /* compute the address of each op code */      /* compute the address of each op code */
       
     gen_code_ptr = gen_code_buf;      gen_code_ptr = gen_code_buf;
     i = 0;      i = 0;
     for(;;) {      for(;;) {
Line 125  static void dyngen_labels(long *gen_labe Line 125  static void dyngen_labels(long *gen_labe
         gen_code_ptr += opc_copy_size[c];          gen_code_ptr += opc_copy_size[c];
         i++;          i++;
     }      }
       
     /* compute the address of each label */      /* compute the address of each label */
     for(i = 0; i < nb_gen_labels; i++) {      for(i = 0; i < nb_gen_labels; i++) {
         gen_labels[i] = gen_code_addr[gen_labels[i]];          gen_labels[i] = gen_code_addr[gen_labels[i]];
     }      }
 }  }
   
   unsigned long code_gen_max_block_size(void)
   {
       static unsigned long max;
   
       if (max == 0) {
   #define DEF(s, n, copy_size) max = copy_size > max? copy_size : max;
   #include "opc.h"
   #undef DEF
           max *= OPC_MAX_SIZE;
       }
   
       return max;
   }
   
 /* return non zero if the very first instruction is invalid so that  /* return non zero if the very first instruction is invalid so that
    the virtual CPU can trigger an exception.      the virtual CPU can trigger an exception.
   
    '*gen_code_size_ptr' contains the size of the generated code (host     '*gen_code_size_ptr' contains the size of the generated code (host
    code).     code).
 */  */
 int cpu_gen_code(CPUState *env, TranslationBlock *tb,  int cpu_gen_code(CPUState *env, TranslationBlock *tb, int *gen_code_size_ptr)
                  int max_code_size, int *gen_code_size_ptr)  
 {  {
     uint8_t *gen_code_buf;      uint8_t *gen_code_buf;
     int gen_code_size;      int gen_code_size;
   
 #ifdef USE_CODE_COPY      if (gen_intermediate_code(env, tb) < 0)
     if (code_copy_enabled &&          return -1;
         cpu_gen_code_copy(env, tb, max_code_size, &gen_code_size) == 0) {      
         /* nothing more to do */      /* generate machine code */
     } else      tb->tb_next_offset[0] = 0xffff;
 #endif      tb->tb_next_offset[1] = 0xffff;
     {      gen_code_buf = tb->tc_ptr;
         if (gen_intermediate_code(env, tb) < 0)  
             return -1;  
   
         /* generate machine code */  
         tb->tb_next_offset[0] = 0xffff;  
         tb->tb_next_offset[1] = 0xffff;  
         gen_code_buf = tb->tc_ptr;  
 #ifdef USE_DIRECT_JUMP  #ifdef USE_DIRECT_JUMP
         /* the following two entries are optional (only used for string ops) */      /* the following two entries are optional (only used for string ops) */
         tb->tb_jmp_offset[2] = 0xffff;      tb->tb_jmp_offset[2] = 0xffff;
         tb->tb_jmp_offset[3] = 0xffff;      tb->tb_jmp_offset[3] = 0xffff;
 #endif  #endif
         dyngen_labels(gen_labels, nb_gen_labels, gen_code_buf, gen_opc_buf);      dyngen_labels(gen_labels, nb_gen_labels, gen_code_buf, gen_opc_buf);
       
         gen_code_size = dyngen_code(gen_code_buf, tb->tb_next_offset,      gen_code_size = dyngen_code(gen_code_buf, tb->tb_next_offset,
 #ifdef USE_DIRECT_JUMP  #ifdef USE_DIRECT_JUMP
                                     tb->tb_jmp_offset,                                  tb->tb_jmp_offset,
 #else  #else
                                     NULL,                                  NULL,
 #endif  #endif
                                     gen_opc_buf, gen_opparam_buf, gen_labels);                                  gen_opc_buf, gen_opparam_buf, gen_labels);
     }  
     *gen_code_size_ptr = gen_code_size;      *gen_code_size_ptr = gen_code_size;
 #ifdef DEBUG_DISAS  #ifdef DEBUG_DISAS
     if (loglevel & CPU_LOG_TB_OUT_ASM) {      if (loglevel & CPU_LOG_TB_OUT_ASM) {
Line 185  int cpu_gen_code(CPUState *env, Translat Line 190  int cpu_gen_code(CPUState *env, Translat
     return 0;      return 0;
 }  }
   
 /* The cpu state corresponding to 'searched_pc' is restored.   /* The cpu state corresponding to 'searched_pc' is restored.
  */   */
 int cpu_restore_state(TranslationBlock *tb,   int cpu_restore_state(TranslationBlock *tb,
                       CPUState *env, unsigned long searched_pc,                        CPUState *env, unsigned long searched_pc,
                       void *puc)                        void *puc)
 {  {
Line 195  int cpu_restore_state(TranslationBlock * Line 200  int cpu_restore_state(TranslationBlock *
     unsigned long tc_ptr;      unsigned long tc_ptr;
     uint16_t *opc_ptr;      uint16_t *opc_ptr;
   
 #ifdef USE_CODE_COPY  
     if (tb->cflags & CF_CODE_COPY) {  
         return cpu_restore_state_copy(tb, env, searched_pc, puc);  
     }  
 #endif  
     if (gen_intermediate_code_pc(env, tb) < 0)      if (gen_intermediate_code_pc(env, tb) < 0)
         return -1;          return -1;
       
     /* find opc index corresponding to search_pc */      /* find opc index corresponding to search_pc */
     tc_ptr = (unsigned long)tb->tc_ptr;      tc_ptr = (unsigned long)tb->tc_ptr;
     if (searched_pc < tc_ptr)      if (searched_pc < tc_ptr)
Line 234  int cpu_restore_state(TranslationBlock * Line 234  int cpu_restore_state(TranslationBlock *
                     fprintf(logfile, "0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);                      fprintf(logfile, "0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
                 }                  }
             }              }
             fprintf(logfile, "spc=0x%08lx j=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",               fprintf(logfile, "spc=0x%08lx j=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
                     searched_pc, j, gen_opc_pc[j] - tb->cs_base,                       searched_pc, j, gen_opc_pc[j] - tb->cs_base,
                     (uint32_t)tb->cs_base);                      (uint32_t)tb->cs_base);
         }          }
 #endif  #endif
Line 254  int cpu_restore_state(TranslationBlock * Line 254  int cpu_restore_state(TranslationBlock *
         if (npc == 1) {          if (npc == 1) {
             /* dynamic NPC: already stored */              /* dynamic NPC: already stored */
         } else if (npc == 2) {          } else if (npc == 2) {
             target_ulong t2 = (target_ulong)puc;              target_ulong t2 = (target_ulong)(unsigned long)puc;
             /* jump PC: use T2 and the jump targets of the translation */              /* jump PC: use T2 and the jump targets of the translation */
             if (t2)               if (t2)
                 env->npc = gen_opc_jump_pc[0];                  env->npc = gen_opc_jump_pc[0];
             else              else
                 env->npc = gen_opc_jump_pc[1];                  env->npc = gen_opc_jump_pc[1];
Line 277  int cpu_restore_state(TranslationBlock * Line 277  int cpu_restore_state(TranslationBlock *
 #else  #else
 #define CASE3(op)\  #define CASE3(op)\
         case INDEX_op_ ## op ## _user:\          case INDEX_op_ ## op ## _user:\
         case INDEX_op_ ## op ## _kernel          case INDEX_op_ ## op ## _kernel:\
           case INDEX_op_ ## op ## _hypv
 #endif  #endif
               
         CASE3(stfd):          CASE3(stfd):
         CASE3(stfs):          CASE3(stfs):
         CASE3(lfd):          CASE3(lfd):
Line 305  int cpu_restore_state(TranslationBlock * Line 306  int cpu_restore_state(TranslationBlock *
 #elif defined(TARGET_M68K)  #elif defined(TARGET_M68K)
     env->pc = gen_opc_pc[j];      env->pc = gen_opc_pc[j];
 #elif defined(TARGET_MIPS)  #elif defined(TARGET_MIPS)
     env->PC = gen_opc_pc[j];      env->PC[env->current_tc] = gen_opc_pc[j];
     env->hflags &= ~MIPS_HFLAG_BMASK;      env->hflags &= ~MIPS_HFLAG_BMASK;
     env->hflags |= gen_opc_hflags[j];      env->hflags |= gen_opc_hflags[j];
   #elif defined(TARGET_ALPHA)
       env->pc = gen_opc_pc[j];
   #elif defined(TARGET_SH4)
       env->pc = gen_opc_pc[j];
       env->flags = gen_opc_hflags[j];
 #endif  #endif
     return 0;      return 0;
 }  }

Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4


unix.superglobalmegacorp.com