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 from VALADDR on
116 STREAM. Formats according to OPTIONS and separates with commas.
117 RECURSE is the recursion (nesting) level. TYPE must have been
118 decoded (as by ada_coerce_to_simple_array). */
121 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
122 int offset
, struct ui_file
*stream
,
124 const struct value_print_options
*options
)
127 unsigned int things_printed
= 0;
129 struct type
*elttype
, *index_type
;
130 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
131 struct value
*mark
= value_mark ();
134 elttype
= TYPE_TARGET_TYPE (type
);
135 index_type
= TYPE_INDEX_TYPE (type
);
139 struct type
*base_index_type
;
141 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
144 len
= high
- low
+ 1;
146 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
147 base_index_type
= TYPE_TARGET_TYPE (index_type
);
149 base_index_type
= index_type
;
151 if (TYPE_CODE (base_index_type
) == TYPE_CODE_ENUM
)
153 LONGEST low_pos
, high_pos
;
155 /* Non-contiguous enumerations types can by used as index types
156 so the array length is computed from the positions of the
157 first and last literal in the enumeration type, and not from
158 the values of these literals. */
160 if (!discrete_position (base_index_type
, low
, &low_pos
)
161 || !discrete_position (base_index_type
, high
, &high_pos
))
163 warning (_("unable to get positions in array, use bounds instead"));
168 /* The array length should normally be HIGH_POS - LOW_POS + 1.
169 But in Ada we allow LOW_POS to be greater than HIGH_POS for
170 empty arrays. In that situation, the array length is just zero,
173 if (low_pos
> high_pos
)
176 len
= high_pos
- low_pos
+ 1;
181 annotate_array_section_begin (i
, elttype
);
183 while (i
< len
&& things_printed
< options
->print_max
)
185 struct value
*v0
, *v1
;
190 if (options
->prettyformat_arrays
)
192 fprintf_filtered (stream
, ",\n");
193 print_spaces_filtered (2 + 2 * recurse
, stream
);
197 fprintf_filtered (stream
, ", ");
200 wrap_here (n_spaces (2 + 2 * recurse
));
201 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
204 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
205 (i0
* bitsize
) / HOST_CHAR_BIT
,
206 (i0
* bitsize
) % HOST_CHAR_BIT
,
213 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
214 (i
* bitsize
) / HOST_CHAR_BIT
,
215 (i
* bitsize
) % HOST_CHAR_BIT
,
217 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
218 != TYPE_LENGTH (check_typedef (value_type (v1
))))
220 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
221 v1
, value_embedded_offset (v1
),
222 TYPE_LENGTH (check_typedef (value_type (v0
)))))
226 if (i
- i0
> options
->repeat_count_threshold
)
228 struct value_print_options opts
= *options
;
231 common_val_print (v0
, stream
, recurse
+ 1, &opts
, current_language
);
232 annotate_elt_rep (i
- i0
);
233 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
234 metadata_style
.style ().ptr (), i
- i0
, nullptr);
235 annotate_elt_rep_end ();
241 struct value_print_options opts
= *options
;
244 for (j
= i0
; j
< i
; j
+= 1)
248 if (options
->prettyformat_arrays
)
250 fprintf_filtered (stream
, ",\n");
251 print_spaces_filtered (2 + 2 * recurse
, stream
);
255 fprintf_filtered (stream
, ", ");
257 wrap_here (n_spaces (2 + 2 * recurse
));
258 maybe_print_array_index (index_type
, j
+ low
,
261 common_val_print (v0
, stream
, recurse
+ 1, &opts
,
266 things_printed
+= i
- i0
;
268 annotate_array_section_end ();
271 fprintf_filtered (stream
, "...");
274 value_free_to_mark (mark
);
277 /* Print the character C on STREAM as part of the contents of a literal
278 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
282 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
283 int quoter
, int type_len
)
285 /* If this character fits in the normal ASCII range, and is
286 a printable character, then print the character as if it was
287 an ASCII character, even if this is a wide character.
288 The UCHAR_MAX check is necessary because the isascii function
289 requires that its argument have a value of an unsigned char,
290 or EOF (EOF is obviously not printable). */
291 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
293 if (c
== quoter
&& c
== '"')
294 fprintf_filtered (stream
, "\"\"");
296 fprintf_filtered (stream
, "%c", c
);
299 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
302 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
306 char_at (const gdb_byte
*string
, int i
, int type_len
,
307 enum bfd_endian byte_order
)
312 return (int) extract_unsigned_integer (string
+ type_len
* i
,
313 type_len
, byte_order
);
316 /* Print a floating-point value of type TYPE, pointed to in GDB by
317 VALADDR, on STREAM. Use Ada formatting conventions: there must be
318 a decimal point, and at least one digit before and after the
319 point. We use the GNAT format for NaNs and infinities. */
322 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
323 struct ui_file
*stream
)
325 string_file tmp_stream
;
327 print_floating (valaddr
, type
, &tmp_stream
);
329 std::string
&s
= tmp_stream
.string ();
330 size_t skip_count
= 0;
332 /* Modify for Ada rules. */
334 size_t pos
= s
.find ("inf");
335 if (pos
== std::string::npos
)
336 pos
= s
.find ("Inf");
337 if (pos
== std::string::npos
)
338 pos
= s
.find ("INF");
339 if (pos
!= std::string::npos
)
340 s
.replace (pos
, 3, "Inf");
342 if (pos
== std::string::npos
)
344 pos
= s
.find ("nan");
345 if (pos
== std::string::npos
)
346 pos
= s
.find ("NaN");
347 if (pos
== std::string::npos
)
348 pos
= s
.find ("Nan");
349 if (pos
!= std::string::npos
)
351 s
[pos
] = s
[pos
+ 2] = 'N';
357 if (pos
== std::string::npos
358 && s
.find ('.') == std::string::npos
)
361 if (pos
== std::string::npos
)
362 fprintf_filtered (stream
, "%s.0", s
.c_str ());
364 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
367 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
371 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
373 fputs_filtered ("'", stream
);
374 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
375 fputs_filtered ("'", stream
);
378 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
379 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
380 like a default signed integer. */
383 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
390 print_longest (stream
, 'd', 0, val
);
394 type
= ada_check_typedef (type
);
396 switch (TYPE_CODE (type
))
400 len
= TYPE_NFIELDS (type
);
401 for (i
= 0; i
< len
; i
++)
403 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
410 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
411 variable_name_style
.style (), stream
);
415 print_longest (stream
, 'd', 0, val
);
420 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
424 LA_PRINT_CHAR (val
, type
, stream
);
428 fprintf_filtered (stream
, val
? "true" : "false");
431 case TYPE_CODE_RANGE
:
432 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
435 case TYPE_CODE_UNDEF
:
437 case TYPE_CODE_ARRAY
:
438 case TYPE_CODE_STRUCT
:
439 case TYPE_CODE_UNION
:
444 case TYPE_CODE_STRING
:
445 case TYPE_CODE_ERROR
:
446 case TYPE_CODE_MEMBERPTR
:
447 case TYPE_CODE_METHODPTR
:
448 case TYPE_CODE_METHOD
:
450 warning (_("internal error: unhandled type in ada_print_scalar"));
454 error (_("Invalid type code in symbol table."));
458 /* Print the character string STRING, printing at most LENGTH characters.
459 Printing stops early if the number hits print_max; repeat counts
460 are printed as appropriate. Print ellipses at the end if we
461 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
462 TYPE_LEN is the length (1 or 2) of the character type. */
465 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
466 unsigned int length
, int force_ellipses
, int type_len
,
467 const struct value_print_options
*options
)
469 enum bfd_endian byte_order
= type_byte_order (elttype
);
471 unsigned int things_printed
= 0;
477 fputs_filtered ("\"\"", stream
);
481 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
483 /* Position of the character we are examining
484 to see whether it is repeated. */
486 /* Number of repetitions we have detected so far. */
493 fputs_filtered (", ", stream
);
500 && char_at (string
, rep1
, type_len
, byte_order
)
501 == char_at (string
, i
, type_len
, byte_order
))
507 if (reps
> options
->repeat_count_threshold
)
511 fputs_filtered ("\", ", stream
);
514 fputs_filtered ("'", stream
);
515 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
516 elttype
, stream
, '\'', type_len
);
517 fputs_filtered ("'", stream
);
518 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
519 metadata_style
.style ().ptr (), reps
, nullptr);
521 things_printed
+= options
->repeat_count_threshold
;
528 fputs_filtered ("\"", stream
);
531 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
532 elttype
, stream
, '"', type_len
);
537 /* Terminate the quotes if necessary. */
539 fputs_filtered ("\"", stream
);
541 if (force_ellipses
|| i
< length
)
542 fputs_filtered ("...", stream
);
546 ada_printstr (struct ui_file
*stream
, struct type
*type
,
547 const gdb_byte
*string
, unsigned int length
,
548 const char *encoding
, int force_ellipses
,
549 const struct value_print_options
*options
)
551 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
556 print_variant_part (struct type
*type
, int field_num
,
557 const gdb_byte
*valaddr
, int offset
,
558 struct ui_file
*stream
, int recurse
,
560 const struct value_print_options
*options
,
562 struct type
*outer_type
, int outer_offset
,
563 const struct language_defn
*language
)
565 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
566 int which
= ada_which_variant_applies (var_type
, outer_type
,
567 valaddr
+ outer_offset
);
572 return print_field_values
573 (TYPE_FIELD_TYPE (var_type
, which
),
575 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
576 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
577 stream
, recurse
, val
, options
,
578 comma_needed
, outer_type
, outer_offset
, language
);
581 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
583 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
584 meanings as in ada_print_value and ada_val_print.
586 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
587 record (used to get discriminant values when printing variant
590 COMMA_NEEDED is 1 if fields have been printed at the current recursion
591 level, so that a comma is needed before any field printed by this
594 Returns 1 if COMMA_NEEDED or any fields were printed. */
597 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
598 int offset
, struct ui_file
*stream
, int recurse
,
600 const struct value_print_options
*options
,
602 struct type
*outer_type
, int outer_offset
,
603 const struct language_defn
*language
)
607 len
= TYPE_NFIELDS (type
);
609 for (i
= 0; i
< len
; i
+= 1)
611 if (ada_is_ignored_field (type
, i
))
614 if (ada_is_wrapper_field (type
, i
))
617 print_field_values (TYPE_FIELD_TYPE (type
, i
),
620 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
621 stream
, recurse
, val
, options
,
622 comma_needed
, type
, offset
, language
);
625 else if (ada_is_variant_part (type
, i
))
628 print_variant_part (type
, i
, valaddr
,
629 offset
, stream
, recurse
, val
,
630 options
, comma_needed
,
631 outer_type
, outer_offset
, language
);
636 fprintf_filtered (stream
, ", ");
639 if (options
->prettyformat
)
641 fprintf_filtered (stream
, "\n");
642 print_spaces_filtered (2 + 2 * recurse
, stream
);
646 wrap_here (n_spaces (2 + 2 * recurse
));
649 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
650 fprintf_filtered (stream
, "%.*s",
651 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
652 TYPE_FIELD_NAME (type
, i
));
653 annotate_field_name_end ();
654 fputs_filtered (" => ", stream
);
655 annotate_field_value ();
657 if (TYPE_FIELD_PACKED (type
, i
))
659 /* Bitfields require special handling, especially due to byte
661 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
663 fputs_styled (_("<optimized out or zero length>"),
664 metadata_style
.style (), stream
);
669 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
670 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
671 struct value_print_options opts
;
673 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
674 v
= ada_value_primitive_packed_val
676 offset
+ bit_pos
/ HOST_CHAR_BIT
,
677 bit_pos
% HOST_CHAR_BIT
,
678 bit_size
, TYPE_FIELD_TYPE (type
, i
));
681 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
686 struct value_print_options opts
= *options
;
690 LONGEST local_off
= (offset
+ TYPE_FIELD_BITPOS (type
, i
)
692 struct value
*v
= value_from_contents (TYPE_FIELD_TYPE (type
, i
),
693 valaddr
+ local_off
);
694 common_val_print (v
, stream
, recurse
+ 1, &opts
, language
);
696 annotate_field_end ();
702 /* Implement Ada val_print'ing for the case where TYPE is
703 a TYPE_CODE_ARRAY of characters. */
706 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
708 struct ui_file
*stream
, int recurse
,
709 const struct value_print_options
*options
)
711 enum bfd_endian byte_order
= type_byte_order (type
);
712 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
716 /* We know that ELTTYPE cannot possibly be null, because we assume
717 that we're called only when TYPE is a string-like type.
718 Similarly, the size of ELTTYPE should also be non-null, since
719 it's a character-like type. */
720 gdb_assert (elttype
!= NULL
);
721 gdb_assert (TYPE_LENGTH (elttype
) != 0);
723 eltlen
= TYPE_LENGTH (elttype
);
724 len
= TYPE_LENGTH (type
) / eltlen
;
726 if (options
->prettyformat_arrays
)
727 print_spaces_filtered (2 + 2 * recurse
, stream
);
729 /* If requested, look for the first null char and only print
730 elements up to it. */
731 if (options
->stop_print_at_null
)
735 /* Look for a NULL char. */
738 && temp_len
< options
->print_max
739 && char_at (valaddr
+ offset_aligned
,
740 temp_len
, eltlen
, byte_order
) != 0);
745 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
749 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
750 thin pointers, etc). */
753 ada_val_print_gnat_array (struct value
*val
,
754 struct ui_file
*stream
, int recurse
,
755 const struct value_print_options
*options
)
757 scoped_value_mark free_values
;
759 struct type
*type
= ada_check_typedef (value_type (val
));
761 /* If this is a reference, coerce it now. This helps taking care
762 of the case where ADDRESS is meaningless because original_value
764 val
= coerce_ref (val
);
765 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
766 val
= ada_coerce_to_simple_array_ptr (val
);
768 val
= ada_coerce_to_simple_array (val
);
771 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
772 fprintf_filtered (stream
, "0x0");
775 common_val_print (val
, stream
, recurse
, options
,
776 language_def (language_ada
));
779 /* Implement Ada value_print'ing for the case where TYPE is a
783 ada_value_print_ptr (struct value
*val
,
784 struct ui_file
*stream
, int recurse
,
785 const struct value_print_options
*options
)
787 common_val_print (val
, stream
, recurse
, options
, language_def (language_c
));
789 struct type
*type
= ada_check_typedef (value_type (val
));
790 if (ada_is_tag_type (type
))
792 const char *name
= ada_tag_name (val
);
795 fprintf_filtered (stream
, " (%s)", name
);
799 /* Implement Ada val_print'ing for the case where TYPE is
800 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
803 ada_value_print_num (struct value
*val
, struct ui_file
*stream
, int recurse
,
804 const struct value_print_options
*options
)
806 struct type
*type
= ada_check_typedef (value_type (val
));
807 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
809 if (ada_is_fixed_point_type (type
))
811 struct value
*scale
= ada_scaling_factor (type
);
812 val
= value_cast (value_type (scale
), val
);
813 val
= value_binop (val
, scale
, BINOP_MUL
);
815 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
817 = target_float_to_string (value_contents (val
), value_type (val
), fmt
);
818 fputs_filtered (str
.c_str (), stream
);
821 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
822 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
823 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
824 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
826 /* For enum-valued ranges, we want to recurse, because we'll end
827 up printing the constant's name rather than its numeric
828 value. Character and fixed-point types are also printed
829 differently, so recuse for those as well. */
830 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
831 val
= value_cast (target_type
, val
);
832 common_val_print (val
, stream
, recurse
+ 1, options
,
833 language_def (language_ada
));
838 int format
= (options
->format
? options
->format
839 : options
->output_format
);
843 struct value_print_options opts
= *options
;
845 opts
.format
= format
;
846 value_print_scalar_formatted (val
, &opts
, 0, stream
);
848 else if (ada_is_system_address_type (type
))
850 /* FIXME: We want to print System.Address variables using
851 the same format as for any access type. But for some
852 reason GNAT encodes the System.Address type as an int,
853 so we have to work-around this deficiency by handling
854 System.Address values as a special case. */
856 struct gdbarch
*gdbarch
= get_type_arch (type
);
857 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
858 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
860 fprintf_filtered (stream
, "(");
861 type_print (type
, "", stream
, -1);
862 fprintf_filtered (stream
, ") ");
863 fputs_filtered (paddress (gdbarch
, addr
), stream
);
867 value_print_scalar_formatted (val
, options
, 0, stream
);
868 if (ada_is_character_type (type
))
872 fputs_filtered (" ", stream
);
873 c
= unpack_long (type
, valaddr
);
874 ada_printchar (c
, type
, stream
);
881 /* Implement Ada val_print'ing for the case where TYPE is
885 ada_val_print_enum (struct value
*value
, struct ui_file
*stream
, int recurse
,
886 const struct value_print_options
*options
)
894 value_print_scalar_formatted (value
, options
, 0, stream
);
898 struct type
*type
= ada_check_typedef (value_type (value
));
899 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
900 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
902 len
= TYPE_NFIELDS (type
);
903 val
= unpack_long (type
, valaddr
+ offset_aligned
);
904 for (i
= 0; i
< len
; i
++)
907 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
913 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
916 fprintf_filtered (stream
, "%ld %ps", (long) val
,
917 styled_string (variable_name_style
.style (),
920 fputs_styled (name
, variable_name_style
.style (), stream
);
923 print_longest (stream
, 'd', 0, val
);
926 /* Implement Ada val_print'ing for the case where TYPE is
927 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
930 ada_val_print_struct_union
931 (struct type
*type
, const gdb_byte
*valaddr
, int offset
,
932 int offset_aligned
, CORE_ADDR address
, struct ui_file
*stream
,
933 int recurse
, struct value
*original_value
,
934 const struct value_print_options
*options
)
936 if (ada_is_bogus_array_descriptor (type
))
938 fprintf_filtered (stream
, "(...?)");
942 fprintf_filtered (stream
, "(");
944 if (print_field_values (type
, valaddr
, offset_aligned
,
945 stream
, recurse
, original_value
, options
,
946 0, type
, offset_aligned
,
947 language_def (language_ada
)) != 0
948 && options
->prettyformat
)
950 fprintf_filtered (stream
, "\n");
951 print_spaces_filtered (2 * recurse
, stream
);
954 fprintf_filtered (stream
, ")");
957 /* Implement Ada value_print'ing for the case where TYPE is a
961 ada_value_print_array (struct value
*val
, struct ui_file
*stream
, int recurse
,
962 const struct value_print_options
*options
)
964 struct type
*type
= ada_check_typedef (value_type (val
));
966 /* For an array of characters, print with string syntax. */
967 if (ada_is_string_type (type
)
968 && (options
->format
== 0 || options
->format
== 's'))
970 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
971 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
973 ada_val_print_string (type
, valaddr
, offset_aligned
, stream
, recurse
,
978 fprintf_filtered (stream
, "(");
979 print_optional_low_bound (stream
, type
, options
);
980 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
982 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
983 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
984 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
985 stream
, recurse
, options
);
988 value_print_array_elements (val
, stream
, recurse
, options
, 0);
989 fprintf_filtered (stream
, ")");
992 /* Implement Ada val_print'ing for the case where TYPE is
996 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
997 int offset
, int offset_aligned
, CORE_ADDR address
,
998 struct ui_file
*stream
, int recurse
,
999 struct value
*original_value
,
1000 const struct value_print_options
*options
)
1002 /* For references, the debugger is expected to print the value as
1003 an address if DEREF_REF is null. But printing an address in place
1004 of the object value would be confusing to an Ada programmer.
1005 So, for Ada values, we print the actual dereferenced value
1007 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1008 struct value
*deref_val
;
1009 CORE_ADDR deref_val_int
;
1011 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1013 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
1018 deref_val
= coerce_ref_if_computed (original_value
);
1021 if (ada_is_tagged_type (value_type (deref_val
), 1))
1022 deref_val
= ada_tag_value_at_base_address (deref_val
);
1024 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1025 language_def (language_ada
));
1029 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1030 if (deref_val_int
== 0)
1032 fputs_filtered ("(null)", stream
);
1037 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1039 if (ada_is_tagged_type (value_type (deref_val
), 1))
1040 deref_val
= ada_tag_value_at_base_address (deref_val
);
1042 /* Make sure that the object does not have an unreasonable size
1043 before trying to print it. This can happen for instance with
1044 references to dynamic objects whose contents is uninitialized
1045 (Eg: an array whose bounds are not set yet). */
1046 ada_ensure_varsize_limit (value_type (deref_val
));
1048 if (value_lazy (deref_val
))
1049 value_fetch_lazy (deref_val
);
1051 common_val_print (deref_val
, stream
, recurse
+ 1,
1052 options
, language_def (language_ada
));
1055 /* See the comment on ada_value_print. This function differs in that
1056 it does not catch evaluation errors (leaving that to
1057 ada_value_print). */
1060 ada_value_print_1 (struct value
*val
, struct ui_file
*stream
, int recurse
,
1061 const struct value_print_options
*options
)
1063 struct type
*type
= ada_check_typedef (value_type (val
));
1065 if (ada_is_array_descriptor_type (type
)
1066 || (ada_is_constrained_packed_array_type (type
)
1067 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1069 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1073 val
= ada_to_fixed_value (val
);
1074 type
= value_type (val
);
1075 struct type
*saved_type
= type
;
1077 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1078 CORE_ADDR address
= value_address (val
);
1079 type
= ada_check_typedef (resolve_dynamic_type (type
, valaddr
, address
));
1080 if (type
!= saved_type
)
1082 val
= value_copy (val
);
1083 deprecated_set_value_type (val
, type
);
1086 switch (TYPE_CODE (type
))
1089 common_val_print (val
, stream
, recurse
, options
,
1090 language_def (language_c
));
1094 ada_value_print_ptr (val
, stream
, recurse
, options
);
1098 case TYPE_CODE_RANGE
:
1099 ada_value_print_num (val
, stream
, recurse
, options
);
1102 case TYPE_CODE_ENUM
:
1103 ada_val_print_enum (val
, stream
, recurse
, options
);
1107 if (options
->format
)
1109 common_val_print (val
, stream
, recurse
, options
,
1110 language_def (language_c
));
1114 ada_print_floating (valaddr
, type
, stream
);
1117 case TYPE_CODE_UNION
:
1118 case TYPE_CODE_STRUCT
:
1119 ada_val_print_struct_union (type
, valaddr
, 0, 0,
1120 address
, stream
, recurse
,
1124 case TYPE_CODE_ARRAY
:
1125 ada_value_print_array (val
, stream
, recurse
, options
);
1129 ada_val_print_ref (type
, valaddr
, 0, 0,
1130 address
, stream
, recurse
, val
,
1136 /* See ada-lang.h. */
1139 ada_value_print_inner (struct value
*val
, struct ui_file
*stream
,
1141 const struct value_print_options
*options
)
1145 ada_value_print_1 (val
, stream
, recurse
, options
);
1147 catch (const gdb_exception_error
&except
)
1149 fprintf_styled (stream
, metadata_style
.style (),
1150 _("<error reading variable: %s>"),
1156 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1157 const struct value_print_options
*options
)
1159 struct value
*val
= ada_to_fixed_value (val0
);
1160 struct type
*type
= ada_check_typedef (value_type (val
));
1161 struct value_print_options opts
;
1163 /* If it is a pointer, indicate what it points to. */
1164 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1166 /* Hack: don't print (char *) for char strings. Their
1167 type is indicated by the quoted string anyway. */
1168 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1169 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1170 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1172 fprintf_filtered (stream
, "(");
1173 type_print (type
, "", stream
, -1);
1174 fprintf_filtered (stream
, ") ");
1177 else if (ada_is_array_descriptor_type (type
))
1179 /* We do not print the type description unless TYPE is an array
1180 access type (this is encoded by the compiler as a typedef to
1181 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1182 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1184 fprintf_filtered (stream
, "(");
1185 type_print (type
, "", stream
, -1);
1186 fprintf_filtered (stream
, ") ");
1189 else if (ada_is_bogus_array_descriptor (type
))
1191 fprintf_filtered (stream
, "(");
1192 type_print (type
, "", stream
, -1);
1193 fprintf_filtered (stream
, ") (...?)");
1199 common_val_print (val
, stream
, 0, &opts
, current_language
);