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, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
27 #include "expression.h"
36 #include "exceptions.h"
39 static void print_record (struct type
*, const gdb_byte
*, struct ui_file
*,
42 const struct value_print_options
*);
44 static int print_field_values (struct type
*, const gdb_byte
*,
45 struct ui_file
*, int,
47 const struct value_print_options
*,
51 static void adjust_type_signedness (struct type
*);
53 static int 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_BITPOS (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
,
137 int bitoffset
, struct ui_file
*stream
,
139 const struct value
*val
,
140 const struct value_print_options
*options
)
143 unsigned int things_printed
= 0;
145 struct type
*elttype
, *index_type
;
147 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
148 struct value
*mark
= value_mark ();
151 elttype
= TYPE_TARGET_TYPE (type
);
152 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
153 index_type
= TYPE_INDEX_TYPE (type
);
158 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
161 len
= high
- low
+ 1;
165 annotate_array_section_begin (i
, elttype
);
167 while (i
< len
&& things_printed
< options
->print_max
)
169 struct value
*v0
, *v1
;
174 if (options
->prettyprint_arrays
)
176 fprintf_filtered (stream
, ",\n");
177 print_spaces_filtered (2 + 2 * recurse
, stream
);
181 fprintf_filtered (stream
, ", ");
184 wrap_here (n_spaces (2 + 2 * recurse
));
185 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
188 v0
= ada_value_primitive_packed_val (NULL
, valaddr
,
189 (i0
* bitsize
) / HOST_CHAR_BIT
,
190 (i0
* bitsize
) % HOST_CHAR_BIT
,
197 v1
= ada_value_primitive_packed_val (NULL
, valaddr
,
198 (i
* bitsize
) / HOST_CHAR_BIT
,
199 (i
* bitsize
) % HOST_CHAR_BIT
,
201 if (memcmp (value_contents (v0
), value_contents (v1
), eltlen
) != 0)
205 if (i
- i0
> options
->repeat_count_threshold
)
207 struct value_print_options opts
= *options
;
210 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
211 recurse
+ 1, val
, &opts
, current_language
);
212 annotate_elt_rep (i
- i0
);
213 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
214 annotate_elt_rep_end ();
220 struct value_print_options opts
= *options
;
223 for (j
= i0
; j
< i
; j
+= 1)
227 if (options
->prettyprint_arrays
)
229 fprintf_filtered (stream
, ",\n");
230 print_spaces_filtered (2 + 2 * recurse
, stream
);
234 fprintf_filtered (stream
, ", ");
236 wrap_here (n_spaces (2 + 2 * recurse
));
237 maybe_print_array_index (index_type
, j
+ low
,
240 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
241 recurse
+ 1, val
, &opts
, current_language
);
245 things_printed
+= i
- i0
;
247 annotate_array_section_end ();
250 fprintf_filtered (stream
, "...");
253 value_free_to_mark (mark
);
257 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
259 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
262 /* Print the character C on STREAM as part of the contents of a literal
263 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
267 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
268 int quoter
, int type_len
)
270 /* If this character fits in the normal ASCII range, and is
271 a printable character, then print the character as if it was
272 an ASCII character, even if this is a wide character.
273 The UCHAR_MAX check is necessary because the isascii function
274 requires that its argument have a value of an unsigned char,
275 or EOF (EOF is obviously not printable). */
276 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
278 if (c
== quoter
&& c
== '"')
279 fprintf_filtered (stream
, "\"\"");
281 fprintf_filtered (stream
, "%c", c
);
284 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
287 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
291 char_at (const gdb_byte
*string
, int i
, int type_len
,
292 enum bfd_endian byte_order
)
297 return (int) extract_unsigned_integer (string
+ type_len
* i
,
298 type_len
, byte_order
);
301 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
303 ui_memcpy (void *dest
, const char *buffer
, long len
)
305 memcpy (dest
, buffer
, (size_t) len
);
306 ((char *) dest
)[len
] = '\0';
309 /* Print a floating-point value of type TYPE, pointed to in GDB by
310 VALADDR, on STREAM. Use Ada formatting conventions: there must be
311 a decimal point, and at least one digit before and after the
312 point. We use GNAT format for NaNs and infinities. */
314 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
315 struct ui_file
*stream
)
320 struct ui_file
*tmp_stream
= mem_fileopen ();
321 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
323 print_floating (valaddr
, type
, tmp_stream
);
324 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
325 do_cleanups (cleanups
);
328 len
= strlen (result
);
330 /* Modify for Ada rules. */
332 s
= strstr (result
, "inf");
334 s
= strstr (result
, "Inf");
336 s
= strstr (result
, "INF");
342 s
= strstr (result
, "nan");
344 s
= strstr (result
, "NaN");
346 s
= strstr (result
, "Nan");
350 if (result
[0] == '-')
355 if (s
== NULL
&& strchr (result
, '.') == NULL
)
357 s
= strchr (result
, 'e');
359 fprintf_filtered (stream
, "%s.0", result
);
361 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
364 fprintf_filtered (stream
, "%s", result
);
368 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
370 fputs_filtered ("'", stream
);
371 ada_emit_char (c
, type
, stream
, '\'', 1);
372 fputs_filtered ("'", stream
);
375 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
376 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
377 like a default signed integer. */
380 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
387 print_longest (stream
, 'd', 0, val
);
391 type
= ada_check_typedef (type
);
393 switch (TYPE_CODE (type
))
397 len
= TYPE_NFIELDS (type
);
398 for (i
= 0; i
< len
; i
++)
400 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
407 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
411 print_longest (stream
, 'd', 0, val
);
416 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
420 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
424 fprintf_filtered (stream
, val
? "true" : "false");
427 case TYPE_CODE_RANGE
:
428 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
431 case TYPE_CODE_UNDEF
:
433 case TYPE_CODE_ARRAY
:
434 case TYPE_CODE_STRUCT
:
435 case TYPE_CODE_UNION
:
440 case TYPE_CODE_STRING
:
441 case TYPE_CODE_ERROR
:
442 case TYPE_CODE_MEMBERPTR
:
443 case TYPE_CODE_METHODPTR
:
444 case TYPE_CODE_METHOD
:
446 warning (_("internal error: unhandled type in ada_print_scalar"));
450 error (_("Invalid type code in symbol table."));
455 /* Print the character string STRING, printing at most LENGTH characters.
456 Printing stops early if the number hits print_max; repeat counts
457 are printed as appropriate. Print ellipses at the end if we
458 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
459 TYPE_LEN is the length (1 or 2) of the character type. */
462 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
463 unsigned int length
, int force_ellipses
, int type_len
,
464 const struct value_print_options
*options
)
466 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
468 unsigned int things_printed
= 0;
474 fputs_filtered ("\"\"", stream
);
478 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
480 /* Position of the character we are examining
481 to see whether it is repeated. */
483 /* Number of repetitions we have detected so far. */
490 fputs_filtered (", ", stream
);
497 && char_at (string
, rep1
, type_len
, byte_order
)
498 == char_at (string
, i
, type_len
, byte_order
))
504 if (reps
> options
->repeat_count_threshold
)
508 if (options
->inspect_it
)
509 fputs_filtered ("\\\", ", stream
);
511 fputs_filtered ("\", ", stream
);
514 fputs_filtered ("'", stream
);
515 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
516 elttype
, stream
, '\'', type_len
);
517 fputs_filtered ("'", stream
);
518 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
520 things_printed
+= options
->repeat_count_threshold
;
527 if (options
->inspect_it
)
528 fputs_filtered ("\\\"", stream
);
530 fputs_filtered ("\"", stream
);
533 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
534 elttype
, stream
, '"', type_len
);
539 /* Terminate the quotes if necessary. */
542 if (options
->inspect_it
)
543 fputs_filtered ("\\\"", stream
);
545 fputs_filtered ("\"", stream
);
548 if (force_ellipses
|| i
< length
)
549 fputs_filtered ("...", stream
);
553 ada_printstr (struct ui_file
*stream
, struct type
*type
,
554 const gdb_byte
*string
, unsigned int length
,
555 const char *encoding
, int force_ellipses
,
556 const struct value_print_options
*options
)
558 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
563 /* Print data of type TYPE located at VALADDR (within GDB), which came from
564 the inferior at address ADDRESS, onto stdio stream STREAM according to
565 OPTIONS. The data at VALADDR is in target byte order.
567 If the data is printed as a string, returns the number of string characters
570 RECURSE indicates the amount of indentation to supply before
571 continuation lines; this amount is roughly twice the value of RECURSE. */
574 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
575 int embedded_offset
, CORE_ADDR address
,
576 struct ui_file
*stream
, int recurse
,
577 const struct value
*val
,
578 const struct value_print_options
*options
)
580 volatile struct gdb_exception except
;
583 TRY_CATCH (except
, RETURN_MASK_ALL
)
585 result
= ada_val_print_1 (type
, valaddr0
, embedded_offset
, address
,
586 stream
, recurse
, val
, options
);
589 if (except
.reason
< 0)
595 /* Assuming TYPE is a simple array, print the value of this array located
596 at VALADDR. See ada_val_print for a description of the various
597 parameters of this function; they are identical. The semantics
598 of the return value is also identical to ada_val_print. */
601 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
602 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
603 const struct value
*val
,
604 const struct value_print_options
*options
)
606 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
607 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
610 /* For an array of chars, print with string syntax. */
611 if (ada_is_string_type (type
)
612 && (options
->format
== 0 || options
->format
== 's'))
620 eltlen
= TYPE_LENGTH (elttype
);
624 len
= TYPE_LENGTH (type
) / eltlen
;
626 if (options
->prettyprint_arrays
)
627 print_spaces_filtered (2 + 2 * recurse
, stream
);
629 /* If requested, look for the first null char and only print
630 elements up to it. */
631 if (options
->stop_print_at_null
)
635 /* Look for a NULL char. */
638 && temp_len
< options
->print_max
639 && char_at (valaddr
, temp_len
, eltlen
, byte_order
) != 0);
644 printstr (stream
, elttype
, valaddr
, len
, 0, eltlen
, options
);
649 fprintf_filtered (stream
, "(");
650 print_optional_low_bound (stream
, type
, options
);
651 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
652 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
653 recurse
, val
, options
);
655 val_print_array_elements (type
, valaddr
, address
, stream
,
656 recurse
, val
, options
, 0);
657 fprintf_filtered (stream
, ")");
663 /* See the comment on ada_val_print. This function differs in that it
664 does not catch evaluation errors (leaving that to ada_val_print). */
667 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
668 int embedded_offset
, CORE_ADDR address
,
669 struct ui_file
*stream
, int recurse
,
670 const struct value
*original_value
,
671 const struct value_print_options
*options
)
675 struct type
*elttype
;
677 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
679 type
= ada_check_typedef (type
);
681 if (ada_is_array_descriptor_type (type
)
682 || ada_is_constrained_packed_array_type (type
))
685 struct value
*mark
= value_mark ();
688 val
= value_from_contents_and_address (type
, valaddr
, address
);
689 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
690 val
= ada_coerce_to_simple_array_ptr (val
);
692 val
= ada_coerce_to_simple_array (val
);
695 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
696 fprintf_filtered (stream
, "0x0");
700 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
701 value_address (val
), stream
, recurse
,
703 value_free_to_mark (mark
);
707 valaddr
= ada_aligned_value_addr (type
, valaddr
);
708 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
709 type
= printable_val_type (type
, valaddr
);
711 switch (TYPE_CODE (type
))
714 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
715 recurse
, original_value
, options
);
719 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
720 stream
, recurse
, original_value
, options
);
722 if (ada_is_tag_type (type
))
725 value_from_contents_and_address (type
, valaddr
, address
);
726 const char *name
= ada_tag_name (val
);
729 fprintf_filtered (stream
, " (%s)", name
);
736 case TYPE_CODE_RANGE
:
737 if (ada_is_fixed_point_type (type
))
739 LONGEST v
= unpack_long (type
, valaddr
);
740 int len
= TYPE_LENGTH (type
);
742 fprintf_filtered (stream
, len
< 4 ? "%.11g" : "%.17g",
743 (double) ada_fixed_to_float (type
, v
));
746 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
748 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
750 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
752 /* Obscure case of range type that has different length from
753 its base type. Perform a conversion, or we will get a
754 nonsense value. Actually, we could use the same
755 code regardless of lengths; I'm just avoiding a cast. */
756 struct value
*v
= value_cast (target_type
,
757 value_from_contents_and_address
760 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
761 stream
, recurse
+ 1, NULL
, options
);
764 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
765 valaddr0
, embedded_offset
,
766 address
, stream
, recurse
,
767 original_value
, options
);
771 int format
= (options
->format
? options
->format
772 : options
->output_format
);
776 struct value_print_options opts
= *options
;
778 opts
.format
= format
;
779 print_scalar_formatted (valaddr
, type
, &opts
, 0, stream
);
781 else if (ada_is_system_address_type (type
))
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 struct gdbarch
*gdbarch
= get_type_arch (type
);
790 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
791 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
793 fprintf_filtered (stream
, "(");
794 type_print (type
, "", stream
, -1);
795 fprintf_filtered (stream
, ") ");
796 fputs_filtered (paddress (gdbarch
, addr
), stream
);
800 val_print_type_code_int (type
, valaddr
, stream
);
801 if (ada_is_character_type (type
))
803 fputs_filtered (" ", stream
);
804 ada_printchar ((unsigned char) unpack_long (type
, valaddr
),
814 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
817 len
= TYPE_NFIELDS (type
);
818 val
= unpack_long (type
, valaddr
);
819 for (i
= 0; i
< len
; i
++)
822 if (val
== TYPE_FIELD_BITPOS (type
, i
))
829 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
832 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
834 fputs_filtered (name
, stream
);
838 print_longest (stream
, 'd', 0, val
);
842 case TYPE_CODE_FLAGS
:
844 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
846 val_print_type_code_flags (type
, valaddr
, stream
);
851 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
852 recurse
, original_value
, options
);
854 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
857 case TYPE_CODE_UNION
:
858 case TYPE_CODE_STRUCT
:
859 if (ada_is_bogus_array_descriptor (type
))
861 fprintf_filtered (stream
, "(...?)");
866 print_record (type
, valaddr
, stream
, recurse
, original_value
,
871 case TYPE_CODE_ARRAY
:
872 return ada_val_print_array (type
, valaddr
, address
, stream
,
873 recurse
, original_value
, options
);
876 /* For references, the debugger is expected to print the value as
877 an address if DEREF_REF is null. But printing an address in place
878 of the object value would be confusing to an Ada programmer.
879 So, for Ada values, we print the actual dereferenced value
881 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
883 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
885 LONGEST deref_val_int
= (LONGEST
) unpack_pointer (type
, valaddr
);
887 if (deref_val_int
!= 0)
889 struct value
*deref_val
=
890 ada_value_ind (value_from_longest
891 (lookup_pointer_type (elttype
),
894 val_print (value_type (deref_val
),
895 value_contents (deref_val
), 0,
896 value_address (deref_val
), stream
, recurse
+ 1,
897 original_value
, options
, current_language
);
900 fputs_filtered ("(null)", stream
);
903 fputs_filtered ("???", stream
);
912 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
913 struct ui_file
*stream
, int recurse
,
914 const struct value
*val
,
915 const struct value_print_options
*options
,
917 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
919 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
920 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
925 return print_field_values
926 (TYPE_FIELD_TYPE (var_type
, which
),
927 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
928 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
929 stream
, recurse
, val
, options
,
930 comma_needed
, outer_type
, outer_valaddr
);
934 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
935 const struct value_print_options
*options
)
937 struct value
*val
= ada_to_fixed_value (val0
);
938 CORE_ADDR address
= value_address (val
);
939 struct type
*type
= value_type (val
);
940 struct value_print_options opts
;
942 /* If it is a pointer, indicate what it points to. */
943 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
945 /* Hack: don't print (char *) for char strings. Their
946 type is indicated by the quoted string anyway. */
947 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
948 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
949 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
951 fprintf_filtered (stream
, "(");
952 type_print (type
, "", stream
, -1);
953 fprintf_filtered (stream
, ") ");
956 else if (ada_is_array_descriptor_type (type
))
958 /* We do not print the type description unless TYPE is an array
959 access type (this is encoded by the compiler as a typedef to
960 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
961 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
963 fprintf_filtered (stream
, "(");
964 type_print (type
, "", stream
, -1);
965 fprintf_filtered (stream
, ") ");
968 else if (ada_is_bogus_array_descriptor (type
))
970 fprintf_filtered (stream
, "(");
971 type_print (type
, "", stream
, -1);
972 fprintf_filtered (stream
, ") (...?)");
978 return (val_print (type
, value_contents (val
), 0, address
,
979 stream
, 0, val
, &opts
, current_language
));
983 print_record (struct type
*type
, const gdb_byte
*valaddr
,
984 struct ui_file
*stream
, int recurse
,
985 const struct value
*val
,
986 const struct value_print_options
*options
)
988 type
= ada_check_typedef (type
);
990 fprintf_filtered (stream
, "(");
992 if (print_field_values (type
, valaddr
, stream
, recurse
, val
, options
,
993 0, type
, valaddr
) != 0 && options
->pretty
)
995 fprintf_filtered (stream
, "\n");
996 print_spaces_filtered (2 * recurse
, stream
);
999 fprintf_filtered (stream
, ")");
1002 /* Print out fields of value at VALADDR having structure type TYPE.
1004 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1005 same meanings as in ada_print_value and ada_val_print.
1007 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1008 (used to get discriminant values when printing variant parts).
1010 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1011 level, so that a comma is needed before any field printed by this
1014 Returns 1 if COMMA_NEEDED or any fields were printed. */
1017 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
1018 struct ui_file
*stream
, int recurse
,
1019 const struct value
*val
,
1020 const struct value_print_options
*options
,
1022 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
1026 len
= TYPE_NFIELDS (type
);
1028 for (i
= 0; i
< len
; i
+= 1)
1030 if (ada_is_ignored_field (type
, i
))
1033 if (ada_is_wrapper_field (type
, i
))
1036 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1038 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1039 stream
, recurse
, val
, options
,
1040 comma_needed
, type
, valaddr
);
1043 else if (ada_is_variant_part (type
, i
))
1046 print_variant_part (type
, i
, valaddr
,
1047 stream
, recurse
, val
, options
, comma_needed
,
1048 outer_type
, outer_valaddr
);
1053 fprintf_filtered (stream
, ", ");
1056 if (options
->pretty
)
1058 fprintf_filtered (stream
, "\n");
1059 print_spaces_filtered (2 + 2 * recurse
, stream
);
1063 wrap_here (n_spaces (2 + 2 * recurse
));
1065 if (options
->inspect_it
)
1067 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1068 fputs_filtered ("\"( ptr \"", stream
);
1070 fputs_filtered ("\"( nodef \"", stream
);
1071 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1072 language_cplus
, DMGL_NO_OPTS
);
1073 fputs_filtered ("\" \"", stream
);
1074 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1075 language_cplus
, DMGL_NO_OPTS
);
1076 fputs_filtered ("\") \"", stream
);
1080 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1081 fprintf_filtered (stream
, "%.*s",
1082 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1083 TYPE_FIELD_NAME (type
, i
));
1084 annotate_field_name_end ();
1085 fputs_filtered (" => ", stream
);
1086 annotate_field_value ();
1089 if (TYPE_FIELD_PACKED (type
, i
))
1093 /* Bitfields require special handling, especially due to byte
1095 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
1097 fputs_filtered (_("<optimized out or zero length>"), stream
);
1101 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1102 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1103 struct value_print_options opts
;
1105 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1106 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1107 bit_pos
/ HOST_CHAR_BIT
,
1108 bit_pos
% HOST_CHAR_BIT
,
1110 TYPE_FIELD_TYPE (type
, i
));
1113 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1114 stream
, recurse
+ 1, v
,
1115 &opts
, current_language
);
1120 struct value_print_options opts
= *options
;
1123 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1124 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1125 0, 0, stream
, recurse
+ 1, val
, &opts
);
1127 annotate_field_end ();
1130 return comma_needed
;