CORE_ADDR
get_pc_function_start (CORE_ADDR pc)
{
struct block *bl;
struct minimal_symbol *msymbol;
bl = block_for_pc (pc);
if (bl)
{
struct symbol *symbol = block_function (bl);
if (symbol)
{
bl = SYMBOL_BLOCK_VALUE (symbol);
/* APPLE LOCAL begin address ranges */
return BLOCK_LOWEST_PC (bl);
/* APPLE LOCAL end address ranges */
}
}
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol)
{
CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
if (find_pc_section (fstart))
return fstart;
}
return 0;
}
static int
there_is_a_visible_common_named (char *comname)
{
SAVED_F77_COMMON_PTR the_common;
struct frame_info *fi;
char *funname = 0;
struct symbol *func;
if (comname == NULL)
error (_("Cannot deal with NULL common name!"));
fi = deprecated_selected_frame;
if (fi == NULL)
error (_("No frame selected"));
/* The following is generally ripped off from stack.c's routine
print_frame_info() */
func = find_pc_function (fi->pc);
if (func)
{
/* In certain pathological cases, the symtabs give the wrong
function (when we are in the first function in a file which
is compiled without debugging symbols, the previous function
is compiled with debugging symbols, and the "foo.o" symbol
that is supposed to tell us where the file with debugging symbols
ends has been truncated by ar because it is longer than 15
characters).
So look in the minimal symbol tables as well, and if it comes
up with a larger address for the function use that instead.
I don't think this can ever cause any problems; there shouldn't
be any minimal symbols in the middle of a function.
FIXME: (Not necessarily true. What about text labels) */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
/* APPLE LOCAL begin address ranges */
if (msymbol != NULL
&& (SYMBOL_VALUE_ADDRESS (msymbol)
> BLOCK_LOWEST_PC (SYMBOL_BLOCK_VALUE (func))))
/* APPLE LOCAL end address ranges */
funname = DEPRECATED_SYMBOL_NAME (msymbol);
else
funname = DEPRECATED_SYMBOL_NAME (func);
}
else
{
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
funname = DEPRECATED_SYMBOL_NAME (msymbol);
}
the_common = find_common_for_function (comname, funname);
return (the_common ? 1 : 0);
}
int
addr_inside_main_func (CORE_ADDR pc)
{
struct minimal_symbol *msymbol;
if (symfile_objfile == 0)
return 0;
/* APPLE LOCAL begin don't recompute start/end of main */
/* If we've already found the start/end addrs of main, don't
recompute them. This will probably be fixed in the FSF sources
soon too, in which case this change can be dropped.
jmolenda/2004-04-28 */
if (symfile_objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC
&& symfile_objfile->ei.main_func_highpc != INVALID_ENTRY_LOWPC)
return (symfile_objfile->ei.main_func_lowpc <= pc
&& symfile_objfile->ei.main_func_highpc > pc);
/* APPLE LOCAL end don't recompute start/end of main */
/* APPLE LOCAL begin don't restrict lookup_minimal_symbol's object file */
/* Don't restrict lookup_minimal_symbol's object file to
symfile_objfile -- this will fail for ZeroLink apps where
symfile_objfile is just the ZL launcher stub. */
msymbol = lookup_minimal_symbol (main_name (), NULL, NULL);
/* APPLE LOCAL end don't restrict lookup_minimal_symbol's object file */
/* If the address range hasn't been set up at symbol reading time,
set it up now. */
if (msymbol != NULL
&& symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC
&& symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
{
/* brobecker/2003-10-10: We used to rely on lookup_symbol() to
search the symbol associated to the "main" function.
Unfortunately, lookup_symbol() uses the current-language
la_lookup_symbol_nonlocal function to do the global symbol
search. Depending on the language, this can introduce
certain side-effects, because certain languages, for instance
Ada, may find more than one match. Therefore we prefer to
search the "main" function symbol using its address rather
than its name. */
struct symbol *mainsym =
find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
{
/* APPLE LOCAL begin address ranges */
struct block *bl = SYMBOL_BLOCK_VALUE (mainsym);
if (BLOCK_RANGES (bl))
{
symfile_objfile->ei.main_func_lowpc = BLOCK_LOWEST_PC (bl);
symfile_objfile->ei.main_func_highpc = BLOCK_HIGHEST_PC (bl);
}
else
{
symfile_objfile->ei.main_func_lowpc =
BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
symfile_objfile->ei.main_func_highpc =
BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
}
/* APPLE LOCAL end address ranges */
}
}
/* Not in the normal symbol tables, see if "main" is in the partial
symbol table. If it's not, then give up. */
if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
{
CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol);
asection *msect = SYMBOL_BFD_SECTION (msymbol);
struct obj_section *osect = find_pc_sect_section (maddr, msect);
if (osect != NULL)
{
int i;
/* 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_LINKAGE_NAME (msymbol + i) != NULL; i++)
{
if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr
&& SYMBOL_BFD_SECTION (msymbol + i) == msect)
break;
}
symfile_objfile->ei.main_func_lowpc = maddr;
/* Use the lesser of the next minimal symbol in the same
section, or the end of the section, as the end of the
function. */
if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
symfile_objfile->ei.main_func_highpc =
SYMBOL_VALUE_ADDRESS (msymbol + i);
else
/* We got the start address from the last msymbol in the
objfile. So the end address is the end of the
section. */
symfile_objfile->ei.main_func_highpc = osect->endaddr;
}
}
return (symfile_objfile->ei.main_func_lowpc <= pc
&& symfile_objfile->ei.main_func_highpc > pc);
}
static int
find_pc_partial_function_impl (CORE_ADDR pc, char **name, CORE_ADDR *address,
CORE_ADDR *endaddr, int inlining_flag)
{
struct bfd_section *section;
struct partial_symtab *pst;
struct symbol *f;
struct minimal_symbol *msymbol;
struct partial_symbol *psb;
struct obj_section *osect;
int i;
CORE_ADDR mapped_pc;
/* To ensure that the symbol returned belongs to the correct setion
(and that the last [random] symbol from the previous section
isn't returned) try to find the section containing PC. First try
the overlay code (which by default returns NULL); and second try
the normal section code (which almost always succeeds). */
section = find_pc_overlay (pc);
if (section == NULL)
{
struct obj_section *obj_section = find_pc_section (pc);
if (obj_section == NULL)
section = NULL;
else
section = obj_section->the_bfd_section;
}
mapped_pc = overlay_mapped_address (pc, section);
if (mapped_pc >= cache_pc_function_low
&& mapped_pc < cache_pc_function_high
&& section == cache_pc_function_section
&& inlining_flag == cache_pc_function_inlining)
goto return_cached_value;
cache_pc_function_inlining = inlining_flag;
msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
pst = find_pc_sect_psymtab (mapped_pc, section);
if (pst)
{
/* Need to read the symbols to get a good value for the end address. */
if (endaddr != NULL && !pst->readin)
{
/* Need to get the terminal in case symbol-reading produces
output. */
target_terminal_ours_for_output ();
PSYMTAB_TO_SYMTAB (pst);
}
if (pst->readin)
{
/* Checking whether the msymbol has a larger value is for the
"pathological" case mentioned in print_frame_info. */
if (inlining_flag)
f = find_pc_sect_function (mapped_pc, section);
else
f = find_pc_sect_function_no_inlined (mapped_pc, section);
/* APPLE LOCAL begin address ranges */
if (f != NULL
&& (msymbol == NULL
|| (BLOCK_LOWEST_PC (SYMBOL_BLOCK_VALUE (f))
>= SYMBOL_VALUE_ADDRESS (msymbol))))
{
cache_pc_function_low = BLOCK_LOWEST_PC (SYMBOL_BLOCK_VALUE (f));
if (BLOCK_RANGES (SYMBOL_BLOCK_VALUE (f)))
cache_pc_function_high =
BLOCK_HIGHEST_PC (SYMBOL_BLOCK_VALUE (f));
else
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
/* APPLE LOCAL end address ranges */
cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
cache_pc_function_section = section;
goto return_cached_value;
}
}
else
{
/* Now that static symbols go in the minimal symbol table, perhaps
we could just ignore the partial symbols. But at least for now
we use the partial or minimal symbol, whichever is larger. */
psb = find_pc_sect_psymbol (pst, mapped_pc, section);
if (psb
&& (msymbol == NULL ||
(SYMBOL_VALUE_ADDRESS (psb)
>= SYMBOL_VALUE_ADDRESS (msymbol))))
{
/* This case isn't being cached currently. */
if (address)
*address = SYMBOL_VALUE_ADDRESS (psb);
if (name)
*name = DEPRECATED_SYMBOL_NAME (psb);
/* endaddr non-NULL can't happen here. */
return 1;
}
}
}
/* 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
of the text seg doesn't appear to be part of the last function in the
text segment. */
osect = find_pc_sect_section (mapped_pc, section);
if (!osect)
msymbol = NULL;
/* Must be in the minimal symbol table. */
if (msymbol == NULL)
{
/* No available symbol. */
if (name != NULL)
*name = 0;
if (address != NULL)
*address = 0;
if (endaddr != NULL)
*endaddr = 0;
return 0;
}
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
cache_pc_function_name = DEPRECATED_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; DEPRECATED_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))
break;
}
if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
else
/* We got the start address from the last msymbol in the objfile.
So the end address is the end of the section. */
cache_pc_function_high = osect->endaddr;
return_cached_value:
if (address)
{
if (pc_in_unmapped_range (pc, section))
*address = overlay_unmapped_address (cache_pc_function_low, section);
else
*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,
section);
}
else
*endaddr = cache_pc_function_high;
}
return 1;
}
static void
info_common_command (char *comname, int from_tty)
{
SAVED_F77_COMMON_PTR the_common;
COMMON_ENTRY_PTR entry;
struct frame_info *fi;
char *funname = 0;
struct symbol *func;
/* We have been told to display the contents of F77 COMMON
block supposedly visible in this function. Let us
first make sure that it is visible and if so, let
us display its contents */
fi = deprecated_selected_frame;
if (fi == NULL)
error (_("No frame selected"));
/* The following is generally ripped off from stack.c's routine
print_frame_info() */
func = find_pc_function (get_frame_pc (fi));
if (func)
{
/* In certain pathological cases, the symtabs give the wrong
function (when we are in the first function in a file which
is compiled without debugging symbols, the previous function
is compiled with debugging symbols, and the "foo.o" symbol
that is supposed to tell us where the file with debugging symbols
ends has been truncated by ar because it is longer than 15
characters).
So look in the minimal symbol tables as well, and if it comes
up with a larger address for the function use that instead.
I don't think this can ever cause any problems; there shouldn't
be any minimal symbols in the middle of a function.
FIXME: (Not necessarily true. What about text labels) */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
/* APPLE LOCAL begin address ranges */
if (msymbol != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol)
> BLOCK_LOWEST_PC (SYMBOL_BLOCK_VALUE (func)))
/* APPLE LOCAL end address ranges */
funname = DEPRECATED_SYMBOL_NAME (msymbol);
else
funname = DEPRECATED_SYMBOL_NAME (func);
}
else
{
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (get_frame_pc (fi));
if (msymbol != NULL)
funname = DEPRECATED_SYMBOL_NAME (msymbol);
}
/* If comname is NULL, we assume the user wishes to see the
which COMMON blocks are visible here and then return */
if (comname == 0)
{
list_all_visible_commons (funname);
return;
}
the_common = find_common_for_function (comname, funname);
if (the_common)
{
if (strcmp (comname, BLANK_COMMON_NAME_LOCAL) == 0)
printf_filtered (_("Contents of blank COMMON block:\n"));
else
printf_filtered (_("Contents of F77 COMMON block '%s':\n"), comname);
printf_filtered ("\n");
entry = the_common->entries;
while (entry != NULL)
{
printf_filtered ("%s = ", DEPRECATED_SYMBOL_NAME (entry->symbol));
print_variable_value (entry->symbol, fi, gdb_stdout);
printf_filtered ("\n");
entry = entry->next;
}
}
else
printf_filtered (_("Cannot locate the common block %s in function '%s'\n"),
comname, funname);
}
struct blockvector *
blockvector_for_pc_sect (CORE_ADDR pc, struct bfd_section *section,
int *pindex, struct symtab *symtab)
{
struct block *b;
struct block *static_block;
int bot, top, half;
struct blockvector *bl;
if (pindex)
*pindex = 0;
/* APPLE LOCAL begin cache lookup values for improved performance */
if ((pc == last_blockvector_lookup_pc)
&& (pc == last_mapped_section_lookup_pc)
&& (section == cached_mapped_section)
&& cached_blockvector && (pindex != NULL))
{
*pindex = cached_blockvector_index;
return cached_blockvector;
}
last_blockvector_lookup_pc = pc;
/* APPLE LOCAL end cache lookup values for improved performance */
if (symtab == 0) /* if no symtab specified by caller */
{
/* First search all symtabs for one whose file contains our pc */
symtab = find_pc_sect_symtab (pc, section);
if (symtab == 0)
/* APPLE LOCAL begin cache lookup values for improved performance */
{
cached_blockvector_index = -1;
cached_blockvector = NULL;
return 0;
}
/* APPLE LOCAL end cache lookup values for improved performance */
}
bl = BLOCKVECTOR(symtab);
static_block = BLOCKVECTOR_BLOCK(bl, STATIC_BLOCK);
b = BLOCKVECTOR_BLOCK(bl, 0);
gdb_assert(b != NULL);
/* Then search that symtab for the smallest block that wins. */
/* Use binary search to find the last block that starts before PC. */
bot = 0;
top = BLOCKVECTOR_NBLOCKS(bl);
while (top - bot > 1)
{
half = (top - bot + 1) >> 1;
b = BLOCKVECTOR_BLOCK(bl, (bot + half));
/* APPLE LOCAL begin address ranges */
if (BLOCK_LOWEST_PC(b) <= pc)
/* APPLE LOCAL end address ranges */
bot += half;
else
top = bot + half;
}
/* APPLE LOCAL We start with the block whose start/end address
is higher than PC. */
/* Now search backward for a block that ends after PC. */
/* APPLE LOCAL: Stop at the first local block; i.e. don't iterate down
to the global/static blocks. */
while (bot >= FIRST_LOCAL_BLOCK)
{
b = BLOCKVECTOR_BLOCK(bl, bot);
/* APPLE LOCAL begin address ranges */
/* This condition is a little tricky.
Given a function like
func () {
{ subblock}
// pc here
}
BOT may be pointing to "subblock" and so the BOT block
start/end addrs are less than PC. But we don't want to
terminate the search in this case - we need to keep iterating
backwards to find "func"'s block.
So I'm trying to restrict this to only quit searching if
we're looking at a function's overall scope and both its
highest/lowest addresses are lower than PC. */
if (BLOCK_SUPERBLOCK (b) == static_block
&& BLOCK_LOWEST_PC (b) < pc && BLOCK_HIGHEST_PC (b) < pc)
/* APPLE LOCAL begin cache lookup values for improved performance */
{
cached_blockvector_index = -1;
cached_blockvector = NULL;
return 0;
}
/* APPLE LOCAL end cache lookup values for improved performance */
if (block_contains_pc(b, pc))
/* APPLE LOCAL end address ranges */
{
if (pindex)
*pindex = bot;
/* APPLE LOCAL begom cache lookup values for improved
performance */
cached_blockvector_index = bot;
cached_blockvector = bl;
/* APPLE LOCAL end cache lookup values for improved performance */
return bl;
}
bot--;
}
/* APPLE LOCAL begin cache lookup values for improved performance */
cached_blockvector_index = -1;
cached_blockvector = NULL;
/* APPLE LOCAL end cache lookup values for improved performance */
return 0;
}