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