1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001,
4 2002, 2003, 2004, 2005 Free 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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "gdb_string.h"
27 #include "expression.h"
36 #include "exceptions.h"
38 /* Encapsulates arguments to ada_val_print. */
39 struct ada_val_print_args
42 const gdb_byte *valaddr0;
45 struct ui_file *stream;
49 enum val_prettyprint pretty;
52 static void print_record (struct type *, const gdb_byte *, struct ui_file *,
53 int, int, enum val_prettyprint);
55 static int print_field_values (struct type *, const gdb_byte *,
56 struct ui_file *, int, int,
57 enum val_prettyprint, int, struct type *,
60 static void adjust_type_signedness (struct type *);
62 static int ada_val_print_stub (void *args0);
64 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
65 struct ui_file *, int, int, int,
66 enum val_prettyprint);
69 /* Make TYPE unsigned if its range of values includes no negatives. */
71 adjust_type_signedness (struct type *type)
73 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
74 && TYPE_LOW_BOUND (type) >= 0)
75 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
78 /* Assuming TYPE is a simple, non-empty array type, prints its lower bound
79 on STREAM, if non-standard (i.e., other than 1 for numbers, other
80 than lower bound of index type for enumerated type). Returns 1
81 if something printed, otherwise 0. */
84 print_optional_low_bound (struct ui_file *stream, struct type *type)
86 struct type *index_type;
89 if (print_array_indexes_p ())
92 if (!get_array_low_bound (type, &low_bound))
95 index_type = TYPE_INDEX_TYPE (type);
97 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
99 /* We need to know what the base type is, in order to do the
100 appropriate check below. Otherwise, if this is a subrange
101 of an enumerated type, where the underlying value of the
102 first element is typically 0, we might test the low bound
103 against the wrong value. */
104 index_type = TYPE_TARGET_TYPE (index_type);
107 switch (TYPE_CODE (index_type))
110 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
113 case TYPE_CODE_UNDEF:
114 index_type = builtin_type_long;
122 ada_print_scalar (index_type, (LONGEST) low_bound, stream);
123 fprintf_filtered (stream, " => ");
127 /* Version of val_print_array_elements for GNAT-style packed arrays.
128 Prints elements of packed array of type TYPE at bit offset
129 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
130 separates with commas. RECURSE is the recursion (nesting) level.
131 If PRETTY, uses "prettier" format. TYPE must have been decoded (as
132 by ada_coerce_to_simple_array). */
135 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
136 int bitoffset, struct ui_file *stream,
137 int format, int recurse,
138 enum val_prettyprint pretty)
141 unsigned int things_printed = 0;
143 struct type *elttype, *index_type;
145 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
146 struct value *mark = value_mark ();
149 elttype = TYPE_TARGET_TYPE (type);
150 eltlen = TYPE_LENGTH (check_typedef (elttype));
151 index_type = TYPE_INDEX_TYPE (type);
155 if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
158 len = high - low + 1;
162 annotate_array_section_begin (i, elttype);
164 while (i < len && things_printed < print_max)
166 struct value *v0, *v1;
171 if (prettyprint_arrays)
173 fprintf_filtered (stream, ",\n");
174 print_spaces_filtered (2 + 2 * recurse, stream);
178 fprintf_filtered (stream, ", ");
181 wrap_here (n_spaces (2 + 2 * recurse));
182 maybe_print_array_index (index_type, i + low, stream, format, pretty);
185 v0 = ada_value_primitive_packed_val (NULL, valaddr,
186 (i0 * bitsize) / HOST_CHAR_BIT,
187 (i0 * bitsize) % HOST_CHAR_BIT,
194 v1 = ada_value_primitive_packed_val (NULL, valaddr,
195 (i * bitsize) / HOST_CHAR_BIT,
196 (i * bitsize) % HOST_CHAR_BIT,
198 if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
202 if (i - i0 > repeat_count_threshold)
204 val_print (elttype, value_contents (v0), 0, 0, stream, format,
205 0, recurse + 1, pretty);
206 annotate_elt_rep (i - i0);
207 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
208 annotate_elt_rep_end ();
214 for (j = i0; j < i; j += 1)
218 if (prettyprint_arrays)
220 fprintf_filtered (stream, ",\n");
221 print_spaces_filtered (2 + 2 * recurse, stream);
225 fprintf_filtered (stream, ", ");
227 wrap_here (n_spaces (2 + 2 * recurse));
228 maybe_print_array_index (index_type, j + low,
229 stream, format, pretty);
231 val_print (elttype, value_contents (v0), 0, 0, stream, format,
232 0, recurse + 1, pretty);
236 things_printed += i - i0;
238 annotate_array_section_end ();
241 fprintf_filtered (stream, "...");
244 value_free_to_mark (mark);
248 printable_val_type (struct type *type, const gdb_byte *valaddr)
250 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
253 /* Print the character C on STREAM as part of the contents of a literal
254 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
255 (1 or 2) of the character. */
258 ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
263 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
265 if (isascii (c) && isprint (c))
267 if (c == quoter && c == '"')
268 fprintf_filtered (stream, "[\"%c\"]", quoter);
270 fprintf_filtered (stream, "%c", c);
273 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
276 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
277 or 2) of a character. */
280 char_at (const gdb_byte *string, int i, int type_len)
285 return (int) extract_unsigned_integer (string + 2 * i, 2);
288 /* Wrapper around memcpy to make it legal argument to ui_file_put */
290 ui_memcpy (void *dest, const char *buffer, long len)
292 memcpy (dest, buffer, (size_t) len);
293 ((char *) dest)[len] = '\0';
296 /* Print a floating-point value of type TYPE, pointed to in GDB by
297 VALADDR, on STREAM. Use Ada formatting conventions: there must be
298 a decimal point, and at least one digit before and after the
299 point. We use GNAT format for NaNs and infinities. */
301 ada_print_floating (const gdb_byte *valaddr, struct type *type,
302 struct ui_file *stream)
307 struct ui_file *tmp_stream = mem_fileopen ();
308 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
310 print_floating (valaddr, type, tmp_stream);
311 ui_file_put (tmp_stream, ui_memcpy, buffer);
312 do_cleanups (cleanups);
315 len = strlen (result);
317 /* Modify for Ada rules. */
319 s = strstr (result, "inf");
321 s = strstr (result, "Inf");
323 s = strstr (result, "INF");
329 s = strstr (result, "nan");
331 s = strstr (result, "NaN");
333 s = strstr (result, "Nan");
337 if (result[0] == '-')
342 if (s == NULL && strchr (result, '.') == NULL)
344 s = strchr (result, 'e');
346 fprintf_filtered (stream, "%s.0", result);
348 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
351 fprintf_filtered (stream, "%s", result);
355 ada_printchar (int c, struct ui_file *stream)
357 fputs_filtered ("'", stream);
358 ada_emit_char (c, stream, '\'', 1);
359 fputs_filtered ("'", stream);
362 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
363 form appropriate for TYPE. */
366 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
371 type = ada_check_typedef (type);
373 switch (TYPE_CODE (type))
377 len = TYPE_NFIELDS (type);
378 for (i = 0; i < len; i++)
380 if (TYPE_FIELD_BITPOS (type, i) == val)
387 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
391 print_longest (stream, 'd', 0, val);
396 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
400 LA_PRINT_CHAR ((unsigned char) val, stream);
404 fprintf_filtered (stream, val ? "true" : "false");
407 case TYPE_CODE_RANGE:
408 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
411 case TYPE_CODE_UNDEF:
413 case TYPE_CODE_ARRAY:
414 case TYPE_CODE_STRUCT:
415 case TYPE_CODE_UNION:
420 case TYPE_CODE_STRING:
421 case TYPE_CODE_ERROR:
422 case TYPE_CODE_MEMBER:
423 case TYPE_CODE_METHOD:
425 warning (_("internal error: unhandled type in ada_print_scalar"));
429 error (_("Invalid type code in symbol table."));
434 /* Print the character string STRING, printing at most LENGTH characters.
435 Printing stops early if the number hits print_max; repeat counts
436 are printed as appropriate. Print ellipses at the end if we
437 had to stop before printing LENGTH characters, or if
438 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
442 printstr (struct ui_file *stream, const gdb_byte *string,
443 unsigned int length, int force_ellipses, int type_len)
446 unsigned int things_printed = 0;
452 fputs_filtered ("\"\"", stream);
456 for (i = 0; i < length && things_printed < print_max; i += 1)
458 /* Position of the character we are examining
459 to see whether it is repeated. */
461 /* Number of repetitions we have detected so far. */
468 fputs_filtered (", ", stream);
475 && char_at (string, rep1, type_len) == char_at (string, i,
482 if (reps > repeat_count_threshold)
487 fputs_filtered ("\\\", ", stream);
489 fputs_filtered ("\", ", stream);
492 fputs_filtered ("'", stream);
493 ada_emit_char (char_at (string, i, type_len), stream, '\'',
495 fputs_filtered ("'", stream);
496 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
498 things_printed += repeat_count_threshold;
506 fputs_filtered ("\\\"", stream);
508 fputs_filtered ("\"", stream);
511 ada_emit_char (char_at (string, i, type_len), stream, '"',
517 /* Terminate the quotes if necessary. */
521 fputs_filtered ("\\\"", stream);
523 fputs_filtered ("\"", stream);
526 if (force_ellipses || i < length)
527 fputs_filtered ("...", stream);
531 ada_printstr (struct ui_file *stream, const gdb_byte *string,
532 unsigned int length, int width, int force_ellipses)
534 printstr (stream, string, length, force_ellipses, width);
538 /* Print data of type TYPE located at VALADDR (within GDB), which came from
539 the inferior at address ADDRESS, onto stdio stream STREAM according to
540 FORMAT (a letter as for the printf % codes or 0 for natural format).
541 The data at VALADDR is in target byte order.
543 If the data is printed as a string, returns the number of string characters
546 If DEREF_REF is nonzero, then dereference references, otherwise just print
549 RECURSE indicates the amount of indentation to supply before
550 continuation lines; this amount is roughly twice the value of RECURSE.
552 When PRETTY is non-zero, prints record fields on separate lines.
553 (For some reason, the current version of gdb instead uses a global
554 variable---prettyprint_arrays--- to causes a similar effect on
558 ada_val_print (struct type *type, const gdb_byte *valaddr0,
559 int embedded_offset, CORE_ADDR address,
560 struct ui_file *stream, int format, int deref_ref,
561 int recurse, enum val_prettyprint pretty)
563 struct ada_val_print_args args;
565 args.valaddr0 = valaddr0;
566 args.embedded_offset = embedded_offset;
567 args.address = address;
568 args.stream = stream;
569 args.format = format;
570 args.deref_ref = deref_ref;
571 args.recurse = recurse;
572 args.pretty = pretty;
574 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
577 /* Helper for ada_val_print; used as argument to catch_errors to
578 unmarshal the arguments to ada_val_print_1, which does the work. */
580 ada_val_print_stub (void *args0)
582 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
583 return ada_val_print_1 (argsp->type, argsp->valaddr0,
584 argsp->embedded_offset, argsp->address,
585 argsp->stream, argsp->format, argsp->deref_ref,
586 argsp->recurse, argsp->pretty);
589 /* See the comment on ada_val_print. This function differs in that it
590 * does not catch evaluation errors (leaving that to ada_val_print). */
593 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
594 int embedded_offset, CORE_ADDR address,
595 struct ui_file *stream, int format,
596 int deref_ref, int recurse, enum val_prettyprint pretty)
600 struct type *elttype;
603 const gdb_byte *valaddr = valaddr0 + embedded_offset;
605 type = ada_check_typedef (type);
607 if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
610 struct value *mark = value_mark ();
612 val = value_from_contents_and_address (type, valaddr, address);
613 val = ada_coerce_to_simple_array_ptr (val);
616 fprintf_filtered (stream, "(null)");
620 retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
621 VALUE_ADDRESS (val), stream, format,
622 deref_ref, recurse, pretty);
623 value_free_to_mark (mark);
627 valaddr = ada_aligned_value_addr (type, valaddr);
628 embedded_offset -= valaddr - valaddr0 - embedded_offset;
629 type = printable_val_type (type, valaddr);
631 switch (TYPE_CODE (type))
634 return c_val_print (type, valaddr0, embedded_offset, address, stream,
635 format, deref_ref, recurse, pretty);
639 int ret = c_val_print (type, valaddr0, embedded_offset, address,
640 stream, format, deref_ref, recurse, pretty);
641 if (ada_is_tag_type (type))
644 value_from_contents_and_address (type, valaddr, address);
645 const char *name = ada_tag_name (val);
647 fprintf_filtered (stream, " (%s)", name);
654 case TYPE_CODE_RANGE:
655 if (ada_is_fixed_point_type (type))
657 LONGEST v = unpack_long (type, valaddr);
658 int len = TYPE_LENGTH (type);
660 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
661 (double) ada_fixed_to_float (type, v));
664 else if (ada_is_vax_floating_type (type))
667 value_from_contents_and_address (type, valaddr, address);
668 struct value *func = ada_vax_float_print_function (type);
671 static struct type *parray_of_char = NULL;
672 struct value *printable_val;
674 if (parray_of_char == NULL)
678 (NULL, builtin_type_char,
679 create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
682 value_ind (value_cast (parray_of_char,
683 call_function_by_hand (func, 1,
686 fprintf_filtered (stream, "%s", value_contents (printable_val));
689 /* No special printing function. Do as best we can. */
691 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
693 struct type *target_type = TYPE_TARGET_TYPE (type);
694 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
696 /* Obscure case of range type that has different length from
697 its base type. Perform a conversion, or we will get a
698 nonsense value. Actually, we could use the same
699 code regardless of lengths; I'm just avoiding a cast. */
700 struct value *v = value_cast (target_type,
701 value_from_contents_and_address
703 return ada_val_print_1 (target_type, value_contents (v), 0, 0,
704 stream, format, 0, recurse + 1, pretty);
707 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
708 valaddr0, embedded_offset,
709 address, stream, format, deref_ref,
714 format = format ? format : output_format;
717 print_scalar_formatted (valaddr, type, format, 0, stream);
719 else if (ada_is_system_address_type (type))
721 /* FIXME: We want to print System.Address variables using
722 the same format as for any access type. But for some
723 reason GNAT encodes the System.Address type as an int,
724 so we have to work-around this deficiency by handling
725 System.Address values as a special case. */
726 fprintf_filtered (stream, "(");
727 type_print (type, "", stream, -1);
728 fprintf_filtered (stream, ") ");
729 deprecated_print_address_numeric
730 (extract_typed_address (valaddr, builtin_type_void_data_ptr),
735 val_print_type_code_int (type, valaddr, stream);
736 if (ada_is_character_type (type))
738 fputs_filtered (" ", stream);
739 ada_printchar ((unsigned char) unpack_long (type, valaddr),
749 print_scalar_formatted (valaddr, type, format, 0, stream);
752 len = TYPE_NFIELDS (type);
753 val = unpack_long (type, valaddr);
754 for (i = 0; i < len; i++)
757 if (val == TYPE_FIELD_BITPOS (type, i))
764 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
766 fprintf_filtered (stream, "%ld %s", (long) val, name);
768 fputs_filtered (name, stream);
772 print_longest (stream, 'd', 0, val);
778 return c_val_print (type, valaddr0, embedded_offset, address, stream,
779 format, deref_ref, recurse, pretty);
781 ada_print_floating (valaddr0 + embedded_offset, type, stream);
784 case TYPE_CODE_UNION:
785 case TYPE_CODE_STRUCT:
786 if (ada_is_bogus_array_descriptor (type))
788 fprintf_filtered (stream, "(...?)");
793 print_record (type, valaddr, stream, format, recurse, pretty);
797 case TYPE_CODE_ARRAY:
798 elttype = TYPE_TARGET_TYPE (type);
802 eltlen = TYPE_LENGTH (elttype);
803 /* FIXME: This doesn't deal with non-empty arrays of
804 0-length items (not a typical case!) */
808 len = TYPE_LENGTH (type) / eltlen;
810 /* For an array of chars, print with string syntax. */
811 if (ada_is_string_type (type) && (format == 0 || format == 's'))
813 if (prettyprint_arrays)
815 print_spaces_filtered (2 + 2 * recurse, stream);
817 /* If requested, look for the first null char and only print
818 elements up to it. */
819 if (stop_print_at_null)
823 /* Look for a NULL char. */
825 temp_len < len && temp_len < print_max
826 && char_at (valaddr, temp_len, eltlen) != 0;
831 printstr (stream, valaddr, len, 0, eltlen);
836 fprintf_filtered (stream, "(");
837 print_optional_low_bound (stream, type);
838 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
839 val_print_packed_array_elements (type, valaddr, 0, stream,
840 format, recurse, pretty);
842 val_print_array_elements (type, valaddr, address, stream,
843 format, deref_ref, recurse,
845 fprintf_filtered (stream, ")");
851 elttype = check_typedef (TYPE_TARGET_TYPE (type));
852 /* De-reference the reference */
855 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
857 LONGEST deref_val_int = (LONGEST)
858 unpack_pointer (lookup_pointer_type (builtin_type_void),
860 if (deref_val_int != 0)
862 struct value *deref_val =
863 ada_value_ind (value_from_longest
864 (lookup_pointer_type (elttype),
866 val_print (value_type (deref_val),
867 value_contents (deref_val), 0,
868 VALUE_ADDRESS (deref_val), stream, format,
869 deref_ref, recurse + 1, pretty);
872 fputs_filtered ("(null)", stream);
875 fputs_filtered ("???", stream);
884 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
885 struct ui_file *stream, int format, int recurse,
886 enum val_prettyprint pretty, int comma_needed,
887 struct type *outer_type, const gdb_byte *outer_valaddr)
889 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
890 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
895 return print_field_values
896 (TYPE_FIELD_TYPE (var_type, which),
897 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
898 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
899 stream, format, recurse, pretty,
900 comma_needed, outer_type, outer_valaddr);
904 ada_value_print (struct value *val0, struct ui_file *stream, int format,
905 enum val_prettyprint pretty)
907 const gdb_byte *valaddr = value_contents (val0);
908 CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
910 ada_to_fixed_type (value_type (val0), valaddr, address, NULL);
912 value_from_contents_and_address (type, valaddr, address);
914 /* If it is a pointer, indicate what it points to. */
915 if (TYPE_CODE (type) == TYPE_CODE_PTR)
917 /* Hack: don't print (char *) for char strings. Their
918 type is indicated by the quoted string anyway. */
919 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
920 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
921 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
923 fprintf_filtered (stream, "(");
924 type_print (type, "", stream, -1);
925 fprintf_filtered (stream, ") ");
928 else if (ada_is_array_descriptor_type (type))
930 fprintf_filtered (stream, "(");
931 type_print (type, "", stream, -1);
932 fprintf_filtered (stream, ") ");
934 else if (ada_is_bogus_array_descriptor (type))
936 fprintf_filtered (stream, "(");
937 type_print (type, "", stream, -1);
938 fprintf_filtered (stream, ") (...?)");
942 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
943 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == 0
944 && TYPE_CODE (TYPE_INDEX_TYPE (type)) == TYPE_CODE_RANGE)
946 /* This is an array of zero-length elements, that is an array
947 of null records. This array needs to be printed by hand,
948 as the standard routine to print arrays relies on the size of
949 the array elements to be nonzero. This is because it computes
950 the number of elements in the array by dividing the array size
951 by the array element size. */
952 fprintf_filtered (stream, "(%d .. %d => ())",
953 TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
954 TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type)));
958 return (val_print (type, value_contents (val), 0, address,
959 stream, format, 1, 0, pretty));
963 print_record (struct type *type, const gdb_byte *valaddr,
964 struct ui_file *stream, int format, int recurse,
965 enum val_prettyprint pretty)
967 type = ada_check_typedef (type);
969 fprintf_filtered (stream, "(");
971 if (print_field_values (type, valaddr, stream, format, recurse, pretty,
972 0, type, valaddr) != 0 && pretty)
974 fprintf_filtered (stream, "\n");
975 print_spaces_filtered (2 * recurse, stream);
978 fprintf_filtered (stream, ")");
981 /* Print out fields of value at VALADDR having structure type TYPE.
983 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
984 same meanings as in ada_print_value and ada_val_print.
986 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
987 (used to get discriminant values when printing variant parts).
989 COMMA_NEEDED is 1 if fields have been printed at the current recursion
990 level, so that a comma is needed before any field printed by this
993 Returns 1 if COMMA_NEEDED or any fields were printed. */
996 print_field_values (struct type *type, const gdb_byte *valaddr,
997 struct ui_file *stream, int format, int recurse,
998 enum val_prettyprint pretty, int comma_needed,
999 struct type *outer_type, const gdb_byte *outer_valaddr)
1003 len = TYPE_NFIELDS (type);
1005 for (i = 0; i < len; i += 1)
1007 if (ada_is_ignored_field (type, i))
1010 if (ada_is_wrapper_field (type, i))
1013 print_field_values (TYPE_FIELD_TYPE (type, i),
1015 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1016 stream, format, recurse, pretty,
1017 comma_needed, type, valaddr);
1020 else if (ada_is_variant_part (type, i))
1023 print_variant_part (type, i, valaddr,
1024 stream, format, recurse, pretty, comma_needed,
1025 outer_type, outer_valaddr);
1030 fprintf_filtered (stream, ", ");
1035 fprintf_filtered (stream, "\n");
1036 print_spaces_filtered (2 + 2 * recurse, stream);
1040 wrap_here (n_spaces (2 + 2 * recurse));
1044 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1045 fputs_filtered ("\"( ptr \"", stream);
1047 fputs_filtered ("\"( nodef \"", stream);
1048 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1049 language_cplus, DMGL_NO_OPTS);
1050 fputs_filtered ("\" \"", stream);
1051 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1052 language_cplus, DMGL_NO_OPTS);
1053 fputs_filtered ("\") \"", stream);
1057 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1058 fprintf_filtered (stream, "%.*s",
1059 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1060 TYPE_FIELD_NAME (type, i));
1061 annotate_field_name_end ();
1062 fputs_filtered (" => ", stream);
1063 annotate_field_value ();
1066 if (TYPE_FIELD_PACKED (type, i))
1070 /* Bitfields require special handling, especially due to byte
1072 if (TYPE_CPLUS_SPECIFIC (type) != NULL
1073 && TYPE_FIELD_IGNORE (type, i))
1075 fputs_filtered (_("<optimized out or zero length>"), stream);
1079 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1080 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1082 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1083 v = ada_value_primitive_packed_val (NULL, valaddr,
1084 bit_pos / HOST_CHAR_BIT,
1085 bit_pos % HOST_CHAR_BIT,
1087 TYPE_FIELD_TYPE (type, i));
1088 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1089 stream, format, 0, recurse + 1, pretty);
1093 ada_val_print (TYPE_FIELD_TYPE (type, i),
1094 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1095 0, 0, stream, format, 0, recurse + 1, pretty);
1096 annotate_field_end ();
1099 return comma_needed;