1 /* Support for printing Ada values for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002, 4 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include <ctype.h> 22 #include "defs.h" 23 #include "gdb_string.h" 24 #include "symtab.h" 25 #include "gdbtypes.h" 26 #include "expression.h" 27 #include "value.h" 28 #include "demangle.h" 29 #include "valprint.h" 30 #include "language.h" 31 #include "annotate.h" 32 #include "ada-lang.h" 33 #include "c-lang.h" 34 #include "infcall.h" 35 #include "exceptions.h" 36 #include "objfiles.h" 37 38 /* Encapsulates arguments to ada_val_print. */ 39 struct ada_val_print_args 40 { 41 struct type *type; 42 const gdb_byte *valaddr0; 43 int embedded_offset; 44 CORE_ADDR address; 45 struct ui_file *stream; 46 int recurse; 47 const struct value_print_options *options; 48 }; 49 50 static void print_record (struct type *, const gdb_byte *, struct ui_file *, 51 int, const struct value_print_options *); 52 53 static int print_field_values (struct type *, const gdb_byte *, 54 struct ui_file *, int, 55 const struct value_print_options *, 56 int, struct type *, 57 const gdb_byte *); 58 59 static void adjust_type_signedness (struct type *); 60 61 static int ada_val_print_stub (void *args0); 62 63 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR, 64 struct ui_file *, int, 65 const struct value_print_options *); 66 67 68 /* Make TYPE unsigned if its range of values includes no negatives. */ 69 static void 70 adjust_type_signedness (struct type *type) 71 { 72 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE 73 && TYPE_LOW_BOUND (type) >= 0) 74 TYPE_UNSIGNED (type) = 1; 75 } 76 77 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM, 78 if non-standard (i.e., other than 1 for numbers, other than lower bound 79 of index type for enumerated type). Returns 1 if something printed, 80 otherwise 0. */ 81 82 static int 83 print_optional_low_bound (struct ui_file *stream, struct type *type, 84 const struct value_print_options *options) 85 { 86 struct type *index_type; 87 long low_bound; 88 long high_bound; 89 90 if (options->print_array_indexes) 91 return 0; 92 93 if (!get_array_bounds (type, &low_bound, &high_bound)) 94 return 0; 95 96 /* If this is an empty array, then don't print the lower bound. 97 That would be confusing, because we would print the lower bound, 98 followed by... nothing! */ 99 if (low_bound > high_bound) 100 return 0; 101 102 index_type = TYPE_INDEX_TYPE (type); 103 104 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE) 105 { 106 /* We need to know what the base type is, in order to do the 107 appropriate check below. Otherwise, if this is a subrange 108 of an enumerated type, where the underlying value of the 109 first element is typically 0, we might test the low bound 110 against the wrong value. */ 111 index_type = TYPE_TARGET_TYPE (index_type); 112 } 113 114 switch (TYPE_CODE (index_type)) 115 { 116 case TYPE_CODE_BOOL: 117 if (low_bound == 0) 118 return 0; 119 break; 120 case TYPE_CODE_ENUM: 121 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0)) 122 return 0; 123 break; 124 case TYPE_CODE_UNDEF: 125 index_type = NULL; 126 /* FALL THROUGH */ 127 default: 128 if (low_bound == 1) 129 return 0; 130 break; 131 } 132 133 ada_print_scalar (index_type, (LONGEST) low_bound, stream); 134 fprintf_filtered (stream, " => "); 135 return 1; 136 } 137 138 /* Version of val_print_array_elements for GNAT-style packed arrays. 139 Prints elements of packed array of type TYPE at bit offset 140 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and 141 separates with commas. RECURSE is the recursion (nesting) level. 142 TYPE must have been decoded (as by ada_coerce_to_simple_array). */ 143 144 static void 145 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr, 146 int bitoffset, struct ui_file *stream, 147 int recurse, 148 const struct value_print_options *options) 149 { 150 unsigned int i; 151 unsigned int things_printed = 0; 152 unsigned len; 153 struct type *elttype, *index_type; 154 unsigned eltlen; 155 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0); 156 struct value *mark = value_mark (); 157 LONGEST low = 0; 158 159 elttype = TYPE_TARGET_TYPE (type); 160 eltlen = TYPE_LENGTH (check_typedef (elttype)); 161 index_type = TYPE_INDEX_TYPE (type); 162 163 { 164 LONGEST high; 165 if (get_discrete_bounds (index_type, &low, &high) < 0) 166 len = 1; 167 else 168 len = high - low + 1; 169 } 170 171 i = 0; 172 annotate_array_section_begin (i, elttype); 173 174 while (i < len && things_printed < options->print_max) 175 { 176 struct value *v0, *v1; 177 int i0; 178 179 if (i != 0) 180 { 181 if (options->prettyprint_arrays) 182 { 183 fprintf_filtered (stream, ",\n"); 184 print_spaces_filtered (2 + 2 * recurse, stream); 185 } 186 else 187 { 188 fprintf_filtered (stream, ", "); 189 } 190 } 191 wrap_here (n_spaces (2 + 2 * recurse)); 192 maybe_print_array_index (index_type, i + low, stream, options); 193 194 i0 = i; 195 v0 = ada_value_primitive_packed_val (NULL, valaddr, 196 (i0 * bitsize) / HOST_CHAR_BIT, 197 (i0 * bitsize) % HOST_CHAR_BIT, 198 bitsize, elttype); 199 while (1) 200 { 201 i += 1; 202 if (i >= len) 203 break; 204 v1 = ada_value_primitive_packed_val (NULL, valaddr, 205 (i * bitsize) / HOST_CHAR_BIT, 206 (i * bitsize) % HOST_CHAR_BIT, 207 bitsize, elttype); 208 if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0) 209 break; 210 } 211 212 if (i - i0 > options->repeat_count_threshold) 213 { 214 struct value_print_options opts = *options; 215 opts.deref_ref = 0; 216 val_print (elttype, value_contents (v0), 0, 0, stream, 217 recurse + 1, &opts, current_language); 218 annotate_elt_rep (i - i0); 219 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0); 220 annotate_elt_rep_end (); 221 222 } 223 else 224 { 225 int j; 226 struct value_print_options opts = *options; 227 opts.deref_ref = 0; 228 for (j = i0; j < i; j += 1) 229 { 230 if (j > i0) 231 { 232 if (options->prettyprint_arrays) 233 { 234 fprintf_filtered (stream, ",\n"); 235 print_spaces_filtered (2 + 2 * recurse, stream); 236 } 237 else 238 { 239 fprintf_filtered (stream, ", "); 240 } 241 wrap_here (n_spaces (2 + 2 * recurse)); 242 maybe_print_array_index (index_type, j + low, 243 stream, options); 244 } 245 val_print (elttype, value_contents (v0), 0, 0, stream, 246 recurse + 1, &opts, current_language); 247 annotate_elt (); 248 } 249 } 250 things_printed += i - i0; 251 } 252 annotate_array_section_end (); 253 if (i < len) 254 { 255 fprintf_filtered (stream, "..."); 256 } 257 258 value_free_to_mark (mark); 259 } 260 261 static struct type * 262 printable_val_type (struct type *type, const gdb_byte *valaddr) 263 { 264 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1); 265 } 266 267 /* Print the character C on STREAM as part of the contents of a literal 268 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes 269 (1 or 2) of the character. */ 270 271 void 272 ada_emit_char (int c, struct type *type, struct ui_file *stream, 273 int quoter, int type_len) 274 { 275 if (type_len != 2) 276 type_len = 1; 277 278 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1; 279 280 if (isascii (c) && isprint (c)) 281 { 282 if (c == quoter && c == '"') 283 fprintf_filtered (stream, "\"\""); 284 else 285 fprintf_filtered (stream, "%c", c); 286 } 287 else 288 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c); 289 } 290 291 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1 292 or 2) of a character. */ 293 294 static int 295 char_at (const gdb_byte *string, int i, int type_len, 296 enum bfd_endian byte_order) 297 { 298 if (type_len == 1) 299 return string[i]; 300 else 301 return (int) extract_unsigned_integer (string + 2 * i, 2, byte_order); 302 } 303 304 /* Wrapper around memcpy to make it legal argument to ui_file_put */ 305 static void 306 ui_memcpy (void *dest, const char *buffer, long len) 307 { 308 memcpy (dest, buffer, (size_t) len); 309 ((char *) dest)[len] = '\0'; 310 } 311 312 /* Print a floating-point value of type TYPE, pointed to in GDB by 313 VALADDR, on STREAM. Use Ada formatting conventions: there must be 314 a decimal point, and at least one digit before and after the 315 point. We use GNAT format for NaNs and infinities. */ 316 static void 317 ada_print_floating (const gdb_byte *valaddr, struct type *type, 318 struct ui_file *stream) 319 { 320 char buffer[64]; 321 char *s, *result; 322 int len; 323 struct ui_file *tmp_stream = mem_fileopen (); 324 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream); 325 326 print_floating (valaddr, type, tmp_stream); 327 ui_file_put (tmp_stream, ui_memcpy, buffer); 328 do_cleanups (cleanups); 329 330 result = buffer; 331 len = strlen (result); 332 333 /* Modify for Ada rules. */ 334 335 s = strstr (result, "inf"); 336 if (s == NULL) 337 s = strstr (result, "Inf"); 338 if (s == NULL) 339 s = strstr (result, "INF"); 340 if (s != NULL) 341 strcpy (s, "Inf"); 342 343 if (s == NULL) 344 { 345 s = strstr (result, "nan"); 346 if (s == NULL) 347 s = strstr (result, "NaN"); 348 if (s == NULL) 349 s = strstr (result, "Nan"); 350 if (s != NULL) 351 { 352 s[0] = s[2] = 'N'; 353 if (result[0] == '-') 354 result += 1; 355 } 356 } 357 358 if (s == NULL && strchr (result, '.') == NULL) 359 { 360 s = strchr (result, 'e'); 361 if (s == NULL) 362 fprintf_filtered (stream, "%s.0", result); 363 else 364 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s); 365 return; 366 } 367 fprintf_filtered (stream, "%s", result); 368 } 369 370 void 371 ada_printchar (int c, struct type *type, struct ui_file *stream) 372 { 373 fputs_filtered ("'", stream); 374 ada_emit_char (c, type, stream, '\'', 1); 375 fputs_filtered ("'", stream); 376 } 377 378 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a 379 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL 380 like a default signed integer. */ 381 382 void 383 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream) 384 { 385 unsigned int i; 386 unsigned len; 387 388 if (!type) 389 { 390 print_longest (stream, 'd', 0, val); 391 return; 392 } 393 394 type = ada_check_typedef (type); 395 396 switch (TYPE_CODE (type)) 397 { 398 399 case TYPE_CODE_ENUM: 400 len = TYPE_NFIELDS (type); 401 for (i = 0; i < len; i++) 402 { 403 if (TYPE_FIELD_BITPOS (type, i) == val) 404 { 405 break; 406 } 407 } 408 if (i < len) 409 { 410 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream); 411 } 412 else 413 { 414 print_longest (stream, 'd', 0, val); 415 } 416 break; 417 418 case TYPE_CODE_INT: 419 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val); 420 break; 421 422 case TYPE_CODE_CHAR: 423 LA_PRINT_CHAR ((unsigned char) val, type, stream); 424 break; 425 426 case TYPE_CODE_BOOL: 427 fprintf_filtered (stream, val ? "true" : "false"); 428 break; 429 430 case TYPE_CODE_RANGE: 431 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream); 432 return; 433 434 case TYPE_CODE_UNDEF: 435 case TYPE_CODE_PTR: 436 case TYPE_CODE_ARRAY: 437 case TYPE_CODE_STRUCT: 438 case TYPE_CODE_UNION: 439 case TYPE_CODE_FUNC: 440 case TYPE_CODE_FLT: 441 case TYPE_CODE_VOID: 442 case TYPE_CODE_SET: 443 case TYPE_CODE_STRING: 444 case TYPE_CODE_ERROR: 445 case TYPE_CODE_MEMBERPTR: 446 case TYPE_CODE_METHODPTR: 447 case TYPE_CODE_METHOD: 448 case TYPE_CODE_REF: 449 warning (_("internal error: unhandled type in ada_print_scalar")); 450 break; 451 452 default: 453 error (_("Invalid type code in symbol table.")); 454 } 455 gdb_flush (stream); 456 } 457 458 /* Print the character string STRING, printing at most LENGTH characters. 459 Printing stops early if the number hits print_max; repeat counts 460 are printed as appropriate. Print ellipses at the end if we 461 had to stop before printing LENGTH characters, or if 462 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type. 463 */ 464 465 static void 466 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string, 467 unsigned int length, int force_ellipses, int type_len, 468 const struct value_print_options *options) 469 { 470 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype)); 471 unsigned int i; 472 unsigned int things_printed = 0; 473 int in_quotes = 0; 474 int need_comma = 0; 475 476 if (length == 0) 477 { 478 fputs_filtered ("\"\"", stream); 479 return; 480 } 481 482 for (i = 0; i < length && things_printed < options->print_max; i += 1) 483 { 484 /* Position of the character we are examining 485 to see whether it is repeated. */ 486 unsigned int rep1; 487 /* Number of repetitions we have detected so far. */ 488 unsigned int reps; 489 490 QUIT; 491 492 if (need_comma) 493 { 494 fputs_filtered (", ", stream); 495 need_comma = 0; 496 } 497 498 rep1 = i + 1; 499 reps = 1; 500 while (rep1 < length 501 && char_at (string, rep1, type_len, byte_order) 502 == char_at (string, i, type_len, byte_order)) 503 { 504 rep1 += 1; 505 reps += 1; 506 } 507 508 if (reps > options->repeat_count_threshold) 509 { 510 if (in_quotes) 511 { 512 if (options->inspect_it) 513 fputs_filtered ("\\\", ", stream); 514 else 515 fputs_filtered ("\", ", stream); 516 in_quotes = 0; 517 } 518 fputs_filtered ("'", stream); 519 ada_emit_char (char_at (string, i, type_len, byte_order), 520 elttype, stream, '\'', type_len); 521 fputs_filtered ("'", stream); 522 fprintf_filtered (stream, _(" <repeats %u times>"), reps); 523 i = rep1 - 1; 524 things_printed += options->repeat_count_threshold; 525 need_comma = 1; 526 } 527 else 528 { 529 if (!in_quotes) 530 { 531 if (options->inspect_it) 532 fputs_filtered ("\\\"", stream); 533 else 534 fputs_filtered ("\"", stream); 535 in_quotes = 1; 536 } 537 ada_emit_char (char_at (string, i, type_len, byte_order), 538 elttype, stream, '"', type_len); 539 things_printed += 1; 540 } 541 } 542 543 /* Terminate the quotes if necessary. */ 544 if (in_quotes) 545 { 546 if (options->inspect_it) 547 fputs_filtered ("\\\"", stream); 548 else 549 fputs_filtered ("\"", stream); 550 } 551 552 if (force_ellipses || i < length) 553 fputs_filtered ("...", stream); 554 } 555 556 void 557 ada_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string, 558 unsigned int length, int force_ellipses, 559 const struct value_print_options *options) 560 { 561 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type), 562 options); 563 } 564 565 566 /* Print data of type TYPE located at VALADDR (within GDB), which came from 567 the inferior at address ADDRESS, onto stdio stream STREAM according to 568 OPTIONS. The data at VALADDR is in target byte order. 569 570 If the data is printed as a string, returns the number of string characters 571 printed. 572 573 RECURSE indicates the amount of indentation to supply before 574 continuation lines; this amount is roughly twice the value of RECURSE. */ 575 576 int 577 ada_val_print (struct type *type, const gdb_byte *valaddr0, 578 int embedded_offset, CORE_ADDR address, 579 struct ui_file *stream, int recurse, 580 const struct value_print_options *options) 581 { 582 struct ada_val_print_args args; 583 args.type = type; 584 args.valaddr0 = valaddr0; 585 args.embedded_offset = embedded_offset; 586 args.address = address; 587 args.stream = stream; 588 args.recurse = recurse; 589 args.options = options; 590 591 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL); 592 } 593 594 /* Helper for ada_val_print; used as argument to catch_errors to 595 unmarshal the arguments to ada_val_print_1, which does the work. */ 596 static int 597 ada_val_print_stub (void *args0) 598 { 599 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0; 600 return ada_val_print_1 (argsp->type, argsp->valaddr0, 601 argsp->embedded_offset, argsp->address, 602 argsp->stream, argsp->recurse, argsp->options); 603 } 604 605 /* Assuming TYPE is a simple array, print the value of this array located 606 at VALADDR. See ada_val_print for a description of the various 607 parameters of this function; they are identical. The semantics 608 of the return value is also identical to ada_val_print. */ 609 610 static int 611 ada_val_print_array (struct type *type, const gdb_byte *valaddr, 612 CORE_ADDR address, struct ui_file *stream, int recurse, 613 const struct value_print_options *options) 614 { 615 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 616 struct type *elttype = TYPE_TARGET_TYPE (type); 617 unsigned int eltlen; 618 unsigned int len; 619 int result = 0; 620 621 if (elttype == NULL) 622 eltlen = 0; 623 else 624 eltlen = TYPE_LENGTH (elttype); 625 if (eltlen == 0) 626 len = 0; 627 else 628 len = TYPE_LENGTH (type) / eltlen; 629 630 /* For an array of chars, print with string syntax. */ 631 if (ada_is_string_type (type) 632 && (options->format == 0 || options->format == 's')) 633 { 634 if (options->prettyprint_arrays) 635 print_spaces_filtered (2 + 2 * recurse, stream); 636 637 /* If requested, look for the first null char and only print 638 elements up to it. */ 639 if (options->stop_print_at_null) 640 { 641 int temp_len; 642 643 /* Look for a NULL char. */ 644 for (temp_len = 0; 645 (temp_len < len 646 && temp_len < options->print_max 647 && char_at (valaddr, temp_len, eltlen, byte_order) != 0); 648 temp_len += 1); 649 len = temp_len; 650 } 651 652 printstr (stream, elttype, valaddr, len, 0, eltlen, options); 653 result = len; 654 } 655 else 656 { 657 fprintf_filtered (stream, "("); 658 print_optional_low_bound (stream, type, options); 659 if (TYPE_FIELD_BITSIZE (type, 0) > 0) 660 val_print_packed_array_elements (type, valaddr, 0, stream, 661 recurse, options); 662 else 663 val_print_array_elements (type, valaddr, address, stream, 664 recurse, options, 0); 665 fprintf_filtered (stream, ")"); 666 } 667 668 return result; 669 } 670 671 /* See the comment on ada_val_print. This function differs in that it 672 does not catch evaluation errors (leaving that to ada_val_print). */ 673 674 static int 675 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0, 676 int embedded_offset, CORE_ADDR address, 677 struct ui_file *stream, int recurse, 678 const struct value_print_options *options) 679 { 680 unsigned int len; 681 int i; 682 struct type *elttype; 683 unsigned int eltlen; 684 LONGEST val; 685 const gdb_byte *valaddr = valaddr0 + embedded_offset; 686 687 type = ada_check_typedef (type); 688 689 if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type)) 690 { 691 int retn; 692 struct value *mark = value_mark (); 693 struct value *val; 694 val = value_from_contents_and_address (type, valaddr, address); 695 val = ada_coerce_to_simple_array_ptr (val); 696 if (val == NULL) 697 { 698 fprintf_filtered (stream, "(null)"); 699 retn = 0; 700 } 701 else 702 retn = ada_val_print_1 (value_type (val), value_contents (val), 0, 703 value_address (val), stream, recurse, options); 704 value_free_to_mark (mark); 705 return retn; 706 } 707 708 valaddr = ada_aligned_value_addr (type, valaddr); 709 embedded_offset -= valaddr - valaddr0 - embedded_offset; 710 type = printable_val_type (type, valaddr); 711 712 switch (TYPE_CODE (type)) 713 { 714 default: 715 return c_val_print (type, valaddr0, embedded_offset, address, stream, 716 recurse, options); 717 718 case TYPE_CODE_PTR: 719 { 720 int ret = c_val_print (type, valaddr0, embedded_offset, address, 721 stream, recurse, options); 722 if (ada_is_tag_type (type)) 723 { 724 struct value *val = 725 value_from_contents_and_address (type, valaddr, address); 726 const char *name = ada_tag_name (val); 727 if (name != NULL) 728 fprintf_filtered (stream, " (%s)", name); 729 return 0; 730 } 731 return ret; 732 } 733 734 case TYPE_CODE_INT: 735 case TYPE_CODE_RANGE: 736 if (ada_is_fixed_point_type (type)) 737 { 738 LONGEST v = unpack_long (type, valaddr); 739 int len = TYPE_LENGTH (type); 740 741 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g", 742 (double) ada_fixed_to_float (type, v)); 743 return 0; 744 } 745 else if (ada_is_vax_floating_type (type)) 746 { 747 struct value *val = 748 value_from_contents_and_address (type, valaddr, address); 749 struct value *func = ada_vax_float_print_function (type); 750 if (func != 0) 751 { 752 struct gdbarch *gdbarch = get_type_arch (type); 753 CORE_ADDR addr; 754 addr = value_as_address (call_function_by_hand (func, 1, &val)); 755 val_print_string (builtin_type (gdbarch)->builtin_true_char, 756 addr, -1, stream, options); 757 return 0; 758 } 759 /* No special printing function. Do as best we can. */ 760 } 761 else if (TYPE_CODE (type) == TYPE_CODE_RANGE) 762 { 763 struct type *target_type = TYPE_TARGET_TYPE (type); 764 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type)) 765 { 766 /* Obscure case of range type that has different length from 767 its base type. Perform a conversion, or we will get a 768 nonsense value. Actually, we could use the same 769 code regardless of lengths; I'm just avoiding a cast. */ 770 struct value *v = value_cast (target_type, 771 value_from_contents_and_address 772 (type, valaddr, 0)); 773 return ada_val_print_1 (target_type, value_contents (v), 0, 0, 774 stream, recurse + 1, options); 775 } 776 else 777 return ada_val_print_1 (TYPE_TARGET_TYPE (type), 778 valaddr0, embedded_offset, 779 address, stream, recurse, options); 780 } 781 else 782 { 783 int format = (options->format ? options->format 784 : options->output_format); 785 if (format) 786 { 787 struct value_print_options opts = *options; 788 opts.format = format; 789 print_scalar_formatted (valaddr, type, &opts, 0, stream); 790 } 791 else if (ada_is_system_address_type (type)) 792 { 793 /* FIXME: We want to print System.Address variables using 794 the same format as for any access type. But for some 795 reason GNAT encodes the System.Address type as an int, 796 so we have to work-around this deficiency by handling 797 System.Address values as a special case. */ 798 799 struct gdbarch *gdbarch = get_type_arch (type); 800 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 801 CORE_ADDR addr = extract_typed_address (valaddr, ptr_type); 802 803 fprintf_filtered (stream, "("); 804 type_print (type, "", stream, -1); 805 fprintf_filtered (stream, ") "); 806 fputs_filtered (paddress (gdbarch, addr), stream); 807 } 808 else 809 { 810 val_print_type_code_int (type, valaddr, stream); 811 if (ada_is_character_type (type)) 812 { 813 fputs_filtered (" ", stream); 814 ada_printchar ((unsigned char) unpack_long (type, valaddr), 815 type, stream); 816 } 817 } 818 return 0; 819 } 820 821 case TYPE_CODE_ENUM: 822 if (options->format) 823 { 824 print_scalar_formatted (valaddr, type, options, 0, stream); 825 break; 826 } 827 len = TYPE_NFIELDS (type); 828 val = unpack_long (type, valaddr); 829 for (i = 0; i < len; i++) 830 { 831 QUIT; 832 if (val == TYPE_FIELD_BITPOS (type, i)) 833 { 834 break; 835 } 836 } 837 if (i < len) 838 { 839 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i)); 840 if (name[0] == '\'') 841 fprintf_filtered (stream, "%ld %s", (long) val, name); 842 else 843 fputs_filtered (name, stream); 844 } 845 else 846 { 847 print_longest (stream, 'd', 0, val); 848 } 849 break; 850 851 case TYPE_CODE_FLAGS: 852 if (options->format) 853 print_scalar_formatted (valaddr, type, options, 0, stream); 854 else 855 val_print_type_code_flags (type, valaddr, stream); 856 break; 857 858 case TYPE_CODE_FLT: 859 if (options->format) 860 return c_val_print (type, valaddr0, embedded_offset, address, stream, 861 recurse, options); 862 else 863 ada_print_floating (valaddr0 + embedded_offset, type, stream); 864 break; 865 866 case TYPE_CODE_UNION: 867 case TYPE_CODE_STRUCT: 868 if (ada_is_bogus_array_descriptor (type)) 869 { 870 fprintf_filtered (stream, "(...?)"); 871 return 0; 872 } 873 else 874 { 875 print_record (type, valaddr, stream, recurse, options); 876 return 0; 877 } 878 879 case TYPE_CODE_ARRAY: 880 return ada_val_print_array (type, valaddr, address, stream, 881 recurse, options); 882 883 case TYPE_CODE_REF: 884 /* For references, the debugger is expected to print the value as 885 an address if DEREF_REF is null. But printing an address in place 886 of the object value would be confusing to an Ada programmer. 887 So, for Ada values, we print the actual dereferenced value 888 regardless. */ 889 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 890 891 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 892 { 893 LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr); 894 if (deref_val_int != 0) 895 { 896 struct value *deref_val = 897 ada_value_ind (value_from_longest 898 (lookup_pointer_type (elttype), 899 deref_val_int)); 900 val_print (value_type (deref_val), 901 value_contents (deref_val), 0, 902 value_address (deref_val), stream, recurse + 1, 903 options, current_language); 904 } 905 else 906 fputs_filtered ("(null)", stream); 907 } 908 else 909 fputs_filtered ("???", stream); 910 911 break; 912 } 913 gdb_flush (stream); 914 return 0; 915 } 916 917 static int 918 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr, 919 struct ui_file *stream, int recurse, 920 const struct value_print_options *options, int comma_needed, 921 struct type *outer_type, const gdb_byte *outer_valaddr) 922 { 923 struct type *var_type = TYPE_FIELD_TYPE (type, field_num); 924 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr); 925 926 if (which < 0) 927 return 0; 928 else 929 return print_field_values 930 (TYPE_FIELD_TYPE (var_type, which), 931 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT 932 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT, 933 stream, recurse, options, 934 comma_needed, outer_type, outer_valaddr); 935 } 936 937 int 938 ada_value_print (struct value *val0, struct ui_file *stream, 939 const struct value_print_options *options) 940 { 941 const gdb_byte *valaddr = value_contents (val0); 942 CORE_ADDR address = value_address (val0); 943 struct type *type = 944 ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1); 945 struct value *val = 946 value_from_contents_and_address (type, valaddr, address); 947 struct value_print_options opts; 948 949 /* If it is a pointer, indicate what it points to. */ 950 if (TYPE_CODE (type) == TYPE_CODE_PTR) 951 { 952 /* Hack: don't print (char *) for char strings. Their 953 type is indicated by the quoted string anyway. */ 954 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char) 955 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT 956 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type))) 957 { 958 fprintf_filtered (stream, "("); 959 type_print (type, "", stream, -1); 960 fprintf_filtered (stream, ") "); 961 } 962 } 963 else if (ada_is_array_descriptor_type (type)) 964 { 965 fprintf_filtered (stream, "("); 966 type_print (type, "", stream, -1); 967 fprintf_filtered (stream, ") "); 968 } 969 else if (ada_is_bogus_array_descriptor (type)) 970 { 971 fprintf_filtered (stream, "("); 972 type_print (type, "", stream, -1); 973 fprintf_filtered (stream, ") (...?)"); 974 return 0; 975 } 976 977 opts = *options; 978 opts.deref_ref = 1; 979 return (val_print (type, value_contents (val), 0, address, 980 stream, 0, &opts, current_language)); 981 } 982 983 static void 984 print_record (struct type *type, const gdb_byte *valaddr, 985 struct ui_file *stream, int recurse, 986 const struct value_print_options *options) 987 { 988 type = ada_check_typedef (type); 989 990 fprintf_filtered (stream, "("); 991 992 if (print_field_values (type, valaddr, stream, recurse, options, 993 0, type, valaddr) != 0 && options->pretty) 994 { 995 fprintf_filtered (stream, "\n"); 996 print_spaces_filtered (2 * recurse, stream); 997 } 998 999 fprintf_filtered (stream, ")"); 1000 } 1001 1002 /* Print out fields of value at VALADDR having structure type TYPE. 1003 1004 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the 1005 same meanings as in ada_print_value and ada_val_print. 1006 1007 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record 1008 (used to get discriminant values when printing variant parts). 1009 1010 COMMA_NEEDED is 1 if fields have been printed at the current recursion 1011 level, so that a comma is needed before any field printed by this 1012 call. 1013 1014 Returns 1 if COMMA_NEEDED or any fields were printed. */ 1015 1016 static int 1017 print_field_values (struct type *type, const gdb_byte *valaddr, 1018 struct ui_file *stream, int recurse, 1019 const struct value_print_options *options, 1020 int comma_needed, 1021 struct type *outer_type, const gdb_byte *outer_valaddr) 1022 { 1023 int i, len; 1024 1025 len = TYPE_NFIELDS (type); 1026 1027 for (i = 0; i < len; i += 1) 1028 { 1029 if (ada_is_ignored_field (type, i)) 1030 continue; 1031 1032 if (ada_is_wrapper_field (type, i)) 1033 { 1034 comma_needed = 1035 print_field_values (TYPE_FIELD_TYPE (type, i), 1036 valaddr 1037 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT, 1038 stream, recurse, options, 1039 comma_needed, type, valaddr); 1040 continue; 1041 } 1042 else if (ada_is_variant_part (type, i)) 1043 { 1044 comma_needed = 1045 print_variant_part (type, i, valaddr, 1046 stream, recurse, options, comma_needed, 1047 outer_type, outer_valaddr); 1048 continue; 1049 } 1050 1051 if (comma_needed) 1052 fprintf_filtered (stream, ", "); 1053 comma_needed = 1; 1054 1055 if (options->pretty) 1056 { 1057 fprintf_filtered (stream, "\n"); 1058 print_spaces_filtered (2 + 2 * recurse, stream); 1059 } 1060 else 1061 { 1062 wrap_here (n_spaces (2 + 2 * recurse)); 1063 } 1064 if (options->inspect_it) 1065 { 1066 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR) 1067 fputs_filtered ("\"( ptr \"", stream); 1068 else 1069 fputs_filtered ("\"( nodef \"", stream); 1070 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 1071 language_cplus, DMGL_NO_OPTS); 1072 fputs_filtered ("\" \"", stream); 1073 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 1074 language_cplus, DMGL_NO_OPTS); 1075 fputs_filtered ("\") \"", stream); 1076 } 1077 else 1078 { 1079 annotate_field_begin (TYPE_FIELD_TYPE (type, i)); 1080 fprintf_filtered (stream, "%.*s", 1081 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)), 1082 TYPE_FIELD_NAME (type, i)); 1083 annotate_field_name_end (); 1084 fputs_filtered (" => ", stream); 1085 annotate_field_value (); 1086 } 1087 1088 if (TYPE_FIELD_PACKED (type, i)) 1089 { 1090 struct value *v; 1091 1092 /* Bitfields require special handling, especially due to byte 1093 order problems. */ 1094 if (TYPE_CPLUS_SPECIFIC (type) != NULL 1095 && TYPE_FIELD_IGNORE (type, i)) 1096 { 1097 fputs_filtered (_("<optimized out or zero length>"), stream); 1098 } 1099 else 1100 { 1101 int bit_pos = TYPE_FIELD_BITPOS (type, i); 1102 int bit_size = TYPE_FIELD_BITSIZE (type, i); 1103 struct value_print_options opts; 1104 1105 adjust_type_signedness (TYPE_FIELD_TYPE (type, i)); 1106 v = ada_value_primitive_packed_val (NULL, valaddr, 1107 bit_pos / HOST_CHAR_BIT, 1108 bit_pos % HOST_CHAR_BIT, 1109 bit_size, 1110 TYPE_FIELD_TYPE (type, i)); 1111 opts = *options; 1112 opts.deref_ref = 0; 1113 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0, 1114 stream, recurse + 1, &opts, current_language); 1115 } 1116 } 1117 else 1118 { 1119 struct value_print_options opts = *options; 1120 opts.deref_ref = 0; 1121 ada_val_print (TYPE_FIELD_TYPE (type, i), 1122 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT, 1123 0, 0, stream, recurse + 1, &opts); 1124 } 1125 annotate_field_end (); 1126 } 1127 1128 return comma_needed; 1129 } 1130