/* Get info from stack frames; convert between frames, blocks,
|
/* Get info from stack frames; convert between frames, blocks,
|
functions and pc values.
|
functions and pc values.
|
|
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
|
2010 Free Software Foundation, Inc.
|
2010 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
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "bfd.h"
|
#include "bfd.h"
|
#include "objfiles.h"
|
#include "objfiles.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "value.h"
|
#include "value.h"
|
#include "target.h"
|
#include "target.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "annotate.h"
|
#include "annotate.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "dummy-frame.h"
|
#include "dummy-frame.h"
|
#include "command.h"
|
#include "command.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "block.h"
|
#include "block.h"
|
#include "inline-frame.h"
|
#include "inline-frame.h"
|
|
|
/* Return the innermost lexical block in execution
|
/* Return the innermost lexical block in execution
|
in a specified stack frame. The frame address is assumed valid.
|
in a specified stack frame. The frame address is assumed valid.
|
|
|
If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
|
If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
|
address we used to choose the block. We use this to find a source
|
address we used to choose the block. We use this to find a source
|
line, to decide which macro definitions are in scope.
|
line, to decide which macro definitions are in scope.
|
|
|
The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
|
The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
|
PC, and may not really be a valid PC at all. For example, in the
|
PC, and may not really be a valid PC at all. For example, in the
|
caller of a function declared to never return, the code at the
|
caller of a function declared to never return, the code at the
|
return address will never be reached, so the call instruction may
|
return address will never be reached, so the call instruction may
|
be the very last instruction in the block. So the address we use
|
be the very last instruction in the block. So the address we use
|
to choose the block is actually one byte before the return address
|
to choose the block is actually one byte before the return address
|
--- hopefully pointing us at the call instruction, or its delay
|
--- hopefully pointing us at the call instruction, or its delay
|
slot instruction. */
|
slot instruction. */
|
|
|
struct block *
|
struct block *
|
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
|
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
|
{
|
{
|
const CORE_ADDR pc = get_frame_address_in_block (frame);
|
const CORE_ADDR pc = get_frame_address_in_block (frame);
|
struct frame_info *next_frame;
|
struct frame_info *next_frame;
|
struct block *bl;
|
struct block *bl;
|
int inline_count;
|
int inline_count;
|
|
|
if (addr_in_block)
|
if (addr_in_block)
|
*addr_in_block = pc;
|
*addr_in_block = pc;
|
|
|
bl = block_for_pc (pc);
|
bl = block_for_pc (pc);
|
if (bl == NULL)
|
if (bl == NULL)
|
return NULL;
|
return NULL;
|
|
|
inline_count = frame_inlined_callees (frame);
|
inline_count = frame_inlined_callees (frame);
|
|
|
while (inline_count > 0)
|
while (inline_count > 0)
|
{
|
{
|
if (block_inlined_p (bl))
|
if (block_inlined_p (bl))
|
inline_count--;
|
inline_count--;
|
|
|
bl = BLOCK_SUPERBLOCK (bl);
|
bl = BLOCK_SUPERBLOCK (bl);
|
gdb_assert (bl != NULL);
|
gdb_assert (bl != NULL);
|
}
|
}
|
|
|
return bl;
|
return bl;
|
}
|
}
|
|
|
CORE_ADDR
|
CORE_ADDR
|
get_pc_function_start (CORE_ADDR pc)
|
get_pc_function_start (CORE_ADDR pc)
|
{
|
{
|
struct block *bl;
|
struct block *bl;
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
|
|
bl = block_for_pc (pc);
|
bl = block_for_pc (pc);
|
if (bl)
|
if (bl)
|
{
|
{
|
struct symbol *symbol = block_linkage_function (bl);
|
struct symbol *symbol = block_linkage_function (bl);
|
|
|
if (symbol)
|
if (symbol)
|
{
|
{
|
bl = SYMBOL_BLOCK_VALUE (symbol);
|
bl = SYMBOL_BLOCK_VALUE (symbol);
|
return BLOCK_START (bl);
|
return BLOCK_START (bl);
|
}
|
}
|
}
|
}
|
|
|
msymbol = lookup_minimal_symbol_by_pc (pc);
|
msymbol = lookup_minimal_symbol_by_pc (pc);
|
if (msymbol)
|
if (msymbol)
|
{
|
{
|
CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
|
CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
|
|
|
if (find_pc_section (fstart))
|
if (find_pc_section (fstart))
|
return fstart;
|
return fstart;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the symbol for the function executing in frame FRAME. */
|
/* Return the symbol for the function executing in frame FRAME. */
|
|
|
struct symbol *
|
struct symbol *
|
get_frame_function (struct frame_info *frame)
|
get_frame_function (struct frame_info *frame)
|
{
|
{
|
struct block *bl = get_frame_block (frame, 0);
|
struct block *bl = get_frame_block (frame, 0);
|
|
|
if (bl == NULL)
|
if (bl == NULL)
|
return NULL;
|
return NULL;
|
|
|
while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
|
while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
|
bl = BLOCK_SUPERBLOCK (bl);
|
bl = BLOCK_SUPERBLOCK (bl);
|
|
|
return BLOCK_FUNCTION (bl);
|
return BLOCK_FUNCTION (bl);
|
}
|
}
|
|
|
|
|
/* Return the function containing pc value PC in section SECTION.
|
/* Return the function containing pc value PC in section SECTION.
|
Returns 0 if function is not known. */
|
Returns 0 if function is not known. */
|
|
|
struct symbol *
|
struct symbol *
|
find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
|
find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
|
{
|
{
|
struct block *b = block_for_pc_sect (pc, section);
|
struct block *b = block_for_pc_sect (pc, section);
|
if (b == 0)
|
if (b == 0)
|
return 0;
|
return 0;
|
return block_linkage_function (b);
|
return block_linkage_function (b);
|
}
|
}
|
|
|
/* Return the function containing pc value PC.
|
/* Return the function containing pc value PC.
|
Returns 0 if function is not known. Backward compatibility, no section */
|
Returns 0 if function is not known. Backward compatibility, no section */
|
|
|
struct symbol *
|
struct symbol *
|
find_pc_function (CORE_ADDR pc)
|
find_pc_function (CORE_ADDR pc)
|
{
|
{
|
return find_pc_sect_function (pc, find_pc_mapped_section (pc));
|
return find_pc_sect_function (pc, find_pc_mapped_section (pc));
|
}
|
}
|
|
|
/* These variables are used to cache the most recent result
|
/* These variables are used to cache the most recent result
|
* of find_pc_partial_function. */
|
* of find_pc_partial_function. */
|
|
|
static CORE_ADDR cache_pc_function_low = 0;
|
static CORE_ADDR cache_pc_function_low = 0;
|
static CORE_ADDR cache_pc_function_high = 0;
|
static CORE_ADDR cache_pc_function_high = 0;
|
static char *cache_pc_function_name = 0;
|
static char *cache_pc_function_name = 0;
|
static struct obj_section *cache_pc_function_section = NULL;
|
static struct obj_section *cache_pc_function_section = NULL;
|
|
|
/* Clear cache, e.g. when symbol table is discarded. */
|
/* Clear cache, e.g. when symbol table is discarded. */
|
|
|
void
|
void
|
clear_pc_function_cache (void)
|
clear_pc_function_cache (void)
|
{
|
{
|
cache_pc_function_low = 0;
|
cache_pc_function_low = 0;
|
cache_pc_function_high = 0;
|
cache_pc_function_high = 0;
|
cache_pc_function_name = (char *) 0;
|
cache_pc_function_name = (char *) 0;
|
cache_pc_function_section = NULL;
|
cache_pc_function_section = NULL;
|
}
|
}
|
|
|
/* Finds the "function" (text symbol) that is smaller than PC but
|
/* Finds the "function" (text symbol) that is smaller than PC but
|
greatest of all of the potential text symbols in SECTION. Sets
|
greatest of all of the potential text symbols in SECTION. Sets
|
*NAME and/or *ADDRESS conditionally if that pointer is non-null.
|
*NAME and/or *ADDRESS conditionally if that pointer is non-null.
|
If ENDADDR is non-null, then set *ENDADDR to be the end of the
|
If ENDADDR is non-null, then set *ENDADDR to be the end of the
|
function (exclusive), but passing ENDADDR as non-null means that
|
function (exclusive), but passing ENDADDR as non-null means that
|
the function might cause symbols to be read. This function either
|
the function might cause symbols to be read. This function either
|
succeeds or fails (not halfway succeeds). If it succeeds, it sets
|
succeeds or fails (not halfway succeeds). If it succeeds, it sets
|
*NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
|
*NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
|
If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
|
If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
|
returns 0. */
|
returns 0. */
|
|
|
/* Backward compatibility, no section argument. */
|
/* Backward compatibility, no section argument. */
|
|
|
int
|
int
|
find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
|
find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
|
CORE_ADDR *endaddr)
|
CORE_ADDR *endaddr)
|
{
|
{
|
struct obj_section *section;
|
struct obj_section *section;
|
struct partial_symtab *pst;
|
struct partial_symtab *pst;
|
struct symbol *f;
|
struct symbol *f;
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
struct partial_symbol *psb;
|
struct partial_symbol *psb;
|
int i;
|
int i;
|
CORE_ADDR mapped_pc;
|
CORE_ADDR mapped_pc;
|
|
|
/* To ensure that the symbol returned belongs to the correct setion
|
/* To ensure that the symbol returned belongs to the correct setion
|
(and that the last [random] symbol from the previous section
|
(and that the last [random] symbol from the previous section
|
isn't returned) try to find the section containing PC. First try
|
isn't returned) try to find the section containing PC. First try
|
the overlay code (which by default returns NULL); and second try
|
the overlay code (which by default returns NULL); and second try
|
the normal section code (which almost always succeeds). */
|
the normal section code (which almost always succeeds). */
|
section = find_pc_overlay (pc);
|
section = find_pc_overlay (pc);
|
if (section == NULL)
|
if (section == NULL)
|
section = find_pc_section (pc);
|
section = find_pc_section (pc);
|
|
|
mapped_pc = overlay_mapped_address (pc, section);
|
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
|
&& mapped_pc < cache_pc_function_high
|
&& section == cache_pc_function_section)
|
&& section == cache_pc_function_section)
|
goto return_cached_value;
|
goto return_cached_value;
|
|
|
msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
|
msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
|
pst = find_pc_sect_psymtab (mapped_pc, section);
|
pst = find_pc_sect_psymtab (mapped_pc, section);
|
if (pst)
|
if (pst)
|
{
|
{
|
/* Need to read the symbols to get a good value for the end address. */
|
/* Need to read the symbols to get a good value for the end address. */
|
if (endaddr != NULL && !pst->readin)
|
if (endaddr != NULL && !pst->readin)
|
{
|
{
|
/* Need to get the terminal in case symbol-reading produces
|
/* Need to get the terminal in case symbol-reading produces
|
output. */
|
output. */
|
target_terminal_ours_for_output ();
|
target_terminal_ours_for_output ();
|
PSYMTAB_TO_SYMTAB (pst);
|
PSYMTAB_TO_SYMTAB (pst);
|
}
|
}
|
|
|
if (pst->readin)
|
if (pst->readin)
|
{
|
{
|
/* Checking whether the msymbol has a larger value is for the
|
/* Checking whether the msymbol has a larger value is for the
|
"pathological" case mentioned in print_frame_info. */
|
"pathological" case mentioned in print_frame_info. */
|
f = find_pc_sect_function (mapped_pc, section);
|
f = find_pc_sect_function (mapped_pc, section);
|
if (f != NULL
|
if (f != NULL
|
&& (msymbol == NULL
|
&& (msymbol == NULL
|
|| (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
|
|| (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
|
>= SYMBOL_VALUE_ADDRESS (msymbol))))
|
>= SYMBOL_VALUE_ADDRESS (msymbol))))
|
{
|
{
|
cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
|
cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
|
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
|
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
|
cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
|
cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
|
cache_pc_function_section = section;
|
cache_pc_function_section = section;
|
goto return_cached_value;
|
goto return_cached_value;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Now that static symbols go in the minimal symbol table, perhaps
|
/* Now that static symbols go in the minimal symbol table, perhaps
|
we could just ignore the partial symbols. But at least for now
|
we could just ignore the partial symbols. But at least for now
|
we use the partial or minimal symbol, whichever is larger. */
|
we use the partial or minimal symbol, whichever is larger. */
|
psb = find_pc_sect_psymbol (pst, mapped_pc, section);
|
psb = find_pc_sect_psymbol (pst, mapped_pc, section);
|
|
|
if (psb
|
if (psb
|
&& (msymbol == NULL
|
&& (msymbol == NULL
|
|| (SYMBOL_VALUE_ADDRESS (psb)
|
|| (SYMBOL_VALUE_ADDRESS (psb)
|
>= SYMBOL_VALUE_ADDRESS (msymbol))))
|
>= SYMBOL_VALUE_ADDRESS (msymbol))))
|
{
|
{
|
/* This case isn't being cached currently. */
|
/* This case isn't being cached currently. */
|
if (address)
|
if (address)
|
*address = SYMBOL_VALUE_ADDRESS (psb);
|
*address = SYMBOL_VALUE_ADDRESS (psb);
|
if (name)
|
if (name)
|
*name = SYMBOL_LINKAGE_NAME (psb);
|
*name = SYMBOL_LINKAGE_NAME (psb);
|
/* endaddr non-NULL can't happen here. */
|
/* endaddr non-NULL can't happen here. */
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Not in the normal symbol tables, see if the pc is in a known section.
|
/* Not in the normal symbol tables, see if the pc is in a known section.
|
If it's not, then give up. This ensures that anything beyond the end
|
If it's not, then give up. This ensures that anything beyond the end
|
of the text seg doesn't appear to be part of the last function in the
|
of the text seg doesn't appear to be part of the last function in the
|
text segment. */
|
text segment. */
|
|
|
if (!section)
|
if (!section)
|
msymbol = NULL;
|
msymbol = NULL;
|
|
|
/* Must be in the minimal symbol table. */
|
/* Must be in the minimal symbol table. */
|
if (msymbol == NULL)
|
if (msymbol == NULL)
|
{
|
{
|
/* No available symbol. */
|
/* No available symbol. */
|
if (name != NULL)
|
if (name != NULL)
|
*name = 0;
|
*name = 0;
|
if (address != NULL)
|
if (address != NULL)
|
*address = 0;
|
*address = 0;
|
if (endaddr != NULL)
|
if (endaddr != NULL)
|
*endaddr = 0;
|
*endaddr = 0;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
|
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
|
cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
|
cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
|
cache_pc_function_section = section;
|
cache_pc_function_section = section;
|
|
|
/* If the minimal symbol has a size, use it for the cache.
|
/* If the minimal symbol has a size, use it for the cache.
|
Otherwise use the lesser of the next minimal symbol in the same
|
Otherwise use the lesser of the next minimal symbol in the same
|
section, or the end of the section, as the end of the
|
section, or the end of the section, as the end of the
|
function. */
|
function. */
|
|
|
if (MSYMBOL_SIZE (msymbol) != 0)
|
if (MSYMBOL_SIZE (msymbol) != 0)
|
cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
|
cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
|
else
|
else
|
{
|
{
|
/* Step over other symbols at this same address, and symbols in
|
/* Step over other symbols at this same address, and symbols in
|
other sections, to find the next symbol in this section with
|
other sections, to find the next symbol in this section with
|
a different address. */
|
a different address. */
|
|
|
for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
|
for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
|
{
|
{
|
if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
|
if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
|
&& SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol))
|
&& SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol))
|
break;
|
break;
|
}
|
}
|
|
|
if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
|
if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
|
&& SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section))
|
&& SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section))
|
cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
|
cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
|
else
|
else
|
/* We got the start address from the last msymbol in the objfile.
|
/* We got the start address from the last msymbol in the objfile.
|
So the end address is the end of the section. */
|
So the end address is the end of the section. */
|
cache_pc_function_high = obj_section_endaddr (section);
|
cache_pc_function_high = obj_section_endaddr (section);
|
}
|
}
|
|
|
return_cached_value:
|
return_cached_value:
|
|
|
if (address)
|
if (address)
|
{
|
{
|
if (pc_in_unmapped_range (pc, section))
|
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
|
else
|
*address = cache_pc_function_low;
|
*address = cache_pc_function_low;
|
}
|
}
|
|
|
if (name)
|
if (name)
|
*name = cache_pc_function_name;
|
*name = cache_pc_function_name;
|
|
|
if (endaddr)
|
if (endaddr)
|
{
|
{
|
if (pc_in_unmapped_range (pc, section))
|
if (pc_in_unmapped_range (pc, section))
|
{
|
{
|
/* Because the high address is actually beyond the end of
|
/* Because the high address is actually beyond the end of
|
the function (and therefore possibly beyond the end of
|
the function (and therefore possibly beyond the end of
|
the overlay), we must actually convert (high - 1) and
|
the overlay), we must actually convert (high - 1) and
|
then add one to that. */
|
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);
|
section);
|
}
|
}
|
else
|
else
|
*endaddr = cache_pc_function_high;
|
*endaddr = cache_pc_function_high;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Return the innermost stack frame executing inside of BLOCK,
|
/* Return the innermost stack frame executing inside of BLOCK,
|
or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
|
or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
|
|
|
struct frame_info *
|
struct frame_info *
|
block_innermost_frame (struct block *block)
|
block_innermost_frame (struct block *block)
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
CORE_ADDR start;
|
CORE_ADDR start;
|
CORE_ADDR end;
|
CORE_ADDR end;
|
|
|
if (block == NULL)
|
if (block == NULL)
|
return NULL;
|
return NULL;
|
|
|
start = BLOCK_START (block);
|
start = BLOCK_START (block);
|
end = BLOCK_END (block);
|
end = BLOCK_END (block);
|
|
|
frame = get_current_frame ();
|
frame = get_current_frame ();
|
while (frame != NULL)
|
while (frame != NULL)
|
{
|
{
|
struct block *frame_block = get_frame_block (frame, NULL);
|
struct block *frame_block = get_frame_block (frame, NULL);
|
if (frame_block != NULL && contained_in (frame_block, block))
|
if (frame_block != NULL && contained_in (frame_block, block))
|
return frame;
|
return frame;
|
|
|
frame = get_prev_frame (frame);
|
frame = get_prev_frame (frame);
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
