1 /* Print values for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2013 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 "gdb_string.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "value.h" 25 #include "gdbcore.h" 26 #include "gdbcmd.h" 27 #include "target.h" 28 #include "language.h" 29 #include "annotate.h" 30 #include "valprint.h" 31 #include "floatformat.h" 32 #include "doublest.h" 33 #include "exceptions.h" 34 #include "dfp.h" 35 #include "python/python.h" 36 #include "ada-lang.h" 37 #include "gdb_obstack.h" 38 #include "charset.h" 39 #include <ctype.h> 40 41 #include <errno.h> 42 43 /* Maximum number of wchars returned from wchar_iterate. */ 44 #define MAX_WCHARS 4 45 46 /* A convenience macro to compute the size of a wchar_t buffer containing X 47 characters. */ 48 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t)) 49 50 /* Character buffer size saved while iterating over wchars. */ 51 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS) 52 53 /* A structure to encapsulate state information from iterated 54 character conversions. */ 55 struct converted_character 56 { 57 /* The number of characters converted. */ 58 int num_chars; 59 60 /* The result of the conversion. See charset.h for more. */ 61 enum wchar_iterate_result result; 62 63 /* The (saved) converted character(s). */ 64 gdb_wchar_t chars[WCHAR_BUFLEN_MAX]; 65 66 /* The first converted target byte. */ 67 const gdb_byte *buf; 68 69 /* The number of bytes converted. */ 70 size_t buflen; 71 72 /* How many times this character(s) is repeated. */ 73 int repeat_count; 74 }; 75 76 typedef struct converted_character converted_character_d; 77 DEF_VEC_O (converted_character_d); 78 79 80 /* Prototypes for local functions */ 81 82 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, 83 int len, int *errnoptr); 84 85 static void show_print (char *, int); 86 87 static void set_print (char *, int); 88 89 static void set_radix (char *, int); 90 91 static void show_radix (char *, int); 92 93 static void set_input_radix (char *, int, struct cmd_list_element *); 94 95 static void set_input_radix_1 (int, unsigned); 96 97 static void set_output_radix (char *, int, struct cmd_list_element *); 98 99 static void set_output_radix_1 (int, unsigned); 100 101 void _initialize_valprint (void); 102 103 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */ 104 105 struct value_print_options user_print_options = 106 { 107 Val_pretty_default, /* pretty */ 108 0, /* prettyprint_arrays */ 109 0, /* prettyprint_structs */ 110 0, /* vtblprint */ 111 1, /* unionprint */ 112 1, /* addressprint */ 113 0, /* objectprint */ 114 PRINT_MAX_DEFAULT, /* print_max */ 115 10, /* repeat_count_threshold */ 116 0, /* output_format */ 117 0, /* format */ 118 0, /* stop_print_at_null */ 119 0, /* print_array_indexes */ 120 0, /* deref_ref */ 121 1, /* static_field_print */ 122 1, /* pascal_static_field_print */ 123 0, /* raw */ 124 0, /* summary */ 125 1 /* symbol_print */ 126 }; 127 128 /* Initialize *OPTS to be a copy of the user print options. */ 129 void 130 get_user_print_options (struct value_print_options *opts) 131 { 132 *opts = user_print_options; 133 } 134 135 /* Initialize *OPTS to be a copy of the user print options, but with 136 pretty-printing disabled. */ 137 void 138 get_raw_print_options (struct value_print_options *opts) 139 { 140 *opts = user_print_options; 141 opts->pretty = Val_no_prettyprint; 142 } 143 144 /* Initialize *OPTS to be a copy of the user print options, but using 145 FORMAT as the formatting option. */ 146 void 147 get_formatted_print_options (struct value_print_options *opts, 148 char format) 149 { 150 *opts = user_print_options; 151 opts->format = format; 152 } 153 154 static void 155 show_print_max (struct ui_file *file, int from_tty, 156 struct cmd_list_element *c, const char *value) 157 { 158 fprintf_filtered (file, 159 _("Limit on string chars or array " 160 "elements to print is %s.\n"), 161 value); 162 } 163 164 165 /* Default input and output radixes, and output format letter. */ 166 167 unsigned input_radix = 10; 168 static void 169 show_input_radix (struct ui_file *file, int from_tty, 170 struct cmd_list_element *c, const char *value) 171 { 172 fprintf_filtered (file, 173 _("Default input radix for entering numbers is %s.\n"), 174 value); 175 } 176 177 unsigned output_radix = 10; 178 static void 179 show_output_radix (struct ui_file *file, int from_tty, 180 struct cmd_list_element *c, const char *value) 181 { 182 fprintf_filtered (file, 183 _("Default output radix for printing of values is %s.\n"), 184 value); 185 } 186 187 /* By default we print arrays without printing the index of each element in 188 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */ 189 190 static void 191 show_print_array_indexes (struct ui_file *file, int from_tty, 192 struct cmd_list_element *c, const char *value) 193 { 194 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value); 195 } 196 197 /* Print repeat counts if there are more than this many repetitions of an 198 element in an array. Referenced by the low level language dependent 199 print routines. */ 200 201 static void 202 show_repeat_count_threshold (struct ui_file *file, int from_tty, 203 struct cmd_list_element *c, const char *value) 204 { 205 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"), 206 value); 207 } 208 209 /* If nonzero, stops printing of char arrays at first null. */ 210 211 static void 212 show_stop_print_at_null (struct ui_file *file, int from_tty, 213 struct cmd_list_element *c, const char *value) 214 { 215 fprintf_filtered (file, 216 _("Printing of char arrays to stop " 217 "at first null char is %s.\n"), 218 value); 219 } 220 221 /* Controls pretty printing of structures. */ 222 223 static void 224 show_prettyprint_structs (struct ui_file *file, int from_tty, 225 struct cmd_list_element *c, const char *value) 226 { 227 fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value); 228 } 229 230 /* Controls pretty printing of arrays. */ 231 232 static void 233 show_prettyprint_arrays (struct ui_file *file, int from_tty, 234 struct cmd_list_element *c, const char *value) 235 { 236 fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value); 237 } 238 239 /* If nonzero, causes unions inside structures or other unions to be 240 printed. */ 241 242 static void 243 show_unionprint (struct ui_file *file, int from_tty, 244 struct cmd_list_element *c, const char *value) 245 { 246 fprintf_filtered (file, 247 _("Printing of unions interior to structures is %s.\n"), 248 value); 249 } 250 251 /* If nonzero, causes machine addresses to be printed in certain contexts. */ 252 253 static void 254 show_addressprint (struct ui_file *file, int from_tty, 255 struct cmd_list_element *c, const char *value) 256 { 257 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value); 258 } 259 260 static void 261 show_symbol_print (struct ui_file *file, int from_tty, 262 struct cmd_list_element *c, const char *value) 263 { 264 fprintf_filtered (file, 265 _("Printing of symbols when printing pointers is %s.\n"), 266 value); 267 } 268 269 270 271 /* A helper function for val_print. When printing in "summary" mode, 272 we want to print scalar arguments, but not aggregate arguments. 273 This function distinguishes between the two. */ 274 275 static int 276 scalar_type_p (struct type *type) 277 { 278 CHECK_TYPEDEF (type); 279 while (TYPE_CODE (type) == TYPE_CODE_REF) 280 { 281 type = TYPE_TARGET_TYPE (type); 282 CHECK_TYPEDEF (type); 283 } 284 switch (TYPE_CODE (type)) 285 { 286 case TYPE_CODE_ARRAY: 287 case TYPE_CODE_STRUCT: 288 case TYPE_CODE_UNION: 289 case TYPE_CODE_SET: 290 case TYPE_CODE_STRING: 291 return 0; 292 default: 293 return 1; 294 } 295 } 296 297 /* See its definition in value.h. */ 298 299 int 300 valprint_check_validity (struct ui_file *stream, 301 struct type *type, 302 int embedded_offset, 303 const struct value *val) 304 { 305 CHECK_TYPEDEF (type); 306 307 if (TYPE_CODE (type) != TYPE_CODE_UNION 308 && TYPE_CODE (type) != TYPE_CODE_STRUCT 309 && TYPE_CODE (type) != TYPE_CODE_ARRAY) 310 { 311 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset, 312 TARGET_CHAR_BIT * TYPE_LENGTH (type))) 313 { 314 val_print_optimized_out (stream); 315 return 0; 316 } 317 318 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset, 319 TARGET_CHAR_BIT * TYPE_LENGTH (type))) 320 { 321 fputs_filtered (_("<synthetic pointer>"), stream); 322 return 0; 323 } 324 325 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) 326 { 327 val_print_unavailable (stream); 328 return 0; 329 } 330 } 331 332 return 1; 333 } 334 335 void 336 val_print_optimized_out (struct ui_file *stream) 337 { 338 fprintf_filtered (stream, _("<optimized out>")); 339 } 340 341 void 342 val_print_unavailable (struct ui_file *stream) 343 { 344 fprintf_filtered (stream, _("<unavailable>")); 345 } 346 347 void 348 val_print_invalid_address (struct ui_file *stream) 349 { 350 fprintf_filtered (stream, _("<invalid address>")); 351 } 352 353 /* A generic val_print that is suitable for use by language 354 implementations of the la_val_print method. This function can 355 handle most type codes, though not all, notably exception 356 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by 357 the caller. 358 359 Most arguments are as to val_print. 360 361 The additional DECORATIONS argument can be used to customize the 362 output in some small, language-specific ways. */ 363 364 void 365 generic_val_print (struct type *type, const gdb_byte *valaddr, 366 int embedded_offset, CORE_ADDR address, 367 struct ui_file *stream, int recurse, 368 const struct value *original_value, 369 const struct value_print_options *options, 370 const struct generic_val_print_decorations *decorations) 371 { 372 struct gdbarch *gdbarch = get_type_arch (type); 373 unsigned int i = 0; /* Number of characters printed. */ 374 unsigned len; 375 struct type *elttype, *unresolved_elttype; 376 struct type *unresolved_type = type; 377 LONGEST val; 378 CORE_ADDR addr; 379 380 CHECK_TYPEDEF (type); 381 switch (TYPE_CODE (type)) 382 { 383 case TYPE_CODE_ARRAY: 384 unresolved_elttype = TYPE_TARGET_TYPE (type); 385 elttype = check_typedef (unresolved_elttype); 386 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0) 387 { 388 LONGEST low_bound, high_bound; 389 390 if (!get_array_bounds (type, &low_bound, &high_bound)) 391 error (_("Could not determine the array high bound")); 392 393 if (options->prettyprint_arrays) 394 { 395 print_spaces_filtered (2 + 2 * recurse, stream); 396 } 397 398 fprintf_filtered (stream, "{"); 399 val_print_array_elements (type, valaddr, embedded_offset, 400 address, stream, 401 recurse, original_value, options, 0); 402 fprintf_filtered (stream, "}"); 403 break; 404 } 405 /* Array of unspecified length: treat like pointer to first 406 elt. */ 407 addr = address + embedded_offset; 408 goto print_unpacked_pointer; 409 410 case TYPE_CODE_MEMBERPTR: 411 val_print_scalar_formatted (type, valaddr, embedded_offset, 412 original_value, options, 0, stream); 413 break; 414 415 case TYPE_CODE_PTR: 416 if (options->format && options->format != 's') 417 { 418 val_print_scalar_formatted (type, valaddr, embedded_offset, 419 original_value, options, 0, stream); 420 break; 421 } 422 unresolved_elttype = TYPE_TARGET_TYPE (type); 423 elttype = check_typedef (unresolved_elttype); 424 { 425 addr = unpack_pointer (type, valaddr + embedded_offset); 426 print_unpacked_pointer: 427 428 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) 429 { 430 /* Try to print what function it points to. */ 431 print_function_pointer_address (options, gdbarch, addr, stream); 432 return; 433 } 434 435 if (options->symbol_print) 436 print_address_demangle (options, gdbarch, addr, stream, demangle); 437 else if (options->addressprint) 438 fputs_filtered (paddress (gdbarch, addr), stream); 439 } 440 break; 441 442 case TYPE_CODE_REF: 443 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 444 if (options->addressprint) 445 { 446 CORE_ADDR addr 447 = extract_typed_address (valaddr + embedded_offset, type); 448 449 fprintf_filtered (stream, "@"); 450 fputs_filtered (paddress (gdbarch, addr), stream); 451 if (options->deref_ref) 452 fputs_filtered (": ", stream); 453 } 454 /* De-reference the reference. */ 455 if (options->deref_ref) 456 { 457 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 458 { 459 struct value *deref_val; 460 461 deref_val = coerce_ref_if_computed (original_value); 462 if (deref_val != NULL) 463 { 464 /* More complicated computed references are not supported. */ 465 gdb_assert (embedded_offset == 0); 466 } 467 else 468 deref_val = value_at (TYPE_TARGET_TYPE (type), 469 unpack_pointer (type, 470 (valaddr 471 + embedded_offset))); 472 473 common_val_print (deref_val, stream, recurse, options, 474 current_language); 475 } 476 else 477 fputs_filtered ("???", stream); 478 } 479 break; 480 481 case TYPE_CODE_ENUM: 482 if (options->format) 483 { 484 val_print_scalar_formatted (type, valaddr, embedded_offset, 485 original_value, options, 0, stream); 486 break; 487 } 488 len = TYPE_NFIELDS (type); 489 val = unpack_long (type, valaddr + embedded_offset); 490 for (i = 0; i < len; i++) 491 { 492 QUIT; 493 if (val == TYPE_FIELD_ENUMVAL (type, i)) 494 { 495 break; 496 } 497 } 498 if (i < len) 499 { 500 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 501 } 502 else if (TYPE_FLAG_ENUM (type)) 503 { 504 int first = 1; 505 506 /* We have a "flag" enum, so we try to decompose it into 507 pieces as appropriate. A flag enum has disjoint 508 constants by definition. */ 509 fputs_filtered ("(", stream); 510 for (i = 0; i < len; ++i) 511 { 512 QUIT; 513 514 if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0) 515 { 516 if (!first) 517 fputs_filtered (" | ", stream); 518 first = 0; 519 520 val &= ~TYPE_FIELD_ENUMVAL (type, i); 521 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 522 } 523 } 524 525 if (first || val != 0) 526 { 527 if (!first) 528 fputs_filtered (" | ", stream); 529 fputs_filtered ("unknown: ", stream); 530 print_longest (stream, 'd', 0, val); 531 } 532 533 fputs_filtered (")", stream); 534 } 535 else 536 print_longest (stream, 'd', 0, val); 537 break; 538 539 case TYPE_CODE_FLAGS: 540 if (options->format) 541 val_print_scalar_formatted (type, valaddr, embedded_offset, 542 original_value, options, 0, stream); 543 else 544 val_print_type_code_flags (type, valaddr + embedded_offset, 545 stream); 546 break; 547 548 case TYPE_CODE_FUNC: 549 case TYPE_CODE_METHOD: 550 if (options->format) 551 { 552 val_print_scalar_formatted (type, valaddr, embedded_offset, 553 original_value, options, 0, stream); 554 break; 555 } 556 /* FIXME, we should consider, at least for ANSI C language, 557 eliminating the distinction made between FUNCs and POINTERs 558 to FUNCs. */ 559 fprintf_filtered (stream, "{"); 560 type_print (type, "", stream, -1); 561 fprintf_filtered (stream, "} "); 562 /* Try to print what function it points to, and its address. */ 563 print_address_demangle (options, gdbarch, address, stream, demangle); 564 break; 565 566 case TYPE_CODE_BOOL: 567 if (options->format || options->output_format) 568 { 569 struct value_print_options opts = *options; 570 opts.format = (options->format ? options->format 571 : options->output_format); 572 val_print_scalar_formatted (type, valaddr, embedded_offset, 573 original_value, &opts, 0, stream); 574 } 575 else 576 { 577 val = unpack_long (type, valaddr + embedded_offset); 578 if (val == 0) 579 fputs_filtered (decorations->false_name, stream); 580 else if (val == 1) 581 fputs_filtered (decorations->true_name, stream); 582 else 583 print_longest (stream, 'd', 0, val); 584 } 585 break; 586 587 case TYPE_CODE_RANGE: 588 /* FIXME: create_range_type does not set the unsigned bit in a 589 range type (I think it probably should copy it from the 590 target type), so we won't print values which are too large to 591 fit in a signed integer correctly. */ 592 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just 593 print with the target type, though, because the size of our 594 type and the target type might differ). */ 595 596 /* FALLTHROUGH */ 597 598 case TYPE_CODE_INT: 599 if (options->format || options->output_format) 600 { 601 struct value_print_options opts = *options; 602 603 opts.format = (options->format ? options->format 604 : options->output_format); 605 val_print_scalar_formatted (type, valaddr, embedded_offset, 606 original_value, &opts, 0, stream); 607 } 608 else 609 val_print_type_code_int (type, valaddr + embedded_offset, stream); 610 break; 611 612 case TYPE_CODE_CHAR: 613 if (options->format || options->output_format) 614 { 615 struct value_print_options opts = *options; 616 617 opts.format = (options->format ? options->format 618 : options->output_format); 619 val_print_scalar_formatted (type, valaddr, embedded_offset, 620 original_value, &opts, 0, stream); 621 } 622 else 623 { 624 val = unpack_long (type, valaddr + embedded_offset); 625 if (TYPE_UNSIGNED (type)) 626 fprintf_filtered (stream, "%u", (unsigned int) val); 627 else 628 fprintf_filtered (stream, "%d", (int) val); 629 fputs_filtered (" ", stream); 630 LA_PRINT_CHAR (val, unresolved_type, stream); 631 } 632 break; 633 634 case TYPE_CODE_FLT: 635 if (options->format) 636 { 637 val_print_scalar_formatted (type, valaddr, embedded_offset, 638 original_value, options, 0, stream); 639 } 640 else 641 { 642 print_floating (valaddr + embedded_offset, type, stream); 643 } 644 break; 645 646 case TYPE_CODE_DECFLOAT: 647 if (options->format) 648 val_print_scalar_formatted (type, valaddr, embedded_offset, 649 original_value, options, 0, stream); 650 else 651 print_decimal_floating (valaddr + embedded_offset, 652 type, stream); 653 break; 654 655 case TYPE_CODE_VOID: 656 fputs_filtered (decorations->void_name, stream); 657 break; 658 659 case TYPE_CODE_ERROR: 660 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); 661 break; 662 663 case TYPE_CODE_UNDEF: 664 /* This happens (without TYPE_FLAG_STUB set) on systems which 665 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a 666 "struct foo *bar" and no complete type for struct foo in that 667 file. */ 668 fprintf_filtered (stream, _("<incomplete type>")); 669 break; 670 671 case TYPE_CODE_COMPLEX: 672 fprintf_filtered (stream, "%s", decorations->complex_prefix); 673 if (options->format) 674 val_print_scalar_formatted (TYPE_TARGET_TYPE (type), 675 valaddr, embedded_offset, 676 original_value, options, 0, stream); 677 else 678 print_floating (valaddr + embedded_offset, 679 TYPE_TARGET_TYPE (type), 680 stream); 681 fprintf_filtered (stream, "%s", decorations->complex_infix); 682 if (options->format) 683 val_print_scalar_formatted (TYPE_TARGET_TYPE (type), 684 valaddr, 685 embedded_offset 686 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), 687 original_value, 688 options, 0, stream); 689 else 690 print_floating (valaddr + embedded_offset 691 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)), 692 TYPE_TARGET_TYPE (type), 693 stream); 694 fprintf_filtered (stream, "%s", decorations->complex_suffix); 695 break; 696 697 case TYPE_CODE_UNION: 698 case TYPE_CODE_STRUCT: 699 case TYPE_CODE_METHODPTR: 700 default: 701 error (_("Unhandled type code %d in symbol table."), 702 TYPE_CODE (type)); 703 } 704 gdb_flush (stream); 705 } 706 707 /* Print using the given LANGUAGE the data of type TYPE located at 708 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the 709 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream 710 STREAM according to OPTIONS. VAL is the whole object that came 711 from ADDRESS. VALADDR must point to the head of VAL's contents 712 buffer. 713 714 The language printers will pass down an adjusted EMBEDDED_OFFSET to 715 further helper subroutines as subfields of TYPE are printed. In 716 such cases, VALADDR is passed down unadjusted, as well as VAL, so 717 that VAL can be queried for metadata about the contents data being 718 printed, using EMBEDDED_OFFSET as an offset into VAL's contents 719 buffer. For example: "has this field been optimized out", or "I'm 720 printing an object while inspecting a traceframe; has this 721 particular piece of data been collected?". 722 723 RECURSE indicates the amount of indentation to supply before 724 continuation lines; this amount is roughly twice the value of 725 RECURSE. */ 726 727 void 728 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, 729 CORE_ADDR address, struct ui_file *stream, int recurse, 730 const struct value *val, 731 const struct value_print_options *options, 732 const struct language_defn *language) 733 { 734 volatile struct gdb_exception except; 735 int ret = 0; 736 struct value_print_options local_opts = *options; 737 struct type *real_type = check_typedef (type); 738 739 if (local_opts.pretty == Val_pretty_default) 740 local_opts.pretty = (local_opts.prettyprint_structs 741 ? Val_prettyprint : Val_no_prettyprint); 742 743 QUIT; 744 745 /* Ensure that the type is complete and not just a stub. If the type is 746 only a stub and we can't find and substitute its complete type, then 747 print appropriate string and return. */ 748 749 if (TYPE_STUB (real_type)) 750 { 751 fprintf_filtered (stream, _("<incomplete type>")); 752 gdb_flush (stream); 753 return; 754 } 755 756 if (!valprint_check_validity (stream, real_type, embedded_offset, val)) 757 return; 758 759 if (!options->raw) 760 { 761 ret = apply_val_pretty_printer (type, valaddr, embedded_offset, 762 address, stream, recurse, 763 val, options, language); 764 if (ret) 765 return; 766 } 767 768 /* Handle summary mode. If the value is a scalar, print it; 769 otherwise, print an ellipsis. */ 770 if (options->summary && !scalar_type_p (type)) 771 { 772 fprintf_filtered (stream, "..."); 773 return; 774 } 775 776 TRY_CATCH (except, RETURN_MASK_ERROR) 777 { 778 language->la_val_print (type, valaddr, embedded_offset, address, 779 stream, recurse, val, 780 &local_opts); 781 } 782 if (except.reason < 0) 783 fprintf_filtered (stream, _("<error reading variable>")); 784 } 785 786 /* Check whether the value VAL is printable. Return 1 if it is; 787 return 0 and print an appropriate error message to STREAM according to 788 OPTIONS if it is not. */ 789 790 static int 791 value_check_printable (struct value *val, struct ui_file *stream, 792 const struct value_print_options *options) 793 { 794 if (val == 0) 795 { 796 fprintf_filtered (stream, _("<address of value unknown>")); 797 return 0; 798 } 799 800 if (value_entirely_optimized_out (val)) 801 { 802 if (options->summary && !scalar_type_p (value_type (val))) 803 fprintf_filtered (stream, "..."); 804 else 805 val_print_optimized_out (stream); 806 return 0; 807 } 808 809 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION) 810 { 811 fprintf_filtered (stream, _("<internal function %s>"), 812 value_internal_function_name (val)); 813 return 0; 814 } 815 816 return 1; 817 } 818 819 /* Print using the given LANGUAGE the value VAL onto stream STREAM according 820 to OPTIONS. 821 822 This is a preferable interface to val_print, above, because it uses 823 GDB's value mechanism. */ 824 825 void 826 common_val_print (struct value *val, struct ui_file *stream, int recurse, 827 const struct value_print_options *options, 828 const struct language_defn *language) 829 { 830 if (!value_check_printable (val, stream, options)) 831 return; 832 833 if (language->la_language == language_ada) 834 /* The value might have a dynamic type, which would cause trouble 835 below when trying to extract the value contents (since the value 836 size is determined from the type size which is unknown). So 837 get a fixed representation of our value. */ 838 val = ada_to_fixed_value (val); 839 840 val_print (value_type (val), value_contents_for_printing (val), 841 value_embedded_offset (val), value_address (val), 842 stream, recurse, 843 val, options, language); 844 } 845 846 /* Print on stream STREAM the value VAL according to OPTIONS. The value 847 is printed using the current_language syntax. */ 848 849 void 850 value_print (struct value *val, struct ui_file *stream, 851 const struct value_print_options *options) 852 { 853 if (!value_check_printable (val, stream, options)) 854 return; 855 856 if (!options->raw) 857 { 858 int r = apply_val_pretty_printer (value_type (val), 859 value_contents_for_printing (val), 860 value_embedded_offset (val), 861 value_address (val), 862 stream, 0, 863 val, options, current_language); 864 865 if (r) 866 return; 867 } 868 869 LA_VALUE_PRINT (val, stream, options); 870 } 871 872 /* Called by various <lang>_val_print routines to print 873 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the 874 value. STREAM is where to print the value. */ 875 876 void 877 val_print_type_code_int (struct type *type, const gdb_byte *valaddr, 878 struct ui_file *stream) 879 { 880 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 881 882 if (TYPE_LENGTH (type) > sizeof (LONGEST)) 883 { 884 LONGEST val; 885 886 if (TYPE_UNSIGNED (type) 887 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type), 888 byte_order, &val)) 889 { 890 print_longest (stream, 'u', 0, val); 891 } 892 else 893 { 894 /* Signed, or we couldn't turn an unsigned value into a 895 LONGEST. For signed values, one could assume two's 896 complement (a reasonable assumption, I think) and do 897 better than this. */ 898 print_hex_chars (stream, (unsigned char *) valaddr, 899 TYPE_LENGTH (type), byte_order); 900 } 901 } 902 else 903 { 904 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, 905 unpack_long (type, valaddr)); 906 } 907 } 908 909 void 910 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr, 911 struct ui_file *stream) 912 { 913 ULONGEST val = unpack_long (type, valaddr); 914 int bitpos, nfields = TYPE_NFIELDS (type); 915 916 fputs_filtered ("[ ", stream); 917 for (bitpos = 0; bitpos < nfields; bitpos++) 918 { 919 if (TYPE_FIELD_BITPOS (type, bitpos) != -1 920 && (val & ((ULONGEST)1 << bitpos))) 921 { 922 if (TYPE_FIELD_NAME (type, bitpos)) 923 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos)); 924 else 925 fprintf_filtered (stream, "#%d ", bitpos); 926 } 927 } 928 fputs_filtered ("]", stream); 929 } 930 931 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR, 932 according to OPTIONS and SIZE on STREAM. Format i is not supported 933 at this level. 934 935 This is how the elements of an array or structure are printed 936 with a format. */ 937 938 void 939 val_print_scalar_formatted (struct type *type, 940 const gdb_byte *valaddr, int embedded_offset, 941 const struct value *val, 942 const struct value_print_options *options, 943 int size, 944 struct ui_file *stream) 945 { 946 gdb_assert (val != NULL); 947 gdb_assert (valaddr == value_contents_for_printing_const (val)); 948 949 /* If we get here with a string format, try again without it. Go 950 all the way back to the language printers, which may call us 951 again. */ 952 if (options->format == 's') 953 { 954 struct value_print_options opts = *options; 955 opts.format = 0; 956 opts.deref_ref = 0; 957 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts, 958 current_language); 959 return; 960 } 961 962 /* A scalar object that does not have all bits available can't be 963 printed, because all bits contribute to its representation. */ 964 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset, 965 TARGET_CHAR_BIT * TYPE_LENGTH (type))) 966 val_print_optimized_out (stream); 967 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) 968 val_print_unavailable (stream); 969 else 970 print_scalar_formatted (valaddr + embedded_offset, type, 971 options, size, stream); 972 } 973 974 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g. 975 The raison d'etre of this function is to consolidate printing of 976 LONG_LONG's into this one function. The format chars b,h,w,g are 977 from print_scalar_formatted(). Numbers are printed using C 978 format. 979 980 USE_C_FORMAT means to use C format in all cases. Without it, 981 'o' and 'x' format do not include the standard C radix prefix 982 (leading 0 or 0x). 983 984 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL 985 and was intended to request formating according to the current 986 language and would be used for most integers that GDB prints. The 987 exceptional cases were things like protocols where the format of 988 the integer is a protocol thing, not a user-visible thing). The 989 parameter remains to preserve the information of what things might 990 be printed with language-specific format, should we ever resurrect 991 that capability. */ 992 993 void 994 print_longest (struct ui_file *stream, int format, int use_c_format, 995 LONGEST val_long) 996 { 997 const char *val; 998 999 switch (format) 1000 { 1001 case 'd': 1002 val = int_string (val_long, 10, 1, 0, 1); break; 1003 case 'u': 1004 val = int_string (val_long, 10, 0, 0, 1); break; 1005 case 'x': 1006 val = int_string (val_long, 16, 0, 0, use_c_format); break; 1007 case 'b': 1008 val = int_string (val_long, 16, 0, 2, 1); break; 1009 case 'h': 1010 val = int_string (val_long, 16, 0, 4, 1); break; 1011 case 'w': 1012 val = int_string (val_long, 16, 0, 8, 1); break; 1013 case 'g': 1014 val = int_string (val_long, 16, 0, 16, 1); break; 1015 break; 1016 case 'o': 1017 val = int_string (val_long, 8, 0, 0, use_c_format); break; 1018 default: 1019 internal_error (__FILE__, __LINE__, 1020 _("failed internal consistency check")); 1021 } 1022 fputs_filtered (val, stream); 1023 } 1024 1025 /* This used to be a macro, but I don't think it is called often enough 1026 to merit such treatment. */ 1027 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of 1028 arguments to a function, number in a value history, register number, etc.) 1029 where the value must not be larger than can fit in an int. */ 1030 1031 int 1032 longest_to_int (LONGEST arg) 1033 { 1034 /* Let the compiler do the work. */ 1035 int rtnval = (int) arg; 1036 1037 /* Check for overflows or underflows. */ 1038 if (sizeof (LONGEST) > sizeof (int)) 1039 { 1040 if (rtnval != arg) 1041 { 1042 error (_("Value out of range.")); 1043 } 1044 } 1045 return (rtnval); 1046 } 1047 1048 /* Print a floating point value of type TYPE (not always a 1049 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */ 1050 1051 void 1052 print_floating (const gdb_byte *valaddr, struct type *type, 1053 struct ui_file *stream) 1054 { 1055 DOUBLEST doub; 1056 int inv; 1057 const struct floatformat *fmt = NULL; 1058 unsigned len = TYPE_LENGTH (type); 1059 enum float_kind kind; 1060 1061 /* If it is a floating-point, check for obvious problems. */ 1062 if (TYPE_CODE (type) == TYPE_CODE_FLT) 1063 fmt = floatformat_from_type (type); 1064 if (fmt != NULL) 1065 { 1066 kind = floatformat_classify (fmt, valaddr); 1067 if (kind == float_nan) 1068 { 1069 if (floatformat_is_negative (fmt, valaddr)) 1070 fprintf_filtered (stream, "-"); 1071 fprintf_filtered (stream, "nan("); 1072 fputs_filtered ("0x", stream); 1073 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream); 1074 fprintf_filtered (stream, ")"); 1075 return; 1076 } 1077 else if (kind == float_infinite) 1078 { 1079 if (floatformat_is_negative (fmt, valaddr)) 1080 fputs_filtered ("-", stream); 1081 fputs_filtered ("inf", stream); 1082 return; 1083 } 1084 } 1085 1086 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating() 1087 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double 1088 needs to be used as that takes care of any necessary type 1089 conversions. Such conversions are of course direct to DOUBLEST 1090 and disregard any possible target floating point limitations. 1091 For instance, a u64 would be converted and displayed exactly on a 1092 host with 80 bit DOUBLEST but with loss of information on a host 1093 with 64 bit DOUBLEST. */ 1094 1095 doub = unpack_double (type, valaddr, &inv); 1096 if (inv) 1097 { 1098 fprintf_filtered (stream, "<invalid float value>"); 1099 return; 1100 } 1101 1102 /* FIXME: kettenis/2001-01-20: The following code makes too much 1103 assumptions about the host and target floating point format. */ 1104 1105 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may 1106 not necessarily be a TYPE_CODE_FLT, the below ignores that and 1107 instead uses the type's length to determine the precision of the 1108 floating-point value being printed. */ 1109 1110 if (len < sizeof (double)) 1111 fprintf_filtered (stream, "%.9g", (double) doub); 1112 else if (len == sizeof (double)) 1113 fprintf_filtered (stream, "%.17g", (double) doub); 1114 else 1115 #ifdef PRINTF_HAS_LONG_DOUBLE 1116 fprintf_filtered (stream, "%.35Lg", doub); 1117 #else 1118 /* This at least wins with values that are representable as 1119 doubles. */ 1120 fprintf_filtered (stream, "%.17g", (double) doub); 1121 #endif 1122 } 1123 1124 void 1125 print_decimal_floating (const gdb_byte *valaddr, struct type *type, 1126 struct ui_file *stream) 1127 { 1128 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 1129 char decstr[MAX_DECIMAL_STRING]; 1130 unsigned len = TYPE_LENGTH (type); 1131 1132 decimal_to_string (valaddr, len, byte_order, decstr); 1133 fputs_filtered (decstr, stream); 1134 return; 1135 } 1136 1137 void 1138 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr, 1139 unsigned len, enum bfd_endian byte_order) 1140 { 1141 1142 #define BITS_IN_BYTES 8 1143 1144 const gdb_byte *p; 1145 unsigned int i; 1146 int b; 1147 1148 /* Declared "int" so it will be signed. 1149 This ensures that right shift will shift in zeros. */ 1150 1151 const int mask = 0x080; 1152 1153 /* FIXME: We should be not printing leading zeroes in most cases. */ 1154 1155 if (byte_order == BFD_ENDIAN_BIG) 1156 { 1157 for (p = valaddr; 1158 p < valaddr + len; 1159 p++) 1160 { 1161 /* Every byte has 8 binary characters; peel off 1162 and print from the MSB end. */ 1163 1164 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++) 1165 { 1166 if (*p & (mask >> i)) 1167 b = 1; 1168 else 1169 b = 0; 1170 1171 fprintf_filtered (stream, "%1d", b); 1172 } 1173 } 1174 } 1175 else 1176 { 1177 for (p = valaddr + len - 1; 1178 p >= valaddr; 1179 p--) 1180 { 1181 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++) 1182 { 1183 if (*p & (mask >> i)) 1184 b = 1; 1185 else 1186 b = 0; 1187 1188 fprintf_filtered (stream, "%1d", b); 1189 } 1190 } 1191 } 1192 } 1193 1194 /* VALADDR points to an integer of LEN bytes. 1195 Print it in octal on stream or format it in buf. */ 1196 1197 void 1198 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr, 1199 unsigned len, enum bfd_endian byte_order) 1200 { 1201 const gdb_byte *p; 1202 unsigned char octa1, octa2, octa3, carry; 1203 int cycle; 1204 1205 /* FIXME: We should be not printing leading zeroes in most cases. */ 1206 1207 1208 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track 1209 * the extra bits, which cycle every three bytes: 1210 * 1211 * Byte side: 0 1 2 3 1212 * | | | | 1213 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 | 1214 * 1215 * Octal side: 0 1 carry 3 4 carry ... 1216 * 1217 * Cycle number: 0 1 2 1218 * 1219 * But of course we are printing from the high side, so we have to 1220 * figure out where in the cycle we are so that we end up with no 1221 * left over bits at the end. 1222 */ 1223 #define BITS_IN_OCTAL 3 1224 #define HIGH_ZERO 0340 1225 #define LOW_ZERO 0016 1226 #define CARRY_ZERO 0003 1227 #define HIGH_ONE 0200 1228 #define MID_ONE 0160 1229 #define LOW_ONE 0016 1230 #define CARRY_ONE 0001 1231 #define HIGH_TWO 0300 1232 #define MID_TWO 0070 1233 #define LOW_TWO 0007 1234 1235 /* For 32 we start in cycle 2, with two bits and one bit carry; 1236 for 64 in cycle in cycle 1, with one bit and a two bit carry. */ 1237 1238 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL; 1239 carry = 0; 1240 1241 fputs_filtered ("0", stream); 1242 if (byte_order == BFD_ENDIAN_BIG) 1243 { 1244 for (p = valaddr; 1245 p < valaddr + len; 1246 p++) 1247 { 1248 switch (cycle) 1249 { 1250 case 0: 1251 /* No carry in, carry out two bits. */ 1252 1253 octa1 = (HIGH_ZERO & *p) >> 5; 1254 octa2 = (LOW_ZERO & *p) >> 2; 1255 carry = (CARRY_ZERO & *p); 1256 fprintf_filtered (stream, "%o", octa1); 1257 fprintf_filtered (stream, "%o", octa2); 1258 break; 1259 1260 case 1: 1261 /* Carry in two bits, carry out one bit. */ 1262 1263 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7); 1264 octa2 = (MID_ONE & *p) >> 4; 1265 octa3 = (LOW_ONE & *p) >> 1; 1266 carry = (CARRY_ONE & *p); 1267 fprintf_filtered (stream, "%o", octa1); 1268 fprintf_filtered (stream, "%o", octa2); 1269 fprintf_filtered (stream, "%o", octa3); 1270 break; 1271 1272 case 2: 1273 /* Carry in one bit, no carry out. */ 1274 1275 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6); 1276 octa2 = (MID_TWO & *p) >> 3; 1277 octa3 = (LOW_TWO & *p); 1278 carry = 0; 1279 fprintf_filtered (stream, "%o", octa1); 1280 fprintf_filtered (stream, "%o", octa2); 1281 fprintf_filtered (stream, "%o", octa3); 1282 break; 1283 1284 default: 1285 error (_("Internal error in octal conversion;")); 1286 } 1287 1288 cycle++; 1289 cycle = cycle % BITS_IN_OCTAL; 1290 } 1291 } 1292 else 1293 { 1294 for (p = valaddr + len - 1; 1295 p >= valaddr; 1296 p--) 1297 { 1298 switch (cycle) 1299 { 1300 case 0: 1301 /* Carry out, no carry in */ 1302 1303 octa1 = (HIGH_ZERO & *p) >> 5; 1304 octa2 = (LOW_ZERO & *p) >> 2; 1305 carry = (CARRY_ZERO & *p); 1306 fprintf_filtered (stream, "%o", octa1); 1307 fprintf_filtered (stream, "%o", octa2); 1308 break; 1309 1310 case 1: 1311 /* Carry in, carry out */ 1312 1313 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7); 1314 octa2 = (MID_ONE & *p) >> 4; 1315 octa3 = (LOW_ONE & *p) >> 1; 1316 carry = (CARRY_ONE & *p); 1317 fprintf_filtered (stream, "%o", octa1); 1318 fprintf_filtered (stream, "%o", octa2); 1319 fprintf_filtered (stream, "%o", octa3); 1320 break; 1321 1322 case 2: 1323 /* Carry in, no carry out */ 1324 1325 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6); 1326 octa2 = (MID_TWO & *p) >> 3; 1327 octa3 = (LOW_TWO & *p); 1328 carry = 0; 1329 fprintf_filtered (stream, "%o", octa1); 1330 fprintf_filtered (stream, "%o", octa2); 1331 fprintf_filtered (stream, "%o", octa3); 1332 break; 1333 1334 default: 1335 error (_("Internal error in octal conversion;")); 1336 } 1337 1338 cycle++; 1339 cycle = cycle % BITS_IN_OCTAL; 1340 } 1341 } 1342 1343 } 1344 1345 /* VALADDR points to an integer of LEN bytes. 1346 Print it in decimal on stream or format it in buf. */ 1347 1348 void 1349 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr, 1350 unsigned len, enum bfd_endian byte_order) 1351 { 1352 #define TEN 10 1353 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */ 1354 #define CARRY_LEFT( x ) ((x) % TEN) 1355 #define SHIFT( x ) ((x) << 4) 1356 #define LOW_NIBBLE( x ) ( (x) & 0x00F) 1357 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4) 1358 1359 const gdb_byte *p; 1360 unsigned char *digits; 1361 int carry; 1362 int decimal_len; 1363 int i, j, decimal_digits; 1364 int dummy; 1365 int flip; 1366 1367 /* Base-ten number is less than twice as many digits 1368 as the base 16 number, which is 2 digits per byte. */ 1369 1370 decimal_len = len * 2 * 2; 1371 digits = xmalloc (decimal_len); 1372 1373 for (i = 0; i < decimal_len; i++) 1374 { 1375 digits[i] = 0; 1376 } 1377 1378 /* Ok, we have an unknown number of bytes of data to be printed in 1379 * decimal. 1380 * 1381 * Given a hex number (in nibbles) as XYZ, we start by taking X and 1382 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply 1383 * the nibbles by 16, add Y and re-decimalize. Repeat with Z. 1384 * 1385 * The trick is that "digits" holds a base-10 number, but sometimes 1386 * the individual digits are > 10. 1387 * 1388 * Outer loop is per nibble (hex digit) of input, from MSD end to 1389 * LSD end. 1390 */ 1391 decimal_digits = 0; /* Number of decimal digits so far */ 1392 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1; 1393 flip = 0; 1394 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr)) 1395 { 1396 /* 1397 * Multiply current base-ten number by 16 in place. 1398 * Each digit was between 0 and 9, now is between 1399 * 0 and 144. 1400 */ 1401 for (j = 0; j < decimal_digits; j++) 1402 { 1403 digits[j] = SHIFT (digits[j]); 1404 } 1405 1406 /* Take the next nibble off the input and add it to what 1407 * we've got in the LSB position. Bottom 'digit' is now 1408 * between 0 and 159. 1409 * 1410 * "flip" is used to run this loop twice for each byte. 1411 */ 1412 if (flip == 0) 1413 { 1414 /* Take top nibble. */ 1415 1416 digits[0] += HIGH_NIBBLE (*p); 1417 flip = 1; 1418 } 1419 else 1420 { 1421 /* Take low nibble and bump our pointer "p". */ 1422 1423 digits[0] += LOW_NIBBLE (*p); 1424 if (byte_order == BFD_ENDIAN_BIG) 1425 p++; 1426 else 1427 p--; 1428 flip = 0; 1429 } 1430 1431 /* Re-decimalize. We have to do this often enough 1432 * that we don't overflow, but once per nibble is 1433 * overkill. Easier this way, though. Note that the 1434 * carry is often larger than 10 (e.g. max initial 1435 * carry out of lowest nibble is 15, could bubble all 1436 * the way up greater than 10). So we have to do 1437 * the carrying beyond the last current digit. 1438 */ 1439 carry = 0; 1440 for (j = 0; j < decimal_len - 1; j++) 1441 { 1442 digits[j] += carry; 1443 1444 /* "/" won't handle an unsigned char with 1445 * a value that if signed would be negative. 1446 * So extend to longword int via "dummy". 1447 */ 1448 dummy = digits[j]; 1449 carry = CARRY_OUT (dummy); 1450 digits[j] = CARRY_LEFT (dummy); 1451 1452 if (j >= decimal_digits && carry == 0) 1453 { 1454 /* 1455 * All higher digits are 0 and we 1456 * no longer have a carry. 1457 * 1458 * Note: "j" is 0-based, "decimal_digits" is 1459 * 1-based. 1460 */ 1461 decimal_digits = j + 1; 1462 break; 1463 } 1464 } 1465 } 1466 1467 /* Ok, now "digits" is the decimal representation, with 1468 the "decimal_digits" actual digits. Print! */ 1469 1470 for (i = decimal_digits - 1; i >= 0; i--) 1471 { 1472 fprintf_filtered (stream, "%1d", digits[i]); 1473 } 1474 xfree (digits); 1475 } 1476 1477 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */ 1478 1479 void 1480 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr, 1481 unsigned len, enum bfd_endian byte_order) 1482 { 1483 const gdb_byte *p; 1484 1485 /* FIXME: We should be not printing leading zeroes in most cases. */ 1486 1487 fputs_filtered ("0x", stream); 1488 if (byte_order == BFD_ENDIAN_BIG) 1489 { 1490 for (p = valaddr; 1491 p < valaddr + len; 1492 p++) 1493 { 1494 fprintf_filtered (stream, "%02x", *p); 1495 } 1496 } 1497 else 1498 { 1499 for (p = valaddr + len - 1; 1500 p >= valaddr; 1501 p--) 1502 { 1503 fprintf_filtered (stream, "%02x", *p); 1504 } 1505 } 1506 } 1507 1508 /* VALADDR points to a char integer of LEN bytes. 1509 Print it out in appropriate language form on stream. 1510 Omit any leading zero chars. */ 1511 1512 void 1513 print_char_chars (struct ui_file *stream, struct type *type, 1514 const gdb_byte *valaddr, 1515 unsigned len, enum bfd_endian byte_order) 1516 { 1517 const gdb_byte *p; 1518 1519 if (byte_order == BFD_ENDIAN_BIG) 1520 { 1521 p = valaddr; 1522 while (p < valaddr + len - 1 && *p == 0) 1523 ++p; 1524 1525 while (p < valaddr + len) 1526 { 1527 LA_EMIT_CHAR (*p, type, stream, '\''); 1528 ++p; 1529 } 1530 } 1531 else 1532 { 1533 p = valaddr + len - 1; 1534 while (p > valaddr && *p == 0) 1535 --p; 1536 1537 while (p >= valaddr) 1538 { 1539 LA_EMIT_CHAR (*p, type, stream, '\''); 1540 --p; 1541 } 1542 } 1543 } 1544 1545 /* Print function pointer with inferior address ADDRESS onto stdio 1546 stream STREAM. */ 1547 1548 void 1549 print_function_pointer_address (const struct value_print_options *options, 1550 struct gdbarch *gdbarch, 1551 CORE_ADDR address, 1552 struct ui_file *stream) 1553 { 1554 CORE_ADDR func_addr 1555 = gdbarch_convert_from_func_ptr_addr (gdbarch, address, 1556 ¤t_target); 1557 1558 /* If the function pointer is represented by a description, print 1559 the address of the description. */ 1560 if (options->addressprint && func_addr != address) 1561 { 1562 fputs_filtered ("@", stream); 1563 fputs_filtered (paddress (gdbarch, address), stream); 1564 fputs_filtered (": ", stream); 1565 } 1566 print_address_demangle (options, gdbarch, func_addr, stream, demangle); 1567 } 1568 1569 1570 /* Print on STREAM using the given OPTIONS the index for the element 1571 at INDEX of an array whose index type is INDEX_TYPE. */ 1572 1573 void 1574 maybe_print_array_index (struct type *index_type, LONGEST index, 1575 struct ui_file *stream, 1576 const struct value_print_options *options) 1577 { 1578 struct value *index_value; 1579 1580 if (!options->print_array_indexes) 1581 return; 1582 1583 index_value = value_from_longest (index_type, index); 1584 1585 LA_PRINT_ARRAY_INDEX (index_value, stream, options); 1586 } 1587 1588 /* Called by various <lang>_val_print routines to print elements of an 1589 array in the form "<elem1>, <elem2>, <elem3>, ...". 1590 1591 (FIXME?) Assumes array element separator is a comma, which is correct 1592 for all languages currently handled. 1593 (FIXME?) Some languages have a notation for repeated array elements, 1594 perhaps we should try to use that notation when appropriate. */ 1595 1596 void 1597 val_print_array_elements (struct type *type, 1598 const gdb_byte *valaddr, int embedded_offset, 1599 CORE_ADDR address, struct ui_file *stream, 1600 int recurse, 1601 const struct value *val, 1602 const struct value_print_options *options, 1603 unsigned int i) 1604 { 1605 unsigned int things_printed = 0; 1606 unsigned len; 1607 struct type *elttype, *index_type; 1608 unsigned eltlen; 1609 /* Position of the array element we are examining to see 1610 whether it is repeated. */ 1611 unsigned int rep1; 1612 /* Number of repetitions we have detected so far. */ 1613 unsigned int reps; 1614 LONGEST low_bound, high_bound; 1615 1616 elttype = TYPE_TARGET_TYPE (type); 1617 eltlen = TYPE_LENGTH (check_typedef (elttype)); 1618 index_type = TYPE_INDEX_TYPE (type); 1619 1620 if (get_array_bounds (type, &low_bound, &high_bound)) 1621 { 1622 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1. 1623 But we have to be a little extra careful, because some languages 1624 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for 1625 empty arrays. In that situation, the array length is just zero, 1626 not negative! */ 1627 if (low_bound > high_bound) 1628 len = 0; 1629 else 1630 len = high_bound - low_bound + 1; 1631 } 1632 else 1633 { 1634 warning (_("unable to get bounds of array, assuming null array")); 1635 low_bound = 0; 1636 len = 0; 1637 } 1638 1639 annotate_array_section_begin (i, elttype); 1640 1641 for (; i < len && things_printed < options->print_max; i++) 1642 { 1643 if (i != 0) 1644 { 1645 if (options->prettyprint_arrays) 1646 { 1647 fprintf_filtered (stream, ",\n"); 1648 print_spaces_filtered (2 + 2 * recurse, stream); 1649 } 1650 else 1651 { 1652 fprintf_filtered (stream, ", "); 1653 } 1654 } 1655 wrap_here (n_spaces (2 + 2 * recurse)); 1656 maybe_print_array_index (index_type, i + low_bound, 1657 stream, options); 1658 1659 rep1 = i + 1; 1660 reps = 1; 1661 /* Only check for reps if repeat_count_threshold is not set to 1662 UINT_MAX (unlimited). */ 1663 if (options->repeat_count_threshold < UINT_MAX) 1664 { 1665 while (rep1 < len 1666 && value_available_contents_eq (val, 1667 embedded_offset + i * eltlen, 1668 val, 1669 (embedded_offset 1670 + rep1 * eltlen), 1671 eltlen)) 1672 { 1673 ++reps; 1674 ++rep1; 1675 } 1676 } 1677 1678 if (reps > options->repeat_count_threshold) 1679 { 1680 val_print (elttype, valaddr, embedded_offset + i * eltlen, 1681 address, stream, recurse + 1, val, options, 1682 current_language); 1683 annotate_elt_rep (reps); 1684 fprintf_filtered (stream, " <repeats %u times>", reps); 1685 annotate_elt_rep_end (); 1686 1687 i = rep1 - 1; 1688 things_printed += options->repeat_count_threshold; 1689 } 1690 else 1691 { 1692 val_print (elttype, valaddr, embedded_offset + i * eltlen, 1693 address, 1694 stream, recurse + 1, val, options, current_language); 1695 annotate_elt (); 1696 things_printed++; 1697 } 1698 } 1699 annotate_array_section_end (); 1700 if (i < len) 1701 { 1702 fprintf_filtered (stream, "..."); 1703 } 1704 } 1705 1706 /* Read LEN bytes of target memory at address MEMADDR, placing the 1707 results in GDB's memory at MYADDR. Returns a count of the bytes 1708 actually read, and optionally an errno value in the location 1709 pointed to by ERRNOPTR if ERRNOPTR is non-null. */ 1710 1711 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this 1712 function be eliminated. */ 1713 1714 static int 1715 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, 1716 int len, int *errnoptr) 1717 { 1718 int nread; /* Number of bytes actually read. */ 1719 int errcode; /* Error from last read. */ 1720 1721 /* First try a complete read. */ 1722 errcode = target_read_memory (memaddr, myaddr, len); 1723 if (errcode == 0) 1724 { 1725 /* Got it all. */ 1726 nread = len; 1727 } 1728 else 1729 { 1730 /* Loop, reading one byte at a time until we get as much as we can. */ 1731 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--) 1732 { 1733 errcode = target_read_memory (memaddr++, myaddr++, 1); 1734 } 1735 /* If an error, the last read was unsuccessful, so adjust count. */ 1736 if (errcode != 0) 1737 { 1738 nread--; 1739 } 1740 } 1741 if (errnoptr != NULL) 1742 { 1743 *errnoptr = errcode; 1744 } 1745 return (nread); 1746 } 1747 1748 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes 1749 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly 1750 allocated buffer containing the string, which the caller is responsible to 1751 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on 1752 success, or errno on failure. 1753 1754 If LEN > 0, reads exactly LEN characters (including eventual NULs in 1755 the middle or end of the string). If LEN is -1, stops at the first 1756 null character (not necessarily the first null byte) up to a maximum 1757 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many 1758 characters as possible from the string. 1759 1760 Unless an exception is thrown, BUFFER will always be allocated, even on 1761 failure. In this case, some characters might have been read before the 1762 failure happened. Check BYTES_READ to recognize this situation. 1763 1764 Note: There was a FIXME asking to make this code use target_read_string, 1765 but this function is more general (can read past null characters, up to 1766 given LEN). Besides, it is used much more often than target_read_string 1767 so it is more tested. Perhaps callers of target_read_string should use 1768 this function instead? */ 1769 1770 int 1771 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit, 1772 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read) 1773 { 1774 int found_nul; /* Non-zero if we found the nul char. */ 1775 int errcode; /* Errno returned from bad reads. */ 1776 unsigned int nfetch; /* Chars to fetch / chars fetched. */ 1777 unsigned int chunksize; /* Size of each fetch, in chars. */ 1778 gdb_byte *bufptr; /* Pointer to next available byte in 1779 buffer. */ 1780 gdb_byte *limit; /* First location past end of fetch buffer. */ 1781 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */ 1782 1783 /* Decide how large of chunks to try to read in one operation. This 1784 is also pretty simple. If LEN >= zero, then we want fetchlimit chars, 1785 so we might as well read them all in one operation. If LEN is -1, we 1786 are looking for a NUL terminator to end the fetching, so we might as 1787 well read in blocks that are large enough to be efficient, but not so 1788 large as to be slow if fetchlimit happens to be large. So we choose the 1789 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but 1790 200 is way too big for remote debugging over a serial line. */ 1791 1792 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit); 1793 1794 /* Loop until we either have all the characters, or we encounter 1795 some error, such as bumping into the end of the address space. */ 1796 1797 found_nul = 0; 1798 *buffer = NULL; 1799 1800 old_chain = make_cleanup (free_current_contents, buffer); 1801 1802 if (len > 0) 1803 { 1804 *buffer = (gdb_byte *) xmalloc (len * width); 1805 bufptr = *buffer; 1806 1807 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode) 1808 / width; 1809 addr += nfetch * width; 1810 bufptr += nfetch * width; 1811 } 1812 else if (len == -1) 1813 { 1814 unsigned long bufsize = 0; 1815 1816 do 1817 { 1818 QUIT; 1819 nfetch = min (chunksize, fetchlimit - bufsize); 1820 1821 if (*buffer == NULL) 1822 *buffer = (gdb_byte *) xmalloc (nfetch * width); 1823 else 1824 *buffer = (gdb_byte *) xrealloc (*buffer, 1825 (nfetch + bufsize) * width); 1826 1827 bufptr = *buffer + bufsize * width; 1828 bufsize += nfetch; 1829 1830 /* Read as much as we can. */ 1831 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode) 1832 / width; 1833 1834 /* Scan this chunk for the null character that terminates the string 1835 to print. If found, we don't need to fetch any more. Note 1836 that bufptr is explicitly left pointing at the next character 1837 after the null character, or at the next character after the end 1838 of the buffer. */ 1839 1840 limit = bufptr + nfetch * width; 1841 while (bufptr < limit) 1842 { 1843 unsigned long c; 1844 1845 c = extract_unsigned_integer (bufptr, width, byte_order); 1846 addr += width; 1847 bufptr += width; 1848 if (c == 0) 1849 { 1850 /* We don't care about any error which happened after 1851 the NUL terminator. */ 1852 errcode = 0; 1853 found_nul = 1; 1854 break; 1855 } 1856 } 1857 } 1858 while (errcode == 0 /* no error */ 1859 && bufptr - *buffer < fetchlimit * width /* no overrun */ 1860 && !found_nul); /* haven't found NUL yet */ 1861 } 1862 else 1863 { /* Length of string is really 0! */ 1864 /* We always allocate *buffer. */ 1865 *buffer = bufptr = xmalloc (1); 1866 errcode = 0; 1867 } 1868 1869 /* bufptr and addr now point immediately beyond the last byte which we 1870 consider part of the string (including a '\0' which ends the string). */ 1871 *bytes_read = bufptr - *buffer; 1872 1873 QUIT; 1874 1875 discard_cleanups (old_chain); 1876 1877 return errcode; 1878 } 1879 1880 /* Return true if print_wchar can display W without resorting to a 1881 numeric escape, false otherwise. */ 1882 1883 static int 1884 wchar_printable (gdb_wchar_t w) 1885 { 1886 return (gdb_iswprint (w) 1887 || w == LCST ('\a') || w == LCST ('\b') 1888 || w == LCST ('\f') || w == LCST ('\n') 1889 || w == LCST ('\r') || w == LCST ('\t') 1890 || w == LCST ('\v')); 1891 } 1892 1893 /* A helper function that converts the contents of STRING to wide 1894 characters and then appends them to OUTPUT. */ 1895 1896 static void 1897 append_string_as_wide (const char *string, 1898 struct obstack *output) 1899 { 1900 for (; *string; ++string) 1901 { 1902 gdb_wchar_t w = gdb_btowc (*string); 1903 obstack_grow (output, &w, sizeof (gdb_wchar_t)); 1904 } 1905 } 1906 1907 /* Print a wide character W to OUTPUT. ORIG is a pointer to the 1908 original (target) bytes representing the character, ORIG_LEN is the 1909 number of valid bytes. WIDTH is the number of bytes in a base 1910 characters of the type. OUTPUT is an obstack to which wide 1911 characters are emitted. QUOTER is a (narrow) character indicating 1912 the style of quotes surrounding the character to be printed. 1913 NEED_ESCAPE is an in/out flag which is used to track numeric 1914 escapes across calls. */ 1915 1916 static void 1917 print_wchar (gdb_wint_t w, const gdb_byte *orig, 1918 int orig_len, int width, 1919 enum bfd_endian byte_order, 1920 struct obstack *output, 1921 int quoter, int *need_escapep) 1922 { 1923 int need_escape = *need_escapep; 1924 1925 *need_escapep = 0; 1926 if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w) 1927 && w != LCST ('8') 1928 && w != LCST ('9')))) 1929 { 1930 gdb_wchar_t wchar = w; 1931 1932 if (w == gdb_btowc (quoter) || w == LCST ('\\')) 1933 obstack_grow_wstr (output, LCST ("\\")); 1934 obstack_grow (output, &wchar, sizeof (gdb_wchar_t)); 1935 } 1936 else 1937 { 1938 switch (w) 1939 { 1940 case LCST ('\a'): 1941 obstack_grow_wstr (output, LCST ("\\a")); 1942 break; 1943 case LCST ('\b'): 1944 obstack_grow_wstr (output, LCST ("\\b")); 1945 break; 1946 case LCST ('\f'): 1947 obstack_grow_wstr (output, LCST ("\\f")); 1948 break; 1949 case LCST ('\n'): 1950 obstack_grow_wstr (output, LCST ("\\n")); 1951 break; 1952 case LCST ('\r'): 1953 obstack_grow_wstr (output, LCST ("\\r")); 1954 break; 1955 case LCST ('\t'): 1956 obstack_grow_wstr (output, LCST ("\\t")); 1957 break; 1958 case LCST ('\v'): 1959 obstack_grow_wstr (output, LCST ("\\v")); 1960 break; 1961 default: 1962 { 1963 int i; 1964 1965 for (i = 0; i + width <= orig_len; i += width) 1966 { 1967 char octal[30]; 1968 ULONGEST value; 1969 1970 value = extract_unsigned_integer (&orig[i], width, 1971 byte_order); 1972 /* If the value fits in 3 octal digits, print it that 1973 way. Otherwise, print it as a hex escape. */ 1974 if (value <= 0777) 1975 xsnprintf (octal, sizeof (octal), "\\%.3o", 1976 (int) (value & 0777)); 1977 else 1978 xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value); 1979 append_string_as_wide (octal, output); 1980 } 1981 /* If we somehow have extra bytes, print them now. */ 1982 while (i < orig_len) 1983 { 1984 char octal[5]; 1985 1986 xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff); 1987 append_string_as_wide (octal, output); 1988 ++i; 1989 } 1990 1991 *need_escapep = 1; 1992 } 1993 break; 1994 } 1995 } 1996 } 1997 1998 /* Print the character C on STREAM as part of the contents of a 1999 literal string whose delimiter is QUOTER. ENCODING names the 2000 encoding of C. */ 2001 2002 void 2003 generic_emit_char (int c, struct type *type, struct ui_file *stream, 2004 int quoter, const char *encoding) 2005 { 2006 enum bfd_endian byte_order 2007 = gdbarch_byte_order (get_type_arch (type)); 2008 struct obstack wchar_buf, output; 2009 struct cleanup *cleanups; 2010 gdb_byte *buf; 2011 struct wchar_iterator *iter; 2012 int need_escape = 0; 2013 2014 buf = alloca (TYPE_LENGTH (type)); 2015 pack_long (buf, type, c); 2016 2017 iter = make_wchar_iterator (buf, TYPE_LENGTH (type), 2018 encoding, TYPE_LENGTH (type)); 2019 cleanups = make_cleanup_wchar_iterator (iter); 2020 2021 /* This holds the printable form of the wchar_t data. */ 2022 obstack_init (&wchar_buf); 2023 make_cleanup_obstack_free (&wchar_buf); 2024 2025 while (1) 2026 { 2027 int num_chars; 2028 gdb_wchar_t *chars; 2029 const gdb_byte *buf; 2030 size_t buflen; 2031 int print_escape = 1; 2032 enum wchar_iterate_result result; 2033 2034 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen); 2035 if (num_chars < 0) 2036 break; 2037 if (num_chars > 0) 2038 { 2039 /* If all characters are printable, print them. Otherwise, 2040 we're going to have to print an escape sequence. We 2041 check all characters because we want to print the target 2042 bytes in the escape sequence, and we don't know character 2043 boundaries there. */ 2044 int i; 2045 2046 print_escape = 0; 2047 for (i = 0; i < num_chars; ++i) 2048 if (!wchar_printable (chars[i])) 2049 { 2050 print_escape = 1; 2051 break; 2052 } 2053 2054 if (!print_escape) 2055 { 2056 for (i = 0; i < num_chars; ++i) 2057 print_wchar (chars[i], buf, buflen, 2058 TYPE_LENGTH (type), byte_order, 2059 &wchar_buf, quoter, &need_escape); 2060 } 2061 } 2062 2063 /* This handles the NUM_CHARS == 0 case as well. */ 2064 if (print_escape) 2065 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type), 2066 byte_order, &wchar_buf, quoter, &need_escape); 2067 } 2068 2069 /* The output in the host encoding. */ 2070 obstack_init (&output); 2071 make_cleanup_obstack_free (&output); 2072 2073 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (), 2074 (gdb_byte *) obstack_base (&wchar_buf), 2075 obstack_object_size (&wchar_buf), 2076 sizeof (gdb_wchar_t), &output, translit_char); 2077 obstack_1grow (&output, '\0'); 2078 2079 fputs_filtered (obstack_base (&output), stream); 2080 2081 do_cleanups (cleanups); 2082 } 2083 2084 /* Return the repeat count of the next character/byte in ITER, 2085 storing the result in VEC. */ 2086 2087 static int 2088 count_next_character (struct wchar_iterator *iter, 2089 VEC (converted_character_d) **vec) 2090 { 2091 struct converted_character *current; 2092 2093 if (VEC_empty (converted_character_d, *vec)) 2094 { 2095 struct converted_character tmp; 2096 gdb_wchar_t *chars; 2097 2098 tmp.num_chars 2099 = wchar_iterate (iter, &tmp.result, &chars, &tmp.buf, &tmp.buflen); 2100 if (tmp.num_chars > 0) 2101 { 2102 gdb_assert (tmp.num_chars < MAX_WCHARS); 2103 memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t)); 2104 } 2105 VEC_safe_push (converted_character_d, *vec, &tmp); 2106 } 2107 2108 current = VEC_last (converted_character_d, *vec); 2109 2110 /* Count repeated characters or bytes. */ 2111 current->repeat_count = 1; 2112 if (current->num_chars == -1) 2113 { 2114 /* EOF */ 2115 return -1; 2116 } 2117 else 2118 { 2119 gdb_wchar_t *chars; 2120 struct converted_character d; 2121 int repeat; 2122 2123 d.repeat_count = 0; 2124 2125 while (1) 2126 { 2127 /* Get the next character. */ 2128 d.num_chars 2129 = wchar_iterate (iter, &d.result, &chars, &d.buf, &d.buflen); 2130 2131 /* If a character was successfully converted, save the character 2132 into the converted character. */ 2133 if (d.num_chars > 0) 2134 { 2135 gdb_assert (d.num_chars < MAX_WCHARS); 2136 memcpy (d.chars, chars, WCHAR_BUFLEN (d.num_chars)); 2137 } 2138 2139 /* Determine if the current character is the same as this 2140 new character. */ 2141 if (d.num_chars == current->num_chars && d.result == current->result) 2142 { 2143 /* There are two cases to consider: 2144 2145 1) Equality of converted character (num_chars > 0) 2146 2) Equality of non-converted character (num_chars == 0) */ 2147 if ((current->num_chars > 0 2148 && memcmp (current->chars, d.chars, 2149 WCHAR_BUFLEN (current->num_chars)) == 0) 2150 || (current->num_chars == 0 2151 && current->buflen == d.buflen 2152 && memcmp (current->buf, d.buf, current->buflen) == 0)) 2153 ++current->repeat_count; 2154 else 2155 break; 2156 } 2157 else 2158 break; 2159 } 2160 2161 /* Push this next converted character onto the result vector. */ 2162 repeat = current->repeat_count; 2163 VEC_safe_push (converted_character_d, *vec, &d); 2164 return repeat; 2165 } 2166 } 2167 2168 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote 2169 character to use with string output. WIDTH is the size of the output 2170 character type. BYTE_ORDER is the the target byte order. OPTIONS 2171 is the user's print options. */ 2172 2173 static void 2174 print_converted_chars_to_obstack (struct obstack *obstack, 2175 VEC (converted_character_d) *chars, 2176 int quote_char, int width, 2177 enum bfd_endian byte_order, 2178 const struct value_print_options *options) 2179 { 2180 unsigned int idx; 2181 struct converted_character *elem; 2182 enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last; 2183 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char); 2184 int need_escape = 0; 2185 2186 /* Set the start state. */ 2187 idx = 0; 2188 last = state = START; 2189 elem = NULL; 2190 2191 while (1) 2192 { 2193 switch (state) 2194 { 2195 case START: 2196 /* Nothing to do. */ 2197 break; 2198 2199 case SINGLE: 2200 { 2201 int j; 2202 2203 /* We are outputting a single character 2204 (< options->repeat_count_threshold). */ 2205 2206 if (last != SINGLE) 2207 { 2208 /* We were outputting some other type of content, so we 2209 must output and a comma and a quote. */ 2210 if (last != START) 2211 obstack_grow_wstr (obstack, LCST (", ")); 2212 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t)); 2213 } 2214 /* Output the character. */ 2215 for (j = 0; j < elem->repeat_count; ++j) 2216 { 2217 if (elem->result == wchar_iterate_ok) 2218 print_wchar (elem->chars[0], elem->buf, elem->buflen, width, 2219 byte_order, obstack, quote_char, &need_escape); 2220 else 2221 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, 2222 byte_order, obstack, quote_char, &need_escape); 2223 } 2224 } 2225 break; 2226 2227 case REPEAT: 2228 { 2229 int j; 2230 char *s; 2231 2232 /* We are outputting a character with a repeat count 2233 greater than options->repeat_count_threshold. */ 2234 2235 if (last == SINGLE) 2236 { 2237 /* We were outputting a single string. Terminate the 2238 string. */ 2239 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t)); 2240 } 2241 if (last != START) 2242 obstack_grow_wstr (obstack, LCST (", ")); 2243 2244 /* Output the character and repeat string. */ 2245 obstack_grow_wstr (obstack, LCST ("'")); 2246 if (elem->result == wchar_iterate_ok) 2247 print_wchar (elem->chars[0], elem->buf, elem->buflen, width, 2248 byte_order, obstack, quote_char, &need_escape); 2249 else 2250 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, 2251 byte_order, obstack, quote_char, &need_escape); 2252 obstack_grow_wstr (obstack, LCST ("'")); 2253 s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count); 2254 for (j = 0; s[j]; ++j) 2255 { 2256 gdb_wchar_t w = gdb_btowc (s[j]); 2257 obstack_grow (obstack, &w, sizeof (gdb_wchar_t)); 2258 } 2259 xfree (s); 2260 } 2261 break; 2262 2263 case INCOMPLETE: 2264 /* We are outputting an incomplete sequence. */ 2265 if (last == SINGLE) 2266 { 2267 /* If we were outputting a string of SINGLE characters, 2268 terminate the quote. */ 2269 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t)); 2270 } 2271 if (last != START) 2272 obstack_grow_wstr (obstack, LCST (", ")); 2273 2274 /* Output the incomplete sequence string. */ 2275 obstack_grow_wstr (obstack, LCST ("<incomplete sequence ")); 2276 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order, 2277 obstack, 0, &need_escape); 2278 obstack_grow_wstr (obstack, LCST (">")); 2279 2280 /* We do not attempt to outupt anything after this. */ 2281 state = FINISH; 2282 break; 2283 2284 case FINISH: 2285 /* All done. If we were outputting a string of SINGLE 2286 characters, the string must be terminated. Otherwise, 2287 REPEAT and INCOMPLETE are always left properly terminated. */ 2288 if (last == SINGLE) 2289 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t)); 2290 2291 return; 2292 } 2293 2294 /* Get the next element and state. */ 2295 last = state; 2296 if (state != FINISH) 2297 { 2298 elem = VEC_index (converted_character_d, chars, idx++); 2299 switch (elem->result) 2300 { 2301 case wchar_iterate_ok: 2302 case wchar_iterate_invalid: 2303 if (elem->repeat_count > options->repeat_count_threshold) 2304 state = REPEAT; 2305 else 2306 state = SINGLE; 2307 break; 2308 2309 case wchar_iterate_incomplete: 2310 state = INCOMPLETE; 2311 break; 2312 2313 case wchar_iterate_eof: 2314 state = FINISH; 2315 break; 2316 } 2317 } 2318 } 2319 } 2320 2321 /* Print the character string STRING, printing at most LENGTH 2322 characters. LENGTH is -1 if the string is nul terminated. TYPE is 2323 the type of each character. OPTIONS holds the printing options; 2324 printing stops early if the number hits print_max; repeat counts 2325 are printed as appropriate. Print ellipses at the end if we had to 2326 stop before printing LENGTH characters, or if FORCE_ELLIPSES. 2327 QUOTE_CHAR is the character to print at each end of the string. If 2328 C_STYLE_TERMINATOR is true, and the last character is 0, then it is 2329 omitted. */ 2330 2331 void 2332 generic_printstr (struct ui_file *stream, struct type *type, 2333 const gdb_byte *string, unsigned int length, 2334 const char *encoding, int force_ellipses, 2335 int quote_char, int c_style_terminator, 2336 const struct value_print_options *options) 2337 { 2338 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 2339 unsigned int i; 2340 int width = TYPE_LENGTH (type); 2341 struct obstack wchar_buf, output; 2342 struct cleanup *cleanup; 2343 struct wchar_iterator *iter; 2344 int finished = 0; 2345 struct converted_character *last; 2346 VEC (converted_character_d) *converted_chars; 2347 2348 if (length == -1) 2349 { 2350 unsigned long current_char = 1; 2351 2352 for (i = 0; current_char; ++i) 2353 { 2354 QUIT; 2355 current_char = extract_unsigned_integer (string + i * width, 2356 width, byte_order); 2357 } 2358 length = i; 2359 } 2360 2361 /* If the string was not truncated due to `set print elements', and 2362 the last byte of it is a null, we don't print that, in 2363 traditional C style. */ 2364 if (c_style_terminator 2365 && !force_ellipses 2366 && length > 0 2367 && (extract_unsigned_integer (string + (length - 1) * width, 2368 width, byte_order) == 0)) 2369 length--; 2370 2371 if (length == 0) 2372 { 2373 fputs_filtered ("\"\"", stream); 2374 return; 2375 } 2376 2377 /* Arrange to iterate over the characters, in wchar_t form. */ 2378 iter = make_wchar_iterator (string, length * width, encoding, width); 2379 cleanup = make_cleanup_wchar_iterator (iter); 2380 converted_chars = NULL; 2381 make_cleanup (VEC_cleanup (converted_character_d), &converted_chars); 2382 2383 /* Convert characters until the string is over or the maximum 2384 number of printed characters has been reached. */ 2385 i = 0; 2386 while (i < options->print_max) 2387 { 2388 int r; 2389 2390 QUIT; 2391 2392 /* Grab the next character and repeat count. */ 2393 r = count_next_character (iter, &converted_chars); 2394 2395 /* If less than zero, the end of the input string was reached. */ 2396 if (r < 0) 2397 break; 2398 2399 /* Otherwise, add the count to the total print count and get 2400 the next character. */ 2401 i += r; 2402 } 2403 2404 /* Get the last element and determine if the entire string was 2405 processed. */ 2406 last = VEC_last (converted_character_d, converted_chars); 2407 finished = (last->result == wchar_iterate_eof); 2408 2409 /* Ensure that CONVERTED_CHARS is terminated. */ 2410 last->result = wchar_iterate_eof; 2411 2412 /* WCHAR_BUF is the obstack we use to represent the string in 2413 wchar_t form. */ 2414 obstack_init (&wchar_buf); 2415 make_cleanup_obstack_free (&wchar_buf); 2416 2417 /* Print the output string to the obstack. */ 2418 print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char, 2419 width, byte_order, options); 2420 2421 if (force_ellipses || !finished) 2422 obstack_grow_wstr (&wchar_buf, LCST ("...")); 2423 2424 /* OUTPUT is where we collect `char's for printing. */ 2425 obstack_init (&output); 2426 make_cleanup_obstack_free (&output); 2427 2428 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (), 2429 (gdb_byte *) obstack_base (&wchar_buf), 2430 obstack_object_size (&wchar_buf), 2431 sizeof (gdb_wchar_t), &output, translit_char); 2432 obstack_1grow (&output, '\0'); 2433 2434 fputs_filtered (obstack_base (&output), stream); 2435 2436 do_cleanups (cleanup); 2437 } 2438 2439 /* Print a string from the inferior, starting at ADDR and printing up to LEN 2440 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing 2441 stops at the first null byte, otherwise printing proceeds (including null 2442 bytes) until either print_max or LEN characters have been printed, 2443 whichever is smaller. ENCODING is the name of the string's 2444 encoding. It can be NULL, in which case the target encoding is 2445 assumed. */ 2446 2447 int 2448 val_print_string (struct type *elttype, const char *encoding, 2449 CORE_ADDR addr, int len, 2450 struct ui_file *stream, 2451 const struct value_print_options *options) 2452 { 2453 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */ 2454 int errcode; /* Errno returned from bad reads. */ 2455 int found_nul; /* Non-zero if we found the nul char. */ 2456 unsigned int fetchlimit; /* Maximum number of chars to print. */ 2457 int bytes_read; 2458 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */ 2459 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */ 2460 struct gdbarch *gdbarch = get_type_arch (elttype); 2461 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 2462 int width = TYPE_LENGTH (elttype); 2463 2464 /* First we need to figure out the limit on the number of characters we are 2465 going to attempt to fetch and print. This is actually pretty simple. If 2466 LEN >= zero, then the limit is the minimum of LEN and print_max. If 2467 LEN is -1, then the limit is print_max. This is true regardless of 2468 whether print_max is zero, UINT_MAX (unlimited), or something in between, 2469 because finding the null byte (or available memory) is what actually 2470 limits the fetch. */ 2471 2472 fetchlimit = (len == -1 ? options->print_max : min (len, 2473 options->print_max)); 2474 2475 errcode = read_string (addr, len, width, fetchlimit, byte_order, 2476 &buffer, &bytes_read); 2477 old_chain = make_cleanup (xfree, buffer); 2478 2479 addr += bytes_read; 2480 2481 /* We now have either successfully filled the buffer to fetchlimit, 2482 or terminated early due to an error or finding a null char when 2483 LEN is -1. */ 2484 2485 /* Determine found_nul by looking at the last character read. */ 2486 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width, 2487 byte_order) == 0; 2488 if (len == -1 && !found_nul) 2489 { 2490 gdb_byte *peekbuf; 2491 2492 /* We didn't find a NUL terminator we were looking for. Attempt 2493 to peek at the next character. If not successful, or it is not 2494 a null byte, then force ellipsis to be printed. */ 2495 2496 peekbuf = (gdb_byte *) alloca (width); 2497 2498 if (target_read_memory (addr, peekbuf, width) == 0 2499 && extract_unsigned_integer (peekbuf, width, byte_order) != 0) 2500 force_ellipsis = 1; 2501 } 2502 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width)) 2503 { 2504 /* Getting an error when we have a requested length, or fetching less 2505 than the number of characters actually requested, always make us 2506 print ellipsis. */ 2507 force_ellipsis = 1; 2508 } 2509 2510 /* If we get an error before fetching anything, don't print a string. 2511 But if we fetch something and then get an error, print the string 2512 and then the error message. */ 2513 if (errcode == 0 || bytes_read > 0) 2514 { 2515 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width, 2516 encoding, force_ellipsis, options); 2517 } 2518 2519 if (errcode != 0) 2520 { 2521 if (errcode == EIO) 2522 { 2523 fprintf_filtered (stream, "<Address "); 2524 fputs_filtered (paddress (gdbarch, addr), stream); 2525 fprintf_filtered (stream, " out of bounds>"); 2526 } 2527 else 2528 { 2529 fprintf_filtered (stream, "<Error reading address "); 2530 fputs_filtered (paddress (gdbarch, addr), stream); 2531 fprintf_filtered (stream, ": %s>", safe_strerror (errcode)); 2532 } 2533 } 2534 2535 gdb_flush (stream); 2536 do_cleanups (old_chain); 2537 2538 return (bytes_read / width); 2539 } 2540 2541 2542 /* The 'set input-radix' command writes to this auxiliary variable. 2543 If the requested radix is valid, INPUT_RADIX is updated; otherwise, 2544 it is left unchanged. */ 2545 2546 static unsigned input_radix_1 = 10; 2547 2548 /* Validate an input or output radix setting, and make sure the user 2549 knows what they really did here. Radix setting is confusing, e.g. 2550 setting the input radix to "10" never changes it! */ 2551 2552 static void 2553 set_input_radix (char *args, int from_tty, struct cmd_list_element *c) 2554 { 2555 set_input_radix_1 (from_tty, input_radix_1); 2556 } 2557 2558 static void 2559 set_input_radix_1 (int from_tty, unsigned radix) 2560 { 2561 /* We don't currently disallow any input radix except 0 or 1, which don't 2562 make any mathematical sense. In theory, we can deal with any input 2563 radix greater than 1, even if we don't have unique digits for every 2564 value from 0 to radix-1, but in practice we lose on large radix values. 2565 We should either fix the lossage or restrict the radix range more. 2566 (FIXME). */ 2567 2568 if (radix < 2) 2569 { 2570 input_radix_1 = input_radix; 2571 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."), 2572 radix); 2573 } 2574 input_radix_1 = input_radix = radix; 2575 if (from_tty) 2576 { 2577 printf_filtered (_("Input radix now set to " 2578 "decimal %u, hex %x, octal %o.\n"), 2579 radix, radix, radix); 2580 } 2581 } 2582 2583 /* The 'set output-radix' command writes to this auxiliary variable. 2584 If the requested radix is valid, OUTPUT_RADIX is updated, 2585 otherwise, it is left unchanged. */ 2586 2587 static unsigned output_radix_1 = 10; 2588 2589 static void 2590 set_output_radix (char *args, int from_tty, struct cmd_list_element *c) 2591 { 2592 set_output_radix_1 (from_tty, output_radix_1); 2593 } 2594 2595 static void 2596 set_output_radix_1 (int from_tty, unsigned radix) 2597 { 2598 /* Validate the radix and disallow ones that we aren't prepared to 2599 handle correctly, leaving the radix unchanged. */ 2600 switch (radix) 2601 { 2602 case 16: 2603 user_print_options.output_format = 'x'; /* hex */ 2604 break; 2605 case 10: 2606 user_print_options.output_format = 0; /* decimal */ 2607 break; 2608 case 8: 2609 user_print_options.output_format = 'o'; /* octal */ 2610 break; 2611 default: 2612 output_radix_1 = output_radix; 2613 error (_("Unsupported output radix ``decimal %u''; " 2614 "output radix unchanged."), 2615 radix); 2616 } 2617 output_radix_1 = output_radix = radix; 2618 if (from_tty) 2619 { 2620 printf_filtered (_("Output radix now set to " 2621 "decimal %u, hex %x, octal %o.\n"), 2622 radix, radix, radix); 2623 } 2624 } 2625 2626 /* Set both the input and output radix at once. Try to set the output radix 2627 first, since it has the most restrictive range. An radix that is valid as 2628 an output radix is also valid as an input radix. 2629 2630 It may be useful to have an unusual input radix. If the user wishes to 2631 set an input radix that is not valid as an output radix, he needs to use 2632 the 'set input-radix' command. */ 2633 2634 static void 2635 set_radix (char *arg, int from_tty) 2636 { 2637 unsigned radix; 2638 2639 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg); 2640 set_output_radix_1 (0, radix); 2641 set_input_radix_1 (0, radix); 2642 if (from_tty) 2643 { 2644 printf_filtered (_("Input and output radices now set to " 2645 "decimal %u, hex %x, octal %o.\n"), 2646 radix, radix, radix); 2647 } 2648 } 2649 2650 /* Show both the input and output radices. */ 2651 2652 static void 2653 show_radix (char *arg, int from_tty) 2654 { 2655 if (from_tty) 2656 { 2657 if (input_radix == output_radix) 2658 { 2659 printf_filtered (_("Input and output radices set to " 2660 "decimal %u, hex %x, octal %o.\n"), 2661 input_radix, input_radix, input_radix); 2662 } 2663 else 2664 { 2665 printf_filtered (_("Input radix set to decimal " 2666 "%u, hex %x, octal %o.\n"), 2667 input_radix, input_radix, input_radix); 2668 printf_filtered (_("Output radix set to decimal " 2669 "%u, hex %x, octal %o.\n"), 2670 output_radix, output_radix, output_radix); 2671 } 2672 } 2673 } 2674 2675 2676 static void 2677 set_print (char *arg, int from_tty) 2678 { 2679 printf_unfiltered ( 2680 "\"set print\" must be followed by the name of a print subcommand.\n"); 2681 help_list (setprintlist, "set print ", -1, gdb_stdout); 2682 } 2683 2684 static void 2685 show_print (char *args, int from_tty) 2686 { 2687 cmd_show_list (showprintlist, from_tty, ""); 2688 } 2689 2690 void 2691 _initialize_valprint (void) 2692 { 2693 add_prefix_cmd ("print", no_class, set_print, 2694 _("Generic command for setting how things print."), 2695 &setprintlist, "set print ", 0, &setlist); 2696 add_alias_cmd ("p", "print", no_class, 1, &setlist); 2697 /* Prefer set print to set prompt. */ 2698 add_alias_cmd ("pr", "print", no_class, 1, &setlist); 2699 2700 add_prefix_cmd ("print", no_class, show_print, 2701 _("Generic command for showing print settings."), 2702 &showprintlist, "show print ", 0, &showlist); 2703 add_alias_cmd ("p", "print", no_class, 1, &showlist); 2704 add_alias_cmd ("pr", "print", no_class, 1, &showlist); 2705 2706 add_setshow_uinteger_cmd ("elements", no_class, 2707 &user_print_options.print_max, _("\ 2708 Set limit on string chars or array elements to print."), _("\ 2709 Show limit on string chars or array elements to print."), _("\ 2710 \"set print elements 0\" causes there to be no limit."), 2711 NULL, 2712 show_print_max, 2713 &setprintlist, &showprintlist); 2714 2715 add_setshow_boolean_cmd ("null-stop", no_class, 2716 &user_print_options.stop_print_at_null, _("\ 2717 Set printing of char arrays to stop at first null char."), _("\ 2718 Show printing of char arrays to stop at first null char."), NULL, 2719 NULL, 2720 show_stop_print_at_null, 2721 &setprintlist, &showprintlist); 2722 2723 add_setshow_uinteger_cmd ("repeats", no_class, 2724 &user_print_options.repeat_count_threshold, _("\ 2725 Set threshold for repeated print elements."), _("\ 2726 Show threshold for repeated print elements."), _("\ 2727 \"set print repeats 0\" causes all elements to be individually printed."), 2728 NULL, 2729 show_repeat_count_threshold, 2730 &setprintlist, &showprintlist); 2731 2732 add_setshow_boolean_cmd ("pretty", class_support, 2733 &user_print_options.prettyprint_structs, _("\ 2734 Set prettyprinting of structures."), _("\ 2735 Show prettyprinting of structures."), NULL, 2736 NULL, 2737 show_prettyprint_structs, 2738 &setprintlist, &showprintlist); 2739 2740 add_setshow_boolean_cmd ("union", class_support, 2741 &user_print_options.unionprint, _("\ 2742 Set printing of unions interior to structures."), _("\ 2743 Show printing of unions interior to structures."), NULL, 2744 NULL, 2745 show_unionprint, 2746 &setprintlist, &showprintlist); 2747 2748 add_setshow_boolean_cmd ("array", class_support, 2749 &user_print_options.prettyprint_arrays, _("\ 2750 Set prettyprinting of arrays."), _("\ 2751 Show prettyprinting of arrays."), NULL, 2752 NULL, 2753 show_prettyprint_arrays, 2754 &setprintlist, &showprintlist); 2755 2756 add_setshow_boolean_cmd ("address", class_support, 2757 &user_print_options.addressprint, _("\ 2758 Set printing of addresses."), _("\ 2759 Show printing of addresses."), NULL, 2760 NULL, 2761 show_addressprint, 2762 &setprintlist, &showprintlist); 2763 2764 add_setshow_boolean_cmd ("symbol", class_support, 2765 &user_print_options.symbol_print, _("\ 2766 Set printing of symbol names when printing pointers."), _("\ 2767 Show printing of symbol names when printing pointers."), 2768 NULL, NULL, 2769 show_symbol_print, 2770 &setprintlist, &showprintlist); 2771 2772 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1, 2773 _("\ 2774 Set default input radix for entering numbers."), _("\ 2775 Show default input radix for entering numbers."), NULL, 2776 set_input_radix, 2777 show_input_radix, 2778 &setlist, &showlist); 2779 2780 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1, 2781 _("\ 2782 Set default output radix for printing of values."), _("\ 2783 Show default output radix for printing of values."), NULL, 2784 set_output_radix, 2785 show_output_radix, 2786 &setlist, &showlist); 2787 2788 /* The "set radix" and "show radix" commands are special in that 2789 they are like normal set and show commands but allow two normally 2790 independent variables to be either set or shown with a single 2791 command. So the usual deprecated_add_set_cmd() and [deleted] 2792 add_show_from_set() commands aren't really appropriate. */ 2793 /* FIXME: i18n: With the new add_setshow_integer command, that is no 2794 longer true - show can display anything. */ 2795 add_cmd ("radix", class_support, set_radix, _("\ 2796 Set default input and output number radices.\n\ 2797 Use 'set input-radix' or 'set output-radix' to independently set each.\n\ 2798 Without an argument, sets both radices back to the default value of 10."), 2799 &setlist); 2800 add_cmd ("radix", class_support, show_radix, _("\ 2801 Show the default input and output number radices.\n\ 2802 Use 'show input-radix' or 'show output-radix' to independently show each."), 2803 &showlist); 2804 2805 add_setshow_boolean_cmd ("array-indexes", class_support, 2806 &user_print_options.print_array_indexes, _("\ 2807 Set printing of array indexes."), _("\ 2808 Show printing of array indexes"), NULL, NULL, show_print_array_indexes, 2809 &setprintlist, &showprintlist); 2810 } 2811