#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"
/* Now construct each line. */
for (; count > 0; count--, asm_lines++)
{
- if (asm_lines->addr_string)
- xfree (asm_lines->addr_string);
- if (asm_lines->insn)
- xfree (asm_lines->insn);
+ xfree (asm_lines->addr_string);
+ xfree (asm_lines->insn);
print_address (gdbarch, pc, &gdb_dis_out);
asm_lines->addr = pc;
/* Function to set the disassembly window's content. */
enum tui_status
-tui_set_disassem_content (struct gdbarch *gdbarch, CORE_ADDR pc)
+tui_set_disassem_content (tui_source_window_base *win_info,
+ struct gdbarch *gdbarch, CORE_ADDR pc)
{
int i;
- int offset = TUI_DISASM_WIN->horizontal_offset;
+ int offset = win_info->horizontal_offset;
int max_lines, line_width;
CORE_ADDR cur_pc;
struct tui_locator_window *locator = tui_locator_win_info_ptr ();
if (pc == 0)
return TUI_FAILURE;
- tui_alloc_source_buffer (TUI_DISASM_WIN);
-
- tui_source_window_base *base = TUI_DISASM_WIN;
- base->gdbarch = gdbarch;
- base->start_line_or_addr.loa = LOA_ADDRESS;
- base->start_line_or_addr.u.addr = pc;
+ 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;
/* Window size, excluding highlight box. */
- max_lines = TUI_DISASM_WIN->height - 2;
- line_width = TUI_DISASM_WIN->width - 2;
+ max_lines = win_info->height - 2;
+ line_width = win_info->width - 2;
/* Get temporary table that will hold all strings (addr & insn). */
asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
line = (char*) alloca (insn_pos + insn_size + 1);
/* Now construct each line. */
+ win_info->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 = TUI_DISASM_WIN->content[i];
- src = &element->which_element.source;
+ 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. */
+ xfree (src->line);
if (strlen (line) > offset)
- {
- strncpy (src->line, &line[offset], line_width);
- src->line[line_width] = '\0';
- }
+ src->line = xstrndup (&line[offset], line_width);
else
- src->line[0] = '\0';
+ src->line = xstrdup ("");
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->has_break = (!src->is_exec_point
- && breakpoint_here_p (current_program_space->aspace,
- pc)
- != no_breakpoint_here);
-
xfree (asm_lines[i].addr_string);
xfree (asm_lines[i].insn);
}
- TUI_DISASM_WIN->content_size = i;
return TUI_SUCCESS;
}
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_add_win_to_layout (DISASSEM_WIN);
- tui_update_source_window (TUI_DISASM_WIN, gdbarch, s, val, FALSE);
+ 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);
-
- return;
}
sal = find_pc_line (start_addr, 0);
val.loa = LOA_LINE;
val.u.line_no = sal.line;
- tui_update_source_window (TUI_SRC_WIN, gdbarch, sal.symtab, val, TRUE);
+ TUI_SRC_WIN->update_source_window (gdbarch, sal.symtab, val);
if (sal.symtab)
{
set_current_source_symtab_and_line (sal);
else
tui_update_locator_fullname ("?");
}
-
- return;
}
void
void
tui_disasm_window::do_scroll_vertical (int num_to_scroll)
{
- if (content != NULL)
+ if (!content.empty ())
{
CORE_ADDR pc;
struct tui_line_or_address val;
- pc = content[0]->which_element.source.line_or_addr.u.addr;
+ pc = content[0].line_or_addr.u.addr;
if (num_to_scroll >= 0)
num_to_scroll++;
else
val.loa = LOA_ADDRESS;
val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
- tui_update_source_window_as_is (this, gdbarch,
- NULL, val, FALSE);
+ 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;
+}
+
+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