[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"

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

/* FIND_SAVED_REGISTER ()

   Return the address in which frame FRAME's value of register REGNUM
   has been saved in memory.  Or return zero if it has not been saved.
   If REGNUM specifies the SP, the value we return is actually
   the SP value, not an address where it was saved.  */

CORE_ADDR
find_saved_register (struct frame_info *frame, int regnum)
{
  register struct frame_info *frame1 = NULL;
  register CORE_ADDR addr = 0;

  if (frame == NULL)		/* No regs saved if want current frame */
    return 0;

  /* Note that this next routine assumes that registers used in
     frame x will be saved only in the frame that x calls and
     frames interior to it.  This is not true on the sparc, but the
     above macro takes care of it, so we should be all right. */
  while (1)
    {
      QUIT;
      frame1 = get_next_frame (frame);
      if (frame1 == 0)
	break;
      frame = frame1;
      FRAME_INIT_SAVED_REGS (frame1);
      if (frame1->saved_regs[regnum])
	addr = frame1->saved_regs[regnum];
    }

  return addr;
}

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;
      *addrp = 0;
      /* 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
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;
}
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"
d65fe839	30
101dcfbe AC	31	/* Return a frame uniq ID that can be used to, later re-find the
	32	frame. */
	33
	34	void
	35	get_frame_id (struct frame_info fi, struct frame_id id)
	36	{
	37	if (fi == NULL)
	38	{
	39	id->base = 0;
	40	id->pc = 0;
	41	}
	42	else
	43	{
	44	id->base = FRAME_FP (fi);
	45	id->pc = fi->pc;
	46	}
	47	}
	48
	49	struct frame_info *
	50	frame_find_by_id (struct frame_id id)
	51	{
	52	struct frame_info *frame;
	53
	54	/* ZERO denotes the null frame, let the caller decide what to do
	55	about it. Should it instead return get_current_frame()? */
	56	if (id.base == 0 && id.pc == 0)
	57	return NULL;
	58
	59	for (frame = get_current_frame ();
	60	frame != NULL;
	61	frame = get_prev_frame (frame))
	62	{
	63	if (INNER_THAN (FRAME_FP (frame), id.base))
	64	/* ``inner/current < frame < id.base''. Keep looking along
	65	the frame chain. */
	66	continue;
	67	if (INNER_THAN (id.base, FRAME_FP (frame)))
	68	/* ``inner/current < id.base < frame''. Oops, gone past it.
	69	Just give up. */
	70	return NULL;
	71	/* FIXME: cagney/2002-04-21: This isn't sufficient. It should
	72	use id.pc to check that the two frames belong to the same
	73	function. Otherwise we'll do things like match dummy frames
	74	or mis-match frameless functions. However, until someone
	75	notices, stick with the existing behavour. */
	76	return frame;
	77	}
	78	return NULL;
	79	}
	80
d65fe839 AC	81	/* FIND_SAVED_REGISTER ()
	82
	83	Return the address in which frame FRAME's value of register REGNUM
	84	has been saved in memory. Or return zero if it has not been saved.
	85	If REGNUM specifies the SP, the value we return is actually
	86	the SP value, not an address where it was saved. */
	87
	88	CORE_ADDR
	89	find_saved_register (struct frame_info *frame, int regnum)
	90	{
	91	register struct frame_info *frame1 = NULL;
	92	register CORE_ADDR addr = 0;
	93
	94	if (frame == NULL) /* No regs saved if want current frame */
	95	return 0;
	96
d65fe839 AC	97	/* Note that this next routine assumes that registers used in
	98	frame x will be saved only in the frame that x calls and
	99	frames interior to it. This is not true on the sparc, but the
	100	above macro takes care of it, so we should be all right. */
	101	while (1)
	102	{
	103	QUIT;
aa40ec90 JT	104	frame1 = get_next_frame (frame);
aa40ec90 JT	105	if (frame1 == 0)
d65fe839	106	break;
aa40ec90	107	frame = frame1;
d65fe839 AC	108	FRAME_INIT_SAVED_REGS (frame1);
	109	if (frame1->saved_regs[regnum])
	110	addr = frame1->saved_regs[regnum];
	111	}
	112
	113	return addr;
	114	}
	115
4f460812 AC	116	void
	117	frame_register_unwind (struct frame_info *frame, int regnum,
	118	int optimizedp, enum lval_type lvalp,
	119	CORE_ADDR addrp, int realnump, void *bufferp)
	120	{
	121	struct frame_unwind_cache *cache;
	122
	123	/* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
	124	that the value proper does not need to be fetched. */
	125	gdb_assert (optimizedp != NULL);
	126	gdb_assert (lvalp != NULL);
	127	gdb_assert (addrp != NULL);
	128	gdb_assert (realnump != NULL);
	129	/* gdb_assert (bufferp != NULL); */
	130
	131	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
	132	special case, there was always an inner frame dedicated to the
	133	hardware registers. Unfortunatly, there is too much unwind code
	134	around that looks up/down the frame chain while making the
	135	assumption that each frame level is using the same unwind code. */
	136
	137	if (frame == NULL)
	138	{
	139	/* We're in the inner-most frame, get the value direct from the
	140	register cache. */
	141	*optimizedp = 0;
	142	*lvalp = lval_register;
	143	*addrp = 0;
	144	/* Should this code test ``register_cached (regnum) < 0'' and do
	145	something like set realnum to -1 when the register isn't
	146	available? */
	147	*realnump = regnum;
	148	if (bufferp)
	149	read_register_gen (regnum, bufferp);
	150	return;
	151	}
	152
	153	/* Ask this frame to unwind its register. */
	154	frame->register_unwind (frame, &frame->register_unwind_cache, regnum,
	155	optimizedp, lvalp, addrp, realnump, bufferp);
	156	}
	157
	158
	159	void
	160	generic_unwind_get_saved_register (char *raw_buffer,
	161	int *optimizedp,
	162	CORE_ADDR *addrp,
	163	struct frame_info *frame,
	164	int regnum,
	165	enum lval_type *lvalp)
	166	{
	167	int optimizedx;
	168	CORE_ADDR addrx;
	169	int realnumx;
	170	enum lval_type lvalx;
	171
	172	if (!target_has_registers)
	173	error ("No registers.");
	174
	175	/* Keep things simple, ensure that all the pointers (except valuep)
	176	are non NULL. */
	177	if (optimizedp == NULL)
	178	optimizedp = &optimizedx;
	179	if (lvalp == NULL)
180	lvalp = &lvalx;
181	if (addrp == NULL)
182	addrp = &addrx;
183
184	/* Reached the the bottom (youngest, inner most) of the frame chain
185	(youngest, inner most) frame, go direct to the hardware register
186	cache (do not pass go, do not try to cache the value, ...). The
187	unwound value would have been cached in frame->next but that
188	doesn't exist. This doesn't matter as the hardware register
189	cache is stopping any unnecessary accesses to the target. */
190
191	/* NOTE: cagney/2002-04-14: It would be nice if, instead of a
192	special case, there was always an inner frame dedicated to the
193	hardware registers. Unfortunatly, there is too much unwind code
194	around that looks up/down the frame chain while making the
195	assumption that each frame level is using the same unwind code. */
196
197	if (frame == NULL)
198	frame_register_unwind (NULL, regnum, optimizedp, lvalp, addrp, &realnumx,
199	raw_buffer);
200	else
201	frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
202	&realnumx, raw_buffer);
203	}
204
d65fe839 AC	205	void
	206	get_saved_register (char *raw_buffer,
	207	int *optimized,
	208	CORE_ADDR *addrp,
	209	struct frame_info *frame,
	210	int regnum,
	211	enum lval_type *lval)
	212	{
	213	GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
	214	}
	215
cda5a58a	216	/* frame_register_read ()
d65fe839	217
cda5a58a	218	Find and return the value of REGNUM for the specified stack frame.
d65fe839 AC	219	The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
d65fe839 AC	220
cda5a58a	221	Returns 0 if the register value could not be found. */
d65fe839	222
cda5a58a AC	223	int
cda5a58a AC	224	frame_register_read (struct frame_info frame, int regnum, void myaddr)
d65fe839 AC	225	{
d65fe839 AC	226	int optim;
d65fe839 AC	227	get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
	228	regnum, (enum lval_type *) NULL);
	229
c97dcfc7 AC	230	/* FIXME: cagney/2002-05-15: This test, is just bogus.
	231
	232	It indicates that the target failed to supply a value for a
	233	register because it was "not available" at this time. Problem
	234	is, the target still has the register and so get saved_register()
	235	may be returning a value saved on the stack. */
	236
d65fe839	237	if (register_cached (regnum) < 0)
cda5a58a	238	return 0; /* register value not available */
d65fe839	239
cda5a58a	240	return !optim;
d65fe839	241	}