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