gdb/disasm.c

   1 /* Disassemble support for GDB.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "ui-out.h"
  25 #include "gdb_string.h"
  26 #include "disasm.h"
  27 #include "gdbcore.h"
  28 #include "dis-asm.h"
  29
  30 /* Disassemble functions.
  31    FIXME: We should get rid of all the duplicate code in gdb that does
  32    the same thing: disassemble_command() and the gdbtk variation. */
  33
  34 /* This Structure is used to store line number information.
  35    We need a different sort of line table from the normal one cuz we can't
  36    depend upon implicit line-end pc's for lines to do the
  37    reordering in this function.  */
  38
  39 struct dis_line_entry
  40 {
  41   int line;
  42   CORE_ADDR start_pc;
  43   CORE_ADDR end_pc;
  44 };
  45
  46 /* Like target_read_memory, but slightly different parameters.  */
  47 static int
  48 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
  49                      struct disassemble_info *info)
  50 {
  51   return target_read_memory (memaddr, myaddr, len);
  52 }
  53
  54 /* Like memory_error with slightly different parameters.  */
  55 static void
  56 dis_asm_memory_error (int status, bfd_vma memaddr,
  57                       struct disassemble_info *info)
  58 {
  59   memory_error (status, memaddr);
  60 }
  61
  62 /* Like print_address with slightly different parameters.  */
  63 static void
  64 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
  65 {
  66   struct gdbarch *gdbarch = info->application_data;
  67   print_address (gdbarch, addr, info->stream);
  68 }
  69
  70 static int
  71 compare_lines (const void *mle1p, const void *mle2p)
  72 {
  73   struct dis_line_entry *mle1, *mle2;
  74   int val;
  75
  76   mle1 = (struct dis_line_entry *) mle1p;
  77   mle2 = (struct dis_line_entry *) mle2p;
  78
  79   val = mle1->line - mle2->line;
  80
  81   if (val != 0)
  82     return val;
  83
  84   return mle1->start_pc - mle2->start_pc;
  85 }
  86
  87 static int
  88 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
  89             struct disassemble_info * di,
  90             CORE_ADDR low, CORE_ADDR high,
  91             int how_many, int flags, struct ui_stream *stb)
  92 {
  93   int num_displayed = 0;
  94   CORE_ADDR pc;
  95
  96   /* parts of the symbolic representation of the address */
  97   int unmapped;
  98   int offset;
  99   int line;
 100   struct cleanup *ui_out_chain;
 101
 102   for (pc = low; pc < high;)
 103     {
 104       char *filename = NULL;
 105       char *name = NULL;
 106
 107       QUIT;
 108       if (how_many >= 0)
 109         {
 110           if (num_displayed >= how_many)
 111             break;
 112           else
 113             num_displayed++;
 114         }
 115       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 116       ui_out_text (uiout, pc_prefix (pc));
 117       ui_out_field_core_addr (uiout, "address", gdbarch, pc);
 118
 119       if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
 120                                    &line, &unmapped))
 121         {
 122           /* We don't care now about line, filename and
 123              unmapped. But we might in the future. */
 124           ui_out_text (uiout, " <");
 125           if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
 126             ui_out_field_string (uiout, "func-name", name);
 127           ui_out_text (uiout, "+");
 128           ui_out_field_int (uiout, "offset", offset);
 129           ui_out_text (uiout, ">:\t");
 130         }
 131       else
 132         ui_out_text (uiout, ":\t");
 133
 134       if (filename != NULL)
 135         xfree (filename);
 136       if (name != NULL)
 137         xfree (name);
 138
 139       ui_file_rewind (stb->stream);
 140       if (flags & DISASSEMBLY_RAW_INSN)
 141         {
 142           CORE_ADDR old_pc = pc;
 143           bfd_byte data;
 144           int status;
 145           pc += gdbarch_print_insn (gdbarch, pc, di);
 146           for (;old_pc < pc; old_pc++)
 147             {
 148               status = (*di->read_memory_func) (old_pc, &data, 1, di);
 149               if (status != 0)
 150                 (*di->memory_error_func) (status, old_pc, di);
 151               ui_out_message (uiout, 0, " %02x", (unsigned)data);
 152             }
 153           ui_out_text (uiout, "\t");
 154         }
 155       else
 156         pc += gdbarch_print_insn (gdbarch, pc, di);
 157       ui_out_field_stream (uiout, "inst", stb);
 158       ui_file_rewind (stb->stream);
 159       do_cleanups (ui_out_chain);
 160       ui_out_text (uiout, "\n");
 161     }
 162   return num_displayed;
 163 }
 164
 165 /* The idea here is to present a source-O-centric view of a
 166    function to the user.  This means that things are presented
 167    in source order, with (possibly) out of order assembly
 168    immediately following.  */
 169 static void
 170 do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 171                               struct disassemble_info *di, int nlines,
 172                               struct linetable_entry *le,
 173                               CORE_ADDR low, CORE_ADDR high,
 174                               struct symtab *symtab,
 175                               int how_many, int flags, struct ui_stream *stb)
 176 {
 177   int newlines = 0;
 178   struct dis_line_entry *mle;
 179   struct symtab_and_line sal;
 180   int i;
 181   int out_of_order = 0;
 182   int next_line = 0;
 183   int num_displayed = 0;
 184   struct cleanup *ui_out_chain;
 185   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 186   struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
 187
 188   mle = (struct dis_line_entry *) alloca (nlines
 189                                           * sizeof (struct dis_line_entry));
 190
 191   /* Copy linetable entries for this function into our data
 192      structure, creating end_pc's and setting out_of_order as
 193      appropriate.  */
 194
 195   /* First, skip all the preceding functions.  */
 196
 197   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
 198
 199   /* Now, copy all entries before the end of this function.  */
 200
 201   for (; i < nlines - 1 && le[i].pc < high; i++)
 202     {
 203       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
 204         continue;               /* Ignore duplicates */
 205
 206       /* Skip any end-of-function markers.  */
 207       if (le[i].line == 0)
 208         continue;
 209
 210       mle[newlines].line = le[i].line;
 211       if (le[i].line > le[i + 1].line)
 212         out_of_order = 1;
 213       mle[newlines].start_pc = le[i].pc;
 214       mle[newlines].end_pc = le[i + 1].pc;
 215       newlines++;
 216     }
 217
 218   /* If we're on the last line, and it's part of the function,
 219      then we need to get the end pc in a special way.  */
 220
 221   if (i == nlines - 1 && le[i].pc < high)
 222     {
 223       mle[newlines].line = le[i].line;
 224       mle[newlines].start_pc = le[i].pc;
 225       sal = find_pc_line (le[i].pc, 0);
 226       mle[newlines].end_pc = sal.end;
 227       newlines++;
 228     }
 229
 230   /* Now, sort mle by line #s (and, then by addresses within
 231      lines). */
 232
 233   if (out_of_order)
 234     qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
 235
 236   /* Now, for each line entry, emit the specified lines (unless
 237      they have been emitted before), followed by the assembly code
 238      for that line.  */
 239
 240   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 241
 242   for (i = 0; i < newlines; i++)
 243     {
 244       /* Print out everything from next_line to the current line.  */
 245       if (mle[i].line >= next_line)
 246         {
 247           if (next_line != 0)
 248             {
 249               /* Just one line to print. */
 250               if (next_line == mle[i].line)
 251                 {
 252                   ui_out_tuple_chain
 253                     = make_cleanup_ui_out_tuple_begin_end (uiout,
 254                                                            "src_and_asm_line");
 255                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
 256                 }
 257               else
 258                 {
 259                   /* Several source lines w/o asm instructions associated. */
 260                   for (; next_line < mle[i].line; next_line++)
 261                     {
 262                       struct cleanup *ui_out_list_chain_line;
 263                       struct cleanup *ui_out_tuple_chain_line;
 264
 265                       ui_out_tuple_chain_line
 266                         = make_cleanup_ui_out_tuple_begin_end (uiout,
 267                                                                "src_and_asm_line");
 268                       print_source_lines (symtab, next_line, next_line + 1,
 269                                           0);
 270                       ui_out_list_chain_line
 271                         = make_cleanup_ui_out_list_begin_end (uiout,
 272                                                               "line_asm_insn");
 273                       do_cleanups (ui_out_list_chain_line);
 274                       do_cleanups (ui_out_tuple_chain_line);
 275                     }
 276                   /* Print the last line and leave list open for
 277                      asm instructions to be added. */
 278                   ui_out_tuple_chain
 279                     = make_cleanup_ui_out_tuple_begin_end (uiout,
 280                                                            "src_and_asm_line");
 281                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
 282                 }
 283             }
 284           else
 285             {
 286               ui_out_tuple_chain
 287                 = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
 288               print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
 289             }
 290
 291           next_line = mle[i].line + 1;
 292           ui_out_list_chain
 293             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
 294         }
 295
 296       num_displayed += dump_insns (gdbarch, uiout, di,
 297                                    mle[i].start_pc, mle[i].end_pc,
 298                                    how_many, flags, stb);
 299
 300       /* When we've reached the end of the mle array, or we've seen the last
 301          assembly range for this source line, close out the list/tuple.  */
 302       if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
 303         {
 304           do_cleanups (ui_out_list_chain);
 305           do_cleanups (ui_out_tuple_chain);
 306           ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 307           ui_out_list_chain = make_cleanup (null_cleanup, 0);
 308           ui_out_text (uiout, "\n");
 309         }
 310       if (how_many >= 0 && num_displayed >= how_many)
 311         break;
 312     }
 313   do_cleanups (ui_out_chain);
 314 }
 315
 316
 317 static void
 318 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
 319                   struct disassemble_info * di,
 320                   CORE_ADDR low, CORE_ADDR high,
 321                   int how_many, int flags, struct ui_stream *stb)
 322 {
 323   int num_displayed = 0;
 324   struct cleanup *ui_out_chain;
 325
 326   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 327
 328   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
 329                               flags, stb);
 330
 331   do_cleanups (ui_out_chain);
 332 }
 333
 334 /* Initialize the disassemble info struct ready for the specified
 335    stream.  */
 336
 337 static int ATTRIBUTE_PRINTF (2, 3)
 338 fprintf_disasm (void *stream, const char *format, ...)
 339 {
 340   va_list args;
 341   va_start (args, format);
 342   vfprintf_filtered (stream, format, args);
 343   va_end (args);
 344   /* Something non -ve.  */
 345   return 0;
 346 }
 347
 348 static struct disassemble_info
 349 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
 350 {
 351   struct disassemble_info di;
 352   init_disassemble_info (&di, file, fprintf_disasm);
 353   di.flavour = bfd_target_unknown_flavour;
 354   di.memory_error_func = dis_asm_memory_error;
 355   di.print_address_func = dis_asm_print_address;
 356   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
 357      disassembler had a local optomization here.  By default it would
 358      access the executable file, instead of the target memory (there
 359      was a growing list of exceptions though).  Unfortunately, the
 360      heuristic was flawed.  Commands like "disassemble &variable"
 361      didn't work as they relied on the access going to the target.
 362      Further, it has been supperseeded by trust-read-only-sections
 363      (although that should be superseeded by target_trust..._p()).  */
 364   di.read_memory_func = dis_asm_read_memory;
 365   di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 366   di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 367   di.endian = gdbarch_byte_order (gdbarch);
 368   di.endian_code = gdbarch_byte_order_for_code (gdbarch);
 369   di.application_data = gdbarch;
 370   disassemble_init_for_target (&di);
 371   return di;
 372 }
 373
 374 void
 375 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 376                  char *file_string, int flags, int how_many,
 377                  CORE_ADDR low, CORE_ADDR high)
 378 {
 379   struct ui_stream *stb = ui_out_stream_new (uiout);
 380   struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
 381   struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
 382   /* To collect the instruction outputted from opcodes. */
 383   struct symtab *symtab = NULL;
 384   struct linetable_entry *le = NULL;
 385   int nlines = -1;
 386
 387   /* Assume symtab is valid for whole PC range */
 388   symtab = find_pc_symtab (low);
 389
 390   if (symtab != NULL && symtab->linetable != NULL)
 391     {
 392       /* Convert the linetable to a bunch of my_line_entry's.  */
 393       le = symtab->linetable->item;
 394       nlines = symtab->linetable->nitems;
 395     }
 396
 397   if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
 398       || symtab == NULL || symtab->linetable == NULL)
 399     do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
 400
 401   else if (flags & DISASSEMBLY_SOURCE)
 402     do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
 403                                   high, symtab, how_many, flags, stb);
 404
 405   do_cleanups (cleanups);
 406   gdb_flush (gdb_stdout);
 407 }
 408
 409 /* Print the instruction at address MEMADDR in debugged memory,
 410    on STREAM.  Returns the length of the instruction, in bytes,
 411    and, if requested, the number of branch delay slot instructions.  */
 412
 413 int
 414 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 415                 struct ui_file *stream, int *branch_delay_insns)
 416 {
 417   struct disassemble_info di;
 418   int length;
 419
 420   di = gdb_disassemble_info (gdbarch, stream);
 421   length = gdbarch_print_insn (gdbarch, memaddr, &di);
 422   if (branch_delay_insns)
 423     {
 424       if (di.insn_info_valid)
 425         *branch_delay_insns = di.branch_delay_insns;
 426       else
 427         *branch_delay_insns = 0;
 428     }
 429   return length;
 430 }
 431
 432 static void
 433 do_ui_file_delete (void *arg)
 434 {
 435   ui_file_delete (arg);
 436 }
 437
 438 /* Return the length in bytes of the instruction at address MEMADDR in
 439    debugged memory.  */
 440
 441 int
 442 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
 443 {
 444   static struct ui_file *null_stream = NULL;
 445
 446   /* Dummy file descriptor for the disassembler.  */
 447   if (!null_stream)
 448     {
 449       null_stream = ui_file_new ();
 450       make_final_cleanup (do_ui_file_delete, null_stream);
 451     }
 452
 453   return gdb_print_insn (gdbarch, addr, null_stream, NULL);
 454 }
 455
 456 /* fprintf-function for gdb_buffered_insn_length.  This function is a
 457    nop, we don't want to print anything, we just want to compute the
 458    length of the insn.  */
 459
 460 static int ATTRIBUTE_PRINTF (2, 3)
 461 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
 462 {
 463   return 0;
 464 }
 465
 466 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.  */
 467
 468 static void
 469 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
 470                                    struct disassemble_info *di,
 471                                    const gdb_byte *insn, int max_len,
 472                                    CORE_ADDR addr)
 473 {
 474   init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
 475
 476   /* init_disassemble_info installs buffer_read_memory, etc.
 477      so we don't need to do that here.
 478      The cast is necessary until disassemble_info is const-ified.  */
 479   di->buffer = (gdb_byte *) insn;
 480   di->buffer_length = max_len;
 481   di->buffer_vma = addr;
 482
 483   di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 484   di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 485   di->endian = gdbarch_byte_order (gdbarch);
 486   di->endian_code = gdbarch_byte_order_for_code (gdbarch);
 487
 488   disassemble_init_for_target (di);
 489 }
 490
 491 /* Return the length in bytes of INSN.  MAX_LEN is the size of the
 492    buffer containing INSN.  */
 493
 494 int
 495 gdb_buffered_insn_length (struct gdbarch *gdbarch,
 496                           const gdb_byte *insn, int max_len, CORE_ADDR addr)
 497 {
 498   struct disassemble_info di;
 499
 500   gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
 501
 502   return gdbarch_print_insn (gdbarch, addr, &di);
 503 }