[thirdparty/binutils-gdb.git] / gdb / frame.c

/* Cache and manage frames for GDB, the GNU debugger.

   Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
   2001, 2002 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "frame.h"
#include "target.h"
#include "value.h"
#include "inferior.h"	/* for inferior_ptid */
#include "regcache.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include "builtin-regs.h"

/* Return a frame uniq ID that can be used to, later re-find the
   frame.  */

void
get_frame_id (struct frame_info *fi, struct frame_id *id)
{
  if (fi == NULL)
    {
      id->base = 0;
      id->pc = 0;
    }
  else
    {
      id->base = FRAME_FP (fi);
      id->pc = fi->pc;
    }
}

struct frame_info *
frame_find_by_id (struct frame_id id)
{
  struct frame_info *frame;

  /* ZERO denotes the null frame, let the caller decide what to do
     about it.  Should it instead return get_current_frame()?  */
  if (id.base == 0 && id.pc == 0)
    return NULL;

  for (frame = get_current_frame ();
       frame != NULL;
       frame = get_prev_frame (frame))
    {
      if (INNER_THAN (FRAME_FP (frame), id.base))
	/* ``inner/current < frame < id.base''.  Keep looking along
           the frame chain.  */
	continue;
      if (INNER_THAN (id.base, FRAME_FP (frame)))
	/* ``inner/current < id.base < frame''.  Oops, gone past it.
           Just give up.  */
	return NULL;
      /* FIXME: cagney/2002-04-21: This isn't sufficient.  It should
	 use id.pc to check that the two frames belong to the same
	 function.  Otherwise we'll do things like match dummy frames
	 or mis-match frameless functions.  However, until someone
	 notices, stick with the existing behavour.  */
      return frame;
    }
  return NULL;
}

void
frame_register_unwind (struct frame_info *frame, int regnum,
		       int *optimizedp, enum lval_type *lvalp,
		       CORE_ADDR *addrp, int *realnump, void *bufferp)
{
  struct frame_unwind_cache *cache;

  /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
     that the value proper does not need to be fetched.  */
  gdb_assert (optimizedp != NULL);
  gdb_assert (lvalp != NULL);
  gdb_assert (addrp != NULL);
  gdb_assert (realnump != NULL);
  /* gdb_assert (bufferp != NULL); */

  /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
     special case, there was always an inner frame dedicated to the
     hardware registers.  Unfortunatly, there is too much unwind code
     around that looks up/down the frame chain while making the
     assumption that each frame level is using the same unwind code.  */

  if (frame == NULL)
    {
      /* We're in the inner-most frame, get the value direct from the
	 register cache.  */
      *optimizedp = 0;
      *lvalp = lval_register;
      /* ULGH!  Code uses the offset into the raw register byte array
         as a way of identifying a register.  */
      *addrp = REGISTER_BYTE (regnum);
      /* Should this code test ``register_cached (regnum) < 0'' and do
         something like set realnum to -1 when the register isn't
         available?  */
      *realnump = regnum;
      if (bufferp)
	deprecated_read_register_gen (regnum, bufferp);
      return;
    }

  /* Ask this frame to unwind its register.  */
  frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
			  optimizedp, lvalp, addrp, realnump, bufferp);
}

