Imagelibrary/binutils-gdb
1
0
Fork 1
mirror of https://github.com/bminor/binutils-gdb.git synced 2025-12-27 01:28:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

import gdb-1999-07-07 post reformat

Browse Source
This commit is contained in:
Jason Molenda
1999-07-07 20:19:36 +00:00
parent 3a4b77d8be
commit c5aa993b1f
643 changed files with 69889 additions and 65773 deletions
Download Patch File Download Diff File Expand all files Collapse all files

283
gdb/blockframe.c
View File

@@ -1,23 +1,24 @@
/* Get info from stack frames;
convert between frames, blocks, functions and pc values.
Copyright 1986, 87, 88, 89, 91, 94, 95, 96, 97, 1998
Free Software Foundation, Inc.
Free Software Foundation, Inc.
This file is part of GDB.
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 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.
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. */
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 "symtab.h"
@@ -45,14 +46,14 @@ default_frame_chain_valid (chain, thisframe)
struct frame_info *thisframe;
{
return ((chain) != 0
&& !inside_main_func ((thisframe) -> pc)
&& !inside_entry_func ((thisframe) -> pc));
&& !inside_main_func ((thisframe)->pc)
&& !inside_entry_func ((thisframe)->pc));
}
/* Use the alternate method of avoiding running up off the end of the
frame chain or following frames back into the startup code. See
the comments in objfiles.h. */
int
alternate_frame_chain_valid (chain, thisframe)
CORE_ADDR chain;
@@ -63,7 +64,7 @@ alternate_frame_chain_valid (chain, thisframe)
}
/* A very simple method of determining a valid frame */
int
nonnull_frame_chain_valid (chain, thisframe)
CORE_ADDR chain;
@@ -91,13 +92,13 @@ inside_entry_file (addr)
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
{
/* Do not stop backtracing if the pc is in the call dummy
at the entry point. */
at the entry point. */
/* FIXME: Won't always work with zeros for the last two arguments */
if (PC_IN_CALL_DUMMY (addr, 0, 0))
if (PC_IN_CALL_DUMMY (addr, 0, 0))
return 0;
}
return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
addr < symfile_objfile -> ei.entry_file_highpc);
return (addr >= symfile_objfile->ei.entry_file_lowpc &&
addr < symfile_objfile->ei.entry_file_highpc);
}
/* Test a specified PC value to see if it is in the range of addresses
@@ -110,7 +111,7 @@ inside_entry_file (addr)
int
inside_main_func (pc)
CORE_ADDR pc;
CORE_ADDR pc;
{
if (pc == 0)
return 1;
@@ -121,22 +122,22 @@ CORE_ADDR pc;
This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
it is unable to set it up and symbol reading time. */
if (symfile_objfile -> ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
symfile_objfile -> ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
{
struct symbol *mainsym;
mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL);
if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK)
{
symfile_objfile->ei.main_func_lowpc =
if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
{
symfile_objfile->ei.main_func_lowpc =
BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
symfile_objfile->ei.main_func_highpc =
symfile_objfile->ei.main_func_highpc =
BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
}
}
}
return (symfile_objfile -> ei.main_func_lowpc <= pc &&
symfile_objfile -> ei.main_func_highpc > pc);
return (symfile_objfile->ei.main_func_lowpc <= pc &&
symfile_objfile->ei.main_func_highpc > pc);
}
/* Test a specified PC value to see if it is in the range of addresses
@@ -158,13 +159,13 @@ inside_entry_func (pc)
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
{
/* Do not stop backtracing if the pc is in the call dummy
at the entry point. */
at the entry point. */
/* FIXME: Won't always work with zeros for the last two arguments */
if (PC_IN_CALL_DUMMY (pc, 0, 0))
return 0;
}
return (symfile_objfile -> ei.entry_func_lowpc <= pc &&
symfile_objfile -> ei.entry_func_highpc > pc);
return (symfile_objfile->ei.entry_func_lowpc <= pc &&
symfile_objfile->ei.entry_func_highpc > pc);
}
/* Info about the innermost stack frame (contents of FP register) */
@@ -188,7 +189,7 @@ void
frame_saved_regs_zalloc (fi)
struct frame_info *fi;
{
fi->saved_regs = (CORE_ADDR*)
fi->saved_regs = (CORE_ADDR *)
frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
}
@@ -237,7 +238,7 @@ create_new_frame (addr, pc)
fi->prev = NULL;
fi->frame = addr;
fi->pc = pc;
find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
fi->signal_handler_caller = IN_SIGTRAMP (fi->pc, name);
#ifdef INIT_EXTRA_FRAME_INFO
@@ -266,7 +267,7 @@ flush_cached_frames ()
obstack_free (&frame_cache_obstack, 0);
obstack_init (&frame_cache_obstack);
current_frame = NULL; /* Invalidate cache */
current_frame = NULL; /* Invalidate cache */
select_frame (NULL, -1);
annotate_frames_invalid ();
}
@@ -306,7 +307,7 @@ frameless_look_for_prologue (frame)
after_prologue = func_start;
#ifdef SKIP_PROLOGUE_FRAMELESS_P
/* This is faster, since only care whether there *is* a prologue,
not how long it is. */
not how long it is. */
after_prologue = SKIP_PROLOGUE_FRAMELESS_P (after_prologue);
#else
after_prologue = SKIP_PROLOGUE (after_prologue);
@@ -360,9 +361,9 @@ get_prev_frame (next_frame)
{
#if 0
/* This screws value_of_variable, which just wants a nice clean
NULL return from block_innermost_frame if there are no frames.
I don't think I've ever seen this message happen otherwise.
And returning NULL here is a perfectly legitimate thing to do. */
NULL return from block_innermost_frame if there are no frames.
I don't think I've ever seen this message happen otherwise.
And returning NULL here is a perfectly legitimate thing to do. */
if (!current_frame)
{
error ("You haven't set up a process's stack to examine.");
@@ -395,18 +396,18 @@ get_prev_frame (next_frame)
if (!fromleaf)
{
/* Two macros defined in tm.h specify the machine-dependent
actions to be performed here.
First, get the frame's chain-pointer.
If that is zero, the frame is the outermost frame or a leaf
called by the outermost frame. This means that if start
calls main without a frame, we'll return 0 (which is fine
anyway).
actions to be performed here.
First, get the frame's chain-pointer.
If that is zero, the frame is the outermost frame or a leaf
called by the outermost frame. This means that if start
calls main without a frame, we'll return 0 (which is fine
anyway).
Nope; there's a problem. This also returns when the current
routine is a leaf of main. This is unacceptable. We move
this to after the ffi test; I'd rather have backtraces from
start go curfluy than have an abort called from main not show
main. */
Nope; there's a problem. This also returns when the current
routine is a leaf of main. This is unacceptable. We move
this to after the ffi test; I'd rather have backtraces from
start go curfluy than have an abort called from main not show
main. */
address = FRAME_CHAIN (next_frame);
if (!FRAME_CHAIN_VALID (address, next_frame))
return 0;
@@ -432,11 +433,11 @@ get_prev_frame (next_frame)
after INIT_EXTRA_FRAME_INFO and come up with a simple way to
express what goes on here.
INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
(where the PC is already set up) and here (where it isn't).
INIT_FRAME_PC is only called from here, always after
INIT_EXTRA_FRAME_INFO.
INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
(where the PC is already set up) and here (where it isn't).
INIT_FRAME_PC is only called from here, always after
INIT_EXTRA_FRAME_INFO.
The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
value (which hasn't been set yet). Some other machines appear to
require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
@@ -448,24 +449,24 @@ get_prev_frame (next_frame)
INIT_EXTRA_FRAME_INFO, one possible scheme:
SETUP_INNERMOST_FRAME()
Default version is just create_new_frame (read_fp ()),
read_pc ()). Machines with extra frame info would do that (or the
local equivalent) and then set the extra fields.
Default version is just create_new_frame (read_fp ()),
read_pc ()). Machines with extra frame info would do that (or the
local equivalent) and then set the extra fields.
SETUP_ARBITRARY_FRAME(argc, argv)
Only change here is that create_new_frame would no longer init extra
frame info; SETUP_ARBITRARY_FRAME would have to do that.
Only change here is that create_new_frame would no longer init extra
frame info; SETUP_ARBITRARY_FRAME would have to do that.
INIT_PREV_FRAME(fromleaf, prev)
Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
also return a flag saying whether to keep the new frame, or
whether to discard it, because on some machines (e.g. mips) it
is really awkward to have FRAME_CHAIN_VALID called *before*
INIT_EXTRA_FRAME_INFO (there is no good way to get information
deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
also return a flag saying whether to keep the new frame, or
whether to discard it, because on some machines (e.g. mips) it
is really awkward to have FRAME_CHAIN_VALID called *before*
INIT_EXTRA_FRAME_INFO (there is no good way to get information
deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
std_frame_pc(fromleaf, prev)
This is the default setting for INIT_PREV_FRAME. It just does what
the default INIT_FRAME_PC does. Some machines will call it from
INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
Some machines won't use it.
This is the default setting for INIT_PREV_FRAME. It just does what
the default INIT_FRAME_PC does. Some machines will call it from
INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
Some machines won't use it.
kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
#ifdef INIT_FRAME_PC_FIRST
@@ -473,13 +474,13 @@ get_prev_frame (next_frame)
#endif
#ifdef INIT_EXTRA_FRAME_INFO
INIT_EXTRA_FRAME_INFO(fromleaf, prev);
INIT_EXTRA_FRAME_INFO (fromleaf, prev);
#endif
/* This entry is in the frame queue now, which is good since
FRAME_SAVED_PC may use that queue to figure out its value
(see tm-sparc.h). We want the pc saved in the inferior frame. */
INIT_FRAME_PC(fromleaf, prev);
INIT_FRAME_PC (fromleaf, prev);
/* If ->frame and ->pc are unchanged, we are in the process of getting
ourselves into an infinite backtrace. Some architectures check this
@@ -497,7 +498,7 @@ get_prev_frame (next_frame)
}
find_pc_partial_function (prev->pc, &name,
(CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
(CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
if (IN_SIGTRAMP (prev->pc, name))
prev->signal_handler_caller = 1;
@@ -524,7 +525,7 @@ get_frame_saved_regs (frame, saved_regs_addr)
{
if (frame->saved_regs == NULL)
{
frame->saved_regs = (CORE_ADDR*)
frame->saved_regs = (CORE_ADDR *)
frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
}
if (saved_regs_addr == NULL)
@@ -618,13 +619,13 @@ blockvector_for_pc_sect (pc, section, pindex, symtab)
struct sec *section;
int *pindex;
struct symtab *symtab;
{
register struct block *b;
register int bot, top, half;
struct blockvector *bl;
if (symtab == 0) /* if no symtab specified by caller */
if (symtab == 0) /* if no symtab specified by caller */
{
/* First search all symtabs for one whose file contains our pc */
if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
@@ -733,19 +734,19 @@ find_pc_function (pc)
/* These variables are used to cache the most recent result
* of find_pc_partial_function. */
static CORE_ADDR cache_pc_function_low = 0;
static CORE_ADDR cache_pc_function_high = 0;
static char *cache_pc_function_name = 0;
static CORE_ADDR cache_pc_function_low = 0;
static CORE_ADDR cache_pc_function_high = 0;
static char *cache_pc_function_name = 0;
static struct sec *cache_pc_function_section = NULL;
/* Clear cache, e.g. when symbol table is discarded. */
void
clear_pc_function_cache()
clear_pc_function_cache ()
{
cache_pc_function_low = 0;
cache_pc_function_high = 0;
cache_pc_function_name = (char *)0;
cache_pc_function_name = (char *) 0;
cache_pc_function_section = NULL;
}
@@ -762,23 +763,23 @@ clear_pc_function_cache()
int
find_pc_sect_partial_function (pc, section, name, address, endaddr)
CORE_ADDR pc;
asection *section;
char **name;
CORE_ADDR pc;
asection *section;
char **name;
CORE_ADDR *address;
CORE_ADDR *endaddr;
{
struct partial_symtab *pst;
struct symbol *f;
struct symbol *f;
struct minimal_symbol *msymbol;
struct partial_symbol *psb;
struct obj_section *osect;
struct obj_section *osect;
int i;
CORE_ADDR mapped_pc;
mapped_pc = overlay_mapped_address (pc, section);
if (mapped_pc >= cache_pc_function_low &&
if (mapped_pc >= cache_pc_function_low &&
mapped_pc < cache_pc_function_high &&
section == cache_pc_function_section)
goto return_cached_value;
@@ -786,11 +787,11 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
/* If sigtramp is in the u area, it counts as a function (especially
important for step_1). */
#if defined SIGTRAMP_START
if (IN_SIGTRAMP (mapped_pc, (char *)NULL))
if (IN_SIGTRAMP (mapped_pc, (char *) NULL))
{
cache_pc_function_low = SIGTRAMP_START (mapped_pc);
cache_pc_function_high = SIGTRAMP_END (mapped_pc);
cache_pc_function_name = "<sigtramp>";
cache_pc_function_low = SIGTRAMP_START (mapped_pc);
cache_pc_function_high = SIGTRAMP_END (mapped_pc);
cache_pc_function_name = "<sigtramp>";
cache_pc_function_section = section;
goto return_cached_value;
}
@@ -819,9 +820,9 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
|| (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
>= SYMBOL_VALUE_ADDRESS (msymbol))))
{
cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_name = SYMBOL_NAME (f);
cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_name = SYMBOL_NAME (f);
cache_pc_function_section = section;
goto return_cached_value;
}
@@ -872,21 +873,21 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
return 0;
}
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
cache_pc_function_name = SYMBOL_NAME (msymbol);
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
cache_pc_function_name = SYMBOL_NAME (msymbol);
cache_pc_function_section = section;
/* Use the lesser of the next minimal symbol in the same section, or
the end of the section, as the end of the function. */
/* Step over other symbols at this same address, and symbols in
other sections, to find the next symbol in this section with
a different address. */
for (i=1; SYMBOL_NAME (msymbol+i) != NULL; i++)
for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
{
if (SYMBOL_VALUE_ADDRESS (msymbol+i) != SYMBOL_VALUE_ADDRESS (msymbol)
&& SYMBOL_BFD_SECTION (msymbol+i) == SYMBOL_BFD_SECTION (msymbol))
if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
&& SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
break;
}
@@ -898,33 +899,33 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
So the end address is the end of the section. */
cache_pc_function_high = osect->endaddr;
return_cached_value:
return_cached_value:
if (address)
{
if (pc_in_unmapped_range (pc, section))
*address = overlay_unmapped_address (cache_pc_function_low, section);
*address = overlay_unmapped_address (cache_pc_function_low, section);
else
*address = cache_pc_function_low;
*address = cache_pc_function_low;
}
if (name)
*name = cache_pc_function_name;
if (endaddr)
{
if (pc_in_unmapped_range (pc, section))
{
{
/* Because the high address is actually beyond the end of
the function (and therefore possibly beyond the end of
the overlay), we must actually convert (high - 1)
and then add one to that. */
*endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
*endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
section);
}
}
else
*endaddr = cache_pc_function_high;
*endaddr = cache_pc_function_high;
}
return 1;
@@ -934,12 +935,12 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
int
find_pc_partial_function (pc, name, address, endaddr)
CORE_ADDR pc;
char **name;
CORE_ADDR pc;
char **name;
CORE_ADDR *address;
CORE_ADDR *endaddr;
{
asection *section;
asection *section;
section = find_pc_overlay (pc);
return find_pc_sect_partial_function (pc, section, name, address, endaddr);
@@ -982,7 +983,7 @@ find_frame_addr_in_frame_chain (frame_addr)
{
struct frame_info *frame = NULL;
if (frame_addr == (CORE_ADDR)0)
if (frame_addr == (CORE_ADDR) 0)
return NULL;
while (1)
@@ -1015,7 +1016,7 @@ sigtramp_saved_pc (frame)
ptrbytes);
else
sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
+ sigcontext_offs,
+ sigcontext_offs,
ptrbytes);
/* Don't cause a memory_error when accessing sigcontext in case the stack
@@ -1131,12 +1132,12 @@ static struct dummy_frame *dummy_frame_stack = NULL;
Search the stack of dummy frames for one matching the given PC, FP and SP.
This is the work-horse for pc_in_call_dummy and read_register_dummy */
char *
char *
generic_find_dummy_frame (pc, fp)
CORE_ADDR pc;
CORE_ADDR fp;
{
struct dummy_frame * dummyframe;
struct dummy_frame *dummyframe;
if (pc != entry_point_address ())
return 0;
@@ -1179,7 +1180,7 @@ generic_read_register_dummy (pc, fp, regno)
if (dummy_regs)
return extract_address (&dummy_regs[REGISTER_BYTE (regno)],
REGISTER_RAW_SIZE(regno));
REGISTER_RAW_SIZE (regno));
else
return 0;
}
@@ -1216,10 +1217,10 @@ generic_push_dummy_frame ()
dummy_frame = xmalloc (sizeof (struct dummy_frame));
dummy_frame->registers = xmalloc (REGISTER_BYTES);
dummy_frame->pc = read_register (PC_REGNUM);
dummy_frame->sp = read_register (SP_REGNUM);
dummy_frame->top = dummy_frame->sp;
dummy_frame->fp = fp;
dummy_frame->pc = read_register (PC_REGNUM);
dummy_frame->sp = read_register (SP_REGNUM);
dummy_frame->top = dummy_frame->sp;
dummy_frame->fp = fp;
read_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
dummy_frame->next = dummy_frame_stack;
dummy_frame_stack = dummy_frame;
@@ -1238,10 +1239,10 @@ generic_save_dummy_frame_tos (sp)
void
generic_pop_current_frame (pop)
void (*pop) PARAMS ((struct frame_info *frame));
void (*pop) PARAMS ((struct frame_info * frame));
{
struct frame_info *frame = get_current_frame ();
if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
generic_pop_dummy_frame ();
else
pop (frame);
@@ -1271,20 +1272,20 @@ generic_pop_dummy_frame ()
/* Function: frame_chain_valid
Returns true for a user frame or a call_function_by_hand dummy frame,
and false for the CRT0 start-up frame. Purpose is to terminate backtrace */
int
generic_frame_chain_valid (fp, fi)
CORE_ADDR fp;
struct frame_info *fi;
{
if (PC_IN_CALL_DUMMY(FRAME_SAVED_PC(fi), fp, fp))
return 1; /* don't prune CALL_DUMMY frames */
else /* fall back to default algorithm (see frame.h) */
if (PC_IN_CALL_DUMMY (FRAME_SAVED_PC (fi), fp, fp))
return 1; /* don't prune CALL_DUMMY frames */
else /* fall back to default algorithm (see frame.h) */
return (fp != 0
&& (INNER_THAN (fi->frame, fp) || fi->frame == fp)
&& !inside_entry_file (FRAME_SAVED_PC(fi)));
&& !inside_entry_file (FRAME_SAVED_PC (fi)));
}
/* Function: fix_call_dummy
Stub function. Generic dumy frames typically do not need to fix
the frame being created */
@@ -1342,7 +1343,7 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
if (optimized != NULL)
*optimized = 0;
if (addrp) /* default assumption: not found in memory */
if (addrp) /* default assumption: not found in memory */
*addrp = 0;
/* Note: since the current frame's registers could only have been
@@ -1354,34 +1355,34 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
{
if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
{
if (lval) /* found it in a CALL_DUMMY frame */
if (lval) /* found it in a CALL_DUMMY frame */
*lval = not_lval;
if (raw_buffer)
memcpy (raw_buffer,
generic_find_dummy_frame (frame->pc, frame->frame) +
memcpy (raw_buffer,
generic_find_dummy_frame (frame->pc, frame->frame) +
REGISTER_BYTE (regnum),
REGISTER_RAW_SIZE (regnum));
return;
return;
}
FRAME_INIT_SAVED_REGS (frame);
if (frame->saved_regs != NULL
&& frame->saved_regs[regnum] != 0)
{
if (lval) /* found it saved on the stack */
if (lval) /* found it saved on the stack */
*lval = lval_memory;
if (regnum == SP_REGNUM)
{
if (raw_buffer) /* SP register treated specially */
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
if (raw_buffer) /* SP register treated specially */
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
frame->saved_regs[regnum]);
}
else
{
if (addrp) /* any other register */
if (addrp) /* any other register */
*addrp = frame->saved_regs[regnum];
if (raw_buffer)
read_memory (frame->saved_regs[regnum], raw_buffer,
read_memory (frame->saved_regs[regnum], raw_buffer,
REGISTER_RAW_SIZE (regnum));
}
return;
@@ -1391,7 +1392,7 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
/* If we get thru the loop to this point, it means the register was
not saved in any frame. Return the actual live-register value. */
if (lval) /* found it in a live register */
if (lval) /* found it in a live register */
*lval = lval_register;
if (addrp)
*addrp = REGISTER_BYTE (regnum);