1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-1989, 1991-1994, 1997, 2001-2012 Free
4 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 static void print_record (struct type *, const gdb_byte *, int,
42 const struct value_print_options *);
44 static int print_field_values (struct type *, const gdb_byte *,
46 struct ui_file *, int,
48 const struct value_print_options *,
49 int, struct type *, int);
51 static void adjust_type_signedness (struct type *);
53 static void ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
54 struct ui_file *, int,
56 const struct value_print_options *);
59 /* Make TYPE unsigned if its range of values includes no negatives. */
61 adjust_type_signedness (struct type *type)
63 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
64 && TYPE_LOW_BOUND (type) >= 0)
65 TYPE_UNSIGNED (type) = 1;
68 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
69 if non-standard (i.e., other than 1 for numbers, other than lower bound
70 of index type for enumerated type). Returns 1 if something printed,
74 print_optional_low_bound (struct ui_file *stream, struct type *type,
75 const struct value_print_options *options)
77 struct type *index_type;
81 if (options->print_array_indexes)
84 if (!get_array_bounds (type, &low_bound, &high_bound))
87 /* If this is an empty array, then don't print the lower bound.
88 That would be confusing, because we would print the lower bound,
89 followed by... nothing! */
90 if (low_bound > high_bound)
93 index_type = TYPE_INDEX_TYPE (type);
95 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
97 /* We need to know what the base type is, in order to do the
98 appropriate check below. Otherwise, if this is a subrange
99 of an enumerated type, where the underlying value of the
100 first element is typically 0, we might test the low bound
101 against the wrong value. */
102 index_type = TYPE_TARGET_TYPE (index_type);
105 switch (TYPE_CODE (index_type))
112 if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0))
115 case TYPE_CODE_UNDEF:
124 ada_print_scalar (index_type, low_bound, stream);
125 fprintf_filtered (stream, " => ");
129 /* Version of val_print_array_elements for GNAT-style packed arrays.
130 Prints elements of packed array of type TYPE at bit offset
131 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
132 separates with commas. RECURSE is the recursion (nesting) level.
133 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
136 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
138 int bitoffset, struct ui_file *stream,
140 const struct value *val,
141 const struct value_print_options *options)
144 unsigned int things_printed = 0;
146 struct type *elttype, *index_type;
148 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
149 struct value *mark = value_mark ();
152 elttype = TYPE_TARGET_TYPE (type);
153 eltlen = TYPE_LENGTH (check_typedef (elttype));
154 index_type = TYPE_INDEX_TYPE (type);
159 if (get_discrete_bounds (index_type, &low, &high) < 0)
162 len = high - low + 1;
166 annotate_array_section_begin (i, elttype);
168 while (i < len && things_printed < options->print_max)
170 struct value *v0, *v1;
175 if (options->prettyprint_arrays)
177 fprintf_filtered (stream, ",\n");
178 print_spaces_filtered (2 + 2 * recurse, stream);
182 fprintf_filtered (stream, ", ");
185 wrap_here (n_spaces (2 + 2 * recurse));
186 maybe_print_array_index (index_type, i + low, stream, options);
189 v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
190 (i0 * bitsize) / HOST_CHAR_BIT,
191 (i0 * bitsize) % HOST_CHAR_BIT,
198 v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
199 (i * bitsize) / HOST_CHAR_BIT,
200 (i * bitsize) % HOST_CHAR_BIT,
202 if (!value_available_contents_eq (v0, value_embedded_offset (v0),
203 v1, value_embedded_offset (v1),
208 if (i - i0 > options->repeat_count_threshold)
210 struct value_print_options opts = *options;
213 val_print (elttype, value_contents_for_printing (v0),
214 value_embedded_offset (v0), 0, stream,
215 recurse + 1, v0, &opts, current_language);
216 annotate_elt_rep (i - i0);
217 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
218 annotate_elt_rep_end ();
224 struct value_print_options opts = *options;
227 for (j = i0; j < i; j += 1)
231 if (options->prettyprint_arrays)
233 fprintf_filtered (stream, ",\n");
234 print_spaces_filtered (2 + 2 * recurse, stream);
238 fprintf_filtered (stream, ", ");
240 wrap_here (n_spaces (2 + 2 * recurse));
241 maybe_print_array_index (index_type, j + low,
244 val_print (elttype, value_contents_for_printing (v0),
245 value_embedded_offset (v0), 0, stream,
246 recurse + 1, v0, &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
272 ada_emit_char (int c, struct type *type, struct ui_file *stream,
273 int quoter, int type_len)
275 /* If this character fits in the normal ASCII range, and is
276 a printable character, then print the character as if it was
277 an ASCII character, even if this is a wide character.
278 The UCHAR_MAX check is necessary because the isascii function
279 requires that its argument have a value of an unsigned char,
280 or EOF (EOF is obviously not printable). */
281 if (c <= UCHAR_MAX && isascii (c) && isprint (c))
283 if (c == quoter && c == '"')
284 fprintf_filtered (stream, "\"\"");
286 fprintf_filtered (stream, "%c", c);
289 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
292 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
296 char_at (const gdb_byte *string, int i, int type_len,
297 enum bfd_endian byte_order)
302 return (int) extract_unsigned_integer (string + type_len * i,
303 type_len, byte_order);
306 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
308 ui_memcpy (void *dest, const char *buffer, long len)
310 memcpy (dest, buffer, (size_t) len);
311 ((char *) dest)[len] = '\0';
314 /* Print a floating-point value of type TYPE, pointed to in GDB by
315 VALADDR, on STREAM. Use Ada formatting conventions: there must be
316 a decimal point, and at least one digit before and after the
317 point. We use GNAT format for NaNs and infinities. */
319 ada_print_floating (const gdb_byte *valaddr, struct type *type,
320 struct ui_file *stream)
325 struct ui_file *tmp_stream = mem_fileopen ();
326 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
328 print_floating (valaddr, type, tmp_stream);
329 ui_file_put (tmp_stream, ui_memcpy, buffer);
330 do_cleanups (cleanups);
333 len = strlen (result);
335 /* Modify for Ada rules. */
337 s = strstr (result, "inf");
339 s = strstr (result, "Inf");
341 s = strstr (result, "INF");
347 s = strstr (result, "nan");
349 s = strstr (result, "NaN");
351 s = strstr (result, "Nan");
355 if (result[0] == '-')
360 if (s == NULL && strchr (result, '.') == NULL)
362 s = strchr (result, 'e');
364 fprintf_filtered (stream, "%s.0", result);
366 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
369 fprintf_filtered (stream, "%s", result);
373 ada_printchar (int c, struct type *type, struct ui_file *stream)
375 fputs_filtered ("'", stream);
376 ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
377 fputs_filtered ("'", stream);
380 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
381 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
382 like a default signed integer. */
385 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
392 print_longest (stream, 'd', 0, val);
396 type = ada_check_typedef (type);
398 switch (TYPE_CODE (type))
402 len = TYPE_NFIELDS (type);
403 for (i = 0; i < len; i++)
405 if (TYPE_FIELD_ENUMVAL (type, i) == val)
412 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
416 print_longest (stream, 'd', 0, val);
421 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
425 LA_PRINT_CHAR (val, type, stream);
429 fprintf_filtered (stream, val ? "true" : "false");
432 case TYPE_CODE_RANGE:
433 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
436 case TYPE_CODE_UNDEF:
438 case TYPE_CODE_ARRAY:
439 case TYPE_CODE_STRUCT:
440 case TYPE_CODE_UNION:
445 case TYPE_CODE_STRING:
446 case TYPE_CODE_ERROR:
447 case TYPE_CODE_MEMBERPTR:
448 case TYPE_CODE_METHODPTR:
449 case TYPE_CODE_METHOD:
451 warning (_("internal error: unhandled type in ada_print_scalar"));
455 error (_("Invalid type code in symbol table."));
460 /* Print the character string STRING, printing at most LENGTH characters.
461 Printing stops early if the number hits print_max; repeat counts
462 are printed as appropriate. Print ellipses at the end if we
463 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
464 TYPE_LEN is the length (1 or 2) of the character type. */
467 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
468 unsigned int length, int force_ellipses, int type_len,
469 const struct value_print_options *options)
471 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
473 unsigned int things_printed = 0;
479 fputs_filtered ("\"\"", stream);
483 for (i = 0; i < length && things_printed < options->print_max; i += 1)
485 /* Position of the character we are examining
486 to see whether it is repeated. */
488 /* Number of repetitions we have detected so far. */
495 fputs_filtered (", ", stream);
502 && char_at (string, rep1, type_len, byte_order)
503 == char_at (string, i, type_len, byte_order))
509 if (reps > options->repeat_count_threshold)
513 if (options->inspect_it)
514 fputs_filtered ("\\\", ", stream);
516 fputs_filtered ("\", ", stream);
519 fputs_filtered ("'", stream);
520 ada_emit_char (char_at (string, i, type_len, byte_order),
521 elttype, stream, '\'', type_len);
522 fputs_filtered ("'", stream);
523 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
525 things_printed += options->repeat_count_threshold;
532 if (options->inspect_it)
533 fputs_filtered ("\\\"", stream);
535 fputs_filtered ("\"", stream);
538 ada_emit_char (char_at (string, i, type_len, byte_order),
539 elttype, stream, '"', type_len);
544 /* Terminate the quotes if necessary. */
547 if (options->inspect_it)
548 fputs_filtered ("\\\"", stream);
550 fputs_filtered ("\"", stream);
553 if (force_ellipses || i < length)
554 fputs_filtered ("...", stream);
558 ada_printstr (struct ui_file *stream, struct type *type,
559 const gdb_byte *string, unsigned int length,
560 const char *encoding, int force_ellipses,
561 const struct value_print_options *options)
563 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
568 /* See val_print for a description of the various parameters of this
569 function; they are identical. */
572 ada_val_print (struct type *type, const gdb_byte *valaddr,
573 int embedded_offset, CORE_ADDR address,
574 struct ui_file *stream, int recurse,
575 const struct value *val,
576 const struct value_print_options *options)
578 volatile struct gdb_exception except;
580 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
581 TRY_CATCH (except, RETURN_MASK_ALL)
583 ada_val_print_1 (type, valaddr, embedded_offset, address,
584 stream, recurse, val, options);
588 /* Assuming TYPE is a simple array, print the value of this array located
589 at VALADDR + OFFSET. See ada_val_print for a description of the various
590 parameters of this function; they are identical. */
593 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
594 int offset, CORE_ADDR address,
595 struct ui_file *stream, int recurse,
596 const struct value *val,
597 const struct value_print_options *options)
599 /* For an array of chars, print with string syntax. */
600 if (ada_is_string_type (type)
601 && (options->format == 0 || options->format == 's'))
603 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
604 struct type *elttype = TYPE_TARGET_TYPE (type);
608 /* We know that ELTTYPE cannot possibly be null, because we found
609 that TYPE is a string-like type. Similarly, the size of ELTTYPE
610 should also be non-null, since it's a character-like type. */
611 gdb_assert (elttype != NULL);
612 gdb_assert (TYPE_LENGTH (elttype) != 0);
614 eltlen = TYPE_LENGTH (elttype);
615 len = TYPE_LENGTH (type) / eltlen;
617 if (options->prettyprint_arrays)
618 print_spaces_filtered (2 + 2 * recurse, stream);
620 /* If requested, look for the first null char and only print
621 elements up to it. */
622 if (options->stop_print_at_null)
626 /* Look for a NULL char. */
629 && temp_len < options->print_max
630 && char_at (valaddr + offset,
631 temp_len, eltlen, byte_order) != 0);
636 printstr (stream, elttype, valaddr + offset, len, 0, eltlen, options);
640 fprintf_filtered (stream, "(");
641 print_optional_low_bound (stream, type, options);
642 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
643 val_print_packed_array_elements (type, valaddr, offset,
644 0, stream, recurse, val, options);
646 val_print_array_elements (type, valaddr, offset, address,
647 stream, recurse, val, options, 0);
648 fprintf_filtered (stream, ")");
652 /* See the comment on ada_val_print. This function differs in that it
653 does not catch evaluation errors (leaving that to ada_val_print). */
656 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
657 int offset, CORE_ADDR address,
658 struct ui_file *stream, int recurse,
659 const struct value *original_value,
660 const struct value_print_options *options)
663 struct type *elttype;
666 type = ada_check_typedef (type);
668 if (ada_is_array_descriptor_type (type)
669 || (ada_is_constrained_packed_array_type (type)
670 && TYPE_CODE (type) != TYPE_CODE_PTR))
672 struct value *mark = value_mark ();
675 val = value_from_contents_and_address (type, valaddr + offset, address);
676 /* If this is a reference, coerce it now. This helps taking care
677 of the case where ADDRESS is meaningless because original_value
679 val = coerce_ref (val);
680 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
681 val = ada_coerce_to_simple_array_ptr (val);
683 val = ada_coerce_to_simple_array (val);
686 gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
687 fprintf_filtered (stream, "0x0");
690 ada_val_print_1 (value_type (val),
691 value_contents_for_printing (val),
692 value_embedded_offset (val),
693 value_address (val), stream, recurse,
695 value_free_to_mark (mark);
699 offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
700 type = printable_val_type (type, valaddr + offset_aligned);
702 switch (TYPE_CODE (type))
705 c_val_print (type, valaddr, offset, address, stream,
706 recurse, original_value, options);
711 c_val_print (type, valaddr, offset, address,
712 stream, recurse, original_value, options);
714 if (ada_is_tag_type (type))
717 value_from_contents_and_address (type,
718 valaddr + offset_aligned,
719 address + offset_aligned);
720 const char *name = ada_tag_name (val);
723 fprintf_filtered (stream, " (%s)", name);
729 case TYPE_CODE_RANGE:
730 if (ada_is_fixed_point_type (type))
732 LONGEST v = unpack_long (type, valaddr + offset_aligned);
734 fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
735 (double) ada_fixed_to_float (type, v));
738 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
740 struct type *target_type = TYPE_TARGET_TYPE (type);
742 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
744 /* Obscure case of range type that has different length from
745 its base type. Perform a conversion, or we will get a
746 nonsense value. Actually, we could use the same
747 code regardless of lengths; I'm just avoiding a cast. */
749 = value_from_contents_and_address (type, valaddr + offset, 0);
750 struct value *v = value_cast (target_type, v1);
752 ada_val_print_1 (target_type,
753 value_contents_for_printing (v),
754 value_embedded_offset (v), 0,
755 stream, recurse + 1, v, options);
758 ada_val_print_1 (TYPE_TARGET_TYPE (type),
760 address, stream, recurse,
761 original_value, options);
766 int format = (options->format ? options->format
767 : options->output_format);
771 struct value_print_options opts = *options;
773 opts.format = format;
774 val_print_scalar_formatted (type, valaddr, offset_aligned,
775 original_value, &opts, 0, stream);
777 else if (ada_is_system_address_type (type))
779 /* FIXME: We want to print System.Address variables using
780 the same format as for any access type. But for some
781 reason GNAT encodes the System.Address type as an int,
782 so we have to work-around this deficiency by handling
783 System.Address values as a special case. */
785 struct gdbarch *gdbarch = get_type_arch (type);
786 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
787 CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
790 fprintf_filtered (stream, "(");
791 type_print (type, "", stream, -1);
792 fprintf_filtered (stream, ") ");
793 fputs_filtered (paddress (gdbarch, addr), stream);
797 val_print_type_code_int (type, valaddr + offset_aligned, stream);
798 if (ada_is_character_type (type))
802 fputs_filtered (" ", stream);
803 c = unpack_long (type, valaddr + offset_aligned);
804 ada_printchar (c, type, stream);
817 val_print_scalar_formatted (type, valaddr, offset_aligned,
818 original_value, options, 0, stream);
821 len = TYPE_NFIELDS (type);
822 val = unpack_long (type, valaddr + offset_aligned);
823 for (i = 0; i < len; i++)
826 if (val == TYPE_FIELD_ENUMVAL (type, i))
833 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);
850 c_val_print (type, valaddr, offset, address, stream,
851 recurse, original_value, options);
855 ada_print_floating (valaddr + offset, type, stream);
858 case TYPE_CODE_UNION:
859 case TYPE_CODE_STRUCT:
860 if (ada_is_bogus_array_descriptor (type))
862 fprintf_filtered (stream, "(...?)");
867 print_record (type, valaddr, offset_aligned,
868 stream, recurse, original_value, options);
872 case TYPE_CODE_ARRAY:
873 ada_val_print_array (type, valaddr, offset_aligned,
874 address, stream, recurse, original_value,
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 CORE_ADDR deref_val_int;
889 struct value *deref_val;
891 deref_val = coerce_ref_if_computed (original_value);
894 if (ada_is_tagged_type (value_type (deref_val), 1))
895 deref_val = ada_tag_value_at_base_address (deref_val);
897 common_val_print (deref_val, stream, recurse + 1, options,
902 deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
903 if (deref_val_int != 0)
906 ada_value_ind (value_from_pointer
907 (lookup_pointer_type (elttype),
910 if (ada_is_tagged_type (value_type (deref_val), 1))
911 deref_val = ada_tag_value_at_base_address (deref_val);
913 val_print (value_type (deref_val),
914 value_contents_for_printing (deref_val),
915 value_embedded_offset (deref_val),
916 value_address (deref_val), stream, recurse + 1,
917 deref_val, options, current_language);
920 fputs_filtered ("(null)", stream);
923 fputs_filtered ("???", stream);
931 print_variant_part (struct type *type, int field_num,
932 const gdb_byte *valaddr, int offset,
933 struct ui_file *stream, int recurse,
934 const struct value *val,
935 const struct value_print_options *options,
937 struct type *outer_type, int outer_offset)
939 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
940 int which = ada_which_variant_applies (var_type, outer_type,
941 valaddr + outer_offset);
946 return print_field_values
947 (TYPE_FIELD_TYPE (var_type, which),
949 offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
950 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
951 stream, recurse, val, options,
952 comma_needed, outer_type, outer_offset);
956 ada_value_print (struct value *val0, struct ui_file *stream,
957 const struct value_print_options *options)
959 struct value *val = ada_to_fixed_value (val0);
960 CORE_ADDR address = value_address (val);
961 struct type *type = ada_check_typedef (value_type (val));
962 struct value_print_options opts;
964 /* If it is a pointer, indicate what it points to. */
965 if (TYPE_CODE (type) == TYPE_CODE_PTR)
967 /* Hack: don't print (char *) for char strings. Their
968 type is indicated by the quoted string anyway. */
969 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
970 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
971 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
973 fprintf_filtered (stream, "(");
974 type_print (type, "", stream, -1);
975 fprintf_filtered (stream, ") ");
978 else if (ada_is_array_descriptor_type (type))
980 /* We do not print the type description unless TYPE is an array
981 access type (this is encoded by the compiler as a typedef to
982 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
983 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
985 fprintf_filtered (stream, "(");
986 type_print (type, "", stream, -1);
987 fprintf_filtered (stream, ") ");
990 else if (ada_is_bogus_array_descriptor (type))
992 fprintf_filtered (stream, "(");
993 type_print (type, "", stream, -1);
994 fprintf_filtered (stream, ") (...?)");
1000 val_print (type, value_contents_for_printing (val),
1001 value_embedded_offset (val), address,
1002 stream, 0, val, &opts, current_language);
1006 print_record (struct type *type, const gdb_byte *valaddr,
1008 struct ui_file *stream, int recurse,
1009 const struct value *val,
1010 const struct value_print_options *options)
1012 type = ada_check_typedef (type);
1014 fprintf_filtered (stream, "(");
1016 if (print_field_values (type, valaddr, offset,
1017 stream, recurse, val, options,
1018 0, type, offset) != 0 && options->pretty)
1020 fprintf_filtered (stream, "\n");
1021 print_spaces_filtered (2 * recurse, stream);
1024 fprintf_filtered (stream, ")");
1027 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
1029 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
1030 meanings as in ada_print_value and ada_val_print.
1032 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
1033 record (used to get discriminant values when printing variant
1036 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1037 level, so that a comma is needed before any field printed by this
1040 Returns 1 if COMMA_NEEDED or any fields were printed. */
1043 print_field_values (struct type *type, const gdb_byte *valaddr,
1044 int offset, struct ui_file *stream, int recurse,
1045 const struct value *val,
1046 const struct value_print_options *options,
1048 struct type *outer_type, int outer_offset)
1052 len = TYPE_NFIELDS (type);
1054 for (i = 0; i < len; i += 1)
1056 if (ada_is_ignored_field (type, i))
1059 if (ada_is_wrapper_field (type, i))
1062 print_field_values (TYPE_FIELD_TYPE (type, i),
1065 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1066 stream, recurse, val, options,
1067 comma_needed, type, offset);
1070 else if (ada_is_variant_part (type, i))
1073 print_variant_part (type, i, valaddr,
1074 offset, stream, recurse, val,
1075 options, comma_needed,
1076 outer_type, outer_offset);
1081 fprintf_filtered (stream, ", ");
1084 if (options->pretty)
1086 fprintf_filtered (stream, "\n");
1087 print_spaces_filtered (2 + 2 * recurse, stream);
1091 wrap_here (n_spaces (2 + 2 * recurse));
1093 if (options->inspect_it)
1095 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1096 fputs_filtered ("\"( ptr \"", stream);
1098 fputs_filtered ("\"( nodef \"", stream);
1099 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1100 language_cplus, DMGL_NO_OPTS);
1101 fputs_filtered ("\" \"", stream);
1102 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1103 language_cplus, DMGL_NO_OPTS);
1104 fputs_filtered ("\") \"", stream);
1108 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1109 fprintf_filtered (stream, "%.*s",
1110 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1111 TYPE_FIELD_NAME (type, i));
1112 annotate_field_name_end ();
1113 fputs_filtered (" => ", stream);
1114 annotate_field_value ();
1117 if (TYPE_FIELD_PACKED (type, i))
1121 /* Bitfields require special handling, especially due to byte
1123 if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
1125 fputs_filtered (_("<optimized out or zero length>"), stream);
1129 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1130 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1131 struct value_print_options opts;
1133 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1134 v = ada_value_primitive_packed_val
1136 offset + bit_pos / HOST_CHAR_BIT,
1137 bit_pos % HOST_CHAR_BIT,
1138 bit_size, TYPE_FIELD_TYPE (type, i));
1141 val_print (TYPE_FIELD_TYPE (type, i),
1142 value_contents_for_printing (v),
1143 value_embedded_offset (v), 0,
1144 stream, recurse + 1, v,
1145 &opts, current_language);
1150 struct value_print_options opts = *options;
1153 ada_val_print (TYPE_FIELD_TYPE (type, i),
1156 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
1157 0, stream, recurse + 1, val, &opts);
1159 annotate_field_end ();
1162 return comma_needed;