A PC of zero is always considered to be the bottom of the stack. */
int
-inside_entry_file (CORE_ADDR addr)
+deprecated_inside_entry_file (CORE_ADDR addr)
{
if (addr == 0)
return 1;
if (symfile_objfile == 0)
return 0;
- if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+ if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT
+ || CALL_DUMMY_LOCATION == AT_SYMBOL)
{
/* Do not stop backtracing if the pc is in the call dummy
at the entry point. */
if (DEPRECATED_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.deprecated_entry_file_lowpc &&
+ addr < symfile_objfile->ei.deprecated_entry_file_highpc);
}
/* Test a specified PC value to see if it is in the range of addresses
BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
}
}
+
+ /* Not in the normal symbol tables, see if "main" is in the partial
+ symbol table. If it's not, then give up. */
+ {
+ struct minimal_symbol *msymbol
+ = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
+ if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
+ {
+ struct obj_section *osect
+ = find_pc_sect_section (SYMBOL_VALUE_ADDRESS (msymbol),
+ msymbol->ginfo.bfd_section);
+ 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) != SYMBOL_VALUE_ADDRESS (msymbol)
+ && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
+ break;
+ }
+
+ symfile_objfile->ei.main_func_lowpc = SYMBOL_VALUE_ADDRESS (msymbol);
+
+ /* 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);
}
return 0;
}
-/* return the address of the PC for the given FRAME, ie the current PC value
- if FRAME is the innermost frame, or the address adjusted to point to the
- call instruction if not. */
-
-CORE_ADDR
-frame_address_in_block (struct frame_info *frame)
-{
- CORE_ADDR pc = get_frame_pc (frame);
-
- /* If we are not in the innermost frame, and we are not interrupted
- by a signal, frame->pc points to the instruction following the
- call. As a consequence, we need to get the address of the previous
- instruction. Unfortunately, this is not straightforward to do, so
- we just use the address minus one, which is a good enough
- approximation. */
- /* FIXME: cagney/2002-11-10: Should this instead test for
- NORMAL_FRAME? A dummy frame (in fact all the abnormal frames)
- save the PC value in the block. */
- if (get_next_frame (frame) != 0
- && get_frame_type (get_next_frame (frame)) != SIGTRAMP_FRAME)
- --pc;
-
- return pc;
-}
-
/* Return the innermost lexical block in execution
in a specified stack frame. The frame address is assumed valid.
struct block *
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
{
- const CORE_ADDR pc = frame_address_in_block (frame);
+ const CORE_ADDR pc = get_frame_address_in_block (frame);
if (addr_in_block)
*addr_in_block = pc;
struct symbol *
get_frame_function (struct frame_info *frame)
{
- register struct block *bl = get_frame_block (frame, 0);
+ struct block *bl = get_frame_block (frame, 0);
if (bl == 0)
return 0;
return block_function (bl);
struct symbol *
find_pc_sect_function (CORE_ADDR pc, struct sec *section)
{
- register struct block *b = block_for_pc_sect (pc, section);
+ struct block *b = block_for_pc_sect (pc, section);
if (b == 0)
return 0;
return block_function (b);
block_innermost_frame (struct block *block)
{
struct frame_info *frame;
- register CORE_ADDR start;
- register CORE_ADDR end;
+ CORE_ADDR start;
+ CORE_ADDR end;
CORE_ADDR calling_pc;
if (block == NULL)
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
- calling_pc = frame_address_in_block (frame);
+ calling_pc = get_frame_address_in_block (frame);
if (calling_pc >= start && calling_pc < end)
return frame;
}
deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
CORE_ADDR frame_address)
{
- return ((pc) >= CALL_DUMMY_ADDRESS ()
- && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
+ CORE_ADDR addr = entry_point_address ();
+ if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
+ addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
+ return ((pc) >= addr && (pc) <= (addr + DECR_PC_AFTER_BREAK));
}
/* Returns true for a user frame or a call_function_by_hand dummy
/* NOTE/drow 2002-12-25: should there be a way to disable this check? It
assumes a single small entry file, and the way some debug readers (e.g.
dbxread) figure out which object is the entry file is somewhat hokey. */
- if (inside_entry_file (frame_pc_unwind (fi)))
+ if (deprecated_inside_entry_file (frame_pc_unwind (fi)))
return 0;
return 1;
projects / deliverable / binutils-gdb.git / blobdiff