gdb/disasm.c

   1 /* Disassemble support for GDB.
   2
   3    Copyright (C) 2000-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "ui-out.h"
  25 #include "disasm.h"
  26 #include "gdbcore.h"
  27 #include "gdbcmd.h"
  28 #include "dis-asm.h"
  29 #include "source.h"
  30 #include "safe-ctype.h"
  31 #include <algorithm>
  32 #include "common/gdb_optional.h"
  33
  34 /* Disassemble functions.
  35    FIXME: We should get rid of all the duplicate code in gdb that does
  36    the same thing: disassemble_command() and the gdbtk variation.  */
  37
  38 /* This variable is used to hold the prospective disassembler_options value
  39    which is set by the "set disassembler_options" command.  */
  40 static char *prospective_options = NULL;
  41
  42 /* This structure is used to store line number information for the
  43    deprecated /m option.
  44    We need a different sort of line table from the normal one cuz we can't
  45    depend upon implicit line-end pc's for lines to do the
  46    reordering in this function.  */
  47
  48 struct deprecated_dis_line_entry
  49 {
  50   int line;
  51   CORE_ADDR start_pc;
  52   CORE_ADDR end_pc;
  53 };
  54
  55 /* This Structure is used to store line number information.
  56    We need a different sort of line table from the normal one cuz we can't
  57    depend upon implicit line-end pc's for lines to do the
  58    reordering in this function.  */
  59
  60 struct dis_line_entry
  61 {
  62   struct symtab *symtab;
  63   int line;
  64 };
  65
  66 /* Hash function for dis_line_entry.  */
  67
  68 static hashval_t
  69 hash_dis_line_entry (const void *item)
  70 {
  71   const struct dis_line_entry *dle = (const struct dis_line_entry *) item;
  72
  73   return htab_hash_pointer (dle->symtab) + dle->line;
  74 }
  75
  76 /* Equal function for dis_line_entry.  */
  77
  78 static int
  79 eq_dis_line_entry (const void *item_lhs, const void *item_rhs)
  80 {
  81   const struct dis_line_entry *lhs = (const struct dis_line_entry *) item_lhs;
  82   const struct dis_line_entry *rhs = (const struct dis_line_entry *) item_rhs;
  83
  84   return (lhs->symtab == rhs->symtab
  85           && lhs->line == rhs->line);
  86 }
  87
  88 /* Create the table to manage lines for mixed source/disassembly.  */
  89
  90 static htab_t
  91 allocate_dis_line_table (void)
  92 {
  93   return htab_create_alloc (41,
  94                             hash_dis_line_entry, eq_dis_line_entry,
  95                             xfree, xcalloc, xfree);
  96 }
  97
  98 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE.  */
  99
 100 static void
 101 add_dis_line_entry (htab_t table, struct symtab *symtab, int line)
 102 {
 103   void **slot;
 104   struct dis_line_entry dle, *dlep;
 105
 106   dle.symtab = symtab;
 107   dle.line = line;
 108   slot = htab_find_slot (table, &dle, INSERT);
 109   if (*slot == NULL)
 110     {
 111       dlep = XNEW (struct dis_line_entry);
 112       dlep->symtab = symtab;
 113       dlep->line = line;
 114       *slot = dlep;
 115     }
 116 }
 117
 118 /* Return non-zero if SYMTAB, LINE are in TABLE.  */
 119
 120 static int
 121 line_has_code_p (htab_t table, struct symtab *symtab, int line)
 122 {
 123   struct dis_line_entry dle;
 124
 125   dle.symtab = symtab;
 126   dle.line = line;
 127   return htab_find (table, &dle) != NULL;
 128 }
 129
 130 /* Wrapper of target_read_code.  */
 131
 132 int
 133 gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr,
 134                                        unsigned int len,
 135                                        struct disassemble_info *info)
 136 {
 137   return target_read_code (memaddr, myaddr, len);
 138 }
 139
 140 /* Wrapper of memory_error.  */
 141
 142 void
 143 gdb_disassembler::dis_asm_memory_error (int err, bfd_vma memaddr,
 144                                         struct disassemble_info *info)
 145 {
 146   gdb_disassembler *self
 147     = static_cast<gdb_disassembler *>(info->application_data);
 148
 149   self->m_err_memaddr = memaddr;
 150 }
 151
 152 /* Wrapper of print_address.  */
 153
 154 void
 155 gdb_disassembler::dis_asm_print_address (bfd_vma addr,
 156                                          struct disassemble_info *info)
 157 {
 158   gdb_disassembler *self
 159     = static_cast<gdb_disassembler *>(info->application_data);
 160
 161   print_address (self->arch (), addr, self->stream ());
 162 }
 163
 164 static int
 165 compare_lines (const void *mle1p, const void *mle2p)
 166 {
 167   struct deprecated_dis_line_entry *mle1, *mle2;
 168   int val;
 169
 170   mle1 = (struct deprecated_dis_line_entry *) mle1p;
 171   mle2 = (struct deprecated_dis_line_entry *) mle2p;
 172
 173   /* End of sequence markers have a line number of 0 but don't want to
 174      be sorted to the head of the list, instead sort by PC.  */
 175   if (mle1->line == 0 || mle2->line == 0)
 176     {
 177       val = mle1->start_pc - mle2->start_pc;
 178       if (val == 0)
 179         val = mle1->line - mle2->line;
 180     }
 181   else
 182     {
 183       val = mle1->line - mle2->line;
 184       if (val == 0)
 185         val = mle1->start_pc - mle2->start_pc;
 186     }
 187   return val;
 188 }
 189
 190 /* See disasm.h.  */
 191
 192 int
 193 gdb_pretty_print_disassembler::pretty_print_insn (struct ui_out *uiout,
 194                                                   const struct disasm_insn *insn,
 195                                                   gdb_disassembly_flags flags)
 196 {
 197   /* parts of the symbolic representation of the address */
 198   int unmapped;
 199   int offset;
 200   int line;
 201   int size;
 202   char *filename = NULL;
 203   char *name = NULL;
 204   CORE_ADDR pc;
 205   struct gdbarch *gdbarch = arch ();
 206
 207   {
 208     ui_out_emit_tuple tuple_emitter (uiout, NULL);
 209     pc = insn->addr;
 210
 211     if (insn->number != 0)
 212       {
 213         uiout->field_fmt ("insn-number", "%u", insn->number);
 214         uiout->text ("\t");
 215       }
 216
 217     if ((flags & DISASSEMBLY_SPECULATIVE) != 0)
 218       {
 219         if (insn->is_speculative)
 220           {
 221             uiout->field_string ("is-speculative", "?");
 222
 223             /* The speculative execution indication overwrites the first
 224                character of the PC prefix.
 225                We assume a PC prefix length of 3 characters.  */
 226             if ((flags & DISASSEMBLY_OMIT_PC) == 0)
 227               uiout->text (pc_prefix (pc) + 1);
 228             else
 229               uiout->text ("  ");
 230           }
 231         else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
 232           uiout->text (pc_prefix (pc));
 233         else
 234           uiout->text ("   ");
 235       }
 236     else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
 237       uiout->text (pc_prefix (pc));
 238     uiout->field_core_addr ("address", gdbarch, pc);
 239
 240     if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
 241                                  &line, &unmapped))
 242       {
 243         /* We don't care now about line, filename and unmapped.  But we might in
 244            the future.  */
 245         uiout->text (" <");
 246         if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
 247           uiout->field_string ("func-name", name);
 248         uiout->text ("+");
 249         uiout->field_int ("offset", offset);
 250         uiout->text (">:\t");
 251       }
 252     else
 253       uiout->text (":\t");
 254
 255     if (filename != NULL)
 256       xfree (filename);
 257     if (name != NULL)
 258       xfree (name);
 259
 260     m_insn_stb.clear ();
 261
 262     if (flags & DISASSEMBLY_RAW_INSN)
 263       {
 264         CORE_ADDR end_pc;
 265         bfd_byte data;
 266         const char *spacer = "";
 267
 268         /* Build the opcodes using a temporary stream so we can
 269            write them out in a single go for the MI.  */
 270         m_opcode_stb.clear ();
 271
 272         size = m_di.print_insn (pc);
 273         end_pc = pc + size;
 274
 275         for (;pc < end_pc; ++pc)
 276           {
 277             read_code (pc, &data, 1);
 278             m_opcode_stb.printf ("%s%02x", spacer, (unsigned) data);
 279             spacer = " ";
 280           }
 281
 282         uiout->field_stream ("opcodes", m_opcode_stb);
 283         uiout->text ("\t");
 284       }
 285     else
 286       size = m_di.print_insn (pc);
 287
 288     uiout->field_stream ("inst", m_insn_stb);
 289   }
 290   uiout->text ("\n");
 291
 292   return size;
 293 }
 294
 295 static int
 296 dump_insns (struct gdbarch *gdbarch,
 297             struct ui_out *uiout, CORE_ADDR low, CORE_ADDR high,
 298             int how_many, gdb_disassembly_flags flags, CORE_ADDR *end_pc)
 299 {
 300   struct disasm_insn insn;
 301   int num_displayed = 0;
 302
 303   memset (&insn, 0, sizeof (insn));
 304   insn.addr = low;
 305
 306   gdb_pretty_print_disassembler disasm (gdbarch);
 307
 308   while (insn.addr < high && (how_many < 0 || num_displayed < how_many))
 309     {
 310       int size;
 311
 312       size = disasm.pretty_print_insn (uiout, &insn, flags);
 313       if (size <= 0)
 314         break;
 315
 316       ++num_displayed;
 317       insn.addr += size;
 318
 319       /* Allow user to bail out with ^C.  */
 320       QUIT;
 321     }
 322
 323   if (end_pc != NULL)
 324     *end_pc = insn.addr;
 325
 326   return num_displayed;
 327 }
 328
 329 /* The idea here is to present a source-O-centric view of a
 330    function to the user.  This means that things are presented
 331    in source order, with (possibly) out of order assembly
 332    immediately following.
 333
 334    N.B. This view is deprecated.  */
 335
 336 static void
 337 do_mixed_source_and_assembly_deprecated
 338   (struct gdbarch *gdbarch, struct ui_out *uiout,
 339    struct symtab *symtab,
 340    CORE_ADDR low, CORE_ADDR high,
 341    int how_many, gdb_disassembly_flags flags)
 342 {
 343   int newlines = 0;
 344   int nlines;
 345   struct linetable_entry *le;
 346   struct deprecated_dis_line_entry *mle;
 347   struct symtab_and_line sal;
 348   int i;
 349   int out_of_order = 0;
 350   int next_line = 0;
 351   int num_displayed = 0;
 352   print_source_lines_flags psl_flags = 0;
 353
 354   gdb_assert (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL);
 355
 356   nlines = SYMTAB_LINETABLE (symtab)->nitems;
 357   le = SYMTAB_LINETABLE (symtab)->item;
 358
 359   if (flags & DISASSEMBLY_FILENAME)
 360     psl_flags |= PRINT_SOURCE_LINES_FILENAME;
 361
 362   mle = (struct deprecated_dis_line_entry *)
 363     alloca (nlines * sizeof (struct deprecated_dis_line_entry));
 364
 365   /* Copy linetable entries for this function into our data
 366      structure, creating end_pc's and setting out_of_order as
 367      appropriate.  */
 368
 369   /* First, skip all the preceding functions.  */
 370
 371   for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
 372
 373   /* Now, copy all entries before the end of this function.  */
 374
 375   for (; i < nlines - 1 && le[i].pc < high; i++)
 376     {
 377       if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
 378         continue;               /* Ignore duplicates.  */
 379
 380       /* Skip any end-of-function markers.  */
 381       if (le[i].line == 0)
 382         continue;
 383
 384       mle[newlines].line = le[i].line;
 385       if (le[i].line > le[i + 1].line)
 386         out_of_order = 1;
 387       mle[newlines].start_pc = le[i].pc;
 388       mle[newlines].end_pc = le[i + 1].pc;
 389       newlines++;
 390     }
 391
 392   /* If we're on the last line, and it's part of the function,
 393      then we need to get the end pc in a special way.  */
 394
 395   if (i == nlines - 1 && le[i].pc < high)
 396     {
 397       mle[newlines].line = le[i].line;
 398       mle[newlines].start_pc = le[i].pc;
 399       sal = find_pc_line (le[i].pc, 0);
 400       mle[newlines].end_pc = sal.end;
 401       newlines++;
 402     }
 403
 404   /* Now, sort mle by line #s (and, then by addresses within lines).  */
 405
 406   if (out_of_order)
 407     qsort (mle, newlines, sizeof (struct deprecated_dis_line_entry),
 408            compare_lines);
 409
 410   /* Now, for each line entry, emit the specified lines (unless
 411      they have been emitted before), followed by the assembly code
 412      for that line.  */
 413
 414   ui_out_emit_list asm_insns_list (uiout, "asm_insns");
 415
 416   gdb::optional<ui_out_emit_tuple> outer_tuple_emitter;
 417   gdb::optional<ui_out_emit_list> inner_list_emitter;
 418
 419   for (i = 0; i < newlines; i++)
 420     {
 421       /* Print out everything from next_line to the current line.  */
 422       if (mle[i].line >= next_line)
 423         {
 424           if (next_line != 0)
 425             {
 426               /* Just one line to print.  */
 427               if (next_line == mle[i].line)
 428                 {
 429                   outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
 430                   print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
 431                 }
 432               else
 433                 {
 434                   /* Several source lines w/o asm instructions associated.  */
 435                   for (; next_line < mle[i].line; next_line++)
 436                     {
 437                       ui_out_emit_tuple tuple_emitter (uiout,
 438                                                        "src_and_asm_line");
 439                       print_source_lines (symtab, next_line, next_line + 1,
 440                                           psl_flags);
 441                       ui_out_emit_list inner_list_emitter (uiout,
 442                                                            "line_asm_insn");
 443                     }
 444                   /* Print the last line and leave list open for
 445                      asm instructions to be added.  */
 446                   outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
 447                   print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
 448                 }
 449             }
 450           else
 451             {
 452               outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
 453               print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
 454             }
 455
 456           next_line = mle[i].line + 1;
 457           inner_list_emitter.emplace (uiout, "line_asm_insn");
 458         }
 459
 460       num_displayed += dump_insns (gdbarch, uiout,
 461                                    mle[i].start_pc, mle[i].end_pc,
 462                                    how_many, flags, NULL);
 463
 464       /* When we've reached the end of the mle array, or we've seen the last
 465          assembly range for this source line, close out the list/tuple.  */
 466       if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
 467         {
 468           inner_list_emitter.reset ();
 469           outer_tuple_emitter.reset ();
 470           uiout->text ("\n");
 471         }
 472       if (how_many >= 0 && num_displayed >= how_many)
 473         break;
 474     }
 475 }
 476
 477 /* The idea here is to present a source-O-centric view of a
 478    function to the user.  This means that things are presented
 479    in source order, with (possibly) out of order assembly
 480    immediately following.  */
 481
 482 static void
 483 do_mixed_source_and_assembly (struct gdbarch *gdbarch,
 484                               struct ui_out *uiout,
 485                               struct symtab *main_symtab,
 486                               CORE_ADDR low, CORE_ADDR high,
 487                               int how_many, gdb_disassembly_flags flags)
 488 {
 489   const struct linetable_entry *le, *first_le;
 490   int i, nlines;
 491   int num_displayed = 0;
 492   print_source_lines_flags psl_flags = 0;
 493   CORE_ADDR pc;
 494   struct symtab *last_symtab;
 495   int last_line;
 496
 497   gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL);
 498
 499   /* First pass: collect the list of all source files and lines.
 500      We do this so that we can only print lines containing code once.
 501      We try to print the source text leading up to the next instruction,
 502      but if that text is for code that will be disassembled later, then
 503      we'll want to defer printing it until later with its associated code.  */
 504
 505   htab_up dis_line_table (allocate_dis_line_table ());
 506
 507   pc = low;
 508
 509   /* The prologue may be empty, but there may still be a line number entry
 510      for the opening brace which is distinct from the first line of code.
 511      If the prologue has been eliminated find_pc_line may return the source
 512      line after the opening brace.  We still want to print this opening brace.
 513      first_le is used to implement this.  */
 514
 515   nlines = SYMTAB_LINETABLE (main_symtab)->nitems;
 516   le = SYMTAB_LINETABLE (main_symtab)->item;
 517   first_le = NULL;
 518
 519   /* Skip all the preceding functions.  */
 520   for (i = 0; i < nlines && le[i].pc < low; i++)
 521     continue;
 522
 523   if (i < nlines && le[i].pc < high)
 524     first_le = &le[i];
 525
 526   /* Add lines for every pc value.  */
 527   while (pc < high)
 528     {
 529       struct symtab_and_line sal;
 530       int length;
 531
 532       sal = find_pc_line (pc, 0);
 533       length = gdb_insn_length (gdbarch, pc);
 534       pc += length;
 535
 536       if (sal.symtab != NULL)
 537         add_dis_line_entry (dis_line_table.get (), sal.symtab, sal.line);
 538     }
 539
 540   /* Second pass: print the disassembly.
 541
 542      Output format, from an MI perspective:
 543        The result is a ui_out list, field name "asm_insns", where elements have
 544        name "src_and_asm_line".
 545        Each element is a tuple of source line specs (field names line, file,
 546        fullname), and field "line_asm_insn" which contains the disassembly.
 547        Field "line_asm_insn" is a list of tuples: address, func-name, offset,
 548        opcodes, inst.
 549
 550      CLI output works on top of this because MI ignores ui_out_text output,
 551      which is where we put file name and source line contents output.
 552
 553      Emitter usage:
 554      asm_insns_emitter
 555        Handles the outer "asm_insns" list.
 556      tuple_emitter
 557        The tuples for each group of consecutive disassemblies.
 558      list_emitter
 559        List of consecutive source lines or disassembled insns.  */
 560
 561   if (flags & DISASSEMBLY_FILENAME)
 562     psl_flags |= PRINT_SOURCE_LINES_FILENAME;
 563
 564   ui_out_emit_list asm_insns_emitter (uiout, "asm_insns");
 565
 566   gdb::optional<ui_out_emit_tuple> tuple_emitter;
 567   gdb::optional<ui_out_emit_list> list_emitter;
 568
 569   last_symtab = NULL;
 570   last_line = 0;
 571   pc = low;
 572
 573   while (pc < high)
 574     {
 575       struct symtab_and_line sal;
 576       CORE_ADDR end_pc;
 577       int start_preceding_line_to_display = 0;
 578       int end_preceding_line_to_display = 0;
 579       int new_source_line = 0;
 580
 581       sal = find_pc_line (pc, 0);
 582
 583       if (sal.symtab != last_symtab)
 584         {
 585           /* New source file.  */
 586           new_source_line = 1;
 587
 588           /* If this is the first line of output, check for any preceding
 589              lines.  */
 590           if (last_line == 0
 591               && first_le != NULL
 592               && first_le->line < sal.line)
 593             {
 594               start_preceding_line_to_display = first_le->line;
 595               end_preceding_line_to_display = sal.line;
 596             }
 597         }
 598       else
 599         {
 600           /* Same source file as last time.  */
 601           if (sal.symtab != NULL)
 602             {
 603               if (sal.line > last_line + 1 && last_line != 0)
 604                 {
 605                   int l;
 606
 607                   /* Several preceding source lines.  Print the trailing ones
 608                      not associated with code that we'll print later.  */
 609                   for (l = sal.line - 1; l > last_line; --l)
 610                     {
 611                       if (line_has_code_p (dis_line_table.get (),
 612                                            sal.symtab, l))
 613                         break;
 614                     }
 615                   if (l < sal.line - 1)
 616                     {
 617                       start_preceding_line_to_display = l + 1;
 618                       end_preceding_line_to_display = sal.line;
 619                     }
 620                 }
 621               if (sal.line != last_line)
 622                 new_source_line = 1;
 623               else
 624                 {
 625                   /* Same source line as last time.  This can happen, depending
 626                      on the debug info.  */
 627                 }
 628             }
 629         }
 630
 631       if (new_source_line)
 632         {
 633           /* Skip the newline if this is the first instruction.  */
 634           if (pc > low)
 635             uiout->text ("\n");
 636           if (tuple_emitter.has_value ())
 637             {
 638               gdb_assert (list_emitter.has_value ());
 639               list_emitter.reset ();
 640               tuple_emitter.reset ();
 641             }
 642           if (sal.symtab != last_symtab
 643               && !(flags & DISASSEMBLY_FILENAME))
 644             {
 645               /* Remember MI ignores ui_out_text.
 646                  We don't have to do anything here for MI because MI
 647                  output includes the source specs for each line.  */
 648               if (sal.symtab != NULL)
 649                 {
 650                   uiout->text (symtab_to_filename_for_display (sal.symtab));
 651                 }
 652               else
 653                 uiout->text ("unknown");
 654               uiout->text (":\n");
 655             }
 656           if (start_preceding_line_to_display > 0)
 657             {
 658               /* Several source lines w/o asm instructions associated.
 659                  We need to preserve the structure of the output, so output
 660                  a bunch of line tuples with no asm entries.  */
 661               int l;
 662
 663               gdb_assert (sal.symtab != NULL);
 664               for (l = start_preceding_line_to_display;
 665                    l < end_preceding_line_to_display;
 666                    ++l)
 667                 {
 668                   ui_out_emit_tuple tuple_emitter (uiout, "src_and_asm_line");
 669                   print_source_lines (sal.symtab, l, l + 1, psl_flags);
 670                   ui_out_emit_list chain_line_emitter (uiout, "line_asm_insn");
 671                 }
 672             }
 673           tuple_emitter.emplace (uiout, "src_and_asm_line");
 674           if (sal.symtab != NULL)
 675             print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags);
 676           else
 677             uiout->text (_("--- no source info for this pc ---\n"));
 678           list_emitter.emplace (uiout, "line_asm_insn");
 679         }
 680       else
 681         {
 682           /* Here we're appending instructions to an existing line.
 683              By construction the very first insn will have a symtab
 684              and follow the new_source_line path above.  */
 685           gdb_assert (tuple_emitter.has_value ());
 686           gdb_assert (list_emitter.has_value ());
 687         }
 688
 689       if (sal.end != 0)
 690         end_pc = std::min (sal.end, high);
 691       else
 692         end_pc = pc + 1;
 693       num_displayed += dump_insns (gdbarch, uiout, pc, end_pc,
 694                                    how_many, flags, &end_pc);
 695       pc = end_pc;
 696
 697       if (how_many >= 0 && num_displayed >= how_many)
 698         break;
 699
 700       last_symtab = sal.symtab;
 701       last_line = sal.line;
 702     }
 703 }
 704
 705 static void
 706 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
 707                   CORE_ADDR low, CORE_ADDR high,
 708                   int how_many, gdb_disassembly_flags flags)
 709 {
 710   ui_out_emit_list list_emitter (uiout, "asm_insns");
 711
 712   dump_insns (gdbarch, uiout, low, high, how_many, flags, NULL);
 713 }
 714
 715 /* Initialize the disassemble info struct ready for the specified
 716    stream.  */
 717
 718 static int ATTRIBUTE_PRINTF (2, 3)
 719 fprintf_disasm (void *stream, const char *format, ...)
 720 {
 721   va_list args;
 722
 723   va_start (args, format);
 724   vfprintf_filtered ((struct ui_file *) stream, format, args);
 725   va_end (args);
 726   /* Something non -ve.  */
 727   return 0;
 728 }
 729
 730 gdb_disassembler::gdb_disassembler (struct gdbarch *gdbarch,
 731                                     struct ui_file *file,
 732                                     di_read_memory_ftype read_memory_func)
 733   : m_gdbarch (gdbarch),
 734     m_err_memaddr (0)
 735 {
 736   init_disassemble_info (&m_di, file, fprintf_disasm);
 737   m_di.flavour = bfd_target_unknown_flavour;
 738   m_di.memory_error_func = dis_asm_memory_error;
 739   m_di.print_address_func = dis_asm_print_address;
 740   /* NOTE: cagney/2003-04-28: The original code, from the old Insight
 741      disassembler had a local optomization here.  By default it would
 742      access the executable file, instead of the target memory (there
 743      was a growing list of exceptions though).  Unfortunately, the
 744      heuristic was flawed.  Commands like "disassemble &variable"
 745      didn't work as they relied on the access going to the target.
 746      Further, it has been supperseeded by trust-read-only-sections
 747      (although that should be superseeded by target_trust..._p()).  */
 748   m_di.read_memory_func = read_memory_func;
 749   m_di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 750   m_di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 751   m_di.endian = gdbarch_byte_order (gdbarch);
 752   m_di.endian_code = gdbarch_byte_order_for_code (gdbarch);
 753   m_di.application_data = this;
 754   m_di.disassembler_options = get_disassembler_options (gdbarch);
 755   disassemble_init_for_target (&m_di);
 756 }
 757
 758 int
 759 gdb_disassembler::print_insn (CORE_ADDR memaddr,
 760                               int *branch_delay_insns)
 761 {
 762   m_err_memaddr = 0;
 763
 764   int length = gdbarch_print_insn (arch (), memaddr, &m_di);
 765
 766   if (length < 0)
 767     memory_error (TARGET_XFER_E_IO, m_err_memaddr);
 768
 769   if (branch_delay_insns != NULL)
 770     {
 771       if (m_di.insn_info_valid)
 772         *branch_delay_insns = m_di.branch_delay_insns;
 773       else
 774         *branch_delay_insns = 0;
 775     }
 776   return length;
 777 }
 778
 779 void
 780 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
 781                  gdb_disassembly_flags flags, int how_many,
 782                  CORE_ADDR low, CORE_ADDR high)
 783 {
 784   struct symtab *symtab;
 785   int nlines = -1;
 786
 787   /* Assume symtab is valid for whole PC range.  */
 788   symtab = find_pc_line_symtab (low);
 789
 790   if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
 791     nlines = SYMTAB_LINETABLE (symtab)->nitems;
 792
 793   if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
 794       || nlines <= 0)
 795     do_assembly_only (gdbarch, uiout, low, high, how_many, flags);
 796
 797   else if (flags & DISASSEMBLY_SOURCE)
 798     do_mixed_source_and_assembly (gdbarch, uiout, symtab, low, high,
 799                                   how_many, flags);
 800
 801   else if (flags & DISASSEMBLY_SOURCE_DEPRECATED)
 802     do_mixed_source_and_assembly_deprecated (gdbarch, uiout, symtab,
 803                                              low, high, how_many, flags);
 804
 805   gdb_flush (gdb_stdout);
 806 }
 807
 808 /* Print the instruction at address MEMADDR in debugged memory,
 809    on STREAM.  Returns the length of the instruction, in bytes,
 810    and, if requested, the number of branch delay slot instructions.  */
 811
 812 int
 813 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 814                 struct ui_file *stream, int *branch_delay_insns)
 815 {
 816
 817   gdb_disassembler di (gdbarch, stream);
 818
 819   return di.print_insn (memaddr, branch_delay_insns);
 820 }
 821
 822 /* Return the length in bytes of the instruction at address MEMADDR in
 823    debugged memory.  */
 824
 825 int
 826 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
 827 {
 828   return gdb_print_insn (gdbarch, addr, &null_stream, NULL);
 829 }
 830
 831 /* fprintf-function for gdb_buffered_insn_length.  This function is a
 832    nop, we don't want to print anything, we just want to compute the
 833    length of the insn.  */
 834
 835 static int ATTRIBUTE_PRINTF (2, 3)
 836 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
 837 {
 838   return 0;
 839 }
 840
 841 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.  */
 842
 843 static void
 844 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
 845                                    struct disassemble_info *di,
 846                                    const gdb_byte *insn, int max_len,
 847                                    CORE_ADDR addr)
 848 {
 849   init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
 850
 851   /* init_disassemble_info installs buffer_read_memory, etc.
 852      so we don't need to do that here.
 853      The cast is necessary until disassemble_info is const-ified.  */
 854   di->buffer = (gdb_byte *) insn;
 855   di->buffer_length = max_len;
 856   di->buffer_vma = addr;
 857
 858   di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
 859   di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
 860   di->endian = gdbarch_byte_order (gdbarch);
 861   di->endian_code = gdbarch_byte_order_for_code (gdbarch);
 862
 863   di->disassembler_options = get_disassembler_options (gdbarch);
 864   disassemble_init_for_target (di);
 865 }
 866
 867 /* Return the length in bytes of INSN.  MAX_LEN is the size of the
 868    buffer containing INSN.  */
 869
 870 int
 871 gdb_buffered_insn_length (struct gdbarch *gdbarch,
 872                           const gdb_byte *insn, int max_len, CORE_ADDR addr)
 873 {
 874   struct disassemble_info di;
 875
 876   gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
 877
 878   return gdbarch_print_insn (gdbarch, addr, &di);
 879 }
 880
 881 char *
 882 get_disassembler_options (struct gdbarch *gdbarch)
 883 {
 884   char **disassembler_options = gdbarch_disassembler_options (gdbarch);
 885   if (disassembler_options == NULL)
 886     return NULL;
 887   return *disassembler_options;
 888 }
 889
 890 void
 891 set_disassembler_options (char *prospective_options)
 892 {
 893   struct gdbarch *gdbarch = get_current_arch ();
 894   char **disassembler_options = gdbarch_disassembler_options (gdbarch);
 895   const disasm_options_t *valid_options;
 896   char *options = remove_whitespace_and_extra_commas (prospective_options);
 897   const char *opt;
 898
 899   /* Allow all architectures, even ones that do not support 'set disassembler',
 900      to reset their disassembler options to NULL.  */
 901   if (options == NULL)
 902     {
 903       if (disassembler_options != NULL)
 904         {
 905           free (*disassembler_options);
 906           *disassembler_options = NULL;
 907         }
 908       return;
 909     }
 910
 911   valid_options = gdbarch_valid_disassembler_options (gdbarch);
 912   if (valid_options  == NULL)
 913     {
 914       fprintf_filtered (gdb_stdlog, _("\
 915 'set disassembler-options ...' is not supported on this architecture.\n"));
 916       return;
 917     }
 918
 919   /* Verify we have valid disassembler options.  */
 920   FOR_EACH_DISASSEMBLER_OPTION (opt, options)
 921     {
 922       size_t i;
 923       for (i = 0; valid_options->name[i] != NULL; i++)
 924         if (disassembler_options_cmp (opt, valid_options->name[i]) == 0)
 925           break;
 926       if (valid_options->name[i] == NULL)
 927         {
 928           fprintf_filtered (gdb_stdlog,
 929                             _("Invalid disassembler option value: '%s'.\n"),
 930                             opt);
 931           return;
 932         }
 933     }
 934
 935   free (*disassembler_options);
 936   *disassembler_options = xstrdup (options);
 937 }
 938
 939 static void
 940 set_disassembler_options_sfunc (const char *args, int from_tty,
 941                                 struct cmd_list_element *c)
 942 {
 943   set_disassembler_options (prospective_options);
 944 }
 945
 946 static void
 947 show_disassembler_options_sfunc (struct ui_file *file, int from_tty,
 948                                  struct cmd_list_element *c, const char *value)
 949 {
 950   struct gdbarch *gdbarch = get_current_arch ();
 951   const disasm_options_t *valid_options;
 952
 953   const char *options = get_disassembler_options (gdbarch);
 954   if (options == NULL)
 955     options = "";
 956
 957   fprintf_filtered (file, _("The current disassembler options are '%s'\n"),
 958                     options);
 959
 960   valid_options = gdbarch_valid_disassembler_options (gdbarch);
 961
 962   if (valid_options == NULL)
 963     return;
 964
 965   fprintf_filtered (file, _("\n\
 966 The following disassembler options are supported for use with the\n\
 967 'set disassembler-options <option>[,<option>...]' command:\n"));
 968
 969   if (valid_options->description != NULL)
 970     {
 971       size_t i, max_len = 0;
 972
 973       /* Compute the length of the longest option name.  */
 974       for (i = 0; valid_options->name[i] != NULL; i++)
 975         {
 976           size_t len = strlen (valid_options->name[i]);
 977           if (max_len < len)
 978             max_len = len;
 979         }
 980
 981       for (i = 0, max_len++; valid_options->name[i] != NULL; i++)
 982         {
 983           fprintf_filtered (file, "  %s", valid_options->name[i]);
 984           if (valid_options->description[i] != NULL)
 985             fprintf_filtered (file, "%*c %s",
 986                               (int)(max_len - strlen (valid_options->name[i])), ' ',
 987                               valid_options->description[i]);
 988           fprintf_filtered (file, "\n");
 989         }
 990     }
 991   else
 992     {
 993       size_t i;
 994       fprintf_filtered (file, "  ");
 995       for (i = 0; valid_options->name[i] != NULL; i++)
 996         {
 997           fprintf_filtered (file, "%s", valid_options->name[i]);
 998           if (valid_options->name[i + 1] != NULL)
 999             fprintf_filtered (file, ", ");
1000           wrap_here ("  ");
1001         }
1002       fprintf_filtered (file, "\n");
1003     }
1004 }
1005
1006 /* A completion function for "set disassembler".  */
1007
1008 static void
1009 disassembler_options_completer (struct cmd_list_element *ignore,
1010                                 completion_tracker &tracker,
1011                                 const char *text, const char *word)
1012 {
1013   struct gdbarch *gdbarch = get_current_arch ();
1014   const disasm_options_t *opts = gdbarch_valid_disassembler_options (gdbarch);
1015
1016   if (opts != NULL)
1017     {
1018       /* Only attempt to complete on the last option text.  */
1019       const char *separator = strrchr (text, ',');
1020       if (separator != NULL)
1021         text = separator + 1;
1022       text = skip_spaces (text);
1023       complete_on_enum (tracker, opts->name, text, word);
1024     }
1025 }
1026
1027
1028 /* Initialization code.  */
1029
1030 void
1031 _initialize_disasm (void)
1032 {
1033   struct cmd_list_element *cmd;
1034
1035   /* Add the command that controls the disassembler options.  */
1036   cmd = add_setshow_string_noescape_cmd ("disassembler-options", no_class,
1037                                          &prospective_options, _("\
1038 Set the disassembler options.\n\
1039 Usage: set disassembler-options <option>[,<option>...]\n\n\
1040 See: 'show disassembler-options' for valid option values.\n"), _("\
1041 Show the disassembler options."), NULL,
1042                                          set_disassembler_options_sfunc,
1043                                          show_disassembler_options_sfunc,
1044                                          &setlist, &showlist);
1045   set_cmd_completer (cmd, disassembler_options_completer);
1046 }