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 enum tui_status
 202 tui_disasm_window::set_contents (struct gdbarch *arch,
 203                                  struct symtab *s,
 204                                  struct tui_line_or_address line_or_addr)
 205 {
 206   int i;
 207   int offset = horizontal_offset;
 208   int max_lines, line_width;
 209   CORE_ADDR cur_pc;
 210   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 211   int tab_len = tui_tab_width;
 212   int insn_pos;
 213
 214   gdb_assert (line_or_addr.loa == LOA_ADDRESS);
 215   CORE_ADDR pc = line_or_addr.u.addr;
 216   if (pc == 0)
 217     return TUI_FAILURE;
 218
 219   gdbarch = arch;
 220   start_line_or_addr.loa = LOA_ADDRESS;
 221   start_line_or_addr.u.addr = pc;
 222   cur_pc = locator->addr;
 223
 224   /* Window size, excluding highlight box.  */
 225   max_lines = height - 2;
 226   line_width = width - TUI_EXECINFO_SIZE - 2;
 227
 228   /* Get temporary table that will hold all strings (addr & insn).  */
 229   std::vector<tui_asm_line> asm_lines (max_lines);
 230   size_t addr_size = 0;
 231   tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines, &addr_size);
 232
 233   /* Align instructions to the same column.  */
 234   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 235
 236   /* Now construct each line.  */
 237   content.resize (max_lines);
 238   for (i = 0; i < max_lines; i++)
 239     {
 240       tui_source_element *src = &content[i];
 241
 242       std::string line
 243         = (asm_lines[i].addr_string
 244            + n_spaces (insn_pos - asm_lines[i].addr_size)
 245            + asm_lines[i].insn);
 246
 247       const char *ptr = line.c_str ();
 248       src->line = tui_copy_source_line (&ptr, -1, offset, line_width, 0);
 249
 250       src->line_or_addr.loa = LOA_ADDRESS;
 251       src->line_or_addr.u.addr = asm_lines[i].addr;
 252       src->is_exec_point = asm_lines[i].addr == cur_pc;
 253     }
 254   return TUI_SUCCESS;
 255 }
 256
 257
 258 /* Function to display the disassembly window with disassembled code.  */
 259 void
 260 tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR start_addr)
 261 {
 262   struct symtab *s = find_pc_line_symtab (start_addr);
 263   struct tui_line_or_address val;
 264
 265   gdb_assert (TUI_DISASM_WIN != nullptr && TUI_DISASM_WIN->is_visible ());
 266
 267   val.loa = LOA_ADDRESS;
 268   val.u.addr = start_addr;
 269   TUI_DISASM_WIN->update_source_window (gdbarch, s, val);
 270 }
 271
 272 void
 273 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 274 {
 275   struct tui_locator_window *locator;
 276   struct gdbarch *gdbarch = get_current_arch ();
 277   CORE_ADDR addr;
 278
 279   locator = tui_locator_win_info_ptr ();
 280
 281   if (locator->addr == 0)
 282     {
 283       struct bound_minimal_symbol main_symbol;
 284
 285       /* Find address of the start of program.
 286          Note: this should be language specific.  */
 287       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 288       if (main_symbol.minsym == 0)
 289         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 290       if (main_symbol.minsym == 0)
 291         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 292       if (main_symbol.minsym)
 293         addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 294       else
 295         addr = 0;
 296     }
 297   else                          /* The target is executing.  */
 298     {
 299       gdbarch = locator->gdbarch;
 300       addr = locator->addr;
 301     }
 302
 303   *gdbarch_p = gdbarch;
 304   *addr_p = addr;
 305 }
 306
 307 /* Determine what the low address will be to display in the TUI's
 308    disassembly window.  This may or may not be the same as the low
 309    address input.  */
 310 CORE_ADDR
 311 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 312                                  CORE_ADDR low, CORE_ADDR pc)
 313 {
 314   int pos;
 315
 316   /* Determine where to start the disassembly so that the pc is about
 317      in the middle of the viewport.  */
 318   if (tui_win_list[DISASSEM_WIN] != NULL)
 319     pos = tui_win_list[DISASSEM_WIN]->height;
 320   else if (TUI_CMD_WIN == NULL)
 321     pos = tui_term_height () / 2 - 2;
 322   else
 323     pos = tui_term_height () - TUI_CMD_WIN->height - 2;
 324   pos = (pos - 2) / 2;
 325
 326   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 327
 328   if (pc < low)
 329     pc = low;
 330   return pc;
 331 }
 332
 333 /* Scroll the disassembly forward or backward vertically.  */
 334 void
 335 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 336 {
 337   if (!content.empty ())
 338     {
 339       CORE_ADDR pc;
 340       struct tui_line_or_address val;
 341
 342       pc = content[0].line_or_addr.u.addr;
 343       if (num_to_scroll >= 0)
 344         num_to_scroll++;
 345       else
 346         --num_to_scroll;
 347
 348       val.loa = LOA_ADDRESS;
 349       val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 350       update_source_window_as_is (gdbarch, NULL, val);
 351     }
 352 }
 353
 354 bool
 355 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 356 {
 357   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 358           && content[line_no].line_or_addr.u.addr == loc->address);
 359 }
 360
 361 bool
 362 tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
 363 {
 364   bool is_displayed = false;
 365   int threshold = SCROLL_THRESHOLD;
 366
 367   int i = 0;
 368   while (i < content.size () - threshold && !is_displayed)
 369     {
 370       is_displayed
 371         = (content[i].line_or_addr.loa == LOA_ADDRESS
 372            && content[i].line_or_addr.u.addr == addr);
 373       i++;
 374     }
 375
 376   return is_displayed;
 377 }
 378
 379 void
 380 tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal)
 381 {
 382   CORE_ADDR low;
 383
 384   struct gdbarch *frame_arch = get_frame_arch (fi);
 385
 386   if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0)
 387     {
 388       /* There is no symbol available for current PC.  There is no
 389          safe way how to "disassemble backwards".  */
 390       low = sal.pc;
 391     }
 392   else
 393     low = tui_get_low_disassembly_address (frame_arch, low, sal.pc);
 394
 395   struct tui_line_or_address a;
 396
 397   a.loa = LOA_ADDRESS;
 398   a.u.addr = low;
 399   if (!addr_is_displayed (sal.pc))
 400     update_source_window (frame_arch, sal.symtab, a);
 401   else
 402     {
 403       a.u.addr = sal.pc;
 404       set_is_exec_point_at (a);
 405     }
 406 }