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_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 (index_type
->code () == 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 (index_type
->code ())
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 (index_type
->code () == TYPE_CODE_RANGE
)
145 base_index_type
= TYPE_TARGET_TYPE (index_type
);
147 base_index_type
= index_type
;
149 if (base_index_type
->code () == 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 ())
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
= ada_value_primitive_field (value
, 0,
615 print_field_values (field_val
, field_val
,
616 stream
, recurse
, options
,
617 comma_needed
, language
);
620 else if (ada_is_variant_part (type
, i
))
623 print_variant_part (value
, i
, outer_value
, stream
, recurse
,
624 options
, comma_needed
, language
);
629 fprintf_filtered (stream
, ", ");
632 if (options
->prettyformat
)
634 fprintf_filtered (stream
, "\n");
635 print_spaces_filtered (2 + 2 * recurse
, stream
);
639 wrap_here (n_spaces (2 + 2 * recurse
));
642 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
643 fprintf_filtered (stream
, "%.*s",
644 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
645 TYPE_FIELD_NAME (type
, i
));
646 annotate_field_name_end ();
647 fputs_filtered (" => ", stream
);
648 annotate_field_value ();
650 if (TYPE_FIELD_PACKED (type
, i
))
652 /* Bitfields require special handling, especially due to byte
654 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
656 fputs_styled (_("<optimized out or zero length>"),
657 metadata_style
.style (), stream
);
662 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
663 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
664 struct value_print_options opts
;
666 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
667 v
= ada_value_primitive_packed_val
669 bit_pos
/ HOST_CHAR_BIT
,
670 bit_pos
% HOST_CHAR_BIT
,
671 bit_size
, TYPE_FIELD_TYPE (type
, i
));
674 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
679 struct value_print_options opts
= *options
;
683 struct value
*v
= value_field (value
, i
);
684 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
686 annotate_field_end ();
692 /* Implement Ada val_print'ing for the case where TYPE is
693 a TYPE_CODE_ARRAY of characters. */
696 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
698 struct ui_file
*stream
, int recurse
,
699 const struct value_print_options
*options
)
701 enum bfd_endian byte_order
= type_byte_order (type
);
702 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
706 /* We know that ELTTYPE cannot possibly be null, because we assume
707 that we're called only when TYPE is a string-like type.
708 Similarly, the size of ELTTYPE should also be non-null, since
709 it's a character-like type. */
710 gdb_assert (elttype
!= NULL
);
711 gdb_assert (TYPE_LENGTH (elttype
) != 0);
713 eltlen
= TYPE_LENGTH (elttype
);
714 len
= TYPE_LENGTH (type
) / eltlen
;
716 /* If requested, look for the first null char and only print
717 elements up to it. */
718 if (options
->stop_print_at_null
)
722 /* Look for a NULL char. */
725 && temp_len
< options
->print_max
726 && char_at (valaddr
+ offset_aligned
,
727 temp_len
, eltlen
, byte_order
) != 0);
732 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
736 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
737 thin pointers, etc). */
740 ada_val_print_gnat_array (struct value
*val
,
741 struct ui_file
*stream
, int recurse
,
742 const struct value_print_options
*options
)
744 scoped_value_mark free_values
;
746 struct type
*type
= ada_check_typedef (value_type (val
));
748 /* If this is a reference, coerce it now. This helps taking care
749 of the case where ADDRESS is meaningless because original_value
751 val
= coerce_ref (val
);
752 if (type
->code () == TYPE_CODE_TYPEDEF
) /* array access type. */
753 val
= ada_coerce_to_simple_array_ptr (val
);
755 val
= ada_coerce_to_simple_array (val
);
758 gdb_assert (type
->code () == TYPE_CODE_TYPEDEF
);
759 fprintf_filtered (stream
, "0x0");
762 common_val_print (val
, stream
, recurse
, options
,
763 language_def (language_ada
));
766 /* Implement Ada value_print'ing for the case where TYPE is a
770 ada_value_print_ptr (struct value
*val
,
771 struct ui_file
*stream
, int recurse
,
772 const struct value_print_options
*options
)
774 common_val_print (val
, stream
, recurse
, options
, language_def (language_c
));
776 struct type
*type
= ada_check_typedef (value_type (val
));
777 if (ada_is_tag_type (type
))
779 const char *name
= ada_tag_name (val
);
782 fprintf_filtered (stream
, " (%s)", name
);
786 /* Implement Ada val_print'ing for the case where TYPE is
787 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
790 ada_value_print_num (struct value
*val
, struct ui_file
*stream
, int recurse
,
791 const struct value_print_options
*options
)
793 struct type
*type
= ada_check_typedef (value_type (val
));
794 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
796 if (ada_is_fixed_point_type (type
))
798 struct value
*scale
= ada_scaling_factor (type
);
799 val
= value_cast (value_type (scale
), val
);
800 val
= value_binop (val
, scale
, BINOP_MUL
);
802 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
804 = target_float_to_string (value_contents (val
), value_type (val
), fmt
);
805 fputs_filtered (str
.c_str (), stream
);
808 else if (type
->code () == TYPE_CODE_RANGE
809 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_ENUM
810 || TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_BOOL
811 || TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_CHAR
))
813 /* For enum-valued ranges, we want to recurse, because we'll end
814 up printing the constant's name rather than its numeric
815 value. Character and fixed-point types are also printed
816 differently, so recuse for those as well. */
817 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
818 val
= value_cast (target_type
, val
);
819 common_val_print (val
, stream
, recurse
+ 1, options
,
820 language_def (language_ada
));
825 int format
= (options
->format
? options
->format
826 : options
->output_format
);
830 struct value_print_options opts
= *options
;
832 opts
.format
= format
;
833 value_print_scalar_formatted (val
, &opts
, 0, stream
);
835 else if (ada_is_system_address_type (type
))
837 /* FIXME: We want to print System.Address variables using
838 the same format as for any access type. But for some
839 reason GNAT encodes the System.Address type as an int,
840 so we have to work-around this deficiency by handling
841 System.Address values as a special case. */
843 struct gdbarch
*gdbarch
= get_type_arch (type
);
844 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
845 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
847 fprintf_filtered (stream
, "(");
848 type_print (type
, "", stream
, -1);
849 fprintf_filtered (stream
, ") ");
850 fputs_filtered (paddress (gdbarch
, addr
), stream
);
854 value_print_scalar_formatted (val
, options
, 0, stream
);
855 if (ada_is_character_type (type
))
859 fputs_filtered (" ", stream
);
860 c
= unpack_long (type
, valaddr
);
861 ada_printchar (c
, type
, stream
);
868 /* Implement Ada val_print'ing for the case where TYPE is
872 ada_val_print_enum (struct value
*value
, struct ui_file
*stream
, int recurse
,
873 const struct value_print_options
*options
)
881 value_print_scalar_formatted (value
, options
, 0, stream
);
885 struct type
*type
= ada_check_typedef (value_type (value
));
886 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
887 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
889 len
= TYPE_NFIELDS (type
);
890 val
= unpack_long (type
, valaddr
+ offset_aligned
);
891 for (i
= 0; i
< len
; i
++)
894 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
900 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
903 fprintf_filtered (stream
, "%ld %ps", (long) val
,
904 styled_string (variable_name_style
.style (),
907 fputs_styled (name
, variable_name_style
.style (), stream
);
910 print_longest (stream
, 'd', 0, val
);
913 /* Implement Ada val_print'ing for the case where the type is
914 TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
917 ada_val_print_struct_union (struct value
*value
,
918 struct ui_file
*stream
,
920 const struct value_print_options
*options
)
922 if (ada_is_bogus_array_descriptor (value_type (value
)))
924 fprintf_filtered (stream
, "(...?)");
928 fprintf_filtered (stream
, "(");
930 if (print_field_values (value
, value
, stream
, recurse
, options
,
931 0, language_def (language_ada
)) != 0
932 && options
->prettyformat
)
934 fprintf_filtered (stream
, "\n");
935 print_spaces_filtered (2 * recurse
, stream
);
938 fprintf_filtered (stream
, ")");
941 /* Implement Ada value_print'ing for the case where TYPE is a
945 ada_value_print_array (struct value
*val
, struct ui_file
*stream
, int recurse
,
946 const struct value_print_options
*options
)
948 struct type
*type
= ada_check_typedef (value_type (val
));
950 /* For an array of characters, print with string syntax. */
951 if (ada_is_string_type (type
)
952 && (options
->format
== 0 || options
->format
== 's'))
954 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
955 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
957 ada_val_print_string (type
, valaddr
, offset_aligned
, stream
, recurse
,
962 fprintf_filtered (stream
, "(");
963 print_optional_low_bound (stream
, type
, options
);
964 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
966 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
967 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
968 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
969 stream
, recurse
, options
);
972 value_print_array_elements (val
, stream
, recurse
, options
, 0);
973 fprintf_filtered (stream
, ")");
976 /* Implement Ada val_print'ing for the case where TYPE is
980 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
981 int offset
, int offset_aligned
, CORE_ADDR address
,
982 struct ui_file
*stream
, int recurse
,
983 struct value
*original_value
,
984 const struct value_print_options
*options
)
986 /* For references, the debugger is expected to print the value as
987 an address if DEREF_REF is null. But printing an address in place
988 of the object value would be confusing to an Ada programmer.
989 So, for Ada values, we print the actual dereferenced value
991 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
992 struct value
*deref_val
;
993 CORE_ADDR deref_val_int
;
995 if (elttype
->code () == TYPE_CODE_UNDEF
)
997 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
1002 deref_val
= coerce_ref_if_computed (original_value
);
1005 if (ada_is_tagged_type (value_type (deref_val
), 1))
1006 deref_val
= ada_tag_value_at_base_address (deref_val
);
1008 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1009 language_def (language_ada
));
1013 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1014 if (deref_val_int
== 0)
1016 fputs_filtered ("(null)", stream
);
1021 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1023 if (ada_is_tagged_type (value_type (deref_val
), 1))
1024 deref_val
= ada_tag_value_at_base_address (deref_val
);
1026 /* Make sure that the object does not have an unreasonable size
1027 before trying to print it. This can happen for instance with
1028 references to dynamic objects whose contents is uninitialized
1029 (Eg: an array whose bounds are not set yet). */
1030 ada_ensure_varsize_limit (value_type (deref_val
));
1032 if (value_lazy (deref_val
))
1033 value_fetch_lazy (deref_val
);
1035 common_val_print (deref_val
, stream
, recurse
+ 1,
1036 options
, language_def (language_ada
));
1039 /* See the comment on ada_value_print. This function differs in that
1040 it does not catch evaluation errors (leaving that to
1041 ada_value_print). */
1044 ada_value_print_1 (struct value
*val
, struct ui_file
*stream
, int recurse
,
1045 const struct value_print_options
*options
)
1047 struct type
*type
= ada_check_typedef (value_type (val
));
1049 if (ada_is_array_descriptor_type (type
)
1050 || (ada_is_constrained_packed_array_type (type
)
1051 && type
->code () != TYPE_CODE_PTR
))
1053 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1057 val
= ada_to_fixed_value (val
);
1058 type
= value_type (val
);
1059 struct type
*saved_type
= type
;
1061 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1062 CORE_ADDR address
= value_address (val
);
1063 gdb::array_view
<const gdb_byte
> view
1064 = gdb::make_array_view (valaddr
, TYPE_LENGTH (type
));
1065 type
= ada_check_typedef (resolve_dynamic_type (type
, view
, address
));
1066 if (type
!= saved_type
)
1068 val
= value_copy (val
);
1069 deprecated_set_value_type (val
, type
);
1072 switch (type
->code ())
1075 common_val_print (val
, stream
, recurse
, options
,
1076 language_def (language_c
));
1080 ada_value_print_ptr (val
, stream
, recurse
, options
);
1084 case TYPE_CODE_RANGE
:
1085 ada_value_print_num (val
, stream
, recurse
, options
);
1088 case TYPE_CODE_ENUM
:
1089 ada_val_print_enum (val
, stream
, recurse
, options
);
1093 if (options
->format
)
1095 common_val_print (val
, stream
, recurse
, options
,
1096 language_def (language_c
));
1100 ada_print_floating (valaddr
, type
, stream
);
1103 case TYPE_CODE_UNION
:
1104 case TYPE_CODE_STRUCT
:
1105 ada_val_print_struct_union (val
, stream
, recurse
, options
);
1108 case TYPE_CODE_ARRAY
:
1109 ada_value_print_array (val
, stream
, recurse
, options
);
1113 ada_val_print_ref (type
, valaddr
, 0, 0,
1114 address
, stream
, recurse
, val
,
1120 /* See ada-lang.h. */
1123 ada_value_print_inner (struct value
*val
, struct ui_file
*stream
,
1125 const struct value_print_options
*options
)
1129 ada_value_print_1 (val
, stream
, recurse
, options
);
1131 catch (const gdb_exception_error
&except
)
1133 fprintf_styled (stream
, metadata_style
.style (),
1134 _("<error reading variable: %s>"),
1140 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1141 const struct value_print_options
*options
)
1143 struct value
*val
= ada_to_fixed_value (val0
);
1144 struct type
*type
= ada_check_typedef (value_type (val
));
1145 struct value_print_options opts
;
1147 /* If it is a pointer, indicate what it points to. */
1148 if (type
->code () == TYPE_CODE_PTR
)
1150 /* Hack: don't print (char *) for char strings. Their
1151 type is indicated by the quoted string anyway. */
1152 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1153 || TYPE_TARGET_TYPE (type
)->code () != TYPE_CODE_INT
1154 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1156 fprintf_filtered (stream
, "(");
1157 type_print (type
, "", stream
, -1);
1158 fprintf_filtered (stream
, ") ");
1161 else if (ada_is_array_descriptor_type (type
))
1163 /* We do not print the type description unless TYPE is an array
1164 access type (this is encoded by the compiler as a typedef to
1165 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1166 if (type
->code () == TYPE_CODE_TYPEDEF
)
1168 fprintf_filtered (stream
, "(");
1169 type_print (type
, "", stream
, -1);
1170 fprintf_filtered (stream
, ") ");
1173 else if (ada_is_bogus_array_descriptor (type
))
1175 fprintf_filtered (stream
, "(");
1176 type_print (type
, "", stream
, -1);
1177 fprintf_filtered (stream
, ") (...?)");
1183 common_val_print (val
, stream
, 0, &opts
, current_language
);