/* Disassembly display.
- Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
- Free Software Foundation, Inc.
+ Copyright (C) 1998-2020 Free Software Foundation, Inc.
Contributed by Hewlett-Packard Company.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "arch-utils.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
#include "value.h"
#include "source.h"
#include "disasm.h"
-#include "gdb_string.h"
#include "tui/tui.h"
+#include "tui/tui-command.h"
#include "tui/tui-data.h"
#include "tui/tui-win.h"
#include "tui/tui-layout.h"
#include "tui/tui-winsource.h"
#include "tui/tui-stack.h"
#include "tui/tui-file.h"
+#include "tui/tui-disasm.h"
+#include "tui/tui-source.h"
+#include "progspace.h"
+#include "objfiles.h"
+#include "cli/cli-style.h"
#include "gdb_curses.h"
-struct tui_asm_line
+struct tui_asm_line
{
CORE_ADDR addr;
- char *addr_string;
- char *insn;
+ std::string addr_string;
+ size_t addr_size;
+ std::string insn;
};
-/* Function to set the disassembly window's content.
- Disassemble count lines starting at pc.
- Return address of the count'th instruction after pc. */
+/* Helper function to find the number of characters in STR, skipping
+ any ANSI escape sequences. */
+static size_t
+len_without_escapes (const std::string &str)
+{
+ size_t len = 0;
+ const char *ptr = str.c_str ();
+ char c;
+
+ while ((c = *ptr++) != '\0')
+ {
+ if (c == '\033')
+ {
+ ui_file_style style;
+ size_t n_read;
+ if (style.parse (ptr, &n_read))
+ ptr += n_read;
+ else
+ {
+ /* Shouldn't happen, but just skip the ESC if it somehow
+ does. */
+ ++ptr;
+ }
+ }
+ else
+ ++len;
+ }
+ return len;
+}
+
+/* Function to disassemble up to COUNT instructions starting from address
+ PC into the ASM_LINES vector (which will be emptied of any previous
+ contents). Return the address of the COUNT'th instruction after pc.
+ When ADDR_SIZE is non-null then place the maximum size of an address and
+ label into the value pointed to by ADDR_SIZE, and set the addr_size
+ field on each item in ASM_LINES, otherwise the addr_size fields within
+ ASM_LINES are undefined.
+
+ It is worth noting that ASM_LINES might not have COUNT entries when this
+ function returns. If the disassembly is truncated for some other
+ reason, for example, we hit invalid memory, then ASM_LINES can have
+ fewer entries than requested. */
static CORE_ADDR
-tui_disassemble (struct tui_asm_line *asm_lines, CORE_ADDR pc, int count)
+tui_disassemble (struct gdbarch *gdbarch,
+ std::vector<tui_asm_line> &asm_lines,
+ CORE_ADDR pc, int count,
+ size_t *addr_size = nullptr)
{
- struct ui_file *gdb_dis_out;
+ bool term_out = source_styling && gdb_stdout->can_emit_style_escape ();
+ string_file gdb_dis_out (term_out);
- /* Now init the ui_file structure. */
- gdb_dis_out = tui_sfileopen (256);
+ /* Must start with an empty list. */
+ asm_lines.clear ();
/* Now construct each line. */
- for (; count > 0; count--, asm_lines++)
+ for (int i = 0; i < count; ++i)
{
- if (asm_lines->addr_string)
- xfree (asm_lines->addr_string);
- if (asm_lines->insn)
- xfree (asm_lines->insn);
-
- print_address (pc, gdb_dis_out);
- asm_lines->addr = pc;
- asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+ tui_asm_line tal;
+ CORE_ADDR orig_pc = pc;
- ui_file_rewind (gdb_dis_out);
+ try
+ {
+ pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
+ }
+ catch (const gdb_exception_error &except)
+ {
+ /* If PC points to an invalid address then we'll catch a
+ MEMORY_ERROR here, this should stop the disassembly, but
+ otherwise is fine. */
+ if (except.error != MEMORY_ERROR)
+ throw;
+ return pc;
+ }
- pc = pc + gdb_print_insn (pc, gdb_dis_out, NULL);
+ /* Capture the disassembled instruction. */
+ tal.insn = std::move (gdb_dis_out.string ());
+ gdb_dis_out.clear ();
- asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+ /* And capture the address the instruction is at. */
+ tal.addr = orig_pc;
+ print_address (gdbarch, orig_pc, &gdb_dis_out);
+ tal.addr_string = std::move (gdb_dis_out.string ());
+ gdb_dis_out.clear ();
- /* Reset the buffer to empty. */
- ui_file_rewind (gdb_dis_out);
+ if (addr_size != nullptr)
+ {
+ size_t new_size;
+
+ if (term_out)
+ new_size = len_without_escapes (tal.addr_string);
+ else
+ new_size = tal.addr_string.size ();
+ *addr_size = std::max (*addr_size, new_size);
+ tal.addr_size = new_size;
+ }
+
+ asm_lines.push_back (std::move (tal));
}
- ui_file_delete (gdb_dis_out);
return pc;
}
+/* Look backward from ADDR for an address from which we can start
+ disassembling, this needs to be something we can be reasonably
+ confident will fall on an instruction boundary. We use msymbol
+ addresses, or the start of a section. */
+
+static CORE_ADDR
+tui_find_backward_disassembly_start_address (CORE_ADDR addr)
+{
+ struct bound_minimal_symbol msym, msym_prev;
+
+ msym = lookup_minimal_symbol_by_pc_section (addr - 1, nullptr,
+ lookup_msym_prefer::TEXT,
+ &msym_prev);
+ if (msym.minsym != nullptr)
+ return BMSYMBOL_VALUE_ADDRESS (msym);
+ else if (msym_prev.minsym != nullptr)
+ return BMSYMBOL_VALUE_ADDRESS (msym_prev);
+
+ /* Find the section that ADDR is in, and look for the start of the
+ section. */
+ struct obj_section *section = find_pc_section (addr);
+ if (section != NULL)
+ return obj_section_addr (section);
+
+ return addr;
+}
+
/* Find the disassembly address that corresponds to FROM lines above
or below the PC. Variable sized instructions are taken into
account by the algorithm. */
static CORE_ADDR
-tui_find_disassembly_address (CORE_ADDR pc, int from)
+tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
{
CORE_ADDR new_low;
int max_lines;
- int i;
- struct tui_asm_line *asm_lines;
max_lines = (from > 0) ? from : - from;
- if (max_lines <= 1)
- return pc;
+ if (max_lines == 0)
+ return pc;
- asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * max_lines);
- memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
+ std::vector<tui_asm_line> asm_lines;
new_low = pc;
if (from > 0)
{
- tui_disassemble (asm_lines, pc, max_lines);
- new_low = asm_lines[max_lines - 1].addr;
+ /* Always disassemble 1 extra instruction here, then if the last
+ instruction fails to disassemble we will take the address of the
+ previous instruction that did disassemble as the result. */
+ tui_disassemble (gdbarch, asm_lines, pc, max_lines + 1);
+ new_low = asm_lines.back ().addr;
}
else
{
+ /* In order to disassemble backwards we need to find a suitable
+ address to start disassembling from and then work forward until we
+ re-find the address we're currently at. We can then figure out
+ which address will be at the top of the TUI window after our
+ backward scroll. During our backward disassemble we need to be
+ able to distinguish between the case where the last address we
+ _can_ disassemble is ADDR, and the case where the disassembly
+ just happens to stop at ADDR, for this reason we increase
+ MAX_LINES by one. */
+ max_lines++;
+
+ /* When we disassemble a series of instructions this will hold the
+ address of the last instruction disassembled. */
CORE_ADDR last_addr;
- int pos;
- struct minimal_symbol *msymbol;
-
- /* Find backward an address which is a symbol and for which
- disassembling from that address will fill completely the
- window. */
- pos = max_lines - 1;
- do {
- new_low -= 1 * max_lines;
- msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
-
- if (msymbol)
- new_low = SYMBOL_VALUE_ADDRESS (msymbol);
- else
- new_low += 1 * max_lines;
-
- tui_disassemble (asm_lines, new_low, max_lines);
- last_addr = asm_lines[pos].addr;
- } while (last_addr > pc && msymbol);
+
+ /* And this will hold the address of the next instruction that would
+ have been disassembled. */
+ CORE_ADDR next_addr;
+
+ /* As we search backward if we find an address that looks like a
+ promising starting point then we record it in this structure. If
+ the next address we try is not a suitable starting point then we
+ will fall back to the address held here. */
+ gdb::optional<CORE_ADDR> possible_new_low;
+
+ /* The previous value of NEW_LOW so we know if the new value is
+ different or not. */
+ CORE_ADDR prev_low;
+
+ do
+ {
+ /* Find an address from which we can start disassembling. */
+ prev_low = new_low;
+ new_low = tui_find_backward_disassembly_start_address (new_low);
+
+ /* Disassemble forward. */
+ next_addr = tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
+ last_addr = asm_lines.back ().addr;
+
+ /* If disassembling from the current value of NEW_LOW reached PC
+ (or went past it) then this would do as a starting point if we
+ can't find anything better, so remember it. */
+ if (last_addr >= pc && new_low != prev_low
+ && asm_lines.size () >= max_lines)
+ possible_new_low.emplace (new_low);
+
+ /* Continue searching until we find a value of NEW_LOW from which
+ disassembling MAX_LINES instructions doesn't reach PC. We
+ know this means we can find the required number of previous
+ instructions then. */
+ }
+ while ((last_addr > pc
+ || (last_addr == pc && asm_lines.size () < max_lines))
+ && new_low != prev_low);
+
+ /* If we failed to disassemble the required number of lines then the
+ following walk forward is not going to work, it assumes that
+ ASM_LINES contains exactly MAX_LINES entries. Instead we should
+ consider falling back to a previous possible start address in
+ POSSIBLE_NEW_LOW. */
+ if (asm_lines.size () < max_lines)
+ {
+ if (!possible_new_low.has_value ())
+ return pc;
+
+ /* Take the best possible match we have. */
+ new_low = *possible_new_low;
+ next_addr = tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
+ last_addr = asm_lines.back ().addr;
+ gdb_assert (asm_lines.size () >= max_lines);
+ }
/* Scan forward disassembling one instruction at a time until
the last visible instruction of the window matches the pc.
We keep the disassembled instructions in the 'lines' window
and shift it downward (increasing its addresses). */
+ int pos = max_lines - 1;
if (last_addr < pc)
do
{
- CORE_ADDR next_addr;
-
pos++;
if (pos >= max_lines)
pos = 0;
- next_addr = tui_disassemble (&asm_lines[pos], last_addr, 1);
-
+ CORE_ADDR old_next_addr = next_addr;
+ std::vector<tui_asm_line> single_asm_line;
+ next_addr = tui_disassemble (gdbarch, single_asm_line,
+ next_addr, 1);
/* If there are some problems while disassembling exit. */
- if (next_addr <= last_addr)
- break;
- last_addr = next_addr;
- } while (last_addr <= pc);
+ if (next_addr <= old_next_addr)
+ return pc;
+ gdb_assert (single_asm_line.size () == 1);
+ asm_lines[pos] = single_asm_line[0];
+ } while (next_addr <= pc);
pos++;
if (pos >= max_lines)
pos = 0;
new_low = asm_lines[pos].addr;
- }
- for (i = 0; i < max_lines; i++)
- {
- xfree (asm_lines[i].addr_string);
- xfree (asm_lines[i].insn);
+
+ /* When scrolling backward the addresses should move backward, or at
+ the very least stay the same if we are at the first address that
+ can be disassembled. */
+ gdb_assert (new_low <= pc);
}
return new_low;
}
/* Function to set the disassembly window's content. */
-enum tui_status
-tui_set_disassem_content (CORE_ADDR pc)
+bool
+tui_disasm_window::set_contents (struct gdbarch *arch,
+ const struct symtab_and_line &sal)
{
- enum tui_status ret = TUI_FAILURE;
int i;
- int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
- int line_width, max_lines;
+ int offset = horizontal_offset;
+ int max_lines, line_width;
CORE_ADDR cur_pc;
- struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
- int tab_len = tui_default_tab_len ();
- struct tui_asm_line *asm_lines;
+ struct tui_locator_window *locator = tui_locator_win_info_ptr ();
+ int tab_len = tui_tab_width;
int insn_pos;
- int addr_size, max_size;
- char *line;
-
- if (pc == 0)
- return TUI_FAILURE;
- ret = tui_alloc_source_buffer (TUI_DISASM_WIN);
- if (ret != TUI_SUCCESS)
- return ret;
+ CORE_ADDR pc = sal.pc;
+ if (pc == 0)
+ return false;
- TUI_DISASM_WIN->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS;
- TUI_DISASM_WIN->detail.source_info.start_line_or_addr.u.addr = pc;
- cur_pc = (CORE_ADDR)
- (((struct tui_win_element *) locator->content[0])->which_element.locator.addr);
+ gdbarch = arch;
+ start_line_or_addr.loa = LOA_ADDRESS;
+ start_line_or_addr.u.addr = pc;
+ cur_pc = locator->addr;
- max_lines = TUI_DISASM_WIN->generic.height - 2; /* Account for
- hilite. */
+ /* Window size, excluding highlight box. */
+ max_lines = height - 2;
+ line_width = width - TUI_EXECINFO_SIZE - 2;
/* Get temporary table that will hold all strings (addr & insn). */
- asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * max_lines);
- memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
-
- line_width = TUI_DISASM_WIN->generic.width - 1;
-
- tui_disassemble (asm_lines, pc, max_lines);
+ std::vector<tui_asm_line> asm_lines;
+ size_t addr_size = 0;
+ tui_disassemble (gdbarch, asm_lines, pc, max_lines, &addr_size);
- /* See what is the maximum length of an address and of a line. */
- addr_size = 0;
- max_size = 0;
- for (i = 0; i < max_lines; i++)
- {
- size_t len = strlen (asm_lines[i].addr_string);
- if (len > addr_size)
- addr_size = len;
-
- len = strlen (asm_lines[i].insn) + tab_len;
- if (len > max_size)
- max_size = len;
- }
- max_size += addr_size + tab_len;
-
- /* Allocate memory to create each line. */
- line = (char*) alloca (max_size);
+ /* Align instructions to the same column. */
insn_pos = (1 + (addr_size / tab_len)) * tab_len;
/* Now construct each line. */
+ content.resize (max_lines);
for (i = 0; i < max_lines; i++)
{
- struct tui_win_element *element;
- struct tui_source_element *src;
- int cur_len;
-
- element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i];
- src = &element->which_element.source;
- strcpy (line, asm_lines[i].addr_string);
- cur_len = strlen (line);
-
- /* Add spaces to make the instructions start on the same
- column. */
- while (cur_len < insn_pos)
- {
- strcat (line, " ");
- cur_len++;
- }
-
- strcat (line, asm_lines[i].insn);
-
- /* Now copy the line taking the offset into account. */
- if (strlen (line) > offset)
- strcpy (src->line, &line[offset]);
- else
- src->line[0] = '\0';
+ tui_source_element *src = &content[i];
- src->line_or_addr.loa = LOA_ADDRESS;
- src->line_or_addr.u.addr = asm_lines[i].addr;
- src->is_exec_point = asm_lines[i].addr == cur_pc;
+ std::string line;
+ CORE_ADDR addr;
+
+ if (i < asm_lines.size ())
+ {
+ line
+ = (asm_lines[i].addr_string
+ + n_spaces (insn_pos - asm_lines[i].addr_size)
+ + asm_lines[i].insn);
+ addr = asm_lines[i].addr;
+ }
+ else
+ {
+ line = "";
+ addr = 0;
+ }
- /* See whether there is a breakpoint installed. */
- src->has_break = (!src->is_exec_point
- && breakpoint_here_p (pc) != no_breakpoint_here);
+ const char *ptr = line.c_str ();
+ src->line = tui_copy_source_line (&ptr, -1, offset, line_width, 0);
- xfree (asm_lines[i].addr_string);
- xfree (asm_lines[i].insn);
+ src->line_or_addr.loa = LOA_ADDRESS;
+ src->line_or_addr.u.addr = addr;
+ src->is_exec_point = (addr == cur_pc && line.size () > 0);
}
- TUI_DISASM_WIN->generic.content_size = i;
- return TUI_SUCCESS;
+ return true;
}
-/* Function to display the disassembly window with disassembled code. */
void
-tui_show_disassem (CORE_ADDR start_addr)
+tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
{
- struct symtab *s = find_pc_symtab (start_addr);
- struct tui_win_info *win_with_focus = tui_win_with_focus ();
- struct tui_line_or_address val;
-
- val.loa = LOA_ADDRESS;
- val.u.addr = start_addr;
- tui_add_win_to_layout (DISASSEM_WIN);
- tui_update_source_window (TUI_DISASM_WIN, s, val, FALSE);
- /*
- ** If the focus was in the src win, put it in the asm win, if
- ** the source view isn't split.
- */
- if (tui_current_layout () != SRC_DISASSEM_COMMAND && win_with_focus == TUI_SRC_WIN)
- tui_set_win_focus_to (TUI_DISASM_WIN);
-
- return;
-}
+ struct tui_locator_window *locator;
+ struct gdbarch *gdbarch = get_current_arch ();
+ CORE_ADDR addr = 0;
+ locator = tui_locator_win_info_ptr ();
-/* Function to display the disassembly window. */
-void
-tui_show_disassem_and_update_source (CORE_ADDR start_addr)
-{
- struct symtab_and_line sal;
-
- tui_show_disassem (start_addr);
- if (tui_current_layout () == SRC_DISASSEM_COMMAND)
+ if (locator->addr == 0)
{
- struct tui_line_or_address val;
-
- /*
- ** Update what is in the source window if it is displayed too,
- ** note that it follows what is in the disassembly window and
- ** visa-versa.
- */
- sal = find_pc_line (start_addr, 0);
- val.loa = LOA_LINE;
- val.u.line_no = sal.line;
- tui_update_source_window (TUI_SRC_WIN, sal.symtab, val, TRUE);
- if (sal.symtab)
+ if (have_full_symbols () || have_partial_symbols ())
{
- set_current_source_symtab_and_line (&sal);
- tui_update_locator_filename (sal.symtab->filename);
- }
- else
- tui_update_locator_filename ("?");
- }
-
- return;
-}
+ set_default_source_symtab_and_line ();
+ struct symtab_and_line sal = get_current_source_symtab_and_line ();
-CORE_ADDR
-tui_get_begin_asm_address (void)
-{
- struct tui_gen_win_info *locator;
- struct tui_locator_element *element;
- CORE_ADDR addr;
-
- locator = tui_locator_win_info_ptr ();
- element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
+ if (sal.symtab != nullptr)
+ find_line_pc (sal.symtab, sal.line, &addr);
+ }
- if (element->addr == 0)
- {
- struct minimal_symbol *main_symbol;
-
- /* Find address of the start of program.
- Note: this should be language specific. */
- main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
- if (main_symbol == 0)
- main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
- if (main_symbol == 0)
- main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
- if (main_symbol)
- addr = SYMBOL_VALUE_ADDRESS (main_symbol);
- else
- addr = 0;
+ if (addr == 0)
+ {
+ struct bound_minimal_symbol main_symbol
+ = lookup_minimal_symbol (main_name (), nullptr, nullptr);
+ if (main_symbol.minsym != nullptr)
+ addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
+ }
}
else /* The target is executing. */
- addr = element->addr;
+ {
+ gdbarch = locator->gdbarch;
+ addr = locator->addr;
+ }
- return addr;
+ *gdbarch_p = gdbarch;
+ *addr_p = addr;
}
/* Determine what the low address will be to display in the TUI's
disassembly window. This may or may not be the same as the low
address input. */
CORE_ADDR
-tui_get_low_disassembly_address (CORE_ADDR low, CORE_ADDR pc)
+tui_get_low_disassembly_address (struct gdbarch *gdbarch,
+ CORE_ADDR low, CORE_ADDR pc)
{
int pos;
/* Determine where to start the disassembly so that the pc is about
in the middle of the viewport. */
- pos = tui_default_win_viewport_height (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
- pc = tui_find_disassembly_address (pc, -pos);
+ if (tui_win_list[DISASSEM_WIN] != NULL)
+ pos = tui_win_list[DISASSEM_WIN]->height;
+ else if (TUI_CMD_WIN == NULL)
+ pos = tui_term_height () / 2 - 2;
+ else
+ pos = tui_term_height () - TUI_CMD_WIN->height - 2;
+ pos = (pos - 2) / 2;
+
+ pc = tui_find_disassembly_address (gdbarch, pc, -pos);
if (pc < low)
pc = low;
/* Scroll the disassembly forward or backward vertically. */
void
-tui_vertical_disassem_scroll (enum tui_scroll_direction scroll_direction,
- int num_to_scroll)
+tui_disasm_window::do_scroll_vertical (int num_to_scroll)
{
- if (TUI_DISASM_WIN->generic.content != NULL)
+ if (!content.empty ())
{
CORE_ADDR pc;
- tui_win_content content;
- struct symtab *s;
- struct tui_line_or_address val;
- int max_lines, dir;
- struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
- content = (tui_win_content) TUI_DISASM_WIN->generic.content;
- if (cursal.symtab == (struct symtab *) NULL)
- s = find_pc_symtab (get_frame_pc (get_selected_frame (NULL)));
- else
- s = cursal.symtab;
- /* Account for hilite. */
- max_lines = TUI_DISASM_WIN->generic.height - 2;
- pc = content[0]->which_element.source.line_or_addr.u.addr;
- dir = (scroll_direction == FORWARD_SCROLL) ? max_lines : - max_lines;
+ pc = start_line_or_addr.u.addr;
- val.loa = LOA_ADDRESS;
- val.u.addr = tui_find_disassembly_address (pc, dir);
- tui_update_source_window_as_is (TUI_DISASM_WIN, s, val, FALSE);
+ symtab_and_line sal {};
+ sal.pspace = current_program_space;
+ sal.pc = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
+ update_source_window_as_is (gdbarch, sal);
+ }
+}
+
+bool
+tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
+{
+ return (content[line_no].line_or_addr.loa == LOA_ADDRESS
+ && content[line_no].line_or_addr.u.addr == loc->address);
+}
+
+bool
+tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
+{
+ if (content.size () < SCROLL_THRESHOLD)
+ return false;
+
+ for (size_t i = 0; i < content.size () - SCROLL_THRESHOLD; ++i)
+ {
+ if (content[i].line_or_addr.loa == LOA_ADDRESS
+ && content[i].line_or_addr.u.addr == addr)
+ return true;
+ }
+
+ return false;
+}
+
+void
+tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
+{
+ CORE_ADDR low;
+
+ struct gdbarch *frame_arch = get_frame_arch (fi);
+
+ if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0)
+ {
+ /* There is no symbol available for current PC. There is no
+ safe way how to "disassemble backwards". */
+ low = sal.pc;
+ }
+ else
+ low = tui_get_low_disassembly_address (frame_arch, low, sal.pc);
+
+ struct tui_line_or_address a;
+
+ a.loa = LOA_ADDRESS;
+ a.u.addr = low;
+ if (!addr_is_displayed (sal.pc))
+ {
+ sal.pc = low;
+ update_source_window (frame_arch, sal);
+ }
+ else
+ {
+ a.u.addr = sal.pc;
+ set_is_exec_point_at (a);
}
}
projects / deliverable / binutils-gdb.git / blobdiff