void
frame_register (struct frame_info *frame, int regnum,
		int *optimizedp, enum lval_type *lvalp,
		CORE_ADDR *addrp, int *realnump, void *bufferp)
{
  /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
     that the value proper does not need to be fetched.  */
  gdb_assert (optimizedp != NULL);
  gdb_assert (lvalp != NULL);
  gdb_assert (addrp != NULL);
  gdb_assert (realnump != NULL);
  /* gdb_assert (bufferp != NULL); */

  /* Ulgh!  Old code that, for lval_register, sets ADDRP to the offset
     of the register in the register cache.  It should instead return
     the REGNUM corresponding to that register.  Translate the .  */
  if (GET_SAVED_REGISTER_P ())
    {
      GET_SAVED_REGISTER (bufferp, optimizedp, addrp, frame, regnum, lvalp);
      /* Compute the REALNUM if the caller wants it.  */
      if (*lvalp == lval_register)
	{
	  int regnum;
	  for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
	    {
	      if (*addrp == register_offset_hack (current_gdbarch, regnum))
		{
		  *realnump = regnum;
		  return;
		}
	    }
	  internal_error (__FILE__, __LINE__,
			  "Failed to compute the register number corresponding"
			  " to 0x%s", paddr_d (*addrp));
	}
      *realnump = -1;
      return;
    }

  /* Reached the the bottom (youngest, inner most) of the frame chain
     (youngest, inner most) frame, go direct to the hardware register
     cache (do not pass go, do not try to cache the value, ...).  The
     unwound value would have been cached in frame->next but that
     doesn't exist.  This doesn't matter as the hardware register
     cache is stopping any unnecessary accesses to the target.  */

  /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
     special case, there was always an inner frame dedicated to the
     hardware registers.  Unfortunatly, there is too much unwind code
     around that looks up/down the frame chain while making the
     assumption that each frame level is using the same unwind code.  */

  if (frame == NULL)
    frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, realnump,
			   bufferp);
  else
    frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
			   realnump, bufferp);
}

void
frame_unwind_signed_register (struct frame_info *frame, int regnum,
			      LONGEST *val)
{
  int optimized;
  CORE_ADDR addr;
  int realnum;
  enum lval_type lval;
  void *buf = alloca (MAX_REGISTER_RAW_SIZE);
  frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
			 &realnum, buf);
  (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
}

void
frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
				ULONGEST *val)
{
  int optimized;
  CORE_ADDR addr;
  int realnum;
  enum lval_type lval;
  void *buf = alloca (MAX_REGISTER_RAW_SIZE);
  frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
			 &realnum, buf);
  (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
}

void
frame_read_unsigned_register (struct frame_info *frame, int regnum,
			      ULONGEST *val)
{
  /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
     always a frame.  Both this, and the equivalent
     frame_read_signed_register() function, can only be called with a
     valid frame.  If, for some reason, this function is called
     without a frame then the problem isn't here, but rather in the
     caller.  It should of first created a frame and then passed that
     in.  */
  /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
     ``current_frame'' should not be treated as a special case.  While
     ``get_next_frame (current_frame) == NULL'' currently holds, it
     should, as far as possible, not be relied upon.  In the future,
     ``get_next_frame (current_frame)'' may instead simply return a
     normal frame object that simply always gets register values from
     the register cache.  Consequently, frame code should try to avoid
     tests like ``if get_next_frame() == NULL'' and instead just rely
     on recursive frame calls (like the below code) when manipulating
     a frame chain.  */
  gdb_assert (frame != NULL);
  frame_unwind_unsigned_register (get_next_frame (frame), regnum, val);
}

void
frame_read_signed_register (struct frame_info *frame, int regnum,
			    LONGEST *val)
{
  /* See note in frame_read_unsigned_register().  */
  gdb_assert (frame != NULL);
  frame_unwind_signed_register (get_next_frame (frame), regnum, val);
}

void
generic_unwind_get_saved_register (char *raw_buffer,
				   int *optimizedp,
				   CORE_ADDR *addrp,
				   struct frame_info *frame,
				   int regnum,
				   enum lval_type *lvalp)
{
  int optimizedx;
  CORE_ADDR addrx;
  int realnumx;
  enum lval_type lvalx;

  if (!target_has_registers)
    error ("No registers.");

  /* Keep things simple, ensure that all the pointers (except valuep)
     are non NULL.  */
  if (optimizedp == NULL)
    optimizedp = &optimizedx;
  if (lvalp == NULL)
    lvalp = &lvalx;
  if (addrp == NULL)
    addrp = &addrx;

