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)
154 if (ada_scan_number (bounds, *n, &B, n))
156 /* STABS decodes all range types which bounds are 0 .. -1 as
157 unsigned integers (ie. the type code is TYPE_CODE_INT, not
158 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
159 on the unsigned flag to determine whether the bound should
160 be printed as a signed or an unsigned value. This causes
161 the upper bound of the 0 .. -1 range types to be printed as
162 a very large unsigned number instead of -1.
163 To workaround this stabs deficiency, we replace the TYPE by NULL
164 to indicate default output when we detect that the bound is negative,
165 and the type is a TYPE_CODE_INT. The bound is negative when
166 'm' is the last character of the number scanned in BOUNDS. */
167 if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
169 ada_print_scalar (type, B, stream);
170 if (bounds[*n] == '_')
176 char *bound = bounds + *n;
179 pend = strstr (bound, "__");
181 *n += bound_len = strlen (bound);
184 bound_len = pend - bound;
187 fprintf_filtered (stream, "%.*s", bound_len, bound);
191 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
192 the value (if found) of the bound indicated by SUFFIX ("___L" or
193 "___U") according to the ___XD conventions. */
196 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
197 const char *suffix, struct ui_file *stream)
199 static char *name_buf = NULL;
200 static size_t name_buf_len = 0;
204 GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
205 strncpy (name_buf, name, name_len);
206 strcpy (name_buf + name_len, suffix);
208 B = get_int_var_value (name_buf, &OK);
210 ada_print_scalar (type, B, stream);
212 fprintf_filtered (stream, "?");
215 /* Print RAW_TYPE as a range type, using any bound information
216 following the GNAT encoding (if available). */
219 print_range_type (struct type *raw_type, struct ui_file *stream)
222 struct type *base_type;
225 gdb_assert (raw_type != NULL);
226 name = TYPE_NAME (raw_type);
227 gdb_assert (name != NULL);
229 if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
230 base_type = TYPE_TARGET_TYPE (raw_type);
232 base_type = raw_type;
234 subtype_info = strstr (name, "___XD");
235 if (subtype_info == NULL)
236 print_range (raw_type, stream);
239 int prefix_len = subtype_info - name;
244 bounds_str = strchr (subtype_info, '_');
247 if (*subtype_info == 'L')
249 print_range_bound (base_type, bounds_str, &n, stream);
253 print_dynamic_range_bound (base_type, name, prefix_len, "___L",
256 fprintf_filtered (stream, " .. ");
258 if (*subtype_info == 'U')
259 print_range_bound (base_type, bounds_str, &n, stream);
261 print_dynamic_range_bound (base_type, name, prefix_len, "___U",
266 /* Print enumerated type TYPE on STREAM. */
269 print_enum_type (struct type *type, struct ui_file *stream)
271 int len = TYPE_NFIELDS (type);
274 fprintf_filtered (stream, "(");
278 for (i = 0; i < len; i++)
282 fprintf_filtered (stream, ", ");
284 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
285 if (lastval != TYPE_FIELD_BITPOS (type, i))
287 fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
288 lastval = TYPE_FIELD_BITPOS (type, i);
292 fprintf_filtered (stream, ")");
295 /* Print representation of Ada fixed-point type TYPE on STREAM. */
298 print_fixed_point_type (struct type *type, struct ui_file *stream)
300 DOUBLEST delta = ada_delta (type);
301 DOUBLEST small = ada_fixed_to_float (type, 1.0);
304 fprintf_filtered (stream, "delta ??");
307 fprintf_filtered (stream, "delta %g", (double) delta);
309 fprintf_filtered (stream, " <'small = %g>", (double) small);
313 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
314 recursion (indentation) level, in case the element type itself has
315 nested structure, and SHOW is the number of levels of internal
316 structure to show (see ada_print_type). */
319 print_array_type (struct type *type, struct ui_file *stream, int show,
325 if (ada_is_constrained_packed_array_type (type))
326 type = ada_coerce_to_simple_array_type (type);
329 fprintf_filtered (stream, "array (");
333 fprintf_filtered (stream, _("<undecipherable array type>"));
339 fprintf_filtered (stream, "...");
342 if (ada_is_simple_array_type (type))
344 struct type *range_desc_type;
345 struct type *arr_type;
347 range_desc_type = ada_find_parallel_type (type, "___XA");
348 ada_fixup_array_indexes_type (range_desc_type);
351 if (range_desc_type == NULL)
353 for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
354 arr_type = TYPE_TARGET_TYPE (arr_type))
356 if (arr_type != type)
357 fprintf_filtered (stream, ", ");
358 print_range (TYPE_INDEX_TYPE (arr_type), stream);
359 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
360 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
366 n_indices = TYPE_NFIELDS (range_desc_type);
367 for (k = 0, arr_type = type;
369 k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
372 fprintf_filtered (stream, ", ");
373 print_range_type (TYPE_FIELD_TYPE (range_desc_type, k),
375 if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
376 bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
383 for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
384 fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
388 fprintf_filtered (stream, ") of ");
390 ada_print_type (ada_array_element_type (type, n_indices), "", stream,
391 show == 0 ? 0 : show - 1, level + 1);
393 fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
396 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
397 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values. */
400 print_choices (struct type *type, int field_num, struct ui_file *stream,
401 struct type *val_type)
405 const char *name = TYPE_FIELD_NAME (type, field_num);
409 /* Skip over leading 'V': NOTE soon to be obsolete. */
412 if (!ada_scan_number (name, 1, NULL, &p))
428 fprintf_filtered (stream, " | ");
438 if (!ada_scan_number (name, p + 1, &W, &p))
440 ada_print_scalar (val_type, W, stream);
446 if (!ada_scan_number (name, p + 1, &L, &p)
447 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
449 ada_print_scalar (val_type, L, stream);
450 fprintf_filtered (stream, " .. ");
451 ada_print_scalar (val_type, U, stream);
455 fprintf_filtered (stream, "others");
462 fprintf_filtered (stream, "??");
466 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
467 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
468 LEVEL is the recursion
469 (indentation) level, in case any of the fields themselves have
470 nested structure, and SHOW is the number of levels of internal structure
471 to show (see ada_print_type). For this purpose, fields nested in a
472 variant part are taken to be at the same level as the fields
473 immediately outside the variant part. */
476 print_variant_clauses (struct type *type, int field_num,
477 struct type *outer_type, struct ui_file *stream,
481 struct type *var_type, *par_type;
482 struct type *discr_type;
484 var_type = TYPE_FIELD_TYPE (type, field_num);
485 discr_type = ada_variant_discrim_type (var_type, outer_type);
487 if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
489 var_type = TYPE_TARGET_TYPE (var_type);
490 if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
494 par_type = ada_find_parallel_type (var_type, "___XVU");
495 if (par_type != NULL)
498 for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
500 fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
501 print_choices (var_type, i, stream, discr_type);
502 fprintf_filtered (stream, " =>");
503 if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
504 outer_type, stream, show, level + 4) <= 0)
505 fprintf_filtered (stream, " null;");
509 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
510 discriminants are contained in OUTER_TYPE, print a description of it
511 on STREAM. LEVEL is the recursion (indentation) level, in case any of
512 the fields themselves have nested structure, and SHOW is the number of
513 levels of internal structure to show (see ada_print_type). For this
514 purpose, fields nested in a variant part are taken to be at the same
515 level as the fields immediately outside the variant part. */
518 print_variant_part (struct type *type, int field_num, struct type *outer_type,
519 struct ui_file *stream, int show, int level)
521 fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
522 ada_variant_discrim_name
523 (TYPE_FIELD_TYPE (type, field_num)));
524 print_variant_clauses (type, field_num, outer_type, stream, show,
526 fprintf_filtered (stream, "\n%*send case;", level + 4, "");
529 /* Print a description on STREAM of the fields in record type TYPE, whose
530 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
531 level, in case any of the fields themselves have nested structure,
532 and SHOW is the number of levels of internal structure to show
533 (see ada_print_type). Does not print parent type information of TYPE.
534 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
535 Prints each field beginning on a new line, but does not put a new line at
539 print_record_field_types (struct type *type, struct type *outer_type,
540 struct ui_file *stream, int show, int level)
545 len = TYPE_NFIELDS (type);
547 if (len == 0 && TYPE_STUB (type))
550 for (i = 0; i < len; i += 1)
554 if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
556 else if (ada_is_wrapper_field (type, i))
557 flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
558 stream, show, level);
559 else if (ada_is_variant_part (type, i))
561 print_variant_part (type, i, outer_type, stream, show, level);
567 fprintf_filtered (stream, "\n%*s", level + 4, "");
568 ada_print_type (TYPE_FIELD_TYPE (type, i),
569 TYPE_FIELD_NAME (type, i),
570 stream, show - 1, level + 4);
571 fprintf_filtered (stream, ";");
578 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
579 level, in case the element type itself has nested structure, and SHOW is
580 the number of levels of internal structure to show (see ada_print_type). */
583 print_record_type (struct type *type0, struct ui_file *stream, int show,
586 struct type *parent_type;
589 type = ada_find_parallel_type (type0, "___XVE");
593 parent_type = ada_parent_type (type);
594 if (ada_type_name (parent_type) != NULL)
595 fprintf_filtered (stream, "new %s with record",
596 decoded_type_name (parent_type));
597 else if (parent_type == NULL && ada_is_tagged_type (type, 0))
598 fprintf_filtered (stream, "tagged record");
600 fprintf_filtered (stream, "record");
603 fprintf_filtered (stream, " ... end record");
609 if (parent_type != NULL && ada_type_name (parent_type) == NULL)
610 flds += print_record_field_types (parent_type, parent_type,
611 stream, show, level);
612 flds += print_record_field_types (type, type, stream, show, level);
615 fprintf_filtered (stream, "\n%*send record", level, "");
617 fprintf_filtered (stream, _(" <incomplete type> end record"));
619 fprintf_filtered (stream, " null; end record");
623 /* Print the unchecked union type TYPE in something resembling Ada
624 format on STREAM. LEVEL is the recursion (indentation) level
625 in case the element type itself has nested structure, and SHOW is the
626 number of levels of internal structure to show (see ada_print_type). */
628 print_unchecked_union_type (struct type *type, struct ui_file *stream,
632 fprintf_filtered (stream, "record (?) is ... end record");
633 else if (TYPE_NFIELDS (type) == 0)
634 fprintf_filtered (stream, "record (?) is null; end record");
639 fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
641 for (i = 0; i < TYPE_NFIELDS (type); i += 1)
643 fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
645 ada_print_type (TYPE_FIELD_TYPE (type, i),
646 TYPE_FIELD_NAME (type, i),
647 stream, show - 1, level + 12);
648 fprintf_filtered (stream, ";");
651 fprintf_filtered (stream, "\n%*send case;\n%*send record",
652 level + 4, "", level, "");
658 /* Print function or procedure type TYPE on STREAM. Make it a header
659 for function or procedure NAME if NAME is not null. */
662 print_func_type (struct type *type, struct ui_file *stream, char *name)
664 int i, len = TYPE_NFIELDS (type);
666 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
667 fprintf_filtered (stream, "procedure");
669 fprintf_filtered (stream, "function");
671 if (name != NULL && name[0] != '\0')
672 fprintf_filtered (stream, " %s", name);
676 fprintf_filtered (stream, " (");
677 for (i = 0; i < len; i += 1)
681 fputs_filtered ("; ", stream);
684 fprintf_filtered (stream, "a%d: ", i + 1);
685 ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
687 fprintf_filtered (stream, ")");
690 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
692 fprintf_filtered (stream, " return ");
693 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
698 /* Print a description of a type TYPE0.
699 Output goes to STREAM (via stdio).
700 If VARSTRING is a non-empty string, print as an Ada variable/field
702 SHOW+1 is the maximum number of levels of internal type structure
703 to show (this applies to record types, enumerated types, and
705 SHOW is the number of levels of internal type structure to show
706 when there is a type name for the SHOWth deepest level (0th is
708 When SHOW<0, no inner structure is shown.
709 LEVEL indicates level of recursion (for nested definitions). */
712 ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
715 struct type *type = ada_check_typedef (ada_get_base_type (type0));
716 char *type_name = decoded_type_name (type0);
717 int is_var_decl = (varstring != NULL && varstring[0] != '\0');
722 fprintf_filtered (stream, "%.*s: ",
723 ada_name_prefix_len (varstring), varstring);
724 fprintf_filtered (stream, "<null type?>");
729 type = ada_check_typedef (type);
731 if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
732 fprintf_filtered (stream, "%.*s: ",
733 ada_name_prefix_len (varstring), varstring);
735 if (type_name != NULL && show <= 0)
737 fprintf_filtered (stream, "%.*s",
738 ada_name_prefix_len (type_name), type_name);
742 if (ada_is_aligner_type (type))
743 ada_print_type (ada_aligned_type (type), "", stream, show, level);
744 else if (ada_is_constrained_packed_array_type (type))
746 if (TYPE_CODE (type) == TYPE_CODE_PTR)
748 fprintf_filtered (stream, "access ");
749 print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
753 print_array_type (type, stream, show, level);
757 switch (TYPE_CODE (type))
760 fprintf_filtered (stream, "<");
761 c_print_type (type, "", stream, show, level);
762 fprintf_filtered (stream, ">");
765 fprintf_filtered (stream, "access ");
766 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
769 fprintf_filtered (stream, "<ref> ");
770 ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
772 case TYPE_CODE_ARRAY:
773 print_array_type (type, stream, show, level);
776 fprintf_filtered (stream, "(false, true)");
779 if (ada_is_fixed_point_type (type))
780 print_fixed_point_type (type, stream);
783 char *name = ada_type_name (type);
784 if (!ada_is_range_type_name (name))
785 fprintf_filtered (stream, _("<%d-byte integer>"),
789 fprintf_filtered (stream, "range ");
790 print_range_type (type, stream);
794 case TYPE_CODE_RANGE:
795 if (ada_is_fixed_point_type (type))
796 print_fixed_point_type (type, stream);
797 else if (ada_is_modular_type (type))
798 fprintf_filtered (stream, "mod %s",
799 int_string (ada_modulus (type), 10, 0, 0, 1));
802 fprintf_filtered (stream, "range ");
803 print_range (type, stream);
807 fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
811 fprintf_filtered (stream, "(...)");
813 print_enum_type (type, stream);
815 case TYPE_CODE_STRUCT:
816 if (ada_is_array_descriptor_type (type))
817 print_array_type (type, stream, show, level);
818 else if (ada_is_bogus_array_descriptor (type))
819 fprintf_filtered (stream,
820 _("array (?) of ? (<mal-formed descriptor>)"));
822 print_record_type (type, stream, show, level);
824 case TYPE_CODE_UNION:
825 print_unchecked_union_type (type, stream, show, level);
828 print_func_type (type, stream, varstring);
833 /* Implement the la_print_typedef language method for Ada. */
836 ada_print_typedef (struct type *type, struct symbol *new_symbol,
837 struct ui_file *stream)
839 type = ada_check_typedef (type);
840 ada_print_type (type, "", stream, 0, 0);
841 fprintf_filtered (stream, "\n");