Diff for /qemu/cpu-exec.c between versions 1.1.1.14 and 1.1.1.16

version 1.1.1.14, 2018/04/24 18:55:50 version 1.1.1.16, 2018/04/24 19:34:01
Line 1 Line 1
 /*  /*
  *  i386 emulator main execution loop   *  emulator main execution loop
  *   *
  *  Copyright (c) 2003-2005 Fabrice Bellard   *  Copyright (c) 2003-2005 Fabrice Bellard
  *   *
Line 21 Line 21
 #include "disas.h"  #include "disas.h"
 #include "tcg.h"  #include "tcg.h"
 #include "qemu-barrier.h"  #include "qemu-barrier.h"
   #include "qtest.h"
   
 int tb_invalidated_flag;  int tb_invalidated_flag;
   
 //#define CONFIG_DEBUG_EXEC  //#define CONFIG_DEBUG_EXEC
   
 bool qemu_cpu_has_work(CPUState *env)  bool qemu_cpu_has_work(CPUArchState *env)
 {  {
     return cpu_has_work(env);      return cpu_has_work(env);
 }  }
   
 void cpu_loop_exit(CPUState *env)  void cpu_loop_exit(CPUArchState *env)
 {  {
     env->current_tb = NULL;      env->current_tb = NULL;
     longjmp(env->jmp_env, 1);      longjmp(env->jmp_env, 1);
Line 41  void cpu_loop_exit(CPUState *env) Line 42  void cpu_loop_exit(CPUState *env)
    restored in a state compatible with the CPU emulator     restored in a state compatible with the CPU emulator
  */   */
 #if defined(CONFIG_SOFTMMU)  #if defined(CONFIG_SOFTMMU)
 void cpu_resume_from_signal(CPUState *env, void *puc)  void cpu_resume_from_signal(CPUArchState *env, void *puc)
 {  {
     /* XXX: restore cpu registers saved in host registers */      /* XXX: restore cpu registers saved in host registers */
   
Line 52  void cpu_resume_from_signal(CPUState *en Line 53  void cpu_resume_from_signal(CPUState *en
   
 /* Execute the code without caching the generated code. An interpreter  /* Execute the code without caching the generated code. An interpreter
    could be used if available. */     could be used if available. */
 static void cpu_exec_nocache(CPUState *env, int max_cycles,  static void cpu_exec_nocache(CPUArchState *env, int max_cycles,
                              TranslationBlock *orig_tb)                               TranslationBlock *orig_tb)
 {  {
     unsigned long next_tb;      tcg_target_ulong next_tb;
     TranslationBlock *tb;      TranslationBlock *tb;
   
     /* Should never happen.      /* Should never happen.
Line 79  static void cpu_exec_nocache(CPUState *e Line 80  static void cpu_exec_nocache(CPUState *e
     tb_free(tb);      tb_free(tb);
 }  }
   
 static TranslationBlock *tb_find_slow(CPUState *env,  static TranslationBlock *tb_find_slow(CPUArchState *env,
                                       target_ulong pc,                                        target_ulong pc,
                                       target_ulong cs_base,                                        target_ulong cs_base,
                                       uint64_t flags)                                        uint64_t flags)
 {  {
     TranslationBlock *tb, **ptb1;      TranslationBlock *tb, **ptb1;
     unsigned int h;      unsigned int h;
     tb_page_addr_t phys_pc, phys_page1, phys_page2;      tb_page_addr_t phys_pc, phys_page1;
     target_ulong virt_page2;      target_ulong virt_page2;
   
     tb_invalidated_flag = 0;      tb_invalidated_flag = 0;
Line 94  static TranslationBlock *tb_find_slow(CP Line 95  static TranslationBlock *tb_find_slow(CP
     /* find translated block using physical mappings */      /* find translated block using physical mappings */
     phys_pc = get_page_addr_code(env, pc);      phys_pc = get_page_addr_code(env, pc);
     phys_page1 = phys_pc & TARGET_PAGE_MASK;      phys_page1 = phys_pc & TARGET_PAGE_MASK;
     phys_page2 = -1;  
     h = tb_phys_hash_func(phys_pc);      h = tb_phys_hash_func(phys_pc);
     ptb1 = &tb_phys_hash[h];      ptb1 = &tb_phys_hash[h];
     for(;;) {      for(;;) {
Line 107  static TranslationBlock *tb_find_slow(CP Line 107  static TranslationBlock *tb_find_slow(CP
             tb->flags == flags) {              tb->flags == flags) {
             /* check next page if needed */              /* check next page if needed */
             if (tb->page_addr[1] != -1) {              if (tb->page_addr[1] != -1) {
                   tb_page_addr_t phys_page2;
   
                 virt_page2 = (pc & TARGET_PAGE_MASK) +                  virt_page2 = (pc & TARGET_PAGE_MASK) +
                     TARGET_PAGE_SIZE;                      TARGET_PAGE_SIZE;
                 phys_page2 = get_page_addr_code(env, virt_page2);                  phys_page2 = get_page_addr_code(env, virt_page2);
Line 134  static TranslationBlock *tb_find_slow(CP Line 136  static TranslationBlock *tb_find_slow(CP
     return tb;      return tb;
 }  }
   
 static inline TranslationBlock *tb_find_fast(CPUState *env)  static inline TranslationBlock *tb_find_fast(CPUArchState *env)
 {  {
     TranslationBlock *tb;      TranslationBlock *tb;
     target_ulong cs_base, pc;      target_ulong cs_base, pc;
Line 162  CPUDebugExcpHandler *cpu_set_debug_excp_ Line 164  CPUDebugExcpHandler *cpu_set_debug_excp_
     return old_handler;      return old_handler;
 }  }
   
 static void cpu_handle_debug_exception(CPUState *env)  static void cpu_handle_debug_exception(CPUArchState *env)
 {  {
     CPUWatchpoint *wp;      CPUWatchpoint *wp;
   
Line 180  static void cpu_handle_debug_exception(C Line 182  static void cpu_handle_debug_exception(C
   
 volatile sig_atomic_t exit_request;  volatile sig_atomic_t exit_request;
   
 int cpu_exec(CPUState *env)  int cpu_exec(CPUArchState *env)
 {  {
     int ret, interrupt_request;      int ret, interrupt_request;
     TranslationBlock *tb;      TranslationBlock *tb;
     uint8_t *tc_ptr;      uint8_t *tc_ptr;
     unsigned long next_tb;      tcg_target_ulong next_tb;
   
     if (env->halted) {      if (env->halted) {
         if (!cpu_has_work(env)) {          if (!cpu_has_work(env)) {
Line 216  int cpu_exec(CPUState *env) Line 218  int cpu_exec(CPUState *env)
 #elif defined(TARGET_ARM)  #elif defined(TARGET_ARM)
 #elif defined(TARGET_UNICORE32)  #elif defined(TARGET_UNICORE32)
 #elif defined(TARGET_PPC)  #elif defined(TARGET_PPC)
       env->reserve_addr = -1;
 #elif defined(TARGET_LM32)  #elif defined(TARGET_LM32)
 #elif defined(TARGET_MICROBLAZE)  #elif defined(TARGET_MICROBLAZE)
 #elif defined(TARGET_MIPS)  #elif defined(TARGET_MIPS)
 #elif defined(TARGET_SH4)  #elif defined(TARGET_SH4)
 #elif defined(TARGET_CRIS)  #elif defined(TARGET_CRIS)
 #elif defined(TARGET_S390X)  #elif defined(TARGET_S390X)
   #elif defined(TARGET_XTENSA)
     /* XXXXX */      /* XXXXX */
 #else  #else
 #error unsupported target CPU  #error unsupported target CPU
Line 301  int cpu_exec(CPUState *env) Line 305  int cpu_exec(CPUState *env)
                             env->hflags2 |= HF2_NMI_MASK;                              env->hflags2 |= HF2_NMI_MASK;
                             do_interrupt_x86_hardirq(env, EXCP02_NMI, 1);                              do_interrupt_x86_hardirq(env, EXCP02_NMI, 1);
                             next_tb = 0;                              next_tb = 0;
                         } else if (interrupt_request & CPU_INTERRUPT_MCE) {                          } else if (interrupt_request & CPU_INTERRUPT_MCE) {
                             env->interrupt_request &= ~CPU_INTERRUPT_MCE;                              env->interrupt_request &= ~CPU_INTERRUPT_MCE;
                             do_interrupt_x86_hardirq(env, EXCP12_MCHK, 0);                              do_interrupt_x86_hardirq(env, EXCP12_MCHK, 0);
                             next_tb = 0;                              next_tb = 0;
Line 336  int cpu_exec(CPUState *env) Line 340  int cpu_exec(CPUState *env)
                         }                          }
                     }                      }
 #elif defined(TARGET_PPC)  #elif defined(TARGET_PPC)
 #if 0  
                     if ((interrupt_request & CPU_INTERRUPT_RESET)) {                      if ((interrupt_request & CPU_INTERRUPT_RESET)) {
                         cpu_reset(env);                          cpu_state_reset(env);
                     }                      }
 #endif  
                     if (interrupt_request & CPU_INTERRUPT_HARD) {                      if (interrupt_request & CPU_INTERRUPT_HARD) {
                         ppc_hw_interrupt(env);                          ppc_hw_interrupt(env);
                         if (env->pending_interrupts == 0)                          if (env->pending_interrupts == 0)
Line 387  int cpu_exec(CPUState *env) Line 389  int cpu_exec(CPUState *env)
                                 next_tb = 0;                                  next_tb = 0;
                             }                              }
                         }                          }
                     }                      }
 #elif defined(TARGET_ARM)  #elif defined(TARGET_ARM)
                     if (interrupt_request & CPU_INTERRUPT_FIQ                      if (interrupt_request & CPU_INTERRUPT_FIQ
                         && !(env->uncached_cpsr & CPSR_F)) {                          && !(env->uncached_cpsr & CPSR_F)) {
Line 426  int cpu_exec(CPUState *env) Line 428  int cpu_exec(CPUState *env)
                     {                      {
                         int idx = -1;                          int idx = -1;
                         /* ??? This hard-codes the OSF/1 interrupt levels.  */                          /* ??? This hard-codes the OSF/1 interrupt levels.  */
                         switch (env->pal_mode ? 7 : env->ps & PS_INT_MASK) {                          switch (env->pal_mode ? 7 : env->ps & PS_INT_MASK) {
                         case 0 ... 3:                          case 0 ... 3:
                             if (interrupt_request & CPU_INTERRUPT_HARD) {                              if (interrupt_request & CPU_INTERRUPT_HARD) {
                                 idx = EXCP_DEV_INTERRUPT;                                  idx = EXCP_DEV_INTERRUPT;
Line 487  int cpu_exec(CPUState *env) Line 489  int cpu_exec(CPUState *env)
                         do_interrupt(env);                          do_interrupt(env);
                         next_tb = 0;                          next_tb = 0;
                     }                      }
   #elif defined(TARGET_XTENSA)
                       if (interrupt_request & CPU_INTERRUPT_HARD) {
                           env->exception_index = EXC_IRQ;
                           do_interrupt(env);
                           next_tb = 0;
                       }
 #endif  #endif
                    /* Don't use the cached interrupt_request value,                     /* Don't use the cached interrupt_request value,
                       do_interrupt may have updated the EXITTB flag. */                        do_interrupt may have updated the EXITTB flag. */
Line 533  int cpu_exec(CPUState *env) Line 541  int cpu_exec(CPUState *env)
                     tb_invalidated_flag = 0;                      tb_invalidated_flag = 0;
                 }                  }
 #ifdef CONFIG_DEBUG_EXEC  #ifdef CONFIG_DEBUG_EXEC
                 qemu_log_mask(CPU_LOG_EXEC, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",                  qemu_log_mask(CPU_LOG_EXEC, "Trace %p [" TARGET_FMT_lx "] %s\n",
                              (long)tb->tc_ptr, tb->pc,                               tb->tc_ptr, tb->pc,
                              lookup_symbol(tb->pc));                               lookup_symbol(tb->pc));
 #endif  #endif
                 /* see if we can patch the calling TB. When the TB                  /* see if we can patch the calling TB. When the TB
Line 553  int cpu_exec(CPUState *env) Line 561  int cpu_exec(CPUState *env)
                 barrier();                  barrier();
                 if (likely(!env->exit_request)) {                  if (likely(!env->exit_request)) {
                     tc_ptr = tb->tc_ptr;                      tc_ptr = tb->tc_ptr;
                 /* execute the generated code */                      /* execute the generated code */
                     next_tb = tcg_qemu_tb_exec(env, tc_ptr);                      next_tb = tcg_qemu_tb_exec(env, tc_ptr);
                     if ((next_tb & 3) == 2) {                      if ((next_tb & 3) == 2) {
                         /* Instruction counter expired.  */                          /* Instruction counter expired.  */
                         int insns_left;                          int insns_left;
                         tb = (TranslationBlock *)(long)(next_tb & ~3);                          tb = (TranslationBlock *)(next_tb & ~3);
                         /* Restore PC.  */                          /* Restore PC.  */
                         cpu_pc_from_tb(env, tb);                          cpu_pc_from_tb(env, tb);
                         insns_left = env->icount_decr.u32;                          insns_left = env->icount_decr.u32;
Line 616  int cpu_exec(CPUState *env) Line 624  int cpu_exec(CPUState *env)
 #elif defined(TARGET_ALPHA)  #elif defined(TARGET_ALPHA)
 #elif defined(TARGET_CRIS)  #elif defined(TARGET_CRIS)
 #elif defined(TARGET_S390X)  #elif defined(TARGET_S390X)
   #elif defined(TARGET_XTENSA)
     /* XXXXX */      /* XXXXX */
 #else  #else
 #error unsupported target CPU  #error unsupported target CPU

Removed from v.1.1.1.14  
changed lines
  Added in v.1.1.1.16


unix.superglobalmegacorp.com