1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2007, 2008, 2009, 2010, 2011 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/>. */
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 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
;
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
);
279 fprintf_filtered (stream
, "(");
283 for (i
= 0; i
< len
; i
++)
287 fprintf_filtered (stream
, ", ");
289 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
290 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
292 fprintf_filtered (stream
, " => %d", TYPE_FIELD_BITPOS (type
, i
));
293 lastval
= TYPE_FIELD_BITPOS (type
, i
);
297 fprintf_filtered (stream
, ")");
300 /* Print representation of Ada fixed-point type TYPE on STREAM. */
303 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
305 DOUBLEST delta
= ada_delta (type
);
306 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
309 fprintf_filtered (stream
, "delta ??");
312 fprintf_filtered (stream
, "delta %g", (double) delta
);
314 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
318 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
319 recursion (indentation) level, in case the element type itself has
320 nested structure, and SHOW is the number of levels of internal
321 structure to show (see ada_print_type). */
324 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
330 if (ada_is_constrained_packed_array_type (type
))
331 type
= ada_coerce_to_simple_array_type (type
);
334 fprintf_filtered (stream
, "array (");
338 fprintf_filtered (stream
, _("<undecipherable array type>"));
344 fprintf_filtered (stream
, "...");
347 if (ada_is_simple_array_type (type
))
349 struct type
*range_desc_type
;
350 struct type
*arr_type
;
352 range_desc_type
= ada_find_parallel_type (type
, "___XA");
353 ada_fixup_array_indexes_type (range_desc_type
);
356 if (range_desc_type
== NULL
)
358 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
359 arr_type
= TYPE_TARGET_TYPE (arr_type
))
361 if (arr_type
!= type
)
362 fprintf_filtered (stream
, ", ");
363 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
364 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
365 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
372 n_indices
= TYPE_NFIELDS (range_desc_type
);
373 for (k
= 0, arr_type
= type
;
375 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
378 fprintf_filtered (stream
, ", ");
379 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
381 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
382 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
390 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
391 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
395 fprintf_filtered (stream
, ") of ");
397 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
398 show
== 0 ? 0 : show
- 1, level
+ 1);
400 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
403 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
404 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
405 values. Return non-zero if the field is an encoding of
406 discriminant values, as in a standard variant record, and 0 if the
407 field is not so encoded (as happens with single-component variants
408 in types annotated with pragma Unchecked_Variant). */
411 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
412 struct type
*val_type
)
416 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
420 /* Skip over leading 'V': NOTE soon to be obsolete. */
423 if (!ada_scan_number (name
, 1, NULL
, &p
))
437 fprintf_filtered (stream
, " =>");
443 fprintf_filtered (stream
, " | ");
454 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
456 ada_print_scalar (val_type
, W
, stream
);
463 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
464 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
466 ada_print_scalar (val_type
, L
, stream
);
467 fprintf_filtered (stream
, " .. ");
468 ada_print_scalar (val_type
, U
, stream
);
472 fprintf_filtered (stream
, "others");
479 fprintf_filtered (stream
, "?? =>");
483 /* Assuming that field FIELD_NUM of TYPE represents variants whose
484 discriminant is contained in OUTER_TYPE, print its components on STREAM.
485 LEVEL is the recursion (indentation) level, in case any of the fields
486 themselves have nested structure, and SHOW is the number of levels of
487 internal structure to show (see ada_print_type). For this purpose,
488 fields nested in a variant part are taken to be at the same level as
489 the fields immediately outside the variant part. */
492 print_variant_clauses (struct type
*type
, int field_num
,
493 struct type
*outer_type
, struct ui_file
*stream
,
497 struct type
*var_type
, *par_type
;
498 struct type
*discr_type
;
500 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
501 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
503 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
505 var_type
= TYPE_TARGET_TYPE (var_type
);
506 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
510 par_type
= ada_find_parallel_type (var_type
, "___XVU");
511 if (par_type
!= NULL
)
514 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
516 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
517 if (print_choices (var_type
, i
, stream
, discr_type
))
519 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
520 outer_type
, stream
, show
, level
+ 4)
522 fprintf_filtered (stream
, " null;");
525 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
526 stream
, show
, level
+ 4);
530 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
531 discriminants are contained in OUTER_TYPE, print a description of it
532 on STREAM. LEVEL is the recursion (indentation) level, in case any of
533 the fields themselves have nested structure, and SHOW is the number of
534 levels of internal structure to show (see ada_print_type). For this
535 purpose, fields nested in a variant part are taken to be at the same
536 level as the fields immediately outside the variant part. */
539 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
540 struct ui_file
*stream
, int show
, int level
)
542 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
543 ada_variant_discrim_name
544 (TYPE_FIELD_TYPE (type
, field_num
)));
545 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
547 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
550 /* Print a description on STREAM of the fields FLD0 through FLD1 in
551 record or union type TYPE, whose discriminants are in OUTER_TYPE.
552 LEVEL is the recursion (indentation) level, in case any of the
553 fields themselves have nested structure, and SHOW is the number of
554 levels of internal structure to show (see ada_print_type). Does
555 not print parent type information of TYPE. Returns 0 if no fields
556 printed, -1 for an incomplete type, else > 0. Prints each field
557 beginning on a new line, but does not put a new line at end. */
560 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
562 struct ui_file
*stream
, int show
, int level
)
568 if (fld0
> fld1
&& TYPE_STUB (type
))
571 for (i
= fld0
; i
<= fld1
; i
+= 1)
575 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
577 else if (ada_is_wrapper_field (type
, i
))
578 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
579 stream
, show
, level
);
580 else if (ada_is_variant_part (type
, i
))
582 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
588 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
589 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
590 TYPE_FIELD_NAME (type
, i
),
591 stream
, show
- 1, level
+ 4);
592 fprintf_filtered (stream
, ";");
599 /* Print a description on STREAM of all fields of record or union type
600 TYPE, as for print_selected_record_field_types, above. */
603 print_record_field_types (struct type
*type
, struct type
*outer_type
,
604 struct ui_file
*stream
, int show
, int level
)
606 return print_selected_record_field_types (type
, outer_type
,
607 0, TYPE_NFIELDS (type
) - 1,
608 stream
, show
, level
);
612 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
613 level, in case the element type itself has nested structure, and SHOW is
614 the number of levels of internal structure to show (see ada_print_type). */
617 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
620 struct type
*parent_type
;
623 type
= ada_find_parallel_type (type0
, "___XVE");
627 parent_type
= ada_parent_type (type
);
628 if (ada_type_name (parent_type
) != NULL
)
629 fprintf_filtered (stream
, "new %s with record",
630 decoded_type_name (parent_type
));
631 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
632 fprintf_filtered (stream
, "tagged record");
634 fprintf_filtered (stream
, "record");
637 fprintf_filtered (stream
, " ... end record");
643 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
644 flds
+= print_record_field_types (parent_type
, parent_type
,
645 stream
, show
, level
);
646 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
649 fprintf_filtered (stream
, "\n%*send record", level
, "");
651 fprintf_filtered (stream
, _(" <incomplete type> end record"));
653 fprintf_filtered (stream
, " null; end record");
657 /* Print the unchecked union type TYPE in something resembling Ada
658 format on STREAM. LEVEL is the recursion (indentation) level
659 in case the element type itself has nested structure, and SHOW is the
660 number of levels of internal structure to show (see ada_print_type). */
662 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
666 fprintf_filtered (stream
, "record (?) is ... end record");
667 else if (TYPE_NFIELDS (type
) == 0)
668 fprintf_filtered (stream
, "record (?) is null; end record");
673 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
675 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
677 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
679 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
680 TYPE_FIELD_NAME (type
, i
),
681 stream
, show
- 1, level
+ 12);
682 fprintf_filtered (stream
, ";");
685 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
686 level
+ 4, "", level
, "");
692 /* Print function or procedure type TYPE on STREAM. Make it a header
693 for function or procedure NAME if NAME is not null. */
696 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
)
698 int i
, len
= TYPE_NFIELDS (type
);
700 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
701 fprintf_filtered (stream
, "procedure");
703 fprintf_filtered (stream
, "function");
705 if (name
!= NULL
&& name
[0] != '\0')
706 fprintf_filtered (stream
, " %s", name
);
710 fprintf_filtered (stream
, " (");
711 for (i
= 0; i
< len
; i
+= 1)
715 fputs_filtered ("; ", stream
);
718 fprintf_filtered (stream
, "a%d: ", i
+ 1);
719 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
721 fprintf_filtered (stream
, ")");
724 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
726 fprintf_filtered (stream
, " return ");
727 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
732 /* Print a description of a type TYPE0.
733 Output goes to STREAM (via stdio).
734 If VARSTRING is a non-empty string, print as an Ada variable/field
736 SHOW+1 is the maximum number of levels of internal type structure
737 to show (this applies to record types, enumerated types, and
739 SHOW is the number of levels of internal type structure to show
740 when there is a type name for the SHOWth deepest level (0th is
742 When SHOW<0, no inner structure is shown.
743 LEVEL indicates level of recursion (for nested definitions). */
746 ada_print_type (struct type
*type0
, const char *varstring
,
747 struct ui_file
*stream
, int show
, int level
)
749 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
750 char *type_name
= decoded_type_name (type0
);
751 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
756 fprintf_filtered (stream
, "%.*s: ",
757 ada_name_prefix_len (varstring
), varstring
);
758 fprintf_filtered (stream
, "<null type?>");
763 type
= ada_check_typedef (type
);
765 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
766 fprintf_filtered (stream
, "%.*s: ",
767 ada_name_prefix_len (varstring
), varstring
);
769 if (type_name
!= NULL
&& show
<= 0)
771 fprintf_filtered (stream
, "%.*s",
772 ada_name_prefix_len (type_name
), type_name
);
776 if (ada_is_aligner_type (type
))
777 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
778 else if (ada_is_constrained_packed_array_type (type
))
780 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
782 fprintf_filtered (stream
, "access ");
783 print_array_type (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
787 print_array_type (type
, stream
, show
, level
);
791 switch (TYPE_CODE (type
))
794 fprintf_filtered (stream
, "<");
795 c_print_type (type
, "", stream
, show
, level
);
796 fprintf_filtered (stream
, ">");
799 case TYPE_CODE_TYPEDEF
:
800 fprintf_filtered (stream
, "access ");
801 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
804 fprintf_filtered (stream
, "<ref> ");
805 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
807 case TYPE_CODE_ARRAY
:
808 print_array_type (type
, stream
, show
, level
);
811 fprintf_filtered (stream
, "(false, true)");
814 if (ada_is_fixed_point_type (type
))
815 print_fixed_point_type (type
, stream
);
818 char *name
= ada_type_name (type
);
820 if (!ada_is_range_type_name (name
))
821 fprintf_filtered (stream
, _("<%d-byte integer>"),
825 fprintf_filtered (stream
, "range ");
826 print_range_type (type
, stream
);
830 case TYPE_CODE_RANGE
:
831 if (ada_is_fixed_point_type (type
))
832 print_fixed_point_type (type
, stream
);
833 else if (ada_is_modular_type (type
))
834 fprintf_filtered (stream
, "mod %s",
835 int_string (ada_modulus (type
), 10, 0, 0, 1));
838 fprintf_filtered (stream
, "range ");
839 print_range (type
, stream
);
843 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
847 fprintf_filtered (stream
, "(...)");
849 print_enum_type (type
, stream
);
851 case TYPE_CODE_STRUCT
:
852 if (ada_is_array_descriptor_type (type
))
853 print_array_type (type
, stream
, show
, level
);
854 else if (ada_is_bogus_array_descriptor (type
))
855 fprintf_filtered (stream
,
856 _("array (?) of ? (<mal-formed descriptor>)"));
858 print_record_type (type
, stream
, show
, level
);
860 case TYPE_CODE_UNION
:
861 print_unchecked_union_type (type
, stream
, show
, level
);
864 print_func_type (type
, stream
, varstring
);
869 /* Implement the la_print_typedef language method for Ada. */
872 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
873 struct ui_file
*stream
)
875 type
= ada_check_typedef (type
);
876 ada_print_type (type
, "", stream
, 0, 0);
877 fprintf_filtered (stream
, "\n");
This page took 0.04784 seconds and 4 git commands to generate.