  /* Reached the the bottom (youngest, inner most) of the frame chain
     (youngest, inner most) frame, go direct to the hardware register
     cache (do not pass go, do not try to cache the value, ...).  The
     unwound value would have been cached in frame->next but that
     doesn't exist.  This doesn't matter as the hardware register
     cache is stopping any unnecessary accesses to the target.  */

  /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
     special case, there was always an inner frame dedicated to the
     hardware registers.  Unfortunatly, there is too much unwind code
     around that looks up/down the frame chain while making the
     assumption that each frame level is using the same unwind code.  */

  if (frame == NULL)
    frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
			   raw_buffer);
  else
    frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
			   &realnumx, raw_buffer);
}

void
get_saved_register (char *raw_buffer,
		    int *optimized,
		    CORE_ADDR *addrp,
		    struct frame_info *frame,
		    int regnum,
		    enum lval_type *lval)
{
  if (GET_SAVED_REGISTER_P ())
    {
      GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
      return;
    }
  generic_unwind_get_saved_register (raw_buffer, optimized, addrp, frame,
				     regnum, lval);
}

/* frame_register_read ()

   Find and return the value of REGNUM for the specified stack frame.
   The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).

   Returns 0 if the register value could not be found.  */

int
frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
{
  int optimized;
  enum lval_type lval;
  CORE_ADDR addr;
  int realnum;
  frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);

  /* FIXME: cagney/2002-05-15: This test, is just bogus.

     It indicates that the target failed to supply a value for a
     register because it was "not available" at this time.  Problem
     is, the target still has the register and so get saved_register()
     may be returning a value saved on the stack.  */

  if (register_cached (regnum) < 0)
    return 0;			/* register value not available */

  return !optimized;
}


/* Map between a frame register number and its name.  A frame register
   space is a superset of the cooked register space --- it also
   includes builtin registers.  */

int
frame_map_name_to_regnum (const char *name, int len)
{
  int i;

  /* Search register name space. */
  for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
    if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
	&& strncmp (name, REGISTER_NAME (i), len) == 0)
      {
	return i;
      }

  /* Try builtin registers.  */
  i = builtin_reg_map_name_to_regnum (name, len);
  if (i >= 0)
    {
      /* A builtin register doesn't fall into the architecture's
         register range.  */
      gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
      return i;
    }

  return -1;
}

const char *
frame_map_regnum_to_name (int regnum)
{
  if (regnum < 0)
    return NULL;
  if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
    return REGISTER_NAME (regnum);
  return builtin_reg_map_regnum_to_name (regnum);
}
Commit	Line	Data
4f460812	1	/* Cache and manage frames for GDB, the GNU debugger.
96cb11df AC	2
	3	Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
	4	2001, 2002 Free Software Foundation, Inc.
d65fe839 AC	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
	23	#include "defs.h"
	24	#include "frame.h"
	25	#include "target.h"
	26	#include "value.h"
39f77062	27	#include "inferior.h" /* for inferior_ptid */
4e052eda	28	#include "regcache.h"
4f460812	29	#include "gdb_assert.h"
e36180d7 AC	30	#include "gdb_string.h"
e36180d7 AC	31	#include "builtin-regs.h"
d65fe839	32
101dcfbe AC	33	/* Return a frame uniq ID that can be used to, later re-find the
	34	frame. */
	35
	36	void
	37	get_frame_id (struct frame_info fi, struct frame_id id)
	38	{
	39	if (fi == NULL)
	40	{
	41	id->base = 0;
	42	id->pc = 0;
	43	}
	44	else
	45	{
	46	id->base = FRAME_FP (fi);
	47	id->pc = fi->pc;
	48	}
	49	}
	50
	51	struct frame_info *
	52	frame_find_by_id (struct frame_id id)
	53	{
	54	struct frame_info *frame;
	55
	56	/* ZERO denotes the null frame, let the caller decide what to do
	57	about it. Should it instead return get_current_frame()? */
	58	if (id.base == 0 && id.pc == 0)
	59	return NULL;
	60
	61	for (frame = get_current_frame ();
	62	frame != NULL;
	63	frame = get_prev_frame (frame))
	64	{
	65	if (INNER_THAN (FRAME_FP (frame), id.base))
	66	/* ``inner/current < frame < id.base''. Keep looking along
	67	the frame chain. */
	68	continue;
	69	if (INNER_THAN (id.base, FRAME_FP (frame)))
	70	/* ``inner/current < id.base < frame''. Oops, gone past it.
	71	Just give up. */
	72	return NULL;
	73	/* FIXME: cagney/2002-04-21: This isn't sufficient. It should
	74	use id.pc to check that the two frames belong to the same
	75	function. Otherwise we'll do things like match dummy frames
	76	or mis-match frameless functions. However, until someone
	77	notices, stick with the existing behavour. */
	78	return frame;
	79	}
	80	return NULL;
	81	}
	82
