X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Ftui%2Ftui-disasm.c;h=726b7c27d607e5b827faed82ed2c302e527545ab;hb=733d0a679536628eb1be4b4b8aa6384de24ff1f1;hp=70ee90724f6bc7d39cfaef5c864f77a896ac3cdb;hpb=8d7493201cf01c9836403695f67f7e157341bfd5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/tui/tui-disasm.c b/gdb/tui/tui-disasm.c index 70ee90724f..726b7c27d6 100644 --- a/gdb/tui/tui-disasm.c +++ b/gdb/tui/tui-disasm.c @@ -1,6 +1,6 @@ /* Disassembly display. - Copyright (C) 1998-2015 Free Software Foundation, Inc. + Copyright (C) 1998-2020 Free Software Foundation, Inc. Contributed by Hewlett-Packard Company. @@ -28,6 +28,7 @@ #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" @@ -35,55 +36,149 @@ #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 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 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 (gdbarch, 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; + + 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; + } - ui_file_rewind (gdb_dis_out); + /* Capture the disassembled instruction. */ + tal.insn = std::move (gdb_dis_out.string ()); + gdb_dis_out.clear (); - pc = pc + gdb_print_insn (gdbarch, pc, gdb_dis_out, NULL); + /* 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 (); - asm_lines->insn = xstrdup (tui_file_get_strbuf (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; + } - /* Reset the buffer to empty. */ - ui_file_rewind (gdb_dis_out); + 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. */ @@ -92,267 +187,231 @@ 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 = XALLOCAVEC (struct tui_asm_line, max_lines); - memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines); + std::vector asm_lines; new_low = pc; if (from > 0) { - tui_disassemble (gdbarch, 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 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 = max_lines - 1; - do { - new_low -= 1 * max_lines; - msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0); - - if (msymbol.minsym) - new_low = BMSYMBOL_VALUE_ADDRESS (msymbol); - else - new_low += 1 * max_lines; - - tui_disassemble (gdbarch, asm_lines, new_low, max_lines); - last_addr = asm_lines[pos].addr; - } while (last_addr > pc && msymbol.minsym); + + /* 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 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 (gdbarch, &asm_lines[pos], - last_addr, 1); - + CORE_ADDR old_next_addr = next_addr; + std::vector 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 (struct gdbarch *gdbarch, 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 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.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 = 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 = XALLOCAVEC (struct tui_asm_line, max_lines); - memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines); - - tui_disassemble (gdbarch, asm_lines, pc, max_lines); + std::vector 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 = 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'; - - 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; -} + tui_source_element *src = &content[i]; + std::string line; + CORE_ADDR addr; -/* Function to display the disassembly window with disassembled code. */ -void -tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR 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; - - 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); - - /* 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; -} - - -/* Function to display the disassembly window. */ -void -tui_show_disassem_and_update_source (struct gdbarch *gdbarch, - CORE_ADDR start_addr) -{ - struct symtab_and_line sal; - - tui_show_disassem (gdbarch, start_addr); - if (tui_current_layout () == SRC_DISASSEM_COMMAND) - { - 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, gdbarch, sal.symtab, val, TRUE); - if (sal.symtab) + if (i < asm_lines.size ()) { - set_current_source_symtab_and_line (&sal); - tui_update_locator_fullname (symtab_to_fullname (sal.symtab)); + 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 - tui_update_locator_fullname ("?"); - } + { + line = ""; + addr = 0; + } + + const char *ptr = line.c_str (); + src->line = tui_copy_source_line (&ptr, -1, offset, line_width, 0); - return; + src->line_or_addr.loa = LOA_ADDRESS; + src->line_or_addr.u.addr = addr; + src->is_exec_point = (addr == cur_pc && line.size () > 0); + } + return true; } + 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; + CORE_ADDR addr = 0; locator = tui_locator_win_info_ptr (); - element = &locator->content[0]->which_element.locator; - if (element->addr == 0) + if (locator->addr == 0) { - 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.minsym == 0) - main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL); - if (main_symbol.minsym == 0) - main_symbol = lookup_minimal_symbol ("_start", NULL, NULL); - if (main_symbol.minsym) - addr = BMSYMBOL_VALUE_ADDRESS (main_symbol); - else - addr = 0; + if (have_full_symbols () || have_partial_symbols ()) + { + set_default_source_symtab_and_line (); + struct symtab_and_line sal = get_current_source_symtab_and_line (); + + if (sal.symtab != nullptr) + find_line_pc (sal.symtab, sal.line, &addr); + } + + 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. */ { - gdbarch = element->gdbarch; - addr = element->addr; + gdbarch = locator->gdbarch; + addr = locator->addr; } *gdbarch_p = gdbarch; @@ -370,7 +429,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) @@ -380,27 +446,72 @@ 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 = start_line_or_addr.u.addr; - 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; + 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; - 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); + 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); } }