OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merges from SKY branch: 

* 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
Show Stats 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)
* 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);
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 = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
symfile_objfile->ei.main_func_lowpc =
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 &&
@ -535,27 +537,32 @@ get_frame_function (frame)
return block_function (bl);
}
/* 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
is NULL, we don't pass this information back to the caller. */
struct blockvector *
blockvector_for_pc (pc, pindex)
blockvector_for_pc_sect (pc, section, pindex, symtab)
register CORE_ADDR pc;
struct sec *section;
int *pindex;
struct symtab *symtab;
{
register struct block *b;
register int bot, top, half;
register struct symtab *s;
struct blockvector *bl;
/* First search all symtabs for one whose file contains our pc */
s = find_pc_symtab (pc);
if (s == 0)
return 0;
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)
return 0;
}
bl = BLOCKVECTOR (s);
bl = BLOCKVECTOR (symtab);
b = BLOCKVECTOR_BLOCK (bl, 0);
/* Then search that symtab for the smallest block that wins. */
@ -587,45 +594,80 @@ blockvector_for_pc (pc, pindex)
}
bot--;
}
return 0;
}
/* Return the innermost lexical block containing the specified pc value,
or 0 if there is none. */
/* Return the blockvector immediately containing the innermost lexical block
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 *
block_for_pc (pc)
block_for_pc_sect (pc, section)
register CORE_ADDR pc;
struct sec *section;
{
register struct blockvector *bl;
int index;
bl = blockvector_for_pc (pc, &index);
bl = blockvector_for_pc_sect (pc, section, &index, NULL);
if (bl)
return BLOCKVECTOR_BLOCK (bl, index);
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. */
struct symbol *
find_pc_function (pc)
find_pc_sect_function (pc, section)
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)
return 0;
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
* 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. */
@ -635,50 +677,58 @@ clear_pc_function_cache()
cache_pc_function_low = 0;
cache_pc_function_high = 0;
cache_pc_function_name = (char *)0;
cache_pc_function_section = NULL;
}
/* Finds the "function" (text symbol) that is smaller than PC but
greatest of all of the potential text symbols. Sets *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 function
(exclusive), but passing ENDADDR as non-null means that the
function might cause symbols to be read. This function either
greatest of all of the potential text symbols in SECTION. Sets
*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
function (exclusive), but passing ENDADDR as non-null means that
the function might cause symbols to be read. This function either
succeeds or fails (not halfway succeeds). If it succeeds, it sets
*NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero
and returns 0. */
If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
returns 0. */
int
find_pc_partial_function (pc, name, address, endaddr)
CORE_ADDR pc;
char **name;
find_pc_sect_partial_function (pc, section, name, address, endaddr)
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 *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;
/* If sigtramp is in the u area, it counts as a function (especially
important for step_1). */
#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_high = SIGTRAMP_END (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;
}
#endif
msymbol = lookup_minimal_symbol_by_pc (pc);
pst = find_pc_psymtab (pc);
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. */
@ -694,15 +744,16 @@ find_pc_partial_function (pc, name, address, endaddr)
{
/* Checking whether the msymbol has a larger value is for the
"pathological" case mentioned in print_frame_info. */
f = find_pc_function (pc);
f = find_pc_sect_function (mapped_pc, section);
if (f != NULL
&& (msymbol == NULL
|| (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;
}
}
@ -711,7 +762,7 @@ find_pc_partial_function (pc, name, address, endaddr)
/* 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_psymbol (pst, pc);
psb = find_pc_sect_psymbol (pst, mapped_pc, section);
if (psb
&& (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
text segment. */
sec = find_pc_section (pc);
osect = find_pc_sect_section (mapped_pc, section);
if (!sec)
if (!osect)
msymbol = NULL;
/* Must be in the minimal symbol table. */
@ -752,30 +803,70 @@ find_pc_partial_function (pc, 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, or the end of the section, as
the end of the function. */
/* 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 to find the next one. */
if (SYMBOL_NAME (msymbol + 1) != NULL
&& SYMBOL_VALUE_ADDRESS (msymbol + 1) < sec->endaddr)
cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + 1);
for (i=1; SYMBOL_NAME (msymbol+i) != NULL
&& (SYMBOL_VALUE_ADDRESS(msymbol+i) == SYMBOL_VALUE_ADDRESS (msymbol)
|| 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
/* 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 = sec->endaddr;
cache_pc_function_high = osect->endaddr;
return_cached_value:
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)
*name = cache_pc_function_name;
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;
}
/* 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,
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;
}
/* 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
Restore the machine state from a saved dummy stack frame. */
@ -982,6 +1088,7 @@ generic_pop_dummy_frame ()
error ("Can't pop dummy frame!");
dummy_frame_stack = dummy_frame->next;
write_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
flush_cached_frames ();
free (dummy_frame);
}
@ -998,7 +1105,7 @@ generic_frame_chain_valid (fp, fi)
return 1; /* don't prune CALL_DUMMY frames */
else /* fall back to default algorithm (see frame.h) */
return (fp != 0
&& fi->frame INNER_THAN fp
&& (fi->frame INNER_THAN fp || fi->frame == fp)
&& !inside_entry_file (FRAME_SAVED_PC(fi)));
}
@ -1035,7 +1142,6 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
int regnum;
enum lval_type *lval;
{
CORE_ADDR addr;
struct frame_saved_regs fsr;
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 simulator_command PARAMS ((char *args, int from_tty));
void simulator_command PARAMS ((char *args, int from_tty));
/* Naming convention:
@ -889,7 +889,7 @@ gdbsim_remove_breakpoint (addr, contents_cache)
/* Pass the command argument through to the simulator verbatim. The
simulator must do any command interpretation work. */
static void
void
simulator_command (args, from_tty)
char *args;
int from_tty;