gdb/disasm.c

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