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 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 (struct type
*, 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 TYPE on STREAM, preferably as a range. */
120 print_range (struct type
*type
, struct ui_file
*stream
)
122 switch (TYPE_CODE (type
))
124 case TYPE_CODE_RANGE
:
127 struct type
*target_type
;
128 target_type
= TYPE_TARGET_TYPE (type
);
129 if (target_type
== NULL
)
131 ada_print_scalar (target_type
, ada_discrete_type_low_bound (type
),
133 fprintf_filtered (stream
, " .. ");
134 ada_print_scalar (target_type
, ada_discrete_type_high_bound (type
),
139 fprintf_filtered (stream
, "%.*s",
140 ada_name_prefix_len (TYPE_NAME (type
)),
146 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
147 set *N past the bound and its delimiter, if any. */
150 print_range_bound (struct type
*type
, char *bounds
, int *n
,
151 struct ui_file
*stream
)
155 if (ada_scan_number (bounds
, *n
, &B
, n
))
157 /* STABS decodes all range types which bounds are 0 .. -1 as
158 unsigned integers (ie. the type code is TYPE_CODE_INT, not
159 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
160 on the unsigned flag to determine whether the bound should
161 be printed as a signed or an unsigned value. This causes
162 the upper bound of the 0 .. -1 range types to be printed as
163 a very large unsigned number instead of -1.
164 To workaround this stabs deficiency, we replace the TYPE by NULL
165 to indicate default output when we detect that the bound is negative,
166 and the type is a TYPE_CODE_INT. The bound is negative when
167 'm' is the last character of the number scanned in BOUNDS. */
168 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
170 ada_print_scalar (type
, B
, stream
);
171 if (bounds
[*n
] == '_')
177 char *bound
= bounds
+ *n
;
180 pend
= strstr (bound
, "__");
182 *n
+= bound_len
= strlen (bound
);
185 bound_len
= pend
- bound
;
188 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
192 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
193 the value (if found) of the bound indicated by SUFFIX ("___L" or
194 "___U") according to the ___XD conventions. */
197 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
198 const char *suffix
, struct ui_file
*stream
)
200 static char *name_buf
= NULL
;
201 static size_t name_buf_len
= 0;
205 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
206 strncpy (name_buf
, name
, name_len
);
207 strcpy (name_buf
+ name_len
, suffix
);
209 B
= get_int_var_value (name_buf
, &OK
);
211 ada_print_scalar (type
, B
, stream
);
213 fprintf_filtered (stream
, "?");
216 /* Print RAW_TYPE as a range type, using any bound information
217 following the GNAT encoding (if available). */
220 print_range_type (struct type
*raw_type
, struct ui_file
*stream
)
223 struct type
*base_type
;
226 gdb_assert (raw_type
!= NULL
);
227 name
= TYPE_NAME (raw_type
);
228 gdb_assert (name
!= NULL
);
230 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
231 base_type
= TYPE_TARGET_TYPE (raw_type
);
233 base_type
= raw_type
;
235 subtype_info
= strstr (name
, "___XD");
236 if (subtype_info
== NULL
)
237 print_range (raw_type
, stream
);
240 int prefix_len
= subtype_info
- name
;
245 bounds_str
= strchr (subtype_info
, '_');
248 if (*subtype_info
== 'L')
250 print_range_bound (base_type
, bounds_str
, &n
, stream
);
254 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
257 fprintf_filtered (stream
, " .. ");
259 if (*subtype_info
== 'U')
260 print_range_bound (base_type
, bounds_str
, &n
, stream
);
262 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
267 /* Print enumerated type TYPE on STREAM. */
270 print_enum_type (struct type
*type
, struct ui_file
*stream
)
272 int len
= TYPE_NFIELDS (type
);
275 fprintf_filtered (stream
, "(");
279 for (i
= 0; i
< len
; i
++)
283 fprintf_filtered (stream
, ", ");
285 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
286 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
288 fprintf_filtered (stream
, " => %d", TYPE_FIELD_BITPOS (type
, i
));
289 lastval
= TYPE_FIELD_BITPOS (type
, i
);
293 fprintf_filtered (stream
, ")");
296 /* Print representation of Ada fixed-point type TYPE on STREAM. */
299 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
301 DOUBLEST delta
= ada_delta (type
);
302 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
305 fprintf_filtered (stream
, "delta ??");
308 fprintf_filtered (stream
, "delta %g", (double) delta
);
310 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
314 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
315 recursion (indentation) level, in case the element type itself has
316 nested structure, and SHOW is the number of levels of internal
317 structure to show (see ada_print_type). */
320 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
326 if (ada_is_constrained_packed_array_type (type
))
327 type
= ada_coerce_to_simple_array_type (type
);
330 fprintf_filtered (stream
, "array (");
334 fprintf_filtered (stream
, _("<undecipherable array type>"));
340 fprintf_filtered (stream
, "...");
343 if (ada_is_simple_array_type (type
))
345 struct type
*range_desc_type
;
346 struct type
*arr_type
;
348 range_desc_type
= ada_find_parallel_type (type
, "___XA");
349 ada_fixup_array_indexes_type (range_desc_type
);
352 if (range_desc_type
== NULL
)
354 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
355 arr_type
= TYPE_TARGET_TYPE (arr_type
))
357 if (arr_type
!= type
)
358 fprintf_filtered (stream
, ", ");
359 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
360 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
361 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
368 n_indices
= TYPE_NFIELDS (range_desc_type
);
369 for (k
= 0, arr_type
= type
;
371 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
374 fprintf_filtered (stream
, ", ");
375 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
377 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
378 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
386 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
387 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
391 fprintf_filtered (stream
, ") of ");
393 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
394 show
== 0 ? 0 : show
- 1, level
+ 1);
396 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
399 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
400 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values. */
403 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
404 struct type
*val_type
)
408 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
412 /* Skip over leading 'V': NOTE soon to be obsolete. */
415 if (!ada_scan_number (name
, 1, NULL
, &p
))
431 fprintf_filtered (stream
, " | ");
442 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
444 ada_print_scalar (val_type
, W
, stream
);
451 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
452 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
454 ada_print_scalar (val_type
, L
, stream
);
455 fprintf_filtered (stream
, " .. ");
456 ada_print_scalar (val_type
, U
, stream
);
460 fprintf_filtered (stream
, "others");
467 fprintf_filtered (stream
, "??");
471 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
472 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
473 LEVEL is the recursion
474 (indentation) level, in case any of the fields themselves have
475 nested structure, and SHOW is the number of levels of internal structure
476 to show (see ada_print_type). For this purpose, fields nested in a
477 variant part are taken to be at the same level as the fields
478 immediately outside the variant part. */
481 print_variant_clauses (struct type
*type
, int field_num
,
482 struct type
*outer_type
, struct ui_file
*stream
,
486 struct type
*var_type
, *par_type
;
487 struct type
*discr_type
;
489 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
490 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
492 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
494 var_type
= TYPE_TARGET_TYPE (var_type
);
495 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
499 par_type
= ada_find_parallel_type (var_type
, "___XVU");
500 if (par_type
!= NULL
)
503 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
505 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
506 print_choices (var_type
, i
, stream
, discr_type
);
507 fprintf_filtered (stream
, " =>");
508 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
509 outer_type
, stream
, show
, level
+ 4) <= 0)
510 fprintf_filtered (stream
, " null;");
514 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
515 discriminants are contained in OUTER_TYPE, print a description of it
516 on STREAM. LEVEL is the recursion (indentation) level, in case any of
517 the fields themselves have nested structure, and SHOW is the number of
518 levels of internal structure to show (see ada_print_type). For this
519 purpose, fields nested in a variant part are taken to be at the same
520 level as the fields immediately outside the variant part. */
523 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
524 struct ui_file
*stream
, int show
, int level
)
526 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
527 ada_variant_discrim_name
528 (TYPE_FIELD_TYPE (type
, field_num
)));
529 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
531 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
534 /* Print a description on STREAM of the fields in record type TYPE, whose
535 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
536 level, in case any of the fields themselves have nested structure,
537 and SHOW is the number of levels of internal structure to show
538 (see ada_print_type). Does not print parent type information of TYPE.
539 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
540 Prints each field beginning on a new line, but does not put a new line at
544 print_record_field_types (struct type
*type
, struct type
*outer_type
,
545 struct ui_file
*stream
, int show
, int level
)
550 len
= TYPE_NFIELDS (type
);
552 if (len
== 0 && TYPE_STUB (type
))
555 for (i
= 0; i
< len
; i
+= 1)
559 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
561 else if (ada_is_wrapper_field (type
, i
))
562 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
563 stream
, show
, level
);
564 else if (ada_is_variant_part (type
, i
))
566 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
572 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
573 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
574 TYPE_FIELD_NAME (type
, i
),
575 stream
, show
- 1, level
+ 4);
576 fprintf_filtered (stream
, ";");
583 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
584 level, in case the element type itself has nested structure, and SHOW is
585 the number of levels of internal structure to show (see ada_print_type). */
588 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
591 struct type
*parent_type
;
594 type
= ada_find_parallel_type (type0
, "___XVE");
598 parent_type
= ada_parent_type (type
);
599 if (ada_type_name (parent_type
) != NULL
)
600 fprintf_filtered (stream
, "new %s with record",
601 decoded_type_name (parent_type
));
602 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
603 fprintf_filtered (stream
, "tagged record");
605 fprintf_filtered (stream
, "record");
608 fprintf_filtered (stream
, " ... end record");
614 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
615 flds
+= print_record_field_types (parent_type
, parent_type
,
616 stream
, show
, level
);
617 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
620 fprintf_filtered (stream
, "\n%*send record", level
, "");
622 fprintf_filtered (stream
, _(" <incomplete type> end record"));
624 fprintf_filtered (stream
, " null; end record");
628 /* Print the unchecked union type TYPE in something resembling Ada
629 format on STREAM. LEVEL is the recursion (indentation) level
630 in case the element type itself has nested structure, and SHOW is the
631 number of levels of internal structure to show (see ada_print_type). */
633 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
637 fprintf_filtered (stream
, "record (?) is ... end record");
638 else if (TYPE_NFIELDS (type
) == 0)
639 fprintf_filtered (stream
, "record (?) is null; end record");
644 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
646 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
648 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
650 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
651 TYPE_FIELD_NAME (type
, i
),
652 stream
, show
- 1, level
+ 12);
653 fprintf_filtered (stream
, ";");
656 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
657 level
+ 4, "", level
, "");
663 /* Print function or procedure type TYPE on STREAM. Make it a header
664 for function or procedure NAME if NAME is not null. */
667 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
)
669 int i
, len
= TYPE_NFIELDS (type
);
671 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
672 fprintf_filtered (stream
, "procedure");
674 fprintf_filtered (stream
, "function");
676 if (name
!= NULL
&& name
[0] != '\0')
677 fprintf_filtered (stream
, " %s", name
);
681 fprintf_filtered (stream
, " (");
682 for (i
= 0; i
< len
; i
+= 1)
686 fputs_filtered ("; ", stream
);
689 fprintf_filtered (stream
, "a%d: ", i
+ 1);
690 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
692 fprintf_filtered (stream
, ")");
695 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
697 fprintf_filtered (stream
, " return ");
698 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
703 /* Print a description of a type TYPE0.
704 Output goes to STREAM (via stdio).
705 If VARSTRING is a non-empty string, print as an Ada variable/field
707 SHOW+1 is the maximum number of levels of internal type structure
708 to show (this applies to record types, enumerated types, and
710 SHOW is the number of levels of internal type structure to show
711 when there is a type name for the SHOWth deepest level (0th is
713 When SHOW<0, no inner structure is shown.
714 LEVEL indicates level of recursion (for nested definitions). */
717 ada_print_type (struct type
*type0
, const char *varstring
,
718 struct ui_file
*stream
, int show
, int level
)
720 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
721 char *type_name
= decoded_type_name (type0
);
722 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
727 fprintf_filtered (stream
, "%.*s: ",
728 ada_name_prefix_len (varstring
), varstring
);
729 fprintf_filtered (stream
, "<null type?>");
734 type
= ada_check_typedef (type
);
736 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
737 fprintf_filtered (stream
, "%.*s: ",
738 ada_name_prefix_len (varstring
), varstring
);
740 if (type_name
!= NULL
&& show
<= 0)
742 fprintf_filtered (stream
, "%.*s",
743 ada_name_prefix_len (type_name
), type_name
);
747 if (ada_is_aligner_type (type
))
748 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
749 else if (ada_is_constrained_packed_array_type (type
))
751 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
753 fprintf_filtered (stream
, "access ");
754 print_array_type (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
758 print_array_type (type
, stream
, show
, level
);
762 switch (TYPE_CODE (type
))
765 fprintf_filtered (stream
, "<");
766 c_print_type (type
, "", stream
, show
, level
);
767 fprintf_filtered (stream
, ">");
770 fprintf_filtered (stream
, "access ");
771 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
774 fprintf_filtered (stream
, "<ref> ");
775 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
777 case TYPE_CODE_ARRAY
:
778 print_array_type (type
, stream
, show
, level
);
781 fprintf_filtered (stream
, "(false, true)");
784 if (ada_is_fixed_point_type (type
))
785 print_fixed_point_type (type
, stream
);
788 char *name
= ada_type_name (type
);
790 if (!ada_is_range_type_name (name
))
791 fprintf_filtered (stream
, _("<%d-byte integer>"),
795 fprintf_filtered (stream
, "range ");
796 print_range_type (type
, stream
);
800 case TYPE_CODE_RANGE
:
801 if (ada_is_fixed_point_type (type
))
802 print_fixed_point_type (type
, stream
);
803 else if (ada_is_modular_type (type
))
804 fprintf_filtered (stream
, "mod %s",
805 int_string (ada_modulus (type
), 10, 0, 0, 1));
808 fprintf_filtered (stream
, "range ");
809 print_range (type
, stream
);
813 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
817 fprintf_filtered (stream
, "(...)");
819 print_enum_type (type
, stream
);
821 case TYPE_CODE_STRUCT
:
822 if (ada_is_array_descriptor_type (type
))
823 print_array_type (type
, stream
, show
, level
);
824 else if (ada_is_bogus_array_descriptor (type
))
825 fprintf_filtered (stream
,
826 _("array (?) of ? (<mal-formed descriptor>)"));
828 print_record_type (type
, stream
, show
, level
);
830 case TYPE_CODE_UNION
:
831 print_unchecked_union_type (type
, stream
, show
, level
);
834 print_func_type (type
, stream
, varstring
);
839 /* Implement the la_print_typedef language method for Ada. */
842 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
843 struct ui_file
*stream
)
845 type
= ada_check_typedef (type
);
846 ada_print_type (type
, "", stream
, 0, 0);
847 fprintf_filtered (stream
, "\n");
This page took 0.051643 seconds and 4 git commands to generate.