This is the mail archive of the gdb-patches@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [patch/cagney_regbuf-20020515-branch] Really separate out old andnew


Andrew Cagney wrote:
> 
> Hello,
> 
> The attached patch, to the cagney_regbuf-20020515-branch, more strongly
> differentiates between the old and new style register caches by using
> regcache->descr->legacy_p.
> 
> For the old case, all registers can be in the cache.  For the new case,
> only 0..NUM_REGS are allowed in the register cache.
> 
> In addition, the regcache code only calls legacy_*() functions when
> ->legacy_p.  The new code goes straight through.
> 
> I think I'm about done with that branch.  I'll next post a full patch
> and figure out how to get something equivalent into the trunk.  More
> importantly, how to do it without breaking SH5.
> 
> enjoy,
> Andrew

OK -- I was trying to ignore this, but it breaks one of my targets.
What do I have to do, to make my old target use the old legacy method?



> 
>   ------------------------------------------------------------------------
> 2002-05-23  Andrew Cagney  <ac131313@redhat.com>
> 
>         * regcache.c (register_buffer): Add regcache parameter.  Update
>         callers.
>         (struct regcache_descr): Add nr_raw_registers and
>         max_register_size.  Add legacy_p.  Change registers to
>         raw_registers, register_valid_p to raw_register_valid_p.  Update
>         all callers.
>         (legacy_regcache_descr): New function handle legacy case.
>         (regcache_descr): Use legacy function.  For non-legacy case,
>         restrict the register cache to just NUM_REGS.
>         (regcache_read, regcache_write): When non-legacy case, implement
>         regcache read and write directly.
>         (regcache_write): Use regcache_valid_p.
> 
>         * regcache.h (deprecated_grub_regcache_for_registers): Rename
>         grub_around_regcache_for_registers
>         (deprecated_grub_regcache_for_register_valid): Rename
>         grub_around_regcache_for_register_valid.
>         * regcache.c (deprecated_grub_around_regcache_for_registers)
>         (deprecated_grub_regcache_for_register_valid): Rename.
>         * rs6000-tdep.c (rs6000_extract_return_value): Update.
>         * regcache.c (build_regcache): Update.
> 
> Index: regcache.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/regcache.c,v
> retrieving revision 1.36.2.4
> diff -u -r1.36.2.4 regcache.c
> --- regcache.c  17 May 2002 16:17:30 -0000      1.36.2.4
> +++ regcache.c  23 May 2002 17:47:27 -0000
> @@ -43,26 +43,39 @@
>  {
>    /* The architecture this descriptor belongs to.  */
>    struct gdbarch *gdbarch;
> -  /* Total number of registers in the buffer.  */
> -  int nr_registers;
> -  /* Size of the register buffer, over-allocate making room for both
> -     real and pseudo-registers.  */
> -  /* FIXME: cagney/2002-05-11: This over-allocation shouldn't be
> -     necessary.  Unfortunatly, some targets store real values in
> -     pseudo-registers and we want to be sure those targets don't crash
> -     GDB.  Once that code has been trashed this can be pruned down to
> -     just raw registers.  */
> -  long sizeof_registers;
> -  /* Offset into the register buffer for each register.  */
> +
> +  /* Is this a ``legacy'' register cache?  Such caches reserve space
> +     for raw and pseudo registers and allow access to both.  */
> +  int legacy_p;
> +
> +  /* The raw register cache.  This should contain just [0
> +     .. NUM_RAW_REGISTERS).  However, for older targets, it contains
> +     space for the full [0 .. NUM_RAW_REGISTERS +
> +     NUM_PSEUDO_REGISTERS).  */
> +  int nr_raw_registers;
> +  long sizeof_raw_registers;
> +  long sizeof_raw_register_valid_p;
> +
> +  /* Offset, in bytes, of reach register in the raw register cache.
> +     Pseudo registers have an offset even though they don't
> +     (shouldn't) have a correspoinding space in the register cache.
> +     It is to keep existing code, that relies on
> +     write/write_register_bytes working.  */
>    long *register_offset;
> -  /* Size, in bytes of the register valid array.  */
> -  long sizeof_register_valid_p;
> -  /* Size, in ``bytes'', of a register.  */
> +
> +  /* The cooked / frame / virtual register space.  The registers in
> +     the range [0..NR_RAW_REGISTERS) should be mapped directly onto
> +     the corresponding raw register.  The next [NR_RAW_REGISTERS
> +     .. NR_REGISTERS) should have been mapped, via
> +     gdbarch_register_read/write onto either raw registers or memory.  */
> +  int nr_registers;
>    long *sizeof_register;
> +  long max_register_size;
> +
>  };
> 
>  static struct regcache_descr *
> -regcache_descr (struct gdbarch *gdbarch)
> +legacy_regcache_descr (struct gdbarch *gdbarch)
>  {
>    int i;
>    struct regcache_descr *descr;
> @@ -76,11 +89,13 @@
> 
>    descr = XMALLOC (struct regcache_descr);
>    descr->gdbarch = gdbarch;
> +  descr->legacy_p = 1;
> 
>    /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
>       in the register buffer.  Unfortunatly some architectures do.  */
>    descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
> -  descr->sizeof_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
> +  descr->nr_raw_registers = descr->nr_registers;
> +  descr->sizeof_raw_register_valid_p = descr->nr_registers;
> 
>    /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
>       code should compute the offets et.al. at runtime.  This currently
> @@ -89,14 +104,17 @@
>       registers.  */
>    descr->sizeof_register = XCALLOC (descr->nr_registers, long);
>    descr->register_offset = XCALLOC (descr->nr_registers, long);
> +  descr->max_register_size = 0;
>    for (i = 0; i < descr->nr_registers; i++)
>      {
>        descr->register_offset[i] = REGISTER_BYTE (i);
>        descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
> +      if (descr->max_register_size < REGISTER_RAW_SIZE (i))
> +       descr->max_register_size = REGISTER_RAW_SIZE (i);
>      }
> 
>    /* Come up with the real size of the registers buffer.  */
> -  descr->sizeof_registers = REGISTER_BYTES; /* OK use.  */
> +  descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use.  */
>    for (i = 0; i < descr->nr_registers; i++)
>      {
>        long regend;
> @@ -111,13 +129,94 @@
>           Ulgh!  New targets use gdbarch's register read/write and
>           entirely avoid this uglyness.  */
>        regend = descr->register_offset[i] + descr->sizeof_register[i];
> -      if (descr->sizeof_registers < regend)
> -       descr->sizeof_registers = regend;
> +      if (descr->sizeof_raw_registers < regend)
> +       descr->sizeof_raw_registers = regend;
>      }
>    set_gdbarch_data (gdbarch, regcache_data_handle, descr);
>    return descr;
>  }
> 
> +static struct regcache_descr *
> +regcache_descr (struct gdbarch *gdbarch)
> +{
> +  int i;
> +  struct regcache_descr *descr;
> +  gdb_assert (gdbarch != NULL);
> +
> +  /* If the value has previously been computed, just return that.  */
> +  descr = gdbarch_data (gdbarch, regcache_data_handle);
> +  if (descr != NULL)
> +    return descr;
> +
> +  /* If an old style architecture, construct the register cache
> +     description using all the register macros.  */
> +  if (!gdbarch_register_read_p (gdbarch)
> +      && !gdbarch_register_write_p (gdbarch))
> +    return legacy_regcache_descr (gdbarch);
> +
> +  descr = XMALLOC (struct regcache_descr);
> +  descr->gdbarch = gdbarch;
> +  descr->legacy_p = 0;
> +
> +  /* Total size of the register space.  The raw registers should
> +     directly map onto the raw register cache while the pseudo's are
> +     either mapped onto raw-registers or memory.  */
> +  descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS;
> +
> +  /* Construct a strictly RAW register cache.  Don't allow pseudo's
> +     into the register cache.  */
> +  descr->nr_raw_registers = NUM_REGS;
> +  descr->sizeof_raw_register_valid_p = NUM_REGS;
> +
> +  /* Lay out the register cache.  The pseud-registers are included in
> +     the layout even though their value isn't stored in the register
> +     cache.  Some code, via read_register_bytes() access a register
> +     using an offset/length rather than a register number.
> +
> +     NOTE: cagney/2002-05-22: Only REGISTER_VIRTUAL_TYPE() needs to be
> +     used when constructing the register cache.  It is assumed that
> +     register raw size, virtual size and type length of the type are
> +     all the same.  */
> +
> +  {
> +    long offset = 0;
> +    descr->sizeof_register = XCALLOC (descr->nr_registers, long);
> +    descr->register_offset = XCALLOC (descr->nr_registers, long);
> +    descr->max_register_size = 0;
> +    for (i = 0; i < descr->nr_registers; i++)
> +      {
> +       descr->sizeof_register[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i));
> +       descr->register_offset[i] = offset;
> +       offset += descr->sizeof_register[i];
> +       if (descr->max_register_size < descr->sizeof_register[i])
> +         descr->max_register_size = descr->sizeof_register[i];
> +      }
> +    /* Set the real size of the register cache buffer.  */
> +    /* FIXME: cagney/2002-05-22: Should only need to allocate space
> +       for the raw registers.  Unfortunatly some code still accesses
> +       the register array directly using the global registers[].
> +       Until that code has been purged, play safe and over allocating
> +       the register buffer.  Ulgh!  */
> +    descr->sizeof_raw_registers = offset;
> +    /* = descr->register_offset[descr->nr_raw_registers]; */
> +  }
> +
> +  set_gdbarch_data (gdbarch, regcache_data_handle, descr);
> +
> +  /* Sanity check.  Confirm that the assumptions about gdbarch are
> +     true.  The REGCACHE_DATA_HANDLE is set before doing the checks so
> +     that targets using the generic methods supplied by regcache don't
> +     go into infinite recursion trying to, again, create the regcache.  */
> +  for (i = 0; i < descr->nr_registers; i++)
> +    {
> +      gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i));
> +      gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i));
> +      gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i));
> +    }
> +  /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i));  */
> +  return descr;
> +}
> +
>  static void
>  xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
>  {
> @@ -131,13 +230,13 @@
>    xfree (descr);
>  }
> 
> -/* For moment, ``struct regcache'' is just a character buffer.  */
> +/* The register cache for storing raw register values.  */
> 
>  struct regcache
>  {
>    struct regcache_descr *descr;
> -  char *registers;
> -  char *register_valid_p;
> +  char *raw_registers;
> +  char *raw_register_valid_p;
>    /* If a value isn't in the cache should the corresponding target be
>       queried for a value.  */
>    int passthrough_p;
> @@ -152,8 +251,10 @@
>    descr = regcache_descr (gdbarch);
>    regcache = XMALLOC (struct regcache);
>    regcache->descr = descr;
> -  regcache->registers = XCALLOC (descr->sizeof_registers, char);
> -  regcache->register_valid_p = XCALLOC (descr->sizeof_register_valid_p, char);
> +  regcache->raw_registers
> +    = XCALLOC (descr->sizeof_raw_registers, char);
> +  regcache->raw_register_valid_p
> +    = XCALLOC (descr->sizeof_raw_register_valid_p, char);
>    regcache->passthrough_p = 0;
>    return regcache;
>  }
> @@ -163,8 +264,8 @@
>  {
>    if (regcache == NULL)
>      return;
> -  xfree (regcache->registers);
> -  xfree (regcache->register_valid_p);
> +  xfree (regcache->raw_registers);
> +  xfree (regcache->raw_register_valid_p);
>    xfree (regcache);
>  }
> 
> @@ -186,33 +287,32 @@
>  regcache_cpy (struct regcache *dst, struct regcache *src)
>  {
>    int i;
> -  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
> +  char *buf;
>    gdb_assert (src != NULL && dst != NULL);
>    gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
>    gdb_assert (src != dst);
>    /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
>       It keeps the existing code working where things rely on going
> -     through the register cache.  */
> -  if (src == current_regcache
> -      && !gdbarch_register_read_p (src->descr->gdbarch))
> +     through to the register cache.  */
> +  if (src == current_regcache && src->descr->legacy_p)
>      {
>        /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
>          untangle fetch.  */
> -      read_register_bytes (0, dst->registers, REGISTER_BYTES);
> +      read_register_bytes (0, dst->raw_registers, REGISTER_BYTES);
>        return;
>      }
>    /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
>       It keeps the existing code working where things rely on going
> -     through the register cache.  */
> -  if (dst == current_regcache
> -      && !gdbarch_register_read_p (dst->descr->gdbarch))
> +     through to the register cache.  */
> +  if (dst == current_regcache && dst->descr->legacy_p)
>      {
>        /* ULGH!!!!  Old way.  Use REGISTER bytes and let code below
>          untangle fetch.  */
> -      write_register_bytes (0, src->registers, REGISTER_BYTES);
> +      write_register_bytes (0, src->raw_registers, REGISTER_BYTES);
>        return;
>      }
> -  for (i = 0; i < current_regcache->descr->nr_registers; i++)
> +  buf = alloca (src->descr->max_register_size);
> +  for (i = 0; i < src->descr->nr_raw_registers; i++)
>      {
>        /* Should we worry about the valid bit here?  */
>        regcache_read (src, i, buf);
> @@ -230,10 +330,10 @@
>       move of data into the current_regcache().  Doing this would be
>       silly - it would mean that valid_p would be completly invalid.  */
>    gdb_assert (dst != current_regcache);
> -  memcpy (dst->registers, src->registers,
> -         dst->descr->sizeof_registers);
> -  memcpy (dst->register_valid_p, src->register_valid_p,
> -         dst->descr->sizeof_register_valid_p);
> +  memcpy (dst->raw_registers, src->raw_registers,
> +         dst->descr->sizeof_raw_registers);
> +  memcpy (dst->raw_register_valid_p, src->raw_register_valid_p,
> +         dst->descr->sizeof_raw_register_valid_p);
>  }
> 
>  struct regcache *
> @@ -260,8 +360,8 @@
>  regcache_valid_p (struct regcache *regcache, int regnum)
>  {
>    gdb_assert (regcache != NULL);
> -  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> -  return regcache->register_valid_p[regnum];
> +  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> +  return regcache->raw_register_valid_p[regnum];
>  }
> 
>  CORE_ADDR
> @@ -269,22 +369,22 @@
>  {
>    char *buf;
>    gdb_assert (regcache != NULL);
> -  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> +  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
>    buf = alloca (regcache->descr->sizeof_register[regnum]);
>    regcache_read (regcache, regnum, buf);
>    return extract_address (buf, regcache->descr->sizeof_register[regnum]);
>  }
> 
>  char *
> -grub_around_regcache_for_registers (struct regcache *regcache)
> +deprecated_grub_regcache_for_registers (struct regcache *regcache)
>  {
> -  return regcache->registers;
> +  return regcache->raw_registers;
>  }
> 
>  char *
> -grub_around_regcache_for_register_valid (struct regcache *regcache)
> +deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
>  {
> -  return regcache->register_valid_p;
> +  return regcache->raw_register_valid_p;
>  }
> 
>  /* Global structure containing the current regcache.  */
> @@ -356,10 +456,9 @@
>     else return a pointer to the start of the cache buffer.  */
> 
>  static char *
> -register_buffer (int regnum)
> +register_buffer (struct regcache *regcache, int regnum)
>  {
> -  gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
> -  return &registers[REGISTER_BYTE (regnum)];
> +  return regcache->raw_registers + regcache->descr->register_offset[regnum];
>  }
> 
>  /* Return whether register REGNUM is a real register.  */
> @@ -570,7 +669,7 @@
>    if (!register_cached (regnum))
>      fetch_register (regnum);
> 
> -  memcpy (myaddr, register_buffer (regnum),
> +  memcpy (myaddr, register_buffer (current_regcache, regnum),
>           REGISTER_RAW_SIZE (regnum));
>  }
> 
> @@ -578,24 +677,44 @@
>  regcache_read (struct regcache *regcache, int regnum, char *buf)
>  {
>    gdb_assert (regcache != NULL && buf != NULL);
> -  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> +  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> +  if (regcache->descr->legacy_p
> +      && regcache->passthrough_p)
> +    {
> +      gdb_assert (regcache == current_regcache);
> +      /* For moment, just use underlying legacy code.  Ulgh!!! This
> +        silently and very indirectly updates the regcache's regcache
> +        via the global register_valid[].  */
> +      legacy_read_register_gen (regnum, buf);
> +      return;
> +    }
> +  /* Make certain that the register cache is up-to-date with respect
> +     to the current thread.  This switching shouldn't be necessary
> +     only there is still only one target side register cache.  Sigh!
> +     On the bright side, at least there is a regcache object.  */
>    if (regcache->passthrough_p)
> -    /* For moment, just use underlying legacy code. Ulgh!!! This
> -       silently and very indirectly updates the regcache's regcache via
> -       the global register_valid[].  */
> -    legacy_read_register_gen (regnum, buf);
> -  else
>      {
> -      memcpy (buf, (regcache->registers
> -                   + regcache->descr->register_offset[regnum]),
> -             regcache->descr->sizeof_register[regnum]);
> +      gdb_assert (regcache == current_regcache);
> +      if (! ptid_equal (registers_ptid, inferior_ptid))
> +       {
> +         registers_changed ();
> +         registers_ptid = inferior_ptid;
> +       }
> +      if (!register_cached (regnum))
> +       fetch_register (regnum);
>      }
> +  /* Copy the value directly into the register cache.  */
> +  memcpy (buf, (regcache->raw_registers
> +               + regcache->descr->register_offset[regnum]),
> +         regcache->descr->sizeof_register[regnum]);
>  }
> 
>  void
>  read_register_gen (int regnum, char *buf)
>  {
> -  if (! gdbarch_register_read_p (current_gdbarch))
> +  gdb_assert (current_regcache != NULL);
> +  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
> +  if (current_regcache->descr->legacy_p)
>      {
>        legacy_read_register_gen (regnum, buf);
>        return;
> @@ -631,13 +750,14 @@
>        /* If we have a valid copy of the register, and new value == old
>          value, then don't bother doing the actual store. */
>        if (register_cached (regnum)
> -         && memcmp (register_buffer (regnum), myaddr, size) == 0)
> +         && (memcmp (register_buffer (current_regcache, regnum), myaddr, size)
> +             == 0))
>         return;
>        else
>         target_prepare_to_store ();
>      }
> 
> -  memcpy (register_buffer (regnum), myaddr, size);
> +  memcpy (register_buffer (current_regcache, regnum), myaddr, size);
> 
>    set_register_cached (regnum, 1);
>    store_register (regnum);
> @@ -647,24 +767,63 @@
>  regcache_write (struct regcache *regcache, int regnum, char *buf)
>  {
>    gdb_assert (regcache != NULL && buf != NULL);
> -  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_registers);
> -  if (regcache->passthrough_p)
> -    /* For moment, just use underlying legacy code. Ulgh!!! This
> -       silently and very indirectly updates the regcache's regcache via
> -       the global register_valid[].  */
> -    legacy_write_register_gen (regnum, buf);
> -  else
> +  gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
> +
> +  if (regcache->passthrough_p
> +      && regcache->descr->legacy_p)
>      {
> -      memcpy (regcache->registers + regcache->descr->register_offset[regnum], buf,
> +      /* For moment, just use underlying legacy code.  Ulgh!!! This
> +        silently and very indirectly updates the regcache's buffers
> +        via the globals register_valid[] and registers[].  */
> +      gdb_assert (regcache == current_regcache);
> +      legacy_write_register_gen (regnum, buf);
> +      return;
> +    }
> +
> +  /* On the sparc, writing %g0 is a no-op, so we don't even want to
> +     change the registers array if something writes to this register.  */
> +  if (CANNOT_STORE_REGISTER (regnum))
> +    return;
> +
> +  /* Handle the simple case first -> not write through so just store
> +     value in cache.  */
> +  if (!regcache->passthrough_p)
> +    {
> +      memcpy ((regcache->raw_registers
> +              + regcache->descr->register_offset[regnum]), buf,
>               regcache->descr->sizeof_register[regnum]);
> -      regcache->register_valid_p[regnum] = 1;
> +      regcache->raw_register_valid_p[regnum] = 1;
> +      return;
>      }
> +
> +  /* Make certain that the correct cache is selected.  */
> +  gdb_assert (regcache == current_regcache);
> +  if (! ptid_equal (registers_ptid, inferior_ptid))
> +    {
> +      registers_changed ();
> +      registers_ptid = inferior_ptid;
> +    }
> +
> +  /* If we have a valid copy of the register, and new value == old
> +     value, then don't bother doing the actual store. */
> +  if (regcache_valid_p (regcache, regnum)
> +      && (memcmp (register_buffer (regcache, regnum), buf,
> +                 regcache->descr->sizeof_register[regnum]) == 0))
> +    return;
> +
> +  target_prepare_to_store ();
> +  memcpy (register_buffer (regcache, regnum), buf,
> +         regcache->descr->sizeof_register[regnum]);
> +  regcache->raw_register_valid_p[regnum] = 1;
> +  store_register (regnum);
>  }
> 
>  void
>  write_register_gen (int regnum, char *buf)
>  {
> -  if (! gdbarch_register_write_p (current_gdbarch))
> +  gdb_assert (current_regcache != NULL);
> +  gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
> +  if (current_regcache->descr->legacy_p)
>      {
>        legacy_write_register_gen (regnum, buf);
>        return;
> @@ -843,10 +1002,10 @@
> 
>    set_register_cached (regnum, 1);
>    if (val)
> -    memcpy (register_buffer (regnum), val,
> +    memcpy (register_buffer (current_regcache, regnum), val,
>             REGISTER_RAW_SIZE (regnum));
>    else
> -    memset (register_buffer (regnum), '\000',
> +    memset (register_buffer (current_regcache, regnum), '\000',
>             REGISTER_RAW_SIZE (regnum));
> 
>    /* On some architectures, e.g. HPPA, there are a few stray bits in
> @@ -866,7 +1025,8 @@
>  void
>  regcache_collect (int regnum, void *buf)
>  {
> -  memcpy (buf, register_buffer (regnum), REGISTER_RAW_SIZE (regnum));
> +  memcpy (buf, register_buffer (current_regcache, regnum),
> +         REGISTER_RAW_SIZE (regnum));
>  }
> 
> 
> @@ -1036,15 +1196,14 @@
>  {
>    current_regcache = regcache_xmalloc (current_gdbarch);
>    current_regcache->passthrough_p = 1;
> -  registers = grub_around_regcache_for_registers (current_regcache);
> -  register_valid = grub_around_regcache_for_register_valid (current_regcache);
> +  registers = deprecated_grub_regcache_for_registers (current_regcache);
> +  register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
>  }
> 
>  void
>  regcache_save (struct regcache *regcache)
>  {
>    int i;
> -  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
>    gdb_assert (current_regcache != NULL && regcache != NULL);
>    gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
>    regcache_cpy (regcache, current_regcache);
> @@ -1062,7 +1221,6 @@
>  regcache_restore (struct regcache *regcache)
>  {
>    int i;
> -  char *buf = alloca (MAX_REGISTER_RAW_SIZE);
>    gdb_assert (current_regcache != NULL && regcache != NULL);
>    gdb_assert (current_regcache->descr->gdbarch == regcache->descr->gdbarch);
>    regcache_cpy (current_regcache, regcache);
> Index: regcache.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/regcache.h,v
> retrieving revision 1.6.6.4
> diff -u -r1.6.6.4 regcache.h
> --- regcache.h  17 May 2002 16:17:30 -0000      1.6.6.4
> +++ regcache.h  23 May 2002 17:47:27 -0000
> @@ -73,8 +73,8 @@
>  extern void regcache_cpy (struct regcache *dest, struct regcache *src);
>  extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
> 
> -extern char *grub_around_regcache_for_registers (struct regcache *);
> -extern char *grub_around_regcache_for_register_valid (struct regcache *);
> +extern char *deprecated_grub_regcache_for_registers (struct regcache *);
> +extern char *deprecated_grub_regcache_for_register_valid (struct regcache *);
> 
>  extern int register_cached (int regnum);
> 
> Index: rs6000-tdep.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
> retrieving revision 1.64.2.2
> diff -u -r1.64.2.2 rs6000-tdep.c
> --- rs6000-tdep.c       16 May 2002 19:08:01 -0000      1.64.2.2
> +++ rs6000-tdep.c       23 May 2002 17:47:29 -0000
> @@ -1150,7 +1150,7 @@
>  {
>    int offset = 0;
>    struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
> -  char *regbuf = grub_around_regcache_for_registers (regs);
> +  char *regbuf = deprecated_grub_regcache_for_registers (regs);
> 
>    if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
>      {


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]