gdb/tui/tui-disasm.c

   1 /* Disassembly display.
   2
   3    Copyright (C) 1998-2020 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
  44 #include "gdb_curses.h"
  45
  46 struct tui_asm_line
  47 {
  48   CORE_ADDR addr;
  49   std::string addr_string;
  50   size_t addr_size;
  51   std::string insn;
  52 };
  53
  54 /* Helper function to find the number of characters in STR, skipping
  55    any ANSI escape sequences.  */
  56 static size_t
  57 len_without_escapes (const std::string &str)
  58 {
  59   size_t len = 0;
  60   const char *ptr = str.c_str ();
  61   char c;
  62
  63   while ((c = *ptr++) != '\0')
  64     {
  65       if (c == '\033')
  66         {
  67           ui_file_style style;
  68           size_t n_read;
  69           if (style.parse (ptr, &n_read))
  70             ptr += n_read;
  71           else
  72             {
  73               /* Shouldn't happen, but just skip the ESC if it somehow
  74                  does.  */
  75               ++ptr;
  76             }
  77         }
  78       else
  79         ++len;
  80     }
  81   return len;
  82 }
  83
  84 /* Function to set the disassembly window's content.
  85    Disassemble count lines starting at pc.
  86    Return address of the count'th instruction after pc.  */
  87 static CORE_ADDR
  88 tui_disassemble (struct gdbarch *gdbarch,
  89                  std::vector<tui_asm_line> &asm_lines,
  90                  CORE_ADDR pc, int pos, int count,
  91                  size_t *addr_size = nullptr)
  92 {
  93   bool term_out = source_styling && gdb_stdout->can_emit_style_escape ();
  94   string_file gdb_dis_out (term_out);
  95
  96   /* Now construct each line.  */
  97   for (int i = 0; i < count; ++i)
  98     {
  99       print_address (gdbarch, pc, &gdb_dis_out);
 100       asm_lines[pos + i].addr = pc;
 101       asm_lines[pos + i].addr_string = std::move (gdb_dis_out.string ());
 102
 103       gdb_dis_out.clear ();
 104
 105       if (addr_size != nullptr)
 106         {
 107           size_t new_size;
 108
 109           if (term_out)
 110             new_size = len_without_escapes (asm_lines[pos + i].addr_string);
 111           else
 112             new_size = asm_lines[pos + i].addr_string.size ();
 113           *addr_size = std::max (*addr_size, new_size);
 114           asm_lines[pos + i].addr_size = new_size;
 115         }
 116
 117       pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
 118
 119       asm_lines[pos + i].insn = std::move (gdb_dis_out.string ());
 120
 121       /* Reset the buffer to empty.  */
 122       gdb_dis_out.clear ();
 123     }
 124   return pc;
 125 }
 126
 127 /* Find the disassembly address that corresponds to FROM lines above
 128    or below the PC.  Variable sized instructions are taken into
 129    account by the algorithm.  */
 130 static CORE_ADDR
 131 tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
 132 {
 133   CORE_ADDR new_low;
 134   int max_lines;
 135
 136   max_lines = (from > 0) ? from : - from;
 137   if (max_lines <= 1)
 138     return pc;
 139
 140   std::vector<tui_asm_line> asm_lines (max_lines);
 141
 142   new_low = pc;
 143   if (from > 0)
 144     {
 145       tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines);
 146       new_low = asm_lines[max_lines - 1].addr;
 147     }
 148   else
 149     {
 150       CORE_ADDR last_addr;
 151       int pos;
 152       struct bound_minimal_symbol msymbol;
 153
 154       /* Find backward an address which is a symbol and for which
 155          disassembling from that address will fill completely the
 156          window.  */
 157       pos = max_lines - 1;
 158       do {
 159          new_low -= 1 * max_lines;
 160          msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
 161
 162          if (msymbol.minsym)
 163             new_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
 164          else
 165             new_low += 1 * max_lines;
 166
 167          tui_disassemble (gdbarch, asm_lines, new_low, 0, max_lines);
 168          last_addr = asm_lines[pos].addr;
 169       } while (last_addr > pc && msymbol.minsym);
 170
 171       /* Scan forward disassembling one instruction at a time until
 172          the last visible instruction of the window matches the pc.
 173          We keep the disassembled instructions in the 'lines' window
 174          and shift it downward (increasing its addresses).  */
 175       if (last_addr < pc)
 176         do
 177           {
 178             CORE_ADDR next_addr;
 179
 180             pos++;
 181             if (pos >= max_lines)
 182               pos = 0;
 183
 184             next_addr = tui_disassemble (gdbarch, asm_lines,
 185                                          last_addr, pos, 1);
 186
 187             /* If there are some problems while disassembling exit.  */
 188             if (next_addr <= last_addr)
 189               break;
 190             last_addr = next_addr;
 191           } while (last_addr <= pc);
 192       pos++;
 193       if (pos >= max_lines)
 194          pos = 0;
 195       new_low = asm_lines[pos].addr;
 196     }
 197   return new_low;
 198 }
 199
 200 /* Function to set the disassembly window's content.  */
 201 bool
 202 tui_disasm_window::set_contents (struct gdbarch *arch,
 203                                  const struct symtab_and_line &sal)
 204 {
 205   int i;
 206   int offset = horizontal_offset;
 207   int max_lines, line_width;
 208   CORE_ADDR cur_pc;
 209   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 210   int tab_len = tui_tab_width;
 211   int insn_pos;
 212
 213   CORE_ADDR pc = sal.pc;
 214   if (pc == 0)
 215     return false;
 216
 217   gdbarch = arch;
 218   start_line_or_addr.loa = LOA_ADDRESS;
 219   start_line_or_addr.u.addr = pc;
 220   cur_pc = locator->addr;
 221
 222   /* Window size, excluding highlight box.  */
 223   max_lines = height - 2;
 224   line_width = width - TUI_EXECINFO_SIZE - 2;
 225
 226   /* Get temporary table that will hold all strings (addr & insn).  */
 227   std::vector<tui_asm_line> asm_lines (max_lines);
 228   size_t addr_size = 0;
 229   tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines, &addr_size);
 230
 231   /* Align instructions to the same column.  */
 232   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 233
 234   /* Now construct each line.  */
 235   content.resize (max_lines);
 236   for (i = 0; i < max_lines; i++)
 237     {
 238       tui_source_element *src = &content[i];
 239
 240       std::string line
 241         = (asm_lines[i].addr_string
 242            + n_spaces (insn_pos - asm_lines[i].addr_size)
 243            + asm_lines[i].insn);
 244
 245       const char *ptr = line.c_str ();
 246       src->line = tui_copy_source_line (&ptr, -1, offset, line_width, 0);
 247
 248       src->line_or_addr.loa = LOA_ADDRESS;
 249       src->line_or_addr.u.addr = asm_lines[i].addr;
 250       src->is_exec_point = asm_lines[i].addr == cur_pc;
 251     }
 252   return true;
 253 }
 254
 255
 256 void
 257 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 258 {
 259   struct tui_locator_window *locator;
 260   struct gdbarch *gdbarch = get_current_arch ();
 261   CORE_ADDR addr = 0;
 262
 263   locator = tui_locator_win_info_ptr ();
 264
 265   if (locator->addr == 0)
 266     {
 267       if (have_full_symbols () || have_partial_symbols ())
 268         {
 269           set_default_source_symtab_and_line ();
 270           struct symtab_and_line sal = get_current_source_symtab_and_line ();
 271
 272           if (sal.symtab != nullptr)
 273             find_line_pc (sal.symtab, sal.line, &addr);
 274         }
 275
 276       if (addr == 0)
 277         {
 278           struct bound_minimal_symbol main_symbol
 279             = lookup_minimal_symbol (main_name (), nullptr, nullptr);
 280           if (main_symbol.minsym != nullptr)
 281             addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 282         }
 283     }
 284   else                          /* The target is executing.  */
 285     {
 286       gdbarch = locator->gdbarch;
 287       addr = locator->addr;
 288     }
 289
 290   *gdbarch_p = gdbarch;
 291   *addr_p = addr;
 292 }
 293
 294 /* Determine what the low address will be to display in the TUI's
 295    disassembly window.  This may or may not be the same as the low
 296    address input.  */
 297 CORE_ADDR
 298 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 299                                  CORE_ADDR low, CORE_ADDR pc)
 300 {
 301   int pos;
 302
 303   /* Determine where to start the disassembly so that the pc is about
 304      in the middle of the viewport.  */
 305   if (tui_win_list[DISASSEM_WIN] != NULL)
 306     pos = tui_win_list[DISASSEM_WIN]->height;
 307   else if (TUI_CMD_WIN == NULL)
 308     pos = tui_term_height () / 2 - 2;
 309   else
 310     pos = tui_term_height () - TUI_CMD_WIN->height - 2;
 311   pos = (pos - 2) / 2;
 312
 313   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 314
 315   if (pc < low)
 316     pc = low;
 317   return pc;
 318 }
 319
 320 /* Scroll the disassembly forward or backward vertically.  */
 321 void
 322 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 323 {
 324   if (!content.empty ())
 325     {
 326       CORE_ADDR pc;
 327
 328       pc = start_line_or_addr.u.addr;
 329       if (num_to_scroll >= 0)
 330         num_to_scroll++;
 331       else
 332         --num_to_scroll;
 333
 334       symtab_and_line sal {};
 335       sal.pspace = current_program_space;
 336       sal.pc = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 337       update_source_window_as_is (gdbarch, sal);
 338     }
 339 }
 340
 341 bool
 342 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 343 {
 344   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 345           && content[line_no].line_or_addr.u.addr == loc->address);
 346 }
 347
 348 bool
 349 tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
 350 {
 351   if (content.size () < SCROLL_THRESHOLD)
 352     return false;
 353
 354   for (size_t i = 0; i < content.size () - SCROLL_THRESHOLD; ++i)
 355     {
 356       if (content[i].line_or_addr.loa == LOA_ADDRESS
 357           && content[i].line_or_addr.u.addr == addr)
 358         return true;
 359     }
 360
 361   return false;
 362 }
 363
 364 void
 365 tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
 366 {
 367   CORE_ADDR low;
 368
 369   struct gdbarch *frame_arch = get_frame_arch (fi);
 370
 371   if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0)
 372     {
 373       /* There is no symbol available for current PC.  There is no
 374          safe way how to "disassemble backwards".  */
 375       low = sal.pc;
 376     }
 377   else
 378     low = tui_get_low_disassembly_address (frame_arch, low, sal.pc);
 379
 380   struct tui_line_or_address a;
 381
 382   a.loa = LOA_ADDRESS;
 383   a.u.addr = low;
 384   if (!addr_is_displayed (sal.pc))
 385     {
 386       sal.pc = low;
 387       update_source_window (frame_arch, sal);
 388     }
 389   else
 390     {
 391       a.u.addr = sal.pc;
 392       set_is_exec_point_at (a);
 393     }
 394 }