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 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 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 /* Encapsulates arguments to ada_val_print. */
39 struct ada_val_print_args
42 const gdb_byte *valaddr0;
45 struct ui_file *stream;
47 const struct value_print_options *options;
50 static void print_record (struct type *, const gdb_byte *, struct ui_file *,
51 int, const struct value_print_options *);
53 static int print_field_values (struct type *, const gdb_byte *,
54 struct ui_file *, int,
55 const struct value_print_options *,
59 static void adjust_type_signedness (struct type *);
61 static int ada_val_print_stub (void *args0);
63 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
64 struct ui_file *, int,
65 const struct value_print_options *);
68 /* Make TYPE unsigned if its range of values includes no negatives. */
70 adjust_type_signedness (struct type *type)
72 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
73 && TYPE_LOW_BOUND (type) >= 0)
74 TYPE_UNSIGNED (type) = 1;
77 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
78 if non-standard (i.e., other than 1 for numbers, other than lower bound
79 of index type for enumerated type). Returns 1 if something printed,
83 print_optional_low_bound (struct ui_file *stream, struct type *type,
84 const struct value_print_options *options)
86 struct type *index_type;
90 if (options->print_array_indexes)
93 if (!get_array_bounds (type, &low_bound, &high_bound))
96 /* If this is an empty array, then don't print the lower bound.
97 That would be confusing, because we would print the lower bound,
98 followed by... nothing! */
99 if (low_bound > high_bound)
102 index_type = TYPE_INDEX_TYPE (type);
104 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
106 /* We need to know what the base type is, in order to do the
107 appropriate check below. Otherwise, if this is a subrange
108 of an enumerated type, where the underlying value of the
109 first element is typically 0, we might test the low bound
110 against the wrong value. */
111 index_type = TYPE_TARGET_TYPE (index_type);
114 switch (TYPE_CODE (index_type))
121 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
124 case TYPE_CODE_UNDEF:
133 ada_print_scalar (index_type, (LONGEST) low_bound, stream);
134 fprintf_filtered (stream, " => ");
138 /* Version of val_print_array_elements for GNAT-style packed arrays.
139 Prints elements of packed array of type TYPE at bit offset
140 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
141 separates with commas. RECURSE is the recursion (nesting) level.
142 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
145 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
146 int bitoffset, struct ui_file *stream,
148 const struct value_print_options *options)
151 unsigned int things_printed = 0;
153 struct type *elttype, *index_type;
155 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
156 struct value *mark = value_mark ();
159 elttype = TYPE_TARGET_TYPE (type);
160 eltlen = TYPE_LENGTH (check_typedef (elttype));
161 index_type = TYPE_INDEX_TYPE (type);
165 if (get_discrete_bounds (index_type, &low, &high) < 0)
168 len = high - low + 1;
172 annotate_array_section_begin (i, elttype);
174 while (i < len && things_printed < options->print_max)
176 struct value *v0, *v1;
181 if (options->prettyprint_arrays)
183 fprintf_filtered (stream, ",\n");
184 print_spaces_filtered (2 + 2 * recurse, stream);
188 fprintf_filtered (stream, ", ");
191 wrap_here (n_spaces (2 + 2 * recurse));
192 maybe_print_array_index (index_type, i + low, stream, options);
195 v0 = ada_value_primitive_packed_val (NULL, valaddr,
196 (i0 * bitsize) / HOST_CHAR_BIT,
197 (i0 * bitsize) % HOST_CHAR_BIT,
204 v1 = ada_value_primitive_packed_val (NULL, valaddr,
205 (i * bitsize) / HOST_CHAR_BIT,
206 (i * bitsize) % HOST_CHAR_BIT,
208 if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
212 if (i - i0 > options->repeat_count_threshold)
214 struct value_print_options opts = *options;
216 val_print (elttype, value_contents (v0), 0, 0, stream,
217 recurse + 1, &opts, current_language);
218 annotate_elt_rep (i - i0);
219 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
220 annotate_elt_rep_end ();
226 struct value_print_options opts = *options;
228 for (j = i0; j < i; j += 1)
232 if (options->prettyprint_arrays)
234 fprintf_filtered (stream, ",\n");
235 print_spaces_filtered (2 + 2 * recurse, stream);
239 fprintf_filtered (stream, ", ");
241 wrap_here (n_spaces (2 + 2 * recurse));
242 maybe_print_array_index (index_type, j + low,
245 val_print (elttype, value_contents (v0), 0, 0, stream,
246 recurse + 1, &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
269 (1 or 2) of the character. */
272 ada_emit_char (int c, struct type *type, struct ui_file *stream,
273 int quoter, int type_len)
278 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
280 if (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 (1
292 or 2) of a character. */
295 char_at (const gdb_byte *string, int i, int type_len)
300 return (int) extract_unsigned_integer (string + 2 * i, 2);
303 /* Wrapper around memcpy to make it legal argument to ui_file_put */
305 ui_memcpy (void *dest, const char *buffer, long len)
307 memcpy (dest, buffer, (size_t) len);
308 ((char *) dest)[len] = '\0';
311 /* Print a floating-point value of type TYPE, pointed to in GDB by
312 VALADDR, on STREAM. Use Ada formatting conventions: there must be
313 a decimal point, and at least one digit before and after the
314 point. We use GNAT format for NaNs and infinities. */
316 ada_print_floating (const gdb_byte *valaddr, struct type *type,
317 struct ui_file *stream)
322 struct ui_file *tmp_stream = mem_fileopen ();
323 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
325 print_floating (valaddr, type, tmp_stream);
326 ui_file_put (tmp_stream, ui_memcpy, buffer);
327 do_cleanups (cleanups);
330 len = strlen (result);
332 /* Modify for Ada rules. */
334 s = strstr (result, "inf");
336 s = strstr (result, "Inf");
338 s = strstr (result, "INF");
344 s = strstr (result, "nan");
346 s = strstr (result, "NaN");
348 s = strstr (result, "Nan");
352 if (result[0] == '-')
357 if (s == NULL && strchr (result, '.') == NULL)
359 s = strchr (result, 'e');
361 fprintf_filtered (stream, "%s.0", result);
363 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
366 fprintf_filtered (stream, "%s", result);
370 ada_printchar (int c, struct type *type, struct ui_file *stream)
372 fputs_filtered ("'", stream);
373 ada_emit_char (c, type, stream, '\'', 1);
374 fputs_filtered ("'", stream);
377 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
378 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
379 like a default signed integer. */
382 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
389 print_longest (stream, 'd', 0, val);
393 type = ada_check_typedef (type);
395 switch (TYPE_CODE (type))
399 len = TYPE_NFIELDS (type);
400 for (i = 0; i < len; i++)
402 if (TYPE_FIELD_BITPOS (type, i) == val)
409 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
413 print_longest (stream, 'd', 0, val);
418 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
422 LA_PRINT_CHAR ((unsigned char) val, type, stream);
426 fprintf_filtered (stream, val ? "true" : "false");
429 case TYPE_CODE_RANGE:
430 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
433 case TYPE_CODE_UNDEF:
435 case TYPE_CODE_ARRAY:
436 case TYPE_CODE_STRUCT:
437 case TYPE_CODE_UNION:
442 case TYPE_CODE_STRING:
443 case TYPE_CODE_ERROR:
444 case TYPE_CODE_MEMBERPTR:
445 case TYPE_CODE_METHODPTR:
446 case TYPE_CODE_METHOD:
448 warning (_("internal error: unhandled type in ada_print_scalar"));
452 error (_("Invalid type code in symbol table."));
457 /* Print the character string STRING, printing at most LENGTH characters.
458 Printing stops early if the number hits print_max; repeat counts
459 are printed as appropriate. Print ellipses at the end if we
460 had to stop before printing LENGTH characters, or if
461 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
465 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
466 unsigned int length, int force_ellipses, int type_len,
467 const struct value_print_options *options)
470 unsigned int things_printed = 0;
476 fputs_filtered ("\"\"", stream);
480 for (i = 0; i < length && things_printed < options->print_max; i += 1)
482 /* Position of the character we are examining
483 to see whether it is repeated. */
485 /* Number of repetitions we have detected so far. */
492 fputs_filtered (", ", stream);
499 && char_at (string, rep1, type_len) == char_at (string, i,
506 if (reps > options->repeat_count_threshold)
510 if (options->inspect_it)
511 fputs_filtered ("\\\", ", stream);
513 fputs_filtered ("\", ", stream);
516 fputs_filtered ("'", stream);
517 ada_emit_char (char_at (string, i, type_len), elttype, stream, '\'',
519 fputs_filtered ("'", stream);
520 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
522 things_printed += options->repeat_count_threshold;
529 if (options->inspect_it)
530 fputs_filtered ("\\\"", stream);
532 fputs_filtered ("\"", stream);
535 ada_emit_char (char_at (string, i, type_len), elttype, stream, '"',
541 /* Terminate the quotes if necessary. */
544 if (options->inspect_it)
545 fputs_filtered ("\\\"", stream);
547 fputs_filtered ("\"", stream);
550 if (force_ellipses || i < length)
551 fputs_filtered ("...", stream);
555 ada_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
556 unsigned int length, int force_ellipses,
557 const struct value_print_options *options)
559 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
564 /* Print data of type TYPE located at VALADDR (within GDB), which came from
565 the inferior at address ADDRESS, onto stdio stream STREAM according to
566 OPTIONS. The data at VALADDR is in target byte order.
568 If the data is printed as a string, returns the number of string characters
571 RECURSE indicates the amount of indentation to supply before
572 continuation lines; this amount is roughly twice the value of RECURSE. */
575 ada_val_print (struct type *type, const gdb_byte *valaddr0,
576 int embedded_offset, CORE_ADDR address,
577 struct ui_file *stream, int recurse,
578 const struct value_print_options *options)
580 struct ada_val_print_args args;
582 args.valaddr0 = valaddr0;
583 args.embedded_offset = embedded_offset;
584 args.address = address;
585 args.stream = stream;
586 args.recurse = recurse;
587 args.options = options;
589 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
592 /* Helper for ada_val_print; used as argument to catch_errors to
593 unmarshal the arguments to ada_val_print_1, which does the work. */
595 ada_val_print_stub (void *args0)
597 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
598 return ada_val_print_1 (argsp->type, argsp->valaddr0,
599 argsp->embedded_offset, argsp->address,
600 argsp->stream, argsp->recurse, argsp->options);
603 /* Assuming TYPE is a simple array, print the value of this array located
604 at VALADDR. See ada_val_print for a description of the various
605 parameters of this function; they are identical. The semantics
606 of the return value is also identical to ada_val_print. */
609 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
610 CORE_ADDR address, struct ui_file *stream, int recurse,
611 const struct value_print_options *options)
613 struct type *elttype = TYPE_TARGET_TYPE (type);
621 eltlen = TYPE_LENGTH (elttype);
625 len = TYPE_LENGTH (type) / eltlen;
627 /* For an array of chars, print with string syntax. */
628 if (ada_is_string_type (type)
629 && (options->format == 0 || options->format == 's'))
631 if (options->prettyprint_arrays)
632 print_spaces_filtered (2 + 2 * recurse, stream);
634 /* If requested, look for the first null char and only print
635 elements up to it. */
636 if (options->stop_print_at_null)
640 /* Look for a NULL char. */
643 && temp_len < options->print_max
644 && char_at (valaddr, temp_len, eltlen) != 0);
649 printstr (stream, elttype, valaddr, len, 0, eltlen, options);
654 fprintf_filtered (stream, "(");
655 print_optional_low_bound (stream, type, options);
656 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
657 val_print_packed_array_elements (type, valaddr, 0, stream,
660 val_print_array_elements (type, valaddr, address, stream,
661 recurse, options, 0);
662 fprintf_filtered (stream, ")");
668 /* See the comment on ada_val_print. This function differs in that it
669 does not catch evaluation errors (leaving that to ada_val_print). */
672 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
673 int embedded_offset, CORE_ADDR address,
674 struct ui_file *stream, int recurse,
675 const struct value_print_options *options)
679 struct type *elttype;
682 const gdb_byte *valaddr = valaddr0 + embedded_offset;
684 type = ada_check_typedef (type);
686 if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
689 struct value *mark = value_mark ();
691 val = value_from_contents_and_address (type, valaddr, address);
692 val = ada_coerce_to_simple_array_ptr (val);
695 fprintf_filtered (stream, "(null)");
699 retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
700 value_address (val), stream, recurse, options);
701 value_free_to_mark (mark);
705 valaddr = ada_aligned_value_addr (type, valaddr);
706 embedded_offset -= valaddr - valaddr0 - embedded_offset;
707 type = printable_val_type (type, valaddr);
709 switch (TYPE_CODE (type))
712 return c_val_print (type, valaddr0, embedded_offset, address, stream,
717 int ret = c_val_print (type, valaddr0, embedded_offset, address,
718 stream, recurse, options);
719 if (ada_is_tag_type (type))
722 value_from_contents_and_address (type, valaddr, address);
723 const char *name = ada_tag_name (val);
725 fprintf_filtered (stream, " (%s)", name);
732 case TYPE_CODE_RANGE:
733 if (ada_is_fixed_point_type (type))
735 LONGEST v = unpack_long (type, valaddr);
736 int len = TYPE_LENGTH (type);
738 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
739 (double) ada_fixed_to_float (type, v));
742 else if (ada_is_vax_floating_type (type))
745 value_from_contents_and_address (type, valaddr, address);
746 struct value *func = ada_vax_float_print_function (type);
749 struct gdbarch *gdbarch = get_type_arch (type);
751 addr = value_as_address (call_function_by_hand (func, 1, &val));
752 val_print_string (builtin_type (gdbarch)->builtin_true_char,
753 addr, -1, stream, options);
756 /* No special printing function. Do as best we can. */
758 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
760 struct type *target_type = TYPE_TARGET_TYPE (type);
761 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
763 /* Obscure case of range type that has different length from
764 its base type. Perform a conversion, or we will get a
765 nonsense value. Actually, we could use the same
766 code regardless of lengths; I'm just avoiding a cast. */
767 struct value *v = value_cast (target_type,
768 value_from_contents_and_address
770 return ada_val_print_1 (target_type, value_contents (v), 0, 0,
771 stream, recurse + 1, options);
774 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
775 valaddr0, embedded_offset,
776 address, stream, recurse, options);
780 int format = (options->format ? options->format
781 : options->output_format);
784 struct value_print_options opts = *options;
785 opts.format = format;
786 print_scalar_formatted (valaddr, type, &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, ptr_type);
800 fprintf_filtered (stream, "(");
801 type_print (type, "", stream, -1);
802 fprintf_filtered (stream, ") ");
803 fputs_filtered (paddress (gdbarch, addr), stream);
807 val_print_type_code_int (type, valaddr, stream);
808 if (ada_is_character_type (type))
810 fputs_filtered (" ", stream);
811 ada_printchar ((unsigned char) unpack_long (type, valaddr),
821 print_scalar_formatted (valaddr, type, options, 0, stream);
824 len = TYPE_NFIELDS (type);
825 val = unpack_long (type, valaddr);
826 for (i = 0; i < len; i++)
829 if (val == TYPE_FIELD_BITPOS (type, i))
836 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
838 fprintf_filtered (stream, "%ld %s", (long) val, name);
840 fputs_filtered (name, stream);
844 print_longest (stream, 'd', 0, val);
848 case TYPE_CODE_FLAGS:
850 print_scalar_formatted (valaddr, type, options, 0, stream);
852 val_print_type_code_flags (type, valaddr, stream);
857 return c_val_print (type, valaddr0, embedded_offset, address, stream,
860 ada_print_floating (valaddr0 + embedded_offset, type, stream);
863 case TYPE_CODE_UNION:
864 case TYPE_CODE_STRUCT:
865 if (ada_is_bogus_array_descriptor (type))
867 fprintf_filtered (stream, "(...?)");
872 print_record (type, valaddr, stream, recurse, options);
876 case TYPE_CODE_ARRAY:
877 return ada_val_print_array (type, valaddr, address, stream,
881 /* For references, the debugger is expected to print the value as
882 an address if DEREF_REF is null. But printing an address in place
883 of the object value would be confusing to an Ada programmer.
884 So, for Ada values, we print the actual dereferenced value
886 elttype = check_typedef (TYPE_TARGET_TYPE (type));
888 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
890 LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
891 if (deref_val_int != 0)
893 struct value *deref_val =
894 ada_value_ind (value_from_longest
895 (lookup_pointer_type (elttype),
897 val_print (value_type (deref_val),
898 value_contents (deref_val), 0,
899 value_address (deref_val), stream, recurse + 1,
900 options, current_language);
903 fputs_filtered ("(null)", stream);
906 fputs_filtered ("???", stream);
915 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
916 struct ui_file *stream, int recurse,
917 const struct value_print_options *options, int comma_needed,
918 struct type *outer_type, const gdb_byte *outer_valaddr)
920 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
921 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
926 return print_field_values
927 (TYPE_FIELD_TYPE (var_type, which),
928 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
929 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
930 stream, recurse, options,
931 comma_needed, outer_type, outer_valaddr);
935 ada_value_print (struct value *val0, struct ui_file *stream,
936 const struct value_print_options *options)
938 const gdb_byte *valaddr = value_contents (val0);
939 CORE_ADDR address = value_address (val0);
941 ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
943 value_from_contents_and_address (type, valaddr, address);
944 struct value_print_options opts;
946 /* If it is a pointer, indicate what it points to. */
947 if (TYPE_CODE (type) == TYPE_CODE_PTR)
949 /* Hack: don't print (char *) for char strings. Their
950 type is indicated by the quoted string anyway. */
951 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
952 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
953 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
955 fprintf_filtered (stream, "(");
956 type_print (type, "", stream, -1);
957 fprintf_filtered (stream, ") ");
960 else if (ada_is_array_descriptor_type (type))
962 fprintf_filtered (stream, "(");
963 type_print (type, "", stream, -1);
964 fprintf_filtered (stream, ") ");
966 else if (ada_is_bogus_array_descriptor (type))
968 fprintf_filtered (stream, "(");
969 type_print (type, "", stream, -1);
970 fprintf_filtered (stream, ") (...?)");
976 return (val_print (type, value_contents (val), 0, address,
977 stream, 0, &opts, current_language));
981 print_record (struct type *type, const gdb_byte *valaddr,
982 struct ui_file *stream, int recurse,
983 const struct value_print_options *options)
985 type = ada_check_typedef (type);
987 fprintf_filtered (stream, "(");
989 if (print_field_values (type, valaddr, stream, recurse, options,
990 0, type, valaddr) != 0 && options->pretty)
992 fprintf_filtered (stream, "\n");
993 print_spaces_filtered (2 * recurse, stream);
996 fprintf_filtered (stream, ")");
999 /* Print out fields of value at VALADDR having structure type TYPE.
1001 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1002 same meanings as in ada_print_value and ada_val_print.
1004 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1005 (used to get discriminant values when printing variant parts).
1007 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1008 level, so that a comma is needed before any field printed by this
1011 Returns 1 if COMMA_NEEDED or any fields were printed. */
1014 print_field_values (struct type *type, const gdb_byte *valaddr,
1015 struct ui_file *stream, int recurse,
1016 const struct value_print_options *options,
1018 struct type *outer_type, const gdb_byte *outer_valaddr)
1022 len = TYPE_NFIELDS (type);
1024 for (i = 0; i < len; i += 1)
1026 if (ada_is_ignored_field (type, i))
1029 if (ada_is_wrapper_field (type, i))
1032 print_field_values (TYPE_FIELD_TYPE (type, i),
1034 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1035 stream, recurse, options,
1036 comma_needed, type, valaddr);
1039 else if (ada_is_variant_part (type, i))
1042 print_variant_part (type, i, valaddr,
1043 stream, recurse, options, comma_needed,
1044 outer_type, outer_valaddr);
1049 fprintf_filtered (stream, ", ");
1052 if (options->pretty)
1054 fprintf_filtered (stream, "\n");
1055 print_spaces_filtered (2 + 2 * recurse, stream);
1059 wrap_here (n_spaces (2 + 2 * recurse));
1061 if (options->inspect_it)
1063 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1064 fputs_filtered ("\"( ptr \"", stream);
1066 fputs_filtered ("\"( nodef \"", stream);
1067 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1068 language_cplus, DMGL_NO_OPTS);
1069 fputs_filtered ("\" \"", stream);
1070 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1071 language_cplus, DMGL_NO_OPTS);
1072 fputs_filtered ("\") \"", stream);
1076 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1077 fprintf_filtered (stream, "%.*s",
1078 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1079 TYPE_FIELD_NAME (type, i));
1080 annotate_field_name_end ();
1081 fputs_filtered (" => ", stream);
1082 annotate_field_value ();
1085 if (TYPE_FIELD_PACKED (type, i))
1089 /* Bitfields require special handling, especially due to byte
1091 if (TYPE_CPLUS_SPECIFIC (type) != NULL
1092 && TYPE_FIELD_IGNORE (type, i))
1094 fputs_filtered (_("<optimized out or zero length>"), stream);
1098 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1099 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1100 struct value_print_options opts;
1102 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1103 v = ada_value_primitive_packed_val (NULL, valaddr,
1104 bit_pos / HOST_CHAR_BIT,
1105 bit_pos % HOST_CHAR_BIT,
1107 TYPE_FIELD_TYPE (type, i));
1110 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1111 stream, recurse + 1, &opts, current_language);
1116 struct value_print_options opts = *options;
1118 ada_val_print (TYPE_FIELD_TYPE (type, i),
1119 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1120 0, 0, stream, recurse + 1, &opts);
1122 annotate_field_end ();
1125 return comma_needed;