/* Disassembly display.
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
- Foundation, Inc.
+ Copyright (C) 1998-2019 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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, 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 "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"
-#ifdef HAVE_NCURSES_H
-#include <ncurses.h>
-#else
-#ifdef HAVE_CURSES_H
-#include <curses.h>
-#endif
-#endif
+#include "gdb_curses.h"
struct tui_asm_line
{
CORE_ADDR addr;
- char* addr_string;
- char* insn;
+ std::string addr_string;
+ size_t addr_size;
+ std::string insn;
};
+/* 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 set the disassembly window's content.
Disassemble count lines starting at pc.
Return address of the count'th instruction after pc. */
static CORE_ADDR
-tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
+tui_disassemble (struct gdbarch *gdbarch,
+ std::vector<tui_asm_line> &asm_lines,
+ CORE_ADDR pc, int pos, 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);
-
- /* Now construct each line */
- for (; count > 0; count--, lines++)
+ /* Now construct each line. */
+ for (int i = 0; i < count; ++i)
{
- if (lines->addr_string)
- xfree (lines->addr_string);
- if (lines->insn)
- xfree (lines->insn);
-
- print_address (pc, gdb_dis_out);
- lines->addr = pc;
- lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+ print_address (gdbarch, pc, &gdb_dis_out);
+ asm_lines[pos + i].addr = pc;
+ asm_lines[pos + i].addr_string = std::move (gdb_dis_out.string ());
- ui_file_rewind (gdb_dis_out);
+ gdb_dis_out.clear ();
- pc = pc + gdb_print_insn (pc, gdb_dis_out);
+ if (addr_size != nullptr)
+ {
+ size_t new_size;
+
+ if (term_out)
+ new_size = len_without_escapes (asm_lines[pos + i].addr_string);
+ else
+ new_size = asm_lines[pos + i].addr_string.size ();
+ *addr_size = std::max (*addr_size, new_size);
+ asm_lines[pos + i].addr_size = new_size;
+ }
- lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+ pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
- /* reset the buffer to empty */
- ui_file_rewind (gdb_dis_out);
+ asm_lines[pos + i].insn = std::move (gdb_dis_out.string ());
+
+ /* Reset the buffer to empty. */
+ gdb_dis_out.clear ();
}
- ui_file_delete (gdb_dis_out);
return pc;
}
-/* Find the disassembly address that corresponds to FROM lines
- above or below the PC. Variable sized instructions are taken
- into account by the algorithm. */
+/* 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)
{
- register CORE_ADDR newLow;
- int maxLines;
- int i;
- struct tui_asm_line* lines;
+ CORE_ADDR new_low;
+ int max_lines;
- maxLines = (from > 0) ? from : - from;
- if (maxLines <= 1)
- return pc;
+ max_lines = (from > 0) ? from : - from;
+ if (max_lines <= 1)
+ return pc;
- lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * maxLines);
- memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
+ std::vector<tui_asm_line> asm_lines (max_lines);
- newLow = pc;
+ new_low = pc;
if (from > 0)
{
- tui_disassemble (lines, pc, maxLines);
- newLow = lines[maxLines - 1].addr;
+ tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines);
+ new_low = asm_lines[max_lines - 1].addr;
}
else
{
CORE_ADDR last_addr;
int pos;
- struct minimal_symbol* msymbol;
+ struct bound_minimal_symbol msymbol;
- /* Find backward an address which is a symbol
- and for which disassembling from that address will fill
- completely the window. */
- pos = maxLines - 1;
+ /* 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 {
- newLow -= 1 * maxLines;
- msymbol = lookup_minimal_symbol_by_pc_section (newLow, 0);
+ new_low -= 1 * max_lines;
+ msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
- if (msymbol)
- newLow = SYMBOL_VALUE_ADDRESS (msymbol);
+ if (msymbol.minsym)
+ new_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
else
- newLow += 1 * maxLines;
+ new_low += 1 * max_lines;
- tui_disassemble (lines, newLow, maxLines);
- last_addr = lines[pos].addr;
- } while (last_addr > pc && msymbol);
+ tui_disassemble (gdbarch, asm_lines, new_low, 0, max_lines);
+ last_addr = asm_lines[pos].addr;
+ } while (last_addr > pc && msymbol.minsym);
- /* 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). */
+ /* 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). */
if (last_addr < pc)
do
{
CORE_ADDR next_addr;
pos++;
- if (pos >= maxLines)
+ if (pos >= max_lines)
pos = 0;
- next_addr = tui_disassemble (&lines[pos], last_addr, 1);
+ next_addr = tui_disassemble (gdbarch, asm_lines,
+ last_addr, pos, 1);
/* If there are some problems while disassembling exit. */
if (next_addr <= last_addr)
last_addr = next_addr;
} while (last_addr <= pc);
pos++;
- if (pos >= maxLines)
+ if (pos >= max_lines)
pos = 0;
- newLow = lines[pos].addr;
+ new_low = asm_lines[pos].addr;
}
- for (i = 0; i < maxLines; i++)
- {
- xfree (lines[i].addr_string);
- xfree (lines[i].insn);
- }
- return newLow;
+ 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)
{
- TuiStatus ret = TUI_FAILURE;
- register int i;
- register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
- register int lineWidth, maxLines;
+ int i;
+ int offset = horizontal_offset;
+ int max_lines, line_width;
CORE_ADDR cur_pc;
- TuiGenWinInfoPtr locator = tui_locator_win_info_ptr ();
- int tab_len = tui_default_tab_len ();
- struct tui_asm_line* 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 (disassemWin);
- if (ret != TUI_SUCCESS)
- return ret;
+ CORE_ADDR pc = sal.pc;
+ if (pc == 0)
+ return false;
- disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
- cur_pc = (CORE_ADDR)
- (((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
+ gdbarch = arch;
+ start_line_or_addr.loa = LOA_ADDRESS;
+ start_line_or_addr.u.addr = pc;
+ cur_pc = locator->addr;
- maxLines = disassemWin->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). */
- lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * maxLines);
- memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
-
- lineWidth = disassemWin->generic.width - 1;
-
- tui_disassemble (lines, pc, maxLines);
-
- /* See what is the maximum length of an address and of a line. */
- addr_size = 0;
- max_size = 0;
- for (i = 0; i < maxLines; i++)
- {
- size_t len = strlen (lines[i].addr_string);
- if (len > addr_size)
- addr_size = len;
+ std::vector<tui_asm_line> asm_lines (max_lines);
+ size_t addr_size = 0;
+ tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines, &addr_size);
- len = strlen (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 */
- for (i = 0; i < maxLines; i++)
+ /* Now construct each line. */
+ content.resize (max_lines);
+ for (i = 0; i < max_lines; i++)
{
- TuiWinElementPtr element;
- TuiSourceElement* src;
- int curLen;
-
- element = (TuiWinElementPtr) disassemWin->generic.content[i];
- src = &element->whichElement.source;
- strcpy (line, lines[i].addr_string);
- curLen = strlen (line);
-
- /* Add spaces to make the instructions start on the same column */
- while (curLen < insn_pos)
- {
- strcat (line, " ");
- curLen++;
- }
-
- strcat (line, 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->lineOrAddr.addr = lines[i].addr;
- src->isExecPoint = lines[i].addr == cur_pc;
+ std::string line
+ = (asm_lines[i].addr_string
+ + n_spaces (insn_pos - asm_lines[i].addr_size)
+ + asm_lines[i].insn);
- /* See whether there is a breakpoint installed. */
- src->hasBreak = (!src->isExecPoint
- && 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 (lines[i].addr_string);
- xfree (lines[i].insn);
+ 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;
}
- disassemWin->generic.contentSize = i;
- return TUI_SUCCESS;
+ return true;
}
-/* Function to display the disassembly window with disassembled code. */
void
-tui_show_disassem (CORE_ADDR startAddr)
+tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
{
- struct symtab *s = find_pc_symtab (startAddr);
- TuiWinInfoPtr winWithFocus = tui_win_with_focus ();
- TuiLineOrAddress val;
-
- val.addr = startAddr;
- tui_add_win_to_layout (DISASSEM_WIN);
- tui_update_source_window (disassemWin, 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 && winWithFocus == srcWin)
- tui_set_win_focus_to (disassemWin);
-
- return;
-}
-
+ struct tui_locator_window *locator;
+ struct gdbarch *gdbarch = get_current_arch ();
+ CORE_ADDR addr = 0;
-/* Function to display the disassembly window. */
-void
-tui_show_disassem_and_update_source (CORE_ADDR startAddr)
-{
- struct symtab_and_line sal;
+ locator = tui_locator_win_info_ptr ();
- tui_show_disassem (startAddr);
- if (tui_current_layout () == SRC_DISASSEM_COMMAND)
+ if (locator->addr == 0)
{
- TuiLineOrAddress 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 (startAddr, 0);
- val.lineNo = sal.line;
- tui_update_source_window (srcWin, 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)
-{
- TuiGenWinInfoPtr locator;
- TuiLocatorElementPtr element;
- CORE_ADDR addr;
-
- locator = tui_locator_win_info_ptr ();
- element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
+ if (sal.symtab != nullptr)
+ find_line_pc (sal.symtab, sal.line, &addr);
+ }
- if (element->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. */
{
- 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;
+ gdbarch = locator->gdbarch;
+ addr = locator->addr;
}
- else /* the target is executing */
- addr = element->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. */
+ disassembly window. This may or may not be the same as the low
+ address input. */
CORE_ADDR
-tuiGetLowDisassemblyAddress (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);
+ /* Determine where to start the disassembly so that the pc is about
+ in the middle of the viewport. */
+ 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 scrollDirection,
- int numToScroll)
+tui_disasm_window::do_scroll_vertical (int num_to_scroll)
{
- if (disassemWin->generic.content != (OpaquePtr) NULL)
+ if (!content.empty ())
{
CORE_ADDR pc;
- TuiWinContent content;
- struct symtab *s;
- TuiLineOrAddress val;
- int maxLines, dir;
- struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
- content = (TuiWinContent) disassemWin->generic.content;
- if (cursal.symtab == (struct symtab *) NULL)
- s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
+
+ pc = start_line_or_addr.u.addr;
+ if (num_to_scroll >= 0)
+ num_to_scroll++;
else
- s = cursal.symtab;
+ --num_to_scroll;
+
+ 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);
+ }
+}
- /* account for hilite */
- maxLines = disassemWin->generic.height - 2;
- pc = content[0]->whichElement.source.lineOrAddr.addr;
- dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
+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
+{
+ bool is_displayed = false;
+ int threshold = SCROLL_THRESHOLD;
- val.addr = tui_find_disassembly_address (pc, dir);
- tui_update_source_window_as_is (disassemWin, s, val, FALSE);
+ int i = 0;
+ while (i < content.size () - threshold && !is_displayed)
+ {
+ is_displayed
+ = (content[i].line_or_addr.loa == LOA_ADDRESS
+ && content[i].line_or_addr.u.addr == addr);
+ i++;
+ }
+
+ return is_displayed;
+}
+
+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