Diff for /qemu/gdbstub.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 16:40:27 version 1.1.1.4, 2018/04/24 16:42:29
Line 17 Line 17
  * License along with this library; if not, write to the Free Software   * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */   */
   #include "config.h"
 #ifdef CONFIG_USER_ONLY  #ifdef CONFIG_USER_ONLY
 #include <stdlib.h>  #include <stdlib.h>
 #include <stdio.h>  #include <stdio.h>
Line 24 Line 25
 #include <string.h>  #include <string.h>
 #include <errno.h>  #include <errno.h>
 #include <unistd.h>  #include <unistd.h>
   #include <fcntl.h>
   
 #include "qemu.h"  #include "qemu.h"
 #else  #else
 #include "vl.h"  #include "vl.h"
 #endif  #endif
   
 #include <sys/socket.h>  #include "qemu_socket.h"
 #include <netinet/in.h>  #ifdef _WIN32
 #include <netinet/tcp.h>  /* XXX: these constants may be independent of the host ones even for Unix */
   #ifndef SIGTRAP
   #define SIGTRAP 5
   #endif
   #ifndef SIGINT
   #define SIGINT 2
   #endif
   #else
 #include <signal.h>  #include <signal.h>
   #endif
   
 //#define DEBUG_GDB  //#define DEBUG_GDB
   
