1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "expression.h"
29 #include "target-float.h"
30 #include "cli/cli-style.h"
33 static int print_field_values (struct value
*, struct value
*,
34 struct ui_file
*, int,
35 const struct value_print_options
*,
36 int, const struct language_defn
*);
40 /* Make TYPE unsigned if its range of values includes no negatives. */
42 adjust_type_signedness (struct type
*type
)
44 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
45 && TYPE_LOW_BOUND (type
) >= 0)
46 TYPE_UNSIGNED (type
) = 1;
49 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
50 if non-standard (i.e., other than 1 for numbers, other than lower bound
51 of index type for enumerated type). Returns 1 if something printed,
55 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
56 const struct value_print_options
*options
)
58 struct type
*index_type
;
62 if (options
->print_array_indexes
)
65 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
68 /* If this is an empty array, then don't print the lower bound.
69 That would be confusing, because we would print the lower bound,
70 followed by... nothing! */
71 if (low_bound
> high_bound
)
74 index_type
= TYPE_INDEX_TYPE (type
);
76 while (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
78 /* We need to know what the base type is, in order to do the
79 appropriate check below. Otherwise, if this is a subrange
80 of an enumerated type, where the underlying value of the
81 first element is typically 0, we might test the low bound
82 against the wrong value. */
83 index_type
= TYPE_TARGET_TYPE (index_type
);
86 /* Don't print the lower bound if it's the default one. */
87 switch (TYPE_CODE (index_type
))
95 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
107 ada_print_scalar (index_type
, low_bound
, stream
);
108 fprintf_filtered (stream
, " => ");
112 /* Version of val_print_array_elements for GNAT-style packed arrays.
113 Prints elements of packed array of type TYPE from VALADDR on
114 STREAM. Formats according to OPTIONS and separates with commas.
115 RECURSE is the recursion (nesting) level. TYPE must have been
116 decoded (as by ada_coerce_to_simple_array). */
119 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
120 int offset
, struct ui_file
*stream
,
122 const struct value_print_options
*options
)
125 unsigned int things_printed
= 0;
127 struct type
*elttype
, *index_type
;
128 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
129 struct value
*mark
= value_mark ();
132 elttype
= TYPE_TARGET_TYPE (type
);
133 index_type
= TYPE_INDEX_TYPE (type
);
137 struct type
*base_index_type
;
139 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
142 len
= high
- low
+ 1;
144 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
145 base_index_type
= TYPE_TARGET_TYPE (index_type
);
147 base_index_type
= index_type
;
149 if (TYPE_CODE (base_index_type
) == TYPE_CODE_ENUM
)
151 LONGEST low_pos
, high_pos
;
153 /* Non-contiguous enumerations types can by used as index types
154 so the array length is computed from the positions of the
155 first and last literal in the enumeration type, and not from
156 the values of these literals. */
158 if (!discrete_position (base_index_type
, low
, &low_pos
)
159 || !discrete_position (base_index_type
, high
, &high_pos
))
161 warning (_("unable to get positions in array, use bounds instead"));
166 /* The array length should normally be HIGH_POS - LOW_POS + 1.
167 But in Ada we allow LOW_POS to be greater than HIGH_POS for
168 empty arrays. In that situation, the array length is just zero,
171 if (low_pos
> high_pos
)
174 len
= high_pos
- low_pos
+ 1;
179 annotate_array_section_begin (i
, elttype
);
181 while (i
< len
&& things_printed
< options
->print_max
)
183 struct value
*v0
, *v1
;
188 if (options
->prettyformat_arrays
)
190 fprintf_filtered (stream
, ",\n");
191 print_spaces_filtered (2 + 2 * recurse
, stream
);
195 fprintf_filtered (stream
, ", ");
198 else if (options
->prettyformat_arrays
)
200 fprintf_filtered (stream
, "\n");
201 print_spaces_filtered (2 + 2 * recurse
, stream
);
203 wrap_here (n_spaces (2 + 2 * recurse
));
204 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
207 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
208 (i0
* bitsize
) / HOST_CHAR_BIT
,
209 (i0
* bitsize
) % HOST_CHAR_BIT
,
216 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
217 (i
* bitsize
) / HOST_CHAR_BIT
,
218 (i
* bitsize
) % HOST_CHAR_BIT
,
220 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
221 != TYPE_LENGTH (check_typedef (value_type (v1
))))
223 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
224 v1
, value_embedded_offset (v1
),
225 TYPE_LENGTH (check_typedef (value_type (v0
)))))
229 if (i
- i0
> options
->repeat_count_threshold
)
231 struct value_print_options opts
= *options
;
234 common_val_print (v0
, stream
, recurse
+ 1, &opts
, current_language
);
235 annotate_elt_rep (i
- i0
);
236 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
237 metadata_style
.style ().ptr (), i
- i0
, nullptr);
238 annotate_elt_rep_end ();
244 struct value_print_options opts
= *options
;
247 for (j
= i0
; j
< i
; j
+= 1)
251 if (options
->prettyformat_arrays
)
253 fprintf_filtered (stream
, ",\n");
254 print_spaces_filtered (2 + 2 * recurse
, stream
);
258 fprintf_filtered (stream
, ", ");
260 wrap_here (n_spaces (2 + 2 * recurse
));
261 maybe_print_array_index (index_type
, j
+ low
,
264 common_val_print (v0
, stream
, recurse
+ 1, &opts
,
269 things_printed
+= i
- i0
;
271 annotate_array_section_end ();
274 fprintf_filtered (stream
, "...");
277 value_free_to_mark (mark
);
280 /* Print the character C on STREAM as part of the contents of a literal
281 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
285 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
286 int quoter
, int type_len
)
288 /* If this character fits in the normal ASCII range, and is
289 a printable character, then print the character as if it was
290 an ASCII character, even if this is a wide character.
291 The UCHAR_MAX check is necessary because the isascii function
292 requires that its argument have a value of an unsigned char,
293 or EOF (EOF is obviously not printable). */
294 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
296 if (c
== quoter
&& c
== '"')
297 fprintf_filtered (stream
, "\"\"");
299 fprintf_filtered (stream
, "%c", c
);
302 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
305 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
309 char_at (const gdb_byte
*string
, int i
, int type_len
,
310 enum bfd_endian byte_order
)
315 return (int) extract_unsigned_integer (string
+ type_len
* i
,
316 type_len
, byte_order
);
319 /* Print a floating-point value of type TYPE, pointed to in GDB by
320 VALADDR, on STREAM. Use Ada formatting conventions: there must be
321 a decimal point, and at least one digit before and after the
322 point. We use the GNAT format for NaNs and infinities. */
325 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
326 struct ui_file
*stream
)
328 string_file tmp_stream
;
330 print_floating (valaddr
, type
, &tmp_stream
);
332 std::string
&s
= tmp_stream
.string ();
333 size_t skip_count
= 0;
335 /* Modify for Ada rules. */
337 size_t pos
= s
.find ("inf");
338 if (pos
== std::string::npos
)
339 pos
= s
.find ("Inf");
340 if (pos
== std::string::npos
)
341 pos
= s
.find ("INF");
342 if (pos
!= std::string::npos
)
343 s
.replace (pos
, 3, "Inf");
345 if (pos
== std::string::npos
)
347 pos
= s
.find ("nan");
348 if (pos
== std::string::npos
)
349 pos
= s
.find ("NaN");
350 if (pos
== std::string::npos
)
351 pos
= s
.find ("Nan");
352 if (pos
!= std::string::npos
)
354 s
[pos
] = s
[pos
+ 2] = 'N';
360 if (pos
== std::string::npos
361 && s
.find ('.') == std::string::npos
)
364 if (pos
== std::string::npos
)
365 fprintf_filtered (stream
, "%s.0", s
.c_str ());
367 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
370 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
374 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
376 fputs_filtered ("'", stream
);
377 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
378 fputs_filtered ("'", stream
);
381 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
382 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
383 like a default signed integer. */
386 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
393 print_longest (stream
, 'd', 0, val
);
397 type
= ada_check_typedef (type
);
399 switch (TYPE_CODE (type
))
403 len
= TYPE_NFIELDS (type
);
404 for (i
= 0; i
< len
; i
++)
406 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
413 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
414 variable_name_style
.style (), stream
);
418 print_longest (stream
, 'd', 0, val
);
423 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
427 LA_PRINT_CHAR (val
, type
, stream
);
431 fprintf_filtered (stream
, val
? "true" : "false");
434 case TYPE_CODE_RANGE
:
435 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
438 case TYPE_CODE_UNDEF
:
440 case TYPE_CODE_ARRAY
:
441 case TYPE_CODE_STRUCT
:
442 case TYPE_CODE_UNION
:
447 case TYPE_CODE_STRING
:
448 case TYPE_CODE_ERROR
:
449 case TYPE_CODE_MEMBERPTR
:
450 case TYPE_CODE_METHODPTR
:
451 case TYPE_CODE_METHOD
:
453 warning (_("internal error: unhandled type in ada_print_scalar"));
457 error (_("Invalid type code in symbol table."));
461 /* Print the character string STRING, printing at most LENGTH characters.
462 Printing stops early if the number hits print_max; repeat counts
463 are printed as appropriate. Print ellipses at the end if we
464 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
465 TYPE_LEN is the length (1 or 2) of the character type. */
468 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
469 unsigned int length
, int force_ellipses
, int type_len
,
470 const struct value_print_options
*options
)
472 enum bfd_endian byte_order
= type_byte_order (elttype
);
474 unsigned int things_printed
= 0;
480 fputs_filtered ("\"\"", stream
);
484 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
486 /* Position of the character we are examining
487 to see whether it is repeated. */
489 /* Number of repetitions we have detected so far. */
496 fputs_filtered (", ", stream
);
503 && char_at (string
, rep1
, type_len
, byte_order
)
504 == char_at (string
, i
, type_len
, byte_order
))
510 if (reps
> options
->repeat_count_threshold
)
514 fputs_filtered ("\", ", stream
);
517 fputs_filtered ("'", stream
);
518 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
519 elttype
, stream
, '\'', type_len
);
520 fputs_filtered ("'", stream
);
521 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
522 metadata_style
.style ().ptr (), reps
, nullptr);
524 things_printed
+= options
->repeat_count_threshold
;
531 fputs_filtered ("\"", stream
);
534 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
535 elttype
, stream
, '"', type_len
);
540 /* Terminate the quotes if necessary. */
542 fputs_filtered ("\"", stream
);
544 if (force_ellipses
|| i
< length
)
545 fputs_filtered ("...", stream
);
549 ada_printstr (struct ui_file
*stream
, struct type
*type
,
550 const gdb_byte
*string
, unsigned int length
,
551 const char *encoding
, int force_ellipses
,
552 const struct value_print_options
*options
)
554 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
559 print_variant_part (struct value
*value
, int field_num
,
560 struct value
*outer_value
,
561 struct ui_file
*stream
, int recurse
,
562 const struct value_print_options
*options
,
564 const struct language_defn
*language
)
566 struct type
*type
= value_type (value
);
567 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
568 int which
= ada_which_variant_applies (var_type
, outer_value
);
573 struct value
*variant_field
= value_field (value
, field_num
);
574 struct value
*active_component
= value_field (variant_field
, which
);
575 return print_field_values (active_component
, outer_value
, stream
, recurse
,
576 options
, comma_needed
, language
);
579 /* Print out fields of VALUE.
581 STREAM, RECURSE, and OPTIONS have the same meanings as in
582 ada_print_value and ada_value_print.
584 OUTER_VALUE gives the enclosing record (used to get discriminant
585 values when printing variant parts).
587 COMMA_NEEDED is 1 if fields have been printed at the current recursion
588 level, so that a comma is needed before any field printed by this
591 Returns 1 if COMMA_NEEDED or any fields were printed. */
594 print_field_values (struct value
*value
, struct value
*outer_value
,
595 struct ui_file
*stream
, int recurse
,
596 const struct value_print_options
*options
,
598 const struct language_defn
*language
)
602 struct type
*type
= value_type (value
);
603 len
= TYPE_NFIELDS (type
);
605 for (i
= 0; i
< len
; i
+= 1)
607 if (ada_is_ignored_field (type
, i
))
610 if (ada_is_wrapper_field (type
, i
))
612 struct value
*field_val
= value_field (value
, i
);
614 print_field_values (field_val
, field_val
,
615 stream
, recurse
, options
,
616 comma_needed
, language
);
619 else if (ada_is_variant_part (type
, i
))
622 print_variant_part (value
, i
, outer_value
, stream
, recurse
,
623 options
, comma_needed
, language
);
628 fprintf_filtered (stream
, ", ");
631 if (options
->prettyformat
)
633 fprintf_filtered (stream
, "\n");
634 print_spaces_filtered (2 + 2 * recurse
, stream
);
638 wrap_here (n_spaces (2 + 2 * recurse
));
641 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
642 fprintf_filtered (stream
, "%.*s",
643 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
644 TYPE_FIELD_NAME (type
, i
));
645 annotate_field_name_end ();
646 fputs_filtered (" => ", stream
);
647 annotate_field_value ();
649 if (TYPE_FIELD_PACKED (type
, i
))
651 /* Bitfields require special handling, especially due to byte
653 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
655 fputs_styled (_("<optimized out or zero length>"),
656 metadata_style
.style (), stream
);
661 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
662 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
663 struct value_print_options opts
;
665 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
666 v
= ada_value_primitive_packed_val
668 bit_pos
/ HOST_CHAR_BIT
,
669 bit_pos
% HOST_CHAR_BIT
,
670 bit_size
, TYPE_FIELD_TYPE (type
, i
));
673 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
678 struct value_print_options opts
= *options
;
682 struct value
*v
= value_field (value
, i
);
683 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
685 annotate_field_end ();
691 /* Implement Ada val_print'ing for the case where TYPE is
692 a TYPE_CODE_ARRAY of characters. */
695 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
697 struct ui_file
*stream
, int recurse
,
698 const struct value_print_options
*options
)
700 enum bfd_endian byte_order
= type_byte_order (type
);
701 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
705 /* We know that ELTTYPE cannot possibly be null, because we assume
706 that we're called only when TYPE is a string-like type.
707 Similarly, the size of ELTTYPE should also be non-null, since
708 it's a character-like type. */
709 gdb_assert (elttype
!= NULL
);
710 gdb_assert (TYPE_LENGTH (elttype
) != 0);
712 eltlen
= TYPE_LENGTH (elttype
);
713 len
= TYPE_LENGTH (type
) / eltlen
;
715 /* If requested, look for the first null char and only print
716 elements up to it. */
717 if (options
->stop_print_at_null
)
721 /* Look for a NULL char. */
724 && temp_len
< options
->print_max
725 && char_at (valaddr
+ offset_aligned
,
726 temp_len
, eltlen
, byte_order
) != 0);
731 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
735 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
736 thin pointers, etc). */
739 ada_val_print_gnat_array (struct value
*val
,
740 struct ui_file
*stream
, int recurse
,
741 const struct value_print_options
*options
)
743 scoped_value_mark free_values
;
745 struct type
*type
= ada_check_typedef (value_type (val
));
747 /* If this is a reference, coerce it now. This helps taking care
748 of the case where ADDRESS is meaningless because original_value
750 val
= coerce_ref (val
);
751 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
752 val
= ada_coerce_to_simple_array_ptr (val
);
754 val
= ada_coerce_to_simple_array (val
);
757 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
758 fprintf_filtered (stream
, "0x0");
761 common_val_print (val
, stream
, recurse
, options
,
762 language_def (language_ada
));
765 /* Implement Ada value_print'ing for the case where TYPE is a
769 ada_value_print_ptr (struct value
*val
,
770 struct ui_file
*stream
, int recurse
,
771 const struct value_print_options
*options
)
773 common_val_print (val
, stream
, recurse
, options
, language_def (language_c
));
775 struct type
*type
= ada_check_typedef (value_type (val
));
776 if (ada_is_tag_type (type
))
778 const char *name
= ada_tag_name (val
);
781 fprintf_filtered (stream
, " (%s)", name
);
785 /* Implement Ada val_print'ing for the case where TYPE is
786 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
789 ada_value_print_num (struct value
*val
, struct ui_file
*stream
, int recurse
,
790 const struct value_print_options
*options
)
792 struct type
*type
= ada_check_typedef (value_type (val
));
793 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
795 if (ada_is_fixed_point_type (type
))
797 struct value
*scale
= ada_scaling_factor (type
);
798 val
= value_cast (value_type (scale
), val
);
799 val
= value_binop (val
, scale
, BINOP_MUL
);
801 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
803 = target_float_to_string (value_contents (val
), value_type (val
), fmt
);
804 fputs_filtered (str
.c_str (), stream
);
807 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
808 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
809 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
810 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
812 /* For enum-valued ranges, we want to recurse, because we'll end
813 up printing the constant's name rather than its numeric
814 value. Character and fixed-point types are also printed
815 differently, so recuse for those as well. */
816 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
817 val
= value_cast (target_type
, val
);
818 common_val_print (val
, stream
, recurse
+ 1, options
,
819 language_def (language_ada
));
824 int format
= (options
->format
? options
->format
825 : options
->output_format
);
829 struct value_print_options opts
= *options
;
831 opts
.format
= format
;
832 value_print_scalar_formatted (val
, &opts
, 0, stream
);
834 else if (ada_is_system_address_type (type
))
836 /* FIXME: We want to print System.Address variables using
837 the same format as for any access type. But for some
838 reason GNAT encodes the System.Address type as an int,
839 so we have to work-around this deficiency by handling
840 System.Address values as a special case. */
842 struct gdbarch
*gdbarch
= get_type_arch (type
);
843 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
844 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
846 fprintf_filtered (stream
, "(");
847 type_print (type
, "", stream
, -1);
848 fprintf_filtered (stream
, ") ");
849 fputs_filtered (paddress (gdbarch
, addr
), stream
);
853 value_print_scalar_formatted (val
, options
, 0, stream
);
854 if (ada_is_character_type (type
))
858 fputs_filtered (" ", stream
);
859 c
= unpack_long (type
, valaddr
);
860 ada_printchar (c
, type
, stream
);
867 /* Implement Ada val_print'ing for the case where TYPE is
871 ada_val_print_enum (struct value
*value
, struct ui_file
*stream
, int recurse
,
872 const struct value_print_options
*options
)
880 value_print_scalar_formatted (value
, options
, 0, stream
);
884 struct type
*type
= ada_check_typedef (value_type (value
));
885 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
886 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
888 len
= TYPE_NFIELDS (type
);
889 val
= unpack_long (type
, valaddr
+ offset_aligned
);
890 for (i
= 0; i
< len
; i
++)
893 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
899 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
902 fprintf_filtered (stream
, "%ld %ps", (long) val
,
903 styled_string (variable_name_style
.style (),
906 fputs_styled (name
, variable_name_style
.style (), stream
);
909 print_longest (stream
, 'd', 0, val
);
912 /* Implement Ada val_print'ing for the case where the type is
913 TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
916 ada_val_print_struct_union (struct value
*value
,
917 struct ui_file
*stream
,
919 const struct value_print_options
*options
)
921 if (ada_is_bogus_array_descriptor (value_type (value
)))
923 fprintf_filtered (stream
, "(...?)");
927 fprintf_filtered (stream
, "(");
929 if (print_field_values (value
, value
, stream
, recurse
, options
,
930 0, language_def (language_ada
)) != 0
931 && options
->prettyformat
)
933 fprintf_filtered (stream
, "\n");
934 print_spaces_filtered (2 * recurse
, stream
);
937 fprintf_filtered (stream
, ")");
940 /* Implement Ada value_print'ing for the case where TYPE is a
944 ada_value_print_array (struct value
*val
, struct ui_file
*stream
, int recurse
,
945 const struct value_print_options
*options
)
947 struct type
*type
= ada_check_typedef (value_type (val
));
949 /* For an array of characters, print with string syntax. */
950 if (ada_is_string_type (type
)
951 && (options
->format
== 0 || options
->format
== 's'))
953 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
954 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
956 ada_val_print_string (type
, valaddr
, offset_aligned
, stream
, recurse
,
961 fprintf_filtered (stream
, "(");
962 print_optional_low_bound (stream
, type
, options
);
963 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
965 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
966 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
967 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
968 stream
, recurse
, options
);
971 value_print_array_elements (val
, stream
, recurse
, options
, 0);
972 fprintf_filtered (stream
, ")");
975 /* Implement Ada val_print'ing for the case where TYPE is
979 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
980 int offset
, int offset_aligned
, CORE_ADDR address
,
981 struct ui_file
*stream
, int recurse
,
982 struct value
*original_value
,
983 const struct value_print_options
*options
)
985 /* For references, the debugger is expected to print the value as
986 an address if DEREF_REF is null. But printing an address in place
987 of the object value would be confusing to an Ada programmer.
988 So, for Ada values, we print the actual dereferenced value
990 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
991 struct value
*deref_val
;
992 CORE_ADDR deref_val_int
;
994 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
996 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
1001 deref_val
= coerce_ref_if_computed (original_value
);
1004 if (ada_is_tagged_type (value_type (deref_val
), 1))
1005 deref_val
= ada_tag_value_at_base_address (deref_val
);
1007 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1008 language_def (language_ada
));
1012 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1013 if (deref_val_int
== 0)
1015 fputs_filtered ("(null)", stream
);
1020 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1022 if (ada_is_tagged_type (value_type (deref_val
), 1))
1023 deref_val
= ada_tag_value_at_base_address (deref_val
);
1025 /* Make sure that the object does not have an unreasonable size
1026 before trying to print it. This can happen for instance with
1027 references to dynamic objects whose contents is uninitialized
1028 (Eg: an array whose bounds are not set yet). */
1029 ada_ensure_varsize_limit (value_type (deref_val
));
1031 if (value_lazy (deref_val
))
1032 value_fetch_lazy (deref_val
);
1034 common_val_print (deref_val
, stream
, recurse
+ 1,
1035 options
, language_def (language_ada
));
1038 /* See the comment on ada_value_print. This function differs in that
1039 it does not catch evaluation errors (leaving that to
1040 ada_value_print). */
1043 ada_value_print_1 (struct value
*val
, struct ui_file
*stream
, int recurse
,
1044 const struct value_print_options
*options
)
1046 struct type
*type
= ada_check_typedef (value_type (val
));
1048 if (ada_is_array_descriptor_type (type
)
1049 || (ada_is_constrained_packed_array_type (type
)
1050 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1052 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1056 val
= ada_to_fixed_value (val
);
1057 type
= value_type (val
);
1058 struct type
*saved_type
= type
;
1060 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1061 CORE_ADDR address
= value_address (val
);
1062 gdb::array_view
<const gdb_byte
> view
1063 = gdb::make_array_view (valaddr
, TYPE_LENGTH (type
));
1064 type
= ada_check_typedef (resolve_dynamic_type (type
, view
, address
));
1065 if (type
!= saved_type
)
1067 val
= value_copy (val
);
1068 deprecated_set_value_type (val
, type
);
1071 switch (TYPE_CODE (type
))
1074 common_val_print (val
, stream
, recurse
, options
,
1075 language_def (language_c
));
1079 ada_value_print_ptr (val
, stream
, recurse
, options
);
1083 case TYPE_CODE_RANGE
:
1084 ada_value_print_num (val
, stream
, recurse
, options
);
1087 case TYPE_CODE_ENUM
:
1088 ada_val_print_enum (val
, stream
, recurse
, options
);
1092 if (options
->format
)
1094 common_val_print (val
, stream
, recurse
, options
,
1095 language_def (language_c
));
1099 ada_print_floating (valaddr
, type
, stream
);
1102 case TYPE_CODE_UNION
:
1103 case TYPE_CODE_STRUCT
:
1104 ada_val_print_struct_union (val
, stream
, recurse
, options
);
1107 case TYPE_CODE_ARRAY
:
1108 ada_value_print_array (val
, stream
, recurse
, options
);
1112 ada_val_print_ref (type
, valaddr
, 0, 0,
1113 address
, stream
, recurse
, val
,
1119 /* See ada-lang.h. */
1122 ada_value_print_inner (struct value
*val
, struct ui_file
*stream
,
1124 const struct value_print_options
*options
)
1128 ada_value_print_1 (val
, stream
, recurse
, options
);
1130 catch (const gdb_exception_error
&except
)
1132 fprintf_styled (stream
, metadata_style
.style (),
1133 _("<error reading variable: %s>"),
1139 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1140 const struct value_print_options
*options
)
1142 struct value
*val
= ada_to_fixed_value (val0
);
1143 struct type
*type
= ada_check_typedef (value_type (val
));
1144 struct value_print_options opts
;
1146 /* If it is a pointer, indicate what it points to. */
1147 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1149 /* Hack: don't print (char *) for char strings. Their
1150 type is indicated by the quoted string anyway. */
1151 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1152 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1153 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1155 fprintf_filtered (stream
, "(");
1156 type_print (type
, "", stream
, -1);
1157 fprintf_filtered (stream
, ") ");
1160 else if (ada_is_array_descriptor_type (type
))
1162 /* We do not print the type description unless TYPE is an array
1163 access type (this is encoded by the compiler as a typedef to
1164 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1165 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1167 fprintf_filtered (stream
, "(");
1168 type_print (type
, "", stream
, -1);
1169 fprintf_filtered (stream
, ") ");
1172 else if (ada_is_bogus_array_descriptor (type
))
1174 fprintf_filtered (stream
, "(");
1175 type_print (type
, "", stream
, -1);
1176 fprintf_filtered (stream
, ") (...?)");
1182 common_val_print (val
, stream
, 0, &opts
, current_language
);