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 type
*, const gdb_byte
*,
35 struct ui_file
*, int,
37 const struct value_print_options
*,
38 int, struct type
*, int,
39 const struct language_defn
*);
42 /* Make TYPE unsigned if its range of values includes no negatives. */
44 adjust_type_signedness (struct type
*type
)
46 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
47 && TYPE_LOW_BOUND (type
) >= 0)
48 TYPE_UNSIGNED (type
) = 1;
51 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
52 if non-standard (i.e., other than 1 for numbers, other than lower bound
53 of index type for enumerated type). Returns 1 if something printed,
57 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
58 const struct value_print_options
*options
)
60 struct type
*index_type
;
64 if (options
->print_array_indexes
)
67 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
70 /* If this is an empty array, then don't print the lower bound.
71 That would be confusing, because we would print the lower bound,
72 followed by... nothing! */
73 if (low_bound
> high_bound
)
76 index_type
= TYPE_INDEX_TYPE (type
);
78 while (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
80 /* We need to know what the base type is, in order to do the
81 appropriate check below. Otherwise, if this is a subrange
82 of an enumerated type, where the underlying value of the
83 first element is typically 0, we might test the low bound
84 against the wrong value. */
85 index_type
= TYPE_TARGET_TYPE (index_type
);
88 /* Don't print the lower bound if it's the default one. */
89 switch (TYPE_CODE (index_type
))
97 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
100 case TYPE_CODE_UNDEF
:
109 ada_print_scalar (index_type
, low_bound
, stream
);
110 fprintf_filtered (stream
, " => ");
114 /* Version of val_print_array_elements for GNAT-style packed arrays.
115 Prints elements of packed array of type TYPE at bit offset
116 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
117 separates with commas. RECURSE is the recursion (nesting) level.
118 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
121 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
123 int bitoffset
, struct ui_file
*stream
,
126 const struct value_print_options
*options
)
129 unsigned int things_printed
= 0;
131 struct type
*elttype
, *index_type
;
132 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
133 struct value
*mark
= value_mark ();
136 elttype
= TYPE_TARGET_TYPE (type
);
137 index_type
= TYPE_INDEX_TYPE (type
);
141 struct type
*base_index_type
;
143 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
146 len
= high
- low
+ 1;
148 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
149 base_index_type
= TYPE_TARGET_TYPE (index_type
);
151 base_index_type
= index_type
;
153 if (TYPE_CODE (base_index_type
) == TYPE_CODE_ENUM
)
155 LONGEST low_pos
, high_pos
;
157 /* Non-contiguous enumerations types can by used as index types
158 so the array length is computed from the positions of the
159 first and last literal in the enumeration type, and not from
160 the values of these literals. */
162 if (!discrete_position (base_index_type
, low
, &low_pos
)
163 || !discrete_position (base_index_type
, high
, &high_pos
))
165 warning (_("unable to get positions in array, use bounds instead"));
170 /* The array length should normally be HIGH_POS - LOW_POS + 1.
171 But in Ada we allow LOW_POS to be greater than HIGH_POS for
172 empty arrays. In that situation, the array length is just zero,
175 if (low_pos
> high_pos
)
178 len
= high_pos
- low_pos
+ 1;
183 annotate_array_section_begin (i
, elttype
);
185 while (i
< len
&& things_printed
< options
->print_max
)
187 struct value
*v0
, *v1
;
192 if (options
->prettyformat_arrays
)
194 fprintf_filtered (stream
, ",\n");
195 print_spaces_filtered (2 + 2 * recurse
, stream
);
199 fprintf_filtered (stream
, ", ");
202 wrap_here (n_spaces (2 + 2 * recurse
));
203 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
206 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
207 (i0
* bitsize
) / HOST_CHAR_BIT
,
208 (i0
* bitsize
) % HOST_CHAR_BIT
,
215 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
216 (i
* bitsize
) / HOST_CHAR_BIT
,
217 (i
* bitsize
) % HOST_CHAR_BIT
,
219 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
220 != TYPE_LENGTH (check_typedef (value_type (v1
))))
222 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
223 v1
, value_embedded_offset (v1
),
224 TYPE_LENGTH (check_typedef (value_type (v0
)))))
228 if (i
- i0
> options
->repeat_count_threshold
)
230 struct value_print_options opts
= *options
;
234 value_embedded_offset (v0
), 0, stream
,
235 recurse
+ 1, v0
, &opts
, current_language
);
236 annotate_elt_rep (i
- i0
);
237 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
238 metadata_style
.style ().ptr (), i
- i0
, nullptr);
239 annotate_elt_rep_end ();
245 struct value_print_options opts
= *options
;
248 for (j
= i0
; j
< i
; j
+= 1)
252 if (options
->prettyformat_arrays
)
254 fprintf_filtered (stream
, ",\n");
255 print_spaces_filtered (2 + 2 * recurse
, stream
);
259 fprintf_filtered (stream
, ", ");
261 wrap_here (n_spaces (2 + 2 * recurse
));
262 maybe_print_array_index (index_type
, j
+ low
,
266 value_embedded_offset (v0
), 0, stream
,
267 recurse
+ 1, v0
, &opts
, current_language
);
271 things_printed
+= i
- i0
;
273 annotate_array_section_end ();
276 fprintf_filtered (stream
, "...");
279 value_free_to_mark (mark
);
283 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
285 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
288 /* Print the character C on STREAM as part of the contents of a literal
289 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
293 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
294 int quoter
, int type_len
)
296 /* If this character fits in the normal ASCII range, and is
297 a printable character, then print the character as if it was
298 an ASCII character, even if this is a wide character.
299 The UCHAR_MAX check is necessary because the isascii function
300 requires that its argument have a value of an unsigned char,
301 or EOF (EOF is obviously not printable). */
302 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
304 if (c
== quoter
&& c
== '"')
305 fprintf_filtered (stream
, "\"\"");
307 fprintf_filtered (stream
, "%c", c
);
310 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
313 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
317 char_at (const gdb_byte
*string
, int i
, int type_len
,
318 enum bfd_endian byte_order
)
323 return (int) extract_unsigned_integer (string
+ type_len
* i
,
324 type_len
, byte_order
);
327 /* Print a floating-point value of type TYPE, pointed to in GDB by
328 VALADDR, on STREAM. Use Ada formatting conventions: there must be
329 a decimal point, and at least one digit before and after the
330 point. We use the GNAT format for NaNs and infinities. */
333 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
334 struct ui_file
*stream
)
336 string_file tmp_stream
;
338 print_floating (valaddr
, type
, &tmp_stream
);
340 std::string
&s
= tmp_stream
.string ();
341 size_t skip_count
= 0;
343 /* Modify for Ada rules. */
345 size_t pos
= s
.find ("inf");
346 if (pos
== std::string::npos
)
347 pos
= s
.find ("Inf");
348 if (pos
== std::string::npos
)
349 pos
= s
.find ("INF");
350 if (pos
!= std::string::npos
)
351 s
.replace (pos
, 3, "Inf");
353 if (pos
== std::string::npos
)
355 pos
= s
.find ("nan");
356 if (pos
== std::string::npos
)
357 pos
= s
.find ("NaN");
358 if (pos
== std::string::npos
)
359 pos
= s
.find ("Nan");
360 if (pos
!= std::string::npos
)
362 s
[pos
] = s
[pos
+ 2] = 'N';
368 if (pos
== std::string::npos
369 && s
.find ('.') == std::string::npos
)
372 if (pos
== std::string::npos
)
373 fprintf_filtered (stream
, "%s.0", s
.c_str ());
375 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
378 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
382 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
384 fputs_filtered ("'", stream
);
385 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
386 fputs_filtered ("'", stream
);
389 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
390 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
391 like a default signed integer. */
394 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
401 print_longest (stream
, 'd', 0, val
);
405 type
= ada_check_typedef (type
);
407 switch (TYPE_CODE (type
))
411 len
= TYPE_NFIELDS (type
);
412 for (i
= 0; i
< len
; i
++)
414 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
421 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
422 variable_name_style
.style (), stream
);
426 print_longest (stream
, 'd', 0, val
);
431 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
435 LA_PRINT_CHAR (val
, type
, stream
);
439 fprintf_filtered (stream
, val
? "true" : "false");
442 case TYPE_CODE_RANGE
:
443 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
446 case TYPE_CODE_UNDEF
:
448 case TYPE_CODE_ARRAY
:
449 case TYPE_CODE_STRUCT
:
450 case TYPE_CODE_UNION
:
455 case TYPE_CODE_STRING
:
456 case TYPE_CODE_ERROR
:
457 case TYPE_CODE_MEMBERPTR
:
458 case TYPE_CODE_METHODPTR
:
459 case TYPE_CODE_METHOD
:
461 warning (_("internal error: unhandled type in ada_print_scalar"));
465 error (_("Invalid type code in symbol table."));
469 /* Print the character string STRING, printing at most LENGTH characters.
470 Printing stops early if the number hits print_max; repeat counts
471 are printed as appropriate. Print ellipses at the end if we
472 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
473 TYPE_LEN is the length (1 or 2) of the character type. */
476 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
477 unsigned int length
, int force_ellipses
, int type_len
,
478 const struct value_print_options
*options
)
480 enum bfd_endian byte_order
= type_byte_order (elttype
);
482 unsigned int things_printed
= 0;
488 fputs_filtered ("\"\"", stream
);
492 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
494 /* Position of the character we are examining
495 to see whether it is repeated. */
497 /* Number of repetitions we have detected so far. */
504 fputs_filtered (", ", stream
);
511 && char_at (string
, rep1
, type_len
, byte_order
)
512 == char_at (string
, i
, type_len
, byte_order
))
518 if (reps
> options
->repeat_count_threshold
)
522 fputs_filtered ("\", ", stream
);
525 fputs_filtered ("'", stream
);
526 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
527 elttype
, stream
, '\'', type_len
);
528 fputs_filtered ("'", stream
);
529 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
530 metadata_style
.style ().ptr (), reps
, nullptr);
532 things_printed
+= options
->repeat_count_threshold
;
539 fputs_filtered ("\"", stream
);
542 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
543 elttype
, stream
, '"', type_len
);
548 /* Terminate the quotes if necessary. */
550 fputs_filtered ("\"", stream
);
552 if (force_ellipses
|| i
< length
)
553 fputs_filtered ("...", stream
);
557 ada_printstr (struct ui_file
*stream
, struct type
*type
,
558 const gdb_byte
*string
, unsigned int length
,
559 const char *encoding
, int force_ellipses
,
560 const struct value_print_options
*options
)
562 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
567 print_variant_part (struct type
*type
, int field_num
,
568 const gdb_byte
*valaddr
, int offset
,
569 struct ui_file
*stream
, int recurse
,
571 const struct value_print_options
*options
,
573 struct type
*outer_type
, int outer_offset
,
574 const struct language_defn
*language
)
576 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
577 int which
= ada_which_variant_applies (var_type
, outer_type
,
578 valaddr
+ outer_offset
);
583 return print_field_values
584 (TYPE_FIELD_TYPE (var_type
, which
),
586 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
587 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
588 stream
, recurse
, val
, options
,
589 comma_needed
, outer_type
, outer_offset
, language
);
592 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
594 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
595 meanings as in ada_print_value and ada_val_print.
597 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
598 record (used to get discriminant values when printing variant
601 COMMA_NEEDED is 1 if fields have been printed at the current recursion
602 level, so that a comma is needed before any field printed by this
605 Returns 1 if COMMA_NEEDED or any fields were printed. */
608 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
609 int offset
, struct ui_file
*stream
, int recurse
,
611 const struct value_print_options
*options
,
613 struct type
*outer_type
, int outer_offset
,
614 const struct language_defn
*language
)
618 len
= TYPE_NFIELDS (type
);
620 for (i
= 0; i
< len
; i
+= 1)
622 if (ada_is_ignored_field (type
, i
))
625 if (ada_is_wrapper_field (type
, i
))
628 print_field_values (TYPE_FIELD_TYPE (type
, i
),
631 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
632 stream
, recurse
, val
, options
,
633 comma_needed
, type
, offset
, language
);
636 else if (ada_is_variant_part (type
, i
))
639 print_variant_part (type
, i
, valaddr
,
640 offset
, stream
, recurse
, val
,
641 options
, comma_needed
,
642 outer_type
, outer_offset
, language
);
647 fprintf_filtered (stream
, ", ");
650 if (options
->prettyformat
)
652 fprintf_filtered (stream
, "\n");
653 print_spaces_filtered (2 + 2 * recurse
, stream
);
657 wrap_here (n_spaces (2 + 2 * recurse
));
660 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
661 fprintf_filtered (stream
, "%.*s",
662 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
663 TYPE_FIELD_NAME (type
, i
));
664 annotate_field_name_end ();
665 fputs_filtered (" => ", stream
);
666 annotate_field_value ();
668 if (TYPE_FIELD_PACKED (type
, i
))
670 /* Bitfields require special handling, especially due to byte
672 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
674 fputs_styled (_("<optimized out or zero length>"),
675 metadata_style
.style (), stream
);
680 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
681 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
682 struct value_print_options opts
;
684 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
685 v
= ada_value_primitive_packed_val
687 offset
+ bit_pos
/ HOST_CHAR_BIT
,
688 bit_pos
% HOST_CHAR_BIT
,
689 bit_size
, TYPE_FIELD_TYPE (type
, i
));
692 val_print (TYPE_FIELD_TYPE (type
, i
),
693 value_embedded_offset (v
), 0,
694 stream
, recurse
+ 1, v
,
700 struct value_print_options opts
= *options
;
703 val_print (TYPE_FIELD_TYPE (type
, i
),
704 (offset
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
705 0, stream
, recurse
+ 1, val
, &opts
, language
);
707 annotate_field_end ();
713 /* Implement Ada val_print'ing for the case where TYPE is
714 a TYPE_CODE_ARRAY of characters. */
717 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
718 int offset
, int offset_aligned
, CORE_ADDR address
,
719 struct ui_file
*stream
, int recurse
,
720 struct value
*original_value
,
721 const struct value_print_options
*options
)
723 enum bfd_endian byte_order
= type_byte_order (type
);
724 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
728 /* We know that ELTTYPE cannot possibly be null, because we assume
729 that we're called only when TYPE is a string-like type.
730 Similarly, the size of ELTTYPE should also be non-null, since
731 it's a character-like type. */
732 gdb_assert (elttype
!= NULL
);
733 gdb_assert (TYPE_LENGTH (elttype
) != 0);
735 eltlen
= TYPE_LENGTH (elttype
);
736 len
= TYPE_LENGTH (type
) / eltlen
;
738 if (options
->prettyformat_arrays
)
739 print_spaces_filtered (2 + 2 * recurse
, stream
);
741 /* If requested, look for the first null char and only print
742 elements up to it. */
743 if (options
->stop_print_at_null
)
747 /* Look for a NULL char. */
750 && temp_len
< options
->print_max
751 && char_at (valaddr
+ offset_aligned
,
752 temp_len
, eltlen
, byte_order
) != 0);
757 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
761 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
762 thin pointers, etc). */
765 ada_val_print_gnat_array (struct type
*type
, const gdb_byte
*valaddr
,
766 int offset
, CORE_ADDR address
,
767 struct ui_file
*stream
, int recurse
,
768 struct value
*original_value
,
769 const struct value_print_options
*options
)
771 struct value
*mark
= value_mark ();
774 val
= value_from_contents_and_address (type
, valaddr
+ offset
, address
);
775 /* If this is a reference, coerce it now. This helps taking care
776 of the case where ADDRESS is meaningless because original_value
778 val
= coerce_ref (val
);
779 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
780 val
= ada_coerce_to_simple_array_ptr (val
);
782 val
= ada_coerce_to_simple_array (val
);
785 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
786 fprintf_filtered (stream
, "0x0");
789 val_print (value_type (val
),
790 value_embedded_offset (val
), value_address (val
),
791 stream
, recurse
, val
, options
,
792 language_def (language_ada
));
793 value_free_to_mark (mark
);
796 /* Implement Ada val_print'ing for the case where TYPE is
800 ada_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
801 int offset
, int offset_aligned
, CORE_ADDR address
,
802 struct ui_file
*stream
, int recurse
,
803 struct value
*original_value
,
804 const struct value_print_options
*options
)
806 val_print (type
, offset
, address
, stream
, recurse
,
807 original_value
, options
, language_def (language_c
));
809 if (ada_is_tag_type (type
))
812 value_from_contents_and_address (type
,
813 valaddr
+ offset_aligned
,
814 address
+ offset_aligned
);
815 const char *name
= ada_tag_name (val
);
818 fprintf_filtered (stream
, " (%s)", name
);
822 /* Implement Ada val_print'ing for the case where TYPE is
823 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
826 ada_val_print_num (struct type
*type
, const gdb_byte
*valaddr
,
827 int offset
, int offset_aligned
, CORE_ADDR address
,
828 struct ui_file
*stream
, int recurse
,
829 struct value
*original_value
,
830 const struct value_print_options
*options
)
832 if (ada_is_fixed_point_type (type
))
834 struct value
*scale
= ada_scaling_factor (type
);
835 struct value
*v
= value_from_contents (type
, valaddr
+ offset_aligned
);
836 v
= value_cast (value_type (scale
), v
);
837 v
= value_binop (v
, scale
, BINOP_MUL
);
839 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
841 = target_float_to_string (value_contents (v
), value_type (v
), fmt
);
842 fputs_filtered (str
.c_str (), stream
);
845 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
846 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
847 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
848 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
850 /* For enum-valued ranges, we want to recurse, because we'll end
851 up printing the constant's name rather than its numeric
852 value. Character and fixed-point types are also printed
853 differently, so recuse for those as well. */
854 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
856 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
858 /* Obscure case of range type that has different length from
859 its base type. Perform a conversion, or we will get a
860 nonsense value. Actually, we could use the same
861 code regardless of lengths; I'm just avoiding a cast. */
863 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
864 struct value
*v
= value_cast (target_type
, v1
);
866 val_print (target_type
,
867 value_embedded_offset (v
), 0, stream
,
868 recurse
+ 1, v
, options
,
869 language_def (language_ada
));
872 val_print (TYPE_TARGET_TYPE (type
), offset
,
873 address
, stream
, recurse
, original_value
,
874 options
, language_def (language_ada
));
879 int format
= (options
->format
? options
->format
880 : options
->output_format
);
884 struct value_print_options opts
= *options
;
886 opts
.format
= format
;
887 val_print_scalar_formatted (type
, offset_aligned
,
888 original_value
, &opts
, 0, stream
);
890 else if (ada_is_system_address_type (type
))
892 /* FIXME: We want to print System.Address variables using
893 the same format as for any access type. But for some
894 reason GNAT encodes the System.Address type as an int,
895 so we have to work-around this deficiency by handling
896 System.Address values as a special case. */
898 struct gdbarch
*gdbarch
= get_type_arch (type
);
899 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
900 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
903 fprintf_filtered (stream
, "(");
904 type_print (type
, "", stream
, -1);
905 fprintf_filtered (stream
, ") ");
906 fputs_filtered (paddress (gdbarch
, addr
), stream
);
910 val_print_scalar_formatted (type
, offset_aligned
,
911 original_value
, options
, 0, stream
);
912 if (ada_is_character_type (type
))
916 fputs_filtered (" ", stream
);
917 c
= unpack_long (type
, valaddr
+ offset_aligned
);
918 ada_printchar (c
, type
, stream
);
925 /* Implement Ada val_print'ing for the case where TYPE is
929 ada_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
930 int offset
, int offset_aligned
, CORE_ADDR address
,
931 struct ui_file
*stream
, int recurse
,
932 struct value
*original_value
,
933 const struct value_print_options
*options
)
941 val_print_scalar_formatted (type
, offset_aligned
,
942 original_value
, options
, 0, stream
);
946 len
= TYPE_NFIELDS (type
);
947 val
= unpack_long (type
, valaddr
+ offset_aligned
);
948 for (i
= 0; i
< len
; i
++)
951 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
957 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
960 fprintf_filtered (stream
, "%ld %ps", (long) val
,
961 styled_string (variable_name_style
.style (),
964 fputs_styled (name
, variable_name_style
.style (), stream
);
967 print_longest (stream
, 'd', 0, val
);
970 /* Implement Ada val_print'ing for the case where TYPE is
974 ada_val_print_flt (struct type
*type
, const gdb_byte
*valaddr
,
975 int offset
, int offset_aligned
, CORE_ADDR address
,
976 struct ui_file
*stream
, int recurse
,
977 struct value
*original_value
,
978 const struct value_print_options
*options
)
982 val_print (type
, offset
, address
, stream
, recurse
,
983 original_value
, options
, language_def (language_c
));
987 ada_print_floating (valaddr
+ offset
, type
, stream
);
990 /* Implement Ada val_print'ing for the case where TYPE is
991 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
994 ada_val_print_struct_union
995 (struct type
*type
, const gdb_byte
*valaddr
, int offset
,
996 int offset_aligned
, CORE_ADDR address
, struct ui_file
*stream
,
997 int recurse
, struct value
*original_value
,
998 const struct value_print_options
*options
)
1000 if (ada_is_bogus_array_descriptor (type
))
1002 fprintf_filtered (stream
, "(...?)");
1006 fprintf_filtered (stream
, "(");
1008 if (print_field_values (type
, valaddr
, offset_aligned
,
1009 stream
, recurse
, original_value
, options
,
1010 0, type
, offset_aligned
,
1011 language_def (language_ada
)) != 0
1012 && options
->prettyformat
)
1014 fprintf_filtered (stream
, "\n");
1015 print_spaces_filtered (2 * recurse
, stream
);
1018 fprintf_filtered (stream
, ")");
1021 /* Implement Ada val_print'ing for the case where TYPE is
1022 a TYPE_CODE_ARRAY. */
1025 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
1026 int offset
, int offset_aligned
, CORE_ADDR address
,
1027 struct ui_file
*stream
, int recurse
,
1028 struct value
*original_value
,
1029 const struct value_print_options
*options
)
1031 /* For an array of characters, print with string syntax. */
1032 if (ada_is_string_type (type
)
1033 && (options
->format
== 0 || options
->format
== 's'))
1035 ada_val_print_string (type
, valaddr
, offset
, offset_aligned
,
1036 address
, stream
, recurse
, original_value
,
1041 fprintf_filtered (stream
, "(");
1042 print_optional_low_bound (stream
, type
, options
);
1043 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
1044 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
1046 original_value
, options
);
1048 val_print_array_elements (type
, offset_aligned
, address
,
1049 stream
, recurse
, original_value
,
1051 fprintf_filtered (stream
, ")");
1054 /* Implement Ada val_print'ing for the case where TYPE is
1058 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
1059 int offset
, int offset_aligned
, CORE_ADDR address
,
1060 struct ui_file
*stream
, int recurse
,
1061 struct value
*original_value
,
1062 const struct value_print_options
*options
)
1064 /* For references, the debugger is expected to print the value as
1065 an address if DEREF_REF is null. But printing an address in place
1066 of the object value would be confusing to an Ada programmer.
1067 So, for Ada values, we print the actual dereferenced value
1069 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1070 struct value
*deref_val
;
1071 CORE_ADDR deref_val_int
;
1073 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1075 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
1080 deref_val
= coerce_ref_if_computed (original_value
);
1083 if (ada_is_tagged_type (value_type (deref_val
), 1))
1084 deref_val
= ada_tag_value_at_base_address (deref_val
);
1086 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1087 language_def (language_ada
));
1091 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1092 if (deref_val_int
== 0)
1094 fputs_filtered ("(null)", stream
);
1099 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1101 if (ada_is_tagged_type (value_type (deref_val
), 1))
1102 deref_val
= ada_tag_value_at_base_address (deref_val
);
1104 /* Make sure that the object does not have an unreasonable size
1105 before trying to print it. This can happen for instance with
1106 references to dynamic objects whose contents is uninitialized
1107 (Eg: an array whose bounds are not set yet). */
1108 ada_ensure_varsize_limit (value_type (deref_val
));
1110 if (value_lazy (deref_val
))
1111 value_fetch_lazy (deref_val
);
1113 val_print (value_type (deref_val
),
1114 value_embedded_offset (deref_val
),
1115 value_address (deref_val
), stream
, recurse
+ 1,
1116 deref_val
, options
, language_def (language_ada
));
1119 /* See the comment on ada_val_print. This function differs in that it
1120 does not catch evaluation errors (leaving that to ada_val_print). */
1123 ada_val_print_1 (struct type
*type
,
1124 int offset
, CORE_ADDR address
,
1125 struct ui_file
*stream
, int recurse
,
1126 struct value
*original_value
,
1127 const struct value_print_options
*options
)
1130 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
1132 type
= ada_check_typedef (type
);
1134 if (ada_is_array_descriptor_type (type
)
1135 || (ada_is_constrained_packed_array_type (type
)
1136 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1138 ada_val_print_gnat_array (type
, valaddr
, offset
, address
,
1139 stream
, recurse
, original_value
,
1144 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1145 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
1146 type
= resolve_dynamic_type (type
, valaddr
+ offset_aligned
,
1147 address
+ offset_aligned
);
1149 switch (TYPE_CODE (type
))
1152 val_print (type
, offset
, address
, stream
, recurse
,
1153 original_value
, options
, language_def (language_c
));
1157 ada_val_print_ptr (type
, valaddr
, offset
, offset_aligned
,
1158 address
, stream
, recurse
, original_value
,
1163 case TYPE_CODE_RANGE
:
1164 ada_val_print_num (type
, valaddr
, offset
, offset_aligned
,
1165 address
, stream
, recurse
, original_value
,
1169 case TYPE_CODE_ENUM
:
1170 ada_val_print_enum (type
, valaddr
, offset
, offset_aligned
,
1171 address
, stream
, recurse
, original_value
,
1176 ada_val_print_flt (type
, valaddr
, offset
, offset_aligned
,
1177 address
, stream
, recurse
, original_value
,
1181 case TYPE_CODE_UNION
:
1182 case TYPE_CODE_STRUCT
:
1183 ada_val_print_struct_union (type
, valaddr
, offset
, offset_aligned
,
1184 address
, stream
, recurse
,
1185 original_value
, options
);
1188 case TYPE_CODE_ARRAY
:
1189 ada_val_print_array (type
, valaddr
, offset
, offset_aligned
,
1190 address
, stream
, recurse
, original_value
,
1195 ada_val_print_ref (type
, valaddr
, offset
, offset_aligned
,
1196 address
, stream
, recurse
, original_value
,
1202 /* See val_print for a description of the various parameters of this
1203 function; they are identical. */
1206 ada_val_print (struct type
*type
,
1207 int embedded_offset
, CORE_ADDR address
,
1208 struct ui_file
*stream
, int recurse
,
1210 const struct value_print_options
*options
)
1214 ada_val_print_1 (type
, embedded_offset
, address
,
1215 stream
, recurse
, val
, options
);
1217 catch (const gdb_exception_error
&except
)
1219 fprintf_styled (stream
, metadata_style
.style (),
1220 _("<error reading variable: %s>"),
1226 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1227 const struct value_print_options
*options
)
1229 struct value
*val
= ada_to_fixed_value (val0
);
1230 CORE_ADDR address
= value_address (val
);
1231 struct type
*type
= ada_check_typedef (value_type (val
));
1232 struct value_print_options opts
;
1234 /* If it is a pointer, indicate what it points to. */
1235 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1237 /* Hack: don't print (char *) for char strings. Their
1238 type is indicated by the quoted string anyway. */
1239 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1240 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1241 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1243 fprintf_filtered (stream
, "(");
1244 type_print (type
, "", stream
, -1);
1245 fprintf_filtered (stream
, ") ");
1248 else if (ada_is_array_descriptor_type (type
))
1250 /* We do not print the type description unless TYPE is an array
1251 access type (this is encoded by the compiler as a typedef to
1252 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1253 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1255 fprintf_filtered (stream
, "(");
1256 type_print (type
, "", stream
, -1);
1257 fprintf_filtered (stream
, ") ");
1260 else if (ada_is_bogus_array_descriptor (type
))
1262 fprintf_filtered (stream
, "(");
1263 type_print (type
, "", stream
, -1);
1264 fprintf_filtered (stream
, ") (...?)");
1271 value_embedded_offset (val
), address
,
1272 stream
, 0, val
, &opts
, current_language
);