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