gdb/disasm.c

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