1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_string.h"
25 #include "expression.h"
34 #include "exceptions.h"
37 static void print_record (struct type *, const gdb_byte *, int,
41 const struct value_print_options *);
43 static int print_field_values (struct type *, const gdb_byte *,
45 struct ui_file *, int,
47 const struct value_print_options *,
48 int, struct type *, int);
50 static void adjust_type_signedness (struct type *);
52 static void ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
53 struct ui_file *, int,
55 const struct value_print_options *);
58 /* Make TYPE unsigned if its range of values includes no negatives. */
60 adjust_type_signedness (struct type *type)
62 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
63 && TYPE_LOW_BOUND (type) >= 0)
64 TYPE_UNSIGNED (type) = 1;
67 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
68 if non-standard (i.e., other than 1 for numbers, other than lower bound
69 of index type for enumerated type). Returns 1 if something printed,
73 print_optional_low_bound (struct ui_file *stream, struct type *type,
74 const struct value_print_options *options)
76 struct type *index_type;
80 if (options->print_array_indexes)
83 if (!get_array_bounds (type, &low_bound, &high_bound))
86 /* If this is an empty array, then don't print the lower bound.
87 That would be confusing, because we would print the lower bound,
88 followed by... nothing! */
89 if (low_bound > high_bound)
92 index_type = TYPE_INDEX_TYPE (type);
94 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
96 /* We need to know what the base type is, in order to do the
97 appropriate check below. Otherwise, if this is a subrange
98 of an enumerated type, where the underlying value of the
99 first element is typically 0, we might test the low bound
100 against the wrong value. */
101 index_type = TYPE_TARGET_TYPE (index_type);
104 switch (TYPE_CODE (index_type))
111 if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0))
114 case TYPE_CODE_UNDEF:
123 ada_print_scalar (index_type, low_bound, stream);
124 fprintf_filtered (stream, " => ");
128 /* Version of val_print_array_elements for GNAT-style packed arrays.
129 Prints elements of packed array of type TYPE at bit offset
130 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
131 separates with commas. RECURSE is the recursion (nesting) level.
132 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
135 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
137 int bitoffset, struct ui_file *stream,
139 const struct value *val,
140 const struct value_print_options *options)
143 unsigned int things_printed = 0;
145 struct type *elttype, *index_type;
147 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
148 struct value *mark = value_mark ();
151 elttype = TYPE_TARGET_TYPE (type);
152 eltlen = TYPE_LENGTH (check_typedef (elttype));
153 index_type = TYPE_INDEX_TYPE (type);
158 if (get_discrete_bounds (index_type, &low, &high) < 0)
161 len = high - low + 1;
165 annotate_array_section_begin (i, elttype);
167 while (i < len && things_printed < options->print_max)
169 struct value *v0, *v1;
174 if (options->prettyprint_arrays)
176 fprintf_filtered (stream, ",\n");
177 print_spaces_filtered (2 + 2 * recurse, stream);
181 fprintf_filtered (stream, ", ");
184 wrap_here (n_spaces (2 + 2 * recurse));
185 maybe_print_array_index (index_type, i + low, stream, options);
188 v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
189 (i0 * bitsize) / HOST_CHAR_BIT,
190 (i0 * bitsize) % HOST_CHAR_BIT,
197 v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
198 (i * bitsize) / HOST_CHAR_BIT,
199 (i * bitsize) % HOST_CHAR_BIT,
201 if (!value_available_contents_eq (v0, value_embedded_offset (v0),
202 v1, value_embedded_offset (v1),
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_ENUMVAL (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 fputs_filtered ("\", ", stream);
515 fputs_filtered ("'", stream);
516 ada_emit_char (char_at (string, i, type_len, byte_order),
517 elttype, stream, '\'', type_len);
518 fputs_filtered ("'", stream);
519 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
521 things_printed += options->repeat_count_threshold;
528 fputs_filtered ("\"", stream);
531 ada_emit_char (char_at (string, i, type_len, byte_order),
532 elttype, stream, '"', type_len);
537 /* Terminate the quotes if necessary. */
539 fputs_filtered ("\"", stream);
541 if (force_ellipses || i < length)
542 fputs_filtered ("...", stream);
546 ada_printstr (struct ui_file *stream, struct type *type,
547 const gdb_byte *string, unsigned int length,
548 const char *encoding, int force_ellipses,
549 const struct value_print_options *options)
551 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
556 /* See val_print for a description of the various parameters of this
557 function; they are identical. */
560 ada_val_print (struct type *type, const gdb_byte *valaddr,
561 int embedded_offset, CORE_ADDR address,
562 struct ui_file *stream, int recurse,
563 const struct value *val,
564 const struct value_print_options *options)
566 volatile struct gdb_exception except;
568 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
569 TRY_CATCH (except, RETURN_MASK_ALL)
571 ada_val_print_1 (type, valaddr, embedded_offset, address,
572 stream, recurse, val, options);
576 /* Assuming TYPE is a simple array, print the value of this array located
577 at VALADDR + OFFSET. See ada_val_print for a description of the various
578 parameters of this function; they are identical. */
581 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
582 int offset, CORE_ADDR address,
583 struct ui_file *stream, int recurse,
584 const struct value *val,
585 const struct value_print_options *options)
587 /* For an array of chars, print with string syntax. */
588 if (ada_is_string_type (type)
589 && (options->format == 0 || options->format == 's'))
591 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
592 struct type *elttype = TYPE_TARGET_TYPE (type);
596 /* We know that ELTTYPE cannot possibly be null, because we found
597 that TYPE is a string-like type. Similarly, the size of ELTTYPE
598 should also be non-null, since it's a character-like type. */
599 gdb_assert (elttype != NULL);
600 gdb_assert (TYPE_LENGTH (elttype) != 0);
602 eltlen = TYPE_LENGTH (elttype);
603 len = TYPE_LENGTH (type) / eltlen;
605 if (options->prettyprint_arrays)
606 print_spaces_filtered (2 + 2 * recurse, stream);
608 /* If requested, look for the first null char and only print
609 elements up to it. */
610 if (options->stop_print_at_null)
614 /* Look for a NULL char. */
617 && temp_len < options->print_max
618 && char_at (valaddr + offset,
619 temp_len, eltlen, byte_order) != 0);
624 printstr (stream, elttype, valaddr + offset, len, 0, eltlen, options);
628 fprintf_filtered (stream, "(");
629 print_optional_low_bound (stream, type, options);
630 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
631 val_print_packed_array_elements (type, valaddr, offset,
632 0, stream, recurse, val, options);
634 val_print_array_elements (type, valaddr, offset, address,
635 stream, recurse, val, options, 0);
636 fprintf_filtered (stream, ")");
640 /* See the comment on ada_val_print. This function differs in that it
641 does not catch evaluation errors (leaving that to ada_val_print). */
644 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
645 int offset, CORE_ADDR address,
646 struct ui_file *stream, int recurse,
647 const struct value *original_value,
648 const struct value_print_options *options)
651 struct type *elttype;
654 type = ada_check_typedef (type);
656 if (ada_is_array_descriptor_type (type)
657 || (ada_is_constrained_packed_array_type (type)
658 && TYPE_CODE (type) != TYPE_CODE_PTR))
660 struct value *mark = value_mark ();
663 val = value_from_contents_and_address (type, valaddr + offset, address);
664 /* If this is a reference, coerce it now. This helps taking care
665 of the case where ADDRESS is meaningless because original_value
667 val = coerce_ref (val);
668 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
669 val = ada_coerce_to_simple_array_ptr (val);
671 val = ada_coerce_to_simple_array (val);
674 gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
675 fprintf_filtered (stream, "0x0");
678 ada_val_print_1 (value_type (val),
679 value_contents_for_printing (val),
680 value_embedded_offset (val),
681 value_address (val), stream, recurse,
683 value_free_to_mark (mark);
687 offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
688 type = printable_val_type (type, valaddr + offset_aligned);
690 switch (TYPE_CODE (type))
693 c_val_print (type, valaddr, offset, address, stream,
694 recurse, original_value, options);
699 c_val_print (type, valaddr, offset, address,
700 stream, recurse, original_value, options);
702 if (ada_is_tag_type (type))
705 value_from_contents_and_address (type,
706 valaddr + offset_aligned,
707 address + offset_aligned);
708 const char *name = ada_tag_name (val);
711 fprintf_filtered (stream, " (%s)", name);
717 case TYPE_CODE_RANGE:
718 if (ada_is_fixed_point_type (type))
720 LONGEST v = unpack_long (type, valaddr + offset_aligned);
722 fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
723 (double) ada_fixed_to_float (type, v));
726 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
728 struct type *target_type = TYPE_TARGET_TYPE (type);
730 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
732 /* Obscure case of range type that has different length from
733 its base type. Perform a conversion, or we will get a
734 nonsense value. Actually, we could use the same
735 code regardless of lengths; I'm just avoiding a cast. */
737 = value_from_contents_and_address (type, valaddr + offset, 0);
738 struct value *v = value_cast (target_type, v1);
740 ada_val_print_1 (target_type,
741 value_contents_for_printing (v),
742 value_embedded_offset (v), 0,
743 stream, recurse + 1, v, options);
746 ada_val_print_1 (TYPE_TARGET_TYPE (type),
748 address, stream, recurse,
749 original_value, options);
754 int format = (options->format ? options->format
755 : options->output_format);
759 struct value_print_options opts = *options;
761 opts.format = format;
762 val_print_scalar_formatted (type, valaddr, offset_aligned,
763 original_value, &opts, 0, stream);
765 else if (ada_is_system_address_type (type))
767 /* FIXME: We want to print System.Address variables using
768 the same format as for any access type. But for some
769 reason GNAT encodes the System.Address type as an int,
770 so we have to work-around this deficiency by handling
771 System.Address values as a special case. */
773 struct gdbarch *gdbarch = get_type_arch (type);
774 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
775 CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
778 fprintf_filtered (stream, "(");
779 type_print (type, "", stream, -1);
780 fprintf_filtered (stream, ") ");
781 fputs_filtered (paddress (gdbarch, addr), stream);
785 val_print_type_code_int (type, valaddr + offset_aligned, stream);
786 if (ada_is_character_type (type))
790 fputs_filtered (" ", stream);
791 c = unpack_long (type, valaddr + offset_aligned);
792 ada_printchar (c, type, stream);
805 val_print_scalar_formatted (type, valaddr, offset_aligned,
806 original_value, options, 0, stream);
809 len = TYPE_NFIELDS (type);
810 val = unpack_long (type, valaddr + offset_aligned);
811 for (i = 0; i < len; i++)
814 if (val == TYPE_FIELD_ENUMVAL (type, i))
821 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
824 fprintf_filtered (stream, "%ld %s", (long) val, name);
826 fputs_filtered (name, stream);
830 print_longest (stream, 'd', 0, val);
838 c_val_print (type, valaddr, offset, address, stream,
839 recurse, original_value, options);
843 ada_print_floating (valaddr + offset, type, stream);
846 case TYPE_CODE_UNION:
847 case TYPE_CODE_STRUCT:
848 if (ada_is_bogus_array_descriptor (type))
850 fprintf_filtered (stream, "(...?)");
855 print_record (type, valaddr, offset_aligned,
856 stream, recurse, original_value, options);
860 case TYPE_CODE_ARRAY:
861 ada_val_print_array (type, valaddr, offset_aligned,
862 address, stream, recurse, original_value,
867 /* For references, the debugger is expected to print the value as
868 an address if DEREF_REF is null. But printing an address in place
869 of the object value would be confusing to an Ada programmer.
870 So, for Ada values, we print the actual dereferenced value
872 elttype = check_typedef (TYPE_TARGET_TYPE (type));
874 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
876 CORE_ADDR deref_val_int;
877 struct value *deref_val;
879 deref_val = coerce_ref_if_computed (original_value);
882 if (ada_is_tagged_type (value_type (deref_val), 1))
883 deref_val = ada_tag_value_at_base_address (deref_val);
885 common_val_print (deref_val, stream, recurse + 1, options,
890 deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
891 if (deref_val_int != 0)
894 ada_value_ind (value_from_pointer
895 (lookup_pointer_type (elttype),
898 if (ada_is_tagged_type (value_type (deref_val), 1))
899 deref_val = ada_tag_value_at_base_address (deref_val);
901 val_print (value_type (deref_val),
902 value_contents_for_printing (deref_val),
903 value_embedded_offset (deref_val),
904 value_address (deref_val), stream, recurse + 1,
905 deref_val, options, current_language);
908 fputs_filtered ("(null)", stream);
911 fputs_filtered ("???", stream);
919 print_variant_part (struct type *type, int field_num,
920 const gdb_byte *valaddr, int offset,
921 struct ui_file *stream, int recurse,
922 const struct value *val,
923 const struct value_print_options *options,
925 struct type *outer_type, int outer_offset)
927 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
928 int which = ada_which_variant_applies (var_type, outer_type,
929 valaddr + outer_offset);
934 return print_field_values
935 (TYPE_FIELD_TYPE (var_type, which),
937 offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
938 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
939 stream, recurse, val, options,
940 comma_needed, outer_type, outer_offset);
944 ada_value_print (struct value *val0, struct ui_file *stream,
945 const struct value_print_options *options)
947 struct value *val = ada_to_fixed_value (val0);
948 CORE_ADDR address = value_address (val);
949 struct type *type = ada_check_typedef (value_type (val));
950 struct value_print_options opts;
952 /* If it is a pointer, indicate what it points to. */
953 if (TYPE_CODE (type) == TYPE_CODE_PTR)
955 /* Hack: don't print (char *) for char strings. Their
956 type is indicated by the quoted string anyway. */
957 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
958 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
959 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
961 fprintf_filtered (stream, "(");
962 type_print (type, "", stream, -1);
963 fprintf_filtered (stream, ") ");
966 else if (ada_is_array_descriptor_type (type))
968 /* We do not print the type description unless TYPE is an array
969 access type (this is encoded by the compiler as a typedef to
970 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
971 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
973 fprintf_filtered (stream, "(");
974 type_print (type, "", stream, -1);
975 fprintf_filtered (stream, ") ");
978 else if (ada_is_bogus_array_descriptor (type))
980 fprintf_filtered (stream, "(");
981 type_print (type, "", stream, -1);
982 fprintf_filtered (stream, ") (...?)");
988 val_print (type, value_contents_for_printing (val),
989 value_embedded_offset (val), address,
990 stream, 0, val, &opts, current_language);
994 print_record (struct type *type, const gdb_byte *valaddr,
996 struct ui_file *stream, int recurse,
997 const struct value *val,
998 const struct value_print_options *options)
1000 type = ada_check_typedef (type);
1002 fprintf_filtered (stream, "(");
1004 if (print_field_values (type, valaddr, offset,
1005 stream, recurse, val, options,
1006 0, type, offset) != 0 && options->pretty)
1008 fprintf_filtered (stream, "\n");
1009 print_spaces_filtered (2 * recurse, stream);
1012 fprintf_filtered (stream, ")");
1015 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
1017 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
1018 meanings as in ada_print_value and ada_val_print.
1020 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
1021 record (used to get discriminant values when printing variant
1024 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1025 level, so that a comma is needed before any field printed by this
1028 Returns 1 if COMMA_NEEDED or any fields were printed. */
1031 print_field_values (struct type *type, const gdb_byte *valaddr,
1032 int offset, struct ui_file *stream, int recurse,
1033 const struct value *val,
1034 const struct value_print_options *options,
1036 struct type *outer_type, int outer_offset)
1040 len = TYPE_NFIELDS (type);
1042 for (i = 0; i < len; i += 1)
1044 if (ada_is_ignored_field (type, i))
1047 if (ada_is_wrapper_field (type, i))
1050 print_field_values (TYPE_FIELD_TYPE (type, i),
1053 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1054 stream, recurse, val, options,
1055 comma_needed, type, offset);
1058 else if (ada_is_variant_part (type, i))
1061 print_variant_part (type, i, valaddr,
1062 offset, stream, recurse, val,
1063 options, comma_needed,
1064 outer_type, outer_offset);
1069 fprintf_filtered (stream, ", ");
1072 if (options->pretty)
1074 fprintf_filtered (stream, "\n");
1075 print_spaces_filtered (2 + 2 * recurse, stream);
1079 wrap_here (n_spaces (2 + 2 * recurse));
1082 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1083 fprintf_filtered (stream, "%.*s",
1084 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1085 TYPE_FIELD_NAME (type, i));
1086 annotate_field_name_end ();
1087 fputs_filtered (" => ", stream);
1088 annotate_field_value ();
1090 if (TYPE_FIELD_PACKED (type, i))
1094 /* Bitfields require special handling, especially due to byte
1096 if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
1098 fputs_filtered (_("<optimized out or zero length>"), stream);
1102 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1103 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1104 struct value_print_options opts;
1106 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1107 v = ada_value_primitive_packed_val
1109 offset + bit_pos / HOST_CHAR_BIT,
1110 bit_pos % HOST_CHAR_BIT,
1111 bit_size, TYPE_FIELD_TYPE (type, i));
1114 val_print (TYPE_FIELD_TYPE (type, i),
1115 value_contents_for_printing (v),
1116 value_embedded_offset (v), 0,
1117 stream, recurse + 1, v,
1118 &opts, current_language);
1123 struct value_print_options opts = *options;
1126 ada_val_print (TYPE_FIELD_TYPE (type, i),
1129 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1130 0, stream, recurse + 1, val, &opts);
1132 annotate_field_end ();
1135 return comma_needed;