gdb/tui/tui-disasm.c

   1 /* Disassembly display.
   2
   3    Copyright (C) 1998-2019 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;
 262
 263   locator = tui_locator_win_info_ptr ();
 264
 265   if (locator->addr == 0)
 266     {
 267       struct bound_minimal_symbol main_symbol;
 268
 269       /* Find address of the start of program.
 270          Note: this should be language specific.  */
 271       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 272       if (main_symbol.minsym == 0)
 273         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 274       if (main_symbol.minsym == 0)
 275         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 276       if (main_symbol.minsym)
 277         addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 278       else
 279         addr = 0;
 280     }
 281   else                          /* The target is executing.  */
 282     {
 283       gdbarch = locator->gdbarch;
 284       addr = locator->addr;
 285     }
 286
 287   *gdbarch_p = gdbarch;
 288   *addr_p = addr;
 289 }
 290
 291 /* Determine what the low address will be to display in the TUI's
 292    disassembly window.  This may or may not be the same as the low
 293    address input.  */
 294 CORE_ADDR
 295 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 296                                  CORE_ADDR low, CORE_ADDR pc)
 297 {
 298   int pos;
 299
 300   /* Determine where to start the disassembly so that the pc is about
 301      in the middle of the viewport.  */
 302   if (tui_win_list[DISASSEM_WIN] != NULL)
 303     pos = tui_win_list[DISASSEM_WIN]->height;
 304   else if (TUI_CMD_WIN == NULL)
 305     pos = tui_term_height () / 2 - 2;
 306   else
 307     pos = tui_term_height () - TUI_CMD_WIN->height - 2;
 308   pos = (pos - 2) / 2;
 309
 310   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 311
 312   if (pc < low)
 313     pc = low;
 314   return pc;
 315 }
 316
 317 /* Scroll the disassembly forward or backward vertically.  */
 318 void
 319 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 320 {
 321   if (!content.empty ())
 322     {
 323       CORE_ADDR pc;
 324
 325       pc = start_line_or_addr.u.addr;
 326       if (num_to_scroll >= 0)
 327         num_to_scroll++;
 328       else
 329         --num_to_scroll;
 330
 331       symtab_and_line sal {};
 332       sal.pspace = current_program_space;
 333       sal.pc = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 334       update_source_window_as_is (gdbarch, sal);
 335     }
 336 }
 337
 338 bool
 339 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 340 {
 341   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 342           && content[line_no].line_or_addr.u.addr == loc->address);
 343 }
 344
 345 bool
 346 tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
 347 {
 348   bool is_displayed = false;
 349   int threshold = SCROLL_THRESHOLD;
 350
 351   int i = 0;
 352   while (i < content.size () - threshold && !is_displayed)
 353     {
 354       is_displayed
 355         = (content[i].line_or_addr.loa == LOA_ADDRESS
 356            && content[i].line_or_addr.u.addr == addr);
 357       i++;
 358     }
 359
 360   return is_displayed;
 361 }
 362
 363 void
 364 tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
 365 {
 366   CORE_ADDR low;
 367
 368   struct gdbarch *frame_arch = get_frame_arch (fi);
 369
 370   if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0)
 371     {
 372       /* There is no symbol available for current PC.  There is no
 373          safe way how to "disassemble backwards".  */
 374       low = sal.pc;
 375     }
 376   else
 377     low = tui_get_low_disassembly_address (frame_arch, low, sal.pc);
 378
 379   struct tui_line_or_address a;
 380
 381   a.loa = LOA_ADDRESS;
 382   a.u.addr = low;
 383   if (!addr_is_displayed (sal.pc))
 384     {
 385       sal.pc = low;
 386       update_source_window (frame_arch, sal);
 387     }
 388   else
 389     {
 390       a.u.addr = sal.pc;
 391       set_is_exec_point_at (a);
 392     }
 393 }