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/>. */
24 #include "expression.h"
33 #include "exceptions.h"
36 static int print_field_values (struct type *, const gdb_byte *,
38 struct ui_file *, int,
40 const struct value_print_options *,
41 int, struct type *, int,
42 const struct language_defn *);
45 /* Make TYPE unsigned if its range of values includes no negatives. */
47 adjust_type_signedness (struct type *type)
49 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
50 && TYPE_LOW_BOUND (type) >= 0)
51 TYPE_UNSIGNED (type) = 1;
54 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
55 if non-standard (i.e., other than 1 for numbers, other than lower bound
56 of index type for enumerated type). Returns 1 if something printed,
60 print_optional_low_bound (struct ui_file *stream, struct type *type,
61 const struct value_print_options *options)
63 struct type *index_type;
67 if (options->print_array_indexes)
70 if (!get_array_bounds (type, &low_bound, &high_bound))
73 /* If this is an empty array, then don't print the lower bound.
74 That would be confusing, because we would print the lower bound,
75 followed by... nothing! */
76 if (low_bound > high_bound)
79 index_type = TYPE_INDEX_TYPE (type);
81 while (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
83 /* We need to know what the base type is, in order to do the
84 appropriate check below. Otherwise, if this is a subrange
85 of an enumerated type, where the underlying value of the
86 first element is typically 0, we might test the low bound
87 against the wrong value. */
88 index_type = TYPE_TARGET_TYPE (index_type);
91 switch (TYPE_CODE (index_type))
98 if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0))
101 case TYPE_CODE_UNDEF:
110 ada_print_scalar (index_type, low_bound, stream);
111 fprintf_filtered (stream, " => ");
115 /* Version of val_print_array_elements for GNAT-style packed arrays.
116 Prints elements of packed array of type TYPE at bit offset
117 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
118 separates with commas. RECURSE is the recursion (nesting) level.
119 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
122 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
124 int bitoffset, struct ui_file *stream,
126 const struct value *val,
127 const struct value_print_options *options)
130 unsigned int things_printed = 0;
132 struct type *elttype, *index_type;
134 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
135 struct value *mark = value_mark ();
138 elttype = TYPE_TARGET_TYPE (type);
139 eltlen = TYPE_LENGTH (check_typedef (elttype));
140 index_type = TYPE_INDEX_TYPE (type);
145 if (get_discrete_bounds (index_type, &low, &high) < 0)
148 len = high - low + 1;
152 annotate_array_section_begin (i, elttype);
154 while (i < len && things_printed < options->print_max)
156 struct value *v0, *v1;
161 if (options->prettyformat_arrays)
163 fprintf_filtered (stream, ",\n");
164 print_spaces_filtered (2 + 2 * recurse, stream);
168 fprintf_filtered (stream, ", ");
171 wrap_here (n_spaces (2 + 2 * recurse));
172 maybe_print_array_index (index_type, i + low, stream, options);
175 v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
176 (i0 * bitsize) / HOST_CHAR_BIT,
177 (i0 * bitsize) % HOST_CHAR_BIT,
184 v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
185 (i * bitsize) / HOST_CHAR_BIT,
186 (i * bitsize) % HOST_CHAR_BIT,
188 if (!value_available_contents_eq (v0, value_embedded_offset (v0),
189 v1, value_embedded_offset (v1),
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)
302 struct ui_file *tmp_stream = mem_fileopen ();
303 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
305 print_floating (valaddr, type, tmp_stream);
306 result = ui_file_xstrdup (tmp_stream, NULL);
307 make_cleanup (xfree, result);
309 /* Modify for Ada rules. */
311 s = strstr (result, "inf");
313 s = strstr (result, "Inf");
315 s = strstr (result, "INF");
321 s = strstr (result, "nan");
323 s = strstr (result, "NaN");
325 s = strstr (result, "Nan");
329 if (result[0] == '-')
334 if (s == NULL && strchr (result, '.') == NULL)
336 s = strchr (result, 'e');
338 fprintf_filtered (stream, "%s.0", result);
340 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
343 fprintf_filtered (stream, "%s", result);
345 do_cleanups (cleanups);
349 ada_printchar (int c, struct type *type, struct ui_file *stream)
351 fputs_filtered ("'", stream);
352 ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
353 fputs_filtered ("'", stream);
356 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
357 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
358 like a default signed integer. */
361 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
368 print_longest (stream, 'd', 0, val);
372 type = ada_check_typedef (type);
374 switch (TYPE_CODE (type))
378 len = TYPE_NFIELDS (type);
379 for (i = 0; i < len; i++)
381 if (TYPE_FIELD_ENUMVAL (type, i) == val)
388 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
392 print_longest (stream, 'd', 0, val);
397 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
401 LA_PRINT_CHAR (val, type, stream);
405 fprintf_filtered (stream, val ? "true" : "false");
408 case TYPE_CODE_RANGE:
409 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
412 case TYPE_CODE_UNDEF:
414 case TYPE_CODE_ARRAY:
415 case TYPE_CODE_STRUCT:
416 case TYPE_CODE_UNION:
421 case TYPE_CODE_STRING:
422 case TYPE_CODE_ERROR:
423 case TYPE_CODE_MEMBERPTR:
424 case TYPE_CODE_METHODPTR:
425 case TYPE_CODE_METHOD:
427 warning (_("internal error: unhandled type in ada_print_scalar"));
431 error (_("Invalid type code in symbol table."));
436 /* Print the character string STRING, printing at most LENGTH characters.
437 Printing stops early if the number hits print_max; repeat counts
438 are printed as appropriate. Print ellipses at the end if we
439 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
440 TYPE_LEN is the length (1 or 2) of the character type. */
443 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
444 unsigned int length, int force_ellipses, int type_len,
445 const struct value_print_options *options)
447 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
449 unsigned int things_printed = 0;
455 fputs_filtered ("\"\"", stream);
459 for (i = 0; i < length && things_printed < options->print_max; i += 1)
461 /* Position of the character we are examining
462 to see whether it is repeated. */
464 /* Number of repetitions we have detected so far. */
471 fputs_filtered (", ", stream);
478 && char_at (string, rep1, type_len, byte_order)
479 == char_at (string, i, type_len, byte_order))
485 if (reps > options->repeat_count_threshold)
489 fputs_filtered ("\", ", stream);
492 fputs_filtered ("'", stream);
493 ada_emit_char (char_at (string, i, type_len, byte_order),
494 elttype, stream, '\'', type_len);
495 fputs_filtered ("'", stream);
496 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
498 things_printed += options->repeat_count_threshold;
505 fputs_filtered ("\"", stream);
508 ada_emit_char (char_at (string, i, type_len, byte_order),
509 elttype, stream, '"', type_len);
514 /* Terminate the quotes if necessary. */
516 fputs_filtered ("\"", stream);
518 if (force_ellipses || i < length)
519 fputs_filtered ("...", stream);
523 ada_printstr (struct ui_file *stream, struct type *type,
524 const gdb_byte *string, unsigned int length,
525 const char *encoding, int force_ellipses,
526 const struct value_print_options *options)
528 printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
533 print_variant_part (struct type *type, int field_num,
534 const gdb_byte *valaddr, int offset,
535 struct ui_file *stream, int recurse,
536 const struct value *val,
537 const struct value_print_options *options,
539 struct type *outer_type, int outer_offset,
540 const struct language_defn *language)
542 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
543 int which = ada_which_variant_applies (var_type, outer_type,
544 valaddr + outer_offset);
549 return print_field_values
550 (TYPE_FIELD_TYPE (var_type, which),
552 offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
553 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
554 stream, recurse, val, options,
555 comma_needed, outer_type, outer_offset, language);
558 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
560 TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
561 meanings as in ada_print_value and ada_val_print.
563 OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
564 record (used to get discriminant values when printing variant
567 COMMA_NEEDED is 1 if fields have been printed at the current recursion
568 level, so that a comma is needed before any field printed by this
571 Returns 1 if COMMA_NEEDED or any fields were printed. */
574 print_field_values (struct type *type, const gdb_byte *valaddr,
575 int offset, struct ui_file *stream, int recurse,
576 const struct value *val,
577 const struct value_print_options *options,
579 struct type *outer_type, int outer_offset,
580 const struct language_defn *language)
584 len = TYPE_NFIELDS (type);
586 for (i = 0; i < len; i += 1)
588 if (ada_is_ignored_field (type, i))
591 if (ada_is_wrapper_field (type, i))
594 print_field_values (TYPE_FIELD_TYPE (type, i),
597 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
598 stream, recurse, val, options,
599 comma_needed, type, offset, language);
602 else if (ada_is_variant_part (type, i))
605 print_variant_part (type, i, valaddr,
606 offset, stream, recurse, val,
607 options, comma_needed,
608 outer_type, outer_offset, language);
613 fprintf_filtered (stream, ", ");
616 if (options->prettyformat)
618 fprintf_filtered (stream, "\n");
619 print_spaces_filtered (2 + 2 * recurse, stream);
623 wrap_here (n_spaces (2 + 2 * recurse));
626 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
627 fprintf_filtered (stream, "%.*s",
628 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
629 TYPE_FIELD_NAME (type, i));
630 annotate_field_name_end ();
631 fputs_filtered (" => ", stream);
632 annotate_field_value ();
634 if (TYPE_FIELD_PACKED (type, i))
638 /* Bitfields require special handling, especially due to byte
640 if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
642 fputs_filtered (_("<optimized out or zero length>"), stream);
646 int bit_pos = TYPE_FIELD_BITPOS (type, i);
647 int bit_size = TYPE_FIELD_BITSIZE (type, i);
648 struct value_print_options opts;
650 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
651 v = ada_value_primitive_packed_val
653 offset + bit_pos / HOST_CHAR_BIT,
654 bit_pos % HOST_CHAR_BIT,
655 bit_size, TYPE_FIELD_TYPE (type, i));
658 val_print (TYPE_FIELD_TYPE (type, i),
659 value_contents_for_printing (v),
660 value_embedded_offset (v), 0,
661 stream, recurse + 1, v,
667 struct value_print_options opts = *options;
670 val_print (TYPE_FIELD_TYPE (type, i), valaddr,
671 (offset + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
672 0, stream, recurse + 1, val, &opts, language);
674 annotate_field_end ();
680 /* Implement Ada val_print'ing for the case where TYPE is
681 a TYPE_CODE_ARRAY of characters. */
684 ada_val_print_string (struct type *type, const gdb_byte *valaddr,
685 int offset, int offset_aligned, CORE_ADDR address,
686 struct ui_file *stream, int recurse,
687 const struct value *original_value,
688 const struct value_print_options *options)
690 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
691 struct type *elttype = TYPE_TARGET_TYPE (type);
695 /* We know that ELTTYPE cannot possibly be null, because we assume
696 that we're called only when TYPE is a string-like type.
697 Similarly, the size of ELTTYPE should also be non-null, since
698 it's a character-like type. */
699 gdb_assert (elttype != NULL);
700 gdb_assert (TYPE_LENGTH (elttype) != 0);
702 eltlen = TYPE_LENGTH (elttype);
703 len = TYPE_LENGTH (type) / eltlen;
705 if (options->prettyformat_arrays)
706 print_spaces_filtered (2 + 2 * recurse, stream);
708 /* If requested, look for the first null char and only print
709 elements up to it. */
710 if (options->stop_print_at_null)
714 /* Look for a NULL char. */
717 && temp_len < options->print_max
718 && char_at (valaddr + offset_aligned,
719 temp_len, eltlen, byte_order) != 0);
724 printstr (stream, elttype, valaddr + offset_aligned, len, 0,
728 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
729 thin pointers, etc). */
732 ada_val_print_gnat_array (struct type *type, const gdb_byte *valaddr,
733 int offset, CORE_ADDR address,
734 struct ui_file *stream, int recurse,
735 const struct value *original_value,
736 const struct value_print_options *options,
737 const struct language_defn *language)
739 struct value *mark = value_mark ();
742 val = value_from_contents_and_address (type, valaddr + offset, address);
743 /* If this is a reference, coerce it now. This helps taking care
744 of the case where ADDRESS is meaningless because original_value
746 val = coerce_ref (val);
747 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
748 val = ada_coerce_to_simple_array_ptr (val);
750 val = ada_coerce_to_simple_array (val);
753 gdb_assert (TYPE_CODE (type) == TYPE_CODE_TYPEDEF);
754 fprintf_filtered (stream, "0x0");
757 val_print (value_type (val), value_contents_for_printing (val),
758 value_embedded_offset (val), value_address (val),
759 stream, recurse, val, options, language);
760 value_free_to_mark (mark);
763 /* Implement Ada val_print'ing for the case where TYPE is
767 ada_val_print_ptr (struct type *type, const gdb_byte *valaddr,
768 int offset, int offset_aligned, CORE_ADDR address,
769 struct ui_file *stream, int recurse,
770 const struct value *original_value,
771 const struct value_print_options *options,
772 const struct language_defn *language)
774 val_print (type, valaddr, offset, address, stream, recurse,
775 original_value, options, language_def (language_c));
777 if (ada_is_tag_type (type))
780 value_from_contents_and_address (type,
781 valaddr + offset_aligned,
782 address + offset_aligned);
783 const char *name = ada_tag_name (val);
786 fprintf_filtered (stream, " (%s)", name);
790 /* Implement Ada val_print'ing for the case where TYPE is
791 a TYPE_CODE_INT or TYPE_CODE_RANGE. */
794 ada_val_print_num (struct type *type, const gdb_byte *valaddr,
795 int offset, int offset_aligned, CORE_ADDR address,
796 struct ui_file *stream, int recurse,
797 const struct value *original_value,
798 const struct value_print_options *options,
799 const struct language_defn *language)
801 if (ada_is_fixed_point_type (type))
803 LONGEST v = unpack_long (type, valaddr + offset_aligned);
805 fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
806 (double) ada_fixed_to_float (type, v));
809 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
811 struct type *target_type = TYPE_TARGET_TYPE (type);
813 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
815 /* Obscure case of range type that has different length from
816 its base type. Perform a conversion, or we will get a
817 nonsense value. Actually, we could use the same
818 code regardless of lengths; I'm just avoiding a cast. */
820 = value_from_contents_and_address (type, valaddr + offset, 0);
821 struct value *v = value_cast (target_type, v1);
823 val_print (target_type, value_contents_for_printing (v),
824 value_embedded_offset (v), 0, stream,
825 recurse + 1, v, options, language);
828 val_print (TYPE_TARGET_TYPE (type), valaddr, offset,
829 address, stream, recurse, original_value,
835 int format = (options->format ? options->format
836 : options->output_format);
840 struct value_print_options opts = *options;
842 opts.format = format;
843 val_print_scalar_formatted (type, valaddr, offset_aligned,
844 original_value, &opts, 0, stream);
846 else if (ada_is_system_address_type (type))
848 /* FIXME: We want to print System.Address variables using
849 the same format as for any access type. But for some
850 reason GNAT encodes the System.Address type as an int,
851 so we have to work-around this deficiency by handling
852 System.Address values as a special case. */
854 struct gdbarch *gdbarch = get_type_arch (type);
855 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
856 CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
859 fprintf_filtered (stream, "(");
860 type_print (type, "", stream, -1);
861 fprintf_filtered (stream, ") ");
862 fputs_filtered (paddress (gdbarch, addr), stream);
866 val_print_type_code_int (type, valaddr + offset_aligned, stream);
867 if (ada_is_character_type (type))
871 fputs_filtered (" ", stream);
872 c = unpack_long (type, valaddr + offset_aligned);
873 ada_printchar (c, type, stream);
880 /* Implement Ada val_print'ing for the case where TYPE is
884 ada_val_print_enum (struct type *type, const gdb_byte *valaddr,
885 int offset, int offset_aligned, CORE_ADDR address,
886 struct ui_file *stream, int recurse,
887 const struct value *original_value,
888 const struct value_print_options *options,
889 const struct language_defn *language)
897 val_print_scalar_formatted (type, valaddr, offset_aligned,
898 original_value, options, 0, stream);
902 len = TYPE_NFIELDS (type);
903 val = unpack_long (type, valaddr + offset_aligned);
904 for (i = 0; i < len; i++)
907 if (val == TYPE_FIELD_ENUMVAL (type, i))
913 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
916 fprintf_filtered (stream, "%ld %s", (long) val, name);
918 fputs_filtered (name, stream);
921 print_longest (stream, 'd', 0, val);
924 /* Implement Ada val_print'ing for the case where TYPE is
928 ada_val_print_flt (struct type *type, const gdb_byte *valaddr,
929 int offset, int offset_aligned, CORE_ADDR address,
930 struct ui_file *stream, int recurse,
931 const struct value *original_value,
932 const struct value_print_options *options,
933 const struct language_defn *language)
937 val_print (type, valaddr, offset, address, stream, recurse,
938 original_value, options, language_def (language_c));
942 ada_print_floating (valaddr + offset, type, stream);
945 /* Implement Ada val_print'ing for the case where TYPE is
946 a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
949 ada_val_print_struct_union
950 (struct type *type, const gdb_byte *valaddr, int offset,
951 int offset_aligned, CORE_ADDR address, struct ui_file *stream,
952 int recurse, const struct value *original_value,
953 const struct value_print_options *options,
954 const struct language_defn *language)
956 if (ada_is_bogus_array_descriptor (type))
958 fprintf_filtered (stream, "(...?)");
962 fprintf_filtered (stream, "(");
964 if (print_field_values (type, valaddr, offset_aligned,
965 stream, recurse, original_value, options,
966 0, type, offset_aligned, language) != 0
967 && options->prettyformat)
969 fprintf_filtered (stream, "\n");
970 print_spaces_filtered (2 * recurse, stream);
973 fprintf_filtered (stream, ")");
976 /* Implement Ada val_print'ing for the case where TYPE is
977 a TYPE_CODE_ARRAY. */
980 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
981 int offset, int offset_aligned, CORE_ADDR address,
982 struct ui_file *stream, int recurse,
983 const struct value *original_value,
984 const struct value_print_options *options)
986 /* For an array of characters, print with string syntax. */
987 if (ada_is_string_type (type)
988 && (options->format == 0 || options->format == 's'))
990 ada_val_print_string (type, valaddr, offset, offset_aligned,
991 address, stream, recurse, original_value,
996 fprintf_filtered (stream, "(");
997 print_optional_low_bound (stream, type, options);
998 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
999 val_print_packed_array_elements (type, valaddr, offset_aligned,
1001 original_value, options);
1003 val_print_array_elements (type, valaddr, offset_aligned, address,
1004 stream, recurse, original_value,
1006 fprintf_filtered (stream, ")");
1009 /* Implement Ada val_print'ing for the case where TYPE is
1013 ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
1014 int offset, int offset_aligned, CORE_ADDR address,
1015 struct ui_file *stream, int recurse,
1016 const struct value *original_value,
1017 const struct value_print_options *options,
1018 const struct language_defn *language)
1020 /* For references, the debugger is expected to print the value as
1021 an address if DEREF_REF is null. But printing an address in place
1022 of the object value would be confusing to an Ada programmer.
1023 So, for Ada values, we print the actual dereferenced value
1025 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
1026 struct value *deref_val;
1027 CORE_ADDR deref_val_int;
1029 if (TYPE_CODE (elttype) == TYPE_CODE_UNDEF)
1031 fputs_filtered ("<ref to undefined type>", stream);
1035 deref_val = coerce_ref_if_computed (original_value);
1038 if (ada_is_tagged_type (value_type (deref_val), 1))
1039 deref_val = ada_tag_value_at_base_address (deref_val);
1041 common_val_print (deref_val, stream, recurse + 1, options,
1046 deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
1047 if (deref_val_int == 0)
1049 fputs_filtered ("(null)", stream);
1054 = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype),
1056 if (ada_is_tagged_type (value_type (deref_val), 1))
1057 deref_val = ada_tag_value_at_base_address (deref_val);
1059 val_print (value_type (deref_val),
1060 value_contents_for_printing (deref_val),
1061 value_embedded_offset (deref_val),
1062 value_address (deref_val), stream, recurse + 1,
1063 deref_val, options, language);
1066 /* See the comment on ada_val_print. This function differs in that it
1067 does not catch evaluation errors (leaving that to ada_val_print). */
1070 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
1071 int offset, CORE_ADDR address,
1072 struct ui_file *stream, int recurse,
1073 const struct value *original_value,
1074 const struct value_print_options *options,
1075 const struct language_defn *language)
1079 type = ada_check_typedef (type);
1081 if (ada_is_array_descriptor_type (type)
1082 || (ada_is_constrained_packed_array_type (type)
1083 && TYPE_CODE (type) != TYPE_CODE_PTR))
1085 ada_val_print_gnat_array (type, valaddr, offset, address,
1086 stream, recurse, original_value,
1091 offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
1092 type = printable_val_type (type, valaddr + offset_aligned);
1094 switch (TYPE_CODE (type))
1097 val_print (type, valaddr, offset, address, stream, recurse,
1098 original_value, options, language_def (language_c));
1102 ada_val_print_ptr (type, valaddr, offset, offset_aligned,
1103 address, stream, recurse, original_value,
1108 case TYPE_CODE_RANGE:
1109 ada_val_print_num (type, valaddr, offset, offset_aligned,
1110 address, stream, recurse, original_value,
1114 case TYPE_CODE_ENUM:
1115 ada_val_print_enum (type, valaddr, offset, offset_aligned,
1116 address, stream, recurse, original_value,
1121 ada_val_print_flt (type, valaddr, offset, offset_aligned,
1122 address, stream, recurse, original_value,
1126 case TYPE_CODE_UNION:
1127 case TYPE_CODE_STRUCT:
1128 ada_val_print_struct_union (type, valaddr, offset, offset_aligned,
1129 address, stream, recurse,
1130 original_value, options, language);
1133 case TYPE_CODE_ARRAY:
1134 ada_val_print_array (type, valaddr, offset, offset_aligned,
1135 address, stream, recurse, original_value,
1140 ada_val_print_ref (type, valaddr, offset, offset_aligned,
1141 address, stream, recurse, original_value,
1147 /* See val_print for a description of the various parameters of this
1148 function; they are identical. */
1151 ada_val_print (struct type *type, const gdb_byte *valaddr,
1152 int embedded_offset, CORE_ADDR address,
1153 struct ui_file *stream, int recurse,
1154 const struct value *val,
1155 const struct value_print_options *options)
1157 volatile struct gdb_exception except;
1159 /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
1160 TRY_CATCH (except, RETURN_MASK_ALL)
1162 ada_val_print_1 (type, valaddr, embedded_offset, address,
1163 stream, recurse, val, options,
1169 ada_value_print (struct value *val0, struct ui_file *stream,
1170 const struct value_print_options *options)
1172 struct value *val = ada_to_fixed_value (val0);
1173 CORE_ADDR address = value_address (val);
1174 struct type *type = ada_check_typedef (value_type (val));
1175 struct value_print_options opts;
1177 /* If it is a pointer, indicate what it points to. */
1178 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1180 /* Hack: don't print (char *) for char strings. Their
1181 type is indicated by the quoted string anyway. */
1182 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
1183 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
1184 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
1186 fprintf_filtered (stream, "(");
1187 type_print (type, "", stream, -1);
1188 fprintf_filtered (stream, ") ");
1191 else if (ada_is_array_descriptor_type (type))
1193 /* We do not print the type description unless TYPE is an array
1194 access type (this is encoded by the compiler as a typedef to
1195 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1196 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1198 fprintf_filtered (stream, "(");
1199 type_print (type, "", stream, -1);
1200 fprintf_filtered (stream, ") ");
1203 else if (ada_is_bogus_array_descriptor (type))
1205 fprintf_filtered (stream, "(");
1206 type_print (type, "", stream, -1);
1207 fprintf_filtered (stream, ") (...?)");
1213 val_print (type, value_contents_for_printing (val),
1214 value_embedded_offset (val), address,
1215 stream, 0, val, &opts, current_language);