Diff for /qemu/gdbstub.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2018/04/24 16:37:52 version 1.1.1.2, 2018/04/24 16:38:02
Line 47  enum RSState { Line 47  enum RSState {
 static int gdbserver_fd = -1;  static int gdbserver_fd = -1;
   
 typedef struct GDBState {  typedef struct GDBState {
       CPUState *env; /* current CPU */
     enum RSState state; /* parsing state */      enum RSState state; /* parsing state */
     int fd;      int fd;
     char line_buf[4096];      char line_buf[4096];
Line 297  static int cpu_gdb_read_registers(CPUSta Line 298  static int cpu_gdb_read_registers(CPUSta
     int i;      int i;
   
     /* fill in g0..g7 */      /* fill in g0..g7 */
     for(i = 0; i < 7; i++) {      for(i = 0; i < 8; i++) {
         registers[i] = tswapl(env->gregs[i]);          registers[i] = tswapl(env->gregs[i]);
     }      }
     /* fill in register window */      /* fill in register window */
Line 398  static int cpu_gdb_read_registers(CPUSta Line 399  static int cpu_gdb_read_registers(CPUSta
     memset (ptr, 0, 8 * 12 + 4);      memset (ptr, 0, 8 * 12 + 4);
     ptr += 8 * 12 + 4;      ptr += 8 * 12 + 4;
     /* CPSR (4 bytes).  */      /* CPSR (4 bytes).  */
     *(uint32_t *)ptr = tswapl (env->cpsr);      *(uint32_t *)ptr = tswapl (cpsr_read(env));
     ptr += 4;      ptr += 4;
   
     return ptr - mem_buf;      return ptr - mem_buf;
Line 418  static void cpu_gdb_write_registers(CPUS Line 419  static void cpu_gdb_write_registers(CPUS
       }        }
     /* Ignore FPA regs and scr.  */      /* Ignore FPA regs and scr.  */
     ptr += 8 * 12 + 4;      ptr += 8 * 12 + 4;
     env->cpsr = tswapl(*(uint32_t *)ptr);      cpsr_write (env, tswapl(*(uint32_t *)ptr), 0xffffffff);
   }
   #elif defined (TARGET_MIPS)
   static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
   {
       int i;
       uint8_t *ptr;
   
       ptr = mem_buf;
       for (i = 0; i < 32; i++)
         {
           *(uint32_t *)ptr = tswapl(env->gpr[i]);
           ptr += 4;
         }
   
       *(uint32_t *)ptr = tswapl(env->CP0_Status);
       ptr += 4;
   
       *(uint32_t *)ptr = tswapl(env->LO);
       ptr += 4;
   
       *(uint32_t *)ptr = tswapl(env->HI);
       ptr += 4;
   
       *(uint32_t *)ptr = tswapl(env->CP0_BadVAddr);
       ptr += 4;
   
       *(uint32_t *)ptr = tswapl(env->CP0_Cause);
       ptr += 4;
   
       *(uint32_t *)ptr = tswapl(env->PC);
       ptr += 4;
   
       /* 32 FP registers, fsr, fir, fp.  Not yet implemented.  */
   
       return ptr - mem_buf;
   }
   
   static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
   {
       int i;
       uint8_t *ptr;
   
       ptr = mem_buf;
       for (i = 0; i < 32; i++)
         {
           env->gpr[i] = tswapl(*(uint32_t *)ptr);
           ptr += 4;
         }
   
       env->CP0_Status = tswapl(*(uint32_t *)ptr);
       ptr += 4;
   
       env->LO = tswapl(*(uint32_t *)ptr);
       ptr += 4;
   
       env->HI = tswapl(*(uint32_t *)ptr);
       ptr += 4;
   
       env->CP0_BadVAddr = tswapl(*(uint32_t *)ptr);
       ptr += 4;
   
       env->CP0_Cause = tswapl(*(uint32_t *)ptr);
       ptr += 4;
   
       env->PC = tswapl(*(uint32_t *)ptr);
       ptr += 4;
 }  }
 #else  #else
 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)  static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
Line 462  static int gdb_handle_packet(GDBState *s Line 529  static int gdb_handle_packet(GDBState *s
 #elif defined (TARGET_SPARC)  #elif defined (TARGET_SPARC)
             env->pc = addr;              env->pc = addr;
             env->npc = addr + 4;              env->npc = addr + 4;
   #elif defined (TARGET_ARM)
               env->regs[15] = addr;
 #endif  #endif
         }          }
 #ifdef CONFIG_USER_ONLY  #ifdef CONFIG_USER_ONLY
Line 480  static int gdb_handle_packet(GDBState *s Line 549  static int gdb_handle_packet(GDBState *s
 #elif defined (TARGET_SPARC)  #elif defined (TARGET_SPARC)
             env->pc = addr;              env->pc = addr;
             env->npc = addr + 4;              env->npc = addr + 4;
   #elif defined (TARGET_ARM)
               env->regs[15] = addr;
 #endif  #endif
         }          }
         cpu_single_step(env, 1);          cpu_single_step(env, 1);
Line 506  static int gdb_handle_packet(GDBState *s Line 577  static int gdb_handle_packet(GDBState *s
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoul(p, NULL, 16);          len = strtoul(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) {
             memset(mem_buf, 0, len);              put_packet (s, "E14");
         memtohex(buf, mem_buf, len);          } else {
         put_packet(s, buf);              memtohex(buf, mem_buf, len);
               put_packet(s, buf);
           }
         break;          break;
     case 'M':      case 'M':
         addr = strtoul(p, (char **)&p, 16);          addr = strtoul(p, (char **)&p, 16);
Line 576  static void gdb_vm_stopped(void *opaque, Line 649  static void gdb_vm_stopped(void *opaque,
     int ret;      int ret;
   
     /* disable single step if it was enable */      /* disable single step if it was enable */
     cpu_single_step(cpu_single_env, 0);      cpu_single_step(s->env, 0);
   
     if (reason == EXCP_DEBUG) {      if (reason == EXCP_DEBUG) {
         tb_flush(cpu_single_env);          tb_flush(s->env);
         ret = SIGTRAP;          ret = SIGTRAP;
     }      }
     else      else
Line 589  static void gdb_vm_stopped(void *opaque, Line 662  static void gdb_vm_stopped(void *opaque,
 }  }
 #endif  #endif
   
 static void gdb_read_byte(GDBState *s, CPUState *env, int ch)  static void gdb_read_byte(GDBState *s, int ch)
 {  {
       CPUState *env = s->env;
     int i, csum;      int i, csum;
     char reply[1];      char reply[1];
   
Line 676  gdb_handlesig (CPUState *env, int sig) Line 750  gdb_handlesig (CPUState *env, int sig)
           int i;            int i;
   
           for (i = 0; i < n; i++)            for (i = 0; i < n; i++)
             gdb_read_byte (s, env, buf[i]);              gdb_read_byte (s, buf[i]);
         }          }
       else if (n == 0 || errno != EAGAIN)        else if (n == 0 || errno != EAGAIN)
         {          {
Line 704  void gdb_exit(CPUState *env, int code) Line 778  void gdb_exit(CPUState *env, int code)
 }  }
   
 #else  #else
 static int gdb_can_read(void *opaque)  static void gdb_read(void *opaque)
 {  
     return 256;  
 }  
   
 static void gdb_read(void *opaque, const uint8_t *buf, int size)  
 {  {
     GDBState *s = opaque;      GDBState *s = opaque;
     int i;      int i, size;
       uint8_t buf[4096];
   
       size = read(s->fd, buf, sizeof(buf));
       if (size < 0)
           return;
     if (size == 0) {      if (size == 0) {
         /* end of connection */          /* end of connection */
         qemu_del_vm_stop_handler(gdb_vm_stopped, s);          qemu_del_vm_stop_handler(gdb_vm_stopped, s);
         qemu_del_fd_read_handler(s->fd);          qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
         qemu_free(s);          qemu_free(s);
         vm_start();          vm_start();
     } else {      } else {
         for(i = 0; i < size; i++)          for(i = 0; i < size; i++)
             gdb_read_byte(s, cpu_single_env, buf[i]);              gdb_read_byte(s, buf[i]);
     }      }
 }  }
   
 #endif  #endif
   
 static void gdb_accept(void *opaque, const uint8_t *buf, int size)  static void gdb_accept(void *opaque)
 {  {
     GDBState *s;      GDBState *s;
     struct sockaddr_in sockaddr;      struct sockaddr_in sockaddr;
Line 759  static void gdb_accept(void *opaque, con Line 833  static void gdb_accept(void *opaque, con
         return;          return;
     }      }
 #endif  #endif
       s->env = first_cpu; /* XXX: allow to change CPU */
     s->fd = fd;      s->fd = fd;
   
     fcntl(fd, F_SETFL, O_NONBLOCK);      fcntl(fd, F_SETFL, O_NONBLOCK);
Line 768  static void gdb_accept(void *opaque, con Line 843  static void gdb_accept(void *opaque, con
     vm_stop(EXCP_INTERRUPT);      vm_stop(EXCP_INTERRUPT);
   
     /* start handling I/O */      /* start handling I/O */
     qemu_add_fd_read_handler(s->fd, gdb_can_read, gdb_read, s);      qemu_set_fd_handler(s->fd, gdb_read, NULL, s);
     /* when the VM is stopped, the following callback is called */      /* when the VM is stopped, the following callback is called */
     qemu_add_vm_stop_handler(gdb_vm_stopped, s);      qemu_add_vm_stop_handler(gdb_vm_stopped, s);
 #endif  #endif
Line 815  int gdbserver_start(int port) Line 890  int gdbserver_start(int port)
         return -1;          return -1;
     /* accept connections */      /* accept connections */
 #ifdef CONFIG_USER_ONLY  #ifdef CONFIG_USER_ONLY
     gdb_accept (NULL, NULL, 0);      gdb_accept (NULL);
 #else  #else
     qemu_add_fd_read_handler(gdbserver_fd, NULL, gdb_accept, NULL);      qemu_set_fd_handler(gdbserver_fd, gdb_accept, NULL, NULL);
 #endif  #endif
     return 0;      return 0;
 }  }

Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2


unix.superglobalmegacorp.com