4f460812 AC	83	void
	84	frame_register_unwind (struct frame_info *frame, int regnum,
	85	int optimizedp, enum lval_type lvalp,
	86	CORE_ADDR addrp, int realnump, void *bufferp)
	87	{
	88	struct frame_unwind_cache *cache;
	89
	90	/* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
	91	that the value proper does not need to be fetched. */
	92	gdb_assert (optimizedp != NULL);
	93	gdb_assert (lvalp != NULL);
	94	gdb_assert (addrp != NULL);
	95	gdb_assert (realnump != NULL);
	96	/* gdb_assert (bufferp != NULL); */
	97
	98	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
	99	special case, there was always an inner frame dedicated to the
	100	hardware registers. Unfortunatly, there is too much unwind code
	101	around that looks up/down the frame chain while making the
	102	assumption that each frame level is using the same unwind code. */
	103
	104	if (frame == NULL)
	105	{
	106	/* We're in the inner-most frame, get the value direct from the
	107	register cache. */
	108	*optimizedp = 0;
	109	*lvalp = lval_register;
fa5f27c7 AC	110	/* ULGH! Code uses the offset into the raw register byte array
	111	as a way of identifying a register. */
	112	*addrp = REGISTER_BYTE (regnum);
4f460812 AC	113	/* Should this code test ``register_cached (regnum) < 0'' and do
	114	something like set realnum to -1 when the register isn't
	115	available? */
	116	*realnump = regnum;
	117	if (bufferp)
4caf0990	118	deprecated_read_register_gen (regnum, bufferp);
4f460812 AC	119	return;
	120	}
	121
	122	/* Ask this frame to unwind its register. */
	123	frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
	124	optimizedp, lvalp, addrp, realnump, bufferp);
	125	}
	126
