1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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/>. */
24 #include "expression.h"
34 #include "target-float.h"
36 static int print_field_values (struct type
*, const gdb_byte
*,
38 struct ui_file
*, int,
40 const struct value_print_options
*,
41 int, struct type
*, int,
42 const struct language_defn
*);
45 /* Make TYPE unsigned if its range of values includes no negatives. */
47 adjust_type_signedness (struct type
*type
)
49 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
50 && TYPE_LOW_BOUND (type
) >= 0)
51 TYPE_UNSIGNED (type
) = 1;
54 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
55 if non-standard (i.e., other than 1 for numbers, other than lower bound
56 of index type for enumerated type). Returns 1 if something printed,
60 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
61 const struct value_print_options
*options
)
63 struct type
*index_type
;
67 if (options
->print_array_indexes
)
70 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
73 /* If this is an empty array, then don't print the lower bound.
74 That would be confusing, because we would print the lower bound,
75 followed by... nothing! */
76 if (low_bound
> high_bound
)
79 index_type
= TYPE_INDEX_TYPE (type
);
81 while (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
83 /* We need to know what the base type is, in order to do the
84 appropriate check below. Otherwise, if this is a subrange
85 of an enumerated type, where the underlying value of the
86 first element is typically 0, we might test the low bound
87 against the wrong value. */
88 index_type
= TYPE_TARGET_TYPE (index_type
);
91 /* Don't print the lower bound if it's the default one. */
92 switch (TYPE_CODE (index_type
))
100 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
103 case TYPE_CODE_UNDEF
:
112 ada_print_scalar (index_type
, low_bound
, stream
);
113 fprintf_filtered (stream
, " => ");
117 /* Version of val_print_array_elements for GNAT-style packed arrays.
118 Prints elements of packed array of type TYPE at bit offset
119 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
120 separates with commas. RECURSE is the recursion (nesting) level.
121 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
124 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
126 int bitoffset
, struct ui_file
*stream
,
129 const struct value_print_options
*options
)
132 unsigned int things_printed
= 0;
134 struct type
*elttype
, *index_type
;
135 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
136 struct value
*mark
= value_mark ();
139 elttype
= TYPE_TARGET_TYPE (type
);
140 index_type
= TYPE_INDEX_TYPE (type
);
144 struct type
*base_index_type
;
146 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
149 len
= high
- low
+ 1;
151 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
152 base_index_type
= TYPE_TARGET_TYPE (index_type
);
154 base_index_type
= index_type
;
156 if (TYPE_CODE (base_index_type
) == TYPE_CODE_ENUM
)
158 LONGEST low_pos
, high_pos
;
160 /* Non-contiguous enumerations types can by used as index types
161 so the array length is computed from the positions of the
162 first and last literal in the enumeration type, and not from
163 the values of these literals. */
165 if (!discrete_position (base_index_type
, low
, &low_pos
)
166 || !discrete_position (base_index_type
, high
, &high_pos
))
168 warning (_("unable to get positions in array, use bounds instead"));
173 /* The array length should normally be HIGH_POS - LOW_POS + 1.
174 But in Ada we allow LOW_POS to be greater than HIGH_POS for
175 empty arrays. In that situation, the array length is just zero,
178 if (low_pos
> high_pos
)
181 len
= high_pos
- low_pos
+ 1;
186 annotate_array_section_begin (i
, elttype
);
188 while (i
< len
&& things_printed
< options
->print_max
)
190 struct value
*v0
, *v1
;
195 if (options
->prettyformat_arrays
)
197 fprintf_filtered (stream
, ",\n");
198 print_spaces_filtered (2 + 2 * recurse
, stream
);
202 fprintf_filtered (stream
, ", ");
205 wrap_here (n_spaces (2 + 2 * recurse
));
206 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
209 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
210 (i0
* bitsize
) / HOST_CHAR_BIT
,
211 (i0
* bitsize
) % HOST_CHAR_BIT
,
218 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
219 (i
* bitsize
) / HOST_CHAR_BIT
,
220 (i
* bitsize
) % HOST_CHAR_BIT
,
222 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
223 != TYPE_LENGTH (check_typedef (value_type (v1
))))
225 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
226 v1
, value_embedded_offset (v1
),
227 TYPE_LENGTH (check_typedef (value_type (v0
)))))
231 if (i
- i0
> options
->repeat_count_threshold
)
233 struct value_print_options opts
= *options
;
237 value_embedded_offset (v0
), 0, stream
,
238 recurse
+ 1, v0
, &opts
, current_language
);
239 annotate_elt_rep (i
- i0
);
240 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
241 annotate_elt_rep_end ();
247 struct value_print_options opts
= *options
;
250 for (j
= i0
; j
< i
; j
+= 1)
254 if (options
->prettyformat_arrays
)
256 fprintf_filtered (stream
, ",\n");
257 print_spaces_filtered (2 + 2 * recurse
, stream
);
261 fprintf_filtered (stream
, ", ");
263 wrap_here (n_spaces (2 + 2 * recurse
));
264 maybe_print_array_index (index_type
, j
+ low
,
268 value_embedded_offset (v0
), 0, stream
,
269 recurse
+ 1, v0
, &opts
, current_language
);
273 things_printed
+= i
- i0
;
275 annotate_array_section_end ();
278 fprintf_filtered (stream
, "...");
281 value_free_to_mark (mark
);
285 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
287 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
290 /* Print the character C on STREAM as part of the contents of a literal
291 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
295 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
296 int quoter
, int type_len
)
298 /* If this character fits in the normal ASCII range, and is
299 a printable character, then print the character as if it was
300 an ASCII character, even if this is a wide character.
301 The UCHAR_MAX check is necessary because the isascii function
302 requires that its argument have a value of an unsigned char,
303 or EOF (EOF is obviously not printable). */
304 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
306 if (c
== quoter
&& c
== '"')
307 fprintf_filtered (stream
, "\"\"");
309 fprintf_filtered (stream
, "%c", c
);
312 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
315 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
319 char_at (const gdb_byte
*string
, int i
, int type_len
,
320 enum bfd_endian byte_order
)
325 return (int) extract_unsigned_integer (string
+ type_len
* i
,
326 type_len
, byte_order
);
329 /* Print a floating-point value of type TYPE, pointed to in GDB by
330 VALADDR, on STREAM. Use Ada formatting conventions: there must be
331 a decimal point, and at least one digit before and after the
332 point. We use the GNAT format for NaNs and infinities. */
335 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
336 struct ui_file
*stream
)
338 string_file tmp_stream
;
340 print_floating (valaddr
, type
, &tmp_stream
);
342 std::string
&s
= tmp_stream
.string ();
343 size_t skip_count
= 0;
345 /* Modify for Ada rules. */
347 size_t pos
= s
.find ("inf");
348 if (pos
== std::string::npos
)
349 pos
= s
.find ("Inf");
350 if (pos
== std::string::npos
)
351 pos
= s
.find ("INF");
352 if (pos
!= std::string::npos
)
353 s
.replace (pos
, 3, "Inf");
355 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
)
361 pos
= s
.find ("Nan");
362 if (pos
!= std::string::npos
)
364 s
[pos
] = s
[pos
+ 2] = 'N';
370 if (pos
== std::string::npos
371 && s
.find ('.') == std::string::npos
)
374 if (pos
== std::string::npos
)
375 fprintf_filtered (stream
, "%s.0", s
.c_str ());
377 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
380 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
384 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
386 fputs_filtered ("'", stream
);
387 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
388 fputs_filtered ("'", stream
);
391 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
392 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
393 like a default signed integer. */
396 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
403 print_longest (stream
, 'd', 0, val
);
407 type
= ada_check_typedef (type
);
409 switch (TYPE_CODE (type
))
413 len
= TYPE_NFIELDS (type
);
414 for (i
= 0; i
< len
; i
++)
416 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
423 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
427 print_longest (stream
, 'd', 0, val
);
432 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
436 LA_PRINT_CHAR (val
, type
, stream
);
440 fprintf_filtered (stream
, val
? "true" : "false");
443 case TYPE_CODE_RANGE
:
444 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
447 case TYPE_CODE_UNDEF
:
449 case TYPE_CODE_ARRAY
:
450 case TYPE_CODE_STRUCT
:
451 case TYPE_CODE_UNION
:
456 case TYPE_CODE_STRING
:
457 case TYPE_CODE_ERROR
:
458 case TYPE_CODE_MEMBERPTR
:
459 case TYPE_CODE_METHODPTR
:
460 case TYPE_CODE_METHOD
:
462 warning (_("internal error: unhandled type in ada_print_scalar"));
466 error (_("Invalid type code in symbol table."));
470 /* Print the character string STRING, printing at most LENGTH characters.
471 Printing stops early if the number hits print_max; repeat counts
472 are printed as appropriate. Print ellipses at the end if we
473 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
474 TYPE_LEN is the length (1 or 2) of the character type. */
477 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
478 unsigned int length
, int force_ellipses
, int type_len
,
479 const struct value_print_options
*options
)
481 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
483 unsigned int things_printed
= 0;
489 fputs_filtered ("\"\"", stream
);
493 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
495 /* Position of the character we are examining
496 to see whether it is repeated. */
498 /* Number of repetitions we have detected so far. */
505 fputs_filtered (", ", stream
);
512 && char_at (string
, rep1
, type_len
, byte_order
)
513 == char_at (string
, i
, type_len
, byte_order
))
519 if (reps
> options
->repeat_count_threshold
)
523 fputs_filtered ("\", ", stream
);
526 fputs_filtered ("'", stream
);
527 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
528 elttype
, stream
, '\'', type_len
);
529 fputs_filtered ("'", stream
);
530 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
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_filtered (_("<optimized out or zero length>"), stream
);
679 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
680 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
681 struct value_print_options opts
;
683 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
684 v
= ada_value_primitive_packed_val
686 offset
+ bit_pos
/ HOST_CHAR_BIT
,
687 bit_pos
% HOST_CHAR_BIT
,
688 bit_size
, TYPE_FIELD_TYPE (type
, i
));
691 val_print (TYPE_FIELD_TYPE (type
, i
),
692 value_embedded_offset (v
), 0,
693 stream
, recurse
+ 1, v
,
699 struct value_print_options opts
= *options
;
702 val_print (TYPE_FIELD_TYPE (type
, i
),
703 (offset
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
704 0, stream
, recurse
+ 1, val
, &opts
, language
);
706 annotate_field_end ();
712 /* Implement Ada val_print'ing for the case where TYPE is
713 a TYPE_CODE_ARRAY of characters. */
716 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
717 int offset
, int offset_aligned
, CORE_ADDR address
,
718 struct ui_file
*stream
, int recurse
,
719 struct value
*original_value
,
720 const struct value_print_options
*options
)
722 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
723 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
727 /* We know that ELTTYPE cannot possibly be null, because we assume
728 that we're called only when TYPE is a string-like type.
729 Similarly, the size of ELTTYPE should also be non-null, since
730 it's a character-like type. */
731 gdb_assert (elttype
!= NULL
);
732 gdb_assert (TYPE_LENGTH (elttype
) != 0);
734 eltlen
= TYPE_LENGTH (elttype
);
735 len
= TYPE_LENGTH (type
) / eltlen
;
737 if (options
->prettyformat_arrays
)
738 print_spaces_filtered (2 + 2 * recurse
, stream
);
740 /* If requested, look for the first null char and only print
741 elements up to it. */
742 if (options
->stop_print_at_null
)
746 /* Look for a NULL char. */
749 && temp_len
< options
->print_max
750 && char_at (valaddr
+ offset_aligned
,
751 temp_len
, eltlen
, byte_order
) != 0);
756 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
760 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
761 thin pointers, etc). */
764 ada_val_print_gnat_array (struct type
*type
, const gdb_byte
*valaddr
,
765 int offset
, CORE_ADDR address
,
766 struct ui_file
*stream
, int recurse
,
767 struct value
*original_value
,
768 const struct value_print_options
*options
)
770 struct value
*mark
= value_mark ();
773 val
= value_from_contents_and_address (type
, valaddr
+ offset
, address
);
774 /* If this is a reference, coerce it now. This helps taking care
775 of the case where ADDRESS is meaningless because original_value
777 val
= coerce_ref (val
);
778 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
779 val
= ada_coerce_to_simple_array_ptr (val
);
781 val
= ada_coerce_to_simple_array (val
);
784 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
785 fprintf_filtered (stream
, "0x0");
788 val_print (value_type (val
),
789 value_embedded_offset (val
), value_address (val
),
790 stream
, recurse
, val
, options
,
791 language_def (language_ada
));
792 value_free_to_mark (mark
);
795 /* Implement Ada val_print'ing for the case where TYPE is
799 ada_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
800 int offset
, int offset_aligned
, CORE_ADDR address
,
801 struct ui_file
*stream
, int recurse
,
802 struct value
*original_value
,
803 const struct value_print_options
*options
)
805 val_print (type
, offset
, address
, stream
, recurse
,
806 original_value
, options
, language_def (language_c
));
808 if (ada_is_tag_type (type
))
811 value_from_contents_and_address (type
,
812 valaddr
+ offset_aligned
,
813 address
+ offset_aligned
);
814 const char *name
= ada_tag_name (val
);
817 fprintf_filtered (stream
, " (%s)", name
);
821 /* Implement Ada val_print'ing for the case where TYPE is
822 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
825 ada_val_print_num (struct type
*type
, const gdb_byte
*valaddr
,
826 int offset
, int offset_aligned
, CORE_ADDR address
,
827 struct ui_file
*stream
, int recurse
,
828 struct value
*original_value
,
829 const struct value_print_options
*options
)
831 if (ada_is_fixed_point_type (type
))
833 struct value
*scale
= ada_scaling_factor (type
);
834 struct value
*v
= value_from_contents (type
, valaddr
+ offset_aligned
);
835 v
= value_cast (value_type (scale
), v
);
836 v
= value_binop (v
, scale
, BINOP_MUL
);
838 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
840 = target_float_to_string (value_contents (v
), value_type (v
), fmt
);
841 fputs_filtered (str
.c_str (), stream
);
844 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
845 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
846 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
847 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
849 /* For enum-valued ranges, we want to recurse, because we'll end
850 up printing the constant's name rather than its numeric
851 value. Character and fixed-point types are also printed
852 differently, so recuse for those as well. */
853 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
855 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
857 /* Obscure case of range type that has different length from
858 its base type. Perform a conversion, or we will get a
859 nonsense value. Actually, we could use the same
860 code regardless of lengths; I'm just avoiding a cast. */
862 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
863 struct value
*v
= value_cast (target_type
, v1
);
865 val_print (target_type
,
866 value_embedded_offset (v
), 0, stream
,
867 recurse
+ 1, v
, options
,
868 language_def (language_ada
));
871 val_print (TYPE_TARGET_TYPE (type
), offset
,
872 address
, stream
, recurse
, original_value
,
873 options
, language_def (language_ada
));
878 int format
= (options
->format
? options
->format
879 : options
->output_format
);
883 struct value_print_options opts
= *options
;
885 opts
.format
= format
;
886 val_print_scalar_formatted (type
, offset_aligned
,
887 original_value
, &opts
, 0, stream
);
889 else if (ada_is_system_address_type (type
))
891 /* FIXME: We want to print System.Address variables using
892 the same format as for any access type. But for some
893 reason GNAT encodes the System.Address type as an int,
894 so we have to work-around this deficiency by handling
895 System.Address values as a special case. */
897 struct gdbarch
*gdbarch
= get_type_arch (type
);
898 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
899 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
902 fprintf_filtered (stream
, "(");
903 type_print (type
, "", stream
, -1);
904 fprintf_filtered (stream
, ") ");
905 fputs_filtered (paddress (gdbarch
, addr
), stream
);
909 val_print_scalar_formatted (type
, offset_aligned
,
910 original_value
, options
, 0, stream
);
911 if (ada_is_character_type (type
))
915 fputs_filtered (" ", stream
);
916 c
= unpack_long (type
, valaddr
+ offset_aligned
);
917 ada_printchar (c
, type
, stream
);
924 /* Implement Ada val_print'ing for the case where TYPE is
928 ada_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
929 int offset
, int offset_aligned
, CORE_ADDR address
,
930 struct ui_file
*stream
, int recurse
,
931 struct value
*original_value
,
932 const struct value_print_options
*options
)
940 val_print_scalar_formatted (type
, offset_aligned
,
941 original_value
, options
, 0, stream
);
945 len
= TYPE_NFIELDS (type
);
946 val
= unpack_long (type
, valaddr
+ offset_aligned
);
947 for (i
= 0; i
< len
; i
++)
950 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
956 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
959 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
961 fputs_filtered (name
, stream
);
964 print_longest (stream
, 'd', 0, val
);
967 /* Implement Ada val_print'ing for the case where TYPE is
971 ada_val_print_flt (struct type
*type
, const gdb_byte
*valaddr
,
972 int offset
, int offset_aligned
, CORE_ADDR address
,
973 struct ui_file
*stream
, int recurse
,
974 struct value
*original_value
,
975 const struct value_print_options
*options
)
979 val_print (type
, offset
, address
, stream
, recurse
,
980 original_value
, options
, language_def (language_c
));
984 ada_print_floating (valaddr
+ offset
, type
, stream
);
987 /* Implement Ada val_print'ing for the case where TYPE is
988 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
991 ada_val_print_struct_union
992 (struct type
*type
, const gdb_byte
*valaddr
, int offset
,
993 int offset_aligned
, CORE_ADDR address
, struct ui_file
*stream
,
994 int recurse
, struct value
*original_value
,
995 const struct value_print_options
*options
)
997 if (ada_is_bogus_array_descriptor (type
))
999 fprintf_filtered (stream
, "(...?)");
1003 fprintf_filtered (stream
, "(");
1005 if (print_field_values (type
, valaddr
, offset_aligned
,
1006 stream
, recurse
, original_value
, options
,
1007 0, type
, offset_aligned
,
1008 language_def (language_ada
)) != 0
1009 && options
->prettyformat
)
1011 fprintf_filtered (stream
, "\n");
1012 print_spaces_filtered (2 * recurse
, stream
);
1015 fprintf_filtered (stream
, ")");
1018 /* Implement Ada val_print'ing for the case where TYPE is
1019 a TYPE_CODE_ARRAY. */
1022 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
1023 int offset
, int offset_aligned
, CORE_ADDR address
,
1024 struct ui_file
*stream
, int recurse
,
1025 struct value
*original_value
,
1026 const struct value_print_options
*options
)
1028 /* For an array of characters, print with string syntax. */
1029 if (ada_is_string_type (type
)
1030 && (options
->format
== 0 || options
->format
== 's'))
1032 ada_val_print_string (type
, valaddr
, offset
, offset_aligned
,
1033 address
, stream
, recurse
, original_value
,
1038 fprintf_filtered (stream
, "(");
1039 print_optional_low_bound (stream
, type
, options
);
1040 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
1041 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
1043 original_value
, options
);
1045 val_print_array_elements (type
, offset_aligned
, address
,
1046 stream
, recurse
, original_value
,
1048 fprintf_filtered (stream
, ")");
1051 /* Implement Ada val_print'ing for the case where TYPE is
1055 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
1056 int offset
, int offset_aligned
, CORE_ADDR address
,
1057 struct ui_file
*stream
, int recurse
,
1058 struct value
*original_value
,
1059 const struct value_print_options
*options
)
1061 /* For references, the debugger is expected to print the value as
1062 an address if DEREF_REF is null. But printing an address in place
1063 of the object value would be confusing to an Ada programmer.
1064 So, for Ada values, we print the actual dereferenced value
1066 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1067 struct value
*deref_val
;
1068 CORE_ADDR deref_val_int
;
1070 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1072 fputs_filtered ("<ref to undefined type>", stream
);
1076 deref_val
= coerce_ref_if_computed (original_value
);
1079 if (ada_is_tagged_type (value_type (deref_val
), 1))
1080 deref_val
= ada_tag_value_at_base_address (deref_val
);
1082 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1083 language_def (language_ada
));
1087 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1088 if (deref_val_int
== 0)
1090 fputs_filtered ("(null)", stream
);
1095 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1097 if (ada_is_tagged_type (value_type (deref_val
), 1))
1098 deref_val
= ada_tag_value_at_base_address (deref_val
);
1100 /* Make sure that the object does not have an unreasonable size
1101 before trying to print it. This can happen for instance with
1102 references to dynamic objects whose contents is uninitialized
1103 (Eg: an array whose bounds are not set yet). */
1104 ada_ensure_varsize_limit (value_type (deref_val
));
1106 if (value_lazy (deref_val
))
1107 value_fetch_lazy (deref_val
);
1109 val_print (value_type (deref_val
),
1110 value_embedded_offset (deref_val
),
1111 value_address (deref_val
), stream
, recurse
+ 1,
1112 deref_val
, options
, language_def (language_ada
));
1115 /* See the comment on ada_val_print. This function differs in that it
1116 does not catch evaluation errors (leaving that to ada_val_print). */
1119 ada_val_print_1 (struct type
*type
,
1120 int offset
, CORE_ADDR address
,
1121 struct ui_file
*stream
, int recurse
,
1122 struct value
*original_value
,
1123 const struct value_print_options
*options
)
1126 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
1128 type
= ada_check_typedef (type
);
1130 if (ada_is_array_descriptor_type (type
)
1131 || (ada_is_constrained_packed_array_type (type
)
1132 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1134 ada_val_print_gnat_array (type
, valaddr
, offset
, address
,
1135 stream
, recurse
, original_value
,
1140 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1141 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
1142 type
= resolve_dynamic_type (type
, valaddr
+ offset_aligned
,
1143 address
+ offset_aligned
);
1145 switch (TYPE_CODE (type
))
1148 val_print (type
, offset
, address
, stream
, recurse
,
1149 original_value
, options
, language_def (language_c
));
1153 ada_val_print_ptr (type
, valaddr
, offset
, offset_aligned
,
1154 address
, stream
, recurse
, original_value
,
1159 case TYPE_CODE_RANGE
:
1160 ada_val_print_num (type
, valaddr
, offset
, offset_aligned
,
1161 address
, stream
, recurse
, original_value
,
1165 case TYPE_CODE_ENUM
:
1166 ada_val_print_enum (type
, valaddr
, offset
, offset_aligned
,
1167 address
, stream
, recurse
, original_value
,
1172 ada_val_print_flt (type
, valaddr
, offset
, offset_aligned
,
1173 address
, stream
, recurse
, original_value
,
1177 case TYPE_CODE_UNION
:
1178 case TYPE_CODE_STRUCT
:
1179 ada_val_print_struct_union (type
, valaddr
, offset
, offset_aligned
,
1180 address
, stream
, recurse
,
1181 original_value
, options
);
1184 case TYPE_CODE_ARRAY
:
1185 ada_val_print_array (type
, valaddr
, offset
, offset_aligned
,
1186 address
, stream
, recurse
, original_value
,
1191 ada_val_print_ref (type
, valaddr
, offset
, offset_aligned
,
1192 address
, stream
, recurse
, original_value
,
1198 /* See val_print for a description of the various parameters of this
1199 function; they are identical. */
1202 ada_val_print (struct type
*type
,
1203 int embedded_offset
, CORE_ADDR address
,
1204 struct ui_file
*stream
, int recurse
,
1206 const struct value_print_options
*options
)
1210 ada_val_print_1 (type
, embedded_offset
, address
,
1211 stream
, recurse
, val
, options
);
1213 catch (const gdb_exception_error
&except
)
1215 fprintf_filtered (stream
, _("<error reading variable: %s>"),
1221 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1222 const struct value_print_options
*options
)
1224 struct value
*val
= ada_to_fixed_value (val0
);
1225 CORE_ADDR address
= value_address (val
);
1226 struct type
*type
= ada_check_typedef (value_type (val
));
1227 struct value_print_options opts
;
1229 /* If it is a pointer, indicate what it points to. */
1230 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1232 /* Hack: don't print (char *) for char strings. Their
1233 type is indicated by the quoted string anyway. */
1234 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1235 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1236 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1238 fprintf_filtered (stream
, "(");
1239 type_print (type
, "", stream
, -1);
1240 fprintf_filtered (stream
, ") ");
1243 else if (ada_is_array_descriptor_type (type
))
1245 /* We do not print the type description unless TYPE is an array
1246 access type (this is encoded by the compiler as a typedef to
1247 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1248 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1250 fprintf_filtered (stream
, "(");
1251 type_print (type
, "", stream
, -1);
1252 fprintf_filtered (stream
, ") ");
1255 else if (ada_is_bogus_array_descriptor (type
))
1257 fprintf_filtered (stream
, "(");
1258 type_print (type
, "", stream
, -1);
1259 fprintf_filtered (stream
, ") (...?)");
1266 value_embedded_offset (val
), address
,
1267 stream
, 0, val
, &opts
, current_language
);