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   return;
 270 }
 271
 272
 273 /* Function to display the disassembly window.  */
 274 void
 275 tui_show_disassem_and_update_source (struct gdbarch *gdbarch,
 276                                      CORE_ADDR start_addr)
 277 {
 278   struct symtab_and_line sal;
 279
 280   tui_show_disassem (gdbarch, start_addr);
 281   if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 282     {
 283       struct tui_line_or_address val;
 284
 285       /* Update what is in the source window if it is displayed too,
 286          note that it follows what is in the disassembly window and
 287          visa-versa.  */
 288       sal = find_pc_line (start_addr, 0);
 289       val.loa = LOA_LINE;
 290       val.u.line_no = sal.line;
 291       tui_update_source_window (TUI_SRC_WIN, gdbarch, sal.symtab, val, TRUE);
 292       if (sal.symtab)
 293         {
 294           set_current_source_symtab_and_line (sal);
 295           tui_update_locator_fullname (symtab_to_fullname (sal.symtab));
 296         }
 297       else
 298         tui_update_locator_fullname ("?");
 299     }
 300
 301   return;
 302 }
 303
 304 void
 305 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 306 {
 307   struct tui_locator_window *locator;
 308   struct gdbarch *gdbarch = get_current_arch ();
 309   CORE_ADDR addr;
 310
 311   locator = tui_locator_win_info_ptr ();
 312
 313   if (locator->addr == 0)
 314     {
 315       struct bound_minimal_symbol main_symbol;
 316
 317       /* Find address of the start of program.
 318          Note: this should be language specific.  */
 319       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 320       if (main_symbol.minsym == 0)
 321         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 322       if (main_symbol.minsym == 0)
 323         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 324       if (main_symbol.minsym)
 325         addr = BMSYMBOL_VALUE_ADDRESS (main_symbol);
 326       else
 327         addr = 0;
 328     }
 329   else                          /* The target is executing.  */
 330     {
 331       gdbarch = locator->gdbarch;
 332       addr = locator->addr;
 333     }
 334
 335   *gdbarch_p = gdbarch;
 336   *addr_p = addr;
 337 }
 338
 339 /* Determine what the low address will be to display in the TUI's
 340    disassembly window.  This may or may not be the same as the low
 341    address input.  */
 342 CORE_ADDR
 343 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 344                                  CORE_ADDR low, CORE_ADDR pc)
 345 {
 346   int pos;
 347
 348   /* Determine where to start the disassembly so that the pc is about
 349      in the middle of the viewport.  */
 350   pos = tui_default_win_viewport_height (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
 351   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 352
 353   if (pc < low)
 354     pc = low;
 355   return pc;
 356 }
 357
 358 /* Scroll the disassembly forward or backward vertically.  */
 359 void
 360 tui_disasm_window::do_scroll_vertical (int num_to_scroll)
 361 {
 362   if (!content.empty ())
 363     {
 364       CORE_ADDR pc;
 365       struct tui_line_or_address val;
 366
 367       pc = content[0].line_or_addr.u.addr;
 368       if (num_to_scroll >= 0)
 369         num_to_scroll++;
 370       else
 371         --num_to_scroll;
 372
 373       val.loa = LOA_ADDRESS;
 374       val.u.addr = tui_find_disassembly_address (gdbarch, pc, num_to_scroll);
 375       tui_update_source_window_as_is (this, gdbarch,
 376                                       NULL, val, FALSE);
 377     }
 378 }
 379
 380 bool
 381 tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no)
 382 {
 383   return (content[line_no].line_or_addr.loa == LOA_ADDRESS
 384           && content[line_no].line_or_addr.u.addr == loc->address);
 385 }