gdb/disasm.c

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