1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
27 #include "expression.h"
36 #include "exceptions.h"
39 static void print_record (struct type *, const gdb_byte *, int,
43 const struct value_print_options *);
45 static int print_field_values (struct type *, const gdb_byte *,
47 struct ui_file *, int,
49 const struct value_print_options *,
50 int, struct type *, int);
52 static void adjust_type_signedness (struct type *);
54 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
55 struct ui_file *, int,
57 const struct value_print_options *);
60 /* Make TYPE unsigned if its range of values includes no negatives. */
62 adjust_type_signedness (struct type *type)
64 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
65 && TYPE_LOW_BOUND (type) >= 0)
66 TYPE_UNSIGNED (type) = 1;
69 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
70 if non-standard (i.e., other than 1 for numbers, other than lower bound
71 of index type for enumerated type). Returns 1 if something printed,
75 print_optional_low_bound (struct ui_file *stream, struct type *type,
76 const struct value_print_options *options)
78 struct type *index_type;
82 if (options->print_array_indexes)
85 if (!get_array_bounds (type, &low_bound, &high_bound))
88 /* If this is an empty array, then don't print the lower bound.
89 That would be confusing, because we would print the lower bound,
90 followed by... nothing! */
91 if (low_bound > high_bound)
94 index_type = TYPE_INDEX_TYPE (type);
96 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
98 /* We need to know what the base type is, in order to do the
99 appropriate check below. Otherwise, if this is a subrange
100 of an enumerated type, where the underlying value of the
101 first element is typically 0, we might test the low bound
102 against the wrong value. */
103 index_type = TYPE_TARGET_TYPE (index_type);
106 switch (TYPE_CODE (index_type))
113 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
116 case TYPE_CODE_UNDEF:
125 ada_print_scalar (index_type, low_bound, stream);
126 fprintf_filtered (stream, " => ");
130 /* Version of val_print_array_elements for GNAT-style packed arrays.
131 Prints elements of packed array of type TYPE at bit offset
132 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
133 separates with commas. RECURSE is the recursion (nesting) level.
134 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
137 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
139 int bitoffset, struct ui_file *stream,
141 const struct value *val,
142 const struct value_print_options *options)
145 unsigned int things_printed = 0;
147 struct type *elttype, *index_type;
149 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
150 struct value *mark = value_mark ();
153 elttype = TYPE_TARGET_TYPE (type);
154 eltlen = TYPE_LENGTH (check_typedef (elttype));
155 index_type = TYPE_INDEX_TYPE (type);
160 if (get_discrete_bounds (index_type, &low, &high) < 0)
163 len = high - low + 1;
167 annotate_array_section_begin (i, elttype);
169 while (i < len && things_printed < options->print_max)
171 struct value *v0, *v1;
176 if (options->prettyprint_arrays)
178 fprintf_filtered (stream, ",\n");
179 print_spaces_filtered (2 + 2 * recurse, stream);
183 fprintf_filtered (stream, ", ");
186 wrap_here (n_spaces (2 + 2 * recurse));
187 maybe_print_array_index (index_type, i + low, stream, options);
190 v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
191 (i0 * bitsize) / HOST_CHAR_BIT,
192 (i0 * bitsize) % HOST_CHAR_BIT,
199 v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
200 (i * bitsize) / HOST_CHAR_BIT,
201 (i * bitsize) % HOST_CHAR_BIT,
203 if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
207 if (i - i0 > options->repeat_count_threshold)
209 struct value_print_options opts = *options;
212 val_print (elttype, value_contents_for_printing (v0),
213 value_embedded_offset (v0), 0, stream,
214 recurse + 1, v0, &opts, current_language);
215 annotate_elt_rep (i - i0);
216 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
217 annotate_elt_rep_end ();
223 struct value_print_options opts = *options;
226 for (j = i0; j < i; j += 1)
230 if (options->prettyprint_arrays)
232 fprintf_filtered (stream, ",\n");
233 print_spaces_filtered (2 + 2 * recurse, stream);
237 fprintf_filtered (stream, ", ");
239 wrap_here (n_spaces (2 + 2 * recurse));
240 maybe_print_array_index (index_type, j + low,
243 val_print (elttype, value_contents_for_printing (v0),
244 value_embedded_offset (v0), 0, stream,
245 recurse + 1, v0, &opts, current_language);
249 things_printed += i - i0;
251 annotate_array_section_end ();
254 fprintf_filtered (stream, "...");
257 value_free_to_mark (mark);
261 printable_val_type (struct type *type, const gdb_byte *valaddr)
263 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
266 /* Print the character C on STREAM as part of the contents of a literal
267 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
271 ada_emit_char (int c, struct type *type, struct ui_file *stream,
272 int quoter, int type_len)
274 /* If this character fits in the normal ASCII range, and is
275 a printable character, then print the character as if it was
276 an ASCII character, even if this is a wide character.
277 The UCHAR_MAX check is necessary because the isascii function
278 requires that its argument have a value of an unsigned char,
279 or EOF (EOF is obviously not printable). */
280 if (c <= UCHAR_MAX && isascii (c) && isprint (c))
282 if (c == quoter && c == '"')
283 fprintf_filtered (stream, "\"\"");
285 fprintf_filtered (stream, "%c", c);
288 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
291 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
295 char_at (const gdb_byte *string, int i, int type_len,
296 enum bfd_endian byte_order)
301 return (int) extract_unsigned_integer (string + type_len * i,
302 type_len, byte_order);
305 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
307 ui_memcpy (void *dest, const char *buffer, long len)
309 memcpy (dest, buffer, (size_t) len);
310 ((char *) dest)[len] = '\0';
313 /* Print a floating-point value of type TYPE, pointed to in GDB by
314 VALADDR, on STREAM. Use Ada formatting conventions: there must be
315 a decimal point, and at least one digit before and after the
316 point. We use GNAT format for NaNs and infinities. */
318 ada_print_floating (const gdb_byte *valaddr, struct type *type,
319 struct ui_file *stream)
324 struct ui_file *tmp_stream = mem_fileopen ();
325 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
327 print_floating (valaddr, type, tmp_stream);
328 ui_file_put (tmp_stream, ui_memcpy, buffer);
329 do_cleanups (cleanups);
332 len = strlen (result);
334 /* Modify for Ada rules. */
336 s = strstr (result, "inf");
338 s = strstr (result, "Inf");
340 s = strstr (result, "INF");
346 s = strstr (result, "nan");
348 s = strstr (result, "NaN");
350 s = strstr (result, "Nan");
354 if (result[0] == '-')
359 if (s == NULL && strchr (result, '.') == NULL)
361 s = strchr (result, 'e');
363 fprintf_filtered (stream, "%s.0", result);
365 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
368 fprintf_filtered (stream, "%s", result);
372 ada_printchar (int c, struct type *type, struct ui_file *stream)
374 fputs_filtered ("'", stream);
375 ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
376 fputs_filtered ("'", stream);
379 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
380 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
381 like a default signed integer. */
384 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
391 print_longest (stream, 'd', 0, val);
395 type = ada_check_typedef (type);
397 switch (TYPE_CODE (type))
401 len = TYPE_NFIELDS (type);
402 for (i = 0; i < len; i++)
404 if (TYPE_FIELD_BITPOS (type, i) == val)
411 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
415 print_longest (stream, 'd', 0, val);
420 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
424 LA_PRINT_CHAR (val, type, stream);
428 fprintf_filtered (stream, val ? "true" : "false");
431 case TYPE_CODE_RANGE:
432 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
435 case TYPE_CODE_UNDEF:
437 case TYPE_CODE_ARRAY:
438 case TYPE_CODE_STRUCT:
439 case TYPE_CODE_UNION:
444 case TYPE_CODE_STRING:
445 case TYPE_CODE_ERROR:
446 case TYPE_CODE_MEMBERPTR:
447 case TYPE_CODE_METHODPTR:
448 case TYPE_CODE_METHOD:
450 warning (_("internal error: unhandled type in ada_print_scalar"));
454 error (_("Invalid type code in symbol table."));
459 /* Print the character string STRING, printing at most LENGTH characters.
460 Printing stops early if the number hits print_max; repeat counts
461 are printed as appropriate. Print ellipses at the end if we
462 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
463 TYPE_LEN is the length (1 or 2) of the character type. */
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)
470 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
472 unsigned int things_printed = 0;
478 fputs_filtered ("\"\"", stream);
482 for (i = 0; i < length && things_printed < options->print_max; i += 1)
484 /* Position of the character we are examining
485 to see whether it is repeated. */
487 /* Number of repetitions we have detected so far. */
494 fputs_filtered (", ", stream);
501 && char_at (string, rep1, type_len, byte_order)
502 == char_at (string, i, type_len, byte_order))
508 if (reps > options->repeat_count_threshold)
512 if (options->inspect_it)
513 fputs_filtered ("\\\", ", stream);
515 fputs_filtered ("\", ", stream);
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);
524 things_printed += options->repeat_count_threshold;
531 if (options->inspect_it)
532 fputs_filtered ("\\\"", stream);
534 fputs_filtered ("\"", stream);
537 ada_emit_char (char_at (string, i, type_len, byte_order),
538 elttype, stream, '"', type_len);
543 /* Terminate the quotes if necessary. */
546 if (options->inspect_it)
547 fputs_filtered ("\\\"", stream);
549 fputs_filtered ("\"", stream);
552 if (force_ellipses || i < length)
553 fputs_filtered ("...", stream);
557 ada_printstr (struct ui_file *stream, struct type *type,
558 const gdb_byte *string, unsigned int length,
559 const char *encoding, int force_ellipses,
560 const struct value_print_options *options)
562 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
567 /* See val_print for a description of the various parameters of this
568 function; they are identical. The semantics of the return value is
569 also identical to val_print. */
572 ada_val_print (struct type *type, const gdb_byte *valaddr,
573 int embedded_offset, CORE_ADDR address,
574 struct ui_file *stream, int recurse,
575 const struct value *val,
576 const struct value_print_options *options)
578 volatile struct gdb_exception except;
581 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
582 TRY_CATCH (except, RETURN_MASK_ALL)
584 result = ada_val_print_1 (type, valaddr, embedded_offset, address,
585 stream, recurse, val, options);
588 if (except.reason < 0)
594 /* Assuming TYPE is a simple array, print the value of this array located
595 at VALADDR + OFFSET. See ada_val_print for a description of the various
596 parameters of this function; they are identical. The semantics
597 of the return value is also identical to ada_val_print. */
600 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
601 int offset, CORE_ADDR address,
602 struct ui_file *stream, int recurse,
603 const struct value *val,
604 const struct value_print_options *options)
606 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
607 struct type *elttype = TYPE_TARGET_TYPE (type);
610 /* For an array of chars, print with string syntax. */
611 if (ada_is_string_type (type)
612 && (options->format == 0 || options->format == 's'))
620 eltlen = TYPE_LENGTH (elttype);
624 len = TYPE_LENGTH (type) / eltlen;
626 if (options->prettyprint_arrays)
627 print_spaces_filtered (2 + 2 * recurse, stream);
629 /* If requested, look for the first null char and only print
630 elements up to it. */
631 if (options->stop_print_at_null)
635 /* Look for a NULL char. */
638 && temp_len < options->print_max
639 && char_at (valaddr + offset,
640 temp_len, eltlen, byte_order) != 0);
645 printstr (stream, elttype, valaddr + offset, len, 0, eltlen, options);
650 fprintf_filtered (stream, "(");
651 print_optional_low_bound (stream, type, options);
652 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
653 val_print_packed_array_elements (type, valaddr, offset,
654 0, stream, recurse, val, options);
656 val_print_array_elements (type, valaddr, offset, address,
657 stream, recurse, val, options, 0);
658 fprintf_filtered (stream, ")");
664 /* See the comment on ada_val_print. This function differs in that it
665 does not catch evaluation errors (leaving that to ada_val_print). */
668 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
669 int offset, CORE_ADDR address,
670 struct ui_file *stream, int recurse,
671 const struct value *original_value,
672 const struct value_print_options *options)
676 struct type *elttype;
680 type = ada_check_typedef (type);
682 if (ada_is_array_descriptor_type (type)
683 || ada_is_constrained_packed_array_type (type))
686 struct value *mark = value_mark ();
689 val = value_from_contents_and_address (type, valaddr + offset, address);
690 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
691 val = ada_coerce_to_simple_array_ptr (val);
693 val = ada_coerce_to_simple_array (val);
696 gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
697 fprintf_filtered (stream, "0x0");
701 retn = ada_val_print_1 (value_type (val),
702 value_contents_for_printing (val),
703 value_embedded_offset (val),
704 value_address (val), stream, recurse,
706 value_free_to_mark (mark);
710 offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
711 type = printable_val_type (type, valaddr + offset_aligned);
713 switch (TYPE_CODE (type))
716 return c_val_print (type, valaddr, offset, address, stream,
717 recurse, original_value, options);
721 int ret = c_val_print (type, valaddr, offset, address,
722 stream, recurse, original_value, options);
724 if (ada_is_tag_type (type))
727 value_from_contents_and_address (type,
728 valaddr + offset_aligned,
729 address + offset_aligned);
730 const char *name = ada_tag_name (val);
733 fprintf_filtered (stream, " (%s)", name);
740 case TYPE_CODE_RANGE:
741 if (ada_is_fixed_point_type (type))
743 LONGEST v = unpack_long (type, valaddr + offset_aligned);
744 int len = TYPE_LENGTH (type);
746 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
747 (double) ada_fixed_to_float (type, v));
750 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
752 struct type *target_type = TYPE_TARGET_TYPE (type);
754 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
756 /* Obscure case of range type that has different length from
757 its base type. Perform a conversion, or we will get a
758 nonsense value. Actually, we could use the same
759 code regardless of lengths; I'm just avoiding a cast. */
761 = value_from_contents_and_address (type, valaddr + offset, 0);
762 struct value *v = value_cast (target_type, v1);
764 return ada_val_print_1 (target_type,
765 value_contents_for_printing (v),
766 value_embedded_offset (v), 0,
767 stream, recurse + 1, v, options);
770 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
772 address, stream, recurse,
773 original_value, options);
777 int format = (options->format ? options->format
778 : options->output_format);
782 struct value_print_options opts = *options;
784 opts.format = format;
785 val_print_scalar_formatted (type, valaddr, offset_aligned,
786 original_value, &opts, 0, stream);
788 else if (ada_is_system_address_type (type))
790 /* FIXME: We want to print System.Address variables using
791 the same format as for any access type. But for some
792 reason GNAT encodes the System.Address type as an int,
793 so we have to work-around this deficiency by handling
794 System.Address values as a special case. */
796 struct gdbarch *gdbarch = get_type_arch (type);
797 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
798 CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
801 fprintf_filtered (stream, "(");
802 type_print (type, "", stream, -1);
803 fprintf_filtered (stream, ") ");
804 fputs_filtered (paddress (gdbarch, addr), stream);
808 val_print_type_code_int (type, valaddr + offset_aligned, stream);
809 if (ada_is_character_type (type))
813 fputs_filtered (" ", stream);
814 c = unpack_long (type, valaddr + offset_aligned);
815 ada_printchar (c, type, stream);
824 val_print_scalar_formatted (type, valaddr, offset_aligned,
825 original_value, options, 0, stream);
828 len = TYPE_NFIELDS (type);
829 val = unpack_long (type, valaddr + offset_aligned);
830 for (i = 0; i < len; i++)
833 if (val == TYPE_FIELD_BITPOS (type, i))
840 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
843 fprintf_filtered (stream, "%ld %s", (long) val, name);
845 fputs_filtered (name, stream);
849 print_longest (stream, 'd', 0, val);
853 case TYPE_CODE_FLAGS:
855 val_print_scalar_formatted (type, valaddr, offset_aligned,
856 original_value, options, 0, stream);
858 val_print_type_code_flags (type, valaddr + offset_aligned, stream);
863 return c_val_print (type, valaddr, offset, address, stream,
864 recurse, original_value, options);
866 ada_print_floating (valaddr + offset, type, stream);
869 case TYPE_CODE_UNION:
870 case TYPE_CODE_STRUCT:
871 if (ada_is_bogus_array_descriptor (type))
873 fprintf_filtered (stream, "(...?)");
878 print_record (type, valaddr, offset_aligned,
879 stream, recurse, original_value, options);
883 case TYPE_CODE_ARRAY:
884 return ada_val_print_array (type, valaddr, offset_aligned,
885 address, stream, recurse, original_value,
889 /* For references, the debugger is expected to print the value as
890 an address if DEREF_REF is null. But printing an address in place
891 of the object value would be confusing to an Ada programmer.
892 So, for Ada values, we print the actual dereferenced value
894 elttype = check_typedef (TYPE_TARGET_TYPE (type));
896 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
898 CORE_ADDR deref_val_int
899 = unpack_pointer (type, valaddr + offset_aligned);
901 if (deref_val_int != 0)
903 struct value *deref_val =
904 ada_value_ind (value_from_pointer
905 (lookup_pointer_type (elttype),
908 val_print (value_type (deref_val),
909 value_contents_for_printing (deref_val),
910 value_embedded_offset (deref_val),
911 value_address (deref_val), stream, recurse + 1,
912 deref_val, options, current_language);
915 fputs_filtered ("(null)", stream);
918 fputs_filtered ("???", stream);
927 print_variant_part (struct type *type, int field_num,
928 const gdb_byte *valaddr, int offset,
929 struct ui_file *stream, int recurse,
930 const struct value *val,
931 const struct value_print_options *options,
933 struct type *outer_type, int outer_offset)
935 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
936 int which = ada_which_variant_applies (var_type, outer_type,
937 valaddr + outer_offset);
942 return print_field_values
943 (TYPE_FIELD_TYPE (var_type, which),
945 offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
946 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
947 stream, recurse, val, options,
948 comma_needed, outer_type, outer_offset);
952 ada_value_print (struct value *val0, struct ui_file *stream,
953 const struct value_print_options *options)
955 struct value *val = ada_to_fixed_value (val0);
956 CORE_ADDR address = value_address (val);
957 struct type *type = value_type (val);
958 struct value_print_options opts;
960 /* If it is a pointer, indicate what it points to. */
961 if (TYPE_CODE (type) == TYPE_CODE_PTR)
963 /* Hack: don't print (char *) for char strings. Their
964 type is indicated by the quoted string anyway. */
965 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
966 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
967 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
969 fprintf_filtered (stream, "(");
970 type_print (type, "", stream, -1);
971 fprintf_filtered (stream, ") ");
974 else if (ada_is_array_descriptor_type (type))
976 /* We do not print the type description unless TYPE is an array
977 access type (this is encoded by the compiler as a typedef to
978 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
979 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
981 fprintf_filtered (stream, "(");
982 type_print (type, "", stream, -1);
983 fprintf_filtered (stream, ") ");
986 else if (ada_is_bogus_array_descriptor (type))
988 fprintf_filtered (stream, "(");
989 type_print (type, "", stream, -1);
990 fprintf_filtered (stream, ") (...?)");
996 return (val_print (type, value_contents_for_printing (val),
997 value_embedded_offset (val), address,
998 stream, 0, val, &opts, current_language));
1002 print_record (struct type *type, const gdb_byte *valaddr,
1004 struct ui_file *stream, int recurse,
1005 const struct value *val,
1006 const struct value_print_options *options)
1008 type = ada_check_typedef (type);
1010 fprintf_filtered (stream, "(");
1012 if (print_field_values (type, valaddr, offset,
1013 stream, recurse, val, options,
1014 0, type, offset) != 0 && options->pretty)
1016 fprintf_filtered (stream, "\n");
1017 print_spaces_filtered (2 * recurse, stream);
1020 fprintf_filtered (stream, ")");
1023 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
1025 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
1026 meanings as in ada_print_value and ada_val_print.
1028 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
1029 record (used to get discriminant values when printing variant
1032 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1033 level, so that a comma is needed before any field printed by this
1036 Returns 1 if COMMA_NEEDED or any fields were printed. */
1039 print_field_values (struct type *type, const gdb_byte *valaddr,
1040 int offset, struct ui_file *stream, int recurse,
1041 const struct value *val,
1042 const struct value_print_options *options,
1044 struct type *outer_type, int outer_offset)
1048 len = TYPE_NFIELDS (type);
1050 for (i = 0; i < len; i += 1)
1052 if (ada_is_ignored_field (type, i))
1055 if (ada_is_wrapper_field (type, i))
1058 print_field_values (TYPE_FIELD_TYPE (type, i),
1061 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1062 stream, recurse, val, options,
1063 comma_needed, type, offset);
1066 else if (ada_is_variant_part (type, i))
1069 print_variant_part (type, i, valaddr,
1070 offset, stream, recurse, val,
1071 options, comma_needed,
1072 outer_type, outer_offset);
1077 fprintf_filtered (stream, ", ");
1080 if (options->pretty)
1082 fprintf_filtered (stream, "\n");
1083 print_spaces_filtered (2 + 2 * recurse, stream);
1087 wrap_here (n_spaces (2 + 2 * recurse));
1089 if (options->inspect_it)
1091 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1092 fputs_filtered ("\"( ptr \"", stream);
1094 fputs_filtered ("\"( nodef \"", stream);
1095 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1096 language_cplus, DMGL_NO_OPTS);
1097 fputs_filtered ("\" \"", stream);
1098 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1099 language_cplus, DMGL_NO_OPTS);
1100 fputs_filtered ("\") \"", stream);
1104 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1105 fprintf_filtered (stream, "%.*s",
1106 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1107 TYPE_FIELD_NAME (type, i));
1108 annotate_field_name_end ();
1109 fputs_filtered (" => ", stream);
1110 annotate_field_value ();
1113 if (TYPE_FIELD_PACKED (type, i))
1117 /* Bitfields require special handling, especially due to byte
1119 if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
1121 fputs_filtered (_("<optimized out or zero length>"), stream);
1125 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1126 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1127 struct value_print_options opts;
1129 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1130 v = ada_value_primitive_packed_val
1132 offset + bit_pos / HOST_CHAR_BIT,
1133 bit_pos % HOST_CHAR_BIT,
1134 bit_size, TYPE_FIELD_TYPE (type, i));
1137 val_print (TYPE_FIELD_TYPE (type, i),
1138 value_contents_for_printing (v),
1139 value_embedded_offset (v), 0,
1140 stream, recurse + 1, v,
1141 &opts, current_language);
1146 struct value_print_options opts = *options;
1149 ada_val_print (TYPE_FIELD_TYPE (type, i),
1152 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1153 0, stream, recurse + 1, val, &opts);
1155 annotate_field_end ();
1158 return comma_needed;