1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988-1989, 1991, 1997-2004, 2007-2012 Free
3 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/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
25 #include "expression.h"
34 #include "typeprint.h"
38 #include "gdb_string.h"
41 static int print_selected_record_field_types (struct type
*, struct type
*,
43 struct ui_file
*, int, int);
45 static int print_record_field_types (struct type
*, struct type
*,
46 struct ui_file
*, int, int);
48 static void print_array_type (struct type
*, struct ui_file
*, int, int);
50 static int print_choices (struct type
*, int, struct ui_file
*,
53 static void print_range (struct type
*, struct ui_file
*);
55 static void print_range_bound (struct type
*, char *, int *,
59 print_dynamic_range_bound (struct type
*, const char *, int,
60 const char *, struct ui_file
*);
62 static void print_range_type (struct type
*, struct ui_file
*);
66 static char *name_buffer
;
67 static int name_buffer_len
;
69 /* The (decoded) Ada name of TYPE. This value persists until the
73 decoded_type_name (struct type
*type
)
75 if (ada_type_name (type
) == NULL
)
79 const char *raw_name
= ada_type_name (type
);
82 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
84 name_buffer_len
= 16 + 2 * strlen (raw_name
);
85 name_buffer
= xrealloc (name_buffer
, name_buffer_len
);
87 strcpy (name_buffer
, raw_name
);
89 s
= (char *) strstr (name_buffer
, "___");
93 s
= name_buffer
+ strlen (name_buffer
) - 1;
94 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
103 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
105 if (s
[0] == '_' && s
[1] == '_')
121 /* Print TYPE on STREAM, preferably as a range. */
124 print_range (struct type
*type
, struct ui_file
*stream
)
126 switch (TYPE_CODE (type
))
128 case TYPE_CODE_RANGE
:
131 struct type
*target_type
;
132 target_type
= TYPE_TARGET_TYPE (type
);
133 if (target_type
== NULL
)
135 ada_print_scalar (target_type
, ada_discrete_type_low_bound (type
),
137 fprintf_filtered (stream
, " .. ");
138 ada_print_scalar (target_type
, ada_discrete_type_high_bound (type
),
143 fprintf_filtered (stream
, "%.*s",
144 ada_name_prefix_len (TYPE_NAME (type
)),
150 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
151 set *N past the bound and its delimiter, if any. */
154 print_range_bound (struct type
*type
, char *bounds
, int *n
,
155 struct ui_file
*stream
)
159 if (ada_scan_number (bounds
, *n
, &B
, n
))
161 /* STABS decodes all range types which bounds are 0 .. -1 as
162 unsigned integers (ie. the type code is TYPE_CODE_INT, not
163 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
164 on the unsigned flag to determine whether the bound should
165 be printed as a signed or an unsigned value. This causes
166 the upper bound of the 0 .. -1 range types to be printed as
167 a very large unsigned number instead of -1.
168 To workaround this stabs deficiency, we replace the TYPE by NULL
169 to indicate default output when we detect that the bound is negative,
170 and the type is a TYPE_CODE_INT. The bound is negative when
171 'm' is the last character of the number scanned in BOUNDS. */
172 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
174 ada_print_scalar (type
, B
, stream
);
175 if (bounds
[*n
] == '_')
181 char *bound
= bounds
+ *n
;
184 pend
= strstr (bound
, "__");
186 *n
+= bound_len
= strlen (bound
);
189 bound_len
= pend
- bound
;
192 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
196 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
197 the value (if found) of the bound indicated by SUFFIX ("___L" or
198 "___U") according to the ___XD conventions. */
201 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
202 const char *suffix
, struct ui_file
*stream
)
204 static char *name_buf
= NULL
;
205 static size_t name_buf_len
= 0;
209 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
210 strncpy (name_buf
, name
, name_len
);
211 strcpy (name_buf
+ name_len
, suffix
);
213 B
= get_int_var_value (name_buf
, &OK
);
215 ada_print_scalar (type
, B
, stream
);
217 fprintf_filtered (stream
, "?");
220 /* Print RAW_TYPE as a range type, using any bound information
221 following the GNAT encoding (if available). */
224 print_range_type (struct type
*raw_type
, struct ui_file
*stream
)
227 struct type
*base_type
;
228 const char *subtype_info
;
230 gdb_assert (raw_type
!= NULL
);
231 name
= TYPE_NAME (raw_type
);
232 gdb_assert (name
!= NULL
);
234 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
235 base_type
= TYPE_TARGET_TYPE (raw_type
);
237 base_type
= raw_type
;
239 subtype_info
= strstr (name
, "___XD");
240 if (subtype_info
== NULL
)
241 print_range (raw_type
, stream
);
244 int prefix_len
= subtype_info
- name
;
249 bounds_str
= strchr (subtype_info
, '_');
252 if (*subtype_info
== 'L')
254 print_range_bound (base_type
, bounds_str
, &n
, stream
);
258 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
261 fprintf_filtered (stream
, " .. ");
263 if (*subtype_info
== 'U')
264 print_range_bound (base_type
, bounds_str
, &n
, stream
);
266 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
271 /* Print enumerated type TYPE on STREAM. */
274 print_enum_type (struct type
*type
, struct ui_file
*stream
)
276 int len
= TYPE_NFIELDS (type
);
280 fprintf_filtered (stream
, "(");
284 for (i
= 0; i
< len
; i
++)
288 fprintf_filtered (stream
, ", ");
290 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
291 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
293 fprintf_filtered (stream
, " => %s",
294 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
295 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
299 fprintf_filtered (stream
, ")");
302 /* Print representation of Ada fixed-point type TYPE on STREAM. */
305 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
307 DOUBLEST delta
= ada_delta (type
);
308 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
311 fprintf_filtered (stream
, "delta ??");
314 fprintf_filtered (stream
, "delta %g", (double) delta
);
316 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
320 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
321 recursion (indentation) level, in case the element type itself has
322 nested structure, and SHOW is the number of levels of internal
323 structure to show (see ada_print_type). */
326 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
332 if (ada_is_constrained_packed_array_type (type
))
333 type
= ada_coerce_to_simple_array_type (type
);
336 fprintf_filtered (stream
, "array (");
340 fprintf_filtered (stream
, _("<undecipherable array type>"));
345 if (ada_is_simple_array_type (type
))
347 struct type
*range_desc_type
;
348 struct type
*arr_type
;
350 range_desc_type
= ada_find_parallel_type (type
, "___XA");
351 ada_fixup_array_indexes_type (range_desc_type
);
354 if (range_desc_type
== NULL
)
356 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
357 arr_type
= TYPE_TARGET_TYPE (arr_type
))
359 if (arr_type
!= type
)
360 fprintf_filtered (stream
, ", ");
361 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
362 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
363 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
370 n_indices
= TYPE_NFIELDS (range_desc_type
);
371 for (k
= 0, arr_type
= type
;
373 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
376 fprintf_filtered (stream
, ", ");
377 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
379 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
380 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
388 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
389 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
392 fprintf_filtered (stream
, ") of ");
394 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
395 show
== 0 ? 0 : show
- 1, level
+ 1);
397 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
400 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
401 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
402 values. Return non-zero if the field is an encoding of
403 discriminant values, as in a standard variant record, and 0 if the
404 field is not so encoded (as happens with single-component variants
405 in types annotated with pragma Unchecked_Variant). */
408 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
409 struct type
*val_type
)
413 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
417 /* Skip over leading 'V': NOTE soon to be obsolete. */
420 if (!ada_scan_number (name
, 1, NULL
, &p
))
434 fprintf_filtered (stream
, " =>");
440 fprintf_filtered (stream
, " | ");
451 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
453 ada_print_scalar (val_type
, W
, stream
);
460 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
461 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
463 ada_print_scalar (val_type
, L
, stream
);
464 fprintf_filtered (stream
, " .. ");
465 ada_print_scalar (val_type
, U
, stream
);
469 fprintf_filtered (stream
, "others");
476 fprintf_filtered (stream
, "?? =>");
480 /* Assuming that field FIELD_NUM of TYPE represents variants whose
481 discriminant is contained in OUTER_TYPE, print its components on STREAM.
482 LEVEL is the recursion (indentation) level, in case any of the fields
483 themselves have nested structure, and SHOW is the number of levels of
484 internal structure to show (see ada_print_type). For this purpose,
485 fields nested in a variant part are taken to be at the same level as
486 the fields immediately outside the variant part. */
489 print_variant_clauses (struct type
*type
, int field_num
,
490 struct type
*outer_type
, struct ui_file
*stream
,
494 struct type
*var_type
, *par_type
;
495 struct type
*discr_type
;
497 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
498 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
500 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
502 var_type
= TYPE_TARGET_TYPE (var_type
);
503 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
507 par_type
= ada_find_parallel_type (var_type
, "___XVU");
508 if (par_type
!= NULL
)
511 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
513 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
514 if (print_choices (var_type
, i
, stream
, discr_type
))
516 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
517 outer_type
, stream
, show
, level
+ 4)
519 fprintf_filtered (stream
, " null;");
522 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
523 stream
, show
, level
+ 4);
527 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
528 discriminants are contained in OUTER_TYPE, print a description of it
529 on STREAM. LEVEL is the recursion (indentation) level, in case any of
530 the fields themselves have nested structure, and SHOW is the number of
531 levels of internal structure to show (see ada_print_type). For this
532 purpose, fields nested in a variant part are taken to be at the same
533 level as the fields immediately outside the variant part. */
536 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
537 struct ui_file
*stream
, int show
, int level
)
539 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
540 ada_variant_discrim_name
541 (TYPE_FIELD_TYPE (type
, field_num
)));
542 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
544 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
547 /* Print a description on STREAM of the fields FLD0 through FLD1 in
548 record or union type TYPE, whose discriminants are in OUTER_TYPE.
549 LEVEL is the recursion (indentation) level, in case any of the
550 fields themselves have nested structure, and SHOW is the number of
551 levels of internal structure to show (see ada_print_type). Does
552 not print parent type information of TYPE. Returns 0 if no fields
553 printed, -1 for an incomplete type, else > 0. Prints each field
554 beginning on a new line, but does not put a new line at end. */
557 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
559 struct ui_file
*stream
, int show
, int level
)
565 if (fld0
> fld1
&& TYPE_STUB (type
))
568 for (i
= fld0
; i
<= fld1
; i
+= 1)
572 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
574 else if (ada_is_wrapper_field (type
, i
))
575 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
576 stream
, show
, level
);
577 else if (ada_is_variant_part (type
, i
))
579 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
585 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
586 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
587 TYPE_FIELD_NAME (type
, i
),
588 stream
, show
- 1, level
+ 4);
589 fprintf_filtered (stream
, ";");
596 /* Print a description on STREAM of all fields of record or union type
597 TYPE, as for print_selected_record_field_types, above. */
600 print_record_field_types (struct type
*type
, struct type
*outer_type
,
601 struct ui_file
*stream
, int show
, int level
)
603 return print_selected_record_field_types (type
, outer_type
,
604 0, TYPE_NFIELDS (type
) - 1,
605 stream
, show
, level
);
609 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
610 level, in case the element type itself has nested structure, and SHOW is
611 the number of levels of internal structure to show (see ada_print_type). */
614 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
617 struct type
*parent_type
;
620 type
= ada_find_parallel_type (type0
, "___XVE");
624 parent_type
= ada_parent_type (type
);
625 if (ada_type_name (parent_type
) != NULL
)
627 const char *parent_name
= decoded_type_name (parent_type
);
629 /* If we fail to decode the parent type name, then use the parent
630 type name as is. Not pretty, but should never happen except
631 when the debugging info is incomplete or incorrect. This
632 prevents a crash trying to print a NULL pointer. */
633 if (parent_name
== NULL
)
634 parent_name
= ada_type_name (parent_type
);
635 fprintf_filtered (stream
, "new %s with record", parent_name
);
637 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
638 fprintf_filtered (stream
, "tagged record");
640 fprintf_filtered (stream
, "record");
643 fprintf_filtered (stream
, " ... end record");
649 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
650 flds
+= print_record_field_types (parent_type
, parent_type
,
651 stream
, show
, level
);
652 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
655 fprintf_filtered (stream
, "\n%*send record", level
, "");
657 fprintf_filtered (stream
, _(" <incomplete type> end record"));
659 fprintf_filtered (stream
, " null; end record");
663 /* Print the unchecked union type TYPE in something resembling Ada
664 format on STREAM. LEVEL is the recursion (indentation) level
665 in case the element type itself has nested structure, and SHOW is the
666 number of levels of internal structure to show (see ada_print_type). */
668 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
672 fprintf_filtered (stream
, "record (?) is ... end record");
673 else if (TYPE_NFIELDS (type
) == 0)
674 fprintf_filtered (stream
, "record (?) is null; end record");
679 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
681 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
683 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
685 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
686 TYPE_FIELD_NAME (type
, i
),
687 stream
, show
- 1, level
+ 12);
688 fprintf_filtered (stream
, ";");
691 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
692 level
+ 4, "", level
, "");
698 /* Print function or procedure type TYPE on STREAM. Make it a header
699 for function or procedure NAME if NAME is not null. */
702 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
)
704 int i
, len
= TYPE_NFIELDS (type
);
706 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
707 fprintf_filtered (stream
, "procedure");
709 fprintf_filtered (stream
, "function");
711 if (name
!= NULL
&& name
[0] != '\0')
712 fprintf_filtered (stream
, " %s", name
);
716 fprintf_filtered (stream
, " (");
717 for (i
= 0; i
< len
; i
+= 1)
721 fputs_filtered ("; ", stream
);
724 fprintf_filtered (stream
, "a%d: ", i
+ 1);
725 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
727 fprintf_filtered (stream
, ")");
730 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
732 fprintf_filtered (stream
, " return ");
733 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
738 /* Print a description of a type TYPE0.
739 Output goes to STREAM (via stdio).
740 If VARSTRING is a non-empty string, print as an Ada variable/field
742 SHOW+1 is the maximum number of levels of internal type structure
743 to show (this applies to record types, enumerated types, and
745 SHOW is the number of levels of internal type structure to show
746 when there is a type name for the SHOWth deepest level (0th is
748 When SHOW<0, no inner structure is shown.
749 LEVEL indicates level of recursion (for nested definitions). */
752 ada_print_type (struct type
*type0
, const char *varstring
,
753 struct ui_file
*stream
, int show
, int level
)
755 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
756 char *type_name
= decoded_type_name (type0
);
757 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
762 fprintf_filtered (stream
, "%.*s: ",
763 ada_name_prefix_len (varstring
), varstring
);
764 fprintf_filtered (stream
, "<null type?>");
769 type
= ada_check_typedef (type
);
771 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
772 fprintf_filtered (stream
, "%.*s: ",
773 ada_name_prefix_len (varstring
), varstring
);
775 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
777 fprintf_filtered (stream
, "%.*s",
778 ada_name_prefix_len (type_name
), type_name
);
782 if (ada_is_aligner_type (type
))
783 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
784 else if (ada_is_constrained_packed_array_type (type
)
785 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
786 print_array_type (type
, stream
, show
, level
);
788 switch (TYPE_CODE (type
))
791 fprintf_filtered (stream
, "<");
792 c_print_type (type
, "", stream
, show
, level
);
793 fprintf_filtered (stream
, ">");
796 case TYPE_CODE_TYPEDEF
:
797 fprintf_filtered (stream
, "access ");
798 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
801 fprintf_filtered (stream
, "<ref> ");
802 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
804 case TYPE_CODE_ARRAY
:
805 print_array_type (type
, stream
, show
, level
);
808 fprintf_filtered (stream
, "(false, true)");
811 if (ada_is_fixed_point_type (type
))
812 print_fixed_point_type (type
, stream
);
815 const char *name
= ada_type_name (type
);
817 if (!ada_is_range_type_name (name
))
818 fprintf_filtered (stream
, _("<%d-byte integer>"),
822 fprintf_filtered (stream
, "range ");
823 print_range_type (type
, stream
);
827 case TYPE_CODE_RANGE
:
828 if (ada_is_fixed_point_type (type
))
829 print_fixed_point_type (type
, stream
);
830 else if (ada_is_modular_type (type
))
831 fprintf_filtered (stream
, "mod %s",
832 int_string (ada_modulus (type
), 10, 0, 0, 1));
835 fprintf_filtered (stream
, "range ");
836 print_range (type
, stream
);
840 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
844 fprintf_filtered (stream
, "(...)");
846 print_enum_type (type
, stream
);
848 case TYPE_CODE_STRUCT
:
849 if (ada_is_array_descriptor_type (type
))
850 print_array_type (type
, stream
, show
, level
);
851 else if (ada_is_bogus_array_descriptor (type
))
852 fprintf_filtered (stream
,
853 _("array (?) of ? (<mal-formed descriptor>)"));
855 print_record_type (type
, stream
, show
, level
);
857 case TYPE_CODE_UNION
:
858 print_unchecked_union_type (type
, stream
, show
, level
);
861 print_func_type (type
, stream
, varstring
);
866 /* Implement the la_print_typedef language method for Ada. */
869 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
870 struct ui_file
*stream
)
872 type
= ada_check_typedef (type
);
873 ada_print_type (type
, "", stream
, 0, 0);
874 fprintf_filtered (stream
, "\n");
This page took 0.04894 seconds and 4 git commands to generate.