a216a322 AC	127	void
	128	frame_register (struct frame_info *frame, int regnum,
	129	int optimizedp, enum lval_type lvalp,
	130	CORE_ADDR addrp, int realnump, void *bufferp)
	131	{
	132	/* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
	133	that the value proper does not need to be fetched. */
	134	gdb_assert (optimizedp != NULL);
	135	gdb_assert (lvalp != NULL);
	136	gdb_assert (addrp != NULL);
	137	gdb_assert (realnump != NULL);
	138	/* gdb_assert (bufferp != NULL); */
	139
	140	/* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
	141	of the register in the register cache. It should instead return
	142	the REGNUM corresponding to that register. Translate the . */
	143	if (GET_SAVED_REGISTER_P ())
	144	{
	145	GET_SAVED_REGISTER (bufferp, optimizedp, addrp, frame, regnum, lvalp);
	146	/* Compute the REALNUM if the caller wants it. */
	147	if (*lvalp == lval_register)
	148	{
	149	int regnum;
	150	for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
	151	{
	152	if (*addrp == register_offset_hack (current_gdbarch, regnum))
	153	{
	154	*realnump = regnum;
	155	return;
	156	}
	157	}
	158	internal_error (__FILE__, __LINE__,
	159	"Failed to compute the register number corresponding"
	160	" to 0x%s", paddr_d (*addrp));
	161	}
	162	*realnump = -1;
	163	return;
	164	}
	165
	166	/* Reached the the bottom (youngest, inner most) of the frame chain
	167	(youngest, inner most) frame, go direct to the hardware register
	168	cache (do not pass go, do not try to cache the value, ...). The
	169	unwound value would have been cached in frame->next but that
	170	doesn't exist. This doesn't matter as the hardware register
	171	cache is stopping any unnecessary accesses to the target. */
	172
	173	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
	174	special case, there was always an inner frame dedicated to the
	175	hardware registers. Unfortunatly, there is too much unwind code
	176	around that looks up/down the frame chain while making the
	177	assumption that each frame level is using the same unwind code. */
	178
	179	if (frame == NULL)
	180	frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, realnump,
	181	bufferp);
	182	else
	183	frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
	184	realnump, bufferp);
	185	}
	186
135c175f AC	187	void
	188	frame_unwind_signed_register (struct frame_info *frame, int regnum,
	189	LONGEST *val)
	190	{
	191	int optimized;
	192	CORE_ADDR addr;
	193	int realnum;
	194	enum lval_type lval;
	195	void *buf = alloca (MAX_REGISTER_RAW_SIZE);
	196	frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
	197	&realnum, buf);
	198	(*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
	199	}
	200
	201	void
	202	frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
	203	ULONGEST *val)
	204	{
	205	int optimized;
	206	CORE_ADDR addr;
	207	int realnum;
	208	enum lval_type lval;
	209	void *buf = alloca (MAX_REGISTER_RAW_SIZE);
	210	frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
	211	&realnum, buf);
	212	(*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
	213	}
4f460812	214
f908a0eb AC	215	void
	216	frame_read_unsigned_register (struct frame_info *frame, int regnum,
	217	ULONGEST *val)
	218	{
	219	/* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
	220	always a frame. Both this, and the equivalent
	221	frame_read_signed_register() function, can only be called with a
	222	valid frame. If, for some reason, this function is called
	223	without a frame then the problem isn't here, but rather in the
	224	caller. It should of first created a frame and then passed that
	225	in. */
	226	/* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
	227	``current_frame'' should not be treated as a special case. While
	228	``get_next_frame (current_frame) == NULL'' currently holds, it
	229	should, as far as possible, not be relied upon. In the future,
	230	``get_next_frame (current_frame)'' may instead simply return a
	231	normal frame object that simply always gets register values from
	232	the register cache. Consequently, frame code should try to avoid
	233	tests like ``if get_next_frame() == NULL'' and instead just rely
	234	on recursive frame calls (like the below code) when manipulating
	235	a frame chain. */
	236	gdb_assert (frame != NULL);
	237	frame_unwind_unsigned_register (get_next_frame (frame), regnum, val);
	238	}
	239
	240	void
	241	frame_read_signed_register (struct frame_info *frame, int regnum,
	242	LONGEST *val)
	243	{
	244	/* See note in frame_read_unsigned_register(). */
	245	gdb_assert (frame != NULL);
	246	frame_unwind_signed_register (get_next_frame (frame), regnum, val);
	247	}
	248
