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); }
struct macro_scope * 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 && get_frame_pc_if_available (frame, &pc)) sal = find_pc_line (pc, 0); /* Fall back to the current listing position. */ else { /* Don't call select_source_symtab here. That can raise an error if symbols aren't loaded, but GDB calls the expression evaluator in all sorts of contexts. For example, commands like `set width' call the expression evaluator to evaluate their numeric arguments. If the current language is C, then that may call this function to choose a scope for macro expansion. If you don't have any symbol files loaded, then get_current_or_default would raise an error. But `set width' shouldn't raise an error just because it can't decide which scope to macro-expand its argument in. */ struct symtab_and_line cursal = get_current_source_symtab_and_line (); sal.symtab = cursal.symtab; sal.line = cursal.line; } ms = sal_macro_scope (sal); if (! ms) ms = user_macro_scope (); return ms; }
int tui_show_frame_info (struct frame_info *fi) { struct tui_win_info *win_info; int locator_changed_p; int i; if (fi) { int start_line, i; CORE_ADDR low; struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); int source_already_displayed; CORE_ADDR pc; symtab_and_line sal = find_frame_sal (fi); source_already_displayed = sal.symtab != 0 && tui_source_is_displayed (symtab_to_fullname (sal.symtab)); if (get_frame_pc_if_available (fi, &pc)) locator_changed_p = tui_set_locator_info (get_frame_arch (fi), (sal.symtab == 0 ? "??" : symtab_to_fullname (sal.symtab)), tui_get_function_from_frame (fi), sal.line, pc); else locator_changed_p = tui_set_locator_info (get_frame_arch (fi), "??", _("<unavailable>"), sal.line, 0); /* If the locator information has not changed, then frame information has not changed. If frame information has not changed, then the windows' contents will not change. So don't bother refreshing the windows. */ if (!locator_changed_p) return 0; tui_show_locator_content (); start_line = 0; for (i = 0; i < (tui_source_windows ())->count; i++) { union tui_which_element *item; win_info = (tui_source_windows ())->list[i]; item = &locator->content[0]->which_element; if (win_info == TUI_SRC_WIN) { start_line = (item->locator.line_no - (win_info->generic.viewport_height / 2)) + 1; if (start_line <= 0) start_line = 1; } else { if (find_pc_partial_function (get_frame_pc (fi), (const char **) NULL, &low, NULL) == 0) { /* There is no symbol available for current PC. There is no safe way how to "disassemble backwards". */ low = get_frame_pc (fi); } else low = tui_get_low_disassembly_address (get_frame_arch (fi), low, get_frame_pc (fi)); } if (win_info == TUI_SRC_WIN) { struct tui_line_or_address l; l.loa = LOA_LINE; l.u.line_no = start_line; if (!(source_already_displayed && tui_line_is_displayed (item->locator.line_no, win_info, TRUE))) tui_update_source_window (win_info, get_frame_arch (fi), sal.symtab, l, TRUE); else { l.u.line_no = item->locator.line_no; tui_set_is_exec_point_at (l, win_info); } } else { if (win_info == TUI_DISASM_WIN) { struct tui_line_or_address a; a.loa = LOA_ADDRESS; a.u.addr = low; if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE)) tui_update_source_window (win_info, get_frame_arch (fi), sal.symtab, a, TRUE); else { a.u.addr = item->locator.addr; tui_set_is_exec_point_at (a, win_info); } } } tui_update_exec_info (win_info); } return 1; } else { locator_changed_p = tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0); if (!locator_changed_p) return 0; tui_show_locator_content (); for (i = 0; i < (tui_source_windows ())->count; i++) { win_info = (tui_source_windows ())->list[i]; tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT); tui_update_exec_info (win_info); } return 1; } }