1/* Print values for GNU debugger GDB. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software 5 Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include "gdb_string.h" 26#include "frame.h" 27#include "symtab.h" 28#include "gdbtypes.h" 29#include "value.h" 30#include "language.h" 31#include "expression.h" 32#include "gdbcore.h" 33#include "gdbcmd.h" 34#include "target.h" 35#include "breakpoint.h" 36#include "demangle.h" 37#include "valprint.h" 38#include "annotate.h" 39#include "symfile.h" /* for overlay functions */ 40#include "objfiles.h" /* ditto */ 41#include "completer.h" /* for completion functions */ 42#include "ui-out.h" 43#include "gdb_assert.h" 44#include "block.h" 45#include "disasm.h" 46 47#ifdef TUI 48#include "tui/tui.h" /* For tui_active et.al. */ 49#endif 50 51extern int asm_demangle; /* Whether to demangle syms in asm printouts */ 52extern int addressprint; /* Whether to print hex addresses in HLL " */ 53 54struct format_data 55 { 56 int count; 57 char format; 58 char size; 59 }; 60 61/* Last specified output format. */ 62 63static char last_format = 'x'; 64 65/* Last specified examination size. 'b', 'h', 'w' or `q'. */ 66 67static char last_size = 'w'; 68 69/* Default address to examine next. */ 70 71static CORE_ADDR next_address; 72 73/* Default section to examine next. */ 74 75static asection *next_section; 76 77/* Last address examined. */ 78 79static CORE_ADDR last_examine_address; 80 81/* Contents of last address examined. 82 This is not valid past the end of the `x' command! */ 83 84static struct value *last_examine_value; 85 86/* Largest offset between a symbolic value and an address, that will be 87 printed as `0x1234 <symbol+offset>'. */ 88 89static unsigned int max_symbolic_offset = UINT_MAX; 90 91/* Append the source filename and linenumber of the symbol when 92 printing a symbolic value as `<symbol at filename:linenum>' if set. */ 93static int print_symbol_filename = 0; 94 95/* Number of auto-display expression currently being displayed. 96 So that we can disable it if we get an error or a signal within it. 97 -1 when not doing one. */ 98 99int current_display_number; 100 101/* Flag to low-level print routines that this value is being printed 102 in an epoch window. We'd like to pass this as a parameter, but 103 every routine would need to take it. Perhaps we can encapsulate 104 this in the I/O stream once we have GNU stdio. */ 105 106int inspect_it = 0; 107 108struct display 109 { 110 /* Chain link to next auto-display item. */ 111 struct display *next; 112 /* Expression to be evaluated and displayed. */ 113 struct expression *exp; 114 /* Item number of this auto-display item. */ 115 int number; 116 /* Display format specified. */ 117 struct format_data format; 118 /* Innermost block required by this expression when evaluated */ 119 struct block *block; 120 /* Status of this display (enabled or disabled) */ 121 int enabled_p; 122 }; 123 124/* Chain of expressions whose values should be displayed 125 automatically each time the program stops. */ 126 127static struct display *display_chain; 128 129static int display_number; 130 131/* Prototypes for exported functions. */ 132 133void output_command (char *, int); 134 135void _initialize_printcmd (void); 136 137/* Prototypes for local functions. */ 138 139static void delete_display (int); 140 141static void enable_display (char *, int); 142 143static void disable_display_command (char *, int); 144 145static void printf_command (char *, int); 146 147static void display_info (char *, int); 148 149static void do_one_display (struct display *); 150 151static void undisplay_command (char *, int); 152 153static void free_display (struct display *); 154 155static void display_command (char *, int); 156 157void x_command (char *, int); 158 159static void address_info (char *, int); 160 161static void set_command (char *, int); 162 163static void call_command (char *, int); 164 165static void inspect_command (char *, int); 166 167static void print_command (char *, int); 168 169static void print_command_1 (char *, int, int); 170 171static void validate_format (struct format_data, char *); 172 173static void do_examine (struct format_data, CORE_ADDR addr, 174 asection * section); 175 176static void print_formatted (struct value *, int, int, struct ui_file *); 177 178static struct format_data decode_format (char **, int, int); 179 180static void sym_info (char *, int); 181 182 183/* Decode a format specification. *STRING_PTR should point to it. 184 OFORMAT and OSIZE are used as defaults for the format and size 185 if none are given in the format specification. 186 If OSIZE is zero, then the size field of the returned value 187 should be set only if a size is explicitly specified by the 188 user. 189 The structure returned describes all the data 190 found in the specification. In addition, *STRING_PTR is advanced 191 past the specification and past all whitespace following it. */ 192 193static struct format_data 194decode_format (char **string_ptr, int oformat, int osize) 195{ 196 struct format_data val; 197 char *p = *string_ptr; 198 199 val.format = '?'; 200 val.size = '?'; 201 val.count = 1; 202 203 if (*p >= '0' && *p <= '9') 204 val.count = atoi (p); 205 while (*p >= '0' && *p <= '9') 206 p++; 207 208 /* Now process size or format letters that follow. */ 209 210 while (1) 211 { 212 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g') 213 val.size = *p++; 214 else if (*p >= 'a' && *p <= 'z') 215 val.format = *p++; 216 else 217 break; 218 } 219 220 while (*p == ' ' || *p == '\t') 221 p++; 222 *string_ptr = p; 223 224 /* Set defaults for format and size if not specified. */ 225 if (val.format == '?') 226 { 227 if (val.size == '?') 228 { 229 /* Neither has been specified. */ 230 val.format = oformat; 231 val.size = osize; 232 } 233 else 234 /* If a size is specified, any format makes a reasonable 235 default except 'i'. */ 236 val.format = oformat == 'i' ? 'x' : oformat; 237 } 238 else if (val.size == '?') 239 switch (val.format) 240 { 241 case 'a': 242 case 's': 243 /* Pick the appropriate size for an address. */ 244 if (TARGET_PTR_BIT == 64) 245 val.size = osize ? 'g' : osize; 246 else if (TARGET_PTR_BIT == 32) 247 val.size = osize ? 'w' : osize; 248 else if (TARGET_PTR_BIT == 16) 249 val.size = osize ? 'h' : osize; 250 else 251 /* Bad value for TARGET_PTR_BIT */ 252 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 253 break; 254 case 'f': 255 /* Floating point has to be word or giantword. */ 256 if (osize == 'w' || osize == 'g') 257 val.size = osize; 258 else 259 /* Default it to giantword if the last used size is not 260 appropriate. */ 261 val.size = osize ? 'g' : osize; 262 break; 263 case 'c': 264 /* Characters default to one byte. */ 265 val.size = osize ? 'b' : osize; 266 break; 267 default: 268 /* The default is the size most recently specified. */ 269 val.size = osize; 270 } 271 272 return val; 273} 274 275/* Print value VAL on stream according to FORMAT, a letter or 0. 276 Do not end with a newline. 277 0 means print VAL according to its own type. 278 SIZE is the letter for the size of datum being printed. 279 This is used to pad hex numbers so they line up. */ 280 281static void 282print_formatted (struct value *val, int format, int size, 283 struct ui_file *stream) 284{ 285 struct type *type = check_typedef (VALUE_TYPE (val)); 286 int len = TYPE_LENGTH (type); 287 288 if (VALUE_LVAL (val) == lval_memory) 289 { 290 next_address = VALUE_ADDRESS (val) + len; 291 next_section = VALUE_BFD_SECTION (val); 292 } 293 294 switch (format) 295 { 296 case 's': 297 /* FIXME: Need to handle wchar_t's here... */ 298 next_address = VALUE_ADDRESS (val) 299 + val_print_string (VALUE_ADDRESS (val), -1, 1, stream); 300 next_section = VALUE_BFD_SECTION (val); 301 break; 302 303 case 'i': 304 /* The old comment says 305 "Force output out, print_insn not using _filtered". 306 I'm not completely sure what that means, I suspect most print_insn 307 now do use _filtered, so I guess it's obsolete. 308 --Yes, it does filter now, and so this is obsolete. -JB */ 309 310 /* We often wrap here if there are long symbolic names. */ 311 wrap_here (" "); 312 next_address = VALUE_ADDRESS (val) 313 + gdb_print_insn (VALUE_ADDRESS (val), stream); 314 next_section = VALUE_BFD_SECTION (val); 315 break; 316 317 default: 318 if (format == 0 319 || TYPE_CODE (type) == TYPE_CODE_ARRAY 320 || TYPE_CODE (type) == TYPE_CODE_STRING 321 || TYPE_CODE (type) == TYPE_CODE_STRUCT 322 || TYPE_CODE (type) == TYPE_CODE_UNION 323 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE) 324 /* If format is 0, use the 'natural' format for 325 * that type of value. If the type is non-scalar, 326 * we have to use language rules to print it as 327 * a series of scalars. 328 */ 329 value_print (val, stream, format, Val_pretty_default); 330 else 331 /* User specified format, so don't look to the 332 * the type to tell us what to do. 333 */ 334 print_scalar_formatted (VALUE_CONTENTS (val), type, 335 format, size, stream); 336 } 337} 338 339/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, 340 according to letters FORMAT and SIZE on STREAM. 341 FORMAT may not be zero. Formats s and i are not supported at this level. 342 343 This is how the elements of an array or structure are printed 344 with a format. */ 345 346void 347print_scalar_formatted (void *valaddr, struct type *type, int format, int size, 348 struct ui_file *stream) 349{ 350 LONGEST val_long = 0; 351 unsigned int len = TYPE_LENGTH (type); 352 353 if (len > sizeof(LONGEST) && 354 (TYPE_CODE (type) == TYPE_CODE_INT 355 || TYPE_CODE (type) == TYPE_CODE_ENUM)) 356 { 357 switch (format) 358 { 359 case 'o': 360 print_octal_chars (stream, valaddr, len); 361 return; 362 case 'u': 363 case 'd': 364 print_decimal_chars (stream, valaddr, len); 365 return; 366 case 't': 367 print_binary_chars (stream, valaddr, len); 368 return; 369 case 'x': 370 print_hex_chars (stream, valaddr, len); 371 return; 372 case 'c': 373 print_char_chars (stream, valaddr, len); 374 return; 375 default: 376 break; 377 }; 378 } 379 380 if (format != 'f') 381 val_long = unpack_long (type, valaddr); 382 383 /* If the value is a pointer, and pointers and addresses are not the 384 same, then at this point, the value's length (in target bytes) is 385 TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */ 386 if (TYPE_CODE (type) == TYPE_CODE_PTR) 387 len = TARGET_ADDR_BIT / TARGET_CHAR_BIT; 388 389 /* If we are printing it as unsigned, truncate it in case it is actually 390 a negative signed value (e.g. "print/u (short)-1" should print 65535 391 (if shorts are 16 bits) instead of 4294967295). */ 392 if (format != 'd') 393 { 394 if (len < sizeof (LONGEST)) 395 val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1; 396 } 397 398 switch (format) 399 { 400 case 'x': 401 if (!size) 402 { 403 /* no size specified, like in print. Print varying # of digits. */ 404 print_longest (stream, 'x', 1, val_long); 405 } 406 else 407 switch (size) 408 { 409 case 'b': 410 case 'h': 411 case 'w': 412 case 'g': 413 print_longest (stream, size, 1, val_long); 414 break; 415 default: 416 error ("Undefined output size \"%c\".", size); 417 } 418 break; 419 420 case 'd': 421 print_longest (stream, 'd', 1, val_long); 422 break; 423 424 case 'u': 425 print_longest (stream, 'u', 0, val_long); 426 break; 427 428 case 'o': 429 if (val_long) 430 print_longest (stream, 'o', 1, val_long); 431 else 432 fprintf_filtered (stream, "0"); 433 break; 434 435 case 'a': 436 { 437 CORE_ADDR addr = unpack_pointer (type, valaddr); 438 print_address (addr, stream); 439 } 440 break; 441 442 case 'c': 443 value_print (value_from_longest (builtin_type_true_char, val_long), 444 stream, 0, Val_pretty_default); 445 break; 446 447 case 'f': 448 if (len == TYPE_LENGTH (builtin_type_float)) 449 type = builtin_type_float; 450 else if (len == TYPE_LENGTH (builtin_type_double)) 451 type = builtin_type_double; 452 else if (len == TYPE_LENGTH (builtin_type_long_double)) 453 type = builtin_type_long_double; 454 print_floating (valaddr, type, stream); 455 break; 456 457 case 0: 458 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 459 460 case 't': 461 /* Binary; 't' stands for "two". */ 462 { 463 char bits[8 * (sizeof val_long) + 1]; 464 char buf[8 * (sizeof val_long) + 32]; 465 char *cp = bits; 466 int width; 467 468 if (!size) 469 width = 8 * (sizeof val_long); 470 else 471 switch (size) 472 { 473 case 'b': 474 width = 8; 475 break; 476 case 'h': 477 width = 16; 478 break; 479 case 'w': 480 width = 32; 481 break; 482 case 'g': 483 width = 64; 484 break; 485 default: 486 error ("Undefined output size \"%c\".", size); 487 } 488 489 bits[width] = '\0'; 490 while (width-- > 0) 491 { 492 bits[width] = (val_long & 1) ? '1' : '0'; 493 val_long >>= 1; 494 } 495 if (!size) 496 { 497 while (*cp && *cp == '0') 498 cp++; 499 if (*cp == '\0') 500 cp--; 501 } 502 strcpy (buf, cp); 503 fputs_filtered (buf, stream); 504 } 505 break; 506 507 default: 508 error ("Undefined output format \"%c\".", format); 509 } 510} 511 512/* Specify default address for `x' command. 513 `info lines' uses this. */ 514 515void 516set_next_address (CORE_ADDR addr) 517{ 518 next_address = addr; 519 520 /* Make address available to the user as $_. */ 521 set_internalvar (lookup_internalvar ("_"), 522 value_from_pointer (lookup_pointer_type (builtin_type_void), 523 addr)); 524} 525 526/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM, 527 after LEADIN. Print nothing if no symbolic name is found nearby. 528 Optionally also print source file and line number, if available. 529 DO_DEMANGLE controls whether to print a symbol in its native "raw" form, 530 or to interpret it as a possible C++ name and convert it back to source 531 form. However note that DO_DEMANGLE can be overridden by the specific 532 settings of the demangle and asm_demangle variables. */ 533 534void 535print_address_symbolic (CORE_ADDR addr, struct ui_file *stream, int do_demangle, 536 char *leadin) 537{ 538 char *name = NULL; 539 char *filename = NULL; 540 int unmapped = 0; 541 int offset = 0; 542 int line = 0; 543 544 /* throw away both name and filename */ 545 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name); 546 make_cleanup (free_current_contents, &filename); 547 548 if (build_address_symbolic (addr, do_demangle, &name, &offset, &filename, &line, &unmapped)) 549 { 550 do_cleanups (cleanup_chain); 551 return; 552 } 553 554 fputs_filtered (leadin, stream); 555 if (unmapped) 556 fputs_filtered ("<*", stream); 557 else 558 fputs_filtered ("<", stream); 559 fputs_filtered (name, stream); 560 if (offset != 0) 561 fprintf_filtered (stream, "+%u", (unsigned int) offset); 562 563 /* Append source filename and line number if desired. Give specific 564 line # of this addr, if we have it; else line # of the nearest symbol. */ 565 if (print_symbol_filename && filename != NULL) 566 { 567 if (line != -1) 568 fprintf_filtered (stream, " at %s:%d", filename, line); 569 else 570 fprintf_filtered (stream, " in %s", filename); 571 } 572 if (unmapped) 573 fputs_filtered ("*>", stream); 574 else 575 fputs_filtered (">", stream); 576 577 do_cleanups (cleanup_chain); 578} 579 580/* Given an address ADDR return all the elements needed to print the 581 address in a symbolic form. NAME can be mangled or not depending 582 on DO_DEMANGLE (and also on the asm_demangle global variable, 583 manipulated via ''set print asm-demangle''). Return 0 in case of 584 success, when all the info in the OUT paramters is valid. Return 1 585 otherwise. */ 586int 587build_address_symbolic (CORE_ADDR addr, /* IN */ 588 int do_demangle, /* IN */ 589 char **name, /* OUT */ 590 int *offset, /* OUT */ 591 char **filename, /* OUT */ 592 int *line, /* OUT */ 593 int *unmapped) /* OUT */ 594{ 595 struct minimal_symbol *msymbol; 596 struct symbol *symbol; 597 struct symtab *symtab = 0; 598 CORE_ADDR name_location = 0; 599 asection *section = 0; 600 char *name_temp = ""; 601 602 /* Let's say it is unmapped. */ 603 *unmapped = 0; 604 605 /* Determine if the address is in an overlay, and whether it is 606 mapped. */ 607 if (overlay_debugging) 608 { 609 section = find_pc_overlay (addr); 610 if (pc_in_unmapped_range (addr, section)) 611 { 612 *unmapped = 1; 613 addr = overlay_mapped_address (addr, section); 614 } 615 } 616 617 /* First try to find the address in the symbol table, then 618 in the minsyms. Take the closest one. */ 619 620 /* This is defective in the sense that it only finds text symbols. So 621 really this is kind of pointless--we should make sure that the 622 minimal symbols have everything we need (by changing that we could 623 save some memory, but for many debug format--ELF/DWARF or 624 anything/stabs--it would be inconvenient to eliminate those minimal 625 symbols anyway). */ 626 msymbol = lookup_minimal_symbol_by_pc_section (addr, section); 627 symbol = find_pc_sect_function (addr, section); 628 629 if (symbol) 630 { 631 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)); 632 if (do_demangle || asm_demangle) 633 name_temp = SYMBOL_PRINT_NAME (symbol); 634 else 635 name_temp = DEPRECATED_SYMBOL_NAME (symbol); 636 } 637 638 if (msymbol != NULL) 639 { 640 if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL) 641 { 642 /* The msymbol is closer to the address than the symbol; 643 use the msymbol instead. */ 644 symbol = 0; 645 symtab = 0; 646 name_location = SYMBOL_VALUE_ADDRESS (msymbol); 647 if (do_demangle || asm_demangle) 648 name_temp = SYMBOL_PRINT_NAME (msymbol); 649 else 650 name_temp = DEPRECATED_SYMBOL_NAME (msymbol); 651 } 652 } 653 if (symbol == NULL && msymbol == 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 = xstrdup (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 = xstrdup (sal.symtab->filename); 680 *line = sal.line; 681 } 682 else if (symtab && symbol && symbol->line) 683 { 684 *filename = xstrdup (symtab->filename); 685 *line = symbol->line; 686 } 687 else if (symtab) 688 { 689 *filename = xstrdup (symtab->filename); 690 *line = -1; 691 } 692 } 693 return 0; 694} 695 696/* Print address ADDR on STREAM. USE_LOCAL means the same thing as for 697 print_longest. */ 698void 699print_address_numeric (CORE_ADDR addr, int use_local, struct ui_file *stream) 700{ 701 /* Truncate address to the size of a target address, avoiding shifts 702 larger or equal than the width of a CORE_ADDR. The local 703 variable ADDR_BIT stops the compiler reporting a shift overflow 704 when it won't occur. */ 705 /* NOTE: This assumes that the significant address information is 706 kept in the least significant bits of ADDR - the upper bits were 707 either zero or sign extended. Should ADDRESS_TO_POINTER() or 708 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */ 709 710 int addr_bit = TARGET_ADDR_BIT; 711 712 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 713 addr &= ((CORE_ADDR) 1 << addr_bit) - 1; 714 print_longest (stream, 'x', use_local, (ULONGEST) addr); 715} 716 717/* Print address ADDR symbolically on STREAM. 718 First print it as a number. Then perhaps print 719 <SYMBOL + OFFSET> after the number. */ 720 721void 722print_address (CORE_ADDR addr, struct ui_file *stream) 723{ 724 print_address_numeric (addr, 1, stream); 725 print_address_symbolic (addr, stream, asm_demangle, " "); 726} 727 728/* Print address ADDR symbolically on STREAM. Parameter DEMANGLE 729 controls whether to print the symbolic name "raw" or demangled. 730 Global setting "addressprint" controls whether to print hex address 731 or not. */ 732 733void 734print_address_demangle (CORE_ADDR addr, struct ui_file *stream, int do_demangle) 735{ 736 if (addr == 0) 737 { 738 fprintf_filtered (stream, "0"); 739 } 740 else if (addressprint) 741 { 742 print_address_numeric (addr, 1, stream); 743 print_address_symbolic (addr, stream, do_demangle, " "); 744 } 745 else 746 { 747 print_address_symbolic (addr, stream, do_demangle, ""); 748 } 749} 750 751 752/* These are the types that $__ will get after an examine command of one 753 of these sizes. */ 754 755static struct type *examine_i_type; 756 757static struct type *examine_b_type; 758static struct type *examine_h_type; 759static struct type *examine_w_type; 760static struct type *examine_g_type; 761 762/* Examine data at address ADDR in format FMT. 763 Fetch it from memory and print on gdb_stdout. */ 764 765static void 766do_examine (struct format_data fmt, CORE_ADDR addr, asection *sect) 767{ 768 char format = 0; 769 char size; 770 int count = 1; 771 struct type *val_type = NULL; 772 int i; 773 int maxelts; 774 775 format = fmt.format; 776 size = fmt.size; 777 count = fmt.count; 778 next_address = addr; 779 next_section = sect; 780 781 /* String or instruction format implies fetch single bytes 782 regardless of the specified size. */ 783 if (format == 's' || format == 'i') 784 size = 'b'; 785 786 if (format == 'i') 787 val_type = examine_i_type; 788 else if (size == 'b') 789 val_type = examine_b_type; 790 else if (size == 'h') 791 val_type = examine_h_type; 792 else if (size == 'w') 793 val_type = examine_w_type; 794 else if (size == 'g') 795 val_type = examine_g_type; 796 797 maxelts = 8; 798 if (size == 'w') 799 maxelts = 4; 800 if (size == 'g') 801 maxelts = 2; 802 if (format == 's' || format == 'i') 803 maxelts = 1; 804 805 /* Print as many objects as specified in COUNT, at most maxelts per line, 806 with the address of the next one at the start of each line. */ 807 808 while (count > 0) 809 { 810 QUIT; 811 print_address (next_address, gdb_stdout); 812 printf_filtered (":"); 813 for (i = maxelts; 814 i > 0 && count > 0; 815 i--, count--) 816 { 817 printf_filtered ("\t"); 818 /* Note that print_formatted sets next_address for the next 819 object. */ 820 last_examine_address = next_address; 821 822 if (last_examine_value) 823 value_free (last_examine_value); 824 825 /* The value to be displayed is not fetched greedily. 826 Instead, to avoid the posibility of a fetched value not 827 being used, its retreval is delayed until the print code 828 uses it. When examining an instruction stream, the 829 disassembler will perform its own memory fetch using just 830 the address stored in LAST_EXAMINE_VALUE. FIXME: Should 831 the disassembler be modified so that LAST_EXAMINE_VALUE 832 is left with the byte sequence from the last complete 833 instruction fetched from memory? */ 834 last_examine_value = value_at_lazy (val_type, next_address, sect); 835 836 if (last_examine_value) 837 release_value (last_examine_value); 838 839 print_formatted (last_examine_value, format, size, gdb_stdout); 840 } 841 printf_filtered ("\n"); 842 gdb_flush (gdb_stdout); 843 } 844} 845 846static void 847validate_format (struct format_data fmt, char *cmdname) 848{ 849 if (fmt.size != 0) 850 error ("Size letters are meaningless in \"%s\" command.", cmdname); 851 if (fmt.count != 1) 852 error ("Item count other than 1 is meaningless in \"%s\" command.", 853 cmdname); 854 if (fmt.format == 'i' || fmt.format == 's') 855 error ("Format letter \"%c\" is meaningless in \"%s\" command.", 856 fmt.format, cmdname); 857} 858 859/* Evaluate string EXP as an expression in the current language and 860 print the resulting value. EXP may contain a format specifier as the 861 first argument ("/x myvar" for example, to print myvar in hex). 862 */ 863 864static void 865print_command_1 (char *exp, int inspect, int voidprint) 866{ 867 struct expression *expr; 868 struct cleanup *old_chain = 0; 869 char format = 0; 870 struct value *val; 871 struct format_data fmt; 872 int cleanup = 0; 873 874 /* Pass inspect flag to the rest of the print routines in a global (sigh). */ 875 inspect_it = inspect; 876 877 if (exp && *exp == '/') 878 { 879 exp++; 880 fmt = decode_format (&exp, last_format, 0); 881 validate_format (fmt, "print"); 882 last_format = format = fmt.format; 883 } 884 else 885 { 886 fmt.count = 1; 887 fmt.format = 0; 888 fmt.size = 0; 889 } 890 891 if (exp && *exp) 892 { 893 struct type *type; 894 expr = parse_expression (exp); 895 old_chain = make_cleanup (free_current_contents, &expr); 896 cleanup = 1; 897 val = evaluate_expression (expr); 898 } 899 else 900 val = access_value_history (0); 901 902 if (voidprint || (val && VALUE_TYPE (val) && 903 TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID)) 904 { 905 int histindex = record_latest_value (val); 906 907 if (histindex >= 0) 908 annotate_value_history_begin (histindex, VALUE_TYPE (val)); 909 else 910 annotate_value_begin (VALUE_TYPE (val)); 911 912 if (inspect) 913 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp, histindex); 914 else if (histindex >= 0) 915 printf_filtered ("$%d = ", histindex); 916 917 if (histindex >= 0) 918 annotate_value_history_value (); 919 920 print_formatted (val, format, fmt.size, gdb_stdout); 921 printf_filtered ("\n"); 922 923 if (histindex >= 0) 924 annotate_value_history_end (); 925 else 926 annotate_value_end (); 927 928 if (inspect) 929 printf_unfiltered ("\") )\030"); 930 } 931 932 if (cleanup) 933 do_cleanups (old_chain); 934 inspect_it = 0; /* Reset print routines to normal */ 935} 936 937static void 938print_command (char *exp, int from_tty) 939{ 940 print_command_1 (exp, 0, 1); 941} 942 943/* Same as print, except in epoch, it gets its own window */ 944static void 945inspect_command (char *exp, int from_tty) 946{ 947 extern int epoch_interface; 948 949 print_command_1 (exp, epoch_interface, 1); 950} 951 952/* Same as print, except it doesn't print void results. */ 953static void 954call_command (char *exp, int from_tty) 955{ 956 print_command_1 (exp, 0, 0); 957} 958 959void 960output_command (char *exp, int from_tty) 961{ 962 struct expression *expr; 963 struct cleanup *old_chain; 964 char format = 0; 965 struct value *val; 966 struct format_data fmt; 967 968 if (exp && *exp == '/') 969 { 970 exp++; 971 fmt = decode_format (&exp, 0, 0); 972 validate_format (fmt, "output"); 973 format = fmt.format; 974 } 975 976 expr = parse_expression (exp); 977 old_chain = make_cleanup (free_current_contents, &expr); 978 979 val = evaluate_expression (expr); 980 981 annotate_value_begin (VALUE_TYPE (val)); 982 983 print_formatted (val, format, fmt.size, gdb_stdout); 984 985 annotate_value_end (); 986 987 wrap_here (""); 988 gdb_flush (gdb_stdout); 989 990 do_cleanups (old_chain); 991} 992 993static void 994set_command (char *exp, int from_tty) 995{ 996 struct expression *expr = parse_expression (exp); 997 struct cleanup *old_chain = 998 make_cleanup (free_current_contents, &expr); 999 evaluate_expression (expr); 1000 do_cleanups (old_chain); 1001} 1002 1003static void 1004sym_info (char *arg, int from_tty) 1005{ 1006 struct minimal_symbol *msymbol; 1007 struct objfile *objfile; 1008 struct obj_section *osect; 1009 asection *sect; 1010 CORE_ADDR addr, sect_addr; 1011 int matches = 0; 1012 unsigned int offset; 1013 1014 if (!arg) 1015 error_no_arg ("address"); 1016 1017 addr = parse_and_eval_address (arg); 1018 ALL_OBJSECTIONS (objfile, osect) 1019 { 1020 sect = osect->the_bfd_section; 1021 sect_addr = overlay_mapped_address (addr, sect); 1022 1023 if (osect->addr <= sect_addr && sect_addr < osect->endaddr && 1024 (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect))) 1025 { 1026 matches = 1; 1027 offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol); 1028 if (offset) 1029 printf_filtered ("%s + %u in ", 1030 SYMBOL_PRINT_NAME (msymbol), offset); 1031 else 1032 printf_filtered ("%s in ", 1033 SYMBOL_PRINT_NAME (msymbol)); 1034 if (pc_in_unmapped_range (addr, sect)) 1035 printf_filtered ("load address range of "); 1036 if (section_is_overlay (sect)) 1037 printf_filtered ("%s overlay ", 1038 section_is_mapped (sect) ? "mapped" : "unmapped"); 1039 printf_filtered ("section %s", sect->name); 1040 printf_filtered ("\n"); 1041 } 1042 } 1043 if (matches == 0) 1044 printf_filtered ("No symbol matches %s.\n", arg); 1045} 1046 1047static void 1048address_info (char *exp, int from_tty) 1049{ 1050 struct symbol *sym; 1051 struct minimal_symbol *msymbol; 1052 long val; 1053 long basereg; 1054 asection *section; 1055 CORE_ADDR load_addr; 1056 int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero 1057 if exp is a field of `this'. */ 1058 1059 if (exp == 0) 1060 error ("Argument required."); 1061 1062 sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN, 1063 &is_a_field_of_this, (struct symtab **) NULL); 1064 if (sym == NULL) 1065 { 1066 if (is_a_field_of_this) 1067 { 1068 printf_filtered ("Symbol \""); 1069 fprintf_symbol_filtered (gdb_stdout, exp, 1070 current_language->la_language, DMGL_ANSI); 1071 printf_filtered ("\" is a field of the local class variable "); 1072 if (current_language->la_language == language_objc) 1073 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */ 1074 else 1075 printf_filtered ("`this'\n"); 1076 return; 1077 } 1078 1079 msymbol = lookup_minimal_symbol (exp, NULL, NULL); 1080 1081 if (msymbol != NULL) 1082 { 1083 load_addr = SYMBOL_VALUE_ADDRESS (msymbol); 1084 1085 printf_filtered ("Symbol \""); 1086 fprintf_symbol_filtered (gdb_stdout, exp, 1087 current_language->la_language, DMGL_ANSI); 1088 printf_filtered ("\" is at "); 1089 print_address_numeric (load_addr, 1, gdb_stdout); 1090 printf_filtered (" in a file compiled without debugging"); 1091 section = SYMBOL_BFD_SECTION (msymbol); 1092 if (section_is_overlay (section)) 1093 { 1094 load_addr = overlay_unmapped_address (load_addr, section); 1095 printf_filtered (",\n -- loaded at "); 1096 print_address_numeric (load_addr, 1, gdb_stdout); 1097 printf_filtered (" in overlay section %s", section->name); 1098 } 1099 printf_filtered (".\n"); 1100 } 1101 else 1102 error ("No symbol \"%s\" in current context.", exp); 1103 return; 1104 } 1105 1106 printf_filtered ("Symbol \""); 1107 fprintf_symbol_filtered (gdb_stdout, DEPRECATED_SYMBOL_NAME (sym), 1108 current_language->la_language, DMGL_ANSI); 1109 printf_filtered ("\" is "); 1110 val = SYMBOL_VALUE (sym); 1111 basereg = SYMBOL_BASEREG (sym); 1112 section = SYMBOL_BFD_SECTION (sym); 1113 1114 switch (SYMBOL_CLASS (sym)) 1115 { 1116 case LOC_CONST: 1117 case LOC_CONST_BYTES: 1118 printf_filtered ("constant"); 1119 break; 1120 1121 case LOC_LABEL: 1122 printf_filtered ("a label at address "); 1123 print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym), 1124 1, gdb_stdout); 1125 if (section_is_overlay (section)) 1126 { 1127 load_addr = overlay_unmapped_address (load_addr, section); 1128 printf_filtered (",\n -- loaded at "); 1129 print_address_numeric (load_addr, 1, gdb_stdout); 1130 printf_filtered (" in overlay section %s", section->name); 1131 } 1132 break; 1133 1134 case LOC_COMPUTED: 1135 case LOC_COMPUTED_ARG: 1136 /* FIXME: cagney/2004-01-26: It should be possible to 1137 unconditionally call the SYMBOL_OPS method when available. 1138 Unfortunately DWARF 2 stores the frame-base (instead of the 1139 function) location in a function's symbol. Oops! For the 1140 moment enable this when/where applicable. */ 1141 SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout); 1142 break; 1143 1144 case LOC_REGISTER: 1145 printf_filtered ("a variable in register %s", REGISTER_NAME (val)); 1146 break; 1147 1148 case LOC_STATIC: 1149 printf_filtered ("static storage at address "); 1150 print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym), 1151 1, gdb_stdout); 1152 if (section_is_overlay (section)) 1153 { 1154 load_addr = overlay_unmapped_address (load_addr, section); 1155 printf_filtered (",\n -- loaded at "); 1156 print_address_numeric (load_addr, 1, gdb_stdout); 1157 printf_filtered (" in overlay section %s", section->name); 1158 } 1159 break; 1160 1161 case LOC_INDIRECT: 1162 printf_filtered ("external global (indirect addressing), at address *("); 1163 print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym), 1164 1, gdb_stdout); 1165 printf_filtered (")"); 1166 if (section_is_overlay (section)) 1167 { 1168 load_addr = overlay_unmapped_address (load_addr, section); 1169 printf_filtered (",\n -- loaded at "); 1170 print_address_numeric (load_addr, 1, gdb_stdout); 1171 printf_filtered (" in overlay section %s", section->name); 1172 } 1173 break; 1174 1175 case LOC_REGPARM: 1176 printf_filtered ("an argument in register %s", REGISTER_NAME (val)); 1177 break; 1178 1179 case LOC_REGPARM_ADDR: 1180 printf_filtered ("address of an argument in register %s", REGISTER_NAME (val)); 1181 break; 1182 1183 case LOC_ARG: 1184 printf_filtered ("an argument at offset %ld", val); 1185 break; 1186 1187 case LOC_LOCAL_ARG: 1188 printf_filtered ("an argument at frame offset %ld", val); 1189 break; 1190 1191 case LOC_LOCAL: 1192 printf_filtered ("a local variable at frame offset %ld", val); 1193 break; 1194 1195 case LOC_REF_ARG: 1196 printf_filtered ("a reference argument at offset %ld", val); 1197 break; 1198 1199 case LOC_BASEREG: 1200 printf_filtered ("a variable at offset %ld from register %s", 1201 val, REGISTER_NAME (basereg)); 1202 break; 1203 1204 case LOC_BASEREG_ARG: 1205 printf_filtered ("an argument at offset %ld from register %s", 1206 val, REGISTER_NAME (basereg)); 1207 break; 1208 1209 case LOC_TYPEDEF: 1210 printf_filtered ("a typedef"); 1211 break; 1212 1213 case LOC_BLOCK: 1214 printf_filtered ("a function at address "); 1215 print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1216 1, gdb_stdout); 1217 if (section_is_overlay (section)) 1218 { 1219 load_addr = overlay_unmapped_address (load_addr, section); 1220 printf_filtered (",\n -- loaded at "); 1221 print_address_numeric (load_addr, 1, gdb_stdout); 1222 printf_filtered (" in overlay section %s", section->name); 1223 } 1224 break; 1225 1226 case LOC_UNRESOLVED: 1227 { 1228 struct minimal_symbol *msym; 1229 1230 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, NULL); 1231 if (msym == NULL) 1232 printf_filtered ("unresolved"); 1233 else 1234 { 1235 section = SYMBOL_BFD_SECTION (msym); 1236 printf_filtered ("static storage at address "); 1237 print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym), 1238 1, gdb_stdout); 1239 if (section_is_overlay (section)) 1240 { 1241 load_addr = overlay_unmapped_address (load_addr, section); 1242 printf_filtered (",\n -- loaded at "); 1243 print_address_numeric (load_addr, 1, gdb_stdout); 1244 printf_filtered (" in overlay section %s", section->name); 1245 } 1246 } 1247 } 1248 break; 1249 1250 case LOC_HP_THREAD_LOCAL_STATIC: 1251 printf_filtered ( 1252 "a thread-local variable at offset %ld from the thread base register %s", 1253 val, REGISTER_NAME (basereg)); 1254 break; 1255 1256 case LOC_OPTIMIZED_OUT: 1257 printf_filtered ("optimized out"); 1258 break; 1259 1260 default: 1261 printf_filtered ("of unknown (botched) type"); 1262 break; 1263 } 1264 printf_filtered (".\n"); 1265} 1266 1267void 1268x_command (char *exp, int from_tty) 1269{ 1270 struct expression *expr; 1271 struct format_data fmt; 1272 struct cleanup *old_chain; 1273 struct value *val; 1274 1275 fmt.format = last_format; 1276 fmt.size = last_size; 1277 fmt.count = 1; 1278 1279 if (exp && *exp == '/') 1280 { 1281 exp++; 1282 fmt = decode_format (&exp, last_format, last_size); 1283 } 1284 1285 /* If we have an expression, evaluate it and use it as the address. */ 1286 1287 if (exp != 0 && *exp != 0) 1288 { 1289 expr = parse_expression (exp); 1290 /* Cause expression not to be there any more 1291 if this command is repeated with Newline. 1292 But don't clobber a user-defined command's definition. */ 1293 if (from_tty) 1294 *exp = 0; 1295 old_chain = make_cleanup (free_current_contents, &expr); 1296 val = evaluate_expression (expr); 1297 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF) 1298 val = value_ind (val); 1299 /* In rvalue contexts, such as this, functions are coerced into 1300 pointers to functions. This makes "x/i main" work. */ 1301 if (/* last_format == 'i' && */ 1302 TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC 1303 && VALUE_LVAL (val) == lval_memory) 1304 next_address = VALUE_ADDRESS (val); 1305 else 1306 next_address = value_as_address (val); 1307 if (VALUE_BFD_SECTION (val)) 1308 next_section = VALUE_BFD_SECTION (val); 1309 do_cleanups (old_chain); 1310 } 1311 1312 do_examine (fmt, next_address, next_section); 1313 1314 /* If the examine succeeds, we remember its size and format for next time. */ 1315 last_size = fmt.size; 1316 last_format = fmt.format; 1317 1318 /* Set a couple of internal variables if appropriate. */ 1319 if (last_examine_value) 1320 { 1321 /* Make last address examined available to the user as $_. Use 1322 the correct pointer type. */ 1323 struct type *pointer_type 1324 = lookup_pointer_type (VALUE_TYPE (last_examine_value)); 1325 set_internalvar (lookup_internalvar ("_"), 1326 value_from_pointer (pointer_type, 1327 last_examine_address)); 1328 1329 /* Make contents of last address examined available to the user as $__. */ 1330 /* If the last value has not been fetched from memory then don't 1331 fetch it now - instead mark it by voiding the $__ variable. */ 1332 if (VALUE_LAZY (last_examine_value)) 1333 set_internalvar (lookup_internalvar ("__"), 1334 allocate_value (builtin_type_void)); 1335 else 1336 set_internalvar (lookup_internalvar ("__"), last_examine_value); 1337 } 1338} 1339 1340 1341/* Add an expression to the auto-display chain. 1342 Specify the expression. */ 1343 1344static void 1345display_command (char *exp, int from_tty) 1346{ 1347 struct format_data fmt; 1348 struct expression *expr; 1349 struct display *new; 1350 int display_it = 1; 1351 1352#if defined(TUI) 1353 /* NOTE: cagney/2003-02-13 The `tui_active' was previously 1354 `tui_version'. */ 1355 if (tui_active && exp != NULL && *exp == '$') 1356 display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE); 1357#endif 1358 1359 if (display_it) 1360 { 1361 if (exp == 0) 1362 { 1363 do_displays (); 1364 return; 1365 } 1366 1367 if (*exp == '/') 1368 { 1369 exp++; 1370 fmt = decode_format (&exp, 0, 0); 1371 if (fmt.size && fmt.format == 0) 1372 fmt.format = 'x'; 1373 if (fmt.format == 'i' || fmt.format == 's') 1374 fmt.size = 'b'; 1375 } 1376 else 1377 { 1378 fmt.format = 0; 1379 fmt.size = 0; 1380 fmt.count = 0; 1381 } 1382 1383 innermost_block = 0; 1384 expr = parse_expression (exp); 1385 1386 new = (struct display *) xmalloc (sizeof (struct display)); 1387 1388 new->exp = expr; 1389 new->block = innermost_block; 1390 new->next = display_chain; 1391 new->number = ++display_number; 1392 new->format = fmt; 1393 new->enabled_p = 1; 1394 display_chain = new; 1395 1396 if (from_tty && target_has_execution) 1397 do_one_display (new); 1398 1399 dont_repeat (); 1400 } 1401} 1402 1403static void 1404free_display (struct display *d) 1405{ 1406 xfree (d->exp); 1407 xfree (d); 1408} 1409 1410/* Clear out the display_chain. 1411 Done when new symtabs are loaded, since this invalidates 1412 the types stored in many expressions. */ 1413 1414void 1415clear_displays (void) 1416{ 1417 struct display *d; 1418 1419 while ((d = display_chain) != NULL) 1420 { 1421 xfree (d->exp); 1422 display_chain = d->next; 1423 xfree (d); 1424 } 1425} 1426 1427/* Delete the auto-display number NUM. */ 1428 1429static void 1430delete_display (int num) 1431{ 1432 struct display *d1, *d; 1433 1434 if (!display_chain) 1435 error ("No display number %d.", num); 1436 1437 if (display_chain->number == num) 1438 { 1439 d1 = display_chain; 1440 display_chain = d1->next; 1441 free_display (d1); 1442 } 1443 else 1444 for (d = display_chain;; d = d->next) 1445 { 1446 if (d->next == 0) 1447 error ("No display number %d.", num); 1448 if (d->next->number == num) 1449 { 1450 d1 = d->next; 1451 d->next = d1->next; 1452 free_display (d1); 1453 break; 1454 } 1455 } 1456} 1457 1458/* Delete some values from the auto-display chain. 1459 Specify the element numbers. */ 1460 1461static void 1462undisplay_command (char *args, int from_tty) 1463{ 1464 char *p = args; 1465 char *p1; 1466 int num; 1467 1468 if (args == 0) 1469 { 1470 if (query ("Delete all auto-display expressions? ")) 1471 clear_displays (); 1472 dont_repeat (); 1473 return; 1474 } 1475 1476 while (*p) 1477 { 1478 p1 = p; 1479 while (*p1 >= '0' && *p1 <= '9') 1480 p1++; 1481 if (*p1 && *p1 != ' ' && *p1 != '\t') 1482 error ("Arguments must be display numbers."); 1483 1484 num = atoi (p); 1485 1486 delete_display (num); 1487 1488 p = p1; 1489 while (*p == ' ' || *p == '\t') 1490 p++; 1491 } 1492 dont_repeat (); 1493} 1494 1495/* Display a single auto-display. 1496 Do nothing if the display cannot be printed in the current context, 1497 or if the display is disabled. */ 1498 1499static void 1500do_one_display (struct display *d) 1501{ 1502 int within_current_scope; 1503 1504 if (d->enabled_p == 0) 1505 return; 1506 1507 if (d->block) 1508 within_current_scope = contained_in (get_selected_block (0), d->block); 1509 else 1510 within_current_scope = 1; 1511 if (!within_current_scope) 1512 return; 1513 1514 current_display_number = d->number; 1515 1516 annotate_display_begin (); 1517 printf_filtered ("%d", d->number); 1518 annotate_display_number_end (); 1519 printf_filtered (": "); 1520 if (d->format.size) 1521 { 1522 CORE_ADDR addr; 1523 struct value *val; 1524 1525 annotate_display_format (); 1526 1527 printf_filtered ("x/"); 1528 if (d->format.count != 1) 1529 printf_filtered ("%d", d->format.count); 1530 printf_filtered ("%c", d->format.format); 1531 if (d->format.format != 'i' && d->format.format != 's') 1532 printf_filtered ("%c", d->format.size); 1533 printf_filtered (" "); 1534 1535 annotate_display_expression (); 1536 1537 print_expression (d->exp, gdb_stdout); 1538 annotate_display_expression_end (); 1539 1540 if (d->format.count != 1) 1541 printf_filtered ("\n"); 1542 else 1543 printf_filtered (" "); 1544 1545 val = evaluate_expression (d->exp); 1546 addr = value_as_address (val); 1547 if (d->format.format == 'i') 1548 addr = ADDR_BITS_REMOVE (addr); 1549 1550 annotate_display_value (); 1551 1552 do_examine (d->format, addr, VALUE_BFD_SECTION (val)); 1553 } 1554 else 1555 { 1556 annotate_display_format (); 1557 1558 if (d->format.format) 1559 printf_filtered ("/%c ", d->format.format); 1560 1561 annotate_display_expression (); 1562 1563 print_expression (d->exp, gdb_stdout); 1564 annotate_display_expression_end (); 1565 1566 printf_filtered (" = "); 1567 1568 annotate_display_expression (); 1569 1570 print_formatted (evaluate_expression (d->exp), 1571 d->format.format, d->format.size, gdb_stdout); 1572 printf_filtered ("\n"); 1573 } 1574 1575 annotate_display_end (); 1576 1577 gdb_flush (gdb_stdout); 1578 current_display_number = -1; 1579} 1580 1581/* Display all of the values on the auto-display chain which can be 1582 evaluated in the current scope. */ 1583 1584void 1585do_displays (void) 1586{ 1587 struct display *d; 1588 1589 for (d = display_chain; d; d = d->next) 1590 do_one_display (d); 1591} 1592 1593/* Delete the auto-display which we were in the process of displaying. 1594 This is done when there is an error or a signal. */ 1595 1596void 1597disable_display (int num) 1598{ 1599 struct display *d; 1600 1601 for (d = display_chain; d; d = d->next) 1602 if (d->number == num) 1603 { 1604 d->enabled_p = 0; 1605 return; 1606 } 1607 printf_unfiltered ("No display number %d.\n", num); 1608} 1609 1610void 1611disable_current_display (void) 1612{ 1613 if (current_display_number >= 0) 1614 { 1615 disable_display (current_display_number); 1616 fprintf_unfiltered (gdb_stderr, "Disabling display %d to avoid infinite recursion.\n", 1617 current_display_number); 1618 } 1619 current_display_number = -1; 1620} 1621 1622static void 1623display_info (char *ignore, int from_tty) 1624{ 1625 struct display *d; 1626 1627 if (!display_chain) 1628 printf_unfiltered ("There are no auto-display expressions now.\n"); 1629 else 1630 printf_filtered ("Auto-display expressions now in effect:\n\ 1631Num Enb Expression\n"); 1632 1633 for (d = display_chain; d; d = d->next) 1634 { 1635 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]); 1636 if (d->format.size) 1637 printf_filtered ("/%d%c%c ", d->format.count, d->format.size, 1638 d->format.format); 1639 else if (d->format.format) 1640 printf_filtered ("/%c ", d->format.format); 1641 print_expression (d->exp, gdb_stdout); 1642 if (d->block && !contained_in (get_selected_block (0), d->block)) 1643 printf_filtered (" (cannot be evaluated in the current context)"); 1644 printf_filtered ("\n"); 1645 gdb_flush (gdb_stdout); 1646 } 1647} 1648 1649static void 1650enable_display (char *args, int from_tty) 1651{ 1652 char *p = args; 1653 char *p1; 1654 int num; 1655 struct display *d; 1656 1657 if (p == 0) 1658 { 1659 for (d = display_chain; d; d = d->next) 1660 d->enabled_p = 1; 1661 } 1662 else 1663 while (*p) 1664 { 1665 p1 = p; 1666 while (*p1 >= '0' && *p1 <= '9') 1667 p1++; 1668 if (*p1 && *p1 != ' ' && *p1 != '\t') 1669 error ("Arguments must be display numbers."); 1670 1671 num = atoi (p); 1672 1673 for (d = display_chain; d; d = d->next) 1674 if (d->number == num) 1675 { 1676 d->enabled_p = 1; 1677 goto win; 1678 } 1679 printf_unfiltered ("No display number %d.\n", num); 1680 win: 1681 p = p1; 1682 while (*p == ' ' || *p == '\t') 1683 p++; 1684 } 1685} 1686 1687static void 1688disable_display_command (char *args, int from_tty) 1689{ 1690 char *p = args; 1691 char *p1; 1692 struct display *d; 1693 1694 if (p == 0) 1695 { 1696 for (d = display_chain; d; d = d->next) 1697 d->enabled_p = 0; 1698 } 1699 else 1700 while (*p) 1701 { 1702 p1 = p; 1703 while (*p1 >= '0' && *p1 <= '9') 1704 p1++; 1705 if (*p1 && *p1 != ' ' && *p1 != '\t') 1706 error ("Arguments must be display numbers."); 1707 1708 disable_display (atoi (p)); 1709 1710 p = p1; 1711 while (*p == ' ' || *p == '\t') 1712 p++; 1713 } 1714} 1715 1716 1717/* Print the value in stack frame FRAME of a variable 1718 specified by a struct symbol. */ 1719 1720void 1721print_variable_value (struct symbol *var, struct frame_info *frame, 1722 struct ui_file *stream) 1723{ 1724 struct value *val = read_var_value (var, frame); 1725 1726 value_print (val, stream, 0, Val_pretty_default); 1727} 1728 1729static void 1730printf_command (char *arg, int from_tty) 1731{ 1732 char *f = NULL; 1733 char *s = arg; 1734 char *string = NULL; 1735 struct value **val_args; 1736 char *substrings; 1737 char *current_substring; 1738 int nargs = 0; 1739 int allocated_args = 20; 1740 struct cleanup *old_cleanups; 1741 1742 val_args = (struct value **) xmalloc (allocated_args 1743 * sizeof (struct value *)); 1744 old_cleanups = make_cleanup (free_current_contents, &val_args); 1745 1746 if (s == 0) 1747 error_no_arg ("format-control string and values to print"); 1748 1749 /* Skip white space before format string */ 1750 while (*s == ' ' || *s == '\t') 1751 s++; 1752 1753 /* A format string should follow, enveloped in double quotes */ 1754 if (*s++ != '"') 1755 error ("Bad format string, missing '\"'."); 1756 1757 /* Parse the format-control string and copy it into the string STRING, 1758 processing some kinds of escape sequence. */ 1759 1760 f = string = (char *) alloca (strlen (s) + 1); 1761 1762 while (*s != '"') 1763 { 1764 int c = *s++; 1765 switch (c) 1766 { 1767 case '\0': 1768 error ("Bad format string, non-terminated '\"'."); 1769 1770 case '\\': 1771 switch (c = *s++) 1772 { 1773 case '\\': 1774 *f++ = '\\'; 1775 break; 1776 case 'a': 1777 *f++ = '\a'; 1778 break; 1779 case 'b': 1780 *f++ = '\b'; 1781 break; 1782 case 'f': 1783 *f++ = '\f'; 1784 break; 1785 case 'n': 1786 *f++ = '\n'; 1787 break; 1788 case 'r': 1789 *f++ = '\r'; 1790 break; 1791 case 't': 1792 *f++ = '\t'; 1793 break; 1794 case 'v': 1795 *f++ = '\v'; 1796 break; 1797 case '"': 1798 *f++ = '"'; 1799 break; 1800 default: 1801 /* ??? TODO: handle other escape sequences */ 1802 error ("Unrecognized escape character \\%c in format string.", 1803 c); 1804 } 1805 break; 1806 1807 default: 1808 *f++ = c; 1809 } 1810 } 1811 1812 /* Skip over " and following space and comma. */ 1813 s++; 1814 *f++ = '\0'; 1815 while (*s == ' ' || *s == '\t') 1816 s++; 1817 1818 if (*s != ',' && *s != 0) 1819 error ("Invalid argument syntax"); 1820 1821 if (*s == ',') 1822 s++; 1823 while (*s == ' ' || *s == '\t') 1824 s++; 1825 1826 /* Need extra space for the '\0's. Doubling the size is sufficient. */ 1827 substrings = alloca (strlen (string) * 2); 1828 current_substring = substrings; 1829 1830 { 1831 /* Now scan the string for %-specs and see what kinds of args they want. 1832 argclass[I] classifies the %-specs so we can give printf_filtered 1833 something of the right size. */ 1834 1835 enum argclass 1836 { 1837 no_arg, int_arg, string_arg, double_arg, long_long_arg 1838 }; 1839 enum argclass *argclass; 1840 enum argclass this_argclass; 1841 char *last_arg; 1842 int nargs_wanted; 1843 int lcount; 1844 int i; 1845 1846 argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass); 1847 nargs_wanted = 0; 1848 f = string; 1849 last_arg = string; 1850 while (*f) 1851 if (*f++ == '%') 1852 { 1853 lcount = 0; 1854 while (strchr ("0123456789.hlL-+ #", *f)) 1855 { 1856 if (*f == 'l' || *f == 'L') 1857 lcount++; 1858 f++; 1859 } 1860 switch (*f) 1861 { 1862 case 's': 1863 this_argclass = string_arg; 1864 break; 1865 1866 case 'e': 1867 case 'f': 1868 case 'g': 1869 this_argclass = double_arg; 1870 break; 1871 1872 case '*': 1873 error ("`*' not supported for precision or width in printf"); 1874 1875 case 'n': 1876 error ("Format specifier `n' not supported in printf"); 1877 1878 case '%': 1879 this_argclass = no_arg; 1880 break; 1881 1882 default: 1883 if (lcount > 1) 1884 this_argclass = long_long_arg; 1885 else 1886 this_argclass = int_arg; 1887 break; 1888 } 1889 f++; 1890 if (this_argclass != no_arg) 1891 { 1892 strncpy (current_substring, last_arg, f - last_arg); 1893 current_substring += f - last_arg; 1894 *current_substring++ = '\0'; 1895 last_arg = f; 1896 argclass[nargs_wanted++] = this_argclass; 1897 } 1898 } 1899 1900 /* Now, parse all arguments and evaluate them. 1901 Store the VALUEs in VAL_ARGS. */ 1902 1903 while (*s != '\0') 1904 { 1905 char *s1; 1906 if (nargs == allocated_args) 1907 val_args = (struct value **) xrealloc ((char *) val_args, 1908 (allocated_args *= 2) 1909 * sizeof (struct value *)); 1910 s1 = s; 1911 val_args[nargs] = parse_to_comma_and_eval (&s1); 1912 1913 /* If format string wants a float, unchecked-convert the value to 1914 floating point of the same size */ 1915 1916 if (argclass[nargs] == double_arg) 1917 { 1918 struct type *type = VALUE_TYPE (val_args[nargs]); 1919 if (TYPE_LENGTH (type) == sizeof (float)) 1920 VALUE_TYPE (val_args[nargs]) = builtin_type_float; 1921 if (TYPE_LENGTH (type) == sizeof (double)) 1922 VALUE_TYPE (val_args[nargs]) = builtin_type_double; 1923 } 1924 nargs++; 1925 s = s1; 1926 if (*s == ',') 1927 s++; 1928 } 1929 1930 if (nargs != nargs_wanted) 1931 error ("Wrong number of arguments for specified format-string"); 1932 1933 /* Now actually print them. */ 1934 current_substring = substrings; 1935 for (i = 0; i < nargs; i++) 1936 { 1937 switch (argclass[i]) 1938 { 1939 case string_arg: 1940 { 1941 char *str; 1942 CORE_ADDR tem; 1943 int j; 1944 tem = value_as_address (val_args[i]); 1945 1946 /* This is a %s argument. Find the length of the string. */ 1947 for (j = 0;; j++) 1948 { 1949 char c; 1950 QUIT; 1951 read_memory (tem + j, &c, 1); 1952 if (c == 0) 1953 break; 1954 } 1955 1956 /* Copy the string contents into a string inside GDB. */ 1957 str = (char *) alloca (j + 1); 1958 if (j != 0) 1959 read_memory (tem, str, j); 1960 str[j] = 0; 1961 1962 printf_filtered (current_substring, str); 1963 } 1964 break; 1965 case double_arg: 1966 { 1967 double val = value_as_double (val_args[i]); 1968 printf_filtered (current_substring, val); 1969 break; 1970 } 1971 case long_long_arg: 1972#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG) 1973 { 1974 long long val = value_as_long (val_args[i]); 1975 printf_filtered (current_substring, val); 1976 break; 1977 } 1978#else 1979 error ("long long not supported in printf"); 1980#endif 1981 case int_arg: 1982 { 1983 /* FIXME: there should be separate int_arg and long_arg. */ 1984 long val = value_as_long (val_args[i]); 1985 printf_filtered (current_substring, val); 1986 break; 1987 } 1988 default: /* purecov: deadcode */ 1989 error ("internal error in printf_command"); /* purecov: deadcode */ 1990 } 1991 /* Skip to the next substring. */ 1992 current_substring += strlen (current_substring) + 1; 1993 } 1994 /* Print the portion of the format string after the last argument. */ 1995 puts_filtered (last_arg); 1996 } 1997 do_cleanups (old_cleanups); 1998} 1999 2000void 2001_initialize_printcmd (void) 2002{ 2003 struct cmd_list_element *c; 2004 2005 current_display_number = -1; 2006 2007 add_info ("address", address_info, 2008 "Describe where symbol SYM is stored."); 2009 2010 add_info ("symbol", sym_info, 2011 "Describe what symbol is at location ADDR.\n\ 2012Only for symbols with fixed locations (global or static scope)."); 2013 2014 add_com ("x", class_vars, x_command, 2015 concat ("Examine memory: x/FMT ADDRESS.\n\ 2016ADDRESS is an expression for the memory address to examine.\n\ 2017FMT is a repeat count followed by a format letter and a size letter.\n\ 2018Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\ 2019 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n", 2020 "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\ 2021The specified number of objects of the specified size are printed\n\ 2022according to the format.\n\n\ 2023Defaults for format and size letters are those previously used.\n\ 2024Default count is 1. Default address is following last thing printed\n\ 2025with this command or \"print\".", NULL)); 2026 2027#if 0 2028 add_com ("whereis", class_vars, whereis_command, 2029 "Print line number and file of definition of variable."); 2030#endif 2031 2032 add_info ("display", display_info, 2033 "Expressions to display when program stops, with code numbers."); 2034 2035 add_cmd ("undisplay", class_vars, undisplay_command, 2036 "Cancel some expressions to be displayed when program stops.\n\ 2037Arguments are the code numbers of the expressions to stop displaying.\n\ 2038No argument means cancel all automatic-display expressions.\n\ 2039\"delete display\" has the same effect as this command.\n\ 2040Do \"info display\" to see current list of code numbers.", 2041 &cmdlist); 2042 2043 add_com ("display", class_vars, display_command, 2044 "Print value of expression EXP each time the program stops.\n\ 2045/FMT may be used before EXP as in the \"print\" command.\n\ 2046/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\ 2047as in the \"x\" command, and then EXP is used to get the address to examine\n\ 2048and examining is done as in the \"x\" command.\n\n\ 2049With no argument, display all currently requested auto-display expressions.\n\ 2050Use \"undisplay\" to cancel display requests previously made." 2051 ); 2052 2053 add_cmd ("display", class_vars, enable_display, 2054 "Enable some expressions to be displayed when program stops.\n\ 2055Arguments are the code numbers of the expressions to resume displaying.\n\ 2056No argument means enable all automatic-display expressions.\n\ 2057Do \"info display\" to see current list of code numbers.", &enablelist); 2058 2059 add_cmd ("display", class_vars, disable_display_command, 2060 "Disable some expressions to be displayed when program stops.\n\ 2061Arguments are the code numbers of the expressions to stop displaying.\n\ 2062No argument means disable all automatic-display expressions.\n\ 2063Do \"info display\" to see current list of code numbers.", &disablelist); 2064 2065 add_cmd ("display", class_vars, undisplay_command, 2066 "Cancel some expressions to be displayed when program stops.\n\ 2067Arguments are the code numbers of the expressions to stop displaying.\n\ 2068No argument means cancel all automatic-display expressions.\n\ 2069Do \"info display\" to see current list of code numbers.", &deletelist); 2070 2071 add_com ("printf", class_vars, printf_command, 2072 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\ 2073This is useful for formatted output in user-defined commands."); 2074 2075 add_com ("output", class_vars, output_command, 2076 "Like \"print\" but don't put in value history and don't print newline.\n\ 2077This is useful in user-defined commands."); 2078 2079 add_prefix_cmd ("set", class_vars, set_command, 2080 concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\ 2081syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2082example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2083with $), a register (a few standard names starting with $), or an actual\n\ 2084variable in the program being debugged. EXP is any valid expression.\n", 2085 "Use \"set variable\" for variables with names identical to set subcommands.\n\ 2086\nWith a subcommand, this command modifies parts of the gdb environment.\n\ 2087You can see these environment settings with the \"show\" command.", NULL), 2088 &setlist, "set ", 1, &cmdlist); 2089 if (dbx_commands) 2090 add_com ("assign", class_vars, set_command, concat ("Evaluate expression \ 2091EXP and assign result to variable VAR, using assignment\n\ 2092syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2093example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2094with $), a register (a few standard names starting with $), or an actual\n\ 2095variable in the program being debugged. EXP is any valid expression.\n", 2096 "Use \"set variable\" for variables with names identical to set subcommands.\n\ 2097\nWith a subcommand, this command modifies parts of the gdb environment.\n\ 2098You can see these environment settings with the \"show\" command.", NULL)); 2099 2100 /* "call" is the same as "set", but handy for dbx users to call fns. */ 2101 c = add_com ("call", class_vars, call_command, 2102 "Call a function in the program.\n\ 2103The argument is the function name and arguments, in the notation of the\n\ 2104current working language. The result is printed and saved in the value\n\ 2105history, if it is not void."); 2106 set_cmd_completer (c, location_completer); 2107 2108 add_cmd ("variable", class_vars, set_command, 2109 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\ 2110syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\ 2111example). VAR may be a debugger \"convenience\" variable (names starting\n\ 2112with $), a register (a few standard names starting with $), or an actual\n\ 2113variable in the program being debugged. EXP is any valid expression.\n\ 2114This may usually be abbreviated to simply \"set\".", 2115 &setlist); 2116 2117 c = add_com ("print", class_vars, print_command, 2118 concat ("Print value of expression EXP.\n\ 2119Variables accessible are those of the lexical environment of the selected\n\ 2120stack frame, plus all those whose scope is global or an entire file.\n\ 2121\n\ 2122$NUM gets previous value number NUM. $ and $$ are the last two values.\n\ 2123$$NUM refers to NUM'th value back from the last one.\n\ 2124Names starting with $ refer to registers (with the values they would have\n", 2125 "if the program were to return to the stack frame now selected, restoring\n\ 2126all registers saved by frames farther in) or else to debugger\n\ 2127\"convenience\" variables (any such name not a known register).\n\ 2128Use assignment expressions to give values to convenience variables.\n", 2129 "\n\ 2130{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\ 2131@ is a binary operator for treating consecutive data objects\n\ 2132anywhere in memory as an array. FOO@NUM gives an array whose first\n\ 2133element is FOO, whose second element is stored in the space following\n\ 2134where FOO is stored, etc. FOO must be an expression whose value\n\ 2135resides in memory.\n", 2136 "\n\ 2137EXP may be preceded with /FMT, where FMT is a format letter\n\ 2138but no count or size letter (see \"x\" command).", NULL)); 2139 set_cmd_completer (c, location_completer); 2140 add_com_alias ("p", "print", class_vars, 1); 2141 2142 c = add_com ("inspect", class_vars, inspect_command, 2143 "Same as \"print\" command, except that if you are running in the epoch\n\ 2144environment, the value is printed in its own window."); 2145 set_cmd_completer (c, location_completer); 2146 2147 deprecated_add_show_from_set 2148 (add_set_cmd ("max-symbolic-offset", no_class, var_uinteger, 2149 (char *) &max_symbolic_offset, 2150 "Set the largest offset that will be printed in <symbol+1234> form.", 2151 &setprintlist), 2152 &showprintlist); 2153 deprecated_add_show_from_set 2154 (add_set_cmd ("symbol-filename", no_class, var_boolean, 2155 (char *) &print_symbol_filename, "\ 2156Set printing of source filename and line number with <symbol>.", 2157 &setprintlist), 2158 &showprintlist); 2159 2160 /* For examine/instruction a single byte quantity is specified as 2161 the data. This avoids problems with value_at_lazy() requiring a 2162 valid data type (and rejecting VOID). */ 2163 examine_i_type = init_type (TYPE_CODE_INT, 1, 0, "examine_i_type", NULL); 2164 2165 examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL); 2166 examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL); 2167 examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL); 2168 examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL); 2169 2170} 2171