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;
799 fprintf_filtered (stream, "(");
800 type_print (type, "", stream, -1);
801 fprintf_filtered (stream, ") ");
802 fputs_filtered (paddress (extract_typed_address
803 (valaddr, ptr_type)),
808 val_print_type_code_int (type, valaddr, stream);
809 if (ada_is_character_type (type))
811 fputs_filtered (" ", stream);
812 ada_printchar ((unsigned char) unpack_long (type, valaddr),
822 print_scalar_formatted (valaddr, type, options, 0, stream);
825 len = TYPE_NFIELDS (type);
826 val = unpack_long (type, valaddr);
827 for (i = 0; i < len; i++)
830 if (val == TYPE_FIELD_BITPOS (type, i))
837 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
839 fprintf_filtered (stream, "%ld %s", (long) val, name);
841 fputs_filtered (name, stream);
845 print_longest (stream, 'd', 0, val);
849 case TYPE_CODE_FLAGS:
851 print_scalar_formatted (valaddr, type, options, 0, stream);
853 val_print_type_code_flags (type, valaddr, stream);
858 return c_val_print (type, valaddr0, embedded_offset, address, stream,
861 ada_print_floating (valaddr0 + embedded_offset, type, stream);
864 case TYPE_CODE_UNION:
865 case TYPE_CODE_STRUCT:
866 if (ada_is_bogus_array_descriptor (type))
868 fprintf_filtered (stream, "(...?)");
873 print_record (type, valaddr, stream, recurse, options);
877 case TYPE_CODE_ARRAY:
878 return ada_val_print_array (type, valaddr, address, stream,
882 /* For references, the debugger is expected to print the value as
883 an address if DEREF_REF is null. But printing an address in place
884 of the object value would be confusing to an Ada programmer.
885 So, for Ada values, we print the actual dereferenced value
887 elttype = check_typedef (TYPE_TARGET_TYPE (type));
889 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
891 LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
892 if (deref_val_int != 0)
894 struct value *deref_val =
895 ada_value_ind (value_from_longest
896 (lookup_pointer_type (elttype),
898 val_print (value_type (deref_val),
899 value_contents (deref_val), 0,
900 value_address (deref_val), stream, recurse + 1,
901 options, current_language);
904 fputs_filtered ("(null)", stream);
907 fputs_filtered ("???", stream);
916 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
917 struct ui_file *stream, int recurse,
918 const struct value_print_options *options, int comma_needed,
919 struct type *outer_type, const gdb_byte *outer_valaddr)
921 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
922 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
927 return print_field_values
928 (TYPE_FIELD_TYPE (var_type, which),
929 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
930 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
931 stream, recurse, options,
932 comma_needed, outer_type, outer_valaddr);
936 ada_value_print (struct value *val0, struct ui_file *stream,
937 const struct value_print_options *options)
939 const gdb_byte *valaddr = value_contents (val0);
940 CORE_ADDR address = value_address (val0);
942 ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
944 value_from_contents_and_address (type, valaddr, address);
945 struct value_print_options opts;
947 /* If it is a pointer, indicate what it points to. */
948 if (TYPE_CODE (type) == TYPE_CODE_PTR)
950 /* Hack: don't print (char *) for char strings. Their
951 type is indicated by the quoted string anyway. */
952 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
953 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
954 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
956 fprintf_filtered (stream, "(");
957 type_print (type, "", stream, -1);
958 fprintf_filtered (stream, ") ");
961 else if (ada_is_array_descriptor_type (type))
963 fprintf_filtered (stream, "(");
964 type_print (type, "", stream, -1);
965 fprintf_filtered (stream, ") ");
967 else if (ada_is_bogus_array_descriptor (type))
969 fprintf_filtered (stream, "(");
970 type_print (type, "", stream, -1);
971 fprintf_filtered (stream, ") (...?)");
977 return (val_print (type, value_contents (val), 0, address,
978 stream, 0, &opts, current_language));
982 print_record (struct type *type, const gdb_byte *valaddr,
983 struct ui_file *stream, int recurse,
984 const struct value_print_options *options)
986 type = ada_check_typedef (type);
988 fprintf_filtered (stream, "(");
990 if (print_field_values (type, valaddr, stream, recurse, options,
991 0, type, valaddr) != 0 && options->pretty)
993 fprintf_filtered (stream, "\n");
994 print_spaces_filtered (2 * recurse, stream);
997 fprintf_filtered (stream, ")");
1000 /* Print out fields of value at VALADDR having structure type TYPE.
1002 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1003 same meanings as in ada_print_value and ada_val_print.
1005 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1006 (used to get discriminant values when printing variant parts).
1008 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1009 level, so that a comma is needed before any field printed by this
1012 Returns 1 if COMMA_NEEDED or any fields were printed. */
1015 print_field_values (struct type *type, const gdb_byte *valaddr,
1016 struct ui_file *stream, int recurse,
1017 const struct value_print_options *options,
1019 struct type *outer_type, const gdb_byte *outer_valaddr)
1023 len = TYPE_NFIELDS (type);
1025 for (i = 0; i < len; i += 1)
1027 if (ada_is_ignored_field (type, i))
1030 if (ada_is_wrapper_field (type, i))
1033 print_field_values (TYPE_FIELD_TYPE (type, i),
1035 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1036 stream, recurse, options,
1037 comma_needed, type, valaddr);
1040 else if (ada_is_variant_part (type, i))
1043 print_variant_part (type, i, valaddr,
1044 stream, recurse, options, comma_needed,
1045 outer_type, outer_valaddr);
1050 fprintf_filtered (stream, ", ");
1053 if (options->pretty)
1055 fprintf_filtered (stream, "\n");
1056 print_spaces_filtered (2 + 2 * recurse, stream);
1060 wrap_here (n_spaces (2 + 2 * recurse));
1062 if (options->inspect_it)
1064 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1065 fputs_filtered ("\"( ptr \"", stream);
1067 fputs_filtered ("\"( nodef \"", stream);
1068 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1069 language_cplus, DMGL_NO_OPTS);
1070 fputs_filtered ("\" \"", stream);
1071 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1072 language_cplus, DMGL_NO_OPTS);
1073 fputs_filtered ("\") \"", stream);
1077 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1078 fprintf_filtered (stream, "%.*s",
1079 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1080 TYPE_FIELD_NAME (type, i));
1081 annotate_field_name_end ();
1082 fputs_filtered (" => ", stream);
1083 annotate_field_value ();
1086 if (TYPE_FIELD_PACKED (type, i))
1090 /* Bitfields require special handling, especially due to byte
1092 if (TYPE_CPLUS_SPECIFIC (type) != NULL
1093 && TYPE_FIELD_IGNORE (type, i))
1095 fputs_filtered (_("<optimized out or zero length>"), stream);
1099 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1100 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1101 struct value_print_options opts;
1103 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1104 v = ada_value_primitive_packed_val (NULL, valaddr,
1105 bit_pos / HOST_CHAR_BIT,
1106 bit_pos % HOST_CHAR_BIT,
1108 TYPE_FIELD_TYPE (type, i));
1111 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1112 stream, recurse + 1, &opts, current_language);
1117 struct value_print_options opts = *options;
1119 ada_val_print (TYPE_FIELD_TYPE (type, i),
1120 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1121 0, 0, stream, recurse + 1, &opts);
1123 annotate_field_end ();
1126 return comma_needed;