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