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

version 1.1.1.15, 2018/04/24 19:16:54 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)
Line 135  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 163  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 181  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 304  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 339  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 390  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 429  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 542  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 562  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;

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


unix.superglobalmegacorp.com