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_win_info *win_with_focus = tui_win_with_focus ();
 264   struct tui_line_or_address val;
 265
 266   gdb_assert (TUI_DISASM_WIN != nullptr && TUI_DISASM_WIN->is_visible ());
 267
 268   val.loa = LOA_ADDRESS;
 269   val.u.addr = start_addr;
 270   TUI_DISASM_WIN->update_source_window (gdbarch, s, val);
 271
 272   /* If the focus was in the src win, put it in the asm win, if the
 273      source view isn't split.  */
 274   if (tui_current_layout () != SRC_DISASSEM_COMMAND
 275       && win_with_focus == TUI_SRC_WIN)
 276     tui_set_win_focus_to (TUI_DISASM_WIN);
 277 }
 278
 279
 280 /* Function to display the disassembly window.  */
 281 void
 282 tui_show_disassem_and_update_source (struct gdbarch *gdbarch,
 283                                      CORE_ADDR start_addr)
 284 {
 285   struct symtab_and_line sal;
 286
 287   tui_show_disassem (gdbarch, start_addr);
 288   if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 289     {
 290       struct tui_line_or_address val;
 291
 292       /* Update what is in the source window if it is displayed too,
 293          note that it follows what is in the disassembly window and
 294          visa-versa.  */
 295       sal = find_pc_line (start_addr, 0);
 296       val.loa = LOA_LINE;
 297       val.u.line_no = sal.line;
 298       TUI_SRC_WIN->update_source_window (gdbarch, sal.symtab, val);
 299       if (sal.symtab)
 300         set_current_source_symtab_and_line (sal);
 301       tui_update_locator_fullname (sal.symtab);
 302     }
 303 }
 304
 305 void
 306 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 307 {
 308   struct tui_locator_window *locator;
 309   struct gdbarch *gdbarch = get_current_arch ();
 310   CORE_ADDR addr;
 311
 312   locator = tui_locator_win_info_ptr ();
 313
 314   if (locator->addr == 0)
 315     {
 316       struct bound_minimal_symbol main_symbol;
 317
 318       /* Find address of the start of program.
 319          Note: this should be language specific.  */
 320       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 321       if (main_symbol.minsym == 0)
 322         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 323       if (main_symbol.minsym == 0)
 324         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 325       if (main_symbol.minsym)
 326         addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 327       else
 328         addr = 0;
 329     }
 330   else                          /* The target is executing.  */
 331     {
 332       gdbarch = locator->gdbarch;
 333       addr = locator->addr;
 334     }
 335
 336   *gdbarch_p = gdbarch;
 337   *addr_p = addr;
 338 }
 339
 340 /* Determine what the low address will be to display in the TUI's
 341    disassembly window.  This may or may not be the same as the low
 342    address input.  */
 343 CORE_ADDR
 344 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 345                                  CORE_ADDR low, CORE_ADDR pc)
 346 {
 347   int pos;
 348
 349   /* Determine where to start the disassembly so that the pc is about
 350      in the middle of the viewport.  */
 351   if (tui_win_list[DISASSEM_WIN] != NULL)
 352     pos = tui_win_list[DISASSEM_WIN]->height;
 353   else if (TUI_CMD_WIN == NULL)
 354     pos = tui_term_height () / 2 - 2;
 355   else
 356     pos = tui_term_height () - TUI_CMD_WIN->height - 2;
 357   pos = (pos - 2) / 2;
 358
 359   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 360
 361   if (pc < low)
 362     pc = low;
 363   return pc;
 364 }
 365
 366 /* Scroll the disassembly forward or backward vertically.  */
 367 void
 368 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 369 {
 370   if (!content.empty ())
 371     {
 372       CORE_ADDR pc;
 373       struct tui_line_or_address val;
 374
 375       pc = content[0].line_or_addr.u.addr;
 376       if (num_to_scroll >= 0)
 377         num_to_scroll++;
 378       else
 379         --num_to_scroll;
 380
 381       val.loa = LOA_ADDRESS;
 382       val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 383       update_source_window_as_is (gdbarch, NULL, val);
 384     }
 385 }
 386
 387 bool
 388 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 389 {
 390   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 391           && content[line_no].line_or_addr.u.addr == loc->address);
 392 }
 393
 394 bool
 395 tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const
 396 {
 397   bool is_displayed = false;
 398   int threshold = SCROLL_THRESHOLD;
 399
 400   int i = 0;
 401   while (i < content.size () - threshold && !is_displayed)
 402     {
 403       is_displayed
 404         = (content[i].line_or_addr.loa == LOA_ADDRESS
 405            && content[i].line_or_addr.u.addr == addr);
 406       i++;
 407     }
 408
 409   return is_displayed;
 410 }
 411
 412 void
 413 tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal,
 414                                  int line_no, CORE_ADDR addr)
 415 {
 416   CORE_ADDR low;
 417
 418   if (find_pc_partial_function (get_frame_pc (fi),
 419                                 NULL, &low, NULL) == 0)
 420     {
 421       /* There is no symbol available for current PC.  There is no
 422          safe way how to "disassemble backwards".  */
 423       low = get_frame_pc (fi);
 424     }
 425   else
 426     low = tui_get_low_disassembly_address (get_frame_arch (fi),
 427                                            low, get_frame_pc (fi));
 428
 429   struct tui_line_or_address a;
 430
 431   a.loa = LOA_ADDRESS;
 432   a.u.addr = low;
 433   if (!addr_is_displayed (addr))
 434     update_source_window (get_frame_arch (fi), sal.symtab, a);
 435   else
 436     {
 437       a.u.addr = addr;
 438       set_is_exec_point_at (a);
 439     }
 440 }