Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

Merges from SKY branch:

Browse Source 
* blockframe.c(find_pc_sect_partial_function): look for min syms in
          the same section when trying to guess the end of a function.
        * symfile.c(list_overlays_command): use print_address_numeric
        * remote-sim.c: export simulator_command
        * tm-r5900.h: add COP0 registers
        * txvu-tdep.c: printvector and printvector-order commands
        * tm-txvu.h: add COP0 registers
        * mips-tdep.c: use NUM_CORE_REGS
This commit is contained in:
Ron Unrau
1998-09-09 17:41:59 +00:00
parent 323f833daf
commit 253ceee6d0
3 changed files with 183 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
gdb/ChangeLog
View File

@@ -1,3 +1,18 @@
Wed Sep 9 11:39:05 1998 Ron Unrau <runrau@cygnus.com>
* blockframe.c(find_pc_sect_partial_function): look for min syms in
the same section when trying to guess the end of a function.
* symfile.c(list_overlays_command): use print_address_numeric
* remote-sim.c: export simulator_command
start-sanitize-r5900
* tm-r5900.h: add COP0 registers
end-sanitize-r5900
start-sanitize-sky
* txvu-tdep.c: printvector and printvector-order commands
* tm-txvu.h: add COP0 registers
* mips-tdep.c: use NUM_CORE_REGS
end-sanitize-sky
1998-09-08 Jason Molenda (jsm@bugshack.cygnus.com) 1998-09-08 Jason Molenda (jsm@bugshack.cygnus.com)
* breakpoint.c (bpstat_stop_status): Declare a bp match if the * breakpoint.c (bpstat_stop_status): Declare a bp match if the

226
gdb/blockframe.c
View File

