Diff for /qemu/gdbstub.c between versions 1.1.1.11 and 1.1.1.12

version 1.1.1.11, 2018/04/24 18:33:15 version 1.1.1.12, 2018/04/24 18:55:33
Line 37 Line 37
   
 #define MAX_PACKET_LENGTH 4096  #define MAX_PACKET_LENGTH 4096
   
 #include "exec-all.h"  #include "cpu.h"
 #include "qemu_socket.h"  #include "qemu_socket.h"
 #include "kvm.h"  #include "kvm.h"
   
Line 45 Line 45
 enum {  enum {
     GDB_SIGNAL_0 = 0,      GDB_SIGNAL_0 = 0,
     GDB_SIGNAL_INT = 2,      GDB_SIGNAL_INT = 2,
       GDB_SIGNAL_QUIT = 3,
     GDB_SIGNAL_TRAP = 5,      GDB_SIGNAL_TRAP = 5,
       GDB_SIGNAL_ABRT = 6,
       GDB_SIGNAL_ALRM = 14,
       GDB_SIGNAL_IO = 23,
       GDB_SIGNAL_XCPU = 24,
     GDB_SIGNAL_UNKNOWN = 143      GDB_SIGNAL_UNKNOWN = 143
 };  };
   
Line 314  static int get_char(GDBState *s) Line 319  static int get_char(GDBState *s)
     int ret;      int ret;
   
     for(;;) {      for(;;) {
         ret = recv(s->fd, &ch, 1, 0);          ret = qemu_recv(s->fd, &ch, 1, 0);
         if (ret < 0) {          if (ret < 0) {
             if (errno == ECONNRESET)              if (errno == ECONNRESET)
                 s->fd = -1;                  s->fd = -1;
Line 1100  static int cpu_gdb_write_register(CPUSta Line 1105  static int cpu_gdb_write_register(CPUSta
             env->active_fpu.fcr31 = tmp & 0xFF83FFFF;              env->active_fpu.fcr31 = tmp & 0xFF83FFFF;
             /* set rounding mode */              /* set rounding mode */
             RESTORE_ROUNDING_MODE;              RESTORE_ROUNDING_MODE;
 #ifndef CONFIG_SOFTFLOAT  
             /* no floating point exception for native float */  
             SET_FP_ENABLE(env->active_fpu.fcr31, 0);  
 #endif  
             break;              break;
         case 71: env->active_fpu.fcr0 = tmp; break;          case 71: env->active_fpu.fcr0 = tmp; break;
         }          }
Line 1431  static int cpu_gdb_read_register(CPUStat Line 1432  static int cpu_gdb_read_register(CPUStat
             /* XXX */              /* XXX */
             break;              break;
         case S390_PC_REGNUM: GET_REGL(env->psw.addr); break;          case S390_PC_REGNUM: GET_REGL(env->psw.addr); break;
         case S390_CC_REGNUM: GET_REG32(env->cc); break;          case S390_CC_REGNUM:
               env->cc_op = calc_cc(env, env->cc_op, env->cc_src, env->cc_dst,
                                    env->cc_vr);
               GET_REG32(env->cc_op);
               break;
     }      }
   
     return 0;      return 0;
Line 1457  static int cpu_gdb_write_register(CPUSta Line 1462  static int cpu_gdb_write_register(CPUSta
             /* XXX */              /* XXX */
             break;              break;
         case S390_PC_REGNUM: env->psw.addr = tmpl; break;          case S390_PC_REGNUM: env->psw.addr = tmpl; break;
         case S390_CC_REGNUM: env->cc = tmp32; r=4; break;          case S390_CC_REGNUM: env->cc_op = tmp32; r=4; break;
     }      }
   
     return r;      return r;
 }  }
   #elif defined (TARGET_LM32)
   
   #include "hw/lm32_pic.h"
   #define NUM_CORE_REGS (32 + 7)
   
   static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       if (n < 32) {
           GET_REG32(env->regs[n]);
       } else {
           switch (n) {
           case 32:
               GET_REG32(env->pc);
               break;
           /* FIXME: put in right exception ID */
           case 33:
               GET_REG32(0);
               break;
           case 34:
               GET_REG32(env->eba);
               break;
           case 35:
               GET_REG32(env->deba);
               break;
           case 36:
               GET_REG32(env->ie);
               break;
           case 37:
               GET_REG32(lm32_pic_get_im(env->pic_state));
               break;
           case 38:
               GET_REG32(lm32_pic_get_ip(env->pic_state));
               break;
           }
       }
       return 0;
   }
   
   static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       uint32_t tmp;
   
       if (n > NUM_CORE_REGS) {
           return 0;
       }
   
       tmp = ldl_p(mem_buf);
   
       if (n < 32) {
           env->regs[n] = tmp;
       } else {
           switch (n) {
           case 32:
               env->pc = tmp;
               break;
           case 34:
               env->eba = tmp;
               break;
           case 35:
               env->deba = tmp;
               break;
           case 36:
               env->ie = tmp;
               break;
           case 37:
               lm32_pic_set_im(env->pic_state, tmp);
               break;
           case 38:
               lm32_pic_set_ip(env->pic_state, tmp);
               break;
           }
       }
       return 4;
   }
 #else  #else
   
 #define NUM_CORE_REGS 0  #define NUM_CORE_REGS 0
