gdb/tui/tui-disasm.c

   1 /* Disassembly display.
   2
   3    Copyright (C) 1998-2021 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "symtab.h"
  25 #include "breakpoint.h"
  26 #include "frame.h"
  27 #include "value.h"
  28 #include "source.h"
  29 #include "disasm.h"
  30 #include "tui/tui.h"
  31 #include "tui/tui-command.h"
  32 #include "tui/tui-data.h"
  33 #include "tui/tui-win.h"
  34 #include "tui/tui-layout.h"
  35 #include "tui/tui-winsource.h"
  36 #include "tui/tui-stack.h"
  37 #include "tui/tui-file.h"
  38 #include "tui/tui-disasm.h"
  39 #include "tui/tui-source.h"
  40 #include "progspace.h"
  41 #include "objfiles.h"
  42 #include "cli/cli-style.h"
  43 #include "tui/tui-location.h"
  44
  45 #include "gdb_curses.h"
  46
  47 struct tui_asm_line
  48 {
  49   CORE_ADDR addr;
  50   std::string addr_string;
  51   size_t addr_size;
  52   std::string insn;
  53 };
  54
  55 /* Helper function to find the number of characters in STR, skipping
  56    any ANSI escape sequences.  */
  57 static size_t
  58 len_without_escapes (const std::string &str)
  59 {
  60   size_t len = 0;
  61   const char *ptr = str.c_str ();
  62   char c;
  63
  64   while ((c = *ptr) != '\0')
  65     {
  66       if (c == '\033')
  67         {
  68           ui_file_style style;
  69           size_t n_read;
  70           if (style.parse (ptr, &n_read))
  71             ptr += n_read;
  72           else
  73             {
  74               /* Shouldn't happen, but just skip the ESC if it somehow
  75                  does.  */
  76               ++ptr;
  77             }
  78         }
  79       else
  80         {
  81           ++len;
  82           ++ptr;
  83         }
  84     }
  85   return len;
  86 }
  87
  88 /* Function to disassemble up to COUNT instructions starting from address
  89    PC into the ASM_LINES vector (which will be emptied of any previous
  90    contents).  Return the address of the COUNT'th instruction after pc.
  91    When ADDR_SIZE is non-null then place the maximum size of an address and
  92    label into the value pointed to by ADDR_SIZE, and set the addr_size
  93    field on each item in ASM_LINES, otherwise the addr_size fields within
  94    ASM_LINES are undefined.
  95
  96    It is worth noting that ASM_LINES might not have COUNT entries when this
  97    function returns.  If the disassembly is truncated for some other
  98    reason, for example, we hit invalid memory, then ASM_LINES can have
  99    fewer entries than requested.  */
 100 static CORE_ADDR
 101 tui_disassemble (struct gdbarch *gdbarch,
 102                  std::vector<tui_asm_line> &asm_lines,
 103                  CORE_ADDR pc, int count,
 104                  size_t *addr_size = nullptr)
 105 {
 106   bool term_out = source_styling && gdb_stdout->can_emit_style_escape ();
 107   string_file gdb_dis_out (term_out);
 108
 109   /* Must start with an empty list.  */
 110   asm_lines.clear ();
 111
 112   /* Now construct each line.  */
 113   for (int i = 0; i < count; ++i)
 114     {
 115       tui_asm_line tal;
 116       CORE_ADDR orig_pc = pc;
 117
 118       try
 119         {
 120           pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
 121         }
 122       catch (const gdb_exception_error &except)
 123         {
 124           /* If PC points to an invalid address then we'll catch a
 125              MEMORY_ERROR here, this should stop the disassembly, but
 126              otherwise is fine.  */
 127           if (except.error != MEMORY_ERROR)
 128             throw;
 129           return pc;
 130         }
 131
 132       /* Capture the disassembled instruction.  */
 133       tal.insn = std::move (gdb_dis_out.string ());
 134       gdb_dis_out.clear ();
 135
 136       /* And capture the address the instruction is at.  */
 137       tal.addr = orig_pc;
 138       print_address (gdbarch, orig_pc, &gdb_dis_out);
 139       tal.addr_string = std::move (gdb_dis_out.string ());
 140       gdb_dis_out.clear ();
 141
 142       if (addr_size != nullptr)
 143         {
 144           size_t new_size;
 145
 146           if (term_out)
 147             new_size = len_without_escapes (tal.addr_string);
 148           else
 149             new_size = tal.addr_string.size ();
 150           *addr_size = std::max (*addr_size, new_size);
 151           tal.addr_size = new_size;
 152         }
 153
 154       asm_lines.push_back (std::move (tal));
 155     }
 156   return pc;
 157 }
 158
 159 /* Look backward from ADDR for an address from which we can start
 160    disassembling, this needs to be something we can be reasonably
 161    confident will fall on an instruction boundary.  We use msymbol
 162    addresses, or the start of a section.  */
 163
 164 static CORE_ADDR
 165 tui_find_backward_disassembly_start_address (CORE_ADDR addr)
 166 {
 167   struct bound_minimal_symbol msym, msym_prev;
 168
 169   msym = lookup_minimal_symbol_by_pc_section (addr - 1, nullptr,
 170                                               lookup_msym_prefer::TEXT,
 171                                               &msym_prev);
 172   if (msym.minsym != nullptr)
 173     return BMSYMBOL_VALUE_ADDRESS (msym);
 174   else if (msym_prev.minsym != nullptr)
 175     return BMSYMBOL_VALUE_ADDRESS (msym_prev);
 176
 177   /* Find the section that ADDR is in, and look for the start of the
 178      section.  */
 179   struct obj_section *section = find_pc_section (addr);
 180   if (section != NULL)
 181     return section->addr ();
 182
 183   return addr;
 184 }
 185
 186 /* Find the disassembly address that corresponds to FROM lines above
 187    or below the PC.  Variable sized instructions are taken into
 188    account by the algorithm.  */
 189 static CORE_ADDR
 190 tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
 191 {
 192   CORE_ADDR new_low;
 193   int max_lines;
 194
 195   max_lines = (from > 0) ? from : - from;
 196   if (max_lines == 0)
 197     return pc;
 198
 199   std::vector<tui_asm_line> asm_lines;
 200
 201   new_low = pc;
 202   if (from > 0)
 203     {
 204       /* Always disassemble 1 extra instruction here, then if the last
 205          instruction fails to disassemble we will take the address of the
 206          previous instruction that did disassemble as the result.  */
 207       tui_disassemble (gdbarch, asm_lines, pc, max_lines + 1);
 208       new_low = asm_lines.back ().addr;
 209     }
 210   else
 211     {
 212       /* In order to disassemble backwards we need to find a suitable
 213          address to start disassembling from and then work forward until we
 214          re-find the address we're currently at.  We can then figure out
 215          which address will be at the top of the TUI window after our
 216          backward scroll.  During our backward disassemble we need to be
 217          able to distinguish between the case where the last address we
 218          _can_ disassemble is ADDR, and the case where the disassembly
 219          just happens to stop at ADDR, for this reason we increase
 220          MAX_LINES by one.  */
 221       max_lines++;
 222
 223       /* When we disassemble a series of instructions this will hold the
 224          address of the last instruction disassembled.  */
 225       CORE_ADDR last_addr;
 226
 227       /* And this will hold the address of the next instruction that would
 228          have been disassembled.  */
 229       CORE_ADDR next_addr;
 230
 231       /* As we search backward if we find an address that looks like a
 232          promising starting point then we record it in this structure.  If
 233          the next address we try is not a suitable starting point then we
 234          will fall back to the address held here.  */
 235       gdb::optional<CORE_ADDR> possible_new_low;
 236
 237       /* The previous value of NEW_LOW so we know if the new value is
 238          different or not.  */
 239       CORE_ADDR prev_low;
 240
 241       do
 242         {
 243           /* Find an address from which we can start disassembling.  */
 244           prev_low = new_low;
 245           new_low = tui_find_backward_disassembly_start_address (new_low);
 246
 247           /* Disassemble forward.  */
 248           next_addr = tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
 249           last_addr = asm_lines.back ().addr;
 250
 251           /* If disassembling from the current value of NEW_LOW reached PC
 252              (or went past it) then this would do as a starting point if we
 253              can't find anything better, so remember it.  */
 254           if (last_addr >= pc && new_low != prev_low
 255               && asm_lines.size () >= max_lines)
 256             possible_new_low.emplace (new_low);
 257
 258           /* Continue searching until we find a value of NEW_LOW from which
 259              disassembling MAX_LINES instructions doesn't reach PC.  We
 260              know this means we can find the required number of previous
 261              instructions then.  */
 262         }
 263       while ((last_addr > pc
 264               || (last_addr == pc && asm_lines.size () < max_lines))
 265              && new_low != prev_low);
 266
 267       /* If we failed to disassemble the required number of lines then the
 268          following walk forward is not going to work, it assumes that
 269          ASM_LINES contains exactly MAX_LINES entries.  Instead we should
 270          consider falling back to a previous possible start address in
 271          POSSIBLE_NEW_LOW.  */
 272       if (asm_lines.size () < max_lines)
 273         {
 274           if (!possible_new_low.has_value ())
 275             return new_low;
 276
 277           /* Take the best possible match we have.  */
 278           new_low = *possible_new_low;
 279           next_addr = tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
 280           last_addr = asm_lines.back ().addr;
 281           gdb_assert (asm_lines.size () >= max_lines);
 282         }
 283
 284       /* Scan forward disassembling one instruction at a time until
 285          the last visible instruction of the window matches the pc.
 286          We keep the disassembled instructions in the 'lines' window
 287          and shift it downward (increasing its addresses).  */
 288       int pos = max_lines - 1;
 289       if (last_addr < pc)
 290         do
 291           {
 292             pos++;
 293             if (pos >= max_lines)
 294               pos = 0;
 295
 296             CORE_ADDR old_next_addr = next_addr;
 297             std::vector<tui_asm_line> single_asm_line;
 298             next_addr = tui_disassemble (gdbarch, single_asm_line,
 299                                          next_addr, 1);
 300             /* If there are some problems while disassembling exit.  */
 301             if (next_addr <= old_next_addr)
 302               return pc;
 303             gdb_assert (single_asm_line.size () == 1);
 304             asm_lines[pos] = single_asm_line[0];
 305           } while (next_addr <= pc);
 306       pos++;
 307       if (pos >= max_lines)
 308          pos = 0;
 309       new_low = asm_lines[pos].addr;
 310
 311       /* When scrolling backward the addresses should move backward, or at
 312          the very least stay the same if we are at the first address that
 313          can be disassembled.  */
 314       gdb_assert (new_low <= pc);
 315     }
 316   return new_low;
 317 }
 318
 319 /* Function to set the disassembly window's content.  */
 320 bool
 321 tui_disasm_window::set_contents (struct gdbarch *arch,
 322                                  const struct symtab_and_line &sal)
 323 {
 324   int i;
 325   int max_lines;
 326   CORE_ADDR cur_pc;
 327   int tab_len = tui_tab_width;
 328   int insn_pos;
 329
 330   CORE_ADDR pc = sal.pc;
 331   if (pc == 0)
 332     return false;
 333
 334   m_gdbarch = arch;
 335   m_start_line_or_addr.loa = LOA_ADDRESS;
 336   m_start_line_or_addr.u.addr = pc;
 337   cur_pc = tui_location.addr ();
 338
 339   /* Window size, excluding highlight box.  */
 340   max_lines = height - 2;
 341
 342   /* Get temporary table that will hold all strings (addr & insn).  */
 343   std::vector<tui_asm_line> asm_lines;
 344   size_t addr_size = 0;
 345   tui_disassemble (m_gdbarch, asm_lines, pc, max_lines, &addr_size);
 346
 347   /* Align instructions to the same column.  */
 348   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 349
 350   /* Now construct each line.  */
 351   m_content.resize (max_lines);
 352   m_max_length = -1;
 353   for (i = 0; i < max_lines; i++)
 354     {
 355       tui_source_element *src = &m_content[i];
 356
 357       std::string line;
 358       CORE_ADDR addr;
 359
 360       if (i < asm_lines.size ())
 361         {
 362           line
 363             = (asm_lines[i].addr_string
 364                + n_spaces (insn_pos - asm_lines[i].addr_size)
 365                + asm_lines[i].insn);
 366           addr = asm_lines[i].addr;
 367         }
 368       else
 369         {
 370           line = "";
 371           addr = 0;
 372         }
 373
 374       const char *ptr = line.c_str ();
 375       int line_len;
 376       src->line = tui_copy_source_line (&ptr, &line_len);
 377       m_max_length = std::max (m_max_length, line_len);
 378
 379       src->line_or_addr.loa = LOA_ADDRESS;
 380       src->line_or_addr.u.addr = addr;
 381       src->is_exec_point = (addr == cur_pc && line.size () > 0);
 382     }
 383   return true;
 384 }
 385
 386
 387 void
 388 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 389 {
 390   struct gdbarch *gdbarch = get_current_arch ();
 391   CORE_ADDR addr = 0;
 392
 393   if (tui_location.addr () == 0)
 394     {
 395       if (have_full_symbols () || have_partial_symbols ())
 396         {
 397           set_default_source_symtab_and_line ();
 398           struct symtab_and_line sal = get_current_source_symtab_and_line ();
 399
 400           if (sal.symtab != nullptr)
 401             find_line_pc (sal.symtab, sal.line, &addr);
 402         }
 403
 404       if (addr == 0)
 405         {
 406           struct bound_minimal_symbol main_symbol
 407             = lookup_minimal_symbol (main_name (), nullptr, nullptr);
 408           if (main_symbol.minsym != nullptr)
 409             addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 410         }
 411     }
 412   else                          /* The target is executing.  */
 413     {
 414       gdbarch = tui_location.gdbarch ();
 415       addr = tui_location.addr ();
 416     }
 417
 418   *gdbarch_p = gdbarch;
 419   *addr_p = addr;
 420 }
 421
 422 /* Determine what the low address will be to display in the TUI's
 423    disassembly window.  This may or may not be the same as the low
 424    address input.  */
 425 CORE_ADDR
 426 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 427                                  CORE_ADDR low, CORE_ADDR pc)
 428 {
 429   int pos;
 430
 431   /* Determine where to start the disassembly so that the pc is about
 432      in the middle of the viewport.  */
 433   if (TUI_DISASM_WIN != NULL)
 434     pos = TUI_DISASM_WIN->height;
 435   else if (TUI_CMD_WIN == NULL)
 436     pos = tui_term_height () / 2 - 2;
 437   else
 438     pos = tui_term_height () - TUI_CMD_WIN->height - 2;
 439   pos = (pos - 2) / 2;
 440
 441   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 442
 443   if (pc < low)
 444     pc = low;
 445   return pc;
 446 }
 447
 448 /* Scroll the disassembly forward or backward vertically.  */
 449 void
 450 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 451 {
 452   if (!m_content.empty ())
 453     {
 454       CORE_ADDR pc;
 455
 456       pc = m_start_line_or_addr.u.addr;
 457
 458       symtab_and_line sal {};
 459       sal.pspace = current_program_space;
 460       sal.pc = tui_find_disassembly_address (m_gdbarch, pc, num_to_scroll);
 461       update_source_window_as_is (m_gdbarch, sal);
 462     }
 463 }
 464
 465 bool
 466 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 467 {
 468   return (m_content[line_no].line_or_addr.loa == LOA_ADDRESS
 469           && m_content[line_no].line_or_addr.u.addr == loc->address);
 470 }
 471
 472 bool
 473 tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
 474 {
 475   if (m_content.size () < SCROLL_THRESHOLD)
 476     return false;
 477
 478   for (size_t i = 0; i < m_content.size () - SCROLL_THRESHOLD; ++i)
 479     {
 480       if (m_content[i].line_or_addr.loa == LOA_ADDRESS
 481           && m_content[i].line_or_addr.u.addr == addr)
 482         return true;
 483     }
 484
 485   return false;
 486 }
 487
 488 void
 489 tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
 490 {
 491   CORE_ADDR low;
 492
 493   struct gdbarch *frame_arch = get_frame_arch (fi);
 494
 495   if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0)
 496     {
 497       /* There is no symbol available for current PC.  There is no
 498          safe way how to "disassemble backwards".  */
 499       low = sal.pc;
 500     }
 501   else
 502     low = tui_get_low_disassembly_address (frame_arch, low, sal.pc);
 503
 504   struct tui_line_or_address a;
 505
 506   a.loa = LOA_ADDRESS;
 507   a.u.addr = low;
 508   if (!addr_is_displayed (sal.pc))
 509     {
 510       sal.pc = low;
 511       update_source_window (frame_arch, sal);
 512     }
 513   else
 514     {
 515       a.u.addr = sal.pc;
 516       set_is_exec_point_at (a);
 517     }
 518 }
 519
 520 void
 521 tui_disasm_window::display_start_addr (struct gdbarch **gdbarch_p,
 522                                        CORE_ADDR *addr_p)
 523 {
 524   *gdbarch_p = m_gdbarch;
 525   *addr_p = m_start_line_or_addr.u.addr;
 526 }