X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftui%2Ftui-disasm.c;h=91c9845f5dc5663f9cbcd89b7ed2577ce38492c8;hb=5d0510553eb447bf6861f4641b5ae3aaf9503a13;hp=00f8325cb3c3c542059f8ce6e72eb13a697881d1;hpb=ecd75fc8eed3bde86036141228074a20e55dcfc9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tui/tui-disasm.c b/gdb/tui/tui-disasm.c index 00f8325cb3..91c9845f5d 100644 --- a/gdb/tui/tui-disasm.c +++ b/gdb/tui/tui-disasm.c @@ -1,6 +1,6 @@ /* Disassembly display. - Copyright (C) 1998-2014 Free Software Foundation, Inc. + Copyright (C) 1998-2019 Free Software Foundation, Inc. Contributed by Hewlett-Packard Company. @@ -27,8 +27,8 @@ #include "value.h" #include "source.h" #include "disasm.h" -#include #include "tui/tui.h" +#include "tui/tui-command.h" #include "tui/tui-data.h" #include "tui/tui-win.h" #include "tui/tui-layout.h" @@ -36,51 +36,45 @@ #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 "gdb_curses.h" struct tui_asm_line { CORE_ADDR addr; - char *addr_string; - char *insn; + std::string addr_string; + 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. */ static CORE_ADDR -tui_disassemble (struct gdbarch *gdbarch, struct tui_asm_line *asm_lines, - CORE_ADDR pc, int count) +tui_disassemble (struct gdbarch *gdbarch, + std::vector &asm_lines, + CORE_ADDR pc, int pos, 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--, 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 (gdbarch, pc, gdb_dis_out); - asm_lines->addr = pc; - asm_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 (gdbarch, pc, gdb_dis_out, NULL); + pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL); - asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out)); + asm_lines[pos + i].insn = std::move (gdb_dis_out.string ()); /* Reset the buffer to empty. */ - ui_file_rewind (gdb_dis_out); + gdb_dis_out.clear (); } - ui_file_delete (gdb_dis_out); return pc; } @@ -92,28 +86,24 @@ 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; + 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 asm_lines (max_lines); new_low = pc; if (from > 0) { - tui_disassemble (gdbarch, asm_lines, pc, max_lines); + 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 @@ -121,16 +111,16 @@ tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from) pos = max_lines - 1; do { new_low -= 1 * max_lines; - msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0).minsym; + msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0); - if (msymbol) - new_low = SYMBOL_VALUE_ADDRESS (msymbol); + if (msymbol.minsym) + new_low = BMSYMBOL_VALUE_ADDRESS (msymbol); else new_low += 1 * max_lines; - tui_disassemble (gdbarch, asm_lines, new_low, max_lines); + tui_disassemble (gdbarch, asm_lines, new_low, 0, max_lines); last_addr = asm_lines[pos].addr; - } while (last_addr > pc && msymbol); + } 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. @@ -145,8 +135,8 @@ tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from) if (pos >= max_lines) pos = 0; - next_addr = tui_disassemble (gdbarch, &asm_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) @@ -158,115 +148,83 @@ tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from) 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); - } return new_low; } /* Function to set the disassembly window's content. */ enum tui_status -tui_set_disassem_content (struct gdbarch *gdbarch, CORE_ADDR pc) +tui_disasm_window::set_contents (struct gdbarch *arch, + struct symtab *s, + struct tui_line_or_address line_or_addr) { - enum tui_status ret = TUI_FAILURE; int i; - int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset; - int 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; + int addr_size, insn_size; + gdb_assert (line_or_addr.loa == LOA_ADDRESS); + CORE_ADDR pc = line_or_addr.u.addr; if (pc == 0) return TUI_FAILURE; - ret = tui_alloc_source_buffer (TUI_DISASM_WIN); - if (ret != TUI_SUCCESS) - return ret; + gdbarch = arch; + start_line_or_addr.loa = LOA_ADDRESS; + start_line_or_addr.u.addr = pc; + cur_pc = locator->addr; - TUI_DISASM_WIN->detail.source_info.gdbarch = gdbarch; - 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); - - 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); + std::vector asm_lines (max_lines); - tui_disassemble (gdbarch, asm_lines, pc, max_lines); + tui_disassemble (gdbarch, asm_lines, pc, 0, 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; + insn_size = 0; for (i = 0; i < max_lines; i++) { - size_t len = strlen (asm_lines[i].addr_string); + size_t len = asm_lines[i].addr_string.size (); if (len > addr_size) addr_size = len; - len = strlen (asm_lines[i].insn) + tab_len; - if (len > max_size) - max_size = len; + len = asm_lines[i].insn.size (); + 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. */ + 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++; - } + tui_source_element *src = &content[i]; - strcat (line, asm_lines[i].insn); + std::string line + = (asm_lines[i].addr_string + + n_spaces (insn_pos + - asm_lines[i].addr_string.size ()) + + asm_lines[i].insn); /* Now copy the line taking the offset into account. */ - if (strlen (line) > offset) - strcpy (src->line, &line[offset]); + if (line.size () > offset) + src->line = line.substr (offset, line_width); else - src->line[0] = '\0'; + src->line.clear (); 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->generic.content_size = i; return TUI_SUCCESS; } @@ -275,22 +233,21 @@ tui_set_disassem_content (struct gdbarch *gdbarch, CORE_ADDR pc) void tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR start_addr) { - struct symtab *s = find_pc_symtab (start_addr); + 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_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; } @@ -312,51 +269,46 @@ tui_show_disassem_and_update_source (struct gdbarch *gdbarch, 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); + set_current_source_symtab_and_line (sal); tui_update_locator_fullname (symtab_to_fullname (sal.symtab)); } else tui_update_locator_fullname ("?"); } - - return; } void tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p) { - struct tui_gen_win_info *locator; - struct tui_locator_element *element; + struct tui_locator_window *locator; struct gdbarch *gdbarch = get_current_arch (); CORE_ADDR addr; locator = tui_locator_win_info_ptr (); - element = &((struct tui_win_element *) - locator->content[0])->which_element.locator; - 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. */ { - gdbarch = element->gdbarch; - addr = element->addr; + gdbarch = locator->gdbarch; + addr = locator->addr; } *gdbarch_p = gdbarch; @@ -374,7 +326,14 @@ tui_get_low_disassembly_address (struct gdbarch *gdbarch, /* 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; + 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) @@ -384,27 +343,76 @@ tui_get_low_disassembly_address (struct gdbarch *gdbarch, /* 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 ()) { - struct gdbarch *gdbarch = TUI_DISASM_WIN->detail.source_info.gdbarch; CORE_ADDR pc; - tui_win_content content; struct tui_line_or_address val; - int dir; - content = (tui_win_content) TUI_DISASM_WIN->generic.content; - - pc = content[0]->which_element.source.line_or_addr.u.addr; - num_to_scroll++; - dir = (scroll_direction == FORWARD_SCROLL) - ? num_to_scroll : -num_to_scroll; + pc = content[0].line_or_addr.u.addr; + if (num_to_scroll >= 0) + num_to_scroll++; + else + --num_to_scroll; val.loa = LOA_ADDRESS; - val.u.addr = tui_find_disassembly_address (gdbarch, pc, dir); - tui_update_source_window_as_is (TUI_DISASM_WIN, gdbarch, - NULL, val, FALSE); + 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; +} + +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); } }