@@ -87,8 +87,10 @@ CORE_ADDR pc;
mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL); mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL);
if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK) if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK)
{ {
symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); symfile_objfile->ei.main_func_lowpc =
symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
symfile_objfile->ei.main_func_highpc =
BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
} }
} }
return (symfile_objfile -> ei.main_func_lowpc <= pc && return (symfile_objfile -> ei.main_func_lowpc <= pc &&
@@ -535,27 +537,32 @@ get_frame_function (frame)
return block_function (bl); return block_function (bl);
} }
/* Return the blockvector immediately containing the innermost lexical block /* Return the blockvector immediately containing the innermost lexical block
containing the specified pc value, or 0 if there is none. containing the specified pc value and section, or 0 if there is none.
PINDEX is a pointer to the index value of the block. If PINDEX PINDEX is a pointer to the index value of the block. If PINDEX
is NULL, we don't pass this information back to the caller. */ is NULL, we don't pass this information back to the caller. */
struct blockvector * struct blockvector *
blockvector_for_pc (pc, pindex) blockvector_for_pc_sect (pc, section, pindex, symtab)
register CORE_ADDR pc; register CORE_ADDR pc;
struct sec *section;
int *pindex; int *pindex;
struct symtab *symtab;
{ {
register struct block *b; register struct block *b;
register int bot, top, half; register int bot, top, half;
register struct symtab *s;
struct blockvector *bl; struct blockvector *bl;
/* First search all symtabs for one whose file contains our pc */ if (symtab == 0) /* if no symtab specified by caller */
s = find_pc_symtab (pc); {
if (s == 0) /* First search all symtabs for one whose file contains our pc */
return 0; if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
return 0;
}
bl = BLOCKVECTOR (s); bl = BLOCKVECTOR (symtab);
b = BLOCKVECTOR_BLOCK (bl, 0); b = BLOCKVECTOR_BLOCK (bl, 0);
/* Then search that symtab for the smallest block that wins. */ /* Then search that symtab for the smallest block that wins. */
@@ -587,45 +594,80 @@ blockvector_for_pc (pc, pindex)
} }
bot--; bot--;
} }
return 0; return 0;
} }
/* Return the innermost lexical block containing the specified pc value, /* Return the blockvector immediately containing the innermost lexical block
or 0 if there is none. */ containing the specified pc value, or 0 if there is none.
Backward compatibility, no section. */
struct blockvector *
blockvector_for_pc (pc, pindex)
register CORE_ADDR pc;
int *pindex;
{
return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
pindex, NULL);
}
/* Return the innermost lexical block containing the specified pc value
in the specified section, or 0 if there is none. */
struct block * struct block *
block_for_pc (pc) block_for_pc_sect (pc, section)
register CORE_ADDR pc; register CORE_ADDR pc;
struct sec *section;
{ {
register struct blockvector *bl; register struct blockvector *bl;
int index; int index;
bl = blockvector_for_pc (pc, &index); bl = blockvector_for_pc_sect (pc, section, &index, NULL);
if (bl) if (bl)
return BLOCKVECTOR_BLOCK (bl, index); return BLOCKVECTOR_BLOCK (bl, index);
return 0; return 0;
} }
/* Return the function containing pc value PC. /* Return the innermost lexical block containing the specified pc value,
or 0 if there is none. Backward compatibility, no section. */
struct block *
block_for_pc (pc)
register CORE_ADDR pc;
{
return block_for_pc_sect (pc, find_pc_mapped_section (pc));
}
/* 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_function (pc) find_pc_sect_function (pc, section)
CORE_ADDR pc; CORE_ADDR pc;
struct sec *section;
{ {
register struct block *b = block_for_pc (pc); register struct block *b = block_for_pc_sect (pc, section);
if (b == 0) if (b == 0)
return 0; return 0;
return block_function (b); return block_function (b);
} }
/* Return the function containing pc value PC.
Returns 0 if function is not known. Backward compatibility, no section */
struct symbol *
find_pc_function (pc)
CORE_ADDR 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 sec *cache_pc_function_section = NULL;
/* Clear cache, e.g. when symbol table is discarded. */ /* Clear cache, e.g. when symbol table is discarded. */
@@ -635,50 +677,58 @@ clear_pc_function_cache()
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;
} }
/* 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. Sets *NAME and/or greatest of all of the potential text symbols in SECTION. Sets
*ADDRESS conditionally if that pointer is non-null. If ENDADDR is *NAME and/or *ADDRESS conditionally if that pointer is non-null.
non-null, then set *ENDADDR to be the end of the function If ENDADDR is non-null, then set *ENDADDR to be the end of the
(exclusive), but passing ENDADDR as non-null means that the function (exclusive), but passing ENDADDR as non-null means that
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 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
and returns 0. */ returns 0. */
int int
find_pc_partial_function (pc, name, address, endaddr) find_pc_sect_partial_function (pc, section, name, address, endaddr)
CORE_ADDR pc; CORE_ADDR pc;
char **name; asection *section;
char **name;
CORE_ADDR *address; CORE_ADDR *address;
CORE_ADDR *endaddr; CORE_ADDR *endaddr;
{ {
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;
struct obj_section *sec; struct obj_section *osect;
int i;
CORE_ADDR mapped_pc;
if (pc >= cache_pc_function_low && pc < cache_pc_function_high) 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)
goto return_cached_value; goto return_cached_value;
/* If sigtramp is in the u area, it counts as a function (especially /* If sigtramp is in the u area, it counts as a function (especially
important for step_1). */ important for step_1). */
#if defined SIGTRAMP_START #if defined SIGTRAMP_START
if (IN_SIGTRAMP (pc, (char *)NULL)) if (IN_SIGTRAMP (mapped_pc, (char *)NULL))
{ {
cache_pc_function_low = SIGTRAMP_START (pc); cache_pc_function_low = SIGTRAMP_START (mapped_pc);
cache_pc_function_high = SIGTRAMP_END (pc); cache_pc_function_high = SIGTRAMP_END (mapped_pc);
cache_pc_function_name = "<sigtramp>"; cache_pc_function_name = "<sigtramp>";
cache_pc_function_section = section;
goto return_cached_value; goto return_cached_value;
} }
#endif #endif
msymbol = lookup_minimal_symbol_by_pc (pc); msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
pst = find_pc_psymtab (pc); 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. */
@@ -694,15 +744,16 @@ find_pc_partial_function (pc, name, address, endaddr)
{ {
/* 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_function (pc); 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_NAME (f); cache_pc_function_name = SYMBOL_NAME (f);
cache_pc_function_section = section;
goto return_cached_value; goto return_cached_value;
} }
} }
@@ -711,7 +762,7 @@ find_pc_partial_function (pc, name, address, endaddr)
/* 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_psymbol (pst, pc); psb = find_pc_sect_psymbol (pst, mapped_pc, section);
if (psb if (psb
&& (msymbol == NULL || && (msymbol == NULL ||
@@ -734,9 +785,9 @@ find_pc_partial_function (pc, name, address, endaddr)
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. */
sec = find_pc_section (pc); osect = find_pc_sect_section (mapped_pc, section);
if (!sec) if (!osect)
msymbol = NULL; msymbol = NULL;
/* Must be in the minimal symbol table. */ /* Must be in the minimal symbol table. */
@@ -752,30 +803,70 @@ find_pc_partial_function (pc, name, address, endaddr)
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_NAME (msymbol); cache_pc_function_name = SYMBOL_NAME (msymbol);
cache_pc_function_section = section;
/* Use the lesser of the next minimal symbol, or the end of the section, as /* Use the lesser of the next minimal symbol in the same section, or the end
the end of the function. */ of the section, as the end of the function. Step over other symbols at
this same address to find the next one. */
if (SYMBOL_NAME (msymbol + 1) != NULL for (i=1; SYMBOL_NAME (msymbol+i) != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol + 1) < sec->endaddr) && (SYMBOL_VALUE_ADDRESS(msymbol+i) == SYMBOL_VALUE_ADDRESS (msymbol)
cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + 1); || SYMBOL_BFD_SECTION(msymbol+i) != section);
i++) /* empty */;
if (SYMBOL_NAME (msymbol + i) != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
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 = sec->endaddr; cache_pc_function_high = osect->endaddr;
return_cached_value: return_cached_value:
if (address) if (address)
*address = cache_pc_function_low; if (pc_in_unmapped_range (pc, section))
*address = overlay_unmapped_address (cache_pc_function_low, section);
else
*address = cache_pc_function_low;
if (name) if (name)
*name = cache_pc_function_name; *name = cache_pc_function_name;
if (endaddr) if (endaddr)
*endaddr = cache_pc_function_high; 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; return 1;
} }
/* Backward compatibility, no section argument */
int
find_pc_partial_function (pc, name, address, endaddr)
CORE_ADDR pc;
char **name;
CORE_ADDR *address;
CORE_ADDR *endaddr;
{
asection *section;
section = find_pc_overlay (pc);
return find_pc_sect_partial_function (pc, section, name, address, endaddr);
}
/* 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. */
@@ -967,6 +1058,21 @@ generic_push_dummy_frame ()
dummy_frame_stack = dummy_frame; dummy_frame_stack = dummy_frame;
} }
/* Function: pop_frame
Restore the machine state from either the saved dummy stack or a
real stack frame. */
void
generic_pop_current_frame (pop)
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))
generic_pop_dummy_frame ();
else
pop (frame);
}
/* Function: pop_dummy_frame /* Function: pop_dummy_frame
Restore the machine state from a saved dummy stack frame. */ Restore the machine state from a saved dummy stack frame. */
@@ -982,6 +1088,7 @@ generic_pop_dummy_frame ()
error ("Can't pop dummy frame!"); error ("Can't pop dummy frame!");
dummy_frame_stack = dummy_frame->next; dummy_frame_stack = dummy_frame->next;
write_register_bytes (0, dummy_frame->regs, REGISTER_BYTES); write_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
flush_cached_frames ();
free (dummy_frame); free (dummy_frame);
} }
@@ -998,7 +1105,7 @@ generic_frame_chain_valid (fp, fi)
return 1; /* don't prune CALL_DUMMY frames */ return 1; /* don't prune CALL_DUMMY frames */
else /* fall back to default algorithm (see frame.h) */ else /* fall back to default algorithm (see frame.h) */
return (fp != 0 return (fp != 0
&& fi->frame INNER_THAN fp && (fi->frame INNER_THAN fp || fi->frame == fp)
&& !inside_entry_file (FRAME_SAVED_PC(fi))); && !inside_entry_file (FRAME_SAVED_PC(fi)));
} }
@@ -1035,7 +1142,6 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
int regnum; int regnum;
enum lval_type *lval; enum lval_type *lval;
{ {
CORE_ADDR addr;
struct frame_saved_regs fsr; struct frame_saved_regs fsr;
if (!target_has_registers) if (!target_has_registers)

4
gdb/remote-sim.c
View File

@@ -97,7 +97,7 @@ static void gdbsim_mourn_inferior PARAMS ((void));
static void gdbsim_stop PARAMS ((void)); static void gdbsim_stop PARAMS ((void));
static void simulator_command PARAMS ((char *args, int from_tty)); void simulator_command PARAMS ((char *args, int from_tty));
/* Naming convention: /* Naming convention:
@@ -889,7 +889,7 @@ gdbsim_remove_breakpoint (addr, contents_cache)
/* Pass the command argument through to the simulator verbatim. The /* Pass the command argument through to the simulator verbatim. The
simulator must do any command interpretation work. */ simulator must do any command interpretation work. */
static void void
simulator_command (args, from_tty) simulator_command (args, from_tty)
char *args; char *args;
int from_tty; int from_tty;