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 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_record_field_types (struct type
*, struct type
*,
42 struct ui_file
*, int, int);
44 static void print_array_type (struct type
*, struct ui_file
*, int, int);
46 static void print_choices (struct type
*, int, struct ui_file
*,
49 static void print_range (struct type
*, struct ui_file
*);
51 static void print_range_bound (struct type
*, char *, int *,
55 print_dynamic_range_bound (struct type
*, const char *, int,
56 const char *, struct ui_file
*);
58 static void print_range_type_named (char *, struct ui_file
*);
62 static char *name_buffer
;
63 static int name_buffer_len
;
65 /* The (decoded) Ada name of TYPE. This value persists until the
69 decoded_type_name (struct type
*type
)
71 if (ada_type_name (type
) == NULL
)
75 char *raw_name
= ada_type_name (type
);
78 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
80 name_buffer_len
= 16 + 2 * strlen (raw_name
);
81 name_buffer
= xrealloc (name_buffer
, name_buffer_len
);
83 strcpy (name_buffer
, raw_name
);
85 s
= (char *) strstr (name_buffer
, "___");
89 s
= name_buffer
+ strlen (name_buffer
) - 1;
90 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
99 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
101 if (s
[0] == '_' && s
[1] == '_')
117 /* Print range type TYPE on STREAM. */
120 print_range (struct type
*type
, struct ui_file
*stream
)
122 struct type
*target_type
;
123 target_type
= TYPE_TARGET_TYPE (type
);
124 if (target_type
== NULL
)
127 switch (TYPE_CODE (target_type
))
129 case TYPE_CODE_RANGE
:
136 target_type
= builtin_type_int32
;
140 if (TYPE_NFIELDS (type
) < 2)
142 /* A range needs at least 2 bounds to be printed. If there are less
143 than 2, just print the type name instead of the range itself.
144 This check handles cases such as characters, for example.
146 If the name is not defined, then we don't print anything.
148 fprintf_filtered (stream
, "%.*s",
149 ada_name_prefix_len (TYPE_NAME (type
)),
154 /* We extract the range type bounds respectively from the first element
155 and the last element of the type->fields array */
156 const LONGEST lower_bound
= (LONGEST
) TYPE_LOW_BOUND (type
);
157 const LONGEST upper_bound
= (TYPE_CODE (type
) == TYPE_CODE_RANGE
158 ? (LONGEST
) TYPE_HIGH_BOUND (type
)
159 : (LONGEST
) TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1));
161 ada_print_scalar (target_type
, lower_bound
, stream
);
162 fprintf_filtered (stream
, " .. ");
163 ada_print_scalar (target_type
, upper_bound
, stream
);
167 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
168 set *N past the bound and its delimiter, if any. */
171 print_range_bound (struct type
*type
, char *bounds
, int *n
,
172 struct ui_file
*stream
)
175 if (ada_scan_number (bounds
, *n
, &B
, n
))
177 /* STABS decodes all range types which bounds are 0 .. -1 as
178 unsigned integers (ie. the type code is TYPE_CODE_INT, not
179 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
180 on the unsigned flag to determine whether the bound should
181 be printed as a signed or an unsigned value. This causes
182 the upper bound of the 0 .. -1 range types to be printed as
183 a very large unsigned number instead of -1.
184 To workaround this stabs deficiency, we replace the TYPE by
185 builtin_type_int32 when we detect that the bound is negative,
186 and the type is a TYPE_CODE_INT. The bound is negative when
187 'm' is the last character of the number scanned in BOUNDS. */
188 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
189 type
= builtin_type_int32
;
190 ada_print_scalar (type
, B
, stream
);
191 if (bounds
[*n
] == '_')
197 char *bound
= bounds
+ *n
;
200 pend
= strstr (bound
, "__");
202 *n
+= bound_len
= strlen (bound
);
205 bound_len
= pend
- bound
;
208 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
212 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
213 the value (if found) of the bound indicated by SUFFIX ("___L" or
214 "___U") according to the ___XD conventions. */
217 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
218 const char *suffix
, struct ui_file
*stream
)
220 static char *name_buf
= NULL
;
221 static size_t name_buf_len
= 0;
225 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
226 strncpy (name_buf
, name
, name_len
);
227 strcpy (name_buf
+ name_len
, suffix
);
229 B
= get_int_var_value (name_buf
, &OK
);
231 ada_print_scalar (type
, B
, stream
);
233 fprintf_filtered (stream
, "?");
236 /* Print the range type named NAME. */
239 print_range_type_named (char *name
, struct ui_file
*stream
)
241 struct type
*raw_type
= ada_find_any_type (name
);
242 struct type
*base_type
;
245 if (raw_type
== NULL
)
246 base_type
= builtin_type_int32
;
247 else if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
248 base_type
= TYPE_TARGET_TYPE (raw_type
);
250 base_type
= raw_type
;
252 subtype_info
= strstr (name
, "___XD");
253 if (subtype_info
== NULL
&& raw_type
== NULL
)
254 fprintf_filtered (stream
, "? .. ?");
255 else if (subtype_info
== NULL
)
256 print_range (raw_type
, stream
);
259 int prefix_len
= subtype_info
- name
;
264 bounds_str
= strchr (subtype_info
, '_');
267 if (*subtype_info
== 'L')
269 print_range_bound (base_type
, bounds_str
, &n
, stream
);
273 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
276 fprintf_filtered (stream
, " .. ");
278 if (*subtype_info
== 'U')
279 print_range_bound (base_type
, bounds_str
, &n
, stream
);
281 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
286 /* Print enumerated type TYPE on STREAM. */
289 print_enum_type (struct type
*type
, struct ui_file
*stream
)
291 int len
= TYPE_NFIELDS (type
);
294 fprintf_filtered (stream
, "(");
298 for (i
= 0; i
< len
; i
++)
302 fprintf_filtered (stream
, ", ");
304 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
305 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
307 fprintf_filtered (stream
, " => %d", TYPE_FIELD_BITPOS (type
, i
));
308 lastval
= TYPE_FIELD_BITPOS (type
, i
);
312 fprintf_filtered (stream
, ")");
315 /* Print representation of Ada fixed-point type TYPE on STREAM. */
318 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
320 DOUBLEST delta
= ada_delta (type
);
321 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
324 fprintf_filtered (stream
, "delta ??");
327 fprintf_filtered (stream
, "delta %g", (double) delta
);
329 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
333 /* Print representation of special VAX floating-point type TYPE on STREAM. */
336 print_vax_floating_point_type (struct type
*type
, struct ui_file
*stream
)
338 fprintf_filtered (stream
, "<float format %c>",
339 ada_vax_float_type_suffix (type
));
342 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
343 recursion (indentation) level, in case the element type itself has
344 nested structure, and SHOW is the number of levels of internal
345 structure to show (see ada_print_type). */
348 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
354 if (ada_is_packed_array_type (type
))
355 type
= ada_coerce_to_simple_array_type (type
);
358 fprintf_filtered (stream
, "array (");
362 fprintf_filtered (stream
, _("<undecipherable array type>"));
368 fprintf_filtered (stream
, "...");
371 if (ada_is_simple_array_type (type
))
373 struct type
*range_desc_type
=
374 ada_find_parallel_type (type
, "___XA");
375 struct type
*arr_type
;
378 if (range_desc_type
== NULL
)
380 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
381 arr_type
= TYPE_TARGET_TYPE (arr_type
))
383 if (arr_type
!= type
)
384 fprintf_filtered (stream
, ", ");
385 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
386 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
387 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
393 n_indices
= TYPE_NFIELDS (range_desc_type
);
394 for (k
= 0, arr_type
= type
;
396 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
399 fprintf_filtered (stream
, ", ");
400 print_range_type_named (TYPE_FIELD_NAME
401 (range_desc_type
, k
), stream
);
402 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
403 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
410 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
411 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
415 fprintf_filtered (stream
, ") of ");
417 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
418 show
== 0 ? 0 : show
- 1, level
+ 1);
420 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
423 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
424 STREAM, assuming the VAL_TYPE is the type of the values. */
427 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
428 struct type
*val_type
)
432 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
436 /* Skip over leading 'V': NOTE soon to be obsolete. */
439 if (!ada_scan_number (name
, 1, NULL
, &p
))
455 fprintf_filtered (stream
, " | ");
465 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
467 ada_print_scalar (val_type
, W
, stream
);
473 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
474 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
476 ada_print_scalar (val_type
, L
, stream
);
477 fprintf_filtered (stream
, " .. ");
478 ada_print_scalar (val_type
, U
, stream
);
482 fprintf_filtered (stream
, "others");
489 fprintf_filtered (stream
, "??");
493 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
494 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
495 LEVEL is the recursion
496 (indentation) level, in case any of the fields themselves have
497 nested structure, and SHOW is the number of levels of internal structure
498 to show (see ada_print_type). For this purpose, fields nested in a
499 variant part are taken to be at the same level as the fields
500 immediately outside the variant part. */
503 print_variant_clauses (struct type
*type
, int field_num
,
504 struct type
*outer_type
, struct ui_file
*stream
,
508 struct type
*var_type
, *par_type
;
509 struct type
*discr_type
;
511 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
512 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
514 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
516 var_type
= TYPE_TARGET_TYPE (var_type
);
517 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
521 par_type
= ada_find_parallel_type (var_type
, "___XVU");
522 if (par_type
!= NULL
)
525 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
527 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
528 print_choices (var_type
, i
, stream
, discr_type
);
529 fprintf_filtered (stream
, " =>");
530 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
531 outer_type
, stream
, show
, level
+ 4) <= 0)
532 fprintf_filtered (stream
, " null;");
536 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
537 discriminants are contained in OUTER_TYPE, print a description of it
538 on STREAM. LEVEL is the recursion (indentation) level, in case any of
539 the fields themselves have nested structure, and SHOW is the number of
540 levels of internal structure to show (see ada_print_type). For this
541 purpose, fields nested in a variant part are taken to be at the same
542 level as the fields immediately outside the variant part. */
545 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
546 struct ui_file
*stream
, int show
, int level
)
548 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
549 ada_variant_discrim_name
550 (TYPE_FIELD_TYPE (type
, field_num
)));
551 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
553 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
556 /* Print a description on STREAM of the fields in record type TYPE, whose
557 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
558 level, in case any of the fields themselves have nested structure,
559 and SHOW is the number of levels of internal structure to show
560 (see ada_print_type). Does not print parent type information of TYPE.
561 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
562 Prints each field beginning on a new line, but does not put a new line at
566 print_record_field_types (struct type
*type
, struct type
*outer_type
,
567 struct ui_file
*stream
, int show
, int level
)
572 len
= TYPE_NFIELDS (type
);
574 if (len
== 0 && TYPE_STUB (type
))
577 for (i
= 0; i
< len
; i
+= 1)
581 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
583 else if (ada_is_wrapper_field (type
, i
))
584 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
585 stream
, show
, level
);
586 else if (ada_is_variant_part (type
, i
))
588 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
594 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
595 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
596 TYPE_FIELD_NAME (type
, i
),
597 stream
, show
- 1, level
+ 4);
598 fprintf_filtered (stream
, ";");
605 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
606 level, in case the element type itself has nested structure, and SHOW is
607 the number of levels of internal structure to show (see ada_print_type). */
610 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
613 struct type
*parent_type
;
616 type
= ada_find_parallel_type (type0
, "___XVE");
620 parent_type
= ada_parent_type (type
);
621 if (ada_type_name (parent_type
) != NULL
)
622 fprintf_filtered (stream
, "new %s with record",
623 decoded_type_name (parent_type
));
624 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
625 fprintf_filtered (stream
, "tagged record");
627 fprintf_filtered (stream
, "record");
630 fprintf_filtered (stream
, " ... end record");
636 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
637 flds
+= print_record_field_types (parent_type
, parent_type
,
638 stream
, show
, level
);
639 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
642 fprintf_filtered (stream
, "\n%*send record", level
, "");
644 fprintf_filtered (stream
, _(" <incomplete type> end record"));
646 fprintf_filtered (stream
, " null; end record");
650 /* Print the unchecked union type TYPE in something resembling Ada
651 format on STREAM. LEVEL is the recursion (indentation) level
652 in case the element type itself has nested structure, and SHOW is the
653 number of levels of internal structure to show (see ada_print_type). */
655 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
659 fprintf_filtered (stream
, "record (?) is ... end record");
660 else if (TYPE_NFIELDS (type
) == 0)
661 fprintf_filtered (stream
, "record (?) is null; end record");
666 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
668 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
670 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
672 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
673 TYPE_FIELD_NAME (type
, i
),
674 stream
, show
- 1, level
+ 12);
675 fprintf_filtered (stream
, ";");
678 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
679 level
+ 4, "", level
, "");
685 /* Print function or procedure type TYPE on STREAM. Make it a header
686 for function or procedure NAME if NAME is not null. */
689 print_func_type (struct type
*type
, struct ui_file
*stream
, char *name
)
691 int i
, len
= TYPE_NFIELDS (type
);
693 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
694 fprintf_filtered (stream
, "procedure");
696 fprintf_filtered (stream
, "function");
698 if (name
!= NULL
&& name
[0] != '\0')
699 fprintf_filtered (stream
, " %s", name
);
703 fprintf_filtered (stream
, " (");
704 for (i
= 0; i
< len
; i
+= 1)
708 fputs_filtered ("; ", stream
);
711 fprintf_filtered (stream
, "a%d: ", i
+ 1);
712 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
714 fprintf_filtered (stream
, ")");
717 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
719 fprintf_filtered (stream
, " return ");
720 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
725 /* Print a description of a type TYPE0.
726 Output goes to STREAM (via stdio).
727 If VARSTRING is a non-empty string, print as an Ada variable/field
729 SHOW+1 is the maximum number of levels of internal type structure
730 to show (this applies to record types, enumerated types, and
732 SHOW is the number of levels of internal type structure to show
733 when there is a type name for the SHOWth deepest level (0th is
735 When SHOW<0, no inner structure is shown.
736 LEVEL indicates level of recursion (for nested definitions). */
739 ada_print_type (struct type
*type0
, char *varstring
, struct ui_file
*stream
,
742 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
743 char *type_name
= decoded_type_name (type0
);
744 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
749 fprintf_filtered (stream
, "%.*s: ",
750 ada_name_prefix_len (varstring
), varstring
);
751 fprintf_filtered (stream
, "<null type?>");
756 type
= ada_check_typedef (type
);
758 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
759 fprintf_filtered (stream
, "%.*s: ",
760 ada_name_prefix_len (varstring
), varstring
);
762 if (type_name
!= NULL
&& show
<= 0)
764 fprintf_filtered (stream
, "%.*s",
765 ada_name_prefix_len (type_name
), type_name
);
769 if (ada_is_aligner_type (type
))
770 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
771 else if (ada_is_packed_array_type (type
))
773 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
775 fprintf_filtered (stream
, "access ");
776 print_array_type (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
780 print_array_type (type
, stream
, show
, level
);
784 switch (TYPE_CODE (type
))
787 fprintf_filtered (stream
, "<");
788 c_print_type (type
, "", stream
, show
, level
);
789 fprintf_filtered (stream
, ">");
792 fprintf_filtered (stream
, "access ");
793 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
796 fprintf_filtered (stream
, "<ref> ");
797 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
799 case TYPE_CODE_ARRAY
:
800 print_array_type (type
, stream
, show
, level
);
803 fprintf_filtered (stream
, "(false, true)");
806 if (ada_is_fixed_point_type (type
))
807 print_fixed_point_type (type
, stream
);
808 else if (ada_is_vax_floating_type (type
))
809 print_vax_floating_point_type (type
, stream
);
812 char *name
= ada_type_name (type
);
813 if (!ada_is_range_type_name (name
))
814 fprintf_filtered (stream
, _("<%d-byte integer>"),
818 fprintf_filtered (stream
, "range ");
819 print_range_type_named (name
, stream
);
823 case TYPE_CODE_RANGE
:
824 if (ada_is_fixed_point_type (type
))
825 print_fixed_point_type (type
, stream
);
826 else if (ada_is_vax_floating_type (type
))
827 print_vax_floating_point_type (type
, stream
);
828 else if (ada_is_modular_type (type
))
829 fprintf_filtered (stream
, "mod %s",
830 int_string (ada_modulus (type
), 10, 0, 0, 1));
833 fprintf_filtered (stream
, "range ");
834 print_range (type
, stream
);
838 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
842 fprintf_filtered (stream
, "(...)");
844 print_enum_type (type
, stream
);
846 case TYPE_CODE_STRUCT
:
847 if (ada_is_array_descriptor_type (type
))
848 print_array_type (type
, stream
, show
, level
);
849 else if (ada_is_bogus_array_descriptor (type
))
850 fprintf_filtered (stream
,
851 _("array (?) of ? (<mal-formed descriptor>)"));
853 print_record_type (type
, stream
, show
, level
);
855 case TYPE_CODE_UNION
:
856 print_unchecked_union_type (type
, stream
, show
, level
);
859 print_func_type (type
, stream
, varstring
);
This page took 0.04854 seconds and 4 git commands to generate.