/* 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-data.h"
#include "tui/tui-win.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"
-#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;
+ char *addr_string;
+ char *insn;
};
/* 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, struct tui_asm_line *asm_lines,
+ CORE_ADDR pc, int count)
{
- struct ui_file *gdb_dis_out;
-
- /* now init the ui_file structure */
- gdb_dis_out = tui_sfileopen (256);
+ string_file gdb_dis_out;
- /* Now construct each line */
- for (; count > 0; count--, lines++)
+ /* Now construct each line. */
+ for (; count > 0; count--, asm_lines++)
{
- if (lines->addr_string)
- xfree (lines->addr_string);
- if (lines->insn)
- xfree (lines->insn);
+ xfree (asm_lines->addr_string);
+ xfree (asm_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->addr = pc;
+ asm_lines->addr_string = xstrdup (gdb_dis_out.c_str ());
- ui_file_rewind (gdb_dis_out);
+ gdb_dis_out.clear ();
- pc = pc + gdb_print_insn (pc, gdb_dis_out);
+ pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
- lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
+ asm_lines->insn = xstrdup (gdb_dis_out.c_str ());
- /* reset the buffer to empty */
- ui_file_rewind (gdb_dis_out);
+ /* 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;
+ CORE_ADDR new_low;
+ int max_lines;
int i;
- struct tui_asm_line* lines;
+ struct tui_asm_line *asm_lines;
- maxLines = (from > 0) ? from : - from;
- if (maxLines <= 1)
+ 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);
+ asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
+ memset (asm_lines, 0, sizeof (struct tui_asm_line) * 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, 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, 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[pos],
+ last_addr, 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++)
+ for (i = 0; i < max_lines; i++)
{
- xfree (lines[i].addr_string);
- xfree (lines[i].insn);
+ xfree (asm_lines[i].addr_string);
+ xfree (asm_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)
+tui_set_disassem_content (tui_source_window_base *win_info,
+ struct gdbarch *gdbarch, CORE_ADDR pc)
{
- TuiStatus ret = TUI_FAILURE;
- register int i;
- register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
- register int lineWidth, maxLines;
+ int i;
+ int offset = win_info->horizontal_offset;
+ int max_lines, line_width;
CORE_ADDR cur_pc;
- TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
- int tab_len = tuiDefaultTabLen ();
- struct tui_asm_line* lines;
+ struct tui_locator_window *locator = tui_locator_win_info_ptr ();
+ int tab_len = tui_tab_width;
+ struct tui_asm_line *asm_lines;
int insn_pos;
- int addr_size, max_size;
- char* line;
+ int addr_size, insn_size;
+ char *line;
if (pc == 0)
return TUI_FAILURE;
- ret = tuiAllocSourceBuffer (disassemWin);
- if (ret != TUI_SUCCESS)
- return ret;
+ win_info->gdbarch = gdbarch;
+ win_info->start_line_or_addr.loa = LOA_ADDRESS;
+ win_info->start_line_or_addr.u.addr = pc;
+ cur_pc = locator->addr;
- disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
- cur_pc = (CORE_ADDR)
- (((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
-
- maxLines = disassemWin->generic.height - 2; /* account for hilite */
+ /* Window size, excluding highlight box. */
+ max_lines = win_info->height - 2;
+ line_width = win_info->width - 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;
+ asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
+ memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
- tui_disassemble (lines, pc, maxLines);
+ tui_disassemble (gdbarch, asm_lines, pc, max_lines);
- /* See what is the maximum length of an address and of a line. */
+ /* Determine maximum address- and instruction lengths. */
addr_size = 0;
- max_size = 0;
- for (i = 0; i < maxLines; i++)
+ insn_size = 0;
+ for (i = 0; i < max_lines; i++)
{
- size_t len = strlen (lines[i].addr_string);
+ size_t len = strlen (asm_lines[i].addr_string);
+
if (len > addr_size)
addr_size = len;
- len = strlen (lines[i].insn) + tab_len;
- if (len > max_size)
- max_size = len;
+ len = strlen (asm_lines[i].insn);
+ if (len > insn_size)
+ insn_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++)
- {
- 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);
+ /* Allocate memory to create each line. */
+ line = (char*) alloca (insn_pos + insn_size + 1);
- /* Add spaces to make the instructions start on the same column */
- while (curLen < insn_pos)
- {
- strcat (line, " ");
- curLen++;
- }
+ /* Now construct each line. */
+ win_info->content.resize (max_lines);
+ for (i = 0; i < max_lines; i++)
+ {
+ int cur_len;
- strcat (line, lines[i].insn);
+ tui_source_element *src = &win_info->content[i];
+ strcpy (line, asm_lines[i].addr_string);
+ cur_len = strlen (line);
+ memset (line + cur_len, ' ', insn_pos - cur_len);
+ strcpy (line + insn_pos, asm_lines[i].insn);
- /* Now copy the line taking the offset into account */
+ /* Now copy the line taking the offset into account. */
+ xfree (src->line);
if (strlen (line) > offset)
- strcpy (src->line, &line[offset]);
+ src->line = xstrndup (&line[offset], line_width);
else
- src->line[0] = '\0';
+ src->line = xstrdup ("");
- src->lineOrAddr.addr = lines[i].addr;
- src->isExecPoint = lines[i].addr == cur_pc;
+ 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;
- /* See whether there is a breakpoint installed. */
- src->hasBreak = (!src->isExecPoint
- && breakpoint_here_p (pc) != no_breakpoint_here);
-
- xfree (lines[i].addr_string);
- xfree (lines[i].insn);
+ xfree (asm_lines[i].addr_string);
+ xfree (asm_lines[i].insn);
}
- disassemWin->generic.contentSize = i;
return TUI_SUCCESS;
}
-/* Function to display the disassembly window with disassembled code. */
+/* Function to display the disassembly window with disassembled code. */
void
-tui_show_disassem (CORE_ADDR startAddr)
+tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR start_addr)
{
- struct symtab *s = find_pc_symtab (startAddr);
- TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
- TuiLineOrAddress val;
-
- val.addr = startAddr;
- tui_add_win_to_layout (DISASSEM_WIN);
- tuiUpdateSourceWindow (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 (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
- tuiSetWinFocusTo (disassemWin);
-
- return;
+ struct symtab *s = find_pc_line_symtab (start_addr);
+ struct tui_win_info *win_with_focus = tui_win_with_focus ();
+ struct tui_line_or_address val;
+
+ gdb_assert (TUI_DISASM_WIN != nullptr && TUI_DISASM_WIN->is_visible ());
+
+ val.loa = LOA_ADDRESS;
+ val.u.addr = start_addr;
+ TUI_DISASM_WIN->update_source_window (gdbarch, s, val);
+
+ /* 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);
}
-/* Function to display the disassembly window. */
+/* Function to display the disassembly window. */
void
-tui_show_disassem_and_update_source (CORE_ADDR startAddr)
+tui_show_disassem_and_update_source (struct gdbarch *gdbarch,
+ CORE_ADDR start_addr)
{
struct symtab_and_line sal;
- tui_show_disassem (startAddr);
- if (currentLayout () == SRC_DISASSEM_COMMAND)
+ tui_show_disassem (gdbarch, start_addr);
+ if (tui_current_layout () == SRC_DISASSEM_COMMAND)
{
- 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;
- tuiUpdateSourceWindow (srcWin, sal.symtab, val, TRUE);
+ 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_SRC_WIN->update_source_window (gdbarch, sal.symtab, val);
if (sal.symtab)
{
- set_current_source_symtab_and_line (&sal);
- tui_update_locator_filename (sal.symtab->filename);
+ set_current_source_symtab_and_line (sal);
+ tui_update_locator_fullname (symtab_to_fullname (sal.symtab));
}
else
- tui_update_locator_filename ("?");
+ tui_update_locator_fullname ("?");
}
-
- return;
}
-CORE_ADDR
-tui_get_begin_asm_address (void)
+void
+tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
{
- TuiGenWinInfoPtr locator;
- TuiLocatorElementPtr element;
+ struct tui_locator_window *locator;
+ struct gdbarch *gdbarch = get_current_arch ();
CORE_ADDR addr;
- locator = locatorWinInfoPtr ();
- element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
+ locator = tui_locator_win_info_ptr ();
- if (element->addr == 0)
+ if (locator->addr == 0)
{
- struct minimal_symbol *main_symbol;
+ struct bound_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)
+ if (main_symbol.minsym == 0)
main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
- if (main_symbol == 0)
+ if (main_symbol.minsym == 0)
main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
- if (main_symbol)
- addr = SYMBOL_VALUE_ADDRESS (main_symbol);
+ if (main_symbol.minsym)
+ addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
else
addr = 0;
}
- else /* the target is executing */
- addr = element->addr;
+ else /* The target is executing. */
+ {
+ 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. */
+ 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. */
+ /* 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);
+ 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));
+ struct tui_line_or_address val;
+
+ pc = content[0].line_or_addr.u.addr;
+ if (num_to_scroll >= 0)
+ num_to_scroll++;
else
- s = cursal.symtab;
+ --num_to_scroll;
- /* account for hilite */
- maxLines = disassemWin->generic.height - 2;
- pc = content[0]->whichElement.source.lineOrAddr.addr;
- dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
+ val.loa = LOA_ADDRESS;
+ val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
+ update_source_window_as_is (gdbarch, NULL, val);
+ }
+}
+
+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;
+
+ 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;
+}
- val.addr = tui_find_disassembly_address (pc, dir);
- tuiUpdateSourceWindowAsIs (disassemWin, s, val, FALSE);
+void
+tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal,
+ int line_no, CORE_ADDR addr)
+{
+ CORE_ADDR low;
+
+ if (find_pc_partial_function (get_frame_pc (fi),
+ 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));
+
+ struct tui_line_or_address a;
+
+ a.loa = LOA_ADDRESS;
+ a.u.addr = low;
+ if (!addr_is_displayed (addr))
+ update_source_window (get_frame_arch (fi), sal.symtab, a);
+ else
+ {
+ a.u.addr = addr;
+ set_is_exec_point_at (a);
}
}
projects / deliverable / binutils-gdb.git / blobdiff