contrib/gdb-7/gdb/tui/tui-disasm.c

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