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-data.h"
  32 #include "tui/tui-win.h"
  33 #include "tui/tui-layout.h"
  34 #include "tui/tui-winsource.h"
  35 #include "tui/tui-stack.h"
  36 #include "tui/tui-file.h"
  37 #include "tui/tui-disasm.h"
  38 #include "tui/tui-source.h"
  39 #include "progspace.h"
  40 #include "objfiles.h"
  41
  42 #include "gdb_curses.h"
  43
  44 struct tui_asm_line
  45 {
  46   CORE_ADDR addr;
  47   char *addr_string;
  48   char *insn;
  49 };
  50
  51 /* Function to set the disassembly window's content.
  52    Disassemble count lines starting at pc.
  53    Return address of the count'th instruction after pc.  */
  54 static CORE_ADDR
  55 tui_disassemble (struct gdbarch *gdbarch, struct tui_asm_line *asm_lines,
  56                  CORE_ADDR pc, int count)
  57 {
  58   string_file gdb_dis_out;
  59
  60   /* Now construct each line.  */
  61   for (; count > 0; count--, asm_lines++)
  62     {
  63       xfree (asm_lines->addr_string);
  64       xfree (asm_lines->insn);
  65
  66       print_address (gdbarch, pc, &gdb_dis_out);
  67       asm_lines->addr = pc;
  68       asm_lines->addr_string = xstrdup (gdb_dis_out.c_str ());
  69
  70       gdb_dis_out.clear ();
  71
  72       pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL);
  73
  74       asm_lines->insn = xstrdup (gdb_dis_out.c_str ());
  75
  76       /* Reset the buffer to empty.  */
  77       gdb_dis_out.clear ();
  78     }
  79   return pc;
  80 }
  81
  82 /* Find the disassembly address that corresponds to FROM lines above
  83    or below the PC.  Variable sized instructions are taken into
  84    account by the algorithm.  */
  85 static CORE_ADDR
  86 tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
  87 {
  88   CORE_ADDR new_low;
  89   int max_lines;
  90   int i;
  91   struct tui_asm_line *asm_lines;
  92
  93   max_lines = (from > 0) ? from : - from;
  94   if (max_lines <= 1)
  95      return pc;
  96
  97   asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
  98   memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
  99
 100   new_low = pc;
 101   if (from > 0)
 102     {
 103       tui_disassemble (gdbarch, asm_lines, pc, max_lines);
 104       new_low = asm_lines[max_lines - 1].addr;
 105     }
 106   else
 107     {
 108       CORE_ADDR last_addr;
 109       int pos;
 110       struct bound_minimal_symbol msymbol;
 111
 112       /* Find backward an address which is a symbol and for which
 113          disassembling from that address will fill completely the
 114          window.  */
 115       pos = max_lines - 1;
 116       do {
 117          new_low -= 1 * max_lines;
 118          msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
 119
 120          if (msymbol.minsym)
 121             new_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
 122          else
 123             new_low += 1 * max_lines;
 124
 125          tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
 126          last_addr = asm_lines[pos].addr;
 127       } while (last_addr > pc && msymbol.minsym);
 128
 129       /* Scan forward disassembling one instruction at a time until
 130          the last visible instruction of the window matches the pc.
 131          We keep the disassembled instructions in the 'lines' window
 132          and shift it downward (increasing its addresses).  */
 133       if (last_addr < pc)
 134         do
 135           {
 136             CORE_ADDR next_addr;
 137
 138             pos++;
 139             if (pos >= max_lines)
 140               pos = 0;
 141
 142             next_addr = tui_disassemble (gdbarch, &asm_lines[pos],
 143                                          last_addr, 1);
 144
 145             /* If there are some problems while disassembling exit.  */
 146             if (next_addr <= last_addr)
 147               break;
 148             last_addr = next_addr;
 149           } while (last_addr <= pc);
 150       pos++;
 151       if (pos >= max_lines)
 152          pos = 0;
 153       new_low = asm_lines[pos].addr;
 154     }
 155   for (i = 0; i < max_lines; i++)
 156     {
 157       xfree (asm_lines[i].addr_string);
 158       xfree (asm_lines[i].insn);
 159     }
 160   return new_low;
 161 }
 162
 163 /* Function to set the disassembly window's content.  */
 164 enum tui_status
 165 tui_set_disassem_content (tui_source_window_base *win_info,
 166                           struct gdbarch *gdbarch, CORE_ADDR pc)
 167 {
 168   int i;
 169   int offset = win_info->horizontal_offset;
 170   int max_lines, line_width;
 171   CORE_ADDR cur_pc;
 172   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 173   int tab_len = tui_tab_width;
 174   struct tui_asm_line *asm_lines;
 175   int insn_pos;
 176   int addr_size, insn_size;
 177   char *line;
 178
 179   if (pc == 0)
 180     return TUI_FAILURE;
 181
 182   tui_alloc_source_buffer (win_info);
 183
 184   win_info->gdbarch = gdbarch;
 185   win_info->start_line_or_addr.loa = LOA_ADDRESS;
 186   win_info->start_line_or_addr.u.addr = pc;
 187   cur_pc = locator->addr;
 188
 189   /* Window size, excluding highlight box.  */
 190   max_lines = win_info->height - 2;
 191   line_width = win_info->width - 2;
 192
 193   /* Get temporary table that will hold all strings (addr & insn).  */
 194   asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
 195   memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
 196
 197   tui_disassemble (gdbarch, asm_lines, pc, max_lines);
 198
 199   /* Determine maximum address- and instruction lengths.  */
 200   addr_size = 0;
 201   insn_size = 0;
 202   for (i = 0; i < max_lines; i++)
 203     {
 204       size_t len = strlen (asm_lines[i].addr_string);
 205
 206       if (len > addr_size)
 207         addr_size = len;
 208
 209       len = strlen (asm_lines[i].insn);
 210       if (len > insn_size)
 211         insn_size = len;
 212     }
 213
 214   /* Align instructions to the same column.  */
 215   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 216
 217   /* Allocate memory to create each line.  */
 218   line = (char*) alloca (insn_pos + insn_size + 1);
 219
 220   /* Now construct each line.  */
 221   win_info->content.resize (max_lines);
 222   for (i = 0; i < max_lines; i++)
 223     {
 224       int cur_len;
 225
 226       tui_source_element *src = &win_info->content[i];
 227       strcpy (line, asm_lines[i].addr_string);
 228       cur_len = strlen (line);
 229       memset (line + cur_len, ' ', insn_pos - cur_len);
 230       strcpy (line + insn_pos, asm_lines[i].insn);
 231
 232       /* Now copy the line taking the offset into account.  */
 233       xfree (src->line);
 234       if (strlen (line) > offset)
 235         src->line = xstrndup (&line[offset], line_width);
 236       else
 237         src->line = xstrdup ("");
 238
 239       src->line_or_addr.loa = LOA_ADDRESS;
 240       src->line_or_addr.u.addr = asm_lines[i].addr;
 241       src->is_exec_point = asm_lines[i].addr == cur_pc;
 242
 243       xfree (asm_lines[i].addr_string);
 244       xfree (asm_lines[i].insn);
 245     }
 246   return TUI_SUCCESS;
 247 }
 248
 249
 250 /* Function to display the disassembly window with disassembled code.  */
 251 void
 252 tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR start_addr)
 253 {
 254   struct symtab *s = find_pc_line_symtab (start_addr);
 255   struct tui_win_info *win_with_focus = tui_win_with_focus ();
 256   struct tui_line_or_address val;
 257
 258   val.loa = LOA_ADDRESS;
 259   val.u.addr = start_addr;
 260   tui_add_win_to_layout (DISASSEM_WIN);
 261   tui_update_source_window (TUI_DISASM_WIN, gdbarch, s, val, FALSE);
 262
 263   /* If the focus was in the src win, put it in the asm win, if the
 264      source view isn't split.  */
 265   if (tui_current_layout () != SRC_DISASSEM_COMMAND
 266       && win_with_focus == TUI_SRC_WIN)
 267     tui_set_win_focus_to (TUI_DISASM_WIN);
 268 }
 269
 270
 271 /* Function to display the disassembly window.  */
 272 void
 273 tui_show_disassem_and_update_source (struct gdbarch *gdbarch,
 274                                      CORE_ADDR start_addr)
 275 {
 276   struct symtab_and_line sal;
 277
 278   tui_show_disassem (gdbarch, start_addr);
 279   if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 280     {
 281       struct tui_line_or_address val;
 282
 283       /* Update what is in the source window if it is displayed too,
 284          note that it follows what is in the disassembly window and
 285          visa-versa.  */
 286       sal = find_pc_line (start_addr, 0);
 287       val.loa = LOA_LINE;
 288       val.u.line_no = sal.line;
 289       tui_update_source_window (TUI_SRC_WIN, gdbarch, sal.symtab, val, TRUE);
 290       if (sal.symtab)
 291         {
 292           set_current_source_symtab_and_line (sal);
 293           tui_update_locator_fullname (symtab_to_fullname (sal.symtab));
 294         }
 295       else
 296         tui_update_locator_fullname ("?");
 297     }
 298 }
 299
 300 void
 301 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 302 {
 303   struct tui_locator_window *locator;
 304   struct gdbarch *gdbarch = get_current_arch ();
 305   CORE_ADDR addr;
 306
 307   locator = tui_locator_win_info_ptr ();
 308
 309   if (locator->addr == 0)
 310     {
 311       struct bound_minimal_symbol main_symbol;
 312
 313       /* Find address of the start of program.
 314          Note: this should be language specific.  */
 315       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 316       if (main_symbol.minsym == 0)
 317         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 318       if (main_symbol.minsym == 0)
 319         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 320       if (main_symbol.minsym)
 321         addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 322       else
 323         addr = 0;
 324     }
 325   else                          /* The target is executing.  */
 326     {
 327       gdbarch = locator->gdbarch;
 328       addr = locator->addr;
 329     }
 330
 331   *gdbarch_p = gdbarch;
 332   *addr_p = addr;
 333 }
 334
 335 /* Determine what the low address will be to display in the TUI's
 336    disassembly window.  This may or may not be the same as the low
 337    address input.  */
 338 CORE_ADDR
 339 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 340                                  CORE_ADDR low, CORE_ADDR pc)
 341 {
 342   int pos;
 343
 344   /* Determine where to start the disassembly so that the pc is about
 345      in the middle of the viewport.  */
 346   pos = tui_default_win_viewport_height (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
 347   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 348
 349   if (pc < low)
 350     pc = low;
 351   return pc;
 352 }
 353
 354 /* Scroll the disassembly forward or backward vertically.  */
 355 void
 356 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 357 {
 358   if (!content.empty ())
 359     {
 360       CORE_ADDR pc;
 361       struct tui_line_or_address val;
 362
 363       pc = content[0].line_or_addr.u.addr;
 364       if (num_to_scroll >= 0)
 365         num_to_scroll++;
 366       else
 367         --num_to_scroll;
 368
 369       val.loa = LOA_ADDRESS;
 370       val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 371       tui_update_source_window_as_is (this, gdbarch,
 372                                       NULL, val, FALSE);
 373     }
 374 }
 375
 376 bool
 377 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 378 {
 379   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 380           && content[line_no].line_or_addr.u.addr == loc->address);
 381 }