Line 69  static int get_char(GDBState *s) Line 79  static int get_char(GDBState *s)
     int ret;      int ret;
   
     for(;;) {      for(;;) {
         ret = read(s->fd, &ch, 1);          ret = recv(s->fd, &ch, 1, 0);
         if (ret < 0) {          if (ret < 0) {
             if (errno != EINTR && errno != EAGAIN)              if (errno != EINTR && errno != EAGAIN)
                 return -1;                  return -1;
Line 87  static void put_buffer(GDBState *s, cons Line 97  static void put_buffer(GDBState *s, cons
     int ret;      int ret;
   
     while (len > 0) {      while (len > 0) {
         ret = write(s->fd, buf, len);          ret = send(s->fd, buf, len, 0);
         if (ret < 0) {          if (ret < 0) {
             if (errno != EINTR && errno != EAGAIN)              if (errno != EINTR && errno != EAGAIN)
                 return;                  return;
Line 305  static int cpu_gdb_read_registers(CPUSta Line 315  static int cpu_gdb_read_registers(CPUSta
     for(i = 0; i < 24; i++) {      for(i = 0; i < 24; i++) {
         registers[i + 8] = tswapl(env->regwptr[i]);          registers[i + 8] = tswapl(env->regwptr[i]);
     }      }
   #ifndef TARGET_SPARC64
     /* fill in fprs */      /* fill in fprs */
     for (i = 0; i < 32; i++) {      for (i = 0; i < 32; i++) {
         registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));          registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
     }      }
 #ifndef TARGET_SPARC64  
     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */      /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
     registers[64] = tswapl(env->y);      registers[64] = tswapl(env->y);
     {      {
Line 327  static int cpu_gdb_read_registers(CPUSta Line 337  static int cpu_gdb_read_registers(CPUSta
     registers[72] = 0;      registers[72] = 0;
     return 73 * sizeof(target_ulong);      return 73 * sizeof(target_ulong);
 #else  #else
     for (i = 0; i < 32; i += 2) {      /* fill in fprs */
         registers[i/2 + 64] = tswapl(*((uint64_t *)&env->fpr[i]));      for (i = 0; i < 64; i += 2) {
     }          uint64_t tmp;
     registers[81] = tswapl(env->pc);  
     registers[82] = tswapl(env->npc);          tmp = (uint64_t)tswap32(*((uint32_t *)&env->fpr[i])) << 32;
     registers[83] = tswapl(env->tstate[env->tl]);          tmp |= tswap32(*((uint32_t *)&env->fpr[i + 1]));
     registers[84] = tswapl(env->fsr);          registers[i/2 + 32] = tmp;
     registers[85] = tswapl(env->fprs);      }
     registers[86] = tswapl(env->y);      registers[64] = tswapl(env->pc);
     return 87 * sizeof(target_ulong);      registers[65] = tswapl(env->npc);
       registers[66] = tswapl(env->tstate[env->tl]);
       registers[67] = tswapl(env->fsr);
       registers[68] = tswapl(env->fprs);
       registers[69] = tswapl(env->y);
       return 70 * sizeof(target_ulong);
 #endif  #endif
 }  }
   
Line 353  static void cpu_gdb_write_registers(CPUS Line 368  static void cpu_gdb_write_registers(CPUS
     for(i = 0; i < 24; i++) {      for(i = 0; i < 24; i++) {
         env->regwptr[i] = tswapl(registers[i + 8]);          env->regwptr[i] = tswapl(registers[i + 8]);
     }      }
   #ifndef TARGET_SPARC64
     /* fill in fprs */      /* fill in fprs */
     for (i = 0; i < 32; i++) {      for (i = 0; i < 32; i++) {
         *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);          *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
     }      }
 #ifndef TARGET_SPARC64  
     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */      /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
     env->y = tswapl(registers[64]);      env->y = tswapl(registers[64]);
     PUT_PSR(env, tswapl(registers[65]));      PUT_PSR(env, tswapl(registers[65]));
Line 367  static void cpu_gdb_write_registers(CPUS Line 382  static void cpu_gdb_write_registers(CPUS
     env->npc = tswapl(registers[69]);      env->npc = tswapl(registers[69]);
     env->fsr = tswapl(registers[70]);      env->fsr = tswapl(registers[70]);
 #else  #else
     for (i = 0; i < 32; i += 2) {      for (i = 0; i < 64; i += 2) {
         uint64_t tmp;          *((uint32_t *)&env->fpr[i]) = tswap32(registers[i/2 + 32] >> 32);
         tmp = tswapl(registers[i/2 + 64]) << 32;          *((uint32_t *)&env->fpr[i + 1]) = tswap32(registers[i/2 + 32] & 0xffffffff);
         tmp |= tswapl(registers[i/2 + 64 + 1]);      }
         *((uint64_t *)&env->fpr[i]) = tmp;      env->pc = tswapl(registers[64]);
     }      env->npc = tswapl(registers[65]);
     env->pc = tswapl(registers[81]);      env->tstate[env->tl] = tswapl(registers[66]);
     env->npc = tswapl(registers[82]);      env->fsr = tswapl(registers[67]);
     env->tstate[env->tl] = tswapl(registers[83]);      env->fprs = tswapl(registers[68]);
     env->fsr = tswapl(registers[84]);      env->y = tswapl(registers[69]);
     env->fprs = tswapl(registers[85]);  
     env->y = tswapl(registers[86]);  
 #endif  #endif
 }  }
 #elif defined (TARGET_ARM)  #elif defined (TARGET_ARM)
Line 494  static int cpu_gdb_read_registers(CPUSta Line 507  static int cpu_gdb_read_registers(CPUSta
   int i;    int i;
   
 #define SAVE(x) *ptr++=tswapl(x)  #define SAVE(x) *ptr++=tswapl(x)
   for (i = 0; i < 16; i++) SAVE(env->gregs[i]);    if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
         for (i = 0; i < 8; i++) SAVE(env->gregs[i + 16]);
     } else {
         for (i = 0; i < 8; i++) SAVE(env->gregs[i]);
     }
     for (i = 8; i < 16; i++) SAVE(env->gregs[i]);
   SAVE (env->pc);    SAVE (env->pc);
   SAVE (env->pr);    SAVE (env->pr);
   SAVE (env->gbr);    SAVE (env->gbr);
Line 517  static void cpu_gdb_write_registers(CPUS Line 535  static void cpu_gdb_write_registers(CPUS
   int i;    int i;
   
 #define LOAD(x) (x)=*ptr++;  #define LOAD(x) (x)=*ptr++;
   for (i = 0; i < 16; i++) LOAD(env->gregs[i]);    if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
         for (i = 0; i < 8; i++) LOAD(env->gregs[i + 16]);
     } else {
         for (i = 0; i < 8; i++) LOAD(env->gregs[i]);
     }
     for (i = 8; i < 16; i++) LOAD(env->gregs[i]);
   LOAD (env->pc);    LOAD (env->pc);
   LOAD (env->pr);    LOAD (env->pr);
   LOAD (env->gbr);    LOAD (env->gbr);
Line 545  static int gdb_handle_packet(GDBState *s Line 568  static int gdb_handle_packet(GDBState *s
     char buf[4096];      char buf[4096];
     uint8_t mem_buf[2000];      uint8_t mem_buf[2000];
     uint32_t *registers;      uint32_t *registers;
     uint32_t addr, len;      target_ulong addr, len;
           
 #ifdef DEBUG_GDB  #ifdef DEBUG_GDB
     printf("command='%s'\n", line_buf);      printf("command='%s'\n", line_buf);
Line 560  static int gdb_handle_packet(GDBState *s Line 583  static int gdb_handle_packet(GDBState *s
         break;          break;
     case 'c':      case 'c':
         if (*p != '\0') {          if (*p != '\0') {
             addr = strtoul(p, (char **)&p, 16);              addr = strtoull(p, (char **)&p, 16);
 #if defined(TARGET_I386)  #if defined(TARGET_I386)
             env->eip = addr;              env->eip = addr;
 #elif defined (TARGET_PPC)  #elif defined (TARGET_PPC)
Line 616  static int gdb_handle_packet(GDBState *s Line 639  static int gdb_handle_packet(GDBState *s
         put_packet(s, "OK");          put_packet(s, "OK");
         break;          break;
     case 'm':      case 'm':
         addr = strtoul(p, (char **)&p, 16);          addr = strtoull(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoul(p, NULL, 16);          len = strtoull(p, NULL, 16);
         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {          if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
             put_packet (s, "E14");              put_packet (s, "E14");
         } else {          } else {
Line 628  static int gdb_handle_packet(GDBState *s Line 651  static int gdb_handle_packet(GDBState *s
         }          }
         break;          break;
     case 'M':      case 'M':
         addr = strtoul(p, (char **)&p, 16);          addr = strtoull(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoul(p, (char **)&p, 16);          len = strtoull(p, (char **)&p, 16);
         if (*p == ':')          if (*p == ':')
             p++;              p++;
         hextomem(mem_buf, p, len);          hextomem(mem_buf, p, len);
Line 644  static int gdb_handle_packet(GDBState *s Line 667  static int gdb_handle_packet(GDBState *s
         type = strtoul(p, (char **)&p, 16);          type = strtoul(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         addr = strtoul(p, (char **)&p, 16);          addr = strtoull(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoul(p, (char **)&p, 16);          len = strtoull(p, (char **)&p, 16);
         if (type == 0 || type == 1) {          if (type == 0 || type == 1) {
             if (cpu_breakpoint_insert(env, addr) < 0)              if (cpu_breakpoint_insert(env, addr) < 0)
                 goto breakpoint_error;                  goto breakpoint_error;
Line 661  static int gdb_handle_packet(GDBState *s Line 684  static int gdb_handle_packet(GDBState *s
         type = strtoul(p, (char **)&p, 16);          type = strtoul(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         addr = strtoul(p, (char **)&p, 16);          addr = strtoull(p, (char **)&p, 16);
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoul(p, (char **)&p, 16);          len = strtoull(p, (char **)&p, 16);
         if (type == 0 || type == 1) {          if (type == 0 || type == 1) {
             cpu_breakpoint_remove(env, addr);              cpu_breakpoint_remove(env, addr);
             put_packet(s, "OK");              put_packet(s, "OK");
Line 672  static int gdb_handle_packet(GDBState *s Line 695  static int gdb_handle_packet(GDBState *s
             goto breakpoint_error;              goto breakpoint_error;
         }          }
         break;          break;
   #ifdef CONFIG_USER_ONLY
       case 'q':
           if (strncmp(p, "Offsets", 7) == 0) {
               TaskState *ts = env->opaque;
   
               sprintf(buf, "Text=%x;Data=%x;Bss=%x", ts->info->code_offset,
                   ts->info->data_offset, ts->info->data_offset);
               put_packet(s, buf);
               break;
           }
           /* Fall through.  */
   #endif
     default:      default:
         //        unknown_command:          //        unknown_command:
         /* put empty packet */          /* put empty packet */
Line 829  static void gdb_read(void *opaque) Line 864  static void gdb_read(void *opaque)
     int i, size;      int i, size;
     uint8_t buf[4096];      uint8_t buf[4096];
   
     size = read(s->fd, buf, sizeof(buf));      size = recv(s->fd, buf, sizeof(buf), 0);
     if (size < 0)      if (size < 0)
         return;          return;
     if (size == 0) {      if (size == 0) {
Line 866  static void gdb_accept(void *opaque) Line 901  static void gdb_accept(void *opaque)
   
     /* set short latency */      /* set short latency */
     val = 1;      val = 1;
     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));      setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
           
 #ifdef CONFIG_USER_ONLY  #ifdef CONFIG_USER_ONLY
     s = &gdbserver_state;      s = &gdbserver_state;
Line 881  static void gdb_accept(void *opaque) Line 916  static void gdb_accept(void *opaque)
     s->env = first_cpu; /* XXX: allow to change CPU */      s->env = first_cpu; /* XXX: allow to change CPU */
     s->fd = fd;      s->fd = fd;
   
   #ifdef CONFIG_USER_ONLY
     fcntl(fd, F_SETFL, O_NONBLOCK);      fcntl(fd, F_SETFL, O_NONBLOCK);
   #else
       socket_set_nonblock(fd);
   
 #ifndef CONFIG_USER_ONLY  
     /* stop the VM */      /* stop the VM */
     vm_stop(EXCP_INTERRUPT);      vm_stop(EXCP_INTERRUPT);
   
Line 907  static int gdbserver_open(int port) Line 944  static int gdbserver_open(int port)
   
     /* allow fast reuse */      /* allow fast reuse */
     val = 1;      val = 1;
     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));      setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
   
     sockaddr.sin_family = AF_INET;      sockaddr.sin_family = AF_INET;
     sockaddr.sin_port = htons(port);      sockaddr.sin_port = htons(port);
Line 923  static int gdbserver_open(int port) Line 960  static int gdbserver_open(int port)
         return -1;          return -1;
     }      }
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
     fcntl(fd, F_SETFL, O_NONBLOCK);      socket_set_nonblock(fd);
 #endif  #endif
     return fd;      return fd;
 }  }

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


unix.superglobalmegacorp.com