[patch] Have remote.c handle 0 .. NUM_REGS+NUM_PSEUDO_REGS, almost

[Andrew Cagney <ac131313 at cygnus dot com>]

Hello,

The attached modifies remote.c so that it can, almost, handle registers
that are not in the g-packet.  I say ``almost'' since it is also going
to need a follow on change - p-packet support (Fernando proposed
something a long time ago, I'll need to review that).

	Andrew

2001-12-04  Andrew Cagney  <ac131313@redhat.com>

	* remote.c (struct packet_reg): Add field in_g_packet.
	(struct remote_state): Rename field g_packet to regs;
	(free_remote_state): Update.
	(init_remote_state): Add pseudo-registers to table.  Initialize
	in_g_packet.  Drop sentinal from table.
	(packet_reg_from_regnum, packet_reg_from_pnum): Update.
	(remote_fetch_registers): Handle registers not in the g-packet.
	(remote_store_registers): Ditto.

Index: remote.c
===================================================================
RCS file: /cvs/src/src/gdb/remote.c,v
retrieving revision 1.70
diff -p -r1.70 remote.c
*** remote.c	2001/11/19 20:18:32	1.70
--- remote.c	2001/12/05 23:56:28
*************** struct packet_reg
*** 222,227 ****
--- 222,228 ----
    long offset; /* Offset into G packet.  */
    long regnum; /* GDB's internal register number.  */
    LONGEST pnum; /* Remote protocol register number.  */
+   int in_g_packet; /* Always part of G packet.  */
    /* long size in bytes;  == REGISTER_RAW_SIZE (regnum); at present.  */
    /* char *name; == REGISTER_NAME (regnum); at present.  */
  };
