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
);
278 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
280 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
283 /* Print the character C on STREAM as part of the contents of a literal
284 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
288 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
289 int quoter
, int type_len
)
291 /* If this character fits in the normal ASCII range, and is
292 a printable character, then print the character as if it was
293 an ASCII character, even if this is a wide character.
294 The UCHAR_MAX check is necessary because the isascii function
295 requires that its argument have a value of an unsigned char,
296 or EOF (EOF is obviously not printable). */
297 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
299 if (c
== quoter
&& c
== '"')
300 fprintf_filtered (stream
, "\"\"");
302 fprintf_filtered (stream
, "%c", c
);
305 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
308 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
312 char_at (const gdb_byte
*string
, int i
, int type_len
,
313 enum bfd_endian byte_order
)
318 return (int) extract_unsigned_integer (string
+ type_len
* i
,
319 type_len
, byte_order
);
322 /* Print a floating-point value of type TYPE, pointed to in GDB by
323 VALADDR, on STREAM. Use Ada formatting conventions: there must be
324 a decimal point, and at least one digit before and after the
325 point. We use the GNAT format for NaNs and infinities. */
328 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
329 struct ui_file
*stream
)
331 string_file tmp_stream
;
333 print_floating (valaddr
, type
, &tmp_stream
);
335 std::string
&s
= tmp_stream
.string ();
336 size_t skip_count
= 0;
338 /* Modify for Ada rules. */
340 size_t pos
= s
.find ("inf");
341 if (pos
== std::string::npos
)
342 pos
= s
.find ("Inf");
343 if (pos
== std::string::npos
)
344 pos
= s
.find ("INF");
345 if (pos
!= std::string::npos
)
346 s
.replace (pos
, 3, "Inf");
348 if (pos
== std::string::npos
)
350 pos
= s
.find ("nan");
351 if (pos
== std::string::npos
)
352 pos
= s
.find ("NaN");
353 if (pos
== std::string::npos
)
354 pos
= s
.find ("Nan");
355 if (pos
!= std::string::npos
)
357 s
[pos
] = s
[pos
+ 2] = 'N';
363 if (pos
== std::string::npos
364 && s
.find ('.') == std::string::npos
)
367 if (pos
== std::string::npos
)
368 fprintf_filtered (stream
, "%s.0", s
.c_str ());
370 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
373 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
377 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
379 fputs_filtered ("'", stream
);
380 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
381 fputs_filtered ("'", stream
);
384 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
385 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
386 like a default signed integer. */
389 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
396 print_longest (stream
, 'd', 0, val
);
400 type
= ada_check_typedef (type
);
402 switch (TYPE_CODE (type
))
406 len
= TYPE_NFIELDS (type
);
407 for (i
= 0; i
< len
; i
++)
409 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
416 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
417 variable_name_style
.style (), stream
);
421 print_longest (stream
, 'd', 0, val
);
426 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
430 LA_PRINT_CHAR (val
, type
, stream
);
434 fprintf_filtered (stream
, val
? "true" : "false");
437 case TYPE_CODE_RANGE
:
438 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
441 case TYPE_CODE_UNDEF
:
443 case TYPE_CODE_ARRAY
:
444 case TYPE_CODE_STRUCT
:
445 case TYPE_CODE_UNION
:
450 case TYPE_CODE_STRING
:
451 case TYPE_CODE_ERROR
:
452 case TYPE_CODE_MEMBERPTR
:
453 case TYPE_CODE_METHODPTR
:
454 case TYPE_CODE_METHOD
:
456 warning (_("internal error: unhandled type in ada_print_scalar"));
460 error (_("Invalid type code in symbol table."));
464 /* Print the character string STRING, printing at most LENGTH characters.
465 Printing stops early if the number hits print_max; repeat counts
466 are printed as appropriate. Print ellipses at the end if we
467 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
468 TYPE_LEN is the length (1 or 2) of the character type. */
471 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
472 unsigned int length
, int force_ellipses
, int type_len
,
473 const struct value_print_options
*options
)
475 enum bfd_endian byte_order
= type_byte_order (elttype
);
477 unsigned int things_printed
= 0;
483 fputs_filtered ("\"\"", stream
);
487 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
489 /* Position of the character we are examining
490 to see whether it is repeated. */
492 /* Number of repetitions we have detected so far. */
499 fputs_filtered (", ", stream
);
506 && char_at (string
, rep1
, type_len
, byte_order
)
507 == char_at (string
, i
, type_len
, byte_order
))
513 if (reps
> options
->repeat_count_threshold
)
517 fputs_filtered ("\", ", stream
);
520 fputs_filtered ("'", stream
);
521 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
522 elttype
, stream
, '\'', type_len
);
523 fputs_filtered ("'", stream
);
524 fprintf_filtered (stream
, _(" %p[<repeats %u times>%p]"),
525 metadata_style
.style ().ptr (), reps
, nullptr);
527 things_printed
+= options
->repeat_count_threshold
;
534 fputs_filtered ("\"", stream
);
537 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
538 elttype
, stream
, '"', type_len
);
543 /* Terminate the quotes if necessary. */
545 fputs_filtered ("\"", stream
);
547 if (force_ellipses
|| i
< length
)
548 fputs_filtered ("...", stream
);
552 ada_printstr (struct ui_file
*stream
, struct type
*type
,
553 const gdb_byte
*string
, unsigned int length
,
554 const char *encoding
, int force_ellipses
,
555 const struct value_print_options
*options
)
557 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
562 print_variant_part (struct type
*type
, int field_num
,
563 const gdb_byte
*valaddr
, int offset
,
564 struct ui_file
*stream
, int recurse
,
566 const struct value_print_options
*options
,
568 struct type
*outer_type
, int outer_offset
,
569 const struct language_defn
*language
)
571 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
572 int which
= ada_which_variant_applies (var_type
, outer_type
,
573 valaddr
+ outer_offset
);
578 return print_field_values
579 (TYPE_FIELD_TYPE (var_type
, which
),
581 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
582 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
583 stream
, recurse
, val
, options
,
584 comma_needed
, outer_type
, outer_offset
, language
);
587 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
589 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
590 meanings as in ada_print_value and ada_val_print.
592 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
593 record (used to get discriminant values when printing variant
596 COMMA_NEEDED is 1 if fields have been printed at the current recursion
597 level, so that a comma is needed before any field printed by this
600 Returns 1 if COMMA_NEEDED or any fields were printed. */
603 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
604 int offset
, struct ui_file
*stream
, int recurse
,
606 const struct value_print_options
*options
,
608 struct type
*outer_type
, int outer_offset
,
609 const struct language_defn
*language
)
613 len
= TYPE_NFIELDS (type
);
615 for (i
= 0; i
< len
; i
+= 1)
617 if (ada_is_ignored_field (type
, i
))
620 if (ada_is_wrapper_field (type
, i
))
623 print_field_values (TYPE_FIELD_TYPE (type
, i
),
626 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
627 stream
, recurse
, val
, options
,
628 comma_needed
, type
, offset
, language
);
631 else if (ada_is_variant_part (type
, i
))
634 print_variant_part (type
, i
, valaddr
,
635 offset
, stream
, recurse
, val
,
636 options
, comma_needed
,
637 outer_type
, outer_offset
, language
);
642 fprintf_filtered (stream
, ", ");
645 if (options
->prettyformat
)
647 fprintf_filtered (stream
, "\n");
648 print_spaces_filtered (2 + 2 * recurse
, stream
);
652 wrap_here (n_spaces (2 + 2 * recurse
));
655 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
656 fprintf_filtered (stream
, "%.*s",
657 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
658 TYPE_FIELD_NAME (type
, i
));
659 annotate_field_name_end ();
660 fputs_filtered (" => ", stream
);
661 annotate_field_value ();
663 if (TYPE_FIELD_PACKED (type
, i
))
665 /* Bitfields require special handling, especially due to byte
667 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
669 fputs_styled (_("<optimized out or zero length>"),
670 metadata_style
.style (), stream
);
675 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
676 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
677 struct value_print_options opts
;
679 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
680 v
= ada_value_primitive_packed_val
682 offset
+ bit_pos
/ HOST_CHAR_BIT
,
683 bit_pos
% HOST_CHAR_BIT
,
684 bit_size
, TYPE_FIELD_TYPE (type
, i
));
687 val_print (TYPE_FIELD_TYPE (type
, i
),
688 value_embedded_offset (v
), 0,
689 stream
, recurse
+ 1, v
,
695 struct value_print_options opts
= *options
;
698 val_print (TYPE_FIELD_TYPE (type
, i
),
699 (offset
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
700 0, stream
, recurse
+ 1, val
, &opts
, language
);
702 annotate_field_end ();
708 /* Implement Ada val_print'ing for the case where TYPE is
709 a TYPE_CODE_ARRAY of characters. */
712 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
714 struct ui_file
*stream
, int recurse
,
715 const struct value_print_options
*options
)
717 enum bfd_endian byte_order
= type_byte_order (type
);
718 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
722 /* We know that ELTTYPE cannot possibly be null, because we assume
723 that we're called only when TYPE is a string-like type.
724 Similarly, the size of ELTTYPE should also be non-null, since
725 it's a character-like type. */
726 gdb_assert (elttype
!= NULL
);
727 gdb_assert (TYPE_LENGTH (elttype
) != 0);
729 eltlen
= TYPE_LENGTH (elttype
);
730 len
= TYPE_LENGTH (type
) / eltlen
;
732 if (options
->prettyformat_arrays
)
733 print_spaces_filtered (2 + 2 * recurse
, stream
);
735 /* If requested, look for the first null char and only print
736 elements up to it. */
737 if (options
->stop_print_at_null
)
741 /* Look for a NULL char. */
744 && temp_len
< options
->print_max
745 && char_at (valaddr
+ offset_aligned
,
746 temp_len
, eltlen
, byte_order
) != 0);
751 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
755 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
756 thin pointers, etc). */
759 ada_val_print_gnat_array (struct value
*val
,
760 struct ui_file
*stream
, int recurse
,
761 const struct value_print_options
*options
)
763 scoped_value_mark free_values
;
765 struct type
*type
= ada_check_typedef (value_type (val
));
767 /* If this is a reference, coerce it now. This helps taking care
768 of the case where ADDRESS is meaningless because original_value
770 val
= coerce_ref (val
);
771 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
772 val
= ada_coerce_to_simple_array_ptr (val
);
774 val
= ada_coerce_to_simple_array (val
);
777 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
778 fprintf_filtered (stream
, "0x0");
781 common_val_print (val
, stream
, recurse
, options
,
782 language_def (language_ada
));
785 /* Implement Ada val_print'ing for the case where TYPE is
789 ada_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
790 int offset
, int offset_aligned
, CORE_ADDR address
,
791 struct ui_file
*stream
, int recurse
,
792 struct value
*original_value
,
793 const struct value_print_options
*options
)
795 val_print (type
, offset
, address
, stream
, recurse
,
796 original_value
, options
, language_def (language_c
));
798 if (ada_is_tag_type (type
))
801 value_from_contents_and_address (type
,
802 valaddr
+ offset_aligned
,
803 address
+ offset_aligned
);
804 const char *name
= ada_tag_name (val
);
807 fprintf_filtered (stream
, " (%s)", name
);
811 /* Implement Ada value_print'ing for the case where TYPE is a
815 ada_value_print_ptr (struct value
*val
,
816 struct ui_file
*stream
, int recurse
,
817 const struct value_print_options
*options
)
819 common_val_print (val
, stream
, recurse
, options
, language_def (language_c
));
821 struct type
*type
= ada_check_typedef (value_type (val
));
822 if (ada_is_tag_type (type
))
824 const char *name
= ada_tag_name (val
);
827 fprintf_filtered (stream
, " (%s)", name
);
831 /* Implement Ada val_print'ing for the case where TYPE is
832 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
835 ada_val_print_num (struct type
*type
, const gdb_byte
*valaddr
,
836 int offset
, int offset_aligned
, CORE_ADDR address
,
837 struct ui_file
*stream
, int recurse
,
838 struct value
*original_value
,
839 const struct value_print_options
*options
)
841 if (ada_is_fixed_point_type (type
))
843 struct value
*scale
= ada_scaling_factor (type
);
844 struct value
*v
= value_from_contents (type
, valaddr
+ offset_aligned
);
845 v
= value_cast (value_type (scale
), v
);
846 v
= value_binop (v
, scale
, BINOP_MUL
);
848 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
850 = target_float_to_string (value_contents (v
), value_type (v
), fmt
);
851 fputs_filtered (str
.c_str (), stream
);
854 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
855 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
856 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
857 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
859 /* For enum-valued ranges, we want to recurse, because we'll end
860 up printing the constant's name rather than its numeric
861 value. Character and fixed-point types are also printed
862 differently, so recuse for those as well. */
863 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
865 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
867 /* Obscure case of range type that has different length from
868 its base type. Perform a conversion, or we will get a
869 nonsense value. Actually, we could use the same
870 code regardless of lengths; I'm just avoiding a cast. */
872 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
873 struct value
*v
= value_cast (target_type
, v1
);
875 val_print (target_type
,
876 value_embedded_offset (v
), 0, stream
,
877 recurse
+ 1, v
, options
,
878 language_def (language_ada
));
881 val_print (TYPE_TARGET_TYPE (type
), offset
,
882 address
, stream
, recurse
, original_value
,
883 options
, language_def (language_ada
));
888 int format
= (options
->format
? options
->format
889 : options
->output_format
);
893 struct value_print_options opts
= *options
;
895 opts
.format
= format
;
896 val_print_scalar_formatted (type
, offset_aligned
,
897 original_value
, &opts
, 0, stream
);
899 else if (ada_is_system_address_type (type
))
901 /* FIXME: We want to print System.Address variables using
902 the same format as for any access type. But for some
903 reason GNAT encodes the System.Address type as an int,
904 so we have to work-around this deficiency by handling
905 System.Address values as a special case. */
907 struct gdbarch
*gdbarch
= get_type_arch (type
);
908 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
909 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
912 fprintf_filtered (stream
, "(");
913 type_print (type
, "", stream
, -1);
914 fprintf_filtered (stream
, ") ");
915 fputs_filtered (paddress (gdbarch
, addr
), stream
);
919 val_print_scalar_formatted (type
, offset_aligned
,
920 original_value
, options
, 0, stream
);
921 if (ada_is_character_type (type
))
925 fputs_filtered (" ", stream
);
926 c
= unpack_long (type
, valaddr
+ offset_aligned
);
927 ada_printchar (c
, type
, stream
);
934 /* Implement Ada val_print'ing for the case where TYPE is
935 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
938 ada_value_print_num (struct value
*val
, struct ui_file
*stream
, int recurse
,
939 const struct value_print_options
*options
)
941 struct type
*type
= ada_check_typedef (value_type (val
));
942 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
944 if (ada_is_fixed_point_type (type
))
946 struct value
*scale
= ada_scaling_factor (type
);
947 val
= value_cast (value_type (scale
), val
);
948 val
= value_binop (val
, scale
, BINOP_MUL
);
950 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g";
952 = target_float_to_string (value_contents (val
), value_type (val
), fmt
);
953 fputs_filtered (str
.c_str (), stream
);
956 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
957 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_ENUM
958 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_BOOL
959 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CHAR
))
961 /* For enum-valued ranges, we want to recurse, because we'll end
962 up printing the constant's name rather than its numeric
963 value. Character and fixed-point types are also printed
964 differently, so recuse for those as well. */
965 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
966 val
= value_cast (target_type
, val
);
967 common_val_print (val
, stream
, recurse
+ 1, options
,
968 language_def (language_ada
));
973 int format
= (options
->format
? options
->format
974 : options
->output_format
);
978 struct value_print_options opts
= *options
;
980 opts
.format
= format
;
981 value_print_scalar_formatted (val
, &opts
, 0, stream
);
983 else if (ada_is_system_address_type (type
))
985 /* FIXME: We want to print System.Address variables using
986 the same format as for any access type. But for some
987 reason GNAT encodes the System.Address type as an int,
988 so we have to work-around this deficiency by handling
989 System.Address values as a special case. */
991 struct gdbarch
*gdbarch
= get_type_arch (type
);
992 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
993 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
995 fprintf_filtered (stream
, "(");
996 type_print (type
, "", stream
, -1);
997 fprintf_filtered (stream
, ") ");
998 fputs_filtered (paddress (gdbarch
, addr
), stream
);
1002 value_print_scalar_formatted (val
, options
, 0, stream
);
1003 if (ada_is_character_type (type
))
1007 fputs_filtered (" ", stream
);
1008 c
= unpack_long (type
, valaddr
);
1009 ada_printchar (c
, type
, stream
);
1016 /* Implement Ada val_print'ing for the case where TYPE is
1017 a TYPE_CODE_ENUM. */
1020 ada_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
1021 int offset
, int offset_aligned
, CORE_ADDR address
,
1022 struct ui_file
*stream
, int recurse
,
1023 struct value
*original_value
,
1024 const struct value_print_options
*options
)
1030 if (options
->format
)
1032 val_print_scalar_formatted (type
, offset_aligned
,
1033 original_value
, options
, 0, stream
);
1037 len
= TYPE_NFIELDS (type
);
1038 val
= unpack_long (type
, valaddr
+ offset_aligned
);
1039 for (i
= 0; i
< len
; i
++)
1042 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
1048 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
1050 if (name
[0] == '\'')
1051 fprintf_filtered (stream
, "%ld %ps", (long) val
,
1052 styled_string (variable_name_style
.style (),
1055 fputs_styled (name
, variable_name_style
.style (), stream
);
1058 print_longest (stream
, 'd', 0, val
);
1061 /* Implement Ada val_print'ing for the case where TYPE is
1065 ada_val_print_flt (struct type
*type
, const gdb_byte
*valaddr
,
1066 int offset
, int offset_aligned
, CORE_ADDR address
,
1067 struct ui_file
*stream
, int recurse
,
1068 struct value
*original_value
,
1069 const struct value_print_options
*options
)
1071 if (options
->format
)
1073 val_print (type
, offset
, address
, stream
, recurse
,
1074 original_value
, options
, language_def (language_c
));
1078 ada_print_floating (valaddr
+ offset
, type
, stream
);
1081 /* Implement Ada val_print'ing for the case where TYPE is
1082 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
1085 ada_val_print_struct_union
1086 (struct type
*type
, const gdb_byte
*valaddr
, int offset
,
1087 int offset_aligned
, CORE_ADDR address
, struct ui_file
*stream
,
1088 int recurse
, struct value
*original_value
,
1089 const struct value_print_options
*options
)
1091 if (ada_is_bogus_array_descriptor (type
))
1093 fprintf_filtered (stream
, "(...?)");
1097 fprintf_filtered (stream
, "(");
1099 if (print_field_values (type
, valaddr
, offset_aligned
,
1100 stream
, recurse
, original_value
, options
,
1101 0, type
, offset_aligned
,
1102 language_def (language_ada
)) != 0
1103 && options
->prettyformat
)
1105 fprintf_filtered (stream
, "\n");
1106 print_spaces_filtered (2 * recurse
, stream
);
1109 fprintf_filtered (stream
, ")");
1112 /* Implement Ada val_print'ing for the case where TYPE is
1113 a TYPE_CODE_ARRAY. */
1116 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
1117 int offset
, int offset_aligned
, CORE_ADDR address
,
1118 struct ui_file
*stream
, int recurse
,
1119 struct value
*original_value
,
1120 const struct value_print_options
*options
)
1122 /* For an array of characters, print with string syntax. */
1123 if (ada_is_string_type (type
)
1124 && (options
->format
== 0 || options
->format
== 's'))
1126 ada_val_print_string (type
, valaddr
, offset_aligned
,
1127 stream
, recurse
, options
);
1131 fprintf_filtered (stream
, "(");
1132 print_optional_low_bound (stream
, type
, options
);
1133 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
1134 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
1135 stream
, recurse
, options
);
1137 val_print_array_elements (type
, offset_aligned
, address
,
1138 stream
, recurse
, original_value
,
1140 fprintf_filtered (stream
, ")");
1143 /* Implement Ada value_print'ing for the case where TYPE is a
1147 ada_value_print_array (struct value
*val
, struct ui_file
*stream
, int recurse
,
1148 const struct value_print_options
*options
)
1150 struct type
*type
= ada_check_typedef (value_type (val
));
1152 /* For an array of characters, print with string syntax. */
1153 if (ada_is_string_type (type
)
1154 && (options
->format
== 0 || options
->format
== 's'))
1156 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1157 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1159 ada_val_print_string (type
, valaddr
, offset_aligned
, stream
, recurse
,
1164 fprintf_filtered (stream
, "(");
1165 print_optional_low_bound (stream
, type
, options
);
1166 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
1168 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1169 int offset_aligned
= ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1170 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
1171 stream
, recurse
, options
);
1174 value_print_array_elements (val
, stream
, recurse
, options
, 0);
1175 fprintf_filtered (stream
, ")");
1178 /* Implement Ada val_print'ing for the case where TYPE is
1182 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
1183 int offset
, int offset_aligned
, CORE_ADDR address
,
1184 struct ui_file
*stream
, int recurse
,
1185 struct value
*original_value
,
1186 const struct value_print_options
*options
)
1188 /* For references, the debugger is expected to print the value as
1189 an address if DEREF_REF is null. But printing an address in place
1190 of the object value would be confusing to an Ada programmer.
1191 So, for Ada values, we print the actual dereferenced value
1193 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1194 struct value
*deref_val
;
1195 CORE_ADDR deref_val_int
;
1197 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1199 fputs_styled ("<ref to undefined type>", metadata_style
.style (),
1204 deref_val
= coerce_ref_if_computed (original_value
);
1207 if (ada_is_tagged_type (value_type (deref_val
), 1))
1208 deref_val
= ada_tag_value_at_base_address (deref_val
);
1210 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1211 language_def (language_ada
));
1215 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1216 if (deref_val_int
== 0)
1218 fputs_filtered ("(null)", stream
);
1223 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1225 if (ada_is_tagged_type (value_type (deref_val
), 1))
1226 deref_val
= ada_tag_value_at_base_address (deref_val
);
1228 /* Make sure that the object does not have an unreasonable size
1229 before trying to print it. This can happen for instance with
1230 references to dynamic objects whose contents is uninitialized
1231 (Eg: an array whose bounds are not set yet). */
1232 ada_ensure_varsize_limit (value_type (deref_val
));
1234 if (value_lazy (deref_val
))
1235 value_fetch_lazy (deref_val
);
1237 common_val_print (deref_val
, stream
, recurse
+ 1,
1238 options
, language_def (language_ada
));
1241 /* See the comment on ada_val_print. This function differs in that it
1242 does not catch evaluation errors (leaving that to ada_val_print). */
1245 ada_val_print_1 (struct type
*type
,
1246 int offset
, CORE_ADDR address
,
1247 struct ui_file
*stream
, int recurse
,
1248 struct value
*original_value
,
1249 const struct value_print_options
*options
)
1252 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
1254 type
= ada_check_typedef (type
);
1256 if (ada_is_array_descriptor_type (type
)
1257 || (ada_is_constrained_packed_array_type (type
)
1258 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1260 struct value
*val
= value_from_contents_and_address (type
,
1263 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1267 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1268 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
1269 type
= resolve_dynamic_type (type
, valaddr
+ offset_aligned
,
1270 address
+ offset_aligned
);
1272 switch (TYPE_CODE (type
))
1275 val_print (type
, offset
, address
, stream
, recurse
,
1276 original_value
, options
, language_def (language_c
));
1280 ada_val_print_ptr (type
, valaddr
, offset
, offset_aligned
,
1281 address
, stream
, recurse
, original_value
,
1286 case TYPE_CODE_RANGE
:
1287 ada_val_print_num (type
, valaddr
, offset
, offset_aligned
,
1288 address
, stream
, recurse
, original_value
,
1292 case TYPE_CODE_ENUM
:
1293 ada_val_print_enum (type
, valaddr
, offset
, offset_aligned
,
1294 address
, stream
, recurse
, original_value
,
1299 ada_val_print_flt (type
, valaddr
, offset
, offset_aligned
,
1300 address
, stream
, recurse
, original_value
,
1304 case TYPE_CODE_UNION
:
1305 case TYPE_CODE_STRUCT
:
1306 ada_val_print_struct_union (type
, valaddr
, offset
, offset_aligned
,
1307 address
, stream
, recurse
,
1308 original_value
, options
);
1311 case TYPE_CODE_ARRAY
:
1312 ada_val_print_array (type
, valaddr
, offset
, offset_aligned
,
1313 address
, stream
, recurse
, original_value
,
1318 ada_val_print_ref (type
, valaddr
, offset
, offset_aligned
,
1319 address
, stream
, recurse
, original_value
,
1325 /* See val_print for a description of the various parameters of this
1326 function; they are identical. */
1329 ada_val_print (struct type
*type
,
1330 int embedded_offset
, CORE_ADDR address
,
1331 struct ui_file
*stream
, int recurse
,
1333 const struct value_print_options
*options
)
1337 ada_val_print_1 (type
, embedded_offset
, address
,
1338 stream
, recurse
, val
, options
);
1340 catch (const gdb_exception_error
&except
)
1342 fprintf_styled (stream
, metadata_style
.style (),
1343 _("<error reading variable: %s>"),
1348 /* See the comment on ada_value_print. This function differs in that
1349 it does not catch evaluation errors (leaving that to
1350 ada_value_print). */
1353 ada_value_print_1 (struct value
*val
, struct ui_file
*stream
, int recurse
,
1354 const struct value_print_options
*options
)
1356 struct type
*type
= ada_check_typedef (value_type (val
));
1358 if (ada_is_array_descriptor_type (type
)
1359 || (ada_is_constrained_packed_array_type (type
)
1360 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1362 ada_val_print_gnat_array (val
, stream
, recurse
, options
);
1366 val
= ada_to_fixed_value (val
);
1367 type
= value_type (val
);
1368 struct type
*saved_type
= type
;
1370 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1371 CORE_ADDR address
= value_address (val
);
1372 type
= ada_check_typedef (resolve_dynamic_type (type
, valaddr
, address
));
1373 if (type
!= saved_type
)
1375 val
= value_copy (val
);
1376 deprecated_set_value_type (val
, type
);
1379 switch (TYPE_CODE (type
))
1382 common_val_print (val
, stream
, recurse
, options
,
1383 language_def (language_c
));
1387 ada_value_print_ptr (val
, stream
, recurse
, options
);
1391 case TYPE_CODE_RANGE
:
1392 ada_value_print_num (val
, stream
, recurse
, options
);
1395 case TYPE_CODE_ENUM
:
1396 ada_val_print_enum (type
, valaddr
, 0, 0,
1397 address
, stream
, recurse
, val
,
1402 if (options
->format
)
1404 common_val_print (val
, stream
, recurse
, options
,
1405 language_def (language_c
));
1409 ada_print_floating (valaddr
, type
, stream
);
1412 case TYPE_CODE_UNION
:
1413 case TYPE_CODE_STRUCT
:
1414 ada_val_print_struct_union (type
, valaddr
, 0, 0,
1415 address
, stream
, recurse
,
1419 case TYPE_CODE_ARRAY
:
1420 ada_value_print_array (val
, stream
, recurse
, options
);
1424 ada_val_print_ref (type
, valaddr
, 0, 0,
1425 address
, stream
, recurse
, val
,
1431 /* See ada-lang.h. */
1434 ada_value_print_inner (struct value
*val
, struct ui_file
*stream
,
1436 const struct value_print_options
*options
)
1440 ada_value_print_1 (val
, stream
, recurse
, options
);
1442 catch (const gdb_exception_error
&except
)
1444 fprintf_styled (stream
, metadata_style
.style (),
1445 _("<error reading variable: %s>"),
1451 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1452 const struct value_print_options
*options
)
1454 struct value
*val
= ada_to_fixed_value (val0
);
1455 struct type
*type
= ada_check_typedef (value_type (val
));
1456 struct value_print_options opts
;
1458 /* If it is a pointer, indicate what it points to. */
1459 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1461 /* Hack: don't print (char *) for char strings. Their
1462 type is indicated by the quoted string anyway. */
1463 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1464 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1465 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1467 fprintf_filtered (stream
, "(");
1468 type_print (type
, "", stream
, -1);
1469 fprintf_filtered (stream
, ") ");
1472 else if (ada_is_array_descriptor_type (type
))
1474 /* We do not print the type description unless TYPE is an array
1475 access type (this is encoded by the compiler as a typedef to
1476 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1477 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1479 fprintf_filtered (stream
, "(");
1480 type_print (type
, "", stream
, -1);
1481 fprintf_filtered (stream
, ") ");
1484 else if (ada_is_bogus_array_descriptor (type
))
1486 fprintf_filtered (stream
, "(");
1487 type_print (type
, "", stream
, -1);
1488 fprintf_filtered (stream
, ") (...?)");
1494 common_val_print (val
, stream
, 0, &opts
, current_language
);