Line 1737  static void gdb_set_cpu_pc(GDBState *s,  Line 1816  static void gdb_set_cpu_pc(GDBState *s, 
 #elif defined (TARGET_S390X)  #elif defined (TARGET_S390X)
     cpu_synchronize_state(s->c_cpu);      cpu_synchronize_state(s->c_cpu);
     s->c_cpu->psw.addr = pc;      s->c_cpu->psw.addr = pc;
   #elif defined (TARGET_LM32)
       s->c_cpu->pc = pc;
 #endif  #endif
 }  }
   
Line 2194  static void gdb_vm_state_change(void *op Line 2275  static void gdb_vm_state_change(void *op
     const char *type;      const char *type;
     int ret;      int ret;
   
     if (running || (reason != EXCP_DEBUG && reason != EXCP_INTERRUPT) ||      if (running || s->state == RS_INACTIVE || s->state == RS_SYSCALL) {
         s->state == RS_INACTIVE || s->state == RS_SYSCALL)  
         return;          return;
       }
     /* disable single step if it was enable */      switch (reason) {
     cpu_single_step(env, 0);      case VMSTOP_DEBUG:
   
     if (reason == EXCP_DEBUG) {  
         if (env->watchpoint_hit) {          if (env->watchpoint_hit) {
             switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {              switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
             case BP_MEM_READ:              case BP_MEM_READ:
Line 2218  static void gdb_vm_state_change(void *op Line 2296  static void gdb_vm_state_change(void *op
                      "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",                       "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
                      GDB_SIGNAL_TRAP, gdb_id(env), type,                       GDB_SIGNAL_TRAP, gdb_id(env), type,
                      env->watchpoint_hit->vaddr);                       env->watchpoint_hit->vaddr);
             put_packet(s, buf);  
             env->watchpoint_hit = NULL;              env->watchpoint_hit = NULL;
             return;              goto send_packet;
         }          }
         tb_flush(env);          tb_flush(env);
         ret = GDB_SIGNAL_TRAP;          ret = GDB_SIGNAL_TRAP;
     } else {          break;
       case VMSTOP_USER:
         ret = GDB_SIGNAL_INT;          ret = GDB_SIGNAL_INT;
           break;
       case VMSTOP_SHUTDOWN:
           ret = GDB_SIGNAL_QUIT;
           break;
       case VMSTOP_DISKFULL:
           ret = GDB_SIGNAL_IO;
           break;
       case VMSTOP_WATCHDOG:
           ret = GDB_SIGNAL_ALRM;
           break;
       case VMSTOP_PANIC:
           ret = GDB_SIGNAL_ABRT;
           break;
       case VMSTOP_SAVEVM:
       case VMSTOP_LOADVM:
           return;
       case VMSTOP_MIGRATE:
           ret = GDB_SIGNAL_XCPU;
           break;
       default:
           ret = GDB_SIGNAL_UNKNOWN;
           break;
     }      }
     snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, gdb_id(env));      snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, gdb_id(env));
   
   send_packet:
     put_packet(s, buf);      put_packet(s, buf);
   
       /* disable single step if it was enabled */
       cpu_single_step(env, 0);
 }  }
 #endif  #endif
   
Line 2252  void gdb_do_syscall(gdb_syscall_complete Line 2357  void gdb_do_syscall(gdb_syscall_complete
     gdb_current_syscall_cb = cb;      gdb_current_syscall_cb = cb;
     s->state = RS_SYSCALL;      s->state = RS_SYSCALL;
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
     vm_stop(EXCP_DEBUG);      vm_stop(VMSTOP_DEBUG);
 #endif  #endif
     s->state = RS_IDLE;      s->state = RS_IDLE;
     va_start(va, fmt);      va_start(va, fmt);
Line 2326  static void gdb_read_byte(GDBState *s, i Line 2431  static void gdb_read_byte(GDBState *s, i
     if (vm_running) {      if (vm_running) {
         /* when the CPU is running, we cannot do anything except stop          /* when the CPU is running, we cannot do anything except stop
            it when receiving a char */             it when receiving a char */
         vm_stop(EXCP_INTERRUPT);          vm_stop(VMSTOP_USER);
     } else      } else
 #endif  #endif
     {      {
Line 2588  static void gdb_chr_event(void *opaque,  Line 2693  static void gdb_chr_event(void *opaque, 
 {  {
     switch (event) {      switch (event) {
     case CHR_EVENT_OPENED:      case CHR_EVENT_OPENED:
         vm_stop(EXCP_INTERRUPT);          vm_stop(VMSTOP_USER);
         gdb_has_xml = 0;          gdb_has_xml = 0;
         break;          break;
     default:      default:
Line 2628  static int gdb_monitor_write(CharDriverS Line 2733  static int gdb_monitor_write(CharDriverS
 #ifndef _WIN32  #ifndef _WIN32
 static void gdb_sigterm_handler(int signal)  static void gdb_sigterm_handler(int signal)
 {  {
     if (vm_running)      if (vm_running) {
         vm_stop(EXCP_INTERRUPT);          vm_stop(VMSTOP_USER);
       }
 }  }
 #endif  #endif
   

Removed from v.1.1.1.11  
changed lines
  Added in v.1.1.1.12


unix.superglobalmegacorp.com