1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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/>. */
25 #include "expression.h"
34 #include "exceptions.h"
37 static void print_record (struct type
*, const gdb_byte
*, int,
41 const struct value_print_options
*);
43 static int print_field_values (struct type
*, const gdb_byte
*,
45 struct ui_file
*, int,
47 const struct value_print_options
*,
48 int, struct type
*, int);
50 static void adjust_type_signedness (struct type
*);
52 static void ada_val_print_1 (struct type
*, const gdb_byte
*, int, CORE_ADDR
,
53 struct ui_file
*, int,
55 const struct value_print_options
*);
58 /* Make TYPE unsigned if its range of values includes no negatives. */
60 adjust_type_signedness (struct type
*type
)
62 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
63 && TYPE_LOW_BOUND (type
) >= 0)
64 TYPE_UNSIGNED (type
) = 1;
67 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
68 if non-standard (i.e., other than 1 for numbers, other than lower bound
69 of index type for enumerated type). Returns 1 if something printed,
73 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
74 const struct value_print_options
*options
)
76 struct type
*index_type
;
80 if (options
->print_array_indexes
)
83 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
86 /* If this is an empty array, then don't print the lower bound.
87 That would be confusing, because we would print the lower bound,
88 followed by... nothing! */
89 if (low_bound
> high_bound
)
92 index_type
= TYPE_INDEX_TYPE (type
);
94 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
96 /* We need to know what the base type is, in order to do the
97 appropriate check below. Otherwise, if this is a subrange
98 of an enumerated type, where the underlying value of the
99 first element is typically 0, we might test the low bound
100 against the wrong value. */
101 index_type
= TYPE_TARGET_TYPE (index_type
);
104 switch (TYPE_CODE (index_type
))
111 if (low_bound
== TYPE_FIELD_ENUMVAL (index_type
, 0))
114 case TYPE_CODE_UNDEF
:
123 ada_print_scalar (index_type
, low_bound
, stream
);
124 fprintf_filtered (stream
, " => ");
128 /* Version of val_print_array_elements for GNAT-style packed arrays.
129 Prints elements of packed array of type TYPE at bit offset
130 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
131 separates with commas. RECURSE is the recursion (nesting) level.
132 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
135 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
137 int bitoffset
, struct ui_file
*stream
,
139 const struct value
*val
,
140 const struct value_print_options
*options
)
143 unsigned int things_printed
= 0;
145 struct type
*elttype
, *index_type
;
147 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
148 struct value
*mark
= value_mark ();
151 elttype
= TYPE_TARGET_TYPE (type
);
152 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
153 index_type
= TYPE_INDEX_TYPE (type
);
158 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
161 len
= high
- low
+ 1;
165 annotate_array_section_begin (i
, elttype
);
167 while (i
< len
&& things_printed
< options
->print_max
)
169 struct value
*v0
, *v1
;
174 if (options
->prettyformat_arrays
)
176 fprintf_filtered (stream
, ",\n");
177 print_spaces_filtered (2 + 2 * recurse
, stream
);
181 fprintf_filtered (stream
, ", ");
184 wrap_here (n_spaces (2 + 2 * recurse
));
185 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
188 v0
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
189 (i0
* bitsize
) / HOST_CHAR_BIT
,
190 (i0
* bitsize
) % HOST_CHAR_BIT
,
197 v1
= ada_value_primitive_packed_val (NULL
, valaddr
+ offset
,
198 (i
* bitsize
) / HOST_CHAR_BIT
,
199 (i
* bitsize
) % HOST_CHAR_BIT
,
201 if (!value_available_contents_eq (v0
, value_embedded_offset (v0
),
202 v1
, value_embedded_offset (v1
),
207 if (i
- i0
> options
->repeat_count_threshold
)
209 struct value_print_options opts
= *options
;
212 val_print (elttype
, value_contents_for_printing (v0
),
213 value_embedded_offset (v0
), 0, stream
,
214 recurse
+ 1, v0
, &opts
, current_language
);
215 annotate_elt_rep (i
- i0
);
216 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
217 annotate_elt_rep_end ();
223 struct value_print_options opts
= *options
;
226 for (j
= i0
; j
< i
; j
+= 1)
230 if (options
->prettyformat_arrays
)
232 fprintf_filtered (stream
, ",\n");
233 print_spaces_filtered (2 + 2 * recurse
, stream
);
237 fprintf_filtered (stream
, ", ");
239 wrap_here (n_spaces (2 + 2 * recurse
));
240 maybe_print_array_index (index_type
, j
+ low
,
243 val_print (elttype
, value_contents_for_printing (v0
),
244 value_embedded_offset (v0
), 0, stream
,
245 recurse
+ 1, v0
, &opts
, current_language
);
249 things_printed
+= i
- i0
;
251 annotate_array_section_end ();
254 fprintf_filtered (stream
, "...");
257 value_free_to_mark (mark
);
261 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
263 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
266 /* Print the character C on STREAM as part of the contents of a literal
267 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
271 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
272 int quoter
, int type_len
)
274 /* If this character fits in the normal ASCII range, and is
275 a printable character, then print the character as if it was
276 an ASCII character, even if this is a wide character.
277 The UCHAR_MAX check is necessary because the isascii function
278 requires that its argument have a value of an unsigned char,
279 or EOF (EOF is obviously not printable). */
280 if (c
<= UCHAR_MAX
&& isascii (c
) && isprint (c
))
282 if (c
== quoter
&& c
== '"')
283 fprintf_filtered (stream
, "\"\"");
285 fprintf_filtered (stream
, "%c", c
);
288 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
291 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
295 char_at (const gdb_byte
*string
, int i
, int type_len
,
296 enum bfd_endian byte_order
)
301 return (int) extract_unsigned_integer (string
+ type_len
* i
,
302 type_len
, byte_order
);
305 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
307 ui_memcpy (void *dest
, const char *buffer
, long len
)
309 memcpy (dest
, buffer
, (size_t) len
);
310 ((char *) dest
)[len
] = '\0';
313 /* Print a floating-point value of type TYPE, pointed to in GDB by
314 VALADDR, on STREAM. Use Ada formatting conventions: there must be
315 a decimal point, and at least one digit before and after the
316 point. We use GNAT format for NaNs and infinities. */
318 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
319 struct ui_file
*stream
)
323 struct ui_file
*tmp_stream
= mem_fileopen ();
324 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
326 print_floating (valaddr
, type
, tmp_stream
);
327 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
328 do_cleanups (cleanups
);
332 /* Modify for Ada rules. */
334 s
= strstr (result
, "inf");
336 s
= strstr (result
, "Inf");
338 s
= strstr (result
, "INF");
344 s
= strstr (result
, "nan");
346 s
= strstr (result
, "NaN");
348 s
= strstr (result
, "Nan");
352 if (result
[0] == '-')
357 if (s
== NULL
&& strchr (result
, '.') == NULL
)
359 s
= strchr (result
, 'e');
361 fprintf_filtered (stream
, "%s.0", result
);
363 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
366 fprintf_filtered (stream
, "%s", result
);
370 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
372 fputs_filtered ("'", stream
);
373 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
374 fputs_filtered ("'", stream
);
377 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
378 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
379 like a default signed integer. */
382 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
389 print_longest (stream
, 'd', 0, val
);
393 type
= ada_check_typedef (type
);
395 switch (TYPE_CODE (type
))
399 len
= TYPE_NFIELDS (type
);
400 for (i
= 0; i
< len
; i
++)
402 if (TYPE_FIELD_ENUMVAL (type
, i
) == val
)
409 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
413 print_longest (stream
, 'd', 0, val
);
418 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
422 LA_PRINT_CHAR (val
, type
, stream
);
426 fprintf_filtered (stream
, val
? "true" : "false");
429 case TYPE_CODE_RANGE
:
430 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
433 case TYPE_CODE_UNDEF
:
435 case TYPE_CODE_ARRAY
:
436 case TYPE_CODE_STRUCT
:
437 case TYPE_CODE_UNION
:
442 case TYPE_CODE_STRING
:
443 case TYPE_CODE_ERROR
:
444 case TYPE_CODE_MEMBERPTR
:
445 case TYPE_CODE_METHODPTR
:
446 case TYPE_CODE_METHOD
:
448 warning (_("internal error: unhandled type in ada_print_scalar"));
452 error (_("Invalid type code in symbol table."));
457 /* Print the character string STRING, printing at most LENGTH characters.
458 Printing stops early if the number hits print_max; repeat counts
459 are printed as appropriate. Print ellipses at the end if we
460 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
461 TYPE_LEN is the length (1 or 2) of the character type. */
464 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
465 unsigned int length
, int force_ellipses
, int type_len
,
466 const struct value_print_options
*options
)
468 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
470 unsigned int things_printed
= 0;
476 fputs_filtered ("\"\"", stream
);
480 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
482 /* Position of the character we are examining
483 to see whether it is repeated. */
485 /* Number of repetitions we have detected so far. */
492 fputs_filtered (", ", stream
);
499 && char_at (string
, rep1
, type_len
, byte_order
)
500 == char_at (string
, i
, type_len
, byte_order
))
506 if (reps
> options
->repeat_count_threshold
)
510 fputs_filtered ("\", ", stream
);
513 fputs_filtered ("'", stream
);
514 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
515 elttype
, stream
, '\'', type_len
);
516 fputs_filtered ("'", stream
);
517 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
519 things_printed
+= options
->repeat_count_threshold
;
526 fputs_filtered ("\"", stream
);
529 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
530 elttype
, stream
, '"', type_len
);
535 /* Terminate the quotes if necessary. */
537 fputs_filtered ("\"", stream
);
539 if (force_ellipses
|| i
< length
)
540 fputs_filtered ("...", stream
);
544 ada_printstr (struct ui_file
*stream
, struct type
*type
,
545 const gdb_byte
*string
, unsigned int length
,
546 const char *encoding
, int force_ellipses
,
547 const struct value_print_options
*options
)
549 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
554 /* See val_print for a description of the various parameters of this
555 function; they are identical. */
558 ada_val_print (struct type
*type
, const gdb_byte
*valaddr
,
559 int embedded_offset
, CORE_ADDR address
,
560 struct ui_file
*stream
, int recurse
,
561 const struct value
*val
,
562 const struct value_print_options
*options
)
564 volatile struct gdb_exception except
;
566 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
567 TRY_CATCH (except
, RETURN_MASK_ALL
)
569 ada_val_print_1 (type
, valaddr
, embedded_offset
, address
,
570 stream
, recurse
, val
, options
);
574 /* Assuming TYPE is a simple array, print the value of this array located
575 at VALADDR + OFFSET. See ada_val_print for a description of the various
576 parameters of this function; they are identical. */
579 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
580 int offset
, CORE_ADDR address
,
581 struct ui_file
*stream
, int recurse
,
582 const struct value
*val
,
583 const struct value_print_options
*options
)
585 /* For an array of chars, print with string syntax. */
586 if (ada_is_string_type (type
)
587 && (options
->format
== 0 || options
->format
== 's'))
589 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
590 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
594 /* We know that ELTTYPE cannot possibly be null, because we found
595 that TYPE is a string-like type. Similarly, the size of ELTTYPE
596 should also be non-null, since it's a character-like type. */
597 gdb_assert (elttype
!= NULL
);
598 gdb_assert (TYPE_LENGTH (elttype
) != 0);
600 eltlen
= TYPE_LENGTH (elttype
);
601 len
= TYPE_LENGTH (type
) / eltlen
;
603 if (options
->prettyformat_arrays
)
604 print_spaces_filtered (2 + 2 * recurse
, stream
);
606 /* If requested, look for the first null char and only print
607 elements up to it. */
608 if (options
->stop_print_at_null
)
612 /* Look for a NULL char. */
615 && temp_len
< options
->print_max
616 && char_at (valaddr
+ offset
,
617 temp_len
, eltlen
, byte_order
) != 0);
622 printstr (stream
, elttype
, valaddr
+ offset
, len
, 0, eltlen
, options
);
626 fprintf_filtered (stream
, "(");
627 print_optional_low_bound (stream
, type
, options
);
628 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
629 val_print_packed_array_elements (type
, valaddr
, offset
,
630 0, stream
, recurse
, val
, options
);
632 val_print_array_elements (type
, valaddr
, offset
, address
,
633 stream
, recurse
, val
, options
, 0);
634 fprintf_filtered (stream
, ")");
638 /* See the comment on ada_val_print. This function differs in that it
639 does not catch evaluation errors (leaving that to ada_val_print). */
642 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr
,
643 int offset
, CORE_ADDR address
,
644 struct ui_file
*stream
, int recurse
,
645 const struct value
*original_value
,
646 const struct value_print_options
*options
)
649 struct type
*elttype
;
652 type
= ada_check_typedef (type
);
654 if (ada_is_array_descriptor_type (type
)
655 || (ada_is_constrained_packed_array_type (type
)
656 && TYPE_CODE (type
) != TYPE_CODE_PTR
))
658 struct value
*mark
= value_mark ();
661 val
= value_from_contents_and_address (type
, valaddr
+ offset
, address
);
662 /* If this is a reference, coerce it now. This helps taking care
663 of the case where ADDRESS is meaningless because original_value
665 val
= coerce_ref (val
);
666 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
667 val
= ada_coerce_to_simple_array_ptr (val
);
669 val
= ada_coerce_to_simple_array (val
);
672 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
673 fprintf_filtered (stream
, "0x0");
676 ada_val_print_1 (value_type (val
),
677 value_contents_for_printing (val
),
678 value_embedded_offset (val
),
679 value_address (val
), stream
, recurse
,
681 value_free_to_mark (mark
);
685 offset_aligned
= offset
+ ada_aligned_value_addr (type
, valaddr
) - valaddr
;
686 type
= printable_val_type (type
, valaddr
+ offset_aligned
);
688 switch (TYPE_CODE (type
))
691 c_val_print (type
, valaddr
, offset
, address
, stream
,
692 recurse
, original_value
, options
);
697 c_val_print (type
, valaddr
, offset
, address
,
698 stream
, recurse
, original_value
, options
);
700 if (ada_is_tag_type (type
))
703 value_from_contents_and_address (type
,
704 valaddr
+ offset_aligned
,
705 address
+ offset_aligned
);
706 const char *name
= ada_tag_name (val
);
709 fprintf_filtered (stream
, " (%s)", name
);
715 case TYPE_CODE_RANGE
:
716 if (ada_is_fixed_point_type (type
))
718 LONGEST v
= unpack_long (type
, valaddr
+ offset_aligned
);
720 fprintf_filtered (stream
, TYPE_LENGTH (type
) < 4 ? "%.11g" : "%.17g",
721 (double) ada_fixed_to_float (type
, v
));
724 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
726 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
728 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
730 /* Obscure case of range type that has different length from
731 its base type. Perform a conversion, or we will get a
732 nonsense value. Actually, we could use the same
733 code regardless of lengths; I'm just avoiding a cast. */
735 = value_from_contents_and_address (type
, valaddr
+ offset
, 0);
736 struct value
*v
= value_cast (target_type
, v1
);
738 ada_val_print_1 (target_type
,
739 value_contents_for_printing (v
),
740 value_embedded_offset (v
), 0,
741 stream
, recurse
+ 1, v
, options
);
744 ada_val_print_1 (TYPE_TARGET_TYPE (type
),
746 address
, stream
, recurse
,
747 original_value
, options
);
752 int format
= (options
->format
? options
->format
753 : options
->output_format
);
757 struct value_print_options opts
= *options
;
759 opts
.format
= format
;
760 val_print_scalar_formatted (type
, valaddr
, offset_aligned
,
761 original_value
, &opts
, 0, stream
);
763 else if (ada_is_system_address_type (type
))
765 /* FIXME: We want to print System.Address variables using
766 the same format as for any access type. But for some
767 reason GNAT encodes the System.Address type as an int,
768 so we have to work-around this deficiency by handling
769 System.Address values as a special case. */
771 struct gdbarch
*gdbarch
= get_type_arch (type
);
772 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
773 CORE_ADDR addr
= extract_typed_address (valaddr
+ offset_aligned
,
776 fprintf_filtered (stream
, "(");
777 type_print (type
, "", stream
, -1);
778 fprintf_filtered (stream
, ") ");
779 fputs_filtered (paddress (gdbarch
, addr
), stream
);
783 val_print_type_code_int (type
, valaddr
+ offset_aligned
, stream
);
784 if (ada_is_character_type (type
))
788 fputs_filtered (" ", stream
);
789 c
= unpack_long (type
, valaddr
+ offset_aligned
);
790 ada_printchar (c
, type
, stream
);
803 val_print_scalar_formatted (type
, valaddr
, offset_aligned
,
804 original_value
, options
, 0, stream
);
807 len
= TYPE_NFIELDS (type
);
808 val
= unpack_long (type
, valaddr
+ offset_aligned
);
809 for (i
= 0; i
< len
; i
++)
812 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
819 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
822 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
824 fputs_filtered (name
, stream
);
828 print_longest (stream
, 'd', 0, val
);
836 c_val_print (type
, valaddr
, offset
, address
, stream
,
837 recurse
, original_value
, options
);
841 ada_print_floating (valaddr
+ offset
, type
, stream
);
844 case TYPE_CODE_UNION
:
845 case TYPE_CODE_STRUCT
:
846 if (ada_is_bogus_array_descriptor (type
))
848 fprintf_filtered (stream
, "(...?)");
853 print_record (type
, valaddr
, offset_aligned
,
854 stream
, recurse
, original_value
, options
);
858 case TYPE_CODE_ARRAY
:
859 ada_val_print_array (type
, valaddr
, offset_aligned
,
860 address
, stream
, recurse
, original_value
,
865 /* For references, the debugger is expected to print the value as
866 an address if DEREF_REF is null. But printing an address in place
867 of the object value would be confusing to an Ada programmer.
868 So, for Ada values, we print the actual dereferenced value
870 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
872 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
874 CORE_ADDR deref_val_int
;
875 struct value
*deref_val
;
877 deref_val
= coerce_ref_if_computed (original_value
);
880 if (ada_is_tagged_type (value_type (deref_val
), 1))
881 deref_val
= ada_tag_value_at_base_address (deref_val
);
883 common_val_print (deref_val
, stream
, recurse
+ 1, options
,
888 deref_val_int
= unpack_pointer (type
, valaddr
+ offset_aligned
);
889 if (deref_val_int
!= 0)
892 ada_value_ind (value_from_pointer
893 (lookup_pointer_type (elttype
),
896 if (ada_is_tagged_type (value_type (deref_val
), 1))
897 deref_val
= ada_tag_value_at_base_address (deref_val
);
899 val_print (value_type (deref_val
),
900 value_contents_for_printing (deref_val
),
901 value_embedded_offset (deref_val
),
902 value_address (deref_val
), stream
, recurse
+ 1,
903 deref_val
, options
, current_language
);
906 fputs_filtered ("(null)", stream
);
909 fputs_filtered ("???", stream
);
917 print_variant_part (struct type
*type
, int field_num
,
918 const gdb_byte
*valaddr
, int offset
,
919 struct ui_file
*stream
, int recurse
,
920 const struct value
*val
,
921 const struct value_print_options
*options
,
923 struct type
*outer_type
, int outer_offset
)
925 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
926 int which
= ada_which_variant_applies (var_type
, outer_type
,
927 valaddr
+ outer_offset
);
932 return print_field_values
933 (TYPE_FIELD_TYPE (var_type
, which
),
935 offset
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
936 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
937 stream
, recurse
, val
, options
,
938 comma_needed
, outer_type
, outer_offset
);
942 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
943 const struct value_print_options
*options
)
945 struct value
*val
= ada_to_fixed_value (val0
);
946 CORE_ADDR address
= value_address (val
);
947 struct type
*type
= ada_check_typedef (value_type (val
));
948 struct value_print_options opts
;
950 /* If it is a pointer, indicate what it points to. */
951 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
953 /* Hack: don't print (char *) for char strings. Their
954 type is indicated by the quoted string anyway. */
955 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
956 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
957 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
959 fprintf_filtered (stream
, "(");
960 type_print (type
, "", stream
, -1);
961 fprintf_filtered (stream
, ") ");
964 else if (ada_is_array_descriptor_type (type
))
966 /* We do not print the type description unless TYPE is an array
967 access type (this is encoded by the compiler as a typedef to
968 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
969 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
971 fprintf_filtered (stream
, "(");
972 type_print (type
, "", stream
, -1);
973 fprintf_filtered (stream
, ") ");
976 else if (ada_is_bogus_array_descriptor (type
))
978 fprintf_filtered (stream
, "(");
979 type_print (type
, "", stream
, -1);
980 fprintf_filtered (stream
, ") (...?)");
986 val_print (type
, value_contents_for_printing (val
),
987 value_embedded_offset (val
), address
,
988 stream
, 0, val
, &opts
, current_language
);
992 print_record (struct type
*type
, const gdb_byte
*valaddr
,
994 struct ui_file
*stream
, int recurse
,
995 const struct value
*val
,
996 const struct value_print_options
*options
)
998 type
= ada_check_typedef (type
);
1000 fprintf_filtered (stream
, "(");
1002 if (print_field_values (type
, valaddr
, offset
,
1003 stream
, recurse
, val
, options
,
1004 0, type
, offset
) != 0 && options
->prettyformat
)
1006 fprintf_filtered (stream
, "\n");
1007 print_spaces_filtered (2 * recurse
, stream
);
1010 fprintf_filtered (stream
, ")");
1013 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
1015 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
1016 meanings as in ada_print_value and ada_val_print.
1018 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
1019 record (used to get discriminant values when printing variant
1022 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1023 level, so that a comma is needed before any field printed by this
1026 Returns 1 if COMMA_NEEDED or any fields were printed. */
1029 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
1030 int offset
, struct ui_file
*stream
, int recurse
,
1031 const struct value
*val
,
1032 const struct value_print_options
*options
,
1034 struct type
*outer_type
, int outer_offset
)
1038 len
= TYPE_NFIELDS (type
);
1040 for (i
= 0; i
< len
; i
+= 1)
1042 if (ada_is_ignored_field (type
, i
))
1045 if (ada_is_wrapper_field (type
, i
))
1048 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1051 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
1052 stream
, recurse
, val
, options
,
1053 comma_needed
, type
, offset
);
1056 else if (ada_is_variant_part (type
, i
))
1059 print_variant_part (type
, i
, valaddr
,
1060 offset
, stream
, recurse
, val
,
1061 options
, comma_needed
,
1062 outer_type
, outer_offset
);
1067 fprintf_filtered (stream
, ", ");
1070 if (options
->prettyformat
)
1072 fprintf_filtered (stream
, "\n");
1073 print_spaces_filtered (2 + 2 * recurse
, stream
);
1077 wrap_here (n_spaces (2 + 2 * recurse
));
1080 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1081 fprintf_filtered (stream
, "%.*s",
1082 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1083 TYPE_FIELD_NAME (type
, i
));
1084 annotate_field_name_end ();
1085 fputs_filtered (" => ", stream
);
1086 annotate_field_value ();
1088 if (TYPE_FIELD_PACKED (type
, i
))
1092 /* Bitfields require special handling, especially due to byte
1094 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
1096 fputs_filtered (_("<optimized out or zero length>"), stream
);
1100 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1101 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1102 struct value_print_options opts
;
1104 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1105 v
= ada_value_primitive_packed_val
1107 offset
+ bit_pos
/ HOST_CHAR_BIT
,
1108 bit_pos
% HOST_CHAR_BIT
,
1109 bit_size
, TYPE_FIELD_TYPE (type
, i
));
1112 val_print (TYPE_FIELD_TYPE (type
, i
),
1113 value_contents_for_printing (v
),
1114 value_embedded_offset (v
), 0,
1115 stream
, recurse
+ 1, v
,
1116 &opts
, current_language
);
1121 struct value_print_options opts
= *options
;
1124 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1127 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
),
1128 0, stream
, recurse
+ 1, val
, &opts
);
1130 annotate_field_end ();
1133 return comma_needed
;