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 wrap_here (n_spaces (2 + 2 * recurse
));
199 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
202 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
203 (i0
* bitsize
) / HOST_CHAR_BIT
,
204 (i0
* bitsize
) % HOST_CHAR_BIT
,
211 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
212 (i
* bitsize
) / HOST_CHAR_BIT
,
213 (i
* bitsize
) % HOST_CHAR_BIT
,
215 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
216 != TYPE_LENGTH (check_typedef (value_type (v1
))))
218 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
219 v1
, value_embedded_offset (v1
),
220 TYPE_LENGTH (check_typedef (value_type (v0
)))))
224 if (i
- i0
> options
->repeat_count_threshold
)
226 struct value_print_options opts
= *options
;
229 common_val_print (v0
, stream
, recurse
+ 1, &opts
, current_language
);
230 annotate_elt_rep (i
- i0
);
231 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
232 metadata_style
.style ().ptr (), i
- i0
, nullptr);
233 annotate_elt_rep_end ();
239 struct value_print_options opts
= *options
;
242 for (j
= i0
; j
< i
; j
+= 1)
246 if (options
->prettyformat_arrays
)
248 fprintf_filtered (stream
, ",\n");
249 print_spaces_filtered (2 + 2 * recurse
, stream
);
253 fprintf_filtered (stream
, ", ");
255 wrap_here (n_spaces (2 + 2 * recurse
));
256 maybe_print_array_index (index_type
, j
+ low
,
259 common_val_print (v0
, stream
, recurse
+ 1, &opts
,
264 things_printed
+= i
- i0
;
266 annotate_array_section_end ();
269 fprintf_filtered (stream
, "...");
272 value_free_to_mark (mark
);
275 /* Print the character C on STREAM as part of the contents of a literal
276 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
280 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
281 int quoter
, int type_len
)
283 /* If this character fits in the normal ASCII range, and is
284 a printable character, then print the character as if it was
285 an ASCII character, even if this is a wide character.
286 The UCHAR_MAX check is necessary because the isascii function
287 requires that its argument have a value of an unsigned char,
288 or EOF (EOF is obviously not printable). */
289 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
291 if (c
== quoter
&& c
== '"')
292 fprintf_filtered (stream
, "\"\"");
294 fprintf_filtered (stream
, "%c", c
);
297 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
300 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
304 char_at (const gdb_byte
*string
, int i
, int type_len
,
305 enum bfd_endian byte_order
)
310 return (int) extract_unsigned_integer (string
+ type_len
* i
,
311 type_len
, byte_order
);
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 the GNAT format for NaNs and infinities. */
320 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
321 struct ui_file
*stream
)
323 string_file tmp_stream
;
325 print_floating (valaddr
, type
, &tmp_stream
);
327 std::string
&s
= tmp_stream
.string ();
328 size_t skip_count
= 0;
330 /* Modify for Ada rules. */
332 size_t pos
= s
.find ("inf");
333 if (pos
== std::string::npos
)
334 pos
= s
.find ("Inf");
335 if (pos
== std::string::npos
)
336 pos
= s
.find ("INF");
337 if (pos
!= std::string::npos
)
338 s
.replace (pos
, 3, "Inf");
340 if (pos
== std::string::npos
)
342 pos
= s
.find ("nan");
343 if (pos
== std::string::npos
)
344 pos
= s
.find ("NaN");
345 if (pos
== std::string::npos
)
346 pos
= s
.find ("Nan");
347 if (pos
!= std::string::npos
)
349 s
[pos
] = s
[pos
+ 2] = 'N';
355 if (pos
== std::string::npos
356 && s
.find ('.') == std::string::npos
)
359 if (pos
== std::string::npos
)
360 fprintf_filtered (stream
, "%s.0", s
.c_str ());
362 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
365 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
369 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
371 fputs_filtered ("'", stream
);
372 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
373 fputs_filtered ("'", stream
);
376 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
377 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
378 like a default signed integer. */
381 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
388 print_longest (stream
, 'd', 0, val
);
392 type
= ada_check_typedef (type
);
394 switch (TYPE_CODE (type
))
398 len
= TYPE_NFIELDS (type
);
399 for (i
= 0; i
< len
; i
++)
401 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
408 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
409 variable_name_style
.style (), stream
);
413 print_longest (stream
, 'd', 0, val
);
418 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
422 LA_PRINT_CHAR (val
, type
, stream
);
426 fprintf_filtered (stream
, val
? "true" : "false");
429 case TYPE_CODE_RANGE
:
430 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
433 case TYPE_CODE_UNDEF
:
435 case TYPE_CODE_ARRAY
:
436 case TYPE_CODE_STRUCT
:
437 case TYPE_CODE_UNION
:
442 case TYPE_CODE_STRING
:
443 case TYPE_CODE_ERROR
:
444 case TYPE_CODE_MEMBERPTR
:
445 case TYPE_CODE_METHODPTR
:
446 case TYPE_CODE_METHOD
:
448 warning (_("internal error: unhandled type in ada_print_scalar"));
452 error (_("Invalid type code in symbol table."));
456 /* Print the character string STRING, printing at most LENGTH characters.
457 Printing stops early if the number hits print_max; repeat counts
458 are printed as appropriate. Print ellipses at the end if we
459 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
460 TYPE_LEN is the length (1 or 2) of the character type. */
463 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
464 unsigned int length
, int force_ellipses
, int type_len
,
465 const struct value_print_options
*options
)
467 enum bfd_endian byte_order
= type_byte_order (elttype
);
469 unsigned int things_printed
= 0;
475 fputs_filtered ("\"\"", stream
);
479 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
481 /* Position of the character we are examining
482 to see whether it is repeated. */
484 /* Number of repetitions we have detected so far. */
491 fputs_filtered (", ", stream
);
498 && char_at (string
, rep1
, type_len
, byte_order
)
499 == char_at (string
, i
, type_len
, byte_order
))
505 if (reps
> options
->repeat_count_threshold
)
509 fputs_filtered ("\", ", stream
);
512 fputs_filtered ("'", stream
);
513 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
514 elttype
, stream
, '\'', type_len
);
515 fputs_filtered ("'", stream
);
516 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
517 metadata_style
.style ().ptr (), reps
, nullptr);
519 things_printed
+= options
->repeat_count_threshold
;
526 fputs_filtered ("\"", stream
);
529 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
530 elttype
, stream
, '"', type_len
);
535 /* Terminate the quotes if necessary. */
537 fputs_filtered ("\"", stream
);
539 if (force_ellipses
|| i
< length
)
540 fputs_filtered ("...", stream
);
544 ada_printstr (struct ui_file
*stream
, struct type
*type
,
545 const gdb_byte
*string
, unsigned int length
,
546 const char *encoding
, int force_ellipses
,
547 const struct value_print_options
*options
)
549 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
554 print_variant_part (struct value
*value
, int field_num
,
555 struct value
*outer_value
,
556 struct ui_file
*stream
, int recurse
,
557 const struct value_print_options
*options
,
559 const struct language_defn
*language
)
561 struct type
*type
= value_type (value
);
562 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
563 int which
= ada_which_variant_applies (var_type
, outer_value
);
568 struct value
*active_component
= value_field (value
, which
);
569 return print_field_values (active_component
, outer_value
, stream
, recurse
,
570 options
, comma_needed
, language
);
573 /* Print out fields of VALUE.
575 STREAM, RECURSE, and OPTIONS have the same meanings as in
576 ada_print_value and ada_value_print.
578 OUTER_VALUE gives the enclosing record (used to get discriminant
579 values when printing variant parts).
581 COMMA_NEEDED is 1 if fields have been printed at the current recursion
582 level, so that a comma is needed before any field printed by this
585 Returns 1 if COMMA_NEEDED or any fields were printed. */
588 print_field_values (struct value
*value
, struct value
*outer_value
,
589 struct ui_file
*stream
, int recurse
,
590 const struct value_print_options
*options
,
592 const struct language_defn
*language
)
596 struct type
*type
= value_type (value
);
597 len
= TYPE_NFIELDS (type
);
599 for (i
= 0; i
< len
; i
+= 1)
601 if (ada_is_ignored_field (type
, i
))
604 if (ada_is_wrapper_field (type
, i
))
607 print_field_values (value_field (value
, i
), outer_value
,
608 stream
, recurse
, options
,
609 comma_needed
, language
);
612 else if (ada_is_variant_part (type
, i
))
615 print_variant_part (value
, i
, outer_value
, stream
, recurse
,
616 options
, comma_needed
, language
);
621 fprintf_filtered (stream
, ", ");
624 if (options
->prettyformat
)
626 fprintf_filtered (stream
, "\n");
627 print_spaces_filtered (2 + 2 * recurse
, stream
);
631 wrap_here (n_spaces (2 + 2 * recurse
));
634 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
635 fprintf_filtered (stream
, "%.*s",
636 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
637 TYPE_FIELD_NAME (type
, i
));
638 annotate_field_name_end ();
639 fputs_filtered (" => ", stream
);
640 annotate_field_value ();
642 if (TYPE_FIELD_PACKED (type
, i
))
644 /* Bitfields require special handling, especially due to byte
646 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
648 fputs_styled (_("<optimized out or zero length>"),
649 metadata_style
.style (), stream
);
654 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
655 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
656 struct value_print_options opts
;
658 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
659 v
= ada_value_primitive_packed_val
661 bit_pos
/ HOST_CHAR_BIT
,
662 bit_pos
% HOST_CHAR_BIT
,
663 bit_size
, TYPE_FIELD_TYPE (type
, i
));
666 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
671 struct value_print_options opts
= *options
;
675 struct value
*v
= value_field (value
, i
);
676 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
678 annotate_field_end ();
684 /* Implement Ada val_print'ing for the case where TYPE is
685 a TYPE_CODE_ARRAY of characters. */
688 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
690 struct ui_file
*stream
, int recurse
,
691 const struct value_print_options
*options
)
693 enum bfd_endian byte_order
= type_byte_order (type
);
694 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
698 /* We know that ELTTYPE cannot possibly be null, because we assume
699 that we're called only when TYPE is a string-like type.
700 Similarly, the size of ELTTYPE should also be non-null, since
701 it's a character-like type. */
702 gdb_assert (elttype
!= NULL
);
703 gdb_assert (TYPE_LENGTH (elttype
) != 0);
705 eltlen
= TYPE_LENGTH (elttype
);
706 len
= TYPE_LENGTH (type
) / eltlen
;
708 if (options
->prettyformat_arrays
)
709 print_spaces_filtered (2 + 2 * recurse
, stream
);
711 /* If requested, look for the first null char and only print
712 elements up to it. */
713 if (options
->stop_print_at_null
)
717 /* Look for a NULL char. */
720 && temp_len
< options
->print_max
721 && char_at (valaddr
+ offset_aligned
,
722 temp_len
, eltlen
, byte_order
) != 0);
727 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
731 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
732 thin pointers, etc). */
735 ada_val_print_gnat_array (struct value
*val
,
736 struct ui_file
*stream
, int recurse
,
737 const struct value_print_options
*options
)
739 scoped_value_mark free_values
;
741 struct type
*type
= ada_check_typedef (value_type (val
));
743 /* If this is a reference, coerce it now. This helps taking care
744 of the case where ADDRESS is meaningless because original_value
746 val
= coerce_ref (val
);
747 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
748 val
= ada_coerce_to_simple_array_ptr (val
);
750 val
= ada_coerce_to_simple_array (val
);
753 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
754 fprintf_filtered (stream
, "0x0");
757 common_val_print (val
, stream
, recurse
, options
,
758 language_def (language_ada
));
761 /* Implement Ada value_print'ing for the case where TYPE is a
765 ada_value_print_ptr (struct value
*val
,
766 struct ui_file
*stream
, int recurse
,
767 const struct value_print_options
*options
)
769 common_val_print (val
, stream
, recurse
, options
, language_def (language_c
));
771 struct type
*type
= ada_check_typedef (value_type (val
));
772 if (ada_is_tag_type (type
))
774 const char *name
= ada_tag_name (val
);
777 fprintf_filtered (stream
, " (%s)", name
);
781 /* Implement Ada val_print'ing for the case where TYPE is
782 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
785 ada_value_print_num (struct value
*val
, struct ui_file
*stream
, int recurse
,
786 const struct value_print_options
*options
)
788 struct type
*type
= ada_check_typedef (value_type (val
));
789 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
791 if (ada_is_fixed_point_type (type
))
793 struct value
*scale
= ada_scaling_factor (type
);
794 val
= value_cast (value_type (scale
), val
);
795 val
= value_binop (val
, scale
, BINOP_MUL
);
797 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
799 = target_float_to_string (value_contents (val
), value_type (val
), fmt
);
800 fputs_filtered (str
.c_str (), stream
);
803 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
804 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
805 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
806 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
808 /* For enum-valued ranges, we want to recurse, because we'll end
809 up printing the constant's name rather than its numeric
810 value. Character and fixed-point types are also printed
811 differently, so recuse for those as well. */
812 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
813 val
= value_cast (target_type
, val
);
814 common_val_print (val
, stream
, recurse
+ 1, options
,
815 language_def (language_ada
));
820 int format
= (options
->format
? options
->format
821 : options
->output_format
);
825 struct value_print_options opts
= *options
;
827 opts
.format
= format
;
828 value_print_scalar_formatted (val
, &opts
, 0, stream
);
830 else if (ada_is_system_address_type (type
))
832 /* FIXME: We want to print System.Address variables using
833 the same format as for any access type. But for some
834 reason GNAT encodes the System.Address type as an int,
835 so we have to work-around this deficiency by handling
836 System.Address values as a special case. */
838 struct gdbarch
*gdbarch
= get_type_arch (type
);
839 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
840 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
842 fprintf_filtered (stream
, "(");
843 type_print (type
, "", stream
, -1);
844 fprintf_filtered (stream
, ") ");
845 fputs_filtered (paddress (gdbarch
, addr
), stream
);
849 value_print_scalar_formatted (val
, options
, 0, stream
);
850 if (ada_is_character_type (type
))
854 fputs_filtered (" ", stream
);
855 c
= unpack_long (type
, valaddr
);
856 ada_printchar (c
, type
, stream
);
863 /* Implement Ada val_print'ing for the case where TYPE is
867 ada_val_print_enum (struct value
*value
, struct ui_file
*stream
, int recurse
,
868 const struct value_print_options
*options
)
876 value_print_scalar_formatted (value
, options
, 0, stream
);
880 struct type
*type
= ada_check_typedef (value_type (value
));
881 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
882 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
884 len
= TYPE_NFIELDS (type
);
885 val
= unpack_long (type
, valaddr
+ offset_aligned
);
886 for (i
= 0; i
< len
; i
++)
889 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
895 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
898 fprintf_filtered (stream
, "%ld %ps", (long) val
,
899 styled_string (variable_name_style
.style (),
902 fputs_styled (name
, variable_name_style
.style (), stream
);
905 print_longest (stream
, 'd', 0, val
);
908 /* Implement Ada val_print'ing for the case where the type is
909 TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
912 ada_val_print_struct_union (struct value
*value
,
913 struct ui_file
*stream
,
915 const struct value_print_options
*options
)
917 if (ada_is_bogus_array_descriptor (value_type (value
)))
919 fprintf_filtered (stream
, "(...?)");
923 fprintf_filtered (stream
, "(");
925 if (print_field_values (value
, value
, stream
, recurse
, options
,
926 0, language_def (language_ada
)) != 0
927 && options
->prettyformat
)
929 fprintf_filtered (stream
, "\n");
930 print_spaces_filtered (2 * recurse
, stream
);
933 fprintf_filtered (stream
, ")");
936 /* Implement Ada value_print'ing for the case where TYPE is a
940 ada_value_print_array (struct value
*val
, struct ui_file
*stream
, int recurse
,
941 const struct value_print_options
*options
)
943 struct type
*type
= ada_check_typedef (value_type (val
));
945 /* For an array of characters, print with string syntax. */
946 if (ada_is_string_type (type
)
947 && (options
->format
== 0 || options
->format
== 's'))
949 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
950 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
952 ada_val_print_string (type
, valaddr
, offset_aligned
, stream
, recurse
,
957 fprintf_filtered (stream
, "(");
958 print_optional_low_bound (stream
, type
, options
);
959 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
961 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
962 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
963 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
964 stream
, recurse
, options
);
967 value_print_array_elements (val
, stream
, recurse
, options
, 0);
968 fprintf_filtered (stream
, ")");
971 /* Implement Ada val_print'ing for the case where TYPE is
975 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
976 int offset
, int offset_aligned
, CORE_ADDR address
,
977 struct ui_file
*stream
, int recurse
,
978 struct value
*original_value
,
979 const struct value_print_options
*options
)
981 /* For references, the debugger is expected to print the value as
982 an address if DEREF_REF is null. But printing an address in place
983 of the object value would be confusing to an Ada programmer.
984 So, for Ada values, we print the actual dereferenced value
986 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
987 struct value
*deref_val
;
988 CORE_ADDR deref_val_int
;
990 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
992 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
997 deref_val
= coerce_ref_if_computed (original_value
);
1000 if (ada_is_tagged_type (value_type (deref_val
), 1))
1001 deref_val
= ada_tag_value_at_base_address (deref_val
);
1003 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1004 language_def (language_ada
));
1008 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1009 if (deref_val_int
== 0)
1011 fputs_filtered ("(null)", stream
);
1016 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1018 if (ada_is_tagged_type (value_type (deref_val
), 1))
1019 deref_val
= ada_tag_value_at_base_address (deref_val
);
1021 /* Make sure that the object does not have an unreasonable size
1022 before trying to print it. This can happen for instance with
1023 references to dynamic objects whose contents is uninitialized
1024 (Eg: an array whose bounds are not set yet). */
1025 ada_ensure_varsize_limit (value_type (deref_val
));
1027 if (value_lazy (deref_val
))
1028 value_fetch_lazy (deref_val
);
1030 common_val_print (deref_val
, stream
, recurse
+ 1,
1031 options
, language_def (language_ada
));
1034 /* See the comment on ada_value_print. This function differs in that
1035 it does not catch evaluation errors (leaving that to
1036 ada_value_print). */
1039 ada_value_print_1 (struct value
*val
, struct ui_file
*stream
, int recurse
,
1040 const struct value_print_options
*options
)
1042 struct type
*type
= ada_check_typedef (value_type (val
));
1044 if (ada_is_array_descriptor_type (type
)
1045 || (ada_is_constrained_packed_array_type (type
)
1046 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1048 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1052 val
= ada_to_fixed_value (val
);
1053 type
= value_type (val
);
1054 struct type
*saved_type
= type
;
1056 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1057 CORE_ADDR address
= value_address (val
);
1058 type
= ada_check_typedef (resolve_dynamic_type (type
, valaddr
, address
));
1059 if (type
!= saved_type
)
1061 val
= value_copy (val
);
1062 deprecated_set_value_type (val
, type
);
1065 switch (TYPE_CODE (type
))
1068 common_val_print (val
, stream
, recurse
, options
,
1069 language_def (language_c
));
1073 ada_value_print_ptr (val
, stream
, recurse
, options
);
1077 case TYPE_CODE_RANGE
:
1078 ada_value_print_num (val
, stream
, recurse
, options
);
1081 case TYPE_CODE_ENUM
:
1082 ada_val_print_enum (val
, stream
, recurse
, options
);
1086 if (options
->format
)
1088 common_val_print (val
, stream
, recurse
, options
,
1089 language_def (language_c
));
1093 ada_print_floating (valaddr
, type
, stream
);
1096 case TYPE_CODE_UNION
:
1097 case TYPE_CODE_STRUCT
:
1098 ada_val_print_struct_union (val
, stream
, recurse
, options
);
1101 case TYPE_CODE_ARRAY
:
1102 ada_value_print_array (val
, stream
, recurse
, options
);
1106 ada_val_print_ref (type
, valaddr
, 0, 0,
1107 address
, stream
, recurse
, val
,
1113 /* See ada-lang.h. */
1116 ada_value_print_inner (struct value
*val
, struct ui_file
*stream
,
1118 const struct value_print_options
*options
)
1122 ada_value_print_1 (val
, stream
, recurse
, options
);
1124 catch (const gdb_exception_error
&except
)
1126 fprintf_styled (stream
, metadata_style
.style (),
1127 _("<error reading variable: %s>"),
1133 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1134 const struct value_print_options
*options
)
1136 struct value
*val
= ada_to_fixed_value (val0
);
1137 struct type
*type
= ada_check_typedef (value_type (val
));
1138 struct value_print_options opts
;
1140 /* If it is a pointer, indicate what it points to. */
1141 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1143 /* Hack: don't print (char *) for char strings. Their
1144 type is indicated by the quoted string anyway. */
1145 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1146 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1147 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1149 fprintf_filtered (stream
, "(");
1150 type_print (type
, "", stream
, -1);
1151 fprintf_filtered (stream
, ") ");
1154 else if (ada_is_array_descriptor_type (type
))
1156 /* We do not print the type description unless TYPE is an array
1157 access type (this is encoded by the compiler as a typedef to
1158 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1159 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1161 fprintf_filtered (stream
, "(");
1162 type_print (type
, "", stream
, -1);
1163 fprintf_filtered (stream
, ") ");
1166 else if (ada_is_bogus_array_descriptor (type
))
1168 fprintf_filtered (stream
, "(");
1169 type_print (type
, "", stream
, -1);
1170 fprintf_filtered (stream
, ") (...?)");
1176 common_val_print (val
, stream
, 0, &opts
, current_language
);