1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-1989, 1991-1994, 1997, 2001-2012 Free
4 Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
23 #include "gdb_string.h"
26 #include "expression.h"
35 #include "exceptions.h"
38 static void print_record (struct type *, const gdb_byte *, int,
42 const struct value_print_options *);
44 static int print_field_values (struct type *, const gdb_byte *,
46 struct ui_file *, int,
48 const struct value_print_options *,
49 int, struct type *, int);
51 static void adjust_type_signedness (struct type *);
53 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
54 struct ui_file *, int,
56 const struct value_print_options *);
59 /* Make TYPE unsigned if its range of values includes no negatives. */
61 adjust_type_signedness (struct type *type)
63 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
64 && TYPE_LOW_BOUND (type) >= 0)
65 TYPE_UNSIGNED (type) = 1;
68 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
69 if non-standard (i.e., other than 1 for numbers, other than lower bound
70 of index type for enumerated type). Returns 1 if something printed,
74 print_optional_low_bound (struct ui_file *stream, struct type *type,
75 const struct value_print_options *options)
77 struct type *index_type;
81 if (options->print_array_indexes)
84 if (!get_array_bounds (type, &low_bound, &high_bound))
87 /* If this is an empty array, then don't print the lower bound.
88 That would be confusing, because we would print the lower bound,
89 followed by... nothing! */
90 if (low_bound > high_bound)
93 index_type = TYPE_INDEX_TYPE (type);
95 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
97 /* We need to know what the base type is, in order to do the
98 appropriate check below. Otherwise, if this is a subrange
99 of an enumerated type, where the underlying value of the
100 first element is typically 0, we might test the low bound
101 against the wrong value. */
102 index_type = TYPE_TARGET_TYPE (index_type);
105 switch (TYPE_CODE (index_type))
112 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
115 case TYPE_CODE_UNDEF:
124 ada_print_scalar (index_type, low_bound, stream);
125 fprintf_filtered (stream, " => ");
129 /* Version of val_print_array_elements for GNAT-style packed arrays.
130 Prints elements of packed array of type TYPE at bit offset
131 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
132 separates with commas. RECURSE is the recursion (nesting) level.
133 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
136 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
138 int bitoffset, struct ui_file *stream,
140 const struct value *val,
141 const struct value_print_options *options)
144 unsigned int things_printed = 0;
146 struct type *elttype, *index_type;
148 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
149 struct value *mark = value_mark ();
152 elttype = TYPE_TARGET_TYPE (type);
153 eltlen = TYPE_LENGTH (check_typedef (elttype));
154 index_type = TYPE_INDEX_TYPE (type);
159 if (get_discrete_bounds (index_type, &low, &high) < 0)
162 len = high - low + 1;
166 annotate_array_section_begin (i, elttype);
168 while (i < len && things_printed < options->print_max)
170 struct value *v0, *v1;
175 if (options->prettyprint_arrays)
177 fprintf_filtered (stream, ",\n");
178 print_spaces_filtered (2 + 2 * recurse, stream);
182 fprintf_filtered (stream, ", ");
185 wrap_here (n_spaces (2 + 2 * recurse));
186 maybe_print_array_index (index_type, i + low, stream, options);
189 v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
190 (i0 * bitsize) / HOST_CHAR_BIT,
191 (i0 * bitsize) % HOST_CHAR_BIT,
198 v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
199 (i * bitsize) / HOST_CHAR_BIT,
200 (i * bitsize) % HOST_CHAR_BIT,
202 if (!value_available_contents_eq (v0, value_embedded_offset (v0),
203 v1, value_embedded_offset (v1),
208 if (i - i0 > options->repeat_count_threshold)
210 struct value_print_options opts = *options;
213 val_print (elttype, value_contents_for_printing (v0),
214 value_embedded_offset (v0), 0, stream,
215 recurse + 1, v0, &opts, current_language);
216 annotate_elt_rep (i - i0);
217 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
218 annotate_elt_rep_end ();
224 struct value_print_options opts = *options;
227 for (j = i0; j < i; j += 1)
231 if (options->prettyprint_arrays)
233 fprintf_filtered (stream, ",\n");
234 print_spaces_filtered (2 + 2 * recurse, stream);
238 fprintf_filtered (stream, ", ");
240 wrap_here (n_spaces (2 + 2 * recurse));
241 maybe_print_array_index (index_type, j + low,
244 val_print (elttype, value_contents_for_printing (v0),
245 value_embedded_offset (v0), 0, stream,
246 recurse + 1, v0, &opts, current_language);
250 things_printed += i - i0;
252 annotate_array_section_end ();
255 fprintf_filtered (stream, "...");
258 value_free_to_mark (mark);
262 printable_val_type (struct type *type, const gdb_byte *valaddr)
264 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
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
272 ada_emit_char (int c, struct type *type, struct ui_file *stream,
273 int quoter, int type_len)
275 /* If this character fits in the normal ASCII range, and is
276 a printable character, then print the character as if it was
277 an ASCII character, even if this is a wide character.
278 The UCHAR_MAX check is necessary because the isascii function
279 requires that its argument have a value of an unsigned char,
280 or EOF (EOF is obviously not printable). */
281 if (c <= UCHAR_MAX && isascii (c) && isprint (c))
283 if (c == quoter && c == '"')
284 fprintf_filtered (stream, "\"\"");
286 fprintf_filtered (stream, "%c", c);
289 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
292 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
296 char_at (const gdb_byte *string, int i, int type_len,
297 enum bfd_endian byte_order)
302 return (int) extract_unsigned_integer (string + type_len * i,
303 type_len, byte_order);
306 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
308 ui_memcpy (void *dest, const char *buffer, long len)
310 memcpy (dest, buffer, (size_t) len);
311 ((char *) dest)[len] = '\0';
314 /* Print a floating-point value of type TYPE, pointed to in GDB by
315 VALADDR, on STREAM. Use Ada formatting conventions: there must be
316 a decimal point, and at least one digit before and after the
317 point. We use GNAT format for NaNs and infinities. */
319 ada_print_floating (const gdb_byte *valaddr, struct type *type,
320 struct ui_file *stream)
325 struct ui_file *tmp_stream = mem_fileopen ();
326 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
328 print_floating (valaddr, type, tmp_stream);
329 ui_file_put (tmp_stream, ui_memcpy, buffer);
330 do_cleanups (cleanups);
333 len = strlen (result);
335 /* Modify for Ada rules. */
337 s = strstr (result, "inf");
339 s = strstr (result, "Inf");
341 s = strstr (result, "INF");
347 s = strstr (result, "nan");
349 s = strstr (result, "NaN");
351 s = strstr (result, "Nan");
355 if (result[0] == '-')
360 if (s == NULL && strchr (result, '.') == NULL)
362 s = strchr (result, 'e');
364 fprintf_filtered (stream, "%s.0", result);
366 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
369 fprintf_filtered (stream, "%s", result);
373 ada_printchar (int c, struct type *type, struct ui_file *stream)
375 fputs_filtered ("'", stream);
376 ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
377 fputs_filtered ("'", stream);
380 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
381 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
382 like a default signed integer. */
385 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
392 print_longest (stream, 'd', 0, val);
396 type = ada_check_typedef (type);
398 switch (TYPE_CODE (type))
402 len = TYPE_NFIELDS (type);
403 for (i = 0; i < len; i++)
405 if (TYPE_FIELD_BITPOS (type, i) == val)
412 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
416 print_longest (stream, 'd', 0, val);
421 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
425 LA_PRINT_CHAR (val, type, stream);
429 fprintf_filtered (stream, val ? "true" : "false");
432 case TYPE_CODE_RANGE:
433 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
436 case TYPE_CODE_UNDEF:
438 case TYPE_CODE_ARRAY:
439 case TYPE_CODE_STRUCT:
440 case TYPE_CODE_UNION:
445 case TYPE_CODE_STRING:
446 case TYPE_CODE_ERROR:
447 case TYPE_CODE_MEMBERPTR:
448 case TYPE_CODE_METHODPTR:
449 case TYPE_CODE_METHOD:
451 warning (_("internal error: unhandled type in ada_print_scalar"));
455 error (_("Invalid type code in symbol table."));
460 /* Print the character string STRING, printing at most LENGTH characters.
461 Printing stops early if the number hits print_max; repeat counts
462 are printed as appropriate. Print ellipses at the end if we
463 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
464 TYPE_LEN is the length (1 or 2) of the character type. */
467 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
468 unsigned int length, int force_ellipses, int type_len,
469 const struct value_print_options *options)
471 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
473 unsigned int things_printed = 0;
479 fputs_filtered ("\"\"", stream);
483 for (i = 0; i < length && things_printed < options->print_max; i += 1)
485 /* Position of the character we are examining
486 to see whether it is repeated. */
488 /* Number of repetitions we have detected so far. */
495 fputs_filtered (", ", stream);
502 && char_at (string, rep1, type_len, byte_order)
503 == char_at (string, i, type_len, byte_order))
509 if (reps > options->repeat_count_threshold)
513 if (options->inspect_it)
514 fputs_filtered ("\\\", ", stream);
516 fputs_filtered ("\", ", stream);
519 fputs_filtered ("'", stream);
520 ada_emit_char (char_at (string, i, type_len, byte_order),
521 elttype, stream, '\'', type_len);
522 fputs_filtered ("'", stream);
523 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
525 things_printed += options->repeat_count_threshold;
532 if (options->inspect_it)
533 fputs_filtered ("\\\"", stream);
535 fputs_filtered ("\"", stream);
538 ada_emit_char (char_at (string, i, type_len, byte_order),
539 elttype, stream, '"', type_len);
544 /* Terminate the quotes if necessary. */
547 if (options->inspect_it)
548 fputs_filtered ("\\\"", stream);
550 fputs_filtered ("\"", stream);
553 if (force_ellipses || i < length)
554 fputs_filtered ("...", stream);
558 ada_printstr (struct ui_file *stream, struct type *type,
559 const gdb_byte *string, unsigned int length,
560 const char *encoding, int force_ellipses,
561 const struct value_print_options *options)
563 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
568 /* See val_print for a description of the various parameters of this
569 function; they are identical. The semantics of the return value is
570 also identical to val_print. */
573 ada_val_print (struct type *type, const gdb_byte *valaddr,
574 int embedded_offset, CORE_ADDR address,
575 struct ui_file *stream, int recurse,
576 const struct value *val,
577 const struct value_print_options *options)
579 volatile struct gdb_exception except;
582 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
583 TRY_CATCH (except, RETURN_MASK_ALL)
585 result = ada_val_print_1 (type, valaddr, embedded_offset, address,
586 stream, recurse, val, options);
589 if (except.reason < 0)
595 /* Assuming TYPE is a simple array, print the value of this array located
596 at VALADDR + OFFSET. See ada_val_print for a description of the various
597 parameters of this function; they are identical. The semantics
598 of the return value is also identical to ada_val_print. */
601 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
602 int offset, CORE_ADDR address,
603 struct ui_file *stream, int recurse,
604 const struct value *val,
605 const struct value_print_options *options)
609 /* For an array of chars, print with string syntax. */
610 if (ada_is_string_type (type)
611 && (options->format == 0 || options->format == 's'))
613 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
614 struct type *elttype = TYPE_TARGET_TYPE (type);
618 /* We know that ELTTYPE cannot possibly be null, because we found
619 that TYPE is a string-like type. Similarly, the size of ELTTYPE
620 should also be non-null, since it's a character-like type. */
621 gdb_assert (elttype != NULL);
622 gdb_assert (TYPE_LENGTH (elttype) != 0);
624 eltlen = TYPE_LENGTH (elttype);
625 len = TYPE_LENGTH (type) / eltlen;
627 if (options->prettyprint_arrays)
628 print_spaces_filtered (2 + 2 * recurse, stream);
630 /* If requested, look for the first null char and only print
631 elements up to it. */
632 if (options->stop_print_at_null)
636 /* Look for a NULL char. */
639 && temp_len < options->print_max
640 && char_at (valaddr + offset,
641 temp_len, eltlen, byte_order) != 0);
646 printstr (stream, elttype, valaddr + offset, len, 0, eltlen, options);
651 fprintf_filtered (stream, "(");
652 print_optional_low_bound (stream, type, options);
653 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
654 val_print_packed_array_elements (type, valaddr, offset,
655 0, stream, recurse, val, options);
657 val_print_array_elements (type, valaddr, offset, address,
658 stream, recurse, val, options, 0);
659 fprintf_filtered (stream, ")");
665 /* See the comment on ada_val_print. This function differs in that it
666 does not catch evaluation errors (leaving that to ada_val_print). */
669 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
670 int offset, CORE_ADDR address,
671 struct ui_file *stream, int recurse,
672 const struct value *original_value,
673 const struct value_print_options *options)
677 struct type *elttype;
681 type = ada_check_typedef (type);
683 if (ada_is_array_descriptor_type (type)
684 || (ada_is_constrained_packed_array_type (type)
685 && TYPE_CODE (type) != TYPE_CODE_PTR))
688 struct value *mark = value_mark ();
691 val = value_from_contents_and_address (type, valaddr + offset, address);
692 /* If this is a reference, coerce it now. This helps taking care
693 of the case where ADDRESS is meaningless because original_value
695 val = coerce_ref (val);
696 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
697 val = ada_coerce_to_simple_array_ptr (val);
699 val = ada_coerce_to_simple_array (val);
702 gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
703 fprintf_filtered (stream, "0x0");
707 retn = ada_val_print_1 (value_type (val),
708 value_contents_for_printing (val),
709 value_embedded_offset (val),
710 value_address (val), stream, recurse,
712 value_free_to_mark (mark);
716 offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
717 type = printable_val_type (type, valaddr + offset_aligned);
719 switch (TYPE_CODE (type))
722 return c_val_print (type, valaddr, offset, address, stream,
723 recurse, original_value, options);
727 int ret = c_val_print (type, valaddr, offset, address,
728 stream, recurse, original_value, options);
730 if (ada_is_tag_type (type))
733 value_from_contents_and_address (type,
734 valaddr + offset_aligned,
735 address + offset_aligned);
736 const char *name = ada_tag_name (val);
739 fprintf_filtered (stream, " (%s)", name);
746 case TYPE_CODE_RANGE:
747 if (ada_is_fixed_point_type (type))
749 LONGEST v = unpack_long (type, valaddr + offset_aligned);
750 int len = TYPE_LENGTH (type);
752 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
753 (double) ada_fixed_to_float (type, v));
756 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
758 struct type *target_type = TYPE_TARGET_TYPE (type);
760 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
762 /* Obscure case of range type that has different length from
763 its base type. Perform a conversion, or we will get a
764 nonsense value. Actually, we could use the same
765 code regardless of lengths; I'm just avoiding a cast. */
767 = value_from_contents_and_address (type, valaddr + offset, 0);
768 struct value *v = value_cast (target_type, v1);
770 return ada_val_print_1 (target_type,
771 value_contents_for_printing (v),
772 value_embedded_offset (v), 0,
773 stream, recurse + 1, v, options);
776 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
778 address, stream, recurse,
779 original_value, options);
783 int format = (options->format ? options->format
784 : options->output_format);
788 struct value_print_options opts = *options;
790 opts.format = format;
791 val_print_scalar_formatted (type, valaddr, offset_aligned,
792 original_value, &opts, 0, stream);
794 else if (ada_is_system_address_type (type))
796 /* FIXME: We want to print System.Address variables using
797 the same format as for any access type. But for some
798 reason GNAT encodes the System.Address type as an int,
799 so we have to work-around this deficiency by handling
800 System.Address values as a special case. */
802 struct gdbarch *gdbarch = get_type_arch (type);
803 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
804 CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
807 fprintf_filtered (stream, "(");
808 type_print (type, "", stream, -1);
809 fprintf_filtered (stream, ") ");
810 fputs_filtered (paddress (gdbarch, addr), stream);
814 val_print_type_code_int (type, valaddr + offset_aligned, stream);
815 if (ada_is_character_type (type))
819 fputs_filtered (" ", stream);
820 c = unpack_long (type, valaddr + offset_aligned);
821 ada_printchar (c, type, stream);
830 val_print_scalar_formatted (type, valaddr, offset_aligned,
831 original_value, options, 0, stream);
834 len = TYPE_NFIELDS (type);
835 val = unpack_long (type, valaddr + offset_aligned);
836 for (i = 0; i < len; i++)
839 if (val == TYPE_FIELD_BITPOS (type, i))
846 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
849 fprintf_filtered (stream, "%ld %s", (long) val, name);
851 fputs_filtered (name, stream);
855 print_longest (stream, 'd', 0, val);
859 case TYPE_CODE_FLAGS:
861 val_print_scalar_formatted (type, valaddr, offset_aligned,
862 original_value, options, 0, stream);
864 val_print_type_code_flags (type, valaddr + offset_aligned, stream);
869 return c_val_print (type, valaddr, offset, address, stream,
870 recurse, original_value, options);
872 ada_print_floating (valaddr + offset, type, stream);
875 case TYPE_CODE_UNION:
876 case TYPE_CODE_STRUCT:
877 if (ada_is_bogus_array_descriptor (type))
879 fprintf_filtered (stream, "(...?)");
884 print_record (type, valaddr, offset_aligned,
885 stream, recurse, original_value, options);
889 case TYPE_CODE_ARRAY:
890 return ada_val_print_array (type, valaddr, offset_aligned,
891 address, stream, recurse, original_value,
895 /* For references, the debugger is expected to print the value as
896 an address if DEREF_REF is null. But printing an address in place
897 of the object value would be confusing to an Ada programmer.
898 So, for Ada values, we print the actual dereferenced value
900 elttype = check_typedef (TYPE_TARGET_TYPE (type));
902 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
904 CORE_ADDR deref_val_int;
905 struct value *deref_val;
907 deref_val = coerce_ref_if_computed (original_value);
910 common_val_print (deref_val, stream, recurse + 1, options,
915 deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
916 if (deref_val_int != 0)
918 struct value *deref_val =
919 ada_value_ind (value_from_pointer
920 (lookup_pointer_type (elttype),
923 val_print (value_type (deref_val),
924 value_contents_for_printing (deref_val),
925 value_embedded_offset (deref_val),
926 value_address (deref_val), stream, recurse + 1,
927 deref_val, options, current_language);
930 fputs_filtered ("(null)", stream);
933 fputs_filtered ("???", stream);
942 print_variant_part (struct type *type, int field_num,
943 const gdb_byte *valaddr, int offset,
944 struct ui_file *stream, int recurse,
945 const struct value *val,
946 const struct value_print_options *options,
948 struct type *outer_type, int outer_offset)
950 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
951 int which = ada_which_variant_applies (var_type, outer_type,
952 valaddr + outer_offset);
957 return print_field_values
958 (TYPE_FIELD_TYPE (var_type, which),
960 offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
961 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
962 stream, recurse, val, options,
963 comma_needed, outer_type, outer_offset);
967 ada_value_print (struct value *val0, struct ui_file *stream,
968 const struct value_print_options *options)
970 struct value *val = ada_to_fixed_value (val0);
971 CORE_ADDR address = value_address (val);
972 struct type *type = ada_check_typedef (value_type (val));
973 struct value_print_options opts;
975 /* If it is a pointer, indicate what it points to. */
976 if (TYPE_CODE (type) == TYPE_CODE_PTR)
978 /* Hack: don't print (char *) for char strings. Their
979 type is indicated by the quoted string anyway. */
980 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
981 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
982 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
984 fprintf_filtered (stream, "(");
985 type_print (type, "", stream, -1);
986 fprintf_filtered (stream, ") ");
989 else if (ada_is_array_descriptor_type (type))
991 /* We do not print the type description unless TYPE is an array
992 access type (this is encoded by the compiler as a typedef to
993 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
994 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
996 fprintf_filtered (stream, "(");
997 type_print (type, "", stream, -1);
998 fprintf_filtered (stream, ") ");
1001 else if (ada_is_bogus_array_descriptor (type))
1003 fprintf_filtered (stream, "(");
1004 type_print (type, "", stream, -1);
1005 fprintf_filtered (stream, ") (...?)");
1011 return (val_print (type, value_contents_for_printing (val),
1012 value_embedded_offset (val), address,
1013 stream, 0, val, &opts, current_language));
1017 print_record (struct type *type, const gdb_byte *valaddr,
1019 struct ui_file *stream, int recurse,
1020 const struct value *val,
1021 const struct value_print_options *options)
1023 type = ada_check_typedef (type);
1025 fprintf_filtered (stream, "(");
1027 if (print_field_values (type, valaddr, offset,
1028 stream, recurse, val, options,
1029 0, type, offset) != 0 && options->pretty)
1031 fprintf_filtered (stream, "\n");
1032 print_spaces_filtered (2 * recurse, stream);
1035 fprintf_filtered (stream, ")");
1038 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
1040 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
1041 meanings as in ada_print_value and ada_val_print.
1043 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
1044 record (used to get discriminant values when printing variant
1047 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1048 level, so that a comma is needed before any field printed by this
1051 Returns 1 if COMMA_NEEDED or any fields were printed. */
1054 print_field_values (struct type *type, const gdb_byte *valaddr,
1055 int offset, struct ui_file *stream, int recurse,
1056 const struct value *val,
1057 const struct value_print_options *options,
1059 struct type *outer_type, int outer_offset)
1063 len = TYPE_NFIELDS (type);
1065 for (i = 0; i < len; i += 1)
1067 if (ada_is_ignored_field (type, i))
1070 if (ada_is_wrapper_field (type, i))
1073 print_field_values (TYPE_FIELD_TYPE (type, i),
1076 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1077 stream, recurse, val, options,
1078 comma_needed, type, offset);
1081 else if (ada_is_variant_part (type, i))
1084 print_variant_part (type, i, valaddr,
1085 offset, stream, recurse, val,
1086 options, comma_needed,
1087 outer_type, outer_offset);
1092 fprintf_filtered (stream, ", ");
1095 if (options->pretty)
1097 fprintf_filtered (stream, "\n");
1098 print_spaces_filtered (2 + 2 * recurse, stream);
1102 wrap_here (n_spaces (2 + 2 * recurse));
1104 if (options->inspect_it)
1106 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1107 fputs_filtered ("\"( ptr \"", stream);
1109 fputs_filtered ("\"( nodef \"", stream);
1110 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1111 language_cplus, DMGL_NO_OPTS);
1112 fputs_filtered ("\" \"", stream);
1113 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1114 language_cplus, DMGL_NO_OPTS);
1115 fputs_filtered ("\") \"", stream);
1119 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1120 fprintf_filtered (stream, "%.*s",
1121 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1122 TYPE_FIELD_NAME (type, i));
1123 annotate_field_name_end ();
1124 fputs_filtered (" => ", stream);
1125 annotate_field_value ();
1128 if (TYPE_FIELD_PACKED (type, i))
1132 /* Bitfields require special handling, especially due to byte
1134 if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
1136 fputs_filtered (_("<optimized out or zero length>"), stream);
1140 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1141 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1142 struct value_print_options opts;
1144 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1145 v = ada_value_primitive_packed_val
1147 offset + bit_pos / HOST_CHAR_BIT,
1148 bit_pos % HOST_CHAR_BIT,
1149 bit_size, TYPE_FIELD_TYPE (type, i));
1152 val_print (TYPE_FIELD_TYPE (type, i),
1153 value_contents_for_printing (v),
1154 value_embedded_offset (v), 0,
1155 stream, recurse + 1, v,
1156 &opts, current_language);
1161 struct value_print_options opts = *options;
1164 ada_val_print (TYPE_FIELD_TYPE (type, i),
1167 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1168 0, stream, recurse + 1, val, &opts);
1170 annotate_field_end ();
1173 return comma_needed;