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