1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
35 static int print_field_values (struct type
*, const gdb_byte
*,
37 struct ui_file
*, int,
39 const struct value_print_options
*,
40 int, struct type
*, int,
41 const struct language_defn
*);
44 /* Make TYPE unsigned if its range of values includes no negatives. */
46 adjust_type_signedness (struct type
*type
)
48 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
49 && TYPE_LOW_BOUND (type
) >= 0)
50 TYPE_UNSIGNED (type
) = 1;
53 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
54 if non-standard (i.e., other than 1 for numbers, other than lower bound
55 of index type for enumerated type). Returns 1 if something printed,
59 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
60 const struct value_print_options
*options
)
62 struct type
*index_type
;
66 if (options
->print_array_indexes
)
69 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
72 /* If this is an empty array, then don't print the lower bound.
73 That would be confusing, because we would print the lower bound,
74 followed by... nothing! */
75 if (low_bound
> high_bound
)
78 index_type
= TYPE_INDEX_TYPE (type
);
80 while (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
82 /* We need to know what the base type is, in order to do the
83 appropriate check below. Otherwise, if this is a subrange
84 of an enumerated type, where the underlying value of the
85 first element is typically 0, we might test the low bound
86 against the wrong value. */
87 index_type
= TYPE_TARGET_TYPE (index_type
);
90 switch (TYPE_CODE (index_type
))
97 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
100 case TYPE_CODE_UNDEF
:
109 ada_print_scalar (index_type
, low_bound
, stream
);
110 fprintf_filtered (stream
, " => ");
114 /* Version of val_print_array_elements for GNAT-style packed arrays.
115 Prints elements of packed array of type TYPE at bit offset
116 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
117 separates with commas. RECURSE is the recursion (nesting) level.
118 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
121 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
123 int bitoffset
, struct ui_file
*stream
,
125 const struct value
*val
,
126 const struct value_print_options
*options
)
129 unsigned int things_printed
= 0;
131 struct type
*elttype
, *index_type
;
132 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
133 struct value
*mark
= value_mark ();
136 elttype
= TYPE_TARGET_TYPE (type
);
137 index_type
= TYPE_INDEX_TYPE (type
);
142 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
145 len
= high
- low
+ 1;
149 annotate_array_section_begin (i
, elttype
);
151 while (i
< len
&& things_printed
< options
->print_max
)
153 struct value
*v0
, *v1
;
158 if (options
->prettyformat_arrays
)
160 fprintf_filtered (stream
, ",\n");
161 print_spaces_filtered (2 + 2 * recurse
, stream
);
165 fprintf_filtered (stream
, ", ");
168 wrap_here (n_spaces (2 + 2 * recurse
));
169 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
172 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
173 (i0
* bitsize
) / HOST_CHAR_BIT
,
174 (i0
* bitsize
) % HOST_CHAR_BIT
,
181 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
182 (i
* bitsize
) / HOST_CHAR_BIT
,
183 (i
* bitsize
) % HOST_CHAR_BIT
,
185 if (TYPE_LENGTH (check_typedef (value_type (v0
)))
186 != TYPE_LENGTH (check_typedef (value_type (v1
))))
188 if (!value_contents_eq (v0
, value_embedded_offset (v0
),
189 v1
, value_embedded_offset (v1
),
190 TYPE_LENGTH (check_typedef (value_type (v0
)))))
194 if (i
- i0
> options
->repeat_count_threshold
)
196 struct value_print_options opts
= *options
;
199 val_print (elttype
, value_contents_for_printing (v0
),
200 value_embedded_offset (v0
), 0, stream
,
201 recurse
+ 1, v0
, &opts
, current_language
);
202 annotate_elt_rep (i
- i0
);
203 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
204 annotate_elt_rep_end ();
210 struct value_print_options opts
= *options
;
213 for (j
= i0
; j
< i
; j
+= 1)
217 if (options
->prettyformat_arrays
)
219 fprintf_filtered (stream
, ",\n");
220 print_spaces_filtered (2 + 2 * recurse
, stream
);
224 fprintf_filtered (stream
, ", ");
226 wrap_here (n_spaces (2 + 2 * recurse
));
227 maybe_print_array_index (index_type
, j
+ low
,
230 val_print (elttype
, value_contents_for_printing (v0
),
231 value_embedded_offset (v0
), 0, stream
,
232 recurse
+ 1, v0
, &opts
, current_language
);
236 things_printed
+= i
- i0
;
238 annotate_array_section_end ();
241 fprintf_filtered (stream
, "...");
244 value_free_to_mark (mark
);
248 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
250 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
253 /* Print the character C on STREAM as part of the contents of a literal
254 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
258 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
259 int quoter
, int type_len
)
261 /* If this character fits in the normal ASCII range, and is
262 a printable character, then print the character as if it was
263 an ASCII character, even if this is a wide character.
264 The UCHAR_MAX check is necessary because the isascii function
265 requires that its argument have a value of an unsigned char,
266 or EOF (EOF is obviously not printable). */
267 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
269 if (c
== quoter
&& c
== '"')
270 fprintf_filtered (stream
, "\"\"");
272 fprintf_filtered (stream
, "%c", c
);
275 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
278 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
282 char_at (const gdb_byte
*string
, int i
, int type_len
,
283 enum bfd_endian byte_order
)
288 return (int) extract_unsigned_integer (string
+ type_len
* i
,
289 type_len
, byte_order
);
292 /* Print a floating-point value of type TYPE, pointed to in GDB by
293 VALADDR, on STREAM. Use Ada formatting conventions: there must be
294 a decimal point, and at least one digit before and after the
295 point. We use the GNAT format for NaNs and infinities. */
298 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
299 struct ui_file
*stream
)
301 struct ui_file
*tmp_stream
= mem_fileopen ();
302 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
304 print_floating (valaddr
, type
, tmp_stream
);
306 std::string s
= ui_file_as_string (tmp_stream
);
307 size_t skip_count
= 0;
309 /* Modify for Ada rules. */
311 size_t pos
= s
.find ("inf");
312 if (pos
== std::string::npos
)
313 pos
= s
.find ("Inf");
314 if (pos
== std::string::npos
)
315 pos
= s
.find ("INF");
316 if (pos
!= std::string::npos
)
317 s
.replace (pos
, 3, "Inf");
319 if (pos
== std::string::npos
)
321 pos
= s
.find ("nan");
322 if (pos
== std::string::npos
)
323 pos
= s
.find ("NaN");
324 if (pos
== std::string::npos
)
325 pos
= s
.find ("Nan");
326 if (pos
!= std::string::npos
)
328 s
[pos
] = s
[pos
+ 2] = 'N';
334 if (pos
== std::string::npos
335 && s
.find ('.') == std::string::npos
)
338 if (pos
== std::string::npos
)
339 fprintf_filtered (stream
, "%s.0", s
.c_str ());
341 fprintf_filtered (stream
, "%.*s.0%s", (int) pos
, s
.c_str (), &s
[pos
]);
344 fprintf_filtered (stream
, "%s", &s
[skip_count
]);
346 do_cleanups (cleanups
);
350 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
352 fputs_filtered ("'", stream
);
353 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
354 fputs_filtered ("'", stream
);
357 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
358 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
359 like a default signed integer. */
362 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
369 print_longest (stream
, 'd', 0, val
);
373 type
= ada_check_typedef (type
);
375 switch (TYPE_CODE (type
))
379 len
= TYPE_NFIELDS (type
);
380 for (i
= 0; i
< len
; i
++)
382 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
389 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
393 print_longest (stream
, 'd', 0, val
);
398 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
402 LA_PRINT_CHAR (val
, type
, stream
);
406 fprintf_filtered (stream
, val
? "true" : "false");
409 case TYPE_CODE_RANGE
:
410 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
413 case TYPE_CODE_UNDEF
:
415 case TYPE_CODE_ARRAY
:
416 case TYPE_CODE_STRUCT
:
417 case TYPE_CODE_UNION
:
422 case TYPE_CODE_STRING
:
423 case TYPE_CODE_ERROR
:
424 case TYPE_CODE_MEMBERPTR
:
425 case TYPE_CODE_METHODPTR
:
426 case TYPE_CODE_METHOD
:
428 warning (_("internal error: unhandled type in ada_print_scalar"));
432 error (_("Invalid type code in symbol table."));
437 /* Print the character string STRING, printing at most LENGTH characters.
438 Printing stops early if the number hits print_max; repeat counts
439 are printed as appropriate. Print ellipses at the end if we
440 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
441 TYPE_LEN is the length (1 or 2) of the character type. */
444 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
445 unsigned int length
, int force_ellipses
, int type_len
,
446 const struct value_print_options
*options
)
448 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
450 unsigned int things_printed
= 0;
456 fputs_filtered ("\"\"", stream
);
460 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
462 /* Position of the character we are examining
463 to see whether it is repeated. */
465 /* Number of repetitions we have detected so far. */
472 fputs_filtered (", ", stream
);
479 && char_at (string
, rep1
, type_len
, byte_order
)
480 == char_at (string
, i
, type_len
, byte_order
))
486 if (reps
> options
->repeat_count_threshold
)
490 fputs_filtered ("\", ", stream
);
493 fputs_filtered ("'", stream
);
494 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
495 elttype
, stream
, '\'', type_len
);
496 fputs_filtered ("'", stream
);
497 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
499 things_printed
+= options
->repeat_count_threshold
;
506 fputs_filtered ("\"", stream
);
509 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
510 elttype
, stream
, '"', type_len
);
515 /* Terminate the quotes if necessary. */
517 fputs_filtered ("\"", stream
);
519 if (force_ellipses
|| i
< length
)
520 fputs_filtered ("...", stream
);
524 ada_printstr (struct ui_file
*stream
, struct type
*type
,
525 const gdb_byte
*string
, unsigned int length
,
526 const char *encoding
, int force_ellipses
,
527 const struct value_print_options
*options
)
529 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
534 print_variant_part (struct type
*type
, int field_num
,
535 const gdb_byte
*valaddr
, int offset
,
536 struct ui_file
*stream
, int recurse
,
537 const struct value
*val
,
538 const struct value_print_options
*options
,
540 struct type
*outer_type
, int outer_offset
,
541 const struct language_defn
*language
)
543 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
544 int which
= ada_which_variant_applies (var_type
, outer_type
,
545 valaddr
+ outer_offset
);
550 return print_field_values
551 (TYPE_FIELD_TYPE (var_type
, which
),
553 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
554 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
555 stream
, recurse
, val
, options
,
556 comma_needed
, outer_type
, outer_offset
, language
);
559 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
561 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
562 meanings as in ada_print_value and ada_val_print.
564 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
565 record (used to get discriminant values when printing variant
568 COMMA_NEEDED is 1 if fields have been printed at the current recursion
569 level, so that a comma is needed before any field printed by this
572 Returns 1 if COMMA_NEEDED or any fields were printed. */
575 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
576 int offset
, struct ui_file
*stream
, int recurse
,
577 const struct value
*val
,
578 const struct value_print_options
*options
,
580 struct type
*outer_type
, int outer_offset
,
581 const struct language_defn
*language
)
585 len
= TYPE_NFIELDS (type
);
587 for (i
= 0; i
< len
; i
+= 1)
589 if (ada_is_ignored_field (type
, i
))
592 if (ada_is_wrapper_field (type
, i
))
595 print_field_values (TYPE_FIELD_TYPE (type
, i
),
598 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
599 stream
, recurse
, val
, options
,
600 comma_needed
, type
, offset
, language
);
603 else if (ada_is_variant_part (type
, i
))
606 print_variant_part (type
, i
, valaddr
,
607 offset
, stream
, recurse
, val
,
608 options
, comma_needed
,
609 outer_type
, outer_offset
, language
);
614 fprintf_filtered (stream
, ", ");
617 if (options
->prettyformat
)
619 fprintf_filtered (stream
, "\n");
620 print_spaces_filtered (2 + 2 * recurse
, stream
);
624 wrap_here (n_spaces (2 + 2 * recurse
));
627 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
628 fprintf_filtered (stream
, "%.*s",
629 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
630 TYPE_FIELD_NAME (type
, i
));
631 annotate_field_name_end ();
632 fputs_filtered (" => ", stream
);
633 annotate_field_value ();
635 if (TYPE_FIELD_PACKED (type
, i
))
639 /* Bitfields require special handling, especially due to byte
641 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
643 fputs_filtered (_("<optimized out or zero length>"), stream
);
647 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
648 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
649 struct value_print_options opts
;
651 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
652 v
= ada_value_primitive_packed_val
654 offset
+ bit_pos
/ HOST_CHAR_BIT
,
655 bit_pos
% HOST_CHAR_BIT
,
656 bit_size
, TYPE_FIELD_TYPE (type
, i
));
659 val_print (TYPE_FIELD_TYPE (type
, i
),
660 value_contents_for_printing (v
),
661 value_embedded_offset (v
), 0,
662 stream
, recurse
+ 1, v
,
668 struct value_print_options opts
= *options
;
671 val_print (TYPE_FIELD_TYPE (type
, i
), valaddr
,
672 (offset
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
673 0, stream
, recurse
+ 1, val
, &opts
, language
);
675 annotate_field_end ();
681 /* Implement Ada val_print'ing for the case where TYPE is
682 a TYPE_CODE_ARRAY of characters. */
685 ada_val_print_string (struct type
*type
, const gdb_byte
*valaddr
,
686 int offset
, int offset_aligned
, CORE_ADDR address
,
687 struct ui_file
*stream
, int recurse
,
688 const struct value
*original_value
,
689 const struct value_print_options
*options
)
691 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
692 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
696 /* We know that ELTTYPE cannot possibly be null, because we assume
697 that we're called only when TYPE is a string-like type.
698 Similarly, the size of ELTTYPE should also be non-null, since
699 it's a character-like type. */
700 gdb_assert (elttype
!= NULL
);
701 gdb_assert (TYPE_LENGTH (elttype
) != 0);
703 eltlen
= TYPE_LENGTH (elttype
);
704 len
= TYPE_LENGTH (type
) / eltlen
;
706 if (options
->prettyformat_arrays
)
707 print_spaces_filtered (2 + 2 * recurse
, stream
);
709 /* If requested, look for the first null char and only print
710 elements up to it. */
711 if (options
->stop_print_at_null
)
715 /* Look for a NULL char. */
718 && temp_len
< options
->print_max
719 && char_at (valaddr
+ offset_aligned
,
720 temp_len
, eltlen
, byte_order
) != 0);
725 printstr (stream
, elttype
, valaddr
+ offset_aligned
, len
, 0,
729 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
730 thin pointers, etc). */
733 ada_val_print_gnat_array (struct type
*type
, const gdb_byte
*valaddr
,
734 int offset
, CORE_ADDR address
,
735 struct ui_file
*stream
, int recurse
,
736 const struct value
*original_value
,
737 const struct value_print_options
*options
,
738 const struct language_defn
*language
)
740 struct value
*mark
= value_mark ();
743 val
= value_from_contents_and_address (type
, valaddr
+ offset
, address
);
744 /* If this is a reference, coerce it now. This helps taking care
745 of the case where ADDRESS is meaningless because original_value
747 val
= coerce_ref (val
);
748 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
749 val
= ada_coerce_to_simple_array_ptr (val
);
751 val
= ada_coerce_to_simple_array (val
);
754 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
755 fprintf_filtered (stream
, "0x0");
758 val_print (value_type (val
), value_contents_for_printing (val
),
759 value_embedded_offset (val
), value_address (val
),
760 stream
, recurse
, val
, options
, language
);
761 value_free_to_mark (mark
);
764 /* Implement Ada val_print'ing for the case where TYPE is
768 ada_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
769 int offset
, int offset_aligned
, CORE_ADDR address
,
770 struct ui_file
*stream
, int recurse
,
771 const struct value
*original_value
,
772 const struct value_print_options
*options
,
773 const struct language_defn
*language
)
775 val_print (type
, valaddr
, offset
, address
, stream
, recurse
,
776 original_value
, options
, language_def (language_c
));
778 if (ada_is_tag_type (type
))
781 value_from_contents_and_address (type
,
782 valaddr
+ offset_aligned
,
783 address
+ offset_aligned
);
784 const char *name
= ada_tag_name (val
);
787 fprintf_filtered (stream
, " (%s)", name
);
791 /* Implement Ada val_print'ing for the case where TYPE is
792 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
795 ada_val_print_num (struct type
*type
, const gdb_byte
*valaddr
,
796 int offset
, int offset_aligned
, CORE_ADDR address
,
797 struct ui_file
*stream
, int recurse
,
798 const struct value
*original_value
,
799 const struct value_print_options
*options
,
800 const struct language_defn
*language
)
802 if (ada_is_fixed_point_type (type
))
804 LONGEST v
= unpack_long (type
, valaddr
+ offset_aligned
);
806 fprintf_filtered (stream
, TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g",
807 (double) ada_fixed_to_float (type
, v
));
810 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
812 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
814 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
816 /* Obscure case of range type that has different length from
817 its base type. Perform a conversion, or we will get a
818 nonsense value. Actually, we could use the same
819 code regardless of lengths; I'm just avoiding a cast. */
821 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
822 struct value
*v
= value_cast (target_type
, v1
);
824 val_print (target_type
, value_contents_for_printing (v
),
825 value_embedded_offset (v
), 0, stream
,
826 recurse
+ 1, v
, options
, language
);
829 val_print (TYPE_TARGET_TYPE (type
), valaddr
, offset
,
830 address
, stream
, recurse
, original_value
,
836 int format
= (options
->format
? options
->format
837 : options
->output_format
);
841 struct value_print_options opts
= *options
;
843 opts
.format
= format
;
844 val_print_scalar_formatted (type
, valaddr
, offset_aligned
,
845 original_value
, &opts
, 0, stream
);
847 else if (ada_is_system_address_type (type
))
849 /* FIXME: We want to print System.Address variables using
850 the same format as for any access type. But for some
851 reason GNAT encodes the System.Address type as an int,
852 so we have to work-around this deficiency by handling
853 System.Address values as a special case. */
855 struct gdbarch
*gdbarch
= get_type_arch (type
);
856 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
857 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
860 fprintf_filtered (stream
, "(");
861 type_print (type
, "", stream
, -1);
862 fprintf_filtered (stream
, ") ");
863 fputs_filtered (paddress (gdbarch
, addr
), stream
);
867 val_print_type_code_int (type
, valaddr
+ offset_aligned
, stream
);
868 if (ada_is_character_type (type
))
872 fputs_filtered (" ", stream
);
873 c
= unpack_long (type
, valaddr
+ offset_aligned
);
874 ada_printchar (c
, type
, stream
);
881 /* Implement Ada val_print'ing for the case where TYPE is
885 ada_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
886 int offset
, int offset_aligned
, CORE_ADDR address
,
887 struct ui_file
*stream
, int recurse
,
888 const struct value
*original_value
,
889 const struct value_print_options
*options
,
890 const struct language_defn
*language
)
898 val_print_scalar_formatted (type
, valaddr
, offset_aligned
,
899 original_value
, options
, 0, stream
);
903 len
= TYPE_NFIELDS (type
);
904 val
= unpack_long (type
, valaddr
+ offset_aligned
);
905 for (i
= 0; i
< len
; i
++)
908 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
914 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
917 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
919 fputs_filtered (name
, stream
);
922 print_longest (stream
, 'd', 0, val
);
925 /* Implement Ada val_print'ing for the case where TYPE is
929 ada_val_print_flt (struct type
*type
, const gdb_byte
*valaddr
,
930 int offset
, int offset_aligned
, CORE_ADDR address
,
931 struct ui_file
*stream
, int recurse
,
932 const struct value
*original_value
,
933 const struct value_print_options
*options
,
934 const struct language_defn
*language
)
938 val_print (type
, valaddr
, offset
, address
, stream
, recurse
,
939 original_value
, options
, language_def (language_c
));
943 ada_print_floating (valaddr
+ offset
, type
, stream
);
946 /* Implement Ada val_print'ing for the case where TYPE is
947 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
950 ada_val_print_struct_union
951 (struct type
*type
, const gdb_byte
*valaddr
, int offset
,
952 int offset_aligned
, CORE_ADDR address
, struct ui_file
*stream
,
953 int recurse
, const struct value
*original_value
,
954 const struct value_print_options
*options
,
955 const struct language_defn
*language
)
957 if (ada_is_bogus_array_descriptor (type
))
959 fprintf_filtered (stream
, "(...?)");
963 fprintf_filtered (stream
, "(");
965 if (print_field_values (type
, valaddr
, offset_aligned
,
966 stream
, recurse
, original_value
, options
,
967 0, type
, offset_aligned
, language
) != 0
968 && options
->prettyformat
)
970 fprintf_filtered (stream
, "\n");
971 print_spaces_filtered (2 * recurse
, stream
);
974 fprintf_filtered (stream
, ")");
977 /* Implement Ada val_print'ing for the case where TYPE is
978 a TYPE_CODE_ARRAY. */
981 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
982 int offset
, int offset_aligned
, CORE_ADDR address
,
983 struct ui_file
*stream
, int recurse
,
984 const struct value
*original_value
,
985 const struct value_print_options
*options
)
987 /* For an array of characters, print with string syntax. */
988 if (ada_is_string_type (type
)
989 && (options
->format
== 0 || options
->format
== 's'))
991 ada_val_print_string (type
, valaddr
, offset
, offset_aligned
,
992 address
, stream
, recurse
, original_value
,
997 fprintf_filtered (stream
, "(");
998 print_optional_low_bound (stream
, type
, options
);
999 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
1000 val_print_packed_array_elements (type
, valaddr
, offset_aligned
,
1002 original_value
, options
);
1004 val_print_array_elements (type
, valaddr
, offset_aligned
, address
,
1005 stream
, recurse
, original_value
,
1007 fprintf_filtered (stream
, ")");
1010 /* Implement Ada val_print'ing for the case where TYPE is
1014 ada_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
1015 int offset
, int offset_aligned
, CORE_ADDR address
,
1016 struct ui_file
*stream
, int recurse
,
1017 const struct value
*original_value
,
1018 const struct value_print_options
*options
,
1019 const struct language_defn
*language
)
1021 /* For references, the debugger is expected to print the value as
1022 an address if DEREF_REF is null. But printing an address in place
1023 of the object value would be confusing to an Ada programmer.
1024 So, for Ada values, we print the actual dereferenced value
1026 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
1027 struct value
*deref_val
;
1028 CORE_ADDR deref_val_int
;
1030 if (TYPE_CODE (elttype
) == TYPE_CODE_UNDEF
)
1032 fputs_filtered ("<ref to undefined type>", stream
);
1036 deref_val
= coerce_ref_if_computed (original_value
);
1039 if (ada_is_tagged_type (value_type (deref_val
), 1))
1040 deref_val
= ada_tag_value_at_base_address (deref_val
);
1042 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
1047 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
1048 if (deref_val_int
== 0)
1050 fputs_filtered ("(null)", stream
);
1055 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype
),
1057 if (ada_is_tagged_type (value_type (deref_val
), 1))
1058 deref_val
= ada_tag_value_at_base_address (deref_val
);
1060 /* Make sure that the object does not have an unreasonable size
1061 before trying to print it. This can happen for instance with
1062 references to dynamic objects whose contents is uninitialized
1063 (Eg: an array whose bounds are not set yet). */
1064 ada_ensure_varsize_limit (value_type (deref_val
));
1066 val_print (value_type (deref_val
),
1067 value_contents_for_printing (deref_val
),
1068 value_embedded_offset (deref_val
),
1069 value_address (deref_val
), stream
, recurse
+ 1,
1070 deref_val
, options
, language
);
1073 /* See the comment on ada_val_print. This function differs in that it
1074 does not catch evaluation errors (leaving that to ada_val_print). */
1077 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr
,
1078 int offset
, CORE_ADDR address
,
1079 struct ui_file
*stream
, int recurse
,
1080 const struct value
*original_value
,
1081 const struct value_print_options
*options
,
1082 const struct language_defn
*language
)
1086 type
= ada_check_typedef (type
);
1088 if (ada_is_array_descriptor_type (type
)
1089 || (ada_is_constrained_packed_array_type (type
)
1090 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
1092 ada_val_print_gnat_array (type
, valaddr
, offset
, address
,
1093 stream
, recurse
, original_value
,
1098 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
1099 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
1100 type
= resolve_dynamic_type (type
, valaddr
+ offset_aligned
,
1101 address
+ offset_aligned
);
1103 switch (TYPE_CODE (type
))
1106 val_print (type
, valaddr
, offset
, address
, stream
, recurse
,
1107 original_value
, options
, language_def (language_c
));
1111 ada_val_print_ptr (type
, valaddr
, offset
, offset_aligned
,
1112 address
, stream
, recurse
, original_value
,
1117 case TYPE_CODE_RANGE
:
1118 ada_val_print_num (type
, valaddr
, offset
, offset_aligned
,
1119 address
, stream
, recurse
, original_value
,
1123 case TYPE_CODE_ENUM
:
1124 ada_val_print_enum (type
, valaddr
, offset
, offset_aligned
,
1125 address
, stream
, recurse
, original_value
,
1130 ada_val_print_flt (type
, valaddr
, offset
, offset_aligned
,
1131 address
, stream
, recurse
, original_value
,
1135 case TYPE_CODE_UNION
:
1136 case TYPE_CODE_STRUCT
:
1137 ada_val_print_struct_union (type
, valaddr
, offset
, offset_aligned
,
1138 address
, stream
, recurse
,
1139 original_value
, options
, language
);
1142 case TYPE_CODE_ARRAY
:
1143 ada_val_print_array (type
, valaddr
, offset
, offset_aligned
,
1144 address
, stream
, recurse
, original_value
,
1149 ada_val_print_ref (type
, valaddr
, offset
, offset_aligned
,
1150 address
, stream
, recurse
, original_value
,
1156 /* See val_print for a description of the various parameters of this
1157 function; they are identical. */
1160 ada_val_print (struct type
*type
, const gdb_byte
*valaddr
,
1161 int embedded_offset
, CORE_ADDR address
,
1162 struct ui_file
*stream
, int recurse
,
1163 const struct value
*val
,
1164 const struct value_print_options
*options
)
1167 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
1170 ada_val_print_1 (type
, valaddr
, embedded_offset
, address
,
1171 stream
, recurse
, val
, options
,
1174 CATCH (except
, RETURN_MASK_ALL
)
1181 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
1182 const struct value_print_options
*options
)
1184 struct value
*val
= ada_to_fixed_value (val0
);
1185 CORE_ADDR address
= value_address (val
);
1186 struct type
*type
= ada_check_typedef (value_enclosing_type (val
));
1187 struct value_print_options opts
;
1189 /* If it is a pointer, indicate what it points to. */
1190 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1192 /* Hack: don't print (char *) for char strings. Their
1193 type is indicated by the quoted string anyway. */
1194 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
1195 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
1196 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
1198 fprintf_filtered (stream
, "(");
1199 type_print (type
, "", stream
, -1);
1200 fprintf_filtered (stream
, ") ");
1203 else if (ada_is_array_descriptor_type (type
))
1205 /* We do not print the type description unless TYPE is an array
1206 access type (this is encoded by the compiler as a typedef to
1207 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1208 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1210 fprintf_filtered (stream
, "(");
1211 type_print (type
, "", stream
, -1);
1212 fprintf_filtered (stream
, ") ");
1215 else if (ada_is_bogus_array_descriptor (type
))
1217 fprintf_filtered (stream
, "(");
1218 type_print (type
, "", stream
, -1);
1219 fprintf_filtered (stream
, ") (...?)");
1225 val_print (type
, value_contents_for_printing (val
),
1226 value_embedded_offset (val
), address
,
1227 stream
, 0, val
, &opts
, current_language
);