Diff for /qemu/gdbstub.c between versions 1.1.1.8 and 1.1.1.9

version 1.1.1.8, 2018/04/24 17:20:17 version 1.1.1.9, 2018/04/24 17:33:42
Line 505  static const int gpr_map[16] = { Line 505  static const int gpr_map[16] = {
     8, 9, 10, 11, 12, 13, 14, 15      8, 9, 10, 11, 12, 13, 14, 15
 };  };
 #else  #else
 static const int gpr_map[8] = {0, 1, 2, 3, 4, 5, 6, 7};  #define gpr_map gpr_map32
 #endif  #endif
   static const int gpr_map32[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
   
 #define NUM_CORE_REGS (CPU_NB_REGS * 2 + 25)  #define NUM_CORE_REGS (CPU_NB_REGS * 2 + 25)
   
Line 520  static const int gpr_map[8] = {0, 1, 2,  Line 521  static const int gpr_map[8] = {0, 1, 2, 
 static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)  static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
 {  {
     if (n < CPU_NB_REGS) {      if (n < CPU_NB_REGS) {
         GET_REGL(env->regs[gpr_map[n]]);          if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
               GET_REG64(env->regs[gpr_map[n]]);
           } else if (n < CPU_NB_REGS32) {
               GET_REG32(env->regs[gpr_map32[n]]);
           }
     } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {      } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {
 #ifdef USE_X86LDOUBLE  #ifdef USE_X86LDOUBLE
         /* FIXME: byteswap float values - after fixing fpregs layout. */          /* FIXME: byteswap float values - after fixing fpregs layout. */
Line 531  static int cpu_gdb_read_register(CPUStat Line 536  static int cpu_gdb_read_register(CPUStat
         return 10;          return 10;
     } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {      } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {
         n -= IDX_XMM_REGS;          n -= IDX_XMM_REGS;
         stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));          if (n < CPU_NB_REGS32 ||
         stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));              (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
         return 16;              stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));
               stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));
               return 16;
           }
     } else {      } else {
         switch (n) {          switch (n) {
         case IDX_IP_REG:    GET_REGL(env->eip);          case IDX_IP_REG:
               if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
                   GET_REG64(env->eip);
               } else {
                   GET_REG32(env->eip);
               }
         case IDX_FLAGS_REG: GET_REG32(env->eflags);          case IDX_FLAGS_REG: GET_REG32(env->eflags);
   
         case IDX_SEG_REGS:     GET_REG32(env->segs[R_CS].selector);          case IDX_SEG_REGS:     GET_REG32(env->segs[R_CS].selector);
Line 592  static int cpu_gdb_write_register(CPUSta Line 605  static int cpu_gdb_write_register(CPUSta
     uint32_t tmp;      uint32_t tmp;
   
     if (n < CPU_NB_REGS) {      if (n < CPU_NB_REGS) {
         env->regs[gpr_map[n]] = ldtul_p(mem_buf);          if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
         return sizeof(target_ulong);              env->regs[gpr_map[n]] = ldtul_p(mem_buf);
               return sizeof(target_ulong);
           } else if (n < CPU_NB_REGS32) {
               n = gpr_map32[n];
               env->regs[n] &= ~0xffffffffUL;
               env->regs[n] |= (uint32_t)ldl_p(mem_buf);
               return 4;
           }
     } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {      } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {
 #ifdef USE_X86LDOUBLE  #ifdef USE_X86LDOUBLE
         /* FIXME: byteswap float values - after fixing fpregs layout. */          /* FIXME: byteswap float values - after fixing fpregs layout. */
Line 602  static int cpu_gdb_write_register(CPUSta Line 622  static int cpu_gdb_write_register(CPUSta
         return 10;          return 10;
     } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {      } else if (n >= IDX_XMM_REGS && n < IDX_XMM_REGS + CPU_NB_REGS) {
         n -= IDX_XMM_REGS;          n -= IDX_XMM_REGS;
         env->xmm_regs[n].XMM_Q(0) = ldq_p(mem_buf);          if (n < CPU_NB_REGS32 ||
         env->xmm_regs[n].XMM_Q(1) = ldq_p(mem_buf + 8);              (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
         return 16;              env->xmm_regs[n].XMM_Q(0) = ldq_p(mem_buf);
               env->xmm_regs[n].XMM_Q(1) = ldq_p(mem_buf + 8);
               return 16;
           }
     } else {      } else {
         switch (n) {          switch (n) {
         case IDX_IP_REG:          case IDX_IP_REG:
             env->eip = ldtul_p(mem_buf);              if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
             return sizeof(target_ulong);                  env->eip = ldq_p(mem_buf);
                   return 8;
               } else {
                   env->eip &= ~0xffffffffUL;
                   env->eip |= (uint32_t)ldl_p(mem_buf);
                   return 4;
               }
         case IDX_FLAGS_REG:          case IDX_FLAGS_REG:
             env->eflags = ldl_p(mem_buf);              env->eflags = ldl_p(mem_buf);
             return 4;              return 4;
Line 1284  static int cpu_gdb_read_register(CPUStat Line 1313  static int cpu_gdb_read_register(CPUStat
     else if (n<63) {      else if (n<63) {
        uint64_t val;         uint64_t val;
   
        val=*((uint64_t *)&env->fir[n-32]);         val = *((uint64_t *)&env->fir[n-32]);
        GET_REGL(val);         GET_REGL(val);
     }      }
     else if (n==63) {      else if (n==63) {
Line 1319  static int cpu_gdb_write_register(CPUSta Line 1348  static int cpu_gdb_write_register(CPUSta
   
     return 8;      return 8;
 }  }
   #elif defined (TARGET_S390X)
   
   #define NUM_CORE_REGS S390_NUM_TOTAL_REGS
   
   static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       switch (n) {
           case S390_PSWM_REGNUM: GET_REGL(env->psw.mask); break;
           case S390_PSWA_REGNUM: GET_REGL(env->psw.addr); break;
           case S390_R0_REGNUM ... S390_R15_REGNUM:
               GET_REGL(env->regs[n-S390_R0_REGNUM]); break;
           case S390_A0_REGNUM ... S390_A15_REGNUM:
               GET_REG32(env->aregs[n-S390_A0_REGNUM]); break;
           case S390_FPC_REGNUM: GET_REG32(env->fpc); break;
           case S390_F0_REGNUM ... S390_F15_REGNUM:
               /* XXX */
               break;
           case S390_PC_REGNUM: GET_REGL(env->psw.addr); break;
           case S390_CC_REGNUM: GET_REG32(env->cc); break;
       }
   
       return 0;
   }
   
   static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       target_ulong tmpl;
       uint32_t tmp32;
       int r = 8;
       tmpl = ldtul_p(mem_buf);
       tmp32 = ldl_p(mem_buf);
   
       switch (n) {
           case S390_PSWM_REGNUM: env->psw.mask = tmpl; break;
           case S390_PSWA_REGNUM: env->psw.addr = tmpl; break;
           case S390_R0_REGNUM ... S390_R15_REGNUM:
               env->regs[n-S390_R0_REGNUM] = tmpl; break;
           case S390_A0_REGNUM ... S390_A15_REGNUM:
               env->aregs[n-S390_A0_REGNUM] = tmp32; r=4; break;
           case S390_FPC_REGNUM: env->fpc = tmp32; r=4; break;
           case S390_F0_REGNUM ... S390_F15_REGNUM:
               /* XXX */
               break;
           case S390_PC_REGNUM: env->psw.addr = tmpl; break;
           case S390_CC_REGNUM: env->cc = tmp32; r=4; break;
       }
   
       return r;
   }
 #else  #else
   
 #define NUM_CORE_REGS 0  #define NUM_CORE_REGS 0
Line 1568  static void gdb_breakpoint_remove_all(vo Line 1646  static void gdb_breakpoint_remove_all(vo
 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)  static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
 {  {
 #if defined(TARGET_I386)  #if defined(TARGET_I386)
       cpu_synchronize_state(s->c_cpu);
     s->c_cpu->eip = pc;      s->c_cpu->eip = pc;
     cpu_synchronize_state(s->c_cpu, 1);  
 #elif defined (TARGET_PPC)  #elif defined (TARGET_PPC)
     s->c_cpu->nip = pc;      s->c_cpu->nip = pc;
 #elif defined (TARGET_SPARC)  #elif defined (TARGET_SPARC)
Line 1587  static void gdb_set_cpu_pc(GDBState *s,  Line 1665  static void gdb_set_cpu_pc(GDBState *s, 
     s->c_cpu->pc = pc;      s->c_cpu->pc = pc;
 #elif defined (TARGET_ALPHA)  #elif defined (TARGET_ALPHA)
     s->c_cpu->pc = pc;      s->c_cpu->pc = pc;
   #elif defined (TARGET_S390X)
       cpu_synchronize_state(s->c_cpu);
       s->c_cpu->psw.addr = pc;
 #endif  #endif
 }  }
   
 static inline int gdb_id(CPUState *env)  static inline int gdb_id(CPUState *env)
 {  {
 #if defined(CONFIG_USER_ONLY) && defined(USE_NPTL)  #if defined(CONFIG_USER_ONLY) && defined(CONFIG_USE_NPTL)
     return env->host_tid;      return env->host_tid;
 #else  #else
     return env->cpu_index + 1;      return env->cpu_index + 1;
Line 1755  static int gdb_handle_packet(GDBState *s Line 1836  static int gdb_handle_packet(GDBState *s
         }          }
         break;          break;
     case 'g':      case 'g':
         cpu_synchronize_state(s->g_cpu, 0);          cpu_synchronize_state(s->g_cpu);
         len = 0;          len = 0;
         for (addr = 0; addr < num_g_regs; addr++) {          for (addr = 0; addr < num_g_regs; addr++) {
             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);              reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
Line 1765  static int gdb_handle_packet(GDBState *s Line 1846  static int gdb_handle_packet(GDBState *s
         put_packet(s, buf);          put_packet(s, buf);
         break;          break;
     case 'G':      case 'G':
           cpu_synchronize_state(s->g_cpu);
         registers = mem_buf;          registers = mem_buf;
         len = strlen(p) / 2;          len = strlen(p) / 2;
         hextomem((uint8_t *)registers, p, len);          hextomem((uint8_t *)registers, p, len);
Line 1773  static int gdb_handle_packet(GDBState *s Line 1855  static int gdb_handle_packet(GDBState *s
             len -= reg_size;              len -= reg_size;
             registers += reg_size;              registers += reg_size;
         }          }
         cpu_synchronize_state(s->g_cpu, 1);  
         put_packet(s, "OK");          put_packet(s, "OK");
         break;          break;
     case 'm':      case 'm':
Line 1929  static int gdb_handle_packet(GDBState *s Line 2010  static int gdb_handle_packet(GDBState *s
             thread = strtoull(p+16, (char **)&p, 16);              thread = strtoull(p+16, (char **)&p, 16);
             env = find_cpu(thread);              env = find_cpu(thread);
             if (env != NULL) {              if (env != NULL) {
                 cpu_synchronize_state(env, 0);                  cpu_synchronize_state(env);
                 len = snprintf((char *)mem_buf, sizeof(mem_buf),                  len = snprintf((char *)mem_buf, sizeof(mem_buf),
                                "CPU#%d [%s]", env->cpu_index,                                 "CPU#%d [%s]", env->cpu_index,
                                env->halted ? "halted " : "running");                                 env->halted ? "halted " : "running");
Line 2327  static void gdb_accept(void) Line 2408  static void gdb_accept(void)
             perror("accept");              perror("accept");
             return;              return;
         } else if (fd >= 0) {          } else if (fd >= 0) {
   #ifndef _WIN32
               fcntl(fd, F_SETFD, FD_CLOEXEC);
   #endif
             break;              break;
         }          }
     }      }
Line 2356  static int gdbserver_open(int port) Line 2440  static int gdbserver_open(int port)
         perror("socket");          perror("socket");
         return -1;          return -1;
     }      }
   #ifndef _WIN32
       fcntl(fd, F_SETFD, FD_CLOEXEC);
   #endif
   
     /* allow fast reuse */      /* allow fast reuse */
     val = 1;      val = 1;
Line 2418  static void gdb_chr_receive(void *opaque Line 2505  static void gdb_chr_receive(void *opaque
 static void gdb_chr_event(void *opaque, int event)  static void gdb_chr_event(void *opaque, int event)
 {  {
     switch (event) {      switch (event) {
     case CHR_EVENT_RESET:      case CHR_EVENT_OPENED:
         vm_stop(EXCP_INTERRUPT);          vm_stop(EXCP_INTERRUPT);
         gdb_has_xml = 0;          gdb_has_xml = 0;
         break;          break;

Removed from v.1.1.1.8  
changed lines
  Added in v.1.1.1.9


unix.superglobalmegacorp.com