1 /* Print values for GNU debugger GDB. 2 3 Copyright (C) 1986-2019 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 "frame.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "value.h" 25 #include "language.h" 26 #include "expression.h" 27 #include "gdbcore.h" 28 #include "gdbcmd.h" 29 #include "target.h" 30 #include "breakpoint.h" 31 #include "demangle.h" 32 #include "gdb-demangle.h" 33 #include "valprint.h" 34 #include "annotate.h" 35 #include "symfile.h" /* for overlay functions */ 36 #include "objfiles.h" /* ditto */ 37 #include "completer.h" /* for completion functions */ 38 #include "ui-out.h" 39 #include "block.h" 40 #include "disasm.h" 41 #include "target-float.h" 42 #include "observable.h" 43 #include "solist.h" 44 #include "parser-defs.h" 45 #include "charset.h" 46 #include "arch-utils.h" 47 #include "cli/cli-utils.h" 48 #include "cli/cli-script.h" 49 #include "cli/cli-style.h" 50 #include "common/format.h" 51 #include "source.h" 52 #include "common/byte-vector.h" 53 54 /* Last specified output format. */ 55 56 static char last_format = 0; 57 58 /* Last specified examination size. 'b', 'h', 'w' or `q'. */ 59 60 static char last_size = 'w'; 61 62 /* Last specified count for the 'x' command. */ 63 64 static int last_count; 65 66 /* Default address to examine next, and associated architecture. */ 67 68 static struct gdbarch *next_gdbarch; 69 static CORE_ADDR next_address; 70 71 /* Number of delay instructions following current disassembled insn. */ 72 73 static int branch_delay_insns; 74 75 /* Last address examined. */ 76 77 static CORE_ADDR last_examine_address; 78 79 /* Contents of last address examined. 80 This is not valid past the end of the `x' command! */ 81 82 static value_ref_ptr last_examine_value; 83 84 /* Largest offset between a symbolic value and an address, that will be 85 printed as `0x1234 <symbol+offset>'. */ 86 87 static unsigned int max_symbolic_offset = UINT_MAX; 88 static void 89 show_max_symbolic_offset (struct ui_file *file, int from_tty, 90 struct cmd_list_element *c, const char *value) 91 { 92 fprintf_filtered (file, 93 _("The largest offset that will be " 94 "printed in <symbol+1234> form is %s.\n"), 95 value); 96 } 97 98 /* Append the source filename and linenumber of the symbol when 99 printing a symbolic value as `<symbol at filename:linenum>' if set. */ 100 static int print_symbol_filename = 0; 101 static void 102 show_print_symbol_filename (struct ui_file *file, int from_tty, 103 struct cmd_list_element *c, const char *value) 104 { 105 fprintf_filtered (file, _("Printing of source filename and " 106 "line number with <symbol> is %s.\n"), 107 value); 108 } 109 110 /* Number of auto-display expression currently being displayed. 111 So that we can disable it if we get a signal within it. 112 -1 when not doing one. */ 113 114 static int current_display_number; 115 116 struct display 117 { 118 /* Chain link to next auto-display item. */ 119 struct display *next; 120 121 /* The expression as the user typed it. */ 122 char *exp_string; 123 124 /* Expression to be evaluated and displayed. */ 125 expression_up exp; 126 127 /* Item number of this auto-display item. */ 128 int number; 129 130 /* Display format specified. */ 131 struct format_data format; 132 133 /* Program space associated with `block'. */ 134 struct program_space *pspace; 135 136 /* Innermost block required by this expression when evaluated. */ 137 const struct block *block; 138 139 /* Status of this display (enabled or disabled). */ 140 int enabled_p; 141 }; 142 143 /* Chain of expressions whose values should be displayed 144 automatically each time the program stops. */ 145 146 static struct display *display_chain; 147 148 static int display_number; 149 150 /* Walk the following statement or block through all displays. 151 ALL_DISPLAYS_SAFE does so even if the statement deletes the current 152 display. */ 153 154 #define ALL_DISPLAYS(B) \ 155 for (B = display_chain; B; B = B->next) 156 157 #define ALL_DISPLAYS_SAFE(B,TMP) \ 158 for (B = display_chain; \ 159 B ? (TMP = B->next, 1): 0; \ 160 B = TMP) 161 162 /* Prototypes for local functions. */ 163 164 static void do_one_display (struct display *); 165 166 167 /* Decode a format specification. *STRING_PTR should point to it. 168 OFORMAT and OSIZE are used as defaults for the format and size 169 if none are given in the format specification. 170 If OSIZE is zero, then the size field of the returned value 171 should be set only if a size is explicitly specified by the 172 user. 173 The structure returned describes all the data 174 found in the specification. In addition, *STRING_PTR is advanced 175 past the specification and past all whitespace following it. */ 176 177 static struct format_data 178 decode_format (const char **string_ptr, int oformat, int osize) 179 { 180 struct format_data val; 181 const char *p = *string_ptr; 182 183 val.format = '?'; 184 val.size = '?'; 185 val.count = 1; 186 val.raw = 0; 187 188 if (*p == '-') 189 { 190 val.count = -1; 191 p++; 192 } 193 if (*p >= '0' && *p <= '9') 194 val.count *= atoi (p); 195 while (*p >= '0' && *p <= '9') 196 p++; 197 198 /* Now process size or format letters that follow. */ 199 200 while (1) 201 { 202 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g') 203 val.size = *p++; 204 else if (*p == 'r') 205 { 206 val.raw = 1; 207 p++; 208 } 209 else if (*p >= 'a' && *p <= 'z') 210 val.format = *p++; 211 else 212 break; 213 } 214 215 *string_ptr = skip_spaces (p); 216 217 /* Set defaults for format and size if not specified. */ 218 if (val.format == '?') 219 { 220 if (val.size == '?') 221 { 222 /* Neither has been specified. */ 223 val.format = oformat; 224 val.size = osize; 225 } 226 else 227 /* If a size is specified, any format makes a reasonable 228 default except 'i'. */ 229 val.format = oformat == 'i' ? 'x' : oformat; 230 } 231 else if (val.size == '?') 232 switch (val.format) 233 { 234 case 'a': 235 /* Pick the appropriate size for an address. This is deferred 236 until do_examine when we know the actual architecture to use. 237 A special size value of 'a' is used to indicate this case. */ 238 val.size = osize ? 'a' : osize; 239 break; 240 case 'f': 241 /* Floating point has to be word or giantword. */ 242 if (osize == 'w' || osize == 'g') 243 val.size = osize; 244 else 245 /* Default it to giantword if the last used size is not 246 appropriate. */ 247 val.size = osize ? 'g' : osize; 248 break; 249 case 'c': 250 /* Characters default to one byte. */ 251 val.size = osize ? 'b' : osize; 252 break; 253 case 's': 254 /* Display strings with byte size chars unless explicitly 255 specified. */ 256 val.size = '\0'; 257 break; 258 259 default: 260 /* The default is the size most recently specified. */ 261 val.size = osize; 262 } 263 264 return val; 265 } 266 267 /* Print value VAL on stream according to OPTIONS. 268 Do not end with a newline. 269 SIZE is the letter for the size of datum being printed. 270 This is used to pad hex numbers so they line up. SIZE is 0 271 for print / output and set for examine. */ 272 273 static void 274 print_formatted (struct value *val, int size, 275 const struct value_print_options *options, 276 struct ui_file *stream) 277 { 278 struct type *type = check_typedef (value_type (val)); 279 int len = TYPE_LENGTH (type); 280 281 if (VALUE_LVAL (val) == lval_memory) 282 next_address = value_address (val) + len; 283 284 if (size) 285 { 286 switch (options->format) 287 { 288 case 's': 289 { 290 struct type *elttype = value_type (val); 291 292 next_address = (value_address (val) 293 + val_print_string (elttype, NULL, 294 value_address (val), -1, 295 stream, options) * len); 296 } 297 return; 298 299 case 'i': 300 /* We often wrap here if there are long symbolic names. */ 301 wrap_here (" "); 302 next_address = (value_address (val) 303 + gdb_print_insn (get_type_arch (type), 304 value_address (val), stream, 305 &branch_delay_insns)); 306 return; 307 } 308 } 309 310 if (options->format == 0 || options->format == 's' 311 || TYPE_CODE (type) == TYPE_CODE_REF 312 || TYPE_CODE (type) == TYPE_CODE_ARRAY 313 || TYPE_CODE (type) == TYPE_CODE_STRING 314 || TYPE_CODE (type) == TYPE_CODE_STRUCT 315 || TYPE_CODE (type) == TYPE_CODE_UNION 316 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) 317 value_print (val, stream, options); 318 else 319 /* User specified format, so don't look to the type to tell us 320 what to do. */ 321 val_print_scalar_formatted (type, 322 value_embedded_offset (val), 323 val, 324 options, size, stream); 325 } 326 327 /* Return builtin floating point type of same length as TYPE. 328 If no such type is found, return TYPE itself. */ 329 static struct type * 330 float_type_from_length (struct type *type) 331 { 332 struct gdbarch *gdbarch = get_type_arch (type); 333 const struct builtin_type *builtin = builtin_type (gdbarch); 334 335 if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float)) 336 type = builtin->builtin_float; 337 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double)) 338 type = builtin->builtin_double; 339 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double)) 340 type = builtin->builtin_long_double; 341 342 return type; 343 } 344 345 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, 346 according to OPTIONS and SIZE on STREAM. Formats s and i are not 347 supported at this level. */ 348 349 void 350 print_scalar_formatted (const gdb_byte *valaddr, struct type *type, 351 const struct value_print_options *options, 352 int size, struct ui_file *stream) 353 { 354 struct gdbarch *gdbarch = get_type_arch (type); 355 unsigned int len = TYPE_LENGTH (type); 356 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 357 358 /* String printing should go through val_print_scalar_formatted. */ 359 gdb_assert (options->format != 's'); 360 361 /* If the value is a pointer, and pointers and addresses are not the 362 same, then at this point, the value's length (in target bytes) is 363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */ 364 if (TYPE_CODE (type) == TYPE_CODE_PTR) 365 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT; 366 367 /* If we are printing it as unsigned, truncate it in case it is actually 368 a negative signed value (e.g. "print/u (short)-1" should print 65535 369 (if shorts are 16 bits) instead of 4294967295). */ 370 if (options->format != 'c' 371 && (options->format != 'd' || TYPE_UNSIGNED (type))) 372 { 373 if (len < TYPE_LENGTH (type) && byte_order == BFD_ENDIAN_BIG) 374 valaddr += TYPE_LENGTH (type) - len; 375 } 376 377 if (size != 0 && (options->format == 'x' || options->format == 't')) 378 { 379 /* Truncate to fit. */ 380 unsigned newlen; 381 switch (size) 382 { 383 case 'b': 384 newlen = 1; 385 break; 386 case 'h': 387 newlen = 2; 388 break; 389 case 'w': 390 newlen = 4; 391 break; 392 case 'g': 393 newlen = 8; 394 break; 395 default: 396 error (_("Undefined output size \"%c\"."), size); 397 } 398 if (newlen < len && byte_order == BFD_ENDIAN_BIG) 399 valaddr += len - newlen; 400 len = newlen; 401 } 402 403 /* Historically gdb has printed floats by first casting them to a 404 long, and then printing the long. PR cli/16242 suggests changing 405 this to using C-style hex float format. */ 406 gdb::byte_vector converted_float_bytes; 407 if (TYPE_CODE (type) == TYPE_CODE_FLT 408 && (options->format == 'o' 409 || options->format == 'x' 410 || options->format == 't' 411 || options->format == 'z' 412 || options->format == 'd' 413 || options->format == 'u')) 414 { 415 LONGEST val_long = unpack_long (type, valaddr); 416 converted_float_bytes.resize (TYPE_LENGTH (type)); 417 store_signed_integer (converted_float_bytes.data (), TYPE_LENGTH (type), 418 byte_order, val_long); 419 valaddr = converted_float_bytes.data (); 420 } 421 422 /* Printing a non-float type as 'f' will interpret the data as if it were 423 of a floating-point type of the same length, if that exists. Otherwise, 424 the data is printed as integer. */ 425 char format = options->format; 426 if (format == 'f' && TYPE_CODE (type) != TYPE_CODE_FLT) 427 { 428 type = float_type_from_length (type); 429 if (TYPE_CODE (type) != TYPE_CODE_FLT) 430 format = 0; 431 } 432 433 switch (format) 434 { 435 case 'o': 436 print_octal_chars (stream, valaddr, len, byte_order); 437 break; 438 case 'd': 439 print_decimal_chars (stream, valaddr, len, true, byte_order); 440 break; 441 case 'u': 442 print_decimal_chars (stream, valaddr, len, false, byte_order); 443 break; 444 case 0: 445 if (TYPE_CODE (type) != TYPE_CODE_FLT) 446 { 447 print_decimal_chars (stream, valaddr, len, !TYPE_UNSIGNED (type), 448 byte_order); 449 break; 450 } 451 /* FALLTHROUGH */ 452 case 'f': 453 print_floating (valaddr, type, stream); 454 break; 455 456 case 't': 457 print_binary_chars (stream, valaddr, len, byte_order, size > 0); 458 break; 459 case 'x': 460 print_hex_chars (stream, valaddr, len, byte_order, size > 0); 461 break; 462 case 'z': 463 print_hex_chars (stream, valaddr, len, byte_order, true); 464 break; 465 case 'c': 466 { 467 struct value_print_options opts = *options; 468 469 LONGEST val_long = unpack_long (type, valaddr); 470 471 opts.format = 0; 472 if (TYPE_UNSIGNED (type)) 473 type = builtin_type (gdbarch)->builtin_true_unsigned_char; 474 else 475 type = builtin_type (gdbarch)->builtin_true_char; 476 477 value_print (value_from_longest (type, val_long), stream, &opts); 478 } 479 break; 480 481 case 'a': 482 { 483 CORE_ADDR addr = unpack_pointer (type, valaddr); 484 485 print_address (gdbarch, addr, stream); 486 } 487 break; 488 489 default: 490 error (_("Undefined output format \"%c\"."), format); 491 } 492 } 493 494 /* Specify default address for `x' command. 495 The `info lines' command uses this. */ 496 497 void 498 set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr) 499 { 500 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 501 502 next_gdbarch = gdbarch; 503 next_address = addr; 504 505 /* Make address available to the user as $_. */ 506 set_internalvar (lookup_internalvar ("_"), 507 value_from_pointer (ptr_type, addr)); 508 } 509 510 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM, 511 after LEADIN. Print nothing if no symbolic name is found nearby. 512 Optionally also print source file and line number, if available. 513 DO_DEMANGLE controls whether to print a symbol in its native "raw" form, 514 or to interpret it as a possible C++ name and convert it back to source 515 form. However note that DO_DEMANGLE can be overridden by the specific 516 settings of the demangle and asm_demangle variables. Returns 517 non-zero if anything was printed; zero otherwise. */ 518 519 int 520 print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr, 521 struct ui_file *stream, 522 int do_demangle, const char *leadin) 523 { 524 std::string name, filename; 525 int unmapped = 0; 526 int offset = 0; 527 int line = 0; 528 529 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset, 530 &filename, &line, &unmapped)) 531 return 0; 532 533 fputs_filtered (leadin, stream); 534 if (unmapped) 535 fputs_filtered ("<*", stream); 536 else 537 fputs_filtered ("<", stream); 538 fputs_styled (name.c_str (), function_name_style.style (), stream); 539 if (offset != 0) 540 fprintf_filtered (stream, "+%u", (unsigned int) offset); 541 542 /* Append source filename and line number if desired. Give specific 543 line # of this addr, if we have it; else line # of the nearest symbol. */ 544 if (print_symbol_filename && !filename.empty ()) 545 { 546 fputs_filtered (line == -1 ? " in " : " at ", stream); 547 fputs_styled (filename.c_str (), file_name_style.style (), stream); 548 if (line != -1) 549 fprintf_filtered (stream, ":%d", line); 550 } 551 if (unmapped) 552 fputs_filtered ("*>", stream); 553 else 554 fputs_filtered (">", stream); 555 556 return 1; 557 } 558 559 /* See valprint.h. */ 560 561 int 562 build_address_symbolic (struct gdbarch *gdbarch, 563 CORE_ADDR addr, /* IN */ 564 int do_demangle, /* IN */ 565 std::string *name, /* OUT */ 566 int *offset, /* OUT */ 567 std::string *filename, /* OUT */ 568 int *line, /* OUT */ 569 int *unmapped) /* OUT */ 570 { 571 struct bound_minimal_symbol msymbol; 572 struct symbol *symbol; 573 CORE_ADDR name_location = 0; 574 struct obj_section *section = NULL; 575 const char *name_temp = ""; 576 577 /* Let's say it is mapped (not unmapped). */ 578 *unmapped = 0; 579 580 /* Determine if the address is in an overlay, and whether it is 581 mapped. */ 582 if (overlay_debugging) 583 { 584 section = find_pc_overlay (addr); 585 if (pc_in_unmapped_range (addr, section)) 586 { 587 *unmapped = 1; 588 addr = overlay_mapped_address (addr, section); 589 } 590 } 591 592 /* First try to find the address in the symbol table, then 593 in the minsyms. Take the closest one. */ 594 595 /* This is defective in the sense that it only finds text symbols. So 596 really this is kind of pointless--we should make sure that the 597 minimal symbols have everything we need (by changing that we could 598 save some memory, but for many debug format--ELF/DWARF or 599 anything/stabs--it would be inconvenient to eliminate those minimal 600 symbols anyway). */ 601 msymbol = lookup_minimal_symbol_by_pc_section (addr, section); 602 symbol = find_pc_sect_function (addr, section); 603 604 if (symbol) 605 { 606 /* If this is a function (i.e. a code address), strip out any 607 non-address bits. For instance, display a pointer to the 608 first instruction of a Thumb function as <function>; the 609 second instruction will be <function+2>, even though the 610 pointer is <function+3>. This matches the ISA behavior. */ 611 addr = gdbarch_addr_bits_remove (gdbarch, addr); 612 613 name_location = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol)); 614 if (do_demangle || asm_demangle) 615 name_temp = SYMBOL_PRINT_NAME (symbol); 616 else 617 name_temp = SYMBOL_LINKAGE_NAME (symbol); 618 } 619 620 if (msymbol.minsym != NULL 621 && MSYMBOL_HAS_SIZE (msymbol.minsym) 622 && MSYMBOL_SIZE (msymbol.minsym) == 0 623 && MSYMBOL_TYPE (msymbol.minsym) != mst_text 624 && MSYMBOL_TYPE (msymbol.minsym) != mst_text_gnu_ifunc 625 && MSYMBOL_TYPE (msymbol.minsym) != mst_file_text) 626 msymbol.minsym = NULL; 627 628 if (msymbol.minsym != NULL) 629 { 630 if (BMSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL) 631 { 632 /* If this is a function (i.e. a code address), strip out any 633 non-address bits. For instance, display a pointer to the 634 first instruction of a Thumb function as <function>; the 635 second instruction will be <function+2>, even though the 636 pointer is <function+3>. This matches the ISA behavior. */ 637 if (MSYMBOL_TYPE (msymbol.minsym) == mst_text 638 || MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc 639 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_text 640 || MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline) 641 addr = gdbarch_addr_bits_remove (gdbarch, addr); 642 643 /* The msymbol is closer to the address than the symbol; 644 use the msymbol instead. */ 645 symbol = 0; 646 name_location = BMSYMBOL_VALUE_ADDRESS (msymbol); 647 if (do_demangle || asm_demangle) 648 name_temp = MSYMBOL_PRINT_NAME (msymbol.minsym); 649 else 650 name_temp = MSYMBOL_LINKAGE_NAME (msymbol.minsym); 651 } 652 } 653 if (symbol == NULL && msymbol.minsym == NULL) 654 return 1; 655 656 /* If the nearest symbol is too far away, don't print anything symbolic. */ 657 658 /* For when CORE_ADDR is larger than unsigned int, we do math in 659 CORE_ADDR. But when we detect unsigned wraparound in the 660 CORE_ADDR math, we ignore this test and print the offset, 661 because addr+max_symbolic_offset has wrapped through the end 662 of the address space back to the beginning, giving bogus comparison. */ 663 if (addr > name_location + max_symbolic_offset 664 && name_location + max_symbolic_offset > name_location) 665 return 1; 666 667 *offset = addr - name_location; 668 669 *name = name_temp; 670 671 if (print_symbol_filename) 672 { 673 struct symtab_and_line sal; 674 675 sal = find_pc_sect_line (addr, section, 0); 676 677 if (sal.symtab) 678 { 679 *filename = symtab_to_filename_for_display (sal.symtab); 680 *line = sal.line; 681 } 682 } 683 return 0; 684 } 685 686 687 /* Print address ADDR symbolically on STREAM. 688 First print it as a number. Then perhaps print 689 <SYMBOL + OFFSET> after the number. */ 690 691 void 692 print_address (struct gdbarch *gdbarch, 693 CORE_ADDR addr, struct ui_file *stream) 694 { 695 fputs_styled (paddress (gdbarch, addr), address_style.style (), stream); 696 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " "); 697 } 698 699 /* Return a prefix for instruction address: 700 "=> " for current instruction, else " ". */ 701 702 const char * 703 pc_prefix (CORE_ADDR addr) 704 { 705 if (has_stack_frames ()) 706 { 707 struct frame_info *frame; 708 CORE_ADDR pc; 709 710 frame = get_selected_frame (NULL); 711 if (get_frame_pc_if_available (frame, &pc) && pc == addr) 712 return "=> "; 713 } 714 return " "; 715 } 716 717 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE 718 controls whether to print the symbolic name "raw" or demangled. 719 Return non-zero if anything was printed; zero otherwise. */ 720 721 int 722 print_address_demangle (const struct value_print_options *opts, 723 struct gdbarch *gdbarch, CORE_ADDR addr, 724 struct ui_file *stream, int do_demangle) 725 { 726 if (opts->addressprint) 727 { 728 fputs_styled (paddress (gdbarch, addr), address_style.style (), stream); 729 print_address_symbolic (gdbarch, addr, stream, do_demangle, " "); 730 } 731 else 732 { 733 return print_address_symbolic (gdbarch, addr, stream, do_demangle, ""); 734 } 735 return 1; 736 } 737 738 739 /* Find the address of the instruction that is INST_COUNT instructions before 740 the instruction at ADDR. 741 Since some architectures have variable-length instructions, we can't just 742 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line 743 number information to locate the nearest known instruction boundary, 744 and disassemble forward from there. If we go out of the symbol range 745 during disassembling, we return the lowest address we've got so far and 746 set the number of instructions read to INST_READ. */ 747 748 static CORE_ADDR 749 find_instruction_backward (struct gdbarch *gdbarch, CORE_ADDR addr, 750 int inst_count, int *inst_read) 751 { 752 /* The vector PCS is used to store instruction addresses within 753 a pc range. */ 754 CORE_ADDR loop_start, loop_end, p; 755 std::vector<CORE_ADDR> pcs; 756 struct symtab_and_line sal; 757 758 *inst_read = 0; 759 loop_start = loop_end = addr; 760 761 /* In each iteration of the outer loop, we get a pc range that ends before 762 LOOP_START, then we count and store every instruction address of the range 763 iterated in the loop. 764 If the number of instructions counted reaches INST_COUNT, return the 765 stored address that is located INST_COUNT instructions back from ADDR. 766 If INST_COUNT is not reached, we subtract the number of counted 767 instructions from INST_COUNT, and go to the next iteration. */ 768 do 769 { 770 pcs.clear (); 771 sal = find_pc_sect_line (loop_start, NULL, 1); 772 if (sal.line <= 0) 773 { 774 /* We reach here when line info is not available. In this case, 775 we print a message and just exit the loop. The return value 776 is calculated after the loop. */ 777 printf_filtered (_("No line number information available " 778 "for address ")); 779 wrap_here (" "); 780 print_address (gdbarch, loop_start - 1, gdb_stdout); 781 printf_filtered ("\n"); 782 break; 783 } 784 785 loop_end = loop_start; 786 loop_start = sal.pc; 787 788 /* This loop pushes instruction addresses in the range from 789 LOOP_START to LOOP_END. */ 790 for (p = loop_start; p < loop_end;) 791 { 792 pcs.push_back (p); 793 p += gdb_insn_length (gdbarch, p); 794 } 795 796 inst_count -= pcs.size (); 797 *inst_read += pcs.size (); 798 } 799 while (inst_count > 0); 800 801 /* After the loop, the vector PCS has instruction addresses of the last 802 source line we processed, and INST_COUNT has a negative value. 803 We return the address at the index of -INST_COUNT in the vector for 804 the reason below. 805 Let's assume the following instruction addresses and run 'x/-4i 0x400e'. 806 Line X of File 807 0x4000 808 0x4001 809 0x4005 810 Line Y of File 811 0x4009 812 0x400c 813 => 0x400e 814 0x4011 815 find_instruction_backward is called with INST_COUNT = 4 and expected to 816 return 0x4001. When we reach here, INST_COUNT is set to -1 because 817 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value 818 4001 is located at the index 1 of the last iterated line (= Line X), 819 which is simply calculated by -INST_COUNT. 820 The case when the length of PCS is 0 means that we reached an area for 821 which line info is not available. In such case, we return LOOP_START, 822 which was the lowest instruction address that had line info. */ 823 p = pcs.size () > 0 ? pcs[-inst_count] : loop_start; 824 825 /* INST_READ includes all instruction addresses in a pc range. Need to 826 exclude the beginning part up to the address we're returning. That 827 is, exclude {0x4000} in the example above. */ 828 if (inst_count < 0) 829 *inst_read += inst_count; 830 831 return p; 832 } 833 834 /* Backward read LEN bytes of target memory from address MEMADDR + LEN, 835 placing the results in GDB's memory from MYADDR + LEN. Returns 836 a count of the bytes actually read. */ 837 838 static int 839 read_memory_backward (struct gdbarch *gdbarch, 840 CORE_ADDR memaddr, gdb_byte *myaddr, int len) 841 { 842 int errcode; 843 int nread; /* Number of bytes actually read. */ 844 845 /* First try a complete read. */ 846 errcode = target_read_memory (memaddr, myaddr, len); 847 if (errcode == 0) 848 { 849 /* Got it all. */ 850 nread = len; 851 } 852 else 853 { 854 /* Loop, reading one byte at a time until we get as much as we can. */ 855 memaddr += len; 856 myaddr += len; 857 for (nread = 0; nread < len; ++nread) 858 { 859 errcode = target_read_memory (--memaddr, --myaddr, 1); 860 if (errcode != 0) 861 { 862 /* The read was unsuccessful, so exit the loop. */ 863 printf_filtered (_("Cannot access memory at address %s\n"), 864 paddress (gdbarch, memaddr)); 865 break; 866 } 867 } 868 } 869 return nread; 870 } 871 872 /* Returns true if X (which is LEN bytes wide) is the number zero. */ 873 874 static int 875 integer_is_zero (const gdb_byte *x, int len) 876 { 877 int i = 0; 878 879 while (i < len && x[i] == 0) 880 ++i; 881 return (i == len); 882 } 883 884 /* Find the start address of a string in which ADDR is included. 885 Basically we search for '\0' and return the next address, 886 but if OPTIONS->PRINT_MAX is smaller than the length of a string, 887 we stop searching and return the address to print characters as many as 888 PRINT_MAX from the string. */ 889 890 static CORE_ADDR 891 find_string_backward (struct gdbarch *gdbarch, 892 CORE_ADDR addr, int count, int char_size, 893 const struct value_print_options *options, 894 int *strings_counted) 895 { 896 const int chunk_size = 0x20; 897 int read_error = 0; 898 int chars_read = 0; 899 int chars_to_read = chunk_size; 900 int chars_counted = 0; 901 int count_original = count; 902 CORE_ADDR string_start_addr = addr; 903 904 gdb_assert (char_size == 1 || char_size == 2 || char_size == 4); 905 gdb::byte_vector buffer (chars_to_read * char_size); 906 while (count > 0 && read_error == 0) 907 { 908 int i; 909 910 addr -= chars_to_read * char_size; 911 chars_read = read_memory_backward (gdbarch, addr, buffer.data (), 912 chars_to_read * char_size); 913 chars_read /= char_size; 914 read_error = (chars_read == chars_to_read) ? 0 : 1; 915 /* Searching for '\0' from the end of buffer in backward direction. */ 916 for (i = 0; i < chars_read && count > 0 ; ++i, ++chars_counted) 917 { 918 int offset = (chars_to_read - i - 1) * char_size; 919 920 if (integer_is_zero (&buffer[offset], char_size) 921 || chars_counted == options->print_max) 922 { 923 /* Found '\0' or reached print_max. As OFFSET is the offset to 924 '\0', we add CHAR_SIZE to return the start address of 925 a string. */ 926 --count; 927 string_start_addr = addr + offset + char_size; 928 chars_counted = 0; 929 } 930 } 931 } 932 933 /* Update STRINGS_COUNTED with the actual number of loaded strings. */ 934 *strings_counted = count_original - count; 935 936 if (read_error != 0) 937 { 938 /* In error case, STRING_START_ADDR is pointing to the string that 939 was last successfully loaded. Rewind the partially loaded string. */ 940 string_start_addr -= chars_counted * char_size; 941 } 942 943 return string_start_addr; 944 } 945 946 /* Examine data at address ADDR in format FMT. 947 Fetch it from memory and print on gdb_stdout. */ 948 949 static void 950 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr) 951 { 952 char format = 0; 953 char size; 954 int count = 1; 955 struct type *val_type = NULL; 956 int i; 957 int maxelts; 958 struct value_print_options opts; 959 int need_to_update_next_address = 0; 960 CORE_ADDR addr_rewound = 0; 961 962 format = fmt.format; 963 size = fmt.size; 964 count = fmt.count; 965 next_gdbarch = gdbarch; 966 next_address = addr; 967 968 /* Instruction format implies fetch single bytes 969 regardless of the specified size. 970 The case of strings is handled in decode_format, only explicit 971 size operator are not changed to 'b'. */ 972 if (format == 'i') 973 size = 'b'; 974 975 if (size == 'a') 976 { 977 /* Pick the appropriate size for an address. */ 978 if (gdbarch_ptr_bit (next_gdbarch) == 64) 979 size = 'g'; 980 else if (gdbarch_ptr_bit (next_gdbarch) == 32) 981 size = 'w'; 982 else if (gdbarch_ptr_bit (next_gdbarch) == 16) 983 size = 'h'; 984 else 985 /* Bad value for gdbarch_ptr_bit. */ 986 internal_error (__FILE__, __LINE__, 987 _("failed internal consistency check")); 988 } 989 990 if (size == 'b') 991 val_type = builtin_type (next_gdbarch)->builtin_int8; 992 else if (size == 'h') 993 val_type = builtin_type (next_gdbarch)->builtin_int16; 994 else if (size == 'w') 995 val_type = builtin_type (next_gdbarch)->builtin_int32; 996 else if (size == 'g') 997 val_type = builtin_type (next_gdbarch)->builtin_int64; 998 999 if (format == 's') 1000 { 1001 struct type *char_type = NULL; 1002 1003 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char 1004 if type is not found. */ 1005 if (size == 'h') 1006 char_type = builtin_type (next_gdbarch)->builtin_char16; 1007 else if (size == 'w') 1008 char_type = builtin_type (next_gdbarch)->builtin_char32; 1009 if (char_type) 1010 val_type = char_type; 1011 else 1012 { 1013 if (size != '\0' && size != 'b') 1014 warning (_("Unable to display strings with " 1015 "size '%c', using 'b' instead."), size); 1016 size = 'b'; 1017 val_type = builtin_type (next_gdbarch)->builtin_int8; 1018 } 1019 } 1020 1021 maxelts = 8; 1022 if (size == 'w') 1023 maxelts = 4; 1024 if (size == 'g') 1025 maxelts = 2; 1026 if (format == 's' || format == 'i') 1027 maxelts = 1; 1028 1029 get_formatted_print_options (&opts, format); 1030 1031 if (count < 0) 1032 { 1033 /* This is the negative repeat count case. 1034 We rewind the address based on the given repeat count and format, 1035 then examine memory from there in forward direction. */ 1036 1037 count = -count; 1038 if (format == 'i') 1039 { 1040 next_address = find_instruction_backward (gdbarch, addr, count, 1041 &count); 1042 } 1043 else if (format == 's') 1044 { 1045 next_address = find_string_backward (gdbarch, addr, count, 1046 TYPE_LENGTH (val_type), 1047 &opts, &count); 1048 } 1049 else 1050 { 1051 next_address = addr - count * TYPE_LENGTH (val_type); 1052 } 1053 1054 /* The following call to print_formatted updates next_address in every 1055 iteration. In backward case, we store the start address here 1056 and update next_address with it before exiting the function. */ 1057 addr_rewound = (format == 's' 1058 ? next_address - TYPE_LENGTH (val_type) 1059 : next_address); 1060 need_to_update_next_address = 1; 1061 } 1062 1063 /* Print as many objects as specified in COUNT, at most maxelts per line, 1064 with the address of the next one at the start of each line. */ 1065 1066 while (count > 0) 1067 { 1068 QUIT; 1069 if (format == 'i') 1070 fputs_filtered (pc_prefix (next_address), gdb_stdout); 1071 print_address (next_gdbarch, next_address, gdb_stdout); 1072 printf_filtered (":"); 1073 for (i = maxelts; 1074 i > 0 && count > 0; 1075 i--, count--) 1076 { 1077 printf_filtered ("\t"); 1078 /* Note that print_formatted sets next_address for the next 1079 object. */ 1080 last_examine_address = next_address; 1081 1082 /* The value to be displayed is not fetched greedily. 1083 Instead, to avoid the possibility of a fetched value not 1084 being used, its retrieval is delayed until the print code 1085 uses it. When examining an instruction stream, the 1086 disassembler will perform its own memory fetch using just 1087 the address stored in LAST_EXAMINE_VALUE. FIXME: Should 1088 the disassembler be modified so that LAST_EXAMINE_VALUE 1089 is left with the byte sequence from the last complete 1090 instruction fetched from memory? */ 1091 last_examine_value 1092 = release_value (value_at_lazy (val_type, next_address)); 1093 1094 print_formatted (last_examine_value.get (), size, &opts, gdb_stdout); 1095 1096 /* Display any branch delay slots following the final insn. */ 1097 if (format == 'i' && count == 1) 1098 count += branch_delay_insns; 1099 } 1100 printf_filtered ("\n"); 1101 gdb_flush (gdb_stdout); 1102 } 1103 1104 if (need_to_update_next_address) 1105 next_address = addr_rewound; 1106 } 1107 1108 static void 1109 validate_format (struct format_data fmt, const char *cmdname) 1110 { 1111 if (fmt.size != 0) 1112 error (_("Size letters are meaningless in \"%s\" command."), cmdname); 1113 if (fmt.count != 1) 1114 error (_("Item count other than 1 is meaningless in \"%s\" command."), 1115 cmdname); 1116 if (fmt.format == 'i') 1117 error (_("Format letter \"%c\" is meaningless in \"%s\" command."), 1118 fmt.format, cmdname); 1119 } 1120 1121 /* Parse print command format string into *FMTP and update *EXPP. 1122 CMDNAME should name the current command. */ 1123 1124 void 1125 print_command_parse_format (const char **expp, const char *cmdname, 1126 struct format_data *fmtp) 1127 { 1128 const char *exp = *expp; 1129 1130 if (exp && *exp == '/') 1131 { 1132 exp++; 1133 *fmtp = decode_format (&exp, last_format, 0); 1134 validate_format (*fmtp, cmdname); 1135 last_format = fmtp->format; 1136 } 1137 else 1138 { 1139 fmtp->count = 1; 1140 fmtp->format = 0; 1141 fmtp->size = 0; 1142 fmtp->raw = 0; 1143 } 1144 1145 *expp = exp; 1146 } 1147 1148 /* Print VAL to console according to *FMTP, including recording it to 1149 the history. */ 1150 1151 void 1152 print_value (struct value *val, const struct format_data *fmtp) 1153 { 1154 struct value_print_options opts; 1155 int histindex = record_latest_value (val); 1156 1157 annotate_value_history_begin (histindex, value_type (val)); 1158 1159 printf_filtered ("$%d = ", histindex); 1160 1161 annotate_value_history_value (); 1162 1163 get_formatted_print_options (&opts, fmtp->format); 1164 opts.raw = fmtp->raw; 1165 1166 print_formatted (val, fmtp->size, &opts, gdb_stdout); 1167 printf_filtered ("\n"); 1168 1169 annotate_value_history_end (); 1170 } 1171 1172 /* Evaluate string EXP as an expression in the current language and 1173 print the resulting value. EXP may contain a format specifier as the 1174 first argument ("/x myvar" for example, to print myvar in hex). */ 1175 1176 static void 1177 print_command_1 (const char *exp, int voidprint) 1178 { 1179 struct value *val; 1180 struct format_data fmt; 1181 1182 print_command_parse_format (&exp, "print", &fmt); 1183 1184 if (exp && *exp) 1185 { 1186 expression_up expr = parse_expression (exp); 1187 val = evaluate_expression (expr.get ()); 1188 } 1189 else 1190 val = access_value_history (0); 1191 1192 if (voidprint || (val && value_type (val) && 1193 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID)) 1194 print_value (val, &fmt); 1195 } 1196 1197 static void 1198 print_command (const char *exp, int from_tty) 1199 { 1200 print_command_1 (exp, 1); 1201 } 1202 1203 /* Same as print, except it doesn't print void results. */ 1204 static void 1205 call_command (const char *exp, int from_tty) 1206 { 1207 print_command_1 (exp, 0); 1208 } 1209 1210 /* Implementation of the "output" command. */ 1211 1212 void 1213 output_command (const char *exp, int from_tty) 1214 { 1215 char format = 0; 1216 struct value *val; 1217 struct format_data fmt; 1218 struct value_print_options opts; 1219 1220 fmt.size = 0; 1221 fmt.raw = 0; 1222 1223 if (exp && *exp == '/') 1224 { 1225 exp++; 1226 fmt = decode_format (&exp, 0, 0); 1227 validate_format (fmt, "output"); 1228 format = fmt.format; 1229 } 1230 1231 expression_up expr = parse_expression (exp); 1232 1233 val = evaluate_expression (expr.get ()); 1234 1235 annotate_value_begin (value_type (val)); 1236 1237 get_formatted_print_options (&opts, format); 1238 opts.raw = fmt.raw; 1239 print_formatted (val, fmt.size, &opts, gdb_stdout); 1240 1241 annotate_value_end (); 1242 1243 wrap_here (""); 1244 gdb_flush (gdb_stdout); 1245 } 1246 1247 static void 1248 set_command (const char *exp, int from_tty) 1249 { 1250 expression_up expr = parse_expression (exp); 1251 1252 if (expr->nelts >= 1) 1253 switch (expr->elts[0].opcode) 1254 { 1255 case UNOP_PREINCREMENT: 1256 case UNOP_POSTINCREMENT: 1257 case UNOP_PREDECREMENT: 1258 case UNOP_POSTDECREMENT: 1259 case BINOP_ASSIGN: 1260 case BINOP_ASSIGN_MODIFY: 1261 case BINOP_COMMA: 1262 break; 1263 default: 1264 warning 1265 (_("Expression is not an assignment (and might have no effect)")); 1266 } 1267 1268 evaluate_expression (expr.get ()); 1269 } 1270 1271 static void 1272 info_symbol_command (const char *arg, int from_tty) 1273 { 1274 struct minimal_symbol *msymbol; 1275 struct obj_section *osect; 1276 CORE_ADDR addr, sect_addr; 1277 int matches = 0; 1278 unsigned int offset; 1279 1280 if (!arg) 1281 error_no_arg (_("address")); 1282 1283 addr = parse_and_eval_address (arg); 1284 for (objfile *objfile : current_program_space->objfiles ()) 1285 ALL_OBJFILE_OSECTIONS (objfile, osect) 1286 { 1287 /* Only process each object file once, even if there's a separate 1288 debug file. */ 1289 if (objfile->separate_debug_objfile_backlink) 1290 continue; 1291 1292 sect_addr = overlay_mapped_address (addr, osect); 1293 1294 if (obj_section_addr (osect) <= sect_addr 1295 && sect_addr < obj_section_endaddr (osect) 1296 && (msymbol 1297 = lookup_minimal_symbol_by_pc_section (sect_addr, 1298 osect).minsym)) 1299 { 1300 const char *obj_name, *mapped, *sec_name, *msym_name; 1301 const char *loc_string; 1302 1303 matches = 1; 1304 offset = sect_addr - MSYMBOL_VALUE_ADDRESS (objfile, msymbol); 1305 mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped"); 1306 sec_name = osect->the_bfd_section->name; 1307 msym_name = MSYMBOL_PRINT_NAME (msymbol); 1308 1309 /* Don't print the offset if it is zero. 1310 We assume there's no need to handle i18n of "sym + offset". */ 1311 std::string string_holder; 1312 if (offset) 1313 { 1314 string_holder = string_printf ("%s + %u", msym_name, offset); 1315 loc_string = string_holder.c_str (); 1316 } 1317 else 1318 loc_string = msym_name; 1319 1320 gdb_assert (osect->objfile && objfile_name (osect->objfile)); 1321 obj_name = objfile_name (osect->objfile); 1322 1323 if (MULTI_OBJFILE_P ()) 1324 if (pc_in_unmapped_range (addr, osect)) 1325 if (section_is_overlay (osect)) 1326 printf_filtered (_("%s in load address range of " 1327 "%s overlay section %s of %s\n"), 1328 loc_string, mapped, sec_name, obj_name); 1329 else 1330 printf_filtered (_("%s in load address range of " 1331 "section %s of %s\n"), 1332 loc_string, sec_name, obj_name); 1333 else 1334 if (section_is_overlay (osect)) 1335 printf_filtered (_("%s in %s overlay section %s of %s\n"), 1336 loc_string, mapped, sec_name, obj_name); 1337 else 1338 printf_filtered (_("%s in section %s of %s\n"), 1339 loc_string, sec_name, obj_name); 1340 else 1341 if (pc_in_unmapped_range (addr, osect)) 1342 if (section_is_overlay (osect)) 1343 printf_filtered (_("%s in load address range of %s overlay " 1344 "section %s\n"), 1345 loc_string, mapped, sec_name); 1346 else 1347 printf_filtered 1348 (_("%s in load address range of section %s\n"), 1349 loc_string, sec_name); 1350 else 1351 if (section_is_overlay (osect)) 1352 printf_filtered (_("%s in %s overlay section %s\n"), 1353 loc_string, mapped, sec_name); 1354 else 1355 printf_filtered (_("%s in section %s\n"), 1356 loc_string, sec_name); 1357 } 1358 } 1359 if (matches == 0) 1360 printf_filtered (_("No symbol matches %s.\n"), arg); 1361 } 1362 1363 static void 1364 info_address_command (const char *exp, int from_tty) 1365 { 1366 struct gdbarch *gdbarch; 1367 int regno; 1368 struct symbol *sym; 1369 struct bound_minimal_symbol msymbol; 1370 long val; 1371 struct obj_section *section; 1372 CORE_ADDR load_addr, context_pc = 0; 1373 struct field_of_this_result is_a_field_of_this; 1374 1375 if (exp == 0) 1376 error (_("Argument required.")); 1377 1378 sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN, 1379 &is_a_field_of_this).symbol; 1380 if (sym == NULL) 1381 { 1382 if (is_a_field_of_this.type != NULL) 1383 { 1384 printf_filtered ("Symbol \""); 1385 fprintf_symbol_filtered (gdb_stdout, exp, 1386 current_language->la_language, DMGL_ANSI); 1387 printf_filtered ("\" is a field of the local class variable "); 1388 if (current_language->la_language == language_objc) 1389 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */ 1390 else 1391 printf_filtered ("`this'\n"); 1392 return; 1393 } 1394 1395 msymbol = lookup_bound_minimal_symbol (exp); 1396 1397 if (msymbol.minsym != NULL) 1398 { 1399 struct objfile *objfile = msymbol.objfile; 1400 1401 gdbarch = get_objfile_arch (objfile); 1402 load_addr = BMSYMBOL_VALUE_ADDRESS (msymbol); 1403 1404 printf_filtered ("Symbol \""); 1405 fprintf_symbol_filtered (gdb_stdout, exp, 1406 current_language->la_language, DMGL_ANSI); 1407 printf_filtered ("\" is at "); 1408 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1409 gdb_stdout); 1410 printf_filtered (" in a file compiled without debugging"); 1411 section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym); 1412 if (section_is_overlay (section)) 1413 { 1414 load_addr = overlay_unmapped_address (load_addr, section); 1415 printf_filtered (",\n -- loaded at "); 1416 fputs_styled (paddress (gdbarch, load_addr), 1417 address_style.style (), 1418 gdb_stdout); 1419 printf_filtered (" in overlay section %s", 1420 section->the_bfd_section->name); 1421 } 1422 printf_filtered (".\n"); 1423 } 1424 else 1425 error (_("No symbol \"%s\" in current context."), exp); 1426 return; 1427 } 1428 1429 printf_filtered ("Symbol \""); 1430 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym), 1431 current_language->la_language, DMGL_ANSI); 1432 printf_filtered ("\" is "); 1433 val = SYMBOL_VALUE (sym); 1434 if (SYMBOL_OBJFILE_OWNED (sym)) 1435 section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym); 1436 else 1437 section = NULL; 1438 gdbarch = symbol_arch (sym); 1439 1440 if (SYMBOL_COMPUTED_OPS (sym) != NULL) 1441 { 1442 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc, 1443 gdb_stdout); 1444 printf_filtered (".\n"); 1445 return; 1446 } 1447 1448 switch (SYMBOL_CLASS (sym)) 1449 { 1450 case LOC_CONST: 1451 case LOC_CONST_BYTES: 1452 printf_filtered ("constant"); 1453 break; 1454 1455 case LOC_LABEL: 1456 printf_filtered ("a label at address "); 1457 load_addr = SYMBOL_VALUE_ADDRESS (sym); 1458 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1459 gdb_stdout); 1460 if (section_is_overlay (section)) 1461 { 1462 load_addr = overlay_unmapped_address (load_addr, section); 1463 printf_filtered (",\n -- loaded at "); 1464 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1465 gdb_stdout); 1466 printf_filtered (" in overlay section %s", 1467 section->the_bfd_section->name); 1468 } 1469 break; 1470 1471 case LOC_COMPUTED: 1472 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); 1473 1474 case LOC_REGISTER: 1475 /* GDBARCH is the architecture associated with the objfile the symbol 1476 is defined in; the target architecture may be different, and may 1477 provide additional registers. However, we do not know the target 1478 architecture at this point. We assume the objfile architecture 1479 will contain all the standard registers that occur in debug info 1480 in that objfile. */ 1481 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); 1482 1483 if (SYMBOL_IS_ARGUMENT (sym)) 1484 printf_filtered (_("an argument in register %s"), 1485 gdbarch_register_name (gdbarch, regno)); 1486 else 1487 printf_filtered (_("a variable in register %s"), 1488 gdbarch_register_name (gdbarch, regno)); 1489 break; 1490 1491 case LOC_STATIC: 1492 printf_filtered (_("static storage at address ")); 1493 load_addr = SYMBOL_VALUE_ADDRESS (sym); 1494 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1495 gdb_stdout); 1496 if (section_is_overlay (section)) 1497 { 1498 load_addr = overlay_unmapped_address (load_addr, section); 1499 printf_filtered (_(",\n -- loaded at ")); 1500 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1501 gdb_stdout); 1502 printf_filtered (_(" in overlay section %s"), 1503 section->the_bfd_section->name); 1504 } 1505 break; 1506 1507 case LOC_REGPARM_ADDR: 1508 /* Note comment at LOC_REGISTER. */ 1509 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); 1510 printf_filtered (_("address of an argument in register %s"), 1511 gdbarch_register_name (gdbarch, regno)); 1512 break; 1513 1514 case LOC_ARG: 1515 printf_filtered (_("an argument at offset %ld"), val); 1516 break; 1517 1518 case LOC_LOCAL: 1519 printf_filtered (_("a local variable at frame offset %ld"), val); 1520 break; 1521 1522 case LOC_REF_ARG: 1523 printf_filtered (_("a reference argument at offset %ld"), val); 1524 break; 1525 1526 case LOC_TYPEDEF: 1527 printf_filtered (_("a typedef")); 1528 break; 1529 1530 case LOC_BLOCK: 1531 printf_filtered (_("a function at address ")); 1532 load_addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)); 1533 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1534 gdb_stdout); 1535 if (section_is_overlay (section)) 1536 { 1537 load_addr = overlay_unmapped_address (load_addr, section); 1538 printf_filtered (_(",\n -- loaded at ")); 1539 fputs_styled (paddress (gdbarch, load_addr), address_style.style (), 1540 gdb_stdout); 1541 printf_filtered (_(" in overlay section %s"), 1542 section->the_bfd_section->name); 1543 } 1544 break; 1545 1546 case LOC_UNRESOLVED: 1547 { 1548 struct bound_minimal_symbol msym; 1549 1550 msym = lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym)); 1551 if (msym.minsym == NULL) 1552 printf_filtered ("unresolved"); 1553 else 1554 { 1555 section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym); 1556 1557 if (section 1558 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 1559 { 1560 load_addr = MSYMBOL_VALUE_RAW_ADDRESS (msym.minsym); 1561 printf_filtered (_("a thread-local variable at offset %s " 1562 "in the thread-local storage for `%s'"), 1563 paddress (gdbarch, load_addr), 1564 objfile_name (section->objfile)); 1565 } 1566 else 1567 { 1568 load_addr = BMSYMBOL_VALUE_ADDRESS (msym); 1569 printf_filtered (_("static storage at address ")); 1570 fputs_styled (paddress (gdbarch, load_addr), 1571 address_style.style (), gdb_stdout); 1572 if (section_is_overlay (section)) 1573 { 1574 load_addr = overlay_unmapped_address (load_addr, section); 1575 printf_filtered (_(",\n -- loaded at ")); 1576 fputs_styled (paddress (gdbarch, load_addr), 1577 address_style.style (), 1578 gdb_stdout); 1579 printf_filtered (_(" in overlay section %s"), 1580 section->the_bfd_section->name); 1581 } 1582 } 1583 } 1584 } 1585 break; 1586 1587 case LOC_OPTIMIZED_OUT: 1588 printf_filtered (_("optimized out")); 1589 break; 1590 1591 default: 1592 printf_filtered (_("of unknown (botched) type")); 1593 break; 1594 } 1595 printf_filtered (".\n"); 1596 } 1597 1598 1599 static void 1600 x_command (const char *exp, int from_tty) 1601 { 1602 struct format_data fmt; 1603 struct value *val; 1604 1605 fmt.format = last_format ? last_format : 'x'; 1606 fmt.size = last_size; 1607 fmt.count = 1; 1608 fmt.raw = 0; 1609 1610 /* If there is no expression and no format, use the most recent 1611 count. */ 1612 if (exp == nullptr && last_count > 0) 1613 fmt.count = last_count; 1614 1615 if (exp && *exp == '/') 1616 { 1617 const char *tmp = exp + 1; 1618 1619 fmt = decode_format (&tmp, last_format, last_size); 1620 exp = (char *) tmp; 1621 } 1622 1623 last_count = fmt.count; 1624 1625 /* If we have an expression, evaluate it and use it as the address. */ 1626 1627 if (exp != 0 && *exp != 0) 1628 { 1629 expression_up expr = parse_expression (exp); 1630 /* Cause expression not to be there any more if this command is 1631 repeated with Newline. But don't clobber a user-defined 1632 command's definition. */ 1633 if (from_tty) 1634 set_repeat_arguments (""); 1635 val = evaluate_expression (expr.get ()); 1636 if (TYPE_IS_REFERENCE (value_type (val))) 1637 val = coerce_ref (val); 1638 /* In rvalue contexts, such as this, functions are coerced into 1639 pointers to functions. This makes "x/i main" work. */ 1640 if (/* last_format == 'i' && */ 1641 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC 1642 && VALUE_LVAL (val) == lval_memory) 1643 next_address = value_address (val); 1644 else 1645 next_address = value_as_address (val); 1646 1647 next_gdbarch = expr->gdbarch; 1648 } 1649 1650 if (!next_gdbarch) 1651 error_no_arg (_("starting display address")); 1652 1653 do_examine (fmt, next_gdbarch, next_address); 1654 1655 /* If the examine succeeds, we remember its size and format for next 1656 time. Set last_size to 'b' for strings. */ 1657 if (fmt.format == 's') 1658 last_size = 'b'; 1659 else 1660 last_size = fmt.size; 1661 last_format = fmt.format; 1662 1663 /* Set a couple of internal variables if appropriate. */ 1664 if (last_examine_value != nullptr) 1665 { 1666 /* Make last address examined available to the user as $_. Use 1667 the correct pointer type. */ 1668 struct type *pointer_type 1669 = lookup_pointer_type (value_type (last_examine_value.get ())); 1670 set_internalvar (lookup_internalvar ("_"), 1671 value_from_pointer (pointer_type, 1672 last_examine_address)); 1673 1674 /* Make contents of last address examined available to the user 1675 as $__. If the last value has not been fetched from memory 1676 then don't fetch it now; instead mark it by voiding the $__ 1677 variable. */ 1678 if (value_lazy (last_examine_value.get ())) 1679 clear_internalvar (lookup_internalvar ("__")); 1680 else 1681 set_internalvar (lookup_internalvar ("__"), last_examine_value.get ()); 1682 } 1683 } 1684 1685 1686 /* Add an expression to the auto-display chain. 1687 Specify the expression. */ 1688 1689 static void 1690 display_command (const char *arg, int from_tty) 1691 { 1692 struct format_data fmt; 1693 struct display *newobj; 1694 const char *exp = arg; 1695 1696 if (exp == 0) 1697 { 1698 do_displays (); 1699 return; 1700 } 1701 1702 if (*exp == '/') 1703 { 1704 exp++; 1705 fmt = decode_format (&exp, 0, 0); 1706 if (fmt.size && fmt.format == 0) 1707 fmt.format = 'x'; 1708 if (fmt.format == 'i' || fmt.format == 's') 1709 fmt.size = 'b'; 1710 } 1711 else 1712 { 1713 fmt.format = 0; 1714 fmt.size = 0; 1715 fmt.count = 0; 1716 fmt.raw = 0; 1717 } 1718 1719 innermost_block.reset (); 1720 expression_up expr = parse_expression (exp); 1721 1722 newobj = new display (); 1723 1724 newobj->exp_string = xstrdup (exp); 1725 newobj->exp = std::move (expr); 1726 newobj->block = innermost_block.block (); 1727 newobj->pspace = current_program_space; 1728 newobj->number = ++display_number; 1729 newobj->format = fmt; 1730 newobj->enabled_p = 1; 1731 newobj->next = NULL; 1732 1733 if (display_chain == NULL) 1734 display_chain = newobj; 1735 else 1736 { 1737 struct display *last; 1738 1739 for (last = display_chain; last->next != NULL; last = last->next) 1740 ; 1741 last->next = newobj; 1742 } 1743 1744 if (from_tty) 1745 do_one_display (newobj); 1746 1747 dont_repeat (); 1748 } 1749 1750 static void 1751 free_display (struct display *d) 1752 { 1753 xfree (d->exp_string); 1754 delete d; 1755 } 1756 1757 /* Clear out the display_chain. Done when new symtabs are loaded, 1758 since this invalidates the types stored in many expressions. */ 1759 1760 void 1761 clear_displays (void) 1762 { 1763 struct display *d; 1764 1765 while ((d = display_chain) != NULL) 1766 { 1767 display_chain = d->next; 1768 free_display (d); 1769 } 1770 } 1771 1772 /* Delete the auto-display DISPLAY. */ 1773 1774 static void 1775 delete_display (struct display *display) 1776 { 1777 struct display *d; 1778 1779 gdb_assert (display != NULL); 1780 1781 if (display_chain == display) 1782 display_chain = display->next; 1783 1784 ALL_DISPLAYS (d) 1785 if (d->next == display) 1786 { 1787 d->next = display->next; 1788 break; 1789 } 1790 1791 free_display (display); 1792 } 1793 1794 /* Call FUNCTION on each of the displays whose numbers are given in 1795 ARGS. DATA is passed unmodified to FUNCTION. */ 1796 1797 static void 1798 map_display_numbers (const char *args, 1799 void (*function) (struct display *, 1800 void *), 1801 void *data) 1802 { 1803 int num; 1804 1805 if (args == NULL) 1806 error_no_arg (_("one or more display numbers")); 1807 1808 number_or_range_parser parser (args); 1809 1810 while (!parser.finished ()) 1811 { 1812 const char *p = parser.cur_tok (); 1813 1814 num = parser.get_number (); 1815 if (num == 0) 1816 warning (_("bad display number at or near '%s'"), p); 1817 else 1818 { 1819 struct display *d, *tmp; 1820 1821 ALL_DISPLAYS_SAFE (d, tmp) 1822 if (d->number == num) 1823 break; 1824 if (d == NULL) 1825 printf_unfiltered (_("No display number %d.\n"), num); 1826 else 1827 function (d, data); 1828 } 1829 } 1830 } 1831 1832 /* Callback for map_display_numbers, that deletes a display. */ 1833 1834 static void 1835 do_delete_display (struct display *d, void *data) 1836 { 1837 delete_display (d); 1838 } 1839 1840 /* "undisplay" command. */ 1841 1842 static void 1843 undisplay_command (const char *args, int from_tty) 1844 { 1845 if (args == NULL) 1846 { 1847 if (query (_("Delete all auto-display expressions? "))) 1848 clear_displays (); 1849 dont_repeat (); 1850 return; 1851 } 1852 1853 map_display_numbers (args, do_delete_display, NULL); 1854 dont_repeat (); 1855 } 1856 1857 /* Display a single auto-display. 1858 Do nothing if the display cannot be printed in the current context, 1859 or if the display is disabled. */ 1860 1861 static void 1862 do_one_display (struct display *d) 1863 { 1864 int within_current_scope; 1865 1866 if (d->enabled_p == 0) 1867 return; 1868 1869 /* The expression carries the architecture that was used at parse time. 1870 This is a problem if the expression depends on architecture features 1871 (e.g. register numbers), and the current architecture is now different. 1872 For example, a display statement like "display/i $pc" is expected to 1873 display the PC register of the current architecture, not the arch at 1874 the time the display command was given. Therefore, we re-parse the 1875 expression if the current architecture has changed. */ 1876 if (d->exp != NULL && d->exp->gdbarch != get_current_arch ()) 1877 { 1878 d->exp.reset (); 1879 d->block = NULL; 1880 } 1881 1882 if (d->exp == NULL) 1883 { 1884 1885 TRY 1886 { 1887 innermost_block.reset (); 1888 d->exp = parse_expression (d->exp_string); 1889 d->block = innermost_block.block (); 1890 } 1891 CATCH (ex, RETURN_MASK_ALL) 1892 { 1893 /* Can't re-parse the expression. Disable this display item. */ 1894 d->enabled_p = 0; 1895 warning (_("Unable to display \"%s\": %s"), 1896 d->exp_string, ex.message); 1897 return; 1898 } 1899 END_CATCH 1900 } 1901 1902 if (d->block) 1903 { 1904 if (d->pspace == current_program_space) 1905 within_current_scope = contained_in (get_selected_block (0), d->block); 1906 else 1907 within_current_scope = 0; 1908 } 1909 else 1910 within_current_scope = 1; 1911 if (!within_current_scope) 1912 return; 1913 1914 scoped_restore save_display_number 1915 = make_scoped_restore (¤t_display_number, d->number); 1916 1917 annotate_display_begin (); 1918 printf_filtered ("%d", d->number); 1919 annotate_display_number_end (); 1920 printf_filtered (": "); 1921 if (d->format.size) 1922 { 1923 1924 annotate_display_format (); 1925 1926 printf_filtered ("x/"); 1927 if (d->format.count != 1) 1928 printf_filtered ("%d", d->format.count); 1929 printf_filtered ("%c", d->format.format); 1930 if (d->format.format != 'i' && d->format.format != 's') 1931 printf_filtered ("%c", d->format.size); 1932 printf_filtered (" "); 1933 1934 annotate_display_expression (); 1935 1936 puts_filtered (d->exp_string); 1937 annotate_display_expression_end (); 1938 1939 if (d->format.count != 1 || d->format.format == 'i') 1940 printf_filtered ("\n"); 1941 else 1942 printf_filtered (" "); 1943 1944 annotate_display_value (); 1945 1946 TRY 1947 { 1948 struct value *val; 1949 CORE_ADDR addr; 1950 1951 val = evaluate_expression (d->exp.get ()); 1952 addr = value_as_address (val); 1953 if (d->format.format == 'i') 1954 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr); 1955 do_examine (d->format, d->exp->gdbarch, addr); 1956 } 1957 CATCH (ex, RETURN_MASK_ERROR) 1958 { 1959 fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message); 1960 } 1961 END_CATCH 1962 } 1963 else 1964 { 1965 struct value_print_options opts; 1966 1967 annotate_display_format (); 1968 1969 if (d->format.format) 1970 printf_filtered ("/%c ", d->format.format); 1971 1972 annotate_display_expression (); 1973 1974 puts_filtered (d->exp_string); 1975 annotate_display_expression_end (); 1976 1977 printf_filtered (" = "); 1978 1979 annotate_display_expression (); 1980 1981 get_formatted_print_options (&opts, d->format.format); 1982 opts.raw = d->format.raw; 1983 1984 TRY 1985 { 1986 struct value *val; 1987 1988 val = evaluate_expression (d->exp.get ()); 1989 print_formatted (val, d->format.size, &opts, gdb_stdout); 1990 } 1991 CATCH (ex, RETURN_MASK_ERROR) 1992 { 1993 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message); 1994 } 1995 END_CATCH 1996 1997 printf_filtered ("\n"); 1998 } 1999 2000 annotate_display_end (); 2001 2002 gdb_flush (gdb_stdout); 2003 } 2004 2005 /* Display all of the values on the auto-display chain which can be 2006 evaluated in the current scope. */ 2007 2008 void 2009 do_displays (void) 2010 { 2011 struct display *d; 2012 2013 for (d = display_chain; d; d = d->next) 2014 do_one_display (d); 2015 } 2016 2017 /* Delete the auto-display which we were in the process of displaying. 2018 This is done when there is an error or a signal. */ 2019 2020 void 2021 disable_display (int num) 2022 { 2023 struct display *d; 2024 2025 for (d = display_chain; d; d = d->next) 2026 if (d->number == num) 2027 { 2028 d->enabled_p = 0; 2029 return; 2030 } 2031 printf_unfiltered (_("No display number %d.\n"), num); 2032 } 2033 2034 void 2035 disable_current_display (void) 2036 { 2037 if (current_display_number >= 0) 2038 { 2039 disable_display (current_display_number); 2040 fprintf_unfiltered (gdb_stderr, 2041 _("Disabling display %d to " 2042 "avoid infinite recursion.\n"), 2043 current_display_number); 2044 } 2045 current_display_number = -1; 2046 } 2047 2048 static void 2049 info_display_command (const char *ignore, int from_tty) 2050 { 2051 struct display *d; 2052 2053 if (!display_chain) 2054 printf_unfiltered (_("There are no auto-display expressions now.\n")); 2055 else 2056 printf_filtered (_("Auto-display expressions now in effect:\n\ 2057 Num Enb Expression\n")); 2058 2059 for (d = display_chain; d; d = d->next) 2060 { 2061 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]); 2062 if (d->format.size) 2063 printf_filtered ("/%d%c%c ", d->format.count, d->format.size, 2064 d->format.format); 2065 else if (d->format.format) 2066 printf_filtered ("/%c ", d->format.format); 2067 puts_filtered (d->exp_string); 2068 if (d->block && !contained_in (get_selected_block (0), d->block)) 2069 printf_filtered (_(" (cannot be evaluated in the current context)")); 2070 printf_filtered ("\n"); 2071 gdb_flush (gdb_stdout); 2072 } 2073 } 2074 2075 /* Callback fo map_display_numbers, that enables or disables the 2076 passed in display D. */ 2077 2078 static void 2079 do_enable_disable_display (struct display *d, void *data) 2080 { 2081 d->enabled_p = *(int *) data; 2082 } 2083 2084 /* Implamentation of both the "disable display" and "enable display" 2085 commands. ENABLE decides what to do. */ 2086 2087 static void 2088 enable_disable_display_command (const char *args, int from_tty, int enable) 2089 { 2090 if (args == NULL) 2091 { 2092 struct display *d; 2093 2094 ALL_DISPLAYS (d) 2095 d->enabled_p = enable; 2096 return; 2097 } 2098 2099 map_display_numbers (args, do_enable_disable_display, &enable); 2100 } 2101 2102 /* The "enable display" command. */ 2103 2104 static void 2105 enable_display_command (const char *args, int from_tty) 2106 { 2107 enable_disable_display_command (args, from_tty, 1); 2108 } 2109 2110 /* The "disable display" command. */ 2111 2112 static void 2113 disable_display_command (const char *args, int from_tty) 2114 { 2115 enable_disable_display_command (args, from_tty, 0); 2116 } 2117 2118 /* display_chain items point to blocks and expressions. Some expressions in 2119 turn may point to symbols. 2120 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are 2121 obstack_free'd when a shared library is unloaded. 2122 Clear pointers that are about to become dangling. 2123 Both .exp and .block fields will be restored next time we need to display 2124 an item by re-parsing .exp_string field in the new execution context. */ 2125 2126 static void 2127 clear_dangling_display_expressions (struct objfile *objfile) 2128 { 2129 struct display *d; 2130 struct program_space *pspace; 2131 2132 /* With no symbol file we cannot have a block or expression from it. */ 2133 if (objfile == NULL) 2134 return; 2135 pspace = objfile->pspace; 2136 if (objfile->separate_debug_objfile_backlink) 2137 { 2138 objfile = objfile->separate_debug_objfile_backlink; 2139 gdb_assert (objfile->pspace == pspace); 2140 } 2141 2142 for (d = display_chain; d != NULL; d = d->next) 2143 { 2144 if (d->pspace != pspace) 2145 continue; 2146 2147 if (lookup_objfile_from_block (d->block) == objfile 2148 || (d->exp != NULL && exp_uses_objfile (d->exp.get (), objfile))) 2149 { 2150 d->exp.reset (); 2151 d->block = NULL; 2152 } 2153 } 2154 } 2155 2156 2157 /* Print the value in stack frame FRAME of a variable specified by a 2158 struct symbol. NAME is the name to print; if NULL then VAR's print 2159 name will be used. STREAM is the ui_file on which to print the 2160 value. INDENT specifies the number of indent levels to print 2161 before printing the variable name. 2162 2163 This function invalidates FRAME. */ 2164 2165 void 2166 print_variable_and_value (const char *name, struct symbol *var, 2167 struct frame_info *frame, 2168 struct ui_file *stream, int indent) 2169 { 2170 2171 if (!name) 2172 name = SYMBOL_PRINT_NAME (var); 2173 2174 fputs_filtered (n_spaces (2 * indent), stream); 2175 fputs_styled (name, variable_name_style.style (), stream); 2176 fputs_filtered (" = ", stream); 2177 2178 TRY 2179 { 2180 struct value *val; 2181 struct value_print_options opts; 2182 2183 /* READ_VAR_VALUE needs a block in order to deal with non-local 2184 references (i.e. to handle nested functions). In this context, we 2185 print variables that are local to this frame, so we can avoid passing 2186 a block to it. */ 2187 val = read_var_value (var, NULL, frame); 2188 get_user_print_options (&opts); 2189 opts.deref_ref = 1; 2190 common_val_print (val, stream, indent, &opts, current_language); 2191 2192 /* common_val_print invalidates FRAME when a pretty printer calls inferior 2193 function. */ 2194 frame = NULL; 2195 } 2196 CATCH (except, RETURN_MASK_ERROR) 2197 { 2198 fprintf_filtered(stream, "<error reading variable %s (%s)>", name, 2199 except.message); 2200 } 2201 END_CATCH 2202 2203 fprintf_filtered (stream, "\n"); 2204 } 2205 2206 /* Subroutine of ui_printf to simplify it. 2207 Print VALUE to STREAM using FORMAT. 2208 VALUE is a C-style string on the target. */ 2209 2210 static void 2211 printf_c_string (struct ui_file *stream, const char *format, 2212 struct value *value) 2213 { 2214 gdb_byte *str; 2215 CORE_ADDR tem; 2216 int j; 2217 2218 tem = value_as_address (value); 2219 if (tem == 0) 2220 { 2221 DIAGNOSTIC_PUSH 2222 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2223 fprintf_filtered (stream, format, "(null)"); 2224 DIAGNOSTIC_POP 2225 return; 2226 } 2227 2228 /* This is a %s argument. Find the length of the string. */ 2229 for (j = 0;; j++) 2230 { 2231 gdb_byte c; 2232 2233 QUIT; 2234 read_memory (tem + j, &c, 1); 2235 if (c == 0) 2236 break; 2237 } 2238 2239 /* Copy the string contents into a string inside GDB. */ 2240 str = (gdb_byte *) alloca (j + 1); 2241 if (j != 0) 2242 read_memory (tem, str, j); 2243 str[j] = 0; 2244 2245 DIAGNOSTIC_PUSH 2246 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2247 fprintf_filtered (stream, format, (char *) str); 2248 DIAGNOSTIC_POP 2249 } 2250 2251 /* Subroutine of ui_printf to simplify it. 2252 Print VALUE to STREAM using FORMAT. 2253 VALUE is a wide C-style string on the target. */ 2254 2255 static void 2256 printf_wide_c_string (struct ui_file *stream, const char *format, 2257 struct value *value) 2258 { 2259 gdb_byte *str; 2260 CORE_ADDR tem; 2261 int j; 2262 struct gdbarch *gdbarch = get_type_arch (value_type (value)); 2263 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2264 struct type *wctype = lookup_typename (current_language, gdbarch, 2265 "wchar_t", NULL, 0); 2266 int wcwidth = TYPE_LENGTH (wctype); 2267 gdb_byte *buf = (gdb_byte *) alloca (wcwidth); 2268 2269 tem = value_as_address (value); 2270 if (tem == 0) 2271 { 2272 DIAGNOSTIC_PUSH 2273 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2274 fprintf_filtered (stream, format, "(null)"); 2275 DIAGNOSTIC_POP 2276 return; 2277 } 2278 2279 /* This is a %s argument. Find the length of the string. */ 2280 for (j = 0;; j += wcwidth) 2281 { 2282 QUIT; 2283 read_memory (tem + j, buf, wcwidth); 2284 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0) 2285 break; 2286 } 2287 2288 /* Copy the string contents into a string inside GDB. */ 2289 str = (gdb_byte *) alloca (j + wcwidth); 2290 if (j != 0) 2291 read_memory (tem, str, j); 2292 memset (&str[j], 0, wcwidth); 2293 2294 auto_obstack output; 2295 2296 convert_between_encodings (target_wide_charset (gdbarch), 2297 host_charset (), 2298 str, j, wcwidth, 2299 &output, translit_char); 2300 obstack_grow_str0 (&output, ""); 2301 2302 DIAGNOSTIC_PUSH 2303 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2304 fprintf_filtered (stream, format, obstack_base (&output)); 2305 DIAGNOSTIC_POP 2306 } 2307 2308 /* Subroutine of ui_printf to simplify it. 2309 Print VALUE, a floating point value, to STREAM using FORMAT. */ 2310 2311 static void 2312 printf_floating (struct ui_file *stream, const char *format, 2313 struct value *value, enum argclass argclass) 2314 { 2315 /* Parameter data. */ 2316 struct type *param_type = value_type (value); 2317 struct gdbarch *gdbarch = get_type_arch (param_type); 2318 2319 /* Determine target type corresponding to the format string. */ 2320 struct type *fmt_type; 2321 switch (argclass) 2322 { 2323 case double_arg: 2324 fmt_type = builtin_type (gdbarch)->builtin_double; 2325 break; 2326 case long_double_arg: 2327 fmt_type = builtin_type (gdbarch)->builtin_long_double; 2328 break; 2329 case dec32float_arg: 2330 fmt_type = builtin_type (gdbarch)->builtin_decfloat; 2331 break; 2332 case dec64float_arg: 2333 fmt_type = builtin_type (gdbarch)->builtin_decdouble; 2334 break; 2335 case dec128float_arg: 2336 fmt_type = builtin_type (gdbarch)->builtin_declong; 2337 break; 2338 default: 2339 gdb_assert_not_reached ("unexpected argument class"); 2340 } 2341 2342 /* To match the traditional GDB behavior, the conversion is 2343 done differently depending on the type of the parameter: 2344 2345 - if the parameter has floating-point type, it's value 2346 is converted to the target type; 2347 2348 - otherwise, if the parameter has a type that is of the 2349 same size as a built-in floating-point type, the value 2350 bytes are interpreted as if they were of that type, and 2351 then converted to the target type (this is not done for 2352 decimal floating-point argument classes); 2353 2354 - otherwise, if the source value has an integer value, 2355 it's value is converted to the target type; 2356 2357 - otherwise, an error is raised. 2358 2359 In either case, the result of the conversion is a byte buffer 2360 formatted in the target format for the target type. */ 2361 2362 if (TYPE_CODE (fmt_type) == TYPE_CODE_FLT) 2363 { 2364 param_type = float_type_from_length (param_type); 2365 if (param_type != value_type (value)) 2366 value = value_from_contents (param_type, value_contents (value)); 2367 } 2368 2369 value = value_cast (fmt_type, value); 2370 2371 /* Convert the value to a string and print it. */ 2372 std::string str 2373 = target_float_to_string (value_contents (value), fmt_type, format); 2374 fputs_filtered (str.c_str (), stream); 2375 } 2376 2377 /* Subroutine of ui_printf to simplify it. 2378 Print VALUE, a target pointer, to STREAM using FORMAT. */ 2379 2380 static void 2381 printf_pointer (struct ui_file *stream, const char *format, 2382 struct value *value) 2383 { 2384 /* We avoid the host's %p because pointers are too 2385 likely to be the wrong size. The only interesting 2386 modifier for %p is a width; extract that, and then 2387 handle %p as glibc would: %#x or a literal "(nil)". */ 2388 2389 const char *p; 2390 char *fmt, *fmt_p; 2391 #ifdef PRINTF_HAS_LONG_LONG 2392 long long val = value_as_long (value); 2393 #else 2394 long val = value_as_long (value); 2395 #endif 2396 2397 fmt = (char *) alloca (strlen (format) + 5); 2398 2399 /* Copy up to the leading %. */ 2400 p = format; 2401 fmt_p = fmt; 2402 while (*p) 2403 { 2404 int is_percent = (*p == '%'); 2405 2406 *fmt_p++ = *p++; 2407 if (is_percent) 2408 { 2409 if (*p == '%') 2410 *fmt_p++ = *p++; 2411 else 2412 break; 2413 } 2414 } 2415 2416 if (val != 0) 2417 *fmt_p++ = '#'; 2418 2419 /* Copy any width or flags. Only the "-" flag is valid for pointers 2420 -- see the format_pieces constructor. */ 2421 while (*p == '-' || (*p >= '0' && *p < '9')) 2422 *fmt_p++ = *p++; 2423 2424 gdb_assert (*p == 'p' && *(p + 1) == '\0'); 2425 if (val != 0) 2426 { 2427 #ifdef PRINTF_HAS_LONG_LONG 2428 *fmt_p++ = 'l'; 2429 #endif 2430 *fmt_p++ = 'l'; 2431 *fmt_p++ = 'x'; 2432 *fmt_p++ = '\0'; 2433 DIAGNOSTIC_PUSH 2434 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2435 fprintf_filtered (stream, fmt, val); 2436 DIAGNOSTIC_POP 2437 } 2438 else 2439 { 2440 *fmt_p++ = 's'; 2441 *fmt_p++ = '\0'; 2442 DIAGNOSTIC_PUSH 2443 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2444 fprintf_filtered (stream, fmt, "(nil)"); 2445 DIAGNOSTIC_POP 2446 } 2447 } 2448 2449 /* printf "printf format string" ARG to STREAM. */ 2450 2451 static void 2452 ui_printf (const char *arg, struct ui_file *stream) 2453 { 2454 const char *s = arg; 2455 std::vector<struct value *> val_args; 2456 2457 if (s == 0) 2458 error_no_arg (_("format-control string and values to print")); 2459 2460 s = skip_spaces (s); 2461 2462 /* A format string should follow, enveloped in double quotes. */ 2463 if (*s++ != '"') 2464 error (_("Bad format string, missing '\"'.")); 2465 2466 format_pieces fpieces (&s); 2467 2468 if (*s++ != '"') 2469 error (_("Bad format string, non-terminated '\"'.")); 2470 2471 s = skip_spaces (s); 2472 2473 if (*s != ',' && *s != 0) 2474 error (_("Invalid argument syntax")); 2475 2476 if (*s == ',') 2477 s++; 2478 s = skip_spaces (s); 2479 2480 { 2481 int nargs_wanted; 2482 int i; 2483 const char *current_substring; 2484 2485 nargs_wanted = 0; 2486 for (auto &&piece : fpieces) 2487 if (piece.argclass != literal_piece) 2488 ++nargs_wanted; 2489 2490 /* Now, parse all arguments and evaluate them. 2491 Store the VALUEs in VAL_ARGS. */ 2492 2493 while (*s != '\0') 2494 { 2495 const char *s1; 2496 2497 s1 = s; 2498 val_args.push_back (parse_to_comma_and_eval (&s1)); 2499 2500 s = s1; 2501 if (*s == ',') 2502 s++; 2503 } 2504 2505 if (val_args.size () != nargs_wanted) 2506 error (_("Wrong number of arguments for specified format-string")); 2507 2508 /* Now actually print them. */ 2509 i = 0; 2510 for (auto &&piece : fpieces) 2511 { 2512 current_substring = piece.string; 2513 switch (piece.argclass) 2514 { 2515 case string_arg: 2516 printf_c_string (stream, current_substring, val_args[i]); 2517 break; 2518 case wide_string_arg: 2519 printf_wide_c_string (stream, current_substring, val_args[i]); 2520 break; 2521 case wide_char_arg: 2522 { 2523 struct gdbarch *gdbarch 2524 = get_type_arch (value_type (val_args[i])); 2525 struct type *wctype = lookup_typename (current_language, gdbarch, 2526 "wchar_t", NULL, 0); 2527 struct type *valtype; 2528 const gdb_byte *bytes; 2529 2530 valtype = value_type (val_args[i]); 2531 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype) 2532 || TYPE_CODE (valtype) != TYPE_CODE_INT) 2533 error (_("expected wchar_t argument for %%lc")); 2534 2535 bytes = value_contents (val_args[i]); 2536 2537 auto_obstack output; 2538 2539 convert_between_encodings (target_wide_charset (gdbarch), 2540 host_charset (), 2541 bytes, TYPE_LENGTH (valtype), 2542 TYPE_LENGTH (valtype), 2543 &output, translit_char); 2544 obstack_grow_str0 (&output, ""); 2545 2546 DIAGNOSTIC_PUSH 2547 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2548 fprintf_filtered (stream, current_substring, 2549 obstack_base (&output)); 2550 DIAGNOSTIC_POP 2551 } 2552 break; 2553 case long_long_arg: 2554 #ifdef PRINTF_HAS_LONG_LONG 2555 { 2556 long long val = value_as_long (val_args[i]); 2557 2558 DIAGNOSTIC_PUSH 2559 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2560 fprintf_filtered (stream, current_substring, val); 2561 DIAGNOSTIC_POP 2562 break; 2563 } 2564 #else 2565 error (_("long long not supported in printf")); 2566 #endif 2567 case int_arg: 2568 { 2569 int val = value_as_long (val_args[i]); 2570 2571 DIAGNOSTIC_PUSH 2572 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2573 fprintf_filtered (stream, current_substring, val); 2574 DIAGNOSTIC_POP 2575 break; 2576 } 2577 case long_arg: 2578 { 2579 long val = value_as_long (val_args[i]); 2580 2581 DIAGNOSTIC_PUSH 2582 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2583 fprintf_filtered (stream, current_substring, val); 2584 DIAGNOSTIC_POP 2585 break; 2586 } 2587 /* Handles floating-point values. */ 2588 case double_arg: 2589 case long_double_arg: 2590 case dec32float_arg: 2591 case dec64float_arg: 2592 case dec128float_arg: 2593 printf_floating (stream, current_substring, val_args[i], 2594 piece.argclass); 2595 break; 2596 case ptr_arg: 2597 printf_pointer (stream, current_substring, val_args[i]); 2598 break; 2599 case literal_piece: 2600 /* Print a portion of the format string that has no 2601 directives. Note that this will not include any 2602 ordinary %-specs, but it might include "%%". That is 2603 why we use printf_filtered and not puts_filtered here. 2604 Also, we pass a dummy argument because some platforms 2605 have modified GCC to include -Wformat-security by 2606 default, which will warn here if there is no 2607 argument. */ 2608 DIAGNOSTIC_PUSH 2609 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL 2610 fprintf_filtered (stream, current_substring, 0); 2611 DIAGNOSTIC_POP 2612 break; 2613 default: 2614 internal_error (__FILE__, __LINE__, 2615 _("failed internal consistency check")); 2616 } 2617 /* Maybe advance to the next argument. */ 2618 if (piece.argclass != literal_piece) 2619 ++i; 2620 } 2621 } 2622 } 2623 2624 /* Implement the "printf" command. */ 2625 2626 static void 2627 printf_command (const char *arg, int from_tty) 2628 { 2629 ui_printf (arg, gdb_stdout); 2630 reset_terminal_style (gdb_stdout); 2631 wrap_here (""); 2632 gdb_flush (gdb_stdout); 2633 } 2634 2635 /* Implement the "eval" command. */ 2636 2637 static void 2638 eval_command (const char *arg, int from_tty) 2639 { 2640 string_file stb; 2641 2642 ui_printf (arg, &stb); 2643 2644 std::string expanded = insert_user_defined_cmd_args (stb.c_str ()); 2645 2646 execute_command (expanded.c_str (), from_tty); 2647 } 2648 2649 void 2650 _initialize_printcmd (void) 2651 { 2652 struct cmd_list_element *c; 2653 2654 current_display_number = -1; 2655 2656 gdb::observers::free_objfile.attach (clear_dangling_display_expressions); 2657 2658 add_info ("address", info_address_command, 2659 _("Describe where symbol SYM is stored.")); 2660 2661 add_info ("symbol", info_symbol_command, _("\ 2662 Describe what symbol is at location ADDR.\n\ 2663 Only for symbols with fixed locations (global or static scope).")); 2664 2665 add_com ("x", class_vars, x_command, _("\ 2666 Examine memory: x/FMT ADDRESS.\n\ 2667 ADDRESS is an expression for the memory address to examine.\n\ 2668 FMT is a repeat count followed by a format letter and a size letter.\n\ 2669 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\ 2670 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\ 2671 and z(hex, zero padded on the left).\n\ 2672 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\ 2673 The specified number of objects of the specified size are printed\n\ 2674 according to the format. If a negative number is specified, memory is\n\ 2675 examined backward from the address.\n\n\ 2676 Defaults for format and size letters are those previously used.\n\ 2677 Default count is 1. Default address is following last thing printed\n\ 2678 with this command or \"print\".")); 2679 2680 #if 0 2681 add_com ("whereis", class_vars, whereis_command, 2682 _("Print line number and file of definition of variable.")); 2683 #endif 2684 2685 add_info ("display", info_display_command, _("\ 2686 Expressions to display when program stops, with code numbers.")); 2687 2688 add_cmd ("undisplay", class_vars, undisplay_command, _("\ 2689 Cancel some expressions to be displayed when program stops.\n\ 2690 Arguments are the code numbers of the expressions to stop displaying.\n\ 2691 No argument means cancel all automatic-display expressions.\n\ 2692 \"delete display\" has the same effect as this command.\n\ 2693 Do \"info display\" to see current list of code numbers."), 2694 &cmdlist); 2695 2696 add_com ("display", class_vars, display_command, _("\ 2697 Print value of expression EXP each time the program stops.\n\ 2698 /FMT may be used before EXP as in the \"print\" command.\n\ 2699 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\ 2700 as in the \"x\" command, and then EXP is used to get the address to examine\n\ 2701 and examining is done as in the \"x\" command.\n\n\ 2702 With no argument, display all currently requested auto-display expressions.\n\ 2703 Use \"undisplay\" to cancel display requests previously made.")); 2704 2705 add_cmd ("display", class_vars, enable_display_command, _("\ 2706 Enable some expressions to be displayed when program stops.\n\ 2707 Arguments are the code numbers of the expressions to resume displaying.\n\ 2708 No argument means enable all automatic-display expressions.\n\ 2709 Do \"info display\" to see current list of code numbers."), &enablelist); 2710 2711 add_cmd ("display", class_vars, disable_display_command, _("\ 2712 Disable some expressions to be displayed when program stops.\n\ 2713 Arguments are the code numbers of the expressions to stop displaying.\n\ 2714 No argument means disable all automatic-display expressions.\n\ 2715 Do \"info display\" to see current list of code numbers."), &disablelist); 2716 2717 add_cmd ("display", class_vars, undisplay_command, _("\ 2718 Cancel some expressions to be displayed when program stops.\n\ 2719 Arguments are the code numbers of the expressions to stop displaying.\n\ 2720 No argument means cancel all automatic-display expressions.\n\ 2721 Do \"info display\" to see current list of code numbers."), &deletelist); 2722 2723 add_com ("printf", class_vars, printf_command, _("\ 2724 Formatted printing, like the C \"printf\" function.\n\ 2725 Usage: printf \"format string\", arg1, arg2, arg3, ..., argn\n\ 2726 This supports most C printf format specifications, like %s, %d, etc.")); 2727 2728 add_com ("output", class_vars, output_command, _("\ 2729 Like \"print\" but don't put in value history and don't print newline.\n\ 2730 This is useful in user-defined commands.")); 2731 2732 add_prefix_cmd ("set", class_vars, set_command, _("\ 2733 Evaluate expression EXP and assign result to variable VAR, using assignment\n\ 2734 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2735 example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2736 with $), a register (a few standard names starting with $), or an actual\n\ 2737 variable in the program being debugged. EXP is any valid expression.\n\ 2738 Use \"set variable\" for variables with names identical to set subcommands.\n\ 2739 \n\ 2740 With a subcommand, this command modifies parts of the gdb environment.\n\ 2741 You can see these environment settings with the \"show\" command."), 2742 &setlist, "set ", 1, &cmdlist); 2743 if (dbx_commands) 2744 add_com ("assign", class_vars, set_command, _("\ 2745 Evaluate expression EXP and assign result to variable VAR, using assignment\n\ 2746 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2747 example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2748 with $), a register (a few standard names starting with $), or an actual\n\ 2749 variable in the program being debugged. EXP is any valid expression.\n\ 2750 Use \"set variable\" for variables with names identical to set subcommands.\n\ 2751 \nWith a subcommand, this command modifies parts of the gdb environment.\n\ 2752 You can see these environment settings with the \"show\" command.")); 2753 2754 /* "call" is the same as "set", but handy for dbx users to call fns. */ 2755 c = add_com ("call", class_vars, call_command, _("\ 2756 Call a function in the program.\n\ 2757 The argument is the function name and arguments, in the notation of the\n\ 2758 current working language. The result is printed and saved in the value\n\ 2759 history, if it is not void.")); 2760 set_cmd_completer (c, expression_completer); 2761 2762 add_cmd ("variable", class_vars, set_command, _("\ 2763 Evaluate expression EXP and assign result to variable VAR, using assignment\n\ 2764 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2765 example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2766 with $), a register (a few standard names starting with $), or an actual\n\ 2767 variable in the program being debugged. EXP is any valid expression.\n\ 2768 This may usually be abbreviated to simply \"set\"."), 2769 &setlist); 2770 add_alias_cmd ("var", "variable", class_vars, 0, &setlist); 2771 2772 c = add_com ("print", class_vars, print_command, _("\ 2773 Print value of expression EXP.\n\ 2774 Variables accessible are those of the lexical environment of the selected\n\ 2775 stack frame, plus all those whose scope is global or an entire file.\n\ 2776 \n\ 2777 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\ 2778 $$NUM refers to NUM'th value back from the last one.\n\ 2779 Names starting with $ refer to registers (with the values they would have\n\ 2780 if the program were to return to the stack frame now selected, restoring\n\ 2781 all registers saved by frames farther in) or else to debugger\n\ 2782 \"convenience\" variables (any such name not a known register).\n\ 2783 Use assignment expressions to give values to convenience variables.\n\ 2784 \n\ 2785 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\ 2786 @ is a binary operator for treating consecutive data objects\n\ 2787 anywhere in memory as an array. FOO@NUM gives an array whose first\n\ 2788 element is FOO, whose second element is stored in the space following\n\ 2789 where FOO is stored, etc. FOO must be an expression whose value\n\ 2790 resides in memory.\n\ 2791 \n\ 2792 EXP may be preceded with /FMT, where FMT is a format letter\n\ 2793 but no count or size letter (see \"x\" command).")); 2794 set_cmd_completer (c, expression_completer); 2795 add_com_alias ("p", "print", class_vars, 1); 2796 add_com_alias ("inspect", "print", class_vars, 1); 2797 2798 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class, 2799 &max_symbolic_offset, _("\ 2800 Set the largest offset that will be printed in <symbol+1234> form."), _("\ 2801 Show the largest offset that will be printed in <symbol+1234> form."), _("\ 2802 Tell GDB to only display the symbolic form of an address if the\n\ 2803 offset between the closest earlier symbol and the address is less than\n\ 2804 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\ 2805 to always print the symbolic form of an address if any symbol precedes\n\ 2806 it. Zero is equivalent to \"unlimited\"."), 2807 NULL, 2808 show_max_symbolic_offset, 2809 &setprintlist, &showprintlist); 2810 add_setshow_boolean_cmd ("symbol-filename", no_class, 2811 &print_symbol_filename, _("\ 2812 Set printing of source filename and line number with <symbol>."), _("\ 2813 Show printing of source filename and line number with <symbol>."), NULL, 2814 NULL, 2815 show_print_symbol_filename, 2816 &setprintlist, &showprintlist); 2817 2818 add_com ("eval", no_class, eval_command, _("\ 2819 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\ 2820 a command line, and call it.")); 2821 } 2822