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/>. */
22 /* Standard C includes. */
25 /* Local non-gdb includes. */
30 #include "expression.h"
36 #include "target-float.h"
40 static int print_field_values (struct type
*, const gdb_byte
*,
42 struct ui_file
*, int,
44 const struct value_print_options
*,
45 int, struct type
*, int,
46 const struct language_defn
*);
49 /* Make TYPE unsigned if its range of values includes no negatives. */
51 adjust_type_signedness (struct type
*type
)
53 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
54 && TYPE_LOW_BOUND (type
) >= 0)
55 TYPE_UNSIGNED (type
) = 1;
58 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
59 if non-standard (i.e., other than 1 for numbers, other than lower bound
60 of index type for enumerated type). Returns 1 if something printed,
64 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
65 const struct value_print_options
*options
)
67 struct type
*index_type
;
71 if (options
->print_array_indexes
)
74 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
77 /* If this is an empty array, then don't print the lower bound.
78 That would be confusing, because we would print the lower bound,
79 followed by... nothing! */
80 if (low_bound
> high_bound
)
83 index_type
= TYPE_INDEX_TYPE (type
);
85 while (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
87 /* We need to know what the base type is, in order to do the
88 appropriate check below. Otherwise, if this is a subrange
89 of an enumerated type, where the underlying value of the
90 first element is typically 0, we might test the low bound
91 against the wrong value. */
92 index_type
= TYPE_TARGET_TYPE (index_type
);
95 /* Don't print the lower bound if it's the default one. */
96 switch (TYPE_CODE (index_type
))
104 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
107 case TYPE_CODE_UNDEF
:
116 ada_print_scalar (index_type
, low_bound
, stream
);
117 fprintf_filtered (stream
, " => ");
121 /* Version of val_print_array_elements for GNAT-style packed arrays.
122 Prints elements of packed array of type TYPE at bit offset
123 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
124 separates with commas. RECURSE is the recursion (nesting) level.
125 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
128 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
130 int bitoffset
, struct ui_file
*stream
,
133 const struct value_print_options
*options
)
136 unsigned int things_printed
= 0;
138 struct type
*elttype
, *index_type
;
139 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
140 struct value
*mark
= value_mark ();
143 elttype
= TYPE_TARGET_TYPE (type
);
144 index_type
= TYPE_INDEX_TYPE (type
);
148 struct type
*base_index_type
;
150 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
153 len
= high
- low
+ 1;
155 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
156 base_index_type
= TYPE_TARGET_TYPE (index_type
);
158 base_index_type
= index_type
;
160 if (TYPE_CODE (base_index_type
) == TYPE_CODE_ENUM
)
162 LONGEST low_pos
, high_pos
;
164 /* Non-contiguous enumerations types can by used as index types
165 so the array length is computed from the positions of the
166 first and last literal in the enumeration type, and not from
167 the values of these literals. */
169 if (!discrete_position (base_index_type
, low
, &low_pos
)
170 || !discrete_position (base_index_type
, high
, &high_pos
))
172 warning (_("unable to get positions in array, use bounds instead"));
177 /* The array length should normally be HIGH_POS - LOW_POS + 1.
178 But in Ada we allow LOW_POS to be greater than HIGH_POS for
179 empty arrays. In that situation, the array length is just zero,
182 if (low_pos
> high_pos
)
185 len
= high_pos
- low_pos
+ 1;
190 annotate_array_section_begin (i
, elttype
);
192 while (i
< len
&& things_printed
< options
->print_max
)
194 struct value
*v0
, *v1
;
199 if (options
->prettyformat_arrays
)
201 fprintf_filtered (stream
, ",\n");
202 print_spaces_filtered (2 + 2 * recurse
, stream
);
206 fprintf_filtered (stream
, ", ");
209 wrap_here (n_spaces (2 + 2 * recurse
));
210 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
213 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
214 (i0
* bitsize
) / HOST_CHAR_BIT
,
215 (i0
* bitsize
) % HOST_CHAR_BIT
,
222 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
223 (i
* bitsize
) / HOST_CHAR_BIT
,
224 (i
* bitsize
) % HOST_CHAR_BIT
,
226 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
227 != TYPE_LENGTH (check_typedef (value_type (v1
))))
229 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
230 v1
, value_embedded_offset (v1
),
231 TYPE_LENGTH (check_typedef (value_type (v0
)))))
235 if (i
- i0
> options
->repeat_count_threshold
)
237 struct value_print_options opts
= *options
;
241 value_embedded_offset (v0
), 0, stream
,
242 recurse
+ 1, v0
, &opts
, current_language
);
243 annotate_elt_rep (i
- i0
);
244 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
245 annotate_elt_rep_end ();
251 struct value_print_options opts
= *options
;
254 for (j
= i0
; j
< i
; j
+= 1)
258 if (options
->prettyformat_arrays
)
260 fprintf_filtered (stream
, ",\n");
261 print_spaces_filtered (2 + 2 * recurse
, stream
);
265 fprintf_filtered (stream
, ", ");
267 wrap_here (n_spaces (2 + 2 * recurse
));
268 maybe_print_array_index (index_type
, j
+ low
,
272 value_embedded_offset (v0
), 0, stream
,
273 recurse
+ 1, v0
, &opts
, current_language
);
277 things_printed
+= i
- i0
;
279 annotate_array_section_end ();
282 fprintf_filtered (stream
, "...");
285 value_free_to_mark (mark
);
289 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
291 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
294 /* Print the character C on STREAM as part of the contents of a literal
295 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
299 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
300 int quoter
, int type_len
)
302 /* If this character fits in the normal ASCII range, and is
303 a printable character, then print the character as if it was
304 an ASCII character, even if this is a wide character.
305 The UCHAR_MAX check is necessary because the isascii function
306 requires that its argument have a value of an unsigned char,
307 or EOF (EOF is obviously not printable). */
308 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
310 if (c
== quoter
&& c
== '"')
311 fprintf_filtered (stream
, "\"\"");
313 fprintf_filtered (stream
, "%c", c
);
316 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
319 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
323 char_at (const gdb_byte
*string
, int i
, int type_len
,
324 enum bfd_endian byte_order
)
329 return (int) extract_unsigned_integer (string
+ type_len
* i
,
330 type_len
, byte_order
);
333 /* Print a floating-point value of type TYPE, pointed to in GDB by
334 VALADDR, on STREAM. Use Ada formatting conventions: there must be
335 a decimal point, and at least one digit before and after the
336 point. We use the GNAT format for NaNs and infinities. */
339 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
340 struct ui_file
*stream
)
342 string_file tmp_stream
;
344 print_floating (valaddr
, type
, &tmp_stream
);
346 std::string
&s
= tmp_stream
.string ();
347 size_t skip_count
= 0;
349 /* Modify for Ada rules. */
351 size_t pos
= s
.find ("inf");
352 if (pos
== std::string::npos
)
353 pos
= s
.find ("Inf");
354 if (pos
== std::string::npos
)
355 pos
= s
.find ("INF");
356 if (pos
!= std::string::npos
)
357 s
.replace (pos
, 3, "Inf");
359 if (pos
== std::string::npos
)
361 pos
= s
.find ("nan");
362 if (pos
== std::string::npos
)
363 pos
= s
.find ("NaN");
364 if (pos
== std::string::npos
)
365 pos
= s
.find ("Nan");
366 if (pos
!= std::string::npos
)
368 s
[pos
] = s
[pos
+ 2] = 'N';
374 if (pos
== std::string::npos
375 && s
.find ('.') == std::string::npos
)
378 if (pos
== std::string::npos
)
379 fprintf_filtered (stream
, "%s.0", s
.c_str ());
381 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
384 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
388 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
390 fputs_filtered ("'", stream
);
391 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
392 fputs_filtered ("'", stream
);
395 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
396 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
397 like a default signed integer. */
400 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
407 print_longest (stream
, 'd', 0, val
);
411 type
= ada_check_typedef (type
);
413 switch (TYPE_CODE (type
))
417 len
= TYPE_NFIELDS (type
);
418 for (i
= 0; i
< len
; i
++)
420 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
427 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
431 print_longest (stream
, 'd', 0, val
);
436 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
440 LA_PRINT_CHAR (val
, type
, stream
);
444 fprintf_filtered (stream
, val
? "true" : "false");
447 case TYPE_CODE_RANGE
:
448 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
451 case TYPE_CODE_UNDEF
:
453 case TYPE_CODE_ARRAY
:
454 case TYPE_CODE_STRUCT
:
455 case TYPE_CODE_UNION
:
460 case TYPE_CODE_STRING
:
461 case TYPE_CODE_ERROR
:
462 case TYPE_CODE_MEMBERPTR
:
463 case TYPE_CODE_METHODPTR
:
464 case TYPE_CODE_METHOD
:
466 warning (_("internal error: unhandled type in ada_print_scalar"));
470 error (_("Invalid type code in symbol table."));
474 /* Print the character string STRING, printing at most LENGTH characters.
475 Printing stops early if the number hits print_max; repeat counts
476 are printed as appropriate. Print ellipses at the end if we
477 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
478 TYPE_LEN is the length (1 or 2) of the character type. */
481 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
482 unsigned int length
, int force_ellipses
, int type_len
,
483 const struct value_print_options
*options
)
485 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
487 unsigned int things_printed
= 0;
493 fputs_filtered ("\"\"", stream
);
497 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
499 /* Position of the character we are examining
500 to see whether it is repeated. */
502 /* Number of repetitions we have detected so far. */
509 fputs_filtered (", ", stream
);
516 && char_at (string
, rep1
, type_len
, byte_order
)
517 == char_at (string
, i
, type_len
, byte_order
))
523 if (reps
> options
->repeat_count_threshold
)
527 fputs_filtered ("\", ", stream
);
530 fputs_filtered ("'", stream
);
531 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
532 elttype
, stream
, '\'', type_len
);
533 fputs_filtered ("'", stream
);
534 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
536 things_printed
+= options
->repeat_count_threshold
;
543 fputs_filtered ("\"", stream
);
546 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
547 elttype
, stream
, '"', type_len
);
552 /* Terminate the quotes if necessary. */
554 fputs_filtered ("\"", stream
);
556 if (force_ellipses
|| i
< length
)
557 fputs_filtered ("...", stream
);
561 ada_printstr (struct ui_file
*stream
, struct type
*type
,
562 const gdb_byte
*string
, unsigned int length
,
563 const char *encoding
, int force_ellipses
,
564 const struct value_print_options
*options
)
566 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
571 print_variant_part (struct type
*type
, int field_num
,
572 const gdb_byte
*valaddr
, int offset
,
573 struct ui_file
*stream
, int recurse
,
575 const struct value_print_options
*options
,
577 struct type
*outer_type
, int outer_offset
,
578 const struct language_defn
*language
)
580 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
581 int which
= ada_which_variant_applies (var_type
, outer_type
,
582 valaddr
+ outer_offset
);
587 return print_field_values
588 (TYPE_FIELD_TYPE (var_type
, which
),
590 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
591 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
592 stream
, recurse
, val
, options
,
593 comma_needed
, outer_type
, outer_offset
, language
);
596 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
598 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
599 meanings as in ada_print_value and ada_val_print.
601 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
602 record (used to get discriminant values when printing variant
605 COMMA_NEEDED is 1 if fields have been printed at the current recursion
606 level, so that a comma is needed before any field printed by this
609 Returns 1 if COMMA_NEEDED or any fields were printed. */
612 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
613 int offset
, struct ui_file
*stream
, int recurse
,
615 const struct value_print_options
*options
,
617 struct type
*outer_type
, int outer_offset
,
618 const struct language_defn
*language
)
622 len
= TYPE_NFIELDS (type
);
624 for (i
= 0; i
< len
; i
+= 1)
626 if (ada_is_ignored_field (type
, i
))
629 if (ada_is_wrapper_field (type
, i
))
632 print_field_values (TYPE_FIELD_TYPE (type
, i
),
635 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
636 stream
, recurse
, val
, options
,
637 comma_needed
, type
, offset
, language
);
640 else if (ada_is_variant_part (type
, i
))
643 print_variant_part (type
, i
, valaddr
,
644 offset
, stream
, recurse
, val
,
645 options
, comma_needed
,
646 outer_type
, outer_offset
, language
);
651 fprintf_filtered (stream
, ", ");
654 if (options
->prettyformat
)
656 fprintf_filtered (stream
, "\n");
657 print_spaces_filtered (2 + 2 * recurse
, stream
);
661 wrap_here (n_spaces (2 + 2 * recurse
));
664 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
665 fprintf_filtered (stream
, "%.*s",
666 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
667 TYPE_FIELD_NAME (type
, i
));
668 annotate_field_name_end ();
669 fputs_filtered (" => ", stream
);
670 annotate_field_value ();
672 if (TYPE_FIELD_PACKED (type
, i
))
674 /* Bitfields require special handling, especially due to byte
676 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
678 fputs_filtered (_("<optimized out or zero length>"), stream
);
683 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
684 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
685 struct value_print_options opts
;
687 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
688 v
= ada_value_primitive_packed_val
690 offset
+ bit_pos
/ HOST_CHAR_BIT
,
691 bit_pos
% HOST_CHAR_BIT
,
692 bit_size
, TYPE_FIELD_TYPE (type
, i
));
695 val_print (TYPE_FIELD_TYPE (type
, i
),
696 value_embedded_offset (v
), 0,
697 stream
, recurse
+ 1, v
,
703 struct value_print_options opts
= *options
;
706 val_print (TYPE_FIELD_TYPE (type
, i
),
707 (offset
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
708 0, stream
, recurse
+ 1, val
, &opts
, language
);
710 annotate_field_end ();
716 /* Implement Ada val_print'ing for the case where TYPE is
717 a TYPE_CODE_ARRAY of characters. */
720 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
721 int offset
, int offset_aligned
, CORE_ADDR address
,
722 struct ui_file
*stream
, int recurse
,
723 struct value
*original_value
,
724 const struct value_print_options
*options
)
726 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
727 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
731 /* We know that ELTTYPE cannot possibly be null, because we assume
732 that we're called only when TYPE is a string-like type.
733 Similarly, the size of ELTTYPE should also be non-null, since
734 it's a character-like type. */
735 gdb_assert (elttype
!= NULL
);
736 gdb_assert (TYPE_LENGTH (elttype
) != 0);
738 eltlen
= TYPE_LENGTH (elttype
);
739 len
= TYPE_LENGTH (type
) / eltlen
;
741 if (options
->prettyformat_arrays
)
742 print_spaces_filtered (2 + 2 * recurse
, stream
);
744 /* If requested, look for the first null char and only print
745 elements up to it. */
746 if (options
->stop_print_at_null
)
750 /* Look for a NULL char. */
753 && temp_len
< options
->print_max
754 && char_at (valaddr
+ offset_aligned
,
755 temp_len
, eltlen
, byte_order
) != 0);
760 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
764 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
765 thin pointers, etc). */
768 ada_val_print_gnat_array (struct type
*type
, const gdb_byte
*valaddr
,
769 int offset
, CORE_ADDR address
,
770 struct ui_file
*stream
, int recurse
,
771 struct value
*original_value
,
772 const struct value_print_options
*options
,
773 const struct language_defn
*language
)
775 struct value
*mark
= value_mark ();
778 val
= value_from_contents_and_address (type
, valaddr
+ offset
, address
);
779 /* If this is a reference, coerce it now. This helps taking care
780 of the case where ADDRESS is meaningless because original_value
782 val
= coerce_ref (val
);
783 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
784 val
= ada_coerce_to_simple_array_ptr (val
);
786 val
= ada_coerce_to_simple_array (val
);
789 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
790 fprintf_filtered (stream
, "0x0");
793 val_print (value_type (val
),
794 value_embedded_offset (val
), value_address (val
),
795 stream
, recurse
, val
, options
, language
);
796 value_free_to_mark (mark
);
799 /* Implement Ada val_print'ing for the case where TYPE is
803 ada_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
804 int offset
, int offset_aligned
, CORE_ADDR address
,
805 struct ui_file
*stream
, int recurse
,
806 struct value
*original_value
,
807 const struct value_print_options
*options
,
808 const struct language_defn
*language
)
810 val_print (type
, offset
, address
, stream
, recurse
,
811 original_value
, options
, language_def (language_c
));
813 if (ada_is_tag_type (type
))
816 value_from_contents_and_address (type
,
817 valaddr
+ offset_aligned
,
818 address
+ offset_aligned
);
819 const char *name
= ada_tag_name (val
);
822 fprintf_filtered (stream
, " (%s)", name
);
826 /* Implement Ada val_print'ing for the case where TYPE is
827 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
830 ada_val_print_num (struct type
*type
, const gdb_byte
*valaddr
,
831 int offset
, int offset_aligned
, CORE_ADDR address
,
832 struct ui_file
*stream
, int recurse
,
833 struct value
*original_value
,
834 const struct value_print_options
*options
,
835 const struct language_defn
*language
)
837 if (ada_is_fixed_point_type (type
))
839 struct value
*scale
= ada_scaling_factor (type
);
840 struct value
*v
= value_from_contents (type
, valaddr
+ offset_aligned
);
841 v
= value_cast (value_type (scale
), v
);
842 v
= value_binop (v
, scale
, BINOP_MUL
);
844 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
846 = target_float_to_string (value_contents (v
), value_type (v
), fmt
);
847 fputs_filtered (str
.c_str (), stream
);
850 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
852 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
854 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
856 /* Obscure case of range type that has different length from
857 its base type. Perform a conversion, or we will get a
858 nonsense value. Actually, we could use the same
859 code regardless of lengths; I'm just avoiding a cast. */
861 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
862 struct value
*v
= value_cast (target_type
, v1
);
864 val_print (target_type
,
865 value_embedded_offset (v
), 0, stream
,
866 recurse
+ 1, v
, options
, language
);
869 val_print (TYPE_TARGET_TYPE (type
), offset
,
870 address
, stream
, recurse
, original_value
,
876 int format
= (options
->format
? options
->format
877 : options
->output_format
);
881 struct value_print_options opts
= *options
;
883 opts
.format
= format
;
884 val_print_scalar_formatted (type
, offset_aligned
,
885 original_value
, &opts
, 0, stream
);
887 else if (ada_is_system_address_type (type
))
889 /* FIXME: We want to print System.Address variables using
890 the same format as for any access type. But for some
891 reason GNAT encodes the System.Address type as an int,
892 so we have to work-around this deficiency by handling
893 System.Address values as a special case. */
895 struct gdbarch
*gdbarch
= get_type_arch (type
);
896 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
897 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
900 fprintf_filtered (stream
, "(");
901 type_print (type
, "", stream
, -1);
902 fprintf_filtered (stream
, ") ");
903 fputs_filtered (paddress (gdbarch
, addr
), stream
);
907 val_print_scalar_formatted (type
, offset_aligned
,
908 original_value
, options
, 0, stream
);
909 if (ada_is_character_type (type
))
913 fputs_filtered (" ", stream
);
914 c
= unpack_long (type
, valaddr
+ offset_aligned
);
915 ada_printchar (c
, type
, stream
);
922 /* Implement Ada val_print'ing for the case where TYPE is
926 ada_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
927 int offset
, int offset_aligned
, CORE_ADDR address
,
928 struct ui_file
*stream
, int recurse
,
929 struct value
*original_value
,
930 const struct value_print_options
*options
,
931 const struct language_defn
*language
)
939 val_print_scalar_formatted (type
, offset_aligned
,
940 original_value
, options
, 0, stream
);
944 len
= TYPE_NFIELDS (type
);
945 val
= unpack_long (type
, valaddr
+ offset_aligned
);
946 for (i
= 0; i
< len
; i
++)
949 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
955 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
958 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
960 fputs_filtered (name
, stream
);
963 print_longest (stream
, 'd', 0, val
);
966 /* Implement Ada val_print'ing for the case where TYPE is
970 ada_val_print_flt (struct type
*type
, const gdb_byte
*valaddr
,
971 int offset
, int offset_aligned
, CORE_ADDR address
,
972 struct ui_file
*stream
, int recurse
,
973 struct value
*original_value
,
974 const struct value_print_options
*options
,
975 const struct language_defn
*language
)
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
,
996 const struct language_defn
*language
)
998 if (ada_is_bogus_array_descriptor (type
))
1000 fprintf_filtered (stream
, "(...?)");
1004 fprintf_filtered (stream
, "(");
1006 if (print_field_values (type
, valaddr
, offset_aligned
,
1007 stream
, recurse
, original_value
, options
,
1008 0, type
, offset_aligned
, language
) != 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
,
1060 const struct language_defn
*language
)
1062 /* For references, the debugger is expected to print the value as
1063 an address if DEREF_REF is null. But printing an address in place
1064 of the object value would be confusing to an Ada programmer.
1065 So, for Ada values, we print the actual dereferenced value
1067 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1068 struct value
*deref_val
;
1069 CORE_ADDR deref_val_int
;
1071 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1073 fputs_filtered ("<ref to undefined type>", stream
);
1077 deref_val
= coerce_ref_if_computed (original_value
);
1080 if (ada_is_tagged_type (value_type (deref_val
), 1))
1081 deref_val
= ada_tag_value_at_base_address (deref_val
);
1083 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1088 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1089 if (deref_val_int
== 0)
1091 fputs_filtered ("(null)", stream
);
1096 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1098 if (ada_is_tagged_type (value_type (deref_val
), 1))
1099 deref_val
= ada_tag_value_at_base_address (deref_val
);
1101 /* Make sure that the object does not have an unreasonable size
1102 before trying to print it. This can happen for instance with
1103 references to dynamic objects whose contents is uninitialized
1104 (Eg: an array whose bounds are not set yet). */
1105 ada_ensure_varsize_limit (value_type (deref_val
));
1107 if (value_lazy (deref_val
))
1108 value_fetch_lazy (deref_val
);
1110 val_print (value_type (deref_val
),
1111 value_embedded_offset (deref_val
),
1112 value_address (deref_val
), stream
, recurse
+ 1,
1113 deref_val
, options
, language
);
1116 /* See the comment on ada_val_print. This function differs in that it
1117 does not catch evaluation errors (leaving that to ada_val_print). */
1120 ada_val_print_1 (struct type
*type
,
1121 int offset
, CORE_ADDR address
,
1122 struct ui_file
*stream
, int recurse
,
1123 struct value
*original_value
,
1124 const struct value_print_options
*options
,
1125 const struct language_defn
*language
)
1128 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
1130 type
= ada_check_typedef (type
);
1132 if (ada_is_array_descriptor_type (type
)
1133 || (ada_is_constrained_packed_array_type (type
)
1134 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1136 ada_val_print_gnat_array (type
, valaddr
, offset
, address
,
1137 stream
, recurse
, original_value
,
1142 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1143 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
1144 type
= resolve_dynamic_type (type
, valaddr
+ offset_aligned
,
1145 address
+ offset_aligned
);
1147 switch (TYPE_CODE (type
))
1150 val_print (type
, offset
, address
, stream
, recurse
,
1151 original_value
, options
, language_def (language_c
));
1155 ada_val_print_ptr (type
, valaddr
, offset
, offset_aligned
,
1156 address
, stream
, recurse
, original_value
,
1161 case TYPE_CODE_RANGE
:
1162 ada_val_print_num (type
, valaddr
, offset
, offset_aligned
,
1163 address
, stream
, recurse
, original_value
,
1167 case TYPE_CODE_ENUM
:
1168 ada_val_print_enum (type
, valaddr
, offset
, offset_aligned
,
1169 address
, stream
, recurse
, original_value
,
1174 ada_val_print_flt (type
, valaddr
, offset
, offset_aligned
,
1175 address
, stream
, recurse
, original_value
,
1179 case TYPE_CODE_UNION
:
1180 case TYPE_CODE_STRUCT
:
1181 ada_val_print_struct_union (type
, valaddr
, offset
, offset_aligned
,
1182 address
, stream
, recurse
,
1183 original_value
, options
, language
);
1186 case TYPE_CODE_ARRAY
:
1187 ada_val_print_array (type
, valaddr
, offset
, offset_aligned
,
1188 address
, stream
, recurse
, original_value
,
1193 ada_val_print_ref (type
, valaddr
, offset
, offset_aligned
,
1194 address
, stream
, recurse
, original_value
,
1200 /* See val_print for a description of the various parameters of this
1201 function; they are identical. */
1204 ada_val_print (struct type
*type
,
1205 int embedded_offset
, CORE_ADDR address
,
1206 struct ui_file
*stream
, int recurse
,
1208 const struct value_print_options
*options
)
1212 ada_val_print_1 (type
, embedded_offset
, address
,
1213 stream
, recurse
, val
, options
,
1216 CATCH (except
, RETURN_MASK_ERROR
)
1218 fprintf_filtered (stream
, _("<error reading variable: %s>"),
1225 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1226 const struct value_print_options
*options
)
1228 struct value
*val
= ada_to_fixed_value (val0
);
1229 CORE_ADDR address
= value_address (val
);
1230 struct type
*type
= ada_check_typedef (value_type (val
));
1231 struct value_print_options opts
;
1233 /* If it is a pointer, indicate what it points to. */
1234 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1236 /* Hack: don't print (char *) for char strings. Their
1237 type is indicated by the quoted string anyway. */
1238 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1239 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1240 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1242 fprintf_filtered (stream
, "(");
1243 type_print (type
, "", stream
, -1);
1244 fprintf_filtered (stream
, ") ");
1247 else if (ada_is_array_descriptor_type (type
))
1249 /* We do not print the type description unless TYPE is an array
1250 access type (this is encoded by the compiler as a typedef to
1251 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1252 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1254 fprintf_filtered (stream
, "(");
1255 type_print (type
, "", stream
, -1);
1256 fprintf_filtered (stream
, ") ");
1259 else if (ada_is_bogus_array_descriptor (type
))
1261 fprintf_filtered (stream
, "(");
1262 type_print (type
, "", stream
, -1);
1263 fprintf_filtered (stream
, ") (...?)");
1270 value_embedded_offset (val
), address
,
1271 stream
, 0, val
, &opts
, current_language
);