*************** struct remote_state
*** 230,237 ****
  {
    /* Description of the remote protocol registers.  */
    long sizeof_g_packet;
-   struct packet_reg *g_packet; /* NULL terminated.  */
  
    /* This is the size (in chars) of the first response to the ``g''
       packet.  It is used as a heuristic when determining the maximum
       size of memory-read and memory-write packets.  A target will
--- 231,241 ----
  {
    /* Description of the remote protocol registers.  */
    long sizeof_g_packet;
  
+   /* Description of the remote protocol registers indexed by REGNUM
+      (making an array of NUM_REGS + NUM_PSEUDO_REGS in size).  */
+   struct packet_reg *regs;
+ 
    /* This is the size (in chars) of the first response to the ``g''
       packet.  It is used as a heuristic when determining the maximum
       size of memory-read and memory-write packets.  A target will
*************** init_remote_state (struct gdbarch *gdbar
*** 264,279 ****
       behavour - just copy in the description of the register cache.  */
    rs->sizeof_g_packet = REGISTER_BYTES; /* OK use.   */
  
!   /* Since, for the moment, the regcache is still being direct mapped,
!      there are exactly NUM_REGS.  Zero allocate a buffer adding space
!      for a sentinal.  */
!   rs->g_packet = xcalloc (NUM_REGS + 1, sizeof (struct packet_reg));
!   rs->g_packet[NUM_REGS].offset = -1;
!   for (regnum = 0; regnum < NUM_REGS; regnum++)
!     {
!       rs->g_packet[regnum].pnum = regnum;
!       rs->g_packet[regnum].regnum = regnum;
!       rs->g_packet[regnum].offset = REGISTER_BYTE (regnum);
        /* ...size = REGISTER_RAW_SIZE (regnum); */
        /* ...name = REGISTER_NAME (regnum); */
      }
--- 268,282 ----
       behavour - just copy in the description of the register cache.  */
    rs->sizeof_g_packet = REGISTER_BYTES; /* OK use.   */
  
!   /* Assume a 1:1 regnum<->pnum table.  */
!   rs->regs = xcalloc (NUM_REGS + NUM_PSEUDO_REGS, sizeof (struct packet_reg));
!   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
!     {
!       struct packet_reg *r = &rs->regs[regnum];
!       r->pnum = regnum;
!       r->regnum = regnum;
!       r->offset = REGISTER_BYTE (regnum);
!       r->in_g_packet = (regnum < NUM_REGS);
        /* ...size = REGISTER_RAW_SIZE (regnum); */
        /* ...name = REGISTER_NAME (regnum); */
      }
*************** static void
*** 306,335 ****
  free_remote_state (struct gdbarch *gdbarch, void *pointer)
  {
    struct remote_state *data = pointer;
!   xfree (data->g_packet);
    xfree (data);
  }
  
  static struct packet_reg *
  packet_reg_from_regnum (struct remote_state *rs, long regnum)
  {
!   struct packet_reg *reg;
!   for (reg = rs->g_packet; reg->offset >= 0; reg++)
      {
!       if (reg->regnum == regnum)
! 	return reg;
      }
-   return NULL;
  }
  
  static struct packet_reg *
  packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
  {
!   struct packet_reg *reg;
!   for (reg = rs->g_packet; reg->offset >= 0; reg++)
      {
!       if (reg->pnum == pnum)
! 	return reg;
      }
    return NULL;
  }
--- 309,340 ----
  free_remote_state (struct gdbarch *gdbarch, void *pointer)
  {
    struct remote_state *data = pointer;
!   xfree (data->regs);
    xfree (data);
  }
  
  static struct packet_reg *
  packet_reg_from_regnum (struct remote_state *rs, long regnum)
  {
!   if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
!     return NULL;
!   else
      {
!       struct packet_reg *r = &rs->regs[regnum];
!       gdb_assert (r->regnum == regnum);
!       return r;
      }
  }
  
  static struct packet_reg *
  packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
  {
!   int i;
!   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
      {
!       struct packet_reg *r = &rs->regs[i];
!       if (r->pnum == pnum)
! 	return r;
      }
    return NULL;
  }
*************** remote_fetch_registers (int regnum)
*** 3406,3411 ****
--- 3411,3426 ----
  
    set_thread (PIDGET (inferior_ptid), 1);
  
+   if (regnum >= 0)
+     {
+       struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+       gdb_assert (reg != NULL);
+       if (!reg->in_g_packet)
+ 	internal_error (__FILE__, __LINE__,
+ 			"Attempt to fetch a non G-packet register when this "
+ 			"remote.c does not support the p-packet.");
+     }
+ 
    sprintf (buf, "g");
    remote_send (buf, (rs->remote_packet_size));
  
*************** remote_fetch_registers (int regnum)
*** 3462,3475 ****
  	warning ("Remote reply is too short: %s", buf);
      }
  
! supply_them:
    {
!     struct packet_reg *g;
!     for (g = rs->g_packet; g->offset >= 0; g++)
        {
! 	supply_register (g->regnum, regs + g->offset);
! 	if (buf[g->offset * 2] == 'x')
! 	  set_register_cached (i, -1);
        }
    }
  }
--- 3477,3494 ----
  	warning ("Remote reply is too short: %s", buf);
      }
  
!  supply_them:
    {
!     int i;
!     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
        {
! 	struct packet_reg *r = &rs->regs[i];
! 	if (r->in_g_packet)
! 	  {
! 	    supply_register (r->regnum, regs + r->offset);
! 	    if (buf[r->offset * 2] == 'x')
! 	      set_register_cached (i, -1);
! 	  }
        }
    }
  }
*************** remote_store_registers (int regnum)
*** 3566,3577 ****
    /* Extract all the registers in the regcache copying them into a
       local buffer.  */
    {
!     struct packet_reg *g;
      regs = alloca (rs->sizeof_g_packet);
      memset (regs, rs->sizeof_g_packet, 0);
!     for (g = rs->g_packet; g->offset >= 0; g++)
        {
! 	regcache_collect (g->regnum, regs + g->offset);
        }
    }
  
--- 3585,3598 ----
    /* Extract all the registers in the regcache copying them into a
       local buffer.  */
    {
!     int i;
      regs = alloca (rs->sizeof_g_packet);
      memset (regs, rs->sizeof_g_packet, 0);
!     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
        {
! 	struct packet_reg *r = &rs->regs[i];
! 	if (r->in_g_packet)
! 	  regcache_collect (r->regnum, regs + r->offset);
        }
    }