gdb/disasm.c

   1 /* Disassemble support for GDB.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   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   print_address (gdbarch, addr, info->stream);
  68 }
  69
  70 static int
  71 compare_lines (const void *mle1p, const void *mle2p)
  72 {
  73   struct dis_line_entry *mle1, *mle2;
  74   int val;
  75
  76   mle1 = (struct dis_line_entry *) mle1p;
  77   mle2 = (struct dis_line_entry *) mle2p;
  78
  79   val = mle1->line - mle2->line;
  80
  81   if (val != 0)
  82     return val;
  83
  84   return mle1->start_pc - mle2->start_pc;
  85 }
  86
  87 static int
  88 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
  89             struct disassemble_info * di,
  90             CORE_ADDR low, CORE_ADDR high,
  91             int how_many, struct ui_stream *stb)
  92 {
  93   int num_displayed = 0;
  94   CORE_ADDR pc;
  95
  96   /* parts of the symbolic representation of the address */
  97   int unmapped;
  98   int offset;
  99   int line;
 100   struct cleanup *ui_out_chain;
 101
 102   for (pc = low; pc < high;)
 103     {
 104       char *filename = NULL;
 105       char *name = NULL;
 106
 107       QUIT;
 108       if (how_many >= 0)
 109         {
 110           if (num_displayed >= how_many)
 111             break;
 112           else
 113             num_displayed++;
 114         }
 115       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 116       ui_out_field_core_addr (uiout, "address", gdbarch, pc);
 117
 118       if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
 119                                    &line, &unmapped))
 120         {
 121           /* We don't care now about line, filename and
 122              unmapped. But we might in the future. */
 123           ui_out_text (uiout, " <");
 124           ui_out_field_string (uiout, "func-name", name);
 125           ui_out_text (uiout, "+");
 126           ui_out_field_int (uiout, "offset", offset);
 127           ui_out_text (uiout, ">:\t");
 128         }
 129       else
 130         ui_out_text (uiout, ":\t");
 131
 132       if (filename != NULL)
 133         xfree (filename);
 134       if (name != NULL)
 135         xfree (name);
 136
 137       ui_file_rewind (stb->stream);
 138       pc += gdbarch_print_insn (gdbarch, pc, di);
 139       ui_out_field_stream (uiout, "inst", stb);
 140       ui_file_rewind (stb->stream);
 141       do_cleanups (ui_out_chain);
 142       ui_out_text (uiout, "\n");
 143     }
 144   return num_displayed;
 145 }
 146
 147 /* The idea here is to present a source-O-centric view of a
 148    function to the user.  This means that things are presented
 149    in source order, with (possibly) out of order assembly
 150    immediately following.  */
 151 static void
 152 do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 153                               struct disassemble_info *di, int nlines,
 154                               struct linetable_entry *le,
 155                               CORE_ADDR low, CORE_ADDR high,
 156                               struct symtab *symtab,
 157                               int how_many, struct ui_stream *stb)
 158 {
 159   int newlines = 0;
 160   struct dis_line_entry *mle;
 161   struct symtab_and_line sal;
 162   int i;
 163   int out_of_order = 0;
 164   int next_line = 0;
 165   CORE_ADDR pc;
 166   int num_displayed = 0;
 167   struct cleanup *ui_out_chain;
 168   struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 169   struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
 170
 171   mle = (struct dis_line_entry *) alloca (nlines
 172                                           * sizeof (struct dis_line_entry));
 173
 174   /* Copy linetable entries for this function into our data
 175      structure, creating end_pc's and setting out_of_order as
 176      appropriate.  */
 177
 178   /* First, skip all the preceding functions.  */
 179
 180   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
 181
 182   /* Now, copy all entries before the end of this function.  */
 183
 184   for (; i < nlines - 1 && le[i].pc < high; i++)
 185     {
 186       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
 187         continue;               /* Ignore duplicates */
 188
 189       /* Skip any end-of-function markers.  */
 190       if (le[i].line == 0)
 191         continue;
 192
 193       mle[newlines].line = le[i].line;
 194       if (le[i].line > le[i + 1].line)
 195         out_of_order = 1;
 196       mle[newlines].start_pc = le[i].pc;
 197       mle[newlines].end_pc = le[i + 1].pc;
 198       newlines++;
 199     }
 200
 201   /* If we're on the last line, and it's part of the function,
 202      then we need to get the end pc in a special way.  */
 203
 204   if (i == nlines - 1 && le[i].pc < high)
 205     {
 206       mle[newlines].line = le[i].line;
 207       mle[newlines].start_pc = le[i].pc;
 208       sal = find_pc_line (le[i].pc, 0);
 209       mle[newlines].end_pc = sal.end;
 210       newlines++;
 211     }
 212
 213   /* Now, sort mle by line #s (and, then by addresses within
 214      lines). */
 215
 216   if (out_of_order)
 217     qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
 218
 219   /* Now, for each line entry, emit the specified lines (unless
 220      they have been emitted before), followed by the assembly code
 221      for that line.  */
 222
 223   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 224
 225   for (i = 0; i < newlines; i++)
 226     {
 227       /* Print out everything from next_line to the current line.  */
 228       if (mle[i].line >= next_line)
 229         {
 230           if (next_line != 0)
 231             {
 232               /* Just one line to print. */
 233               if (next_line == mle[i].line)
 234                 {
 235                   ui_out_tuple_chain
 236                     = make_cleanup_ui_out_tuple_begin_end (uiout,
 237                                                            "src_and_asm_line");
 238                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
 239                 }
 240               else
 241                 {
 242                   /* Several source lines w/o asm instructions associated. */
 243                   for (; next_line < mle[i].line; next_line++)
 244                     {
 245                       struct cleanup *ui_out_list_chain_line;
 246                       struct cleanup *ui_out_tuple_chain_line;
 247
 248                       ui_out_tuple_chain_line
 249                         = make_cleanup_ui_out_tuple_begin_end (uiout,
 250                                                                "src_and_asm_line");
 251                       print_source_lines (symtab, next_line, next_line + 1,
 252                                           0);
 253                       ui_out_list_chain_line
 254                         = make_cleanup_ui_out_list_begin_end (uiout,
 255                                                               "line_asm_insn");
 256                       do_cleanups (ui_out_list_chain_line);
 257                       do_cleanups (ui_out_tuple_chain_line);
 258                     }
 259                   /* Print the last line and leave list open for
 260                      asm instructions to be added. */
 261                   ui_out_tuple_chain
 262                     = make_cleanup_ui_out_tuple_begin_end (uiout,
 263                                                            "src_and_asm_line");
 264                   print_source_lines (symtab, next_line, mle[i].line + 1, 0);
 265                 }
 266             }
 267           else
 268             {
 269               ui_out_tuple_chain
 270                 = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
 271               print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
 272             }
 273
 274           next_line = mle[i].line + 1;
 275           ui_out_list_chain
 276             = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
 277         }
 278
 279       num_displayed += dump_insns (gdbarch, uiout, di,
 280                                    mle[i].start_pc, mle[i].end_pc,
 281                                    how_many, stb);
 282
 283       /* When we've reached the end of the mle array, or we've seen the last
 284          assembly range for this source line, close out the list/tuple.  */
 285       if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
 286         {
 287           do_cleanups (ui_out_list_chain);
 288           do_cleanups (ui_out_tuple_chain);
 289           ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
 290           ui_out_list_chain = make_cleanup (null_cleanup, 0);
 291           ui_out_text (uiout, "\n");
 292         }
 293       if (how_many >= 0 && num_displayed >= how_many)
 294         break;
 295     }
 296   do_cleanups (ui_out_chain);
 297 }
 298
 299
 300 static void
 301 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
 302                   struct disassemble_info * di,
 303                   CORE_ADDR low, CORE_ADDR high,
 304                   int how_many, struct ui_stream *stb)
 305 {
 306   int num_displayed = 0;
 307   struct cleanup *ui_out_chain;
 308
 309   ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
 310
 311   num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, stb);
 312
 313   do_cleanups (ui_out_chain);
 314 }
 315
 316 /* Initialize the disassemble info struct ready for the specified
 317    stream.  */
 318
 319 static int ATTR_FORMAT (printf, 2, 3)
 320 fprintf_disasm (void *stream, const char *format, ...)
 321 {
 322   va_list args;
 323   va_start (args, format);
 324   vfprintf_filtered (stream, format, args);
 325   va_end (args);
 326   /* Something non -ve.  */
 327   return 0;
 328 }
 329
 330 static struct disassemble_info
 331 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
 332 {
 333   struct disassemble_info di;
 334   init_disassemble_info (&di, file, fprintf_disasm);
 335   di.flavour = bfd_target_unknown_flavour;
 336   di.memory_error_func = dis_asm_memory_error;
 337   di.print_address_func = dis_asm_print_address;
 338   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
 339      disassembler had a local optomization here.  By default it would
 340      access the executable file, instead of the target memory (there
 341      was a growing list of exceptions though).  Unfortunately, the
 342      heuristic was flawed.  Commands like "disassemble &variable"
 343      didn't work as they relied on the access going to the target.
 344      Further, it has been supperseeded by trust-read-only-sections
 345      (although that should be superseeded by target_trust..._p()).  */
 346   di.read_memory_func = dis_asm_read_memory;
 347   di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 348   di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 349   di.endian = gdbarch_byte_order (gdbarch);
 350   di.endian_code = gdbarch_byte_order_for_code (gdbarch);
 351   di.application_data = gdbarch;
 352   disassemble_init_for_target (&di);
 353   return di;
 354 }
 355
 356 void
 357 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 358                 char *file_string,
 359                 int mixed_source_and_assembly,
 360                 int how_many, CORE_ADDR low, CORE_ADDR high)
 361 {
 362   struct ui_stream *stb = ui_out_stream_new (uiout);
 363   struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
 364   struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
 365   /* To collect the instruction outputted from opcodes. */
 366   struct symtab *symtab = NULL;
 367   struct linetable_entry *le = NULL;
 368   int nlines = -1;
 369
 370   /* Assume symtab is valid for whole PC range */
 371   symtab = find_pc_symtab (low);
 372
 373   if (symtab != NULL && symtab->linetable != NULL)
 374     {
 375       /* Convert the linetable to a bunch of my_line_entry's.  */
 376       le = symtab->linetable->item;
 377       nlines = symtab->linetable->nitems;
 378     }
 379
 380   if (!mixed_source_and_assembly || nlines <= 0
 381       || symtab == NULL || symtab->linetable == NULL)
 382     do_assembly_only (gdbarch, uiout, &di, low, high, how_many, stb);
 383
 384   else if (mixed_source_and_assembly)
 385     do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
 386                                   high, symtab, how_many, stb);
 387
 388   do_cleanups (cleanups);
 389   gdb_flush (gdb_stdout);
 390 }
 391
 392 /* Print the instruction at address MEMADDR in debugged memory,
 393    on STREAM.  Returns the length of the instruction, in bytes,
 394    and, if requested, the number of branch delay slot instructions.  */
 395
 396 int
 397 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 398                 struct ui_file *stream, int *branch_delay_insns)
 399 {
 400   struct disassemble_info di;
 401   int length;
 402
 403   di = gdb_disassemble_info (gdbarch, stream);
 404   length = gdbarch_print_insn (gdbarch, memaddr, &di);
 405   if (branch_delay_insns)
 406     {
 407       if (di.insn_info_valid)
 408         *branch_delay_insns = di.branch_delay_insns;
 409       else
 410         *branch_delay_insns = 0;
 411     }
 412   return length;
 413 }