[deliverable/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)
	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_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)
{
  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 optim;
  get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
		      regnum, (enum lval_type *) NULL);

  /* 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 !optim;
}


/* 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)
	118	read_register_gen (regnum, bufferp);
	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
135c175f AC	127	void
	128	frame_unwind_signed_register (struct frame_info *frame, int regnum,
	129	LONGEST *val)
	130	{
	131	int optimized;
	132	CORE_ADDR addr;
	133	int realnum;
	134	enum lval_type lval;
	135	void *buf = alloca (MAX_REGISTER_RAW_SIZE);
	136	frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
	137	&realnum, buf);
	138	(*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
	139	}
	140
	141	void
	142	frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
	143	ULONGEST *val)
	144	{
	145	int optimized;
	146	CORE_ADDR addr;
	147	int realnum;
	148	enum lval_type lval;
	149	void *buf = alloca (MAX_REGISTER_RAW_SIZE);
	150	frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
	151	&realnum, buf);
	152	(*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
	153	}
4f460812	154
f908a0eb AC	155	void
	156	frame_read_unsigned_register (struct frame_info *frame, int regnum,
	157	ULONGEST *val)
	158	{
	159	/* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
	160	always a frame. Both this, and the equivalent
	161	frame_read_signed_register() function, can only be called with a
	162	valid frame. If, for some reason, this function is called
	163	without a frame then the problem isn't here, but rather in the
	164	caller. It should of first created a frame and then passed that
	165	in. */
	166	/* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
	167	``current_frame'' should not be treated as a special case. While
	168	``get_next_frame (current_frame) == NULL'' currently holds, it
	169	should, as far as possible, not be relied upon. In the future,
	170	``get_next_frame (current_frame)'' may instead simply return a
	171	normal frame object that simply always gets register values from
	172	the register cache. Consequently, frame code should try to avoid
	173	tests like ``if get_next_frame() == NULL'' and instead just rely
	174	on recursive frame calls (like the below code) when manipulating
	175	a frame chain. */
	176	gdb_assert (frame != NULL);
	177	frame_unwind_unsigned_register (get_next_frame (frame), regnum, val);
	178	}
	179
	180	void
	181	frame_read_signed_register (struct frame_info *frame, int regnum,
	182	LONGEST *val)
	183	{
	184	/* See note in frame_read_unsigned_register(). */
	185	gdb_assert (frame != NULL);
	186	frame_unwind_signed_register (get_next_frame (frame), regnum, val);
	187	}
	188
4f460812 AC	189	void
	190	generic_unwind_get_saved_register (char *raw_buffer,
	191	int *optimizedp,
	192	CORE_ADDR *addrp,
	193	struct frame_info *frame,
	194	int regnum,
	195	enum lval_type *lvalp)
	196	{
	197	int optimizedx;
	198	CORE_ADDR addrx;
	199	int realnumx;
	200	enum lval_type lvalx;
	201
	202	if (!target_has_registers)
	203	error ("No registers.");
	204
	205	/* Keep things simple, ensure that all the pointers (except valuep)
	206	are non NULL. */
	207	if (optimizedp == NULL)
	208	optimizedp = &optimizedx;
	209	if (lvalp == NULL)
	210	lvalp = &lvalx;
	211	if (addrp == NULL)
	212	addrp = &addrx;
	213
	214	/* Reached the the bottom (youngest, inner most) of the frame chain
	215	(youngest, inner most) frame, go direct to the hardware register
	216	cache (do not pass go, do not try to cache the value, ...). The
	217	unwound value would have been cached in frame->next but that
	218	doesn't exist. This doesn't matter as the hardware register
	219	cache is stopping any unnecessary accesses to the target. */
	220
	221	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
	222	special case, there was always an inner frame dedicated to the
	223	hardware registers. Unfortunatly, there is too much unwind code
	224	around that looks up/down the frame chain while making the
	225	assumption that each frame level is using the same unwind code. */
	226
	227	if (frame == NULL)
	228	frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
	229	raw_buffer);
	230	else
	231	frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
	232	&realnumx, raw_buffer);
	233	}
	234
d65fe839 AC	235	void
	236	get_saved_register (char *raw_buffer,
	237	int *optimized,
	238	CORE_ADDR *addrp,
	239	struct frame_info *frame,
	240	int regnum,
	241	enum lval_type *lval)
	242	{
	243	GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
	244	}
	245
cda5a58a	246	/* frame_register_read ()
d65fe839	247
cda5a58a	248	Find and return the value of REGNUM for the specified stack frame.
d65fe839 AC	249	The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
d65fe839 AC	250
cda5a58a	251	Returns 0 if the register value could not be found. */
d65fe839	252
cda5a58a AC	253	int
cda5a58a AC	254	frame_register_read (struct frame_info frame, int regnum, void myaddr)
d65fe839 AC	255	{
d65fe839 AC	256	int optim;
d65fe839 AC	257	get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
	258	regnum, (enum lval_type *) NULL);
	259
c97dcfc7 AC	260	/* FIXME: cagney/2002-05-15: This test, is just bogus.
	261
	262	It indicates that the target failed to supply a value for a
	263	register because it was "not available" at this time. Problem
	264	is, the target still has the register and so get saved_register()
	265	may be returning a value saved on the stack. */
	266
d65fe839	267	if (register_cached (regnum) < 0)
cda5a58a	268	return 0; /* register value not available */
d65fe839	269
cda5a58a	270	return !optim;
d65fe839	271	}
e36180d7 AC	272
	273
	274	/* Map between a frame register number and its name. A frame register
	275	space is a superset of the cooked register space --- it also
	276	includes builtin registers. */
	277
	278	int
	279	frame_map_name_to_regnum (const char *name, int len)
	280	{
	281	int i;
	282
	283	/* Search register name space. */
	284	for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
	285	if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
	286	&& strncmp (name, REGISTER_NAME (i), len) == 0)
	287	{
	288	return i;
	289	}
	290
	291	/* Try builtin registers. */
	292	i = builtin_reg_map_name_to_regnum (name, len);
	293	if (i >= 0)
	294	{
	295	/* A builtin register doesn't fall into the architecture's
	296	register range. */
	297	gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
	298	return i;
	299	}
	300
	301	return -1;
	302	}
	303
	304	const char *
	305	frame_map_regnum_to_name (int regnum)
	306	{
	307	if (regnum < 0)
	308	return NULL;
	309	if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
	310	return REGISTER_NAME (regnum);
	311	return builtin_reg_map_regnum_to_name (regnum);
	312	}