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 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,
 290                                                        "src_and_asm_line");
 291               print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
 292             }
 293
 294           next_line = mle[i].line + 1;
 295           ui_out_list_chain
 296             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
 297         }
 298
 299       num_displayed += dump_insns (gdbarch, uiout, di,
 300                                    mle[i].start_pc, mle[i].end_pc,
 301                                    how_many, flags, stb);
 302
 303       /* When we've reached the end of the mle array, or we've seen the last
 304          assembly range for this source line, close out the list/tuple.  */
 305       if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
 306         {
 307           do_cleanups (ui_out_list_chain);
 308           do_cleanups (ui_out_tuple_chain);
 309           ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 310           ui_out_list_chain = make_cleanup (null_cleanup, 0);
 311           ui_out_text (uiout, "\n");
 312         }
 313       if (how_many >= 0 && num_displayed >= how_many)
 314         break;
 315     }
 316   do_cleanups (ui_out_chain);
 317 }
 318
 319
 320 static void
 321 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
 322                   struct disassemble_info * di,
 323                   CORE_ADDR low, CORE_ADDR high,
 324                   int how_many, int flags, struct ui_stream *stb)
 325 {
 326   int num_displayed = 0;
 327   struct cleanup *ui_out_chain;
 328
 329   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 330
 331   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
 332                               flags, stb);
 333
 334   do_cleanups (ui_out_chain);
 335 }
 336
 337 /* Initialize the disassemble info struct ready for the specified
 338    stream.  */
 339
 340 static int ATTRIBUTE_PRINTF (2, 3)
 341 fprintf_disasm (void *stream, const char *format, ...)
 342 {
 343   va_list args;
 344
 345   va_start (args, format);
 346   vfprintf_filtered (stream, format, args);
 347   va_end (args);
 348   /* Something non -ve.  */
 349   return 0;
 350 }
 351
 352 static struct disassemble_info
 353 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
 354 {
 355   struct disassemble_info di;
 356
 357   init_disassemble_info (&di, file, fprintf_disasm);
 358   di.flavour = bfd_target_unknown_flavour;
 359   di.memory_error_func = dis_asm_memory_error;
 360   di.print_address_func = dis_asm_print_address;
 361   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
 362      disassembler had a local optomization here.  By default it would
 363      access the executable file, instead of the target memory (there
 364      was a growing list of exceptions though).  Unfortunately, the
 365      heuristic was flawed.  Commands like "disassemble &variable"
 366      didn't work as they relied on the access going to the target.
 367      Further, it has been supperseeded by trust-read-only-sections
 368      (although that should be superseeded by target_trust..._p()).  */
 369   di.read_memory_func = dis_asm_read_memory;
 370   di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 371   di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 372   di.endian = gdbarch_byte_order (gdbarch);
 373   di.endian_code = gdbarch_byte_order_for_code (gdbarch);
 374   di.application_data = gdbarch;
 375   disassemble_init_for_target (&di);
 376   return di;
 377 }
 378
 379 void
 380 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 381                  char *file_string, int flags, int how_many,
 382                  CORE_ADDR low, CORE_ADDR high)
 383 {
 384   struct ui_stream *stb = ui_out_stream_new (uiout);
 385   struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
 386   struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
 387   /* To collect the instruction outputted from opcodes. */
 388   struct symtab *symtab = NULL;
 389   struct linetable_entry *le = NULL;
 390   int nlines = -1;
 391
 392   /* Assume symtab is valid for whole PC range */
 393   symtab = find_pc_symtab (low);
 394
 395   if (symtab != NULL && symtab->linetable != NULL)
 396     {
 397       /* Convert the linetable to a bunch of my_line_entry's.  */
 398       le = symtab->linetable->item;
 399       nlines = symtab->linetable->nitems;
 400     }
 401
 402   if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
 403       || symtab == NULL || symtab->linetable == NULL)
 404     do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
 405
 406   else if (flags & DISASSEMBLY_SOURCE)
 407     do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
 408                                   high, symtab, how_many, flags, stb);
 409
 410   do_cleanups (cleanups);
 411   gdb_flush (gdb_stdout);
 412 }
 413
 414 /* Print the instruction at address MEMADDR in debugged memory,
 415    on STREAM.  Returns the length of the instruction, in bytes,
 416    and, if requested, the number of branch delay slot instructions.  */
 417
 418 int
 419 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 420                 struct ui_file *stream, int *branch_delay_insns)
 421 {
 422   struct disassemble_info di;
 423   int length;
 424
 425   di = gdb_disassemble_info (gdbarch, stream);
 426   length = gdbarch_print_insn (gdbarch, memaddr, &di);
 427   if (branch_delay_insns)
 428     {
 429       if (di.insn_info_valid)
 430         *branch_delay_insns = di.branch_delay_insns;
 431       else
 432         *branch_delay_insns = 0;
 433     }
 434   return length;
 435 }
 436
 437 static void
 438 do_ui_file_delete (void *arg)
 439 {
 440   ui_file_delete (arg);
 441 }
 442
 443 /* Return the length in bytes of the instruction at address MEMADDR in
 444    debugged memory.  */
 445
 446 int
 447 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
 448 {
 449   static struct ui_file *null_stream = NULL;
 450
 451   /* Dummy file descriptor for the disassembler.  */
 452   if (!null_stream)
 453     {
 454       null_stream = ui_file_new ();
 455       make_final_cleanup (do_ui_file_delete, null_stream);
 456     }
 457
 458   return gdb_print_insn (gdbarch, addr, null_stream, NULL);
 459 }
 460
 461 /* fprintf-function for gdb_buffered_insn_length.  This function is a
 462    nop, we don't want to print anything, we just want to compute the
 463    length of the insn.  */
 464
 465 static int ATTRIBUTE_PRINTF (2, 3)
 466 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
 467 {
 468   return 0;
 469 }
 470
 471 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.  */
 472
 473 static void
 474 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
 475                                    struct disassemble_info *di,
 476                                    const gdb_byte *insn, int max_len,
 477                                    CORE_ADDR addr)
 478 {
 479   init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
 480
 481   /* init_disassemble_info installs buffer_read_memory, etc.
 482      so we don't need to do that here.
 483      The cast is necessary until disassemble_info is const-ified.  */
 484   di->buffer = (gdb_byte *) insn;
 485   di->buffer_length = max_len;
 486   di->buffer_vma = addr;
 487
 488   di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 489   di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 490   di->endian = gdbarch_byte_order (gdbarch);
 491   di->endian_code = gdbarch_byte_order_for_code (gdbarch);
 492
 493   disassemble_init_for_target (di);
 494 }
 495
 496 /* Return the length in bytes of INSN.  MAX_LEN is the size of the
 497    buffer containing INSN.  */
 498
 499 int
 500 gdb_buffered_insn_length (struct gdbarch *gdbarch,
 501                           const gdb_byte *insn, int max_len, CORE_ADDR addr)
 502 {
 503   struct disassemble_info di;
 504
 505   gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
 506
 507   return gdbarch_print_insn (gdbarch, addr, &di);
 508 }