4f460812 AC	249	void
	250	generic_unwind_get_saved_register (char *raw_buffer,
	251	int *optimizedp,
	252	CORE_ADDR *addrp,
	253	struct frame_info *frame,
	254	int regnum,
	255	enum lval_type *lvalp)
	256	{
	257	int optimizedx;
	258	CORE_ADDR addrx;
	259	int realnumx;
	260	enum lval_type lvalx;
	261
	262	if (!target_has_registers)
	263	error ("No registers.");
	264
	265	/* Keep things simple, ensure that all the pointers (except valuep)
	266	are non NULL. */
	267	if (optimizedp == NULL)
	268	optimizedp = &optimizedx;
	269	if (lvalp == NULL)
	270	lvalp = &lvalx;
	271	if (addrp == NULL)
	272	addrp = &addrx;
	273
	274	/* Reached the the bottom (youngest, inner most) of the frame chain
	275	(youngest, inner most) frame, go direct to the hardware register
	276	cache (do not pass go, do not try to cache the value, ...). The
	277	unwound value would have been cached in frame->next but that
	278	doesn't exist. This doesn't matter as the hardware register
	279	cache is stopping any unnecessary accesses to the target. */
	280
	281	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
	282	special case, there was always an inner frame dedicated to the
	283	hardware registers. Unfortunatly, there is too much unwind code
	284	around that looks up/down the frame chain while making the
	285	assumption that each frame level is using the same unwind code. */
	286
	287	if (frame == NULL)
	288	frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
	289	raw_buffer);
	290	else
	291	frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
	292	&realnumx, raw_buffer);
	293	}
	294
d65fe839 AC	295	void
	296	get_saved_register (char *raw_buffer,
	297	int *optimized,
	298	CORE_ADDR *addrp,
	299	struct frame_info *frame,
	300	int regnum,
	301	enum lval_type *lval)
	302	{
a216a322 AC	303	if (GET_SAVED_REGISTER_P ())
	304	{
	305	GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
	306	return;
	307	}
	308	generic_unwind_get_saved_register (raw_buffer, optimized, addrp, frame,
	309	regnum, lval);
d65fe839 AC	310	}
d65fe839 AC	311
cda5a58a	312	/* frame_register_read ()
d65fe839	313
cda5a58a	314	Find and return the value of REGNUM for the specified stack frame.
d65fe839 AC	315	The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
d65fe839 AC	316
cda5a58a	317	Returns 0 if the register value could not be found. */
d65fe839	318
cda5a58a AC	319	int
cda5a58a AC	320	frame_register_read (struct frame_info frame, int regnum, void myaddr)
d65fe839	321	{
a216a322 AC	322	int optimized;
	323	enum lval_type lval;
	324	CORE_ADDR addr;
	325	int realnum;
	326	frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
d65fe839	327
c97dcfc7 AC	328	/* FIXME: cagney/2002-05-15: This test, is just bogus.
	329
	330	It indicates that the target failed to supply a value for a
	331	register because it was "not available" at this time. Problem
	332	is, the target still has the register and so get saved_register()
	333	may be returning a value saved on the stack. */
	334
d65fe839	335	if (register_cached (regnum) < 0)
cda5a58a	336	return 0; /* register value not available */
d65fe839	337
a216a322	338	return !optimized;
d65fe839	339	}
e36180d7 AC	340
	341
	342	/* Map between a frame register number and its name. A frame register
	343	space is a superset of the cooked register space --- it also
	344	includes builtin registers. */
	345
	346	int
	347	frame_map_name_to_regnum (const char *name, int len)
	348	{
	349	int i;
	350
	351	/* Search register name space. */
	352	for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
	353	if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
	354	&& strncmp (name, REGISTER_NAME (i), len) == 0)
	355	{
	356	return i;
	357	}
	358
	359	/* Try builtin registers. */
	360	i = builtin_reg_map_name_to_regnum (name, len);
	361	if (i >= 0)
	362	{
	363	/* A builtin register doesn't fall into the architecture's
	364	register range. */
	365	gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
	366	return i;
	367	}
	368
	369	return -1;
	370	}
	371
	372	const char *
	373	frame_map_regnum_to_name (int regnum)
	374	{
	375	if (regnum < 0)
	376	return NULL;
	377	if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
	378	return REGISTER_NAME (regnum);
	379	return builtin_reg_map_regnum_to_name (regnum);
	380	}