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:
125 index_type = builtin_type_int32;
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. */
381 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
386 type = ada_check_typedef (type);
388 switch (TYPE_CODE (type))
392 len = TYPE_NFIELDS (type);
393 for (i = 0; i < len; i++)
395 if (TYPE_FIELD_BITPOS (type, i) == val)
402 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
406 print_longest (stream, 'd', 0, val);
411 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
415 LA_PRINT_CHAR ((unsigned char) val, type, stream);
419 fprintf_filtered (stream, val ? "true" : "false");
422 case TYPE_CODE_RANGE:
423 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
426 case TYPE_CODE_UNDEF:
428 case TYPE_CODE_ARRAY:
429 case TYPE_CODE_STRUCT:
430 case TYPE_CODE_UNION:
435 case TYPE_CODE_STRING:
436 case TYPE_CODE_ERROR:
437 case TYPE_CODE_MEMBERPTR:
438 case TYPE_CODE_METHODPTR:
439 case TYPE_CODE_METHOD:
441 warning (_("internal error: unhandled type in ada_print_scalar"));
445 error (_("Invalid type code in symbol table."));
450 /* Print the character string STRING, printing at most LENGTH characters.
451 Printing stops early if the number hits print_max; repeat counts
452 are printed as appropriate. Print ellipses at the end if we
453 had to stop before printing LENGTH characters, or if
454 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
458 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
459 unsigned int length, int force_ellipses, int type_len,
460 const struct value_print_options *options)
463 unsigned int things_printed = 0;
469 fputs_filtered ("\"\"", stream);
473 for (i = 0; i < length && things_printed < options->print_max; i += 1)
475 /* Position of the character we are examining
476 to see whether it is repeated. */
478 /* Number of repetitions we have detected so far. */
485 fputs_filtered (", ", stream);
492 && char_at (string, rep1, type_len) == char_at (string, i,
499 if (reps > options->repeat_count_threshold)
503 if (options->inspect_it)
504 fputs_filtered ("\\\", ", stream);
506 fputs_filtered ("\", ", stream);
509 fputs_filtered ("'", stream);
510 ada_emit_char (char_at (string, i, type_len), elttype, stream, '\'',
512 fputs_filtered ("'", stream);
513 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
515 things_printed += options->repeat_count_threshold;
522 if (options->inspect_it)
523 fputs_filtered ("\\\"", stream);
525 fputs_filtered ("\"", stream);
528 ada_emit_char (char_at (string, i, type_len), elttype, stream, '"',
534 /* Terminate the quotes if necessary. */
537 if (options->inspect_it)
538 fputs_filtered ("\\\"", stream);
540 fputs_filtered ("\"", stream);
543 if (force_ellipses || i < length)
544 fputs_filtered ("...", stream);
548 ada_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
549 unsigned int length, int force_ellipses,
550 const struct value_print_options *options)
552 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
557 /* Print data of type TYPE located at VALADDR (within GDB), which came from
558 the inferior at address ADDRESS, onto stdio stream STREAM according to
559 OPTIONS. The data at VALADDR is in target byte order.
561 If the data is printed as a string, returns the number of string characters
564 RECURSE indicates the amount of indentation to supply before
565 continuation lines; this amount is roughly twice the value of RECURSE. */
568 ada_val_print (struct type *type, const gdb_byte *valaddr0,
569 int embedded_offset, CORE_ADDR address,
570 struct ui_file *stream, int recurse,
571 const struct value_print_options *options)
573 struct ada_val_print_args args;
575 args.valaddr0 = valaddr0;
576 args.embedded_offset = embedded_offset;
577 args.address = address;
578 args.stream = stream;
579 args.recurse = recurse;
580 args.options = options;
582 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
585 /* Helper for ada_val_print; used as argument to catch_errors to
586 unmarshal the arguments to ada_val_print_1, which does the work. */
588 ada_val_print_stub (void *args0)
590 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
591 return ada_val_print_1 (argsp->type, argsp->valaddr0,
592 argsp->embedded_offset, argsp->address,
593 argsp->stream, argsp->recurse, argsp->options);
596 /* Assuming TYPE is a simple array, print the value of this array located
597 at VALADDR. See ada_val_print for a description of the various
598 parameters of this function; they are identical. The semantics
599 of the return value is also identical to ada_val_print. */
602 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
603 CORE_ADDR address, struct ui_file *stream, int recurse,
604 const struct value_print_options *options)
606 struct type *elttype = TYPE_TARGET_TYPE (type);
614 eltlen = TYPE_LENGTH (elttype);
618 len = TYPE_LENGTH (type) / eltlen;
620 /* For an array of chars, print with string syntax. */
621 if (ada_is_string_type (type)
622 && (options->format == 0 || options->format == 's'))
624 if (options->prettyprint_arrays)
625 print_spaces_filtered (2 + 2 * recurse, stream);
627 /* If requested, look for the first null char and only print
628 elements up to it. */
629 if (options->stop_print_at_null)
633 /* Look for a NULL char. */
636 && temp_len < options->print_max
637 && char_at (valaddr, temp_len, eltlen) != 0);
642 printstr (stream, elttype, valaddr, len, 0, eltlen, options);
647 fprintf_filtered (stream, "(");
648 print_optional_low_bound (stream, type, options);
649 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
650 val_print_packed_array_elements (type, valaddr, 0, stream,
653 val_print_array_elements (type, valaddr, address, stream,
654 recurse, options, 0);
655 fprintf_filtered (stream, ")");
661 /* See the comment on ada_val_print. This function differs in that it
662 does not catch evaluation errors (leaving that to ada_val_print). */
665 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
666 int embedded_offset, CORE_ADDR address,
667 struct ui_file *stream, int recurse,
668 const struct value_print_options *options)
672 struct type *elttype;
675 const gdb_byte *valaddr = valaddr0 + embedded_offset;
677 type = ada_check_typedef (type);
679 if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
682 struct value *mark = value_mark ();
684 val = value_from_contents_and_address (type, valaddr, address);
685 val = ada_coerce_to_simple_array_ptr (val);
688 fprintf_filtered (stream, "(null)");
692 retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
693 VALUE_ADDRESS (val), stream, recurse, options);
694 value_free_to_mark (mark);
698 valaddr = ada_aligned_value_addr (type, valaddr);
699 embedded_offset -= valaddr - valaddr0 - embedded_offset;
700 type = printable_val_type (type, valaddr);
702 switch (TYPE_CODE (type))
705 return c_val_print (type, valaddr0, embedded_offset, address, stream,
710 int ret = c_val_print (type, valaddr0, embedded_offset, address,
711 stream, recurse, options);
712 if (ada_is_tag_type (type))
715 value_from_contents_and_address (type, valaddr, address);
716 const char *name = ada_tag_name (val);
718 fprintf_filtered (stream, " (%s)", name);
725 case TYPE_CODE_RANGE:
726 if (ada_is_fixed_point_type (type))
728 LONGEST v = unpack_long (type, valaddr);
729 int len = TYPE_LENGTH (type);
731 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
732 (double) ada_fixed_to_float (type, v));
735 else if (ada_is_vax_floating_type (type))
738 value_from_contents_and_address (type, valaddr, address);
739 struct value *func = ada_vax_float_print_function (type);
743 addr = value_as_address (call_function_by_hand (func, 1, &val));
744 val_print_string (builtin_type_true_char,
745 addr, -1, stream, options);
748 /* No special printing function. Do as best we can. */
750 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
752 struct type *target_type = TYPE_TARGET_TYPE (type);
753 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
755 /* Obscure case of range type that has different length from
756 its base type. Perform a conversion, or we will get a
757 nonsense value. Actually, we could use the same
758 code regardless of lengths; I'm just avoiding a cast. */
759 struct value *v = value_cast (target_type,
760 value_from_contents_and_address
762 return ada_val_print_1 (target_type, value_contents (v), 0, 0,
763 stream, recurse + 1, options);
766 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
767 valaddr0, embedded_offset,
768 address, stream, recurse, options);
772 int format = (options->format ? options->format
773 : options->output_format);
776 struct value_print_options opts = *options;
777 opts.format = format;
778 print_scalar_formatted (valaddr, type, &opts, 0, stream);
780 else if (ada_is_system_address_type (type)
781 && TYPE_OBJFILE (type) != NULL)
783 /* FIXME: We want to print System.Address variables using
784 the same format as for any access type. But for some
785 reason GNAT encodes the System.Address type as an int,
786 so we have to work-around this deficiency by handling
787 System.Address values as a special case.
789 We do this only for System.Address types defined in an
790 objfile. For the built-in version of System.Address we
791 have installed the proper type to begin with. */
793 struct gdbarch *gdbarch = get_objfile_arch (TYPE_OBJFILE (type));
794 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
796 fprintf_filtered (stream, "(");
797 type_print (type, "", stream, -1);
798 fprintf_filtered (stream, ") ");
799 fputs_filtered (paddress (extract_typed_address
800 (valaddr, ptr_type)),
805 val_print_type_code_int (type, valaddr, stream);
806 if (ada_is_character_type (type))
808 fputs_filtered (" ", stream);
809 ada_printchar ((unsigned char) unpack_long (type, valaddr),
819 print_scalar_formatted (valaddr, type, options, 0, stream);
822 len = TYPE_NFIELDS (type);
823 val = unpack_long (type, valaddr);
824 for (i = 0; i < len; i++)
827 if (val == TYPE_FIELD_BITPOS (type, i))
834 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
836 fprintf_filtered (stream, "%ld %s", (long) val, name);
838 fputs_filtered (name, stream);
842 print_longest (stream, 'd', 0, val);
846 case TYPE_CODE_FLAGS:
848 print_scalar_formatted (valaddr, type, options, 0, stream);
850 val_print_type_code_flags (type, valaddr, stream);
855 return c_val_print (type, valaddr0, embedded_offset, address, stream,
858 ada_print_floating (valaddr0 + embedded_offset, type, stream);
861 case TYPE_CODE_UNION:
862 case TYPE_CODE_STRUCT:
863 if (ada_is_bogus_array_descriptor (type))
865 fprintf_filtered (stream, "(...?)");
870 print_record (type, valaddr, stream, recurse, options);
874 case TYPE_CODE_ARRAY:
875 return ada_val_print_array (type, valaddr, address, stream,
879 /* For references, the debugger is expected to print the value as
880 an address if DEREF_REF is null. But printing an address in place
881 of the object value would be confusing to an Ada programmer.
882 So, for Ada values, we print the actual dereferenced value
884 elttype = check_typedef (TYPE_TARGET_TYPE (type));
886 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
888 LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
889 if (deref_val_int != 0)
891 struct value *deref_val =
892 ada_value_ind (value_from_longest
893 (lookup_pointer_type (elttype),
895 val_print (value_type (deref_val),
896 value_contents (deref_val), 0,
897 VALUE_ADDRESS (deref_val), stream, recurse + 1,
898 options, current_language);
901 fputs_filtered ("(null)", stream);
904 fputs_filtered ("???", stream);
913 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
914 struct ui_file *stream, int recurse,
915 const struct value_print_options *options, int comma_needed,
916 struct type *outer_type, const gdb_byte *outer_valaddr)
918 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
919 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
924 return print_field_values
925 (TYPE_FIELD_TYPE (var_type, which),
926 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
927 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
928 stream, recurse, options,
929 comma_needed, outer_type, outer_valaddr);
933 ada_value_print (struct value *val0, struct ui_file *stream,
934 const struct value_print_options *options)
936 const gdb_byte *valaddr = value_contents (val0);
937 CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
939 ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
941 value_from_contents_and_address (type, valaddr, address);
942 struct value_print_options opts;
944 /* If it is a pointer, indicate what it points to. */
945 if (TYPE_CODE (type) == TYPE_CODE_PTR)
947 /* Hack: don't print (char *) for char strings. Their
948 type is indicated by the quoted string anyway. */
949 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
950 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
951 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
953 fprintf_filtered (stream, "(");
954 type_print (type, "", stream, -1);
955 fprintf_filtered (stream, ") ");
958 else if (ada_is_array_descriptor_type (type))
960 fprintf_filtered (stream, "(");
961 type_print (type, "", stream, -1);
962 fprintf_filtered (stream, ") ");
964 else if (ada_is_bogus_array_descriptor (type))
966 fprintf_filtered (stream, "(");
967 type_print (type, "", stream, -1);
968 fprintf_filtered (stream, ") (...?)");
974 return (val_print (type, value_contents (val), 0, address,
975 stream, 0, &opts, current_language));
979 print_record (struct type *type, const gdb_byte *valaddr,
980 struct ui_file *stream, int recurse,
981 const struct value_print_options *options)
983 type = ada_check_typedef (type);
985 fprintf_filtered (stream, "(");
987 if (print_field_values (type, valaddr, stream, recurse, options,
988 0, type, valaddr) != 0 && options->pretty)
990 fprintf_filtered (stream, "\n");
991 print_spaces_filtered (2 * recurse, stream);
994 fprintf_filtered (stream, ")");
997 /* Print out fields of value at VALADDR having structure type TYPE.
999 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1000 same meanings as in ada_print_value and ada_val_print.
1002 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1003 (used to get discriminant values when printing variant parts).
1005 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1006 level, so that a comma is needed before any field printed by this
1009 Returns 1 if COMMA_NEEDED or any fields were printed. */
1012 print_field_values (struct type *type, const gdb_byte *valaddr,
1013 struct ui_file *stream, int recurse,
1014 const struct value_print_options *options,
1016 struct type *outer_type, const gdb_byte *outer_valaddr)
1020 len = TYPE_NFIELDS (type);
1022 for (i = 0; i < len; i += 1)
1024 if (ada_is_ignored_field (type, i))
1027 if (ada_is_wrapper_field (type, i))
1030 print_field_values (TYPE_FIELD_TYPE (type, i),
1032 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1033 stream, recurse, options,
1034 comma_needed, type, valaddr);
1037 else if (ada_is_variant_part (type, i))
1040 print_variant_part (type, i, valaddr,
1041 stream, recurse, options, comma_needed,
1042 outer_type, outer_valaddr);
1047 fprintf_filtered (stream, ", ");
1050 if (options->pretty)
1052 fprintf_filtered (stream, "\n");
1053 print_spaces_filtered (2 + 2 * recurse, stream);
1057 wrap_here (n_spaces (2 + 2 * recurse));
1059 if (options->inspect_it)
1061 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1062 fputs_filtered ("\"( ptr \"", stream);
1064 fputs_filtered ("\"( nodef \"", stream);
1065 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1066 language_cplus, DMGL_NO_OPTS);
1067 fputs_filtered ("\" \"", stream);
1068 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1069 language_cplus, DMGL_NO_OPTS);
1070 fputs_filtered ("\") \"", stream);
1074 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1075 fprintf_filtered (stream, "%.*s",
1076 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1077 TYPE_FIELD_NAME (type, i));
1078 annotate_field_name_end ();
1079 fputs_filtered (" => ", stream);
1080 annotate_field_value ();
1083 if (TYPE_FIELD_PACKED (type, i))
1087 /* Bitfields require special handling, especially due to byte
1089 if (TYPE_CPLUS_SPECIFIC (type) != NULL
1090 && TYPE_FIELD_IGNORE (type, i))
1092 fputs_filtered (_("<optimized out or zero length>"), stream);
1096 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1097 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1098 struct value_print_options opts;
1100 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1101 v = ada_value_primitive_packed_val (NULL, valaddr,
1102 bit_pos / HOST_CHAR_BIT,
1103 bit_pos % HOST_CHAR_BIT,
1105 TYPE_FIELD_TYPE (type, i));
1108 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1109 stream, recurse + 1, &opts, current_language);
1114 struct value_print_options opts = *options;
1116 ada_val_print (TYPE_FIELD_TYPE (type, i),
1117 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1118 0, 0, stream, recurse + 1, &opts);
1120 annotate_field_end ();
1123 return comma_needed;