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