gdb/
* frame.c (frame_unwind_pc): Rename to ... (frame_unwind_pc_if_available): ... this. New `pc' output parameter. Change return type to int. Gracefully handle gdbarch_unwind_pc throwing NOT_AVAILABLE_ERROR. Return 0 if that happened, or 1 otherwise. (frame_unwind_pc): Reimplement on top of frame_unwind_pc_if_available. (get_frame_func): Rename to ... (get_frame_func_if_available): New `pc' output parameter. Change return type to int. Gracefully handle the PC not being available. (get_frame_func): Reimplement on top of get_frame_func_if_available. (select_frame): Handle the PC being unavailable. (get_prev_frame): Handle the PC being unavailable. (get_frame_pc_if_available): New. (get_frame_address_in_block_if_available): New. (find_frame_sal): Handle the frame PC not being available. * frame.h (get_frame_pc_if_available): Declare. (get_frame_address_in_block_if_available): Declare. (get_frame_func_if_available): Declare. * stack.c (print_frame_info): Handle the PC being unavailable. (find_frame_funname): Ditto. (print_frame): Handle the PC being unavailable. (get_frame_language): Ditto. * blockframe.c (get_frame_block): Ditto. * macroscope.c (default_macro_scope): Ditto. * tui/tui-stack.c (tui_show_frame_info): Ditto.
This commit is contained in:
parent
79e1a869ac
commit
e3eebbd742
|
@ -58,10 +58,13 @@
|
|||
struct block *
|
||||
get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
|
||||
{
|
||||
const CORE_ADDR pc = get_frame_address_in_block (frame);
|
||||
CORE_ADDR pc;
|
||||
struct block *bl;
|
||||
int inline_count;
|
||||
|
||||
if (!get_frame_address_in_block_if_available (frame, &pc))
|
||||
return NULL;
|
||||
|
||||
if (addr_in_block)
|
||||
*addr_in_block = pc;
|
||||
|
||||
|
|
220
gdb/frame.c
220
gdb/frame.c
|
@ -619,15 +619,17 @@ frame_find_by_id (struct frame_id id)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frame_unwind_pc (struct frame_info *this_frame)
|
||||
static int
|
||||
frame_unwind_pc_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
|
||||
{
|
||||
if (!this_frame->prev_pc.p)
|
||||
{
|
||||
CORE_ADDR pc;
|
||||
|
||||
if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
|
||||
{
|
||||
volatile struct gdb_exception ex;
|
||||
struct gdbarch *prev_gdbarch;
|
||||
CORE_ADDR pc = 0;
|
||||
|
||||
/* The right way. The `pure' way. The one true way. This
|
||||
method depends solely on the register-unwind code to
|
||||
determine the value of registers in THIS frame, and hence
|
||||
|
@ -644,20 +646,62 @@ frame_unwind_pc (struct frame_info *this_frame)
|
|||
frame. This is all in stark contrast to the old
|
||||
FRAME_SAVED_PC which would try to directly handle all the
|
||||
different ways that a PC could be unwound. */
|
||||
pc = gdbarch_unwind_pc (frame_unwind_arch (this_frame), this_frame);
|
||||
prev_gdbarch = frame_unwind_arch (this_frame);
|
||||
|
||||
TRY_CATCH (ex, RETURN_MASK_ERROR)
|
||||
{
|
||||
pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
|
||||
}
|
||||
if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
|
||||
{
|
||||
this_frame->prev_pc.p = -1;
|
||||
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ frame_unwind_pc (this_frame=%d)"
|
||||
" -> <unavailable> }\n",
|
||||
this_frame->level);
|
||||
}
|
||||
else if (ex.reason < 0)
|
||||
{
|
||||
throw_exception (ex);
|
||||
}
|
||||
else
|
||||
{
|
||||
this_frame->prev_pc.value = pc;
|
||||
this_frame->prev_pc.p = 1;
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ frame_unwind_pc (this_frame=%d) "
|
||||
"-> %s }\n",
|
||||
this_frame->level,
|
||||
hex_string (this_frame->prev_pc.value));
|
||||
}
|
||||
}
|
||||
else
|
||||
internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
|
||||
this_frame->prev_pc.value = pc;
|
||||
this_frame->prev_pc.p = 1;
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ frame_unwind_caller_pc "
|
||||
"(this_frame=%d) -> %s }\n",
|
||||
this_frame->level,
|
||||
hex_string (this_frame->prev_pc.value));
|
||||
}
|
||||
return this_frame->prev_pc.value;
|
||||
if (this_frame->prev_pc.p < 0)
|
||||
{
|
||||
*pc = -1;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
*pc = this_frame->prev_pc.value;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frame_unwind_pc (struct frame_info *this_frame)
|
||||
{
|
||||
CORE_ADDR pc;
|
||||
|
||||
if (!frame_unwind_pc_if_available (this_frame, &pc))
|
||||
throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
|
||||
else
|
||||
return pc;
|
||||
}
|
||||
|
||||
CORE_ADDR
|
||||
|
@ -666,25 +710,59 @@ frame_unwind_caller_pc (struct frame_info *this_frame)
|
|||
return frame_unwind_pc (skip_inlined_frames (this_frame));
|
||||
}
|
||||
|
||||
CORE_ADDR
|
||||
get_frame_func (struct frame_info *this_frame)
|
||||
int
|
||||
get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
|
||||
{
|
||||
struct frame_info *next_frame = this_frame->next;
|
||||
|
||||
if (!next_frame->prev_func.p)
|
||||
{
|
||||
CORE_ADDR addr_in_block;
|
||||
|
||||
/* Make certain that this, and not the adjacent, function is
|
||||
found. */
|
||||
CORE_ADDR addr_in_block = get_frame_address_in_block (this_frame);
|
||||
next_frame->prev_func.p = 1;
|
||||
next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ get_frame_func (this_frame=%d) -> %s }\n",
|
||||
this_frame->level,
|
||||
hex_string (next_frame->prev_func.addr));
|
||||
if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
|
||||
{
|
||||
next_frame->prev_func.p = -1;
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ get_frame_func (this_frame=%d)"
|
||||
" -> unavailable }\n",
|
||||
this_frame->level);
|
||||
}
|
||||
else
|
||||
{
|
||||
next_frame->prev_func.p = 1;
|
||||
next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
|
||||
if (frame_debug)
|
||||
fprintf_unfiltered (gdb_stdlog,
|
||||
"{ get_frame_func (this_frame=%d) -> %s }\n",
|
||||
this_frame->level,
|
||||
hex_string (next_frame->prev_func.addr));
|
||||
}
|
||||
}
|
||||
return next_frame->prev_func.addr;
|
||||
|
||||
if (next_frame->prev_func.p < 0)
|
||||
{
|
||||
*pc = -1;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
*pc = next_frame->prev_func.addr;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
CORE_ADDR
|
||||
get_frame_func (struct frame_info *this_frame)
|
||||
{
|
||||
CORE_ADDR pc;
|
||||
|
||||
if (!get_frame_func_if_available (this_frame, &pc))
|
||||
throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
|
||||
|
||||
return pc;
|
||||
}
|
||||
|
||||
static enum register_status
|
||||
|
@ -1298,8 +1376,6 @@ deprecated_safe_get_selected_frame (void)
|
|||
void
|
||||
select_frame (struct frame_info *fi)
|
||||
{
|
||||
struct symtab *s;
|
||||
|
||||
selected_frame = fi;
|
||||
/* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
|
||||
frame is being invalidated. */
|
||||
|
@ -1319,23 +1395,28 @@ select_frame (struct frame_info *fi)
|
|||
source language of this frame, and switch to it if desired. */
|
||||
if (fi)
|
||||
{
|
||||
/* We retrieve the frame's symtab by using the frame PC. However
|
||||
we cannot use the frame PC as-is, because it usually points to
|
||||
the instruction following the "call", which is sometimes the
|
||||
first instruction of another function. So we rely on
|
||||
get_frame_address_in_block() which provides us with a PC which
|
||||
is guaranteed to be inside the frame's code block. */
|
||||
s = find_pc_symtab (get_frame_address_in_block (fi));
|
||||
if (s
|
||||
&& s->language != current_language->la_language
|
||||
&& s->language != language_unknown
|
||||
&& language_mode == language_mode_auto)
|
||||
CORE_ADDR pc;
|
||||
|
||||
/* We retrieve the frame's symtab by using the frame PC.
|
||||
However we cannot use the frame PC as-is, because it usually
|
||||
points to the instruction following the "call", which is
|
||||
sometimes the first instruction of another function. So we
|
||||
rely on get_frame_address_in_block() which provides us with a
|
||||
PC which is guaranteed to be inside the frame's code
|
||||
block. */
|
||||
if (get_frame_address_in_block_if_available (fi, &pc))
|
||||
{
|
||||
set_language (s->language);
|
||||
struct symtab *s = find_pc_symtab (pc);
|
||||
|
||||
if (s
|
||||
&& s->language != current_language->la_language
|
||||
&& s->language != language_unknown
|
||||
&& language_mode == language_mode_auto)
|
||||
set_language (s->language);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Create an arbitrary (i.e. address specified by user) or innermost frame.
|
||||
Always returns a non-NULL value. */
|
||||
|
||||
|
@ -1755,10 +1836,14 @@ inside_entry_func (struct frame_info *this_frame)
|
|||
struct frame_info *
|
||||
get_prev_frame (struct frame_info *this_frame)
|
||||
{
|
||||
CORE_ADDR frame_pc;
|
||||
int frame_pc_p;
|
||||
|
||||
/* There is always a frame. If this assertion fails, suspect that
|
||||
something should be calling get_selected_frame() or
|
||||
get_current_frame(). */
|
||||
gdb_assert (this_frame != NULL);
|
||||
frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);
|
||||
|
||||
/* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
|
||||
sense to stop unwinding at a dummy frame. One place where a dummy
|
||||
|
@ -1773,6 +1858,7 @@ get_prev_frame (struct frame_info *this_frame)
|
|||
if (this_frame->level >= 0
|
||||
&& get_frame_type (this_frame) == NORMAL_FRAME
|
||||
&& !backtrace_past_main
|
||||
&& frame_pc_p
|
||||
&& inside_main_func (this_frame))
|
||||
/* Don't unwind past main(). Note, this is done _before_ the
|
||||
frame has been marked as previously unwound. That way if the
|
||||
|
@ -1819,6 +1905,7 @@ get_prev_frame (struct frame_info *this_frame)
|
|||
if (this_frame->level >= 0
|
||||
&& get_frame_type (this_frame) == NORMAL_FRAME
|
||||
&& !backtrace_past_entry
|
||||
&& frame_pc_p
|
||||
&& inside_entry_func (this_frame))
|
||||
{
|
||||
frame_debug_got_null_frame (this_frame, "inside entry func");
|
||||
|
@ -1832,7 +1919,7 @@ get_prev_frame (struct frame_info *this_frame)
|
|||
&& (get_frame_type (this_frame) == NORMAL_FRAME
|
||||
|| get_frame_type (this_frame) == INLINE_FRAME)
|
||||
&& get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
|
||||
&& get_frame_pc (this_frame) == 0)
|
||||
&& frame_pc_p && frame_pc == 0)
|
||||
{
|
||||
frame_debug_got_null_frame (this_frame, "zero PC");
|
||||
return NULL;
|
||||
|
@ -1848,6 +1935,28 @@ get_frame_pc (struct frame_info *frame)
|
|||
return frame_unwind_pc (frame->next);
|
||||
}
|
||||
|
||||
int
|
||||
get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
|
||||
{
|
||||
volatile struct gdb_exception ex;
|
||||
|
||||
gdb_assert (frame->next != NULL);
|
||||
|
||||
TRY_CATCH (ex, RETURN_MASK_ERROR)
|
||||
{
|
||||
*pc = frame_unwind_pc (frame->next);
|
||||
}
|
||||
if (ex.reason < 0)
|
||||
{
|
||||
if (ex.error == NOT_AVAILABLE_ERROR)
|
||||
return 0;
|
||||
else
|
||||
throw_exception (ex);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Return an address that falls within THIS_FRAME's code block. */
|
||||
|
||||
CORE_ADDR
|
||||
|
@ -1908,11 +2017,30 @@ get_frame_address_in_block (struct frame_info *this_frame)
|
|||
return pc;
|
||||
}
|
||||
|
||||
int
|
||||
get_frame_address_in_block_if_available (struct frame_info *this_frame,
|
||||
CORE_ADDR *pc)
|
||||
{
|
||||
volatile struct gdb_exception ex;
|
||||
|
||||
TRY_CATCH (ex, RETURN_MASK_ERROR)
|
||||
{
|
||||
*pc = get_frame_address_in_block (this_frame);
|
||||
}
|
||||
if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
|
||||
return 0;
|
||||
else if (ex.reason < 0)
|
||||
throw_exception (ex);
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
void
|
||||
find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
|
||||
{
|
||||
struct frame_info *next_frame;
|
||||
int notcurrent;
|
||||
CORE_ADDR pc;
|
||||
|
||||
/* If the next frame represents an inlined function call, this frame's
|
||||
sal is the "call site" of that inlined function, which can not
|
||||
|
@ -1953,8 +2081,14 @@ find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
|
|||
PC and such a PC indicates the current (rather than next)
|
||||
instruction/line, consequently, for such cases, want to get the
|
||||
line containing fi->pc. */
|
||||
notcurrent = (get_frame_pc (frame) != get_frame_address_in_block (frame));
|
||||
(*sal) = find_pc_line (get_frame_pc (frame), notcurrent);
|
||||
if (!get_frame_pc_if_available (frame, &pc))
|
||||
{
|
||||
init_sal (sal);
|
||||
return;
|
||||
}
|
||||
|
||||
notcurrent = (pc != get_frame_address_in_block (frame));
|
||||
(*sal) = find_pc_line (pc, notcurrent);
|
||||
}
|
||||
|
||||
/* Per "frame.h", return the ``address'' of the frame. Code should
|
||||
|
|
22
gdb/frame.h
22
gdb/frame.h
|
@ -284,6 +284,12 @@ extern struct frame_info *frame_find_by_id (struct frame_id id);
|
|||
This replaced: frame->pc; */
|
||||
extern CORE_ADDR get_frame_pc (struct frame_info *);
|
||||
|
||||
/* Same as get_frame_pc, but return a boolean indication of whether
|
||||
the PC is actually available, instead of throwing an error. */
|
||||
|
||||
extern int get_frame_pc_if_available (struct frame_info *frame,
|
||||
CORE_ADDR *pc);
|
||||
|
||||
/* An address (not necessarily aligned to an instruction boundary)
|
||||
that falls within THIS frame's code block.
|
||||
|
||||
|
@ -299,6 +305,15 @@ extern CORE_ADDR get_frame_pc (struct frame_info *);
|
|||
|
||||
extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame);
|
||||
|
||||
/* Same as get_frame_address_in_block, but returns a boolean
|
||||
indication of whether the frame address is determinable (when the
|
||||
PC is unavailable, it will not be), instead of possibly throwing an
|
||||
error trying to read an unavailable PC. */
|
||||
|
||||
extern int
|
||||
get_frame_address_in_block_if_available (struct frame_info *this_frame,
|
||||
CORE_ADDR *pc);
|
||||
|
||||
/* The frame's inner-most bound. AKA the stack-pointer. Confusingly
|
||||
known as top-of-stack. */
|
||||
|
||||
|
@ -309,6 +324,13 @@ extern CORE_ADDR get_frame_sp (struct frame_info *);
|
|||
that function isn't known. */
|
||||
extern CORE_ADDR get_frame_func (struct frame_info *fi);
|
||||
|
||||
/* Same as get_frame_func, but returns a boolean indication of whether
|
||||
the frame function is determinable (when the PC is unavailable, it
|
||||
will not be), instead of possibly throwing an error trying to read
|
||||
an unavailable PC. */
|
||||
|
||||
extern int get_frame_func_if_available (struct frame_info *fi, CORE_ADDR *);
|
||||
|
||||
/* Closely related to the resume address, various symbol table
|
||||
attributes that are determined by the PC. Note that for a normal
|
||||
frame, the PC refers to the resume address after the return, and
|
||||
|
|
|
@ -102,12 +102,13 @@ default_macro_scope (void)
|
|||
struct symtab_and_line sal;
|
||||
struct macro_scope *ms;
|
||||
struct frame_info *frame;
|
||||
CORE_ADDR pc;
|
||||
|
||||
/* If there's a selected frame, use its PC. */
|
||||
frame = deprecated_safe_get_selected_frame ();
|
||||
if (frame)
|
||||
sal = find_pc_line (get_frame_pc (frame), 0);
|
||||
|
||||
if (frame && get_frame_pc_if_available (frame, &pc))
|
||||
sal = find_pc_line (pc, 0);
|
||||
|
||||
/* Fall back to the current listing position. */
|
||||
else
|
||||
{
|
||||
|
|
57
gdb/stack.c
57
gdb/stack.c
|
@ -654,8 +654,14 @@ print_frame_info (struct frame_info *frame, int print_level,
|
|||
}
|
||||
|
||||
if (print_what != LOCATION)
|
||||
set_default_breakpoint (1, sal.pspace,
|
||||
get_frame_pc (frame), sal.symtab, sal.line);
|
||||
{
|
||||
CORE_ADDR pc;
|
||||
|
||||
if (get_frame_pc_if_available (frame, &pc))
|
||||
set_default_breakpoint (1, sal.pspace, pc, sal.symtab, sal.line);
|
||||
else
|
||||
set_default_breakpoint (0, 0, 0, 0, 0);
|
||||
}
|
||||
|
||||
annotate_frame_end ();
|
||||
|
||||
|
@ -740,9 +746,13 @@ find_frame_funname (struct frame_info *frame, char **funname,
|
|||
}
|
||||
else
|
||||
{
|
||||
struct minimal_symbol *msymbol =
|
||||
lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
|
||||
struct minimal_symbol *msymbol;
|
||||
CORE_ADDR pc;
|
||||
|
||||
if (!get_frame_address_in_block_if_available (frame, &pc))
|
||||
return;
|
||||
|
||||
msymbol = lookup_minimal_symbol_by_pc (pc);
|
||||
if (msymbol != NULL)
|
||||
{
|
||||
*funname = SYMBOL_PRINT_NAME (msymbol);
|
||||
|
@ -763,6 +773,10 @@ print_frame (struct frame_info *frame, int print_level,
|
|||
struct cleanup *old_chain, *list_chain;
|
||||
struct value_print_options opts;
|
||||
struct symbol *func;
|
||||
CORE_ADDR pc = 0;
|
||||
int pc_p;
|
||||
|
||||
pc_p = get_frame_pc_if_available (frame, &pc);
|
||||
|
||||
stb = ui_out_stream_new (uiout);
|
||||
old_chain = make_cleanup_ui_out_stream_delete (stb);
|
||||
|
@ -770,7 +784,7 @@ print_frame (struct frame_info *frame, int print_level,
|
|||
find_frame_funname (frame, &funname, &funlang, &func);
|
||||
|
||||
annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
|
||||
gdbarch, get_frame_pc (frame));
|
||||
gdbarch, pc);
|
||||
|
||||
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
|
||||
|
||||
|
@ -782,11 +796,15 @@ print_frame (struct frame_info *frame, int print_level,
|
|||
}
|
||||
get_user_print_options (&opts);
|
||||
if (opts.addressprint)
|
||||
if (frame_show_address (frame, sal) || !sal.symtab
|
||||
if (!sal.symtab
|
||||
|| frame_show_address (frame, sal)
|
||||
|| print_what == LOC_AND_ADDRESS)
|
||||
{
|
||||
annotate_frame_address ();
|
||||
ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame));
|
||||
if (pc_p)
|
||||
ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
|
||||
else
|
||||
ui_out_field_string (uiout, "addr", "<unavailable>");
|
||||
annotate_frame_address_end ();
|
||||
ui_out_text (uiout, " in ");
|
||||
}
|
||||
|
@ -836,7 +854,7 @@ print_frame (struct frame_info *frame, int print_level,
|
|||
annotate_frame_source_end ();
|
||||
}
|
||||
|
||||
if (!funname || (!sal.symtab || !sal.symtab->filename))
|
||||
if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename)))
|
||||
{
|
||||
#ifdef PC_SOLIB
|
||||
char *lib = PC_SOLIB (get_frame_pc (frame));
|
||||
|
@ -2142,6 +2160,10 @@ get_frame_language (void)
|
|||
|
||||
if (frame)
|
||||
{
|
||||
volatile struct gdb_exception ex;
|
||||
CORE_ADDR pc = 0;
|
||||
struct symtab *s;
|
||||
|
||||
/* We determine the current frame language by looking up its
|
||||
associated symtab. To retrieve this symtab, we use the frame
|
||||
PC. However we cannot use the frame PC as is, because it
|
||||
|
@ -2150,11 +2172,22 @@ get_frame_language (void)
|
|||
we rely on get_frame_address_in_block(), it provides us with
|
||||
a PC that is guaranteed to be inside the frame's code
|
||||
block. */
|
||||
CORE_ADDR pc = get_frame_address_in_block (frame);
|
||||
struct symtab *s = find_pc_symtab (pc);
|
||||
|
||||
if (s)
|
||||
return s->language;
|
||||
TRY_CATCH (ex, RETURN_MASK_ERROR)
|
||||
{
|
||||
pc = get_frame_address_in_block (frame);
|
||||
}
|
||||
if (ex.reason < 0)
|
||||
{
|
||||
if (ex.error != NOT_AVAILABLE_ERROR)
|
||||
throw_exception (ex);
|
||||
}
|
||||
else
|
||||
{
|
||||
s = find_pc_symtab (pc);
|
||||
if (s != NULL)
|
||||
return s->language;
|
||||
}
|
||||
}
|
||||
|
||||
return language_unknown;
|
||||
|
|
|
@ -1,3 +1,33 @@
|
|||
2011-03-18 Pedro Alves <pedro@codesourcery.com>
|
||||
|
||||
* frame.c (frame_unwind_pc): Rename to ...
|
||||
(frame_unwind_pc_if_available): ... this. New `pc' output
|
||||
parameter. Change return type to int. Gracefully handle
|
||||
gdbarch_unwind_pc throwing NOT_AVAILABLE_ERROR. Return 0 if that
|
||||
happened, or 1 otherwise.
|
||||
(frame_unwind_pc): Reimplement on top of
|
||||
frame_unwind_pc_if_available.
|
||||
(get_frame_func): Rename to ...
|
||||
(get_frame_func_if_available): New `pc' output parameter. Change
|
||||
return type to int. Gracefully handle the PC not being available.
|
||||
(get_frame_func): Reimplement on top of
|
||||
get_frame_func_if_available.
|
||||
(select_frame): Handle the PC being unavailable.
|
||||
(get_prev_frame): Handle the PC being unavailable.
|
||||
(get_frame_pc_if_available): New.
|
||||
(get_frame_address_in_block_if_available): New.
|
||||
(find_frame_sal): Handle the frame PC not being available.
|
||||
* frame.h (get_frame_pc_if_available): Declare.
|
||||
(get_frame_address_in_block_if_available): Declare.
|
||||
(get_frame_func_if_available): Declare.
|
||||
* stack.c (print_frame_info): Handle the PC being unavailable.
|
||||
(find_frame_funname): Ditto.
|
||||
(print_frame): Handle the PC being unavailable.
|
||||
(get_frame_language): Ditto.
|
||||
* blockframe.c (get_frame_block): Ditto.
|
||||
* macroscope.c (default_macro_scope): Ditto.
|
||||
* tui/tui-stack.c (tui_show_frame_info): Ditto.
|
||||
|
||||
2011-03-18 Pedro Alves <pedro@codesourcery.com>
|
||||
|
||||
* dwarf2loc.c (dwarf2_evaluate_loc_desc): Catch
|
||||
|
|
|
@ -342,16 +342,23 @@ tui_show_frame_info (struct frame_info *fi)
|
|||
struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
|
||||
int source_already_displayed;
|
||||
struct symtab_and_line sal;
|
||||
CORE_ADDR pc;
|
||||
|
||||
find_frame_sal (fi, &sal);
|
||||
|
||||
source_already_displayed = sal.symtab != 0
|
||||
&& tui_source_is_displayed (sal.symtab->filename);
|
||||
tui_set_locator_info (get_frame_arch (fi),
|
||||
sal.symtab == 0 ? "??" : sal.symtab->filename,
|
||||
tui_get_function_from_frame (fi),
|
||||
sal.line,
|
||||
get_frame_pc (fi));
|
||||
|
||||
if (get_frame_pc_if_available (fi, &pc))
|
||||
tui_set_locator_info (get_frame_arch (fi),
|
||||
sal.symtab == 0 ? "??" : sal.symtab->filename,
|
||||
tui_get_function_from_frame (fi),
|
||||
sal.line,
|
||||
pc);
|
||||
else
|
||||
tui_set_locator_info (get_frame_arch (fi),
|
||||
"??", _("<unavailable>"), sal.line, 0);
|
||||
|
||||
tui_show_locator_content ();
|
||||
start_line = 0;
|
||||
for (i = 0; i < (tui_source_windows ())->count; i++)
|
||||
|
|
Loading…
Reference in New Issue