gdb/tui/tui-disasm.c

   1 /* Disassembly display.
   2
   3    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Hewlett-Packard Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.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 "gdb_string.h"
  31 #include "tui/tui.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
  40 #include "gdb_curses.h"
  41
  42 struct tui_asm_line
  43 {
  44   CORE_ADDR addr;
  45   char *addr_string;
  46   char *insn;
  47 };
  48
  49 /* Function to set the disassembly window's content.
  50    Disassemble count lines starting at pc.
  51    Return address of the count'th instruction after pc.  */
  52 static CORE_ADDR
  53 tui_disassemble (struct gdbarch *gdbarch, struct tui_asm_line *asm_lines,
  54                  CORE_ADDR pc, int count)
  55 {
  56   struct ui_file *gdb_dis_out;
  57
  58   /* Now init the ui_file structure.  */
  59   gdb_dis_out = tui_sfileopen (256);
  60
  61   /* Now construct each line.  */
  62   for (; count > 0; count--, asm_lines++)
  63     {
  64       if (asm_lines->addr_string)
  65         xfree (asm_lines->addr_string);
  66       if (asm_lines->insn)
  67         xfree (asm_lines->insn);
  68
  69       print_address (gdbarch, pc, gdb_dis_out);
  70       asm_lines->addr = pc;
  71       asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
  72
  73       ui_file_rewind (gdb_dis_out);
  74
  75       pc = pc + gdb_print_insn (gdbarch, pc, gdb_dis_out, NULL);
  76
  77       asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
  78
  79       /* Reset the buffer to empty.  */
  80       ui_file_rewind (gdb_dis_out);
  81     }
  82   ui_file_delete (gdb_dis_out);
  83   return pc;
  84 }
  85
  86 /* Find the disassembly address that corresponds to FROM lines above
  87    or below the PC.  Variable sized instructions are taken into
  88    account by the algorithm.  */
  89 static CORE_ADDR
  90 tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
  91 {
  92   CORE_ADDR new_low;
  93   int max_lines;
  94   int i;
  95   struct tui_asm_line *asm_lines;
  96
  97   max_lines = (from > 0) ? from : - from;
  98   if (max_lines <= 1)
  99      return pc;
 100
 101   asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
 102                                          * max_lines);
 103   memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
 104
 105   new_low = pc;
 106   if (from > 0)
 107     {
 108       tui_disassemble (gdbarch, asm_lines, pc, max_lines);
 109       new_low = asm_lines[max_lines - 1].addr;
 110     }
 111   else
 112     {
 113       CORE_ADDR last_addr;
 114       int pos;
 115       struct minimal_symbol *msymbol;
 116
 117       /* Find backward an address which is a symbol and for which
 118          disassembling from that address will fill completely the
 119          window.  */
 120       pos = max_lines - 1;
 121       do {
 122          new_low -= 1 * max_lines;
 123          msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
 124
 125          if (msymbol)
 126             new_low = SYMBOL_VALUE_ADDRESS (msymbol);
 127          else
 128             new_low += 1 * max_lines;
 129
 130          tui_disassemble (gdbarch, asm_lines, new_low, max_lines);
 131          last_addr = asm_lines[pos].addr;
 132       } while (last_addr > pc && msymbol);
 133
 134       /* Scan forward disassembling one instruction at a time until
 135          the last visible instruction of the window matches the pc.
 136          We keep the disassembled instructions in the 'lines' window
 137          and shift it downward (increasing its addresses).  */
 138       if (last_addr < pc)
 139         do
 140           {
 141             CORE_ADDR next_addr;
 142
 143             pos++;
 144             if (pos >= max_lines)
 145               pos = 0;
 146
 147             next_addr = tui_disassemble (gdbarch, &asm_lines[pos],
 148                                          last_addr, 1);
 149
 150             /* If there are some problems while disassembling exit.  */
 151             if (next_addr <= last_addr)
 152               break;
 153             last_addr = next_addr;
 154           } while (last_addr <= pc);
 155       pos++;
 156       if (pos >= max_lines)
 157          pos = 0;
 158       new_low = asm_lines[pos].addr;
 159     }
 160   for (i = 0; i < max_lines; i++)
 161     {
 162       xfree (asm_lines[i].addr_string);
 163       xfree (asm_lines[i].insn);
 164     }
 165   return new_low;
 166 }
 167
 168 /* Function to set the disassembly window's content.  */
 169 enum tui_status
 170 tui_set_disassem_content (struct gdbarch *gdbarch, CORE_ADDR pc)
 171 {
 172   enum tui_status ret = TUI_FAILURE;
 173   int i;
 174   int offset = TUI_DISASM_WIN->detail.source_info.horizontal_offset;
 175   int line_width, max_lines;
 176   CORE_ADDR cur_pc;
 177   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 178   int tab_len = tui_default_tab_len ();
 179   struct tui_asm_line *asm_lines;
 180   int insn_pos;
 181   int addr_size, max_size;
 182   char *line;
 183
 184   if (pc == 0)
 185     return TUI_FAILURE;
 186
 187   ret = tui_alloc_source_buffer (TUI_DISASM_WIN);
 188   if (ret != TUI_SUCCESS)
 189     return ret;
 190
 191   TUI_DISASM_WIN->detail.source_info.gdbarch = gdbarch;
 192   TUI_DISASM_WIN->detail.source_info.start_line_or_addr.loa = LOA_ADDRESS;
 193   TUI_DISASM_WIN->detail.source_info.start_line_or_addr.u.addr = pc;
 194   cur_pc = (CORE_ADDR)
 195     (((struct tui_win_element *) locator->content[0])->which_element.locator.addr);
 196
 197   max_lines = TUI_DISASM_WIN->generic.height - 2;       /* Account for
 198                                                            hilite.  */
 199
 200   /* Get temporary table that will hold all strings (addr & insn).  */
 201   asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
 202                                          * max_lines);
 203   memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
 204
 205   line_width = TUI_DISASM_WIN->generic.width - 1;
 206
 207   tui_disassemble (gdbarch, asm_lines, pc, max_lines);
 208
 209   /* See what is the maximum length of an address and of a line.  */
 210   addr_size = 0;
 211   max_size = 0;
 212   for (i = 0; i < max_lines; i++)
 213     {
 214       size_t len = strlen (asm_lines[i].addr_string);
 215       if (len > addr_size)
 216         addr_size = len;
 217
 218       len = strlen (asm_lines[i].insn) + tab_len;
 219       if (len > max_size)
 220         max_size = len;
 221     }
 222   max_size += addr_size + tab_len;
 223
 224   /* Allocate memory to create each line.  */
 225   line = (char*) alloca (max_size);
 226   insn_pos = (1 + (addr_size / tab_len)) * tab_len;
 227
 228   /* Now construct each line.  */
 229   for (i = 0; i < max_lines; i++)
 230     {
 231       struct tui_win_element *element;
 232       struct tui_source_element *src;
 233       int cur_len;
 234
 235       element = (struct tui_win_element *) TUI_DISASM_WIN->generic.content[i];
 236       src = &element->which_element.source;
 237       strcpy (line, asm_lines[i].addr_string);
 238       cur_len = strlen (line);
 239
 240       /* Add spaces to make the instructions start on the same
 241          column.  */
 242       while (cur_len < insn_pos)
 243         {
 244           strcat (line, " ");
 245           cur_len++;
 246         }
 247
 248       strcat (line, asm_lines[i].insn);
 249
 250       /* Now copy the line taking the offset into account.  */
 251       if (strlen (line) > offset)
 252         strcpy (src->line, &line[offset]);
 253       else
 254         src->line[0] = '\0';
 255
 256       src->line_or_addr.loa = LOA_ADDRESS;
 257       src->line_or_addr.u.addr = asm_lines[i].addr;
 258       src->is_exec_point = asm_lines[i].addr == cur_pc;
 259
 260       /* See whether there is a breakpoint installed.  */
 261       src->has_break = (!src->is_exec_point
 262                        && breakpoint_here_p (pc) != no_breakpoint_here);
 263
 264       xfree (asm_lines[i].addr_string);
 265       xfree (asm_lines[i].insn);
 266     }
 267   TUI_DISASM_WIN->generic.content_size = i;
 268   return TUI_SUCCESS;
 269 }
 270
 271
 272 /* Function to display the disassembly window with disassembled code.  */
 273 void
 274 tui_show_disassem (struct gdbarch *gdbarch, CORE_ADDR start_addr)
 275 {
 276   struct symtab *s = find_pc_symtab (start_addr);
 277   struct tui_win_info *win_with_focus = tui_win_with_focus ();
 278   struct tui_line_or_address val;
 279
 280   val.loa = LOA_ADDRESS;
 281   val.u.addr = start_addr;
 282   tui_add_win_to_layout (DISASSEM_WIN);
 283   tui_update_source_window (TUI_DISASM_WIN, gdbarch, s, val, FALSE);
 284
 285   /* If the focus was in the src win, put it in the asm win, if the
 286      source view isn't split.  */
 287   if (tui_current_layout () != SRC_DISASSEM_COMMAND
 288       && win_with_focus == TUI_SRC_WIN)
 289     tui_set_win_focus_to (TUI_DISASM_WIN);
 290
 291   return;
 292 }
 293
 294
 295 /* Function to display the disassembly window.  */
 296 void
 297 tui_show_disassem_and_update_source (struct gdbarch *gdbarch,
 298                                      CORE_ADDR start_addr)
 299 {
 300   struct symtab_and_line sal;
 301
 302   tui_show_disassem (gdbarch, start_addr);
 303   if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 304     {
 305       struct tui_line_or_address val;
 306
 307       /* Update what is in the source window if it is displayed too,
 308          note that it follows what is in the disassembly window and
 309          visa-versa.  */
 310       sal = find_pc_line (start_addr, 0);
 311       val.loa = LOA_LINE;
 312       val.u.line_no = sal.line;
 313       tui_update_source_window (TUI_SRC_WIN, gdbarch, sal.symtab, val, TRUE);
 314       if (sal.symtab)
 315         {
 316           set_current_source_symtab_and_line (&sal);
 317           tui_update_locator_filename (sal.symtab->filename);
 318         }
 319       else
 320         tui_update_locator_filename ("?");
 321     }
 322
 323   return;
 324 }
 325
 326 void
 327 tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
 328 {
 329   struct tui_gen_win_info *locator;
 330   struct tui_locator_element *element;
 331   struct gdbarch *gdbarch = NULL;
 332   CORE_ADDR addr;
 333
 334   locator = tui_locator_win_info_ptr ();
 335   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 336
 337   if (element->addr == 0)
 338     {
 339       struct minimal_symbol *main_symbol;
 340
 341       /* Find address of the start of program.
 342          Note: this should be language specific.  */
 343       main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
 344       if (main_symbol == 0)
 345         main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
 346       if (main_symbol == 0)
 347         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
 348       if (main_symbol)
 349         addr = SYMBOL_VALUE_ADDRESS (main_symbol);
 350       else
 351         addr = 0;
 352     }
 353   else                          /* The target is executing.  */
 354     {
 355       gdbarch = element->gdbarch;
 356       addr = element->addr;
 357     }
 358
 359   *gdbarch_p = gdbarch;
 360   *addr_p = addr;
 361 }
 362
 363 /* Determine what the low address will be to display in the TUI's
 364    disassembly window.  This may or may not be the same as the low
 365    address input.  */
 366 CORE_ADDR
 367 tui_get_low_disassembly_address (struct gdbarch *gdbarch,
 368                                  CORE_ADDR low, CORE_ADDR pc)
 369 {
 370   int pos;
 371
 372   /* Determine where to start the disassembly so that the pc is about
 373      in the middle of the viewport.  */
 374   pos = tui_default_win_viewport_height (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
 375   pc = tui_find_disassembly_address (gdbarch, pc, -pos);
 376
 377   if (pc < low)
 378     pc = low;
 379   return pc;
 380 }
 381
 382 /* Scroll the disassembly forward or backward vertically.  */
 383 void
 384 tui_vertical_disassem_scroll (enum tui_scroll_direction scroll_direction,
 385                               int num_to_scroll)
 386 {
 387   if (TUI_DISASM_WIN->generic.content != NULL)
 388     {
 389       struct gdbarch *gdbarch = TUI_DISASM_WIN->detail.source_info.gdbarch;
 390       CORE_ADDR pc;
 391       tui_win_content content;
 392       struct tui_line_or_address val;
 393       int dir;
 394
 395       content = (tui_win_content) TUI_DISASM_WIN->generic.content;
 396
 397       pc = content[0]->which_element.source.line_or_addr.u.addr;
 398       num_to_scroll++;
 399       dir = (scroll_direction == FORWARD_SCROLL) ? num_to_scroll : -num_to_scroll;
 400
 401       val.loa = LOA_ADDRESS;
 402       val.u.addr = tui_find_disassembly_address (gdbarch, pc, dir);
 403       tui_update_source_window_as_is (TUI_DISASM_WIN, gdbarch, NULL, val, FALSE);
 404     }
 405 }