static void
tui_refresh_frame_and_register_information (int registers_too_p)
{
struct frame_info *fi;
CORE_ADDR pc;
struct cleanup *old_chain;
int frame_info_changed_p;
if (!has_stack_frames ())
return;
old_chain = make_cleanup_restore_target_terminal ();
target_terminal_ours_for_output ();
fi = get_selected_frame (NULL);
/* Ensure that symbols for this frame are read in. Also, determine
the source language of this frame, and switch to it if
desired. */
if (get_frame_pc_if_available (fi, &pc))
{
struct symtab *s;
s = find_pc_line_symtab (pc);
/* elz: This if here fixes the problem with the pc not being
displayed in the tui asm layout, with no debug symbols. The
value of s would be 0 here, and select_source_symtab would
abort the command by calling the 'error' function. */
if (s)
select_source_symtab (s);
}
/* Display the frame position (even if there is no symbols or the PC
is not known). */
frame_info_changed_p = tui_show_frame_info (fi);
/* Refresh the register window if it's visible. */
if (tui_is_window_visible (DATA_WIN)
&& (frame_info_changed_p || registers_too_p))
{
tui_refreshing_registers = 1;
tui_check_data_values (fi);
tui_refreshing_registers = 0;
}
do_cleanups (old_chain);
}
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
haiku_init_debug_create_inferior(int pid)
{
extern int stop_after_trap;
// fix inferior_ptid -- fork_inferior() sets the process ID only
inferior_ptid = ptid_build (pid, 0, pid);
// team ID == team main thread ID under Haiku
haiku_init_child_debugging(pid, false);
// eat the initial `debugged' event caused by wait_for_inferior()
// TODO: Maybe we should just dequeue the event and continue the thread instead
// of using gdb's mechanism, since I don't know what undesired side-effects
// they may have.
clear_proceed_status ();
init_wait_for_inferior ();
if (STARTUP_WITH_SHELL)
inferior_ignoring_startup_exec_events = 2;
else
inferior_ignoring_startup_exec_events = 1;
inferior_ignoring_leading_exec_events = 0;
while (true) {
thread_debug_info *thread;
stop_soon = STOP_QUIETLY;
wait_for_inferior();
if (stop_signal == TARGET_SIGNAL_TRAP) {
thread = haiku_find_thread(&sTeamDebugInfo, pid);
if (thread && thread->stopped
&& thread->last_event->message
== B_DEBUGGER_MESSAGE_IMAGE_CREATED
&& thread->last_event->data.image_created.info.type
== B_APP_IMAGE
&& thread->reprocess_event == 0
&& inferior_ignoring_startup_exec_events <= 0) {
// This is the trap for the last (second, if started via shell)
// `load app image' event. Be done.
break;
}
}
resume(0, stop_signal);
}
stop_soon = NO_STOP_QUIETLY;
// load shared library symbols
target_terminal_ours_for_output ();
SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
target_terminal_inferior ();
// startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
//while (1) {
// stop_after_trap = 1;
// wait_for_inferior ();
// if (debugThread && stop_signal != TARGET_SIGNAL_TRAP)
// resume (0, stop_signal);
// else
// break;
//}
//stop_after_trap = 0;
// while (1) {
// thread_debug_info *thread;
//
// stop_after_trap = 1;
// wait_for_inferior ();
//// TODO: Catch deadly events, so that we won't block here.
//
// thread = haiku_find_thread(&sTeamDebugInfo, pid);
//TRACE(("haiku_init_debug_create_inferior(): wait_for_inferior() returned: "
//"thread: %p (%ld)\n", thread, (thread ? thread->thread : -1)));
// if (thread && thread->stopped
// && thread->last_event->message
// == B_DEBUGGER_MESSAGE_IMAGE_CREATED
// && thread->last_event->data.image_created.info.type
// == B_APP_IMAGE) {
//TRACE(("haiku_init_debug_create_inferior(): Got an `app image created' "
//"message\n"));
// break;
// }
//
// resume (0, stop_signal);
// }
}
int
find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
CORE_ADDR *address, CORE_ADDR *endaddr)
{
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;
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 (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
{
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;
}
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. */
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 = 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;
}
