1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2016 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description. */
24 #include "expression.h"
31 #include "typeprint.h"
34 #include "cp-support.h"
36 static void c_type_print_varspec_prefix (struct type *,
39 const struct type_print_options *);
41 /* Print "const", "volatile", or address space modifiers. */
42 static void c_type_print_modifier (struct type *,
47 /* A callback function for cp_canonicalize_string_full that uses
48 find_typedef_in_hash. */
51 find_typedef_for_canonicalize (struct type *t, void *data)
53 return find_typedef_in_hash ((const struct type_print_options *) data, t);
56 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
57 canonicalize NAME using the local typedefs first. */
60 print_name_maybe_canonical (const char *name,
61 const struct type_print_options *flags,
62 struct ui_file *stream)
67 s = cp_canonicalize_string_full (name,
68 find_typedef_for_canonicalize,
71 fputs_filtered (s ? s : name, stream);
77 /* LEVEL is the depth to indent lines by. */
80 c_print_type (struct type *type,
81 const char *varstring,
82 struct ui_file *stream,
84 const struct type_print_options *flags)
89 const char *local_name;
92 type = check_typedef (type);
94 local_name = find_typedef_in_hash (flags, type);
95 if (local_name != NULL)
97 fputs_filtered (local_name, stream);
98 if (varstring != NULL && *varstring != '\0')
99 fputs_filtered (" ", stream);
103 c_type_print_base (type, stream, show, level, flags);
104 code = TYPE_CODE (type);
105 if ((varstring != NULL && *varstring != '\0')
106 /* Need a space if going to print stars or brackets;
107 but not if we will print just a type name. */
108 || ((show > 0 || TYPE_NAME (type) == 0)
109 && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
110 || code == TYPE_CODE_METHOD
111 || (code == TYPE_CODE_ARRAY
112 && !TYPE_VECTOR (type))
113 || code == TYPE_CODE_MEMBERPTR
114 || code == TYPE_CODE_METHODPTR
115 || code == TYPE_CODE_REF)))
116 fputs_filtered (" ", stream);
117 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
118 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
122 if (varstring != NULL)
124 fputs_filtered (varstring, stream);
126 /* For demangled function names, we have the arglist as part of
127 the name, so don't print an additional pair of ()'s. */
128 if (local_name == NULL)
130 demangled_args = strchr (varstring, '(') != NULL;
131 c_type_print_varspec_suffix (type, stream, show,
138 /* Print a typedef using C syntax. TYPE is the underlying type.
139 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
143 c_print_typedef (struct type *type,
144 struct symbol *new_symbol,
145 struct ui_file *stream)
147 type = check_typedef (type);
148 fprintf_filtered (stream, "typedef ");
149 type_print (type, "", stream, 0);
150 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
151 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
152 SYMBOL_LINKAGE_NAME (new_symbol)) != 0
153 || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
154 fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
155 fprintf_filtered (stream, ";\n");
158 /* If TYPE is a derived type, then print out derivation information.
159 Print only the actual base classes of this type, not the base
160 classes of the base classes. I.e. for the derivation hierarchy:
163 class B : public A {int b; };
164 class C : public B {int c; };
166 Print the type of class C as:
172 Not as the following (like gdb used to), which is not legal C++
173 syntax for derived types and may be confused with the multiple
176 class C : public B : public A {
180 In general, gdb should try to print the types as closely as
181 possible to the form that they appear in the source code. */
184 cp_type_print_derivation_info (struct ui_file *stream,
186 const struct type_print_options *flags)
191 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
194 fputs_filtered (i == 0 ? ": " : ", ", stream);
195 fprintf_filtered (stream, "%s%s ",
196 BASETYPE_VIA_PUBLIC (type, i)
197 ? "public" : (TYPE_FIELD_PROTECTED (type, i)
198 ? "protected" : "private"),
199 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
200 name = type_name_no_tag (TYPE_BASECLASS (type, i));
202 print_name_maybe_canonical (name, flags, stream);
204 fprintf_filtered (stream, "(null)");
208 fputs_filtered (" ", stream);
212 /* Print the C++ method arguments ARGS to the file STREAM. */
215 cp_type_print_method_args (struct type *mtype, const char *prefix,
216 const char *varstring, int staticp,
217 struct ui_file *stream,
218 const struct type_print_options *flags)
220 struct field *args = TYPE_FIELDS (mtype);
221 int nargs = TYPE_NFIELDS (mtype);
222 int varargs = TYPE_VARARGS (mtype);
225 fprintf_symbol_filtered (stream, prefix,
226 language_cplus, DMGL_ANSI);
227 fprintf_symbol_filtered (stream, varstring,
228 language_cplus, DMGL_ANSI);
229 fputs_filtered ("(", stream);
231 /* Skip the class variable. */
237 c_print_type (args[i++].type, "", stream, 0, 0, flags);
239 if (i == nargs && varargs)
240 fprintf_filtered (stream, ", ...");
243 fprintf_filtered (stream, ", ");
249 fprintf_filtered (stream, "...");
250 else if (current_language->la_language == language_cplus)
251 fprintf_filtered (stream, "void");
253 fprintf_filtered (stream, ")");
255 /* For non-static methods, read qualifiers from the type of
261 gdb_assert (nargs > 0);
262 gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
263 domain = TYPE_TARGET_TYPE (args[0].type);
265 if (TYPE_CONST (domain))
266 fprintf_filtered (stream, " const");
268 if (TYPE_VOLATILE (domain))
269 fprintf_filtered (stream, " volatile");
271 if (TYPE_RESTRICT (domain))
272 fprintf_filtered (stream, " restrict");
274 if (TYPE_ATOMIC (domain))
275 fprintf_filtered (stream, " _Atomic");
280 /* Print any asterisks or open-parentheses needed before the
281 variable name (to describe its type).
283 On outermost call, pass 0 for PASSED_A_PTR.
284 On outermost call, SHOW > 0 means should ignore
285 any typename for TYPE and show its details.
286 SHOW is always zero on recursive calls.
288 NEED_POST_SPACE is non-zero when a space will be be needed
289 between a trailing qualifier and a field, variable, or function
293 c_type_print_varspec_prefix (struct type *type,
294 struct ui_file *stream,
295 int show, int passed_a_ptr,
297 const struct type_print_options *flags)
304 if (TYPE_NAME (type) && show <= 0)
309 switch (TYPE_CODE (type))
312 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
313 stream, show, 1, 1, flags);
314 fprintf_filtered (stream, "*");
315 c_type_print_modifier (type, stream, 1, need_post_space);
318 case TYPE_CODE_MEMBERPTR:
319 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
320 stream, show, 0, 0, flags);
321 name = type_name_no_tag (TYPE_SELF_TYPE (type));
323 print_name_maybe_canonical (name, flags, stream);
325 c_type_print_base (TYPE_SELF_TYPE (type),
326 stream, -1, passed_a_ptr, flags);
327 fprintf_filtered (stream, "::*");
330 case TYPE_CODE_METHODPTR:
331 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
332 stream, show, 0, 0, flags);
333 fprintf_filtered (stream, "(");
334 name = type_name_no_tag (TYPE_SELF_TYPE (type));
336 print_name_maybe_canonical (name, flags, stream);
338 c_type_print_base (TYPE_SELF_TYPE (type),
339 stream, -1, passed_a_ptr, flags);
340 fprintf_filtered (stream, "::*");
344 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
345 stream, show, 1, 0, flags);
346 fprintf_filtered (stream, "&");
347 c_type_print_modifier (type, stream, 1, need_post_space);
350 case TYPE_CODE_METHOD:
352 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
353 stream, show, 0, 0, flags);
355 fprintf_filtered (stream, "(");
358 case TYPE_CODE_ARRAY:
359 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
360 stream, show, 0, 0, flags);
362 fprintf_filtered (stream, "(");
365 case TYPE_CODE_TYPEDEF:
366 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
367 stream, show, passed_a_ptr, 0, flags);
370 case TYPE_CODE_UNDEF:
371 case TYPE_CODE_STRUCT:
372 case TYPE_CODE_UNION:
374 case TYPE_CODE_FLAGS:
378 case TYPE_CODE_ERROR:
382 case TYPE_CODE_RANGE:
383 case TYPE_CODE_STRING:
384 case TYPE_CODE_COMPLEX:
385 case TYPE_CODE_NAMESPACE:
386 case TYPE_CODE_DECFLOAT:
387 /* These types need no prefix. They are listed here so that
388 gcc -Wall will reveal any types that haven't been handled. */
391 error (_("type not handled in c_type_print_varspec_prefix()"));
396 /* Print out "const" and "volatile" attributes,
397 and address space id if present.
398 TYPE is a pointer to the type being printed out.
399 STREAM is the output destination.
400 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
401 NEED_POST_SPACE = 1 indicates a final white space is needed. */
404 c_type_print_modifier (struct type *type, struct ui_file *stream,
405 int need_pre_space, int need_post_space)
407 int did_print_modifier = 0;
408 const char *address_space_id;
410 /* We don't print `const' qualifiers for references --- since all
411 operators affect the thing referenced, not the reference itself,
412 every reference is `const'. */
413 if (TYPE_CONST (type)
414 && TYPE_CODE (type) != TYPE_CODE_REF)
417 fprintf_filtered (stream, " ");
418 fprintf_filtered (stream, "const");
419 did_print_modifier = 1;
422 if (TYPE_VOLATILE (type))
424 if (did_print_modifier || need_pre_space)
425 fprintf_filtered (stream, " ");
426 fprintf_filtered (stream, "volatile");
427 did_print_modifier = 1;
430 if (TYPE_RESTRICT (type))
432 if (did_print_modifier || need_pre_space)
433 fprintf_filtered (stream, " ");
434 fprintf_filtered (stream, "restrict");
435 did_print_modifier = 1;
438 if (TYPE_ATOMIC (type))
440 if (did_print_modifier || need_pre_space)
441 fprintf_filtered (stream, " ");
442 fprintf_filtered (stream, "_Atomic");
443 did_print_modifier = 1;
446 address_space_id = address_space_int_to_name (get_type_arch (type),
447 TYPE_INSTANCE_FLAGS (type));
448 if (address_space_id)
450 if (did_print_modifier || need_pre_space)
451 fprintf_filtered (stream, " ");
452 fprintf_filtered (stream, "@%s", address_space_id);
453 did_print_modifier = 1;
456 if (did_print_modifier && need_post_space)
457 fprintf_filtered (stream, " ");
461 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
462 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
463 in non-static methods, are displayed if LINKAGE_NAME is zero. If
464 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
465 parameter types get removed their possible const and volatile qualifiers to
466 match demangled linkage name parameters part of such function type.
467 LANGUAGE is the language in which TYPE was defined. This is a necessary
468 evil since this code is used by the C, C++, and Java backends. */
471 c_type_print_args (struct type *type, struct ui_file *stream,
472 int linkage_name, enum language language,
473 const struct type_print_options *flags)
478 fprintf_filtered (stream, "(");
480 for (i = 0; i < TYPE_NFIELDS (type); i++)
482 struct type *param_type;
484 if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
489 fprintf_filtered (stream, ", ");
493 param_type = TYPE_FIELD_TYPE (type, i);
495 if (language == language_cplus && linkage_name)
497 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
498 - Parameter declarations that differ only in the presence or
499 absence of const and/or volatile are equivalent.
501 And the const/volatile qualifiers are not present in the mangled
502 names as produced by GCC. */
504 param_type = make_cv_type (0, 0, param_type, NULL);
507 if (language == language_java)
508 java_print_type (param_type, "", stream, -1, 0, flags);
510 c_print_type (param_type, "", stream, -1, 0, flags);
514 if (printed_any && TYPE_VARARGS (type))
516 /* Print out a trailing ellipsis for varargs functions. Ignore
517 TYPE_VARARGS if the function has no named arguments; that
518 represents unprototyped (K&R style) C functions. */
519 if (printed_any && TYPE_VARARGS (type))
521 fprintf_filtered (stream, ", ");
523 fprintf_filtered (stream, "...");
526 else if (!printed_any
527 && ((TYPE_PROTOTYPED (type) && language != language_java)
528 || language == language_cplus))
529 fprintf_filtered (stream, "void");
531 fprintf_filtered (stream, ")");
534 /* Return true iff the j'th overloading of the i'th method of TYPE
535 is a type conversion operator, like `operator int () { ... }'.
536 When listing a class's methods, we don't print the return type of
540 is_type_conversion_operator (struct type *type, int i, int j)
542 /* I think the whole idea of recognizing type conversion operators
543 by their name is pretty terrible. But I don't think our present
544 data structure gives us any other way to tell. If you know of
545 some other way, feel free to rewrite this function. */
546 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
548 if (!startswith (name, "operator"))
552 if (! strchr (" \t\f\n\r", *name))
555 while (strchr (" \t\f\n\r", *name))
558 if (!('a' <= *name && *name <= 'z')
559 && !('A' <= *name && *name <= 'Z')
561 /* If this doesn't look like the start of an identifier, then it
562 isn't a type conversion operator. */
564 else if (startswith (name, "new"))
566 else if (startswith (name, "delete"))
569 /* If it doesn't look like new or delete, it's a type conversion
573 /* Is that really the end of the name? */
574 if (('a' <= *name && *name <= 'z')
575 || ('A' <= *name && *name <= 'Z')
576 || ('0' <= *name && *name <= '9')
578 /* No, so the identifier following "operator" must be a type name,
579 and this is a type conversion operator. */
582 /* That was indeed the end of the name, so it was `operator new' or
583 `operator delete', neither of which are type conversion
588 /* Given a C++ qualified identifier QID, strip off the qualifiers,
589 yielding the unqualified name. The return value is a pointer into
592 It's a pity we don't have this information in some more structured
593 form. Even the author of this function feels that writing little
594 parsers like this everywhere is stupid. */
597 remove_qualifiers (char *qid)
599 int quoted = 0; /* Zero if we're not in quotes;
600 '"' if we're in a double-quoted string;
601 '\'' if we're in a single-quoted string. */
602 int depth = 0; /* Number of unclosed parens we've seen. */
603 char *parenstack = (char *) alloca (strlen (qid));
605 char *last = 0; /* The character after the rightmost
606 `::' token we've seen so far. */
608 for (scan = qid; *scan; scan++)
614 else if (*scan == '\\' && *(scan + 1))
617 else if (scan[0] == ':' && scan[1] == ':')
619 /* If we're inside parenthesis (i.e., an argument list) or
620 angle brackets (i.e., a list of template arguments), then
621 we don't record the position of this :: token, since it's
622 not relevant to the top-level structure we're trying to
630 else if (*scan == '"' || *scan == '\'')
632 else if (*scan == '(')
633 parenstack[depth++] = ')';
634 else if (*scan == '[')
635 parenstack[depth++] = ']';
636 /* We're going to treat <> as a pair of matching characters,
637 since we're more likely to see those in template id's than
638 real less-than characters. What a crock. */
639 else if (*scan == '<')
640 parenstack[depth++] = '>';
641 else if (*scan == ')' || *scan == ']' || *scan == '>')
643 if (depth > 0 && parenstack[depth - 1] == *scan)
647 /* We're going to do a little error recovery here. If
648 we don't find a match for *scan on the paren stack,
649 but there is something lower on the stack that does
650 match, we pop the stack to that point. */
653 for (i = depth - 1; i >= 0; i--)
654 if (parenstack[i] == *scan)
666 /* We didn't find any :: tokens at the top level, so declare the
667 whole thing an unqualified identifier. */
671 /* Print any array sizes, function arguments or close parentheses
672 needed after the variable name (to describe its type).
673 Args work like c_type_print_varspec_prefix. */
676 c_type_print_varspec_suffix (struct type *type,
677 struct ui_file *stream,
678 int show, int passed_a_ptr,
680 const struct type_print_options *flags)
685 if (TYPE_NAME (type) && show <= 0)
690 switch (TYPE_CODE (type))
692 case TYPE_CODE_ARRAY:
694 LONGEST low_bound, high_bound;
695 int is_vector = TYPE_VECTOR (type);
698 fprintf_filtered (stream, ")");
700 fprintf_filtered (stream, (is_vector ?
701 " __attribute__ ((vector_size(" : "["));
702 /* Bounds are not yet resolved, print a bounds placeholder instead. */
703 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
704 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
705 fprintf_filtered (stream, "variable length");
706 else if (get_array_bounds (type, &low_bound, &high_bound))
707 fprintf_filtered (stream, "%s",
708 plongest (high_bound - low_bound + 1));
709 fprintf_filtered (stream, (is_vector ? ")))" : "]"));
711 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
716 case TYPE_CODE_MEMBERPTR:
717 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
721 case TYPE_CODE_METHODPTR:
722 fprintf_filtered (stream, ")");
723 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
729 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
733 case TYPE_CODE_METHOD:
736 fprintf_filtered (stream, ")");
738 c_type_print_args (type, stream, 0, current_language->la_language,
740 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
741 show, passed_a_ptr, 0, flags);
744 case TYPE_CODE_TYPEDEF:
745 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
746 show, passed_a_ptr, 0, flags);
749 case TYPE_CODE_UNDEF:
750 case TYPE_CODE_STRUCT:
751 case TYPE_CODE_UNION:
752 case TYPE_CODE_FLAGS:
757 case TYPE_CODE_ERROR:
761 case TYPE_CODE_RANGE:
762 case TYPE_CODE_STRING:
763 case TYPE_CODE_COMPLEX:
764 case TYPE_CODE_NAMESPACE:
765 case TYPE_CODE_DECFLOAT:
766 /* These types do not need a suffix. They are listed so that
767 gcc -Wall will report types that may not have been
771 error (_("type not handled in c_type_print_varspec_suffix()"));
776 /* A helper for c_type_print_base that displays template
777 parameters and their bindings, if needed.
779 TABLE is the local bindings table to use. If NULL, no printing is
780 done. Note that, at this point, TABLE won't have any useful
781 information in it -- but it is also used as a flag to
782 print_name_maybe_canonical to activate searching the global typedef
785 TYPE is the type whose template arguments are being displayed.
787 STREAM is the stream on which to print. */
790 c_type_print_template_args (const struct type_print_options *flags,
791 struct type *type, struct ui_file *stream)
798 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
800 struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
802 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
808 fprintf_filtered (stream, _("[with %s = "),
809 SYMBOL_LINKAGE_NAME (sym));
814 fputs_filtered (", ", stream);
816 fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
819 c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
823 fputs_filtered (_("] "), stream);
826 /* Print the name of the type (or the ultimate pointer target,
827 function value or array element), or the description of a structure
830 SHOW positive means print details about the type (e.g. enum
831 values), and print structure elements passing SHOW - 1 for show.
833 SHOW negative means just print the type name or struct tag if there
834 is one. If there is no name, print something sensible but concise
837 SHOW zero means just print the type name or struct tag if there is
838 one. If there is no name, print something sensible but not as
839 concise like "struct {int x; int y;}".
841 LEVEL is the number of spaces to indent by.
842 We increase it for some recursive calls. */
845 c_type_print_base (struct type *type, struct ui_file *stream,
846 int show, int level, const struct type_print_options *flags)
852 s_none, s_public, s_private, s_protected
855 int need_access_label = 0;
862 fputs_filtered (_("<type unknown>"), stream);
866 /* When SHOW is zero or less, and there is a valid type name, then
867 always just print the type name directly from the type. */
868 /* If we have "typedef struct foo {. . .} bar;" do we want to print
869 it as "struct foo" or as "bar"? Pick the latter, because C++
870 folk tend to expect things like "class5 *foo" rather than "struct
874 && TYPE_NAME (type) != NULL)
876 c_type_print_modifier (type, stream, 0, 1);
877 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
881 type = check_typedef (type);
883 switch (TYPE_CODE (type))
885 case TYPE_CODE_TYPEDEF:
886 /* If we get here, the typedef doesn't have a name, and we
887 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
888 gdb_assert (TYPE_NAME (type) == NULL);
889 gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
890 fprintf_filtered (stream, _("<unnamed typedef>"));
893 case TYPE_CODE_ARRAY:
895 case TYPE_CODE_MEMBERPTR:
898 case TYPE_CODE_METHOD:
899 case TYPE_CODE_METHODPTR:
900 c_type_print_base (TYPE_TARGET_TYPE (type),
901 stream, show, level, flags);
904 case TYPE_CODE_STRUCT:
905 case TYPE_CODE_UNION:
907 struct type_print_options local_flags = *flags;
908 struct type_print_options semi_local_flags = *flags;
909 struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
911 local_flags.local_typedefs = NULL;
912 semi_local_flags.local_typedefs = NULL;
916 if (flags->local_typedefs)
917 local_flags.local_typedefs
918 = copy_typedef_hash (flags->local_typedefs);
920 local_flags.local_typedefs = create_typedef_hash ();
922 make_cleanup_free_typedef_hash (local_flags.local_typedefs);
925 c_type_print_modifier (type, stream, 0, 1);
926 if (TYPE_CODE (type) == TYPE_CODE_UNION)
927 fprintf_filtered (stream, "union ");
928 else if (TYPE_DECLARED_CLASS (type))
929 fprintf_filtered (stream, "class ");
931 fprintf_filtered (stream, "struct ");
933 /* Print the tag if it exists. The HP aCC compiler emits a
934 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
935 enum}" tag for unnamed struct/union/enum's, which we don't
937 if (TYPE_TAG_NAME (type) != NULL
938 && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
940 /* When printing the tag name, we are still effectively
941 printing in the outer context, hence the use of FLAGS
943 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
945 fputs_filtered (" ", stream);
950 /* If we just printed a tag name, no need to print anything
952 if (TYPE_TAG_NAME (type) == NULL)
953 fprintf_filtered (stream, "{...}");
955 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
957 struct type *basetype;
960 c_type_print_template_args (&local_flags, type, stream);
962 /* Add in template parameters when printing derivation info. */
963 add_template_parameters (local_flags.local_typedefs, type);
964 cp_type_print_derivation_info (stream, type, &local_flags);
966 /* This holds just the global typedefs and the template
968 semi_local_flags.local_typedefs
969 = copy_typedef_hash (local_flags.local_typedefs);
970 if (semi_local_flags.local_typedefs)
971 make_cleanup_free_typedef_hash (semi_local_flags.local_typedefs);
973 /* Now add in the local typedefs. */
974 recursively_update_typedef_hash (local_flags.local_typedefs, type);
976 fprintf_filtered (stream, "{\n");
977 if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
978 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
980 if (TYPE_STUB (type))
981 fprintfi_filtered (level + 4, stream,
982 _("<incomplete type>\n"));
984 fprintfi_filtered (level + 4, stream,
985 _("<no data fields>\n"));
988 /* Start off with no specific section type, so we can print
989 one for the first field we find, and use that section type
990 thereafter until we find another type. */
992 section_type = s_none;
994 /* For a class, if all members are private, there's no need
995 for a "private:" label; similarly, for a struct or union
996 masquerading as a class, if all members are public, there's
997 no need for a "public:" label. */
999 if (TYPE_DECLARED_CLASS (type))
1002 len = TYPE_NFIELDS (type);
1003 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1004 if (!TYPE_FIELD_PRIVATE (type, i))
1006 need_access_label = 1;
1010 if (!need_access_label)
1012 len2 = TYPE_NFN_FIELDS (type);
1013 for (j = 0; j < len2; j++)
1015 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1016 for (i = 0; i < len; i++)
1017 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1020 need_access_label = 1;
1023 if (need_access_label)
1031 len = TYPE_NFIELDS (type);
1032 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1033 if (TYPE_FIELD_PRIVATE (type, i)
1034 || TYPE_FIELD_PROTECTED (type, i))
1036 need_access_label = 1;
1040 if (!need_access_label)
1042 len2 = TYPE_NFN_FIELDS (type);
1043 for (j = 0; j < len2; j++)
1046 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1047 for (i = 0; i < len; i++)
1048 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1050 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1054 need_access_label = 1;
1057 if (need_access_label)
1063 /* If there is a base class for this type,
1064 do not print the field that it occupies. */
1066 len = TYPE_NFIELDS (type);
1067 vptr_fieldno = get_vptr_fieldno (type, &basetype);
1068 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1072 /* If we have a virtual table pointer, omit it. Even if
1073 virtual table pointers are not specifically marked in
1074 the debug info, they should be artificial. */
1075 if ((i == vptr_fieldno && type == basetype)
1076 || TYPE_FIELD_ARTIFICIAL (type, i))
1079 if (need_access_label)
1081 if (TYPE_FIELD_PROTECTED (type, i))
1083 if (section_type != s_protected)
1085 section_type = s_protected;
1086 fprintfi_filtered (level + 2, stream,
1090 else if (TYPE_FIELD_PRIVATE (type, i))
1092 if (section_type != s_private)
1094 section_type = s_private;
1095 fprintfi_filtered (level + 2, stream,
1101 if (section_type != s_public)
1103 section_type = s_public;
1104 fprintfi_filtered (level + 2, stream,
1110 print_spaces_filtered (level + 4, stream);
1111 if (field_is_static (&TYPE_FIELD (type, i)))
1112 fprintf_filtered (stream, "static ");
1113 c_print_type (TYPE_FIELD_TYPE (type, i),
1114 TYPE_FIELD_NAME (type, i),
1115 stream, show - 1, level + 4,
1117 if (!field_is_static (&TYPE_FIELD (type, i))
1118 && TYPE_FIELD_PACKED (type, i))
1120 /* It is a bitfield. This code does not attempt
1121 to look at the bitpos and reconstruct filler,
1122 unnamed fields. This would lead to misleading
1123 results if the compiler does not put out fields
1124 for such things (I don't know what it does). */
1125 fprintf_filtered (stream, " : %d",
1126 TYPE_FIELD_BITSIZE (type, i));
1128 fprintf_filtered (stream, ";\n");
1131 /* If there are both fields and methods, put a blank line
1132 between them. Make sure to count only method that we
1133 will display; artificial methods will be hidden. */
1134 len = TYPE_NFN_FIELDS (type);
1135 if (!flags->print_methods)
1138 for (i = 0; i < len; i++)
1140 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1141 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1144 for (j = 0; j < len2; j++)
1145 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1148 if (real_len > 0 && section_type != s_none)
1149 fprintf_filtered (stream, "\n");
1151 /* C++: print out the methods. */
1152 for (i = 0; i < len; i++)
1154 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1155 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1156 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1157 const char *name = type_name_no_tag (type);
1158 int is_constructor = name && strcmp (method_name,
1161 for (j = 0; j < len2; j++)
1163 const char *mangled_name;
1164 char *demangled_name;
1165 struct cleanup *inner_cleanup;
1166 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1167 int is_full_physname_constructor =
1168 TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1169 || is_constructor_name (physname)
1170 || is_destructor_name (physname)
1171 || method_name[0] == '~';
1173 /* Do not print out artificial methods. */
1174 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1177 inner_cleanup = make_cleanup (null_cleanup, NULL);
1180 if (TYPE_FN_FIELD_PROTECTED (f, j))
1182 if (section_type != s_protected)
1184 section_type = s_protected;
1185 fprintfi_filtered (level + 2, stream,
1189 else if (TYPE_FN_FIELD_PRIVATE (f, j))
1191 if (section_type != s_private)
1193 section_type = s_private;
1194 fprintfi_filtered (level + 2, stream,
1200 if (section_type != s_public)
1202 section_type = s_public;
1203 fprintfi_filtered (level + 2, stream,
1208 print_spaces_filtered (level + 4, stream);
1209 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1210 fprintf_filtered (stream, "virtual ");
1211 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1212 fprintf_filtered (stream, "static ");
1213 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1215 /* Keep GDB from crashing here. */
1216 fprintf_filtered (stream,
1217 _("<undefined type> %s;\n"),
1218 TYPE_FN_FIELD_PHYSNAME (f, j));
1221 else if (!is_constructor /* Constructors don't
1224 && !is_full_physname_constructor /* " " */
1225 && !is_type_conversion_operator (type, i, j))
1227 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1230 fputs_filtered (" ", stream);
1232 if (TYPE_FN_FIELD_STUB (f, j))
1236 /* Build something we can demangle. */
1237 tem = gdb_mangle_name (type, i, j);
1238 make_cleanup (xfree, tem);
1242 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1245 gdb_demangle (mangled_name,
1246 DMGL_ANSI | DMGL_PARAMS);
1247 if (demangled_name == NULL)
1249 /* In some cases (for instance with the HP
1250 demangling), if a function has more than 10
1251 arguments, the demangling will fail.
1252 Let's try to reconstruct the function
1253 signature from the symbol information. */
1254 if (!TYPE_FN_FIELD_STUB (f, j))
1256 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1257 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1259 cp_type_print_method_args (mtype,
1263 stream, &local_flags);
1266 fprintf_filtered (stream,
1267 _("<badly mangled name '%s'>"),
1273 char *demangled_no_class
1274 = remove_qualifiers (demangled_name);
1276 /* Get rid of the `static' appended by the
1278 p = strstr (demangled_no_class, " static");
1281 int length = p - demangled_no_class;
1282 char *demangled_no_static;
1285 = (char *) xmalloc (length + 1);
1286 strncpy (demangled_no_static,
1287 demangled_no_class, length);
1288 *(demangled_no_static + length) = '\0';
1289 fputs_filtered (demangled_no_static, stream);
1290 xfree (demangled_no_static);
1293 fputs_filtered (demangled_no_class, stream);
1294 xfree (demangled_name);
1297 do_cleanups (inner_cleanup);
1299 fprintf_filtered (stream, ";\n");
1303 /* Print typedefs defined in this class. */
1305 if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1307 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1308 fprintf_filtered (stream, "\n");
1310 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1312 struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1314 /* Dereference the typedef declaration itself. */
1315 gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1316 target = TYPE_TARGET_TYPE (target);
1318 print_spaces_filtered (level + 4, stream);
1319 fprintf_filtered (stream, "typedef ");
1321 /* We want to print typedefs with substitutions
1322 from the template parameters or globally-known
1323 typedefs but not local typedefs. */
1324 c_print_type (target,
1325 TYPE_TYPEDEF_FIELD_NAME (type, i),
1326 stream, show - 1, level + 4,
1328 fprintf_filtered (stream, ";\n");
1332 fprintfi_filtered (level, stream, "}");
1335 do_cleanups (local_cleanups);
1339 case TYPE_CODE_ENUM:
1340 c_type_print_modifier (type, stream, 0, 1);
1341 fprintf_filtered (stream, "enum ");
1342 if (TYPE_DECLARED_CLASS (type))
1343 fprintf_filtered (stream, "class ");
1344 /* Print the tag name if it exists.
1345 The aCC compiler emits a spurious
1346 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1347 tag for unnamed struct/union/enum's, which we don't
1349 if (TYPE_TAG_NAME (type) != NULL
1350 && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
1352 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1354 fputs_filtered (" ", stream);
1360 /* If we just printed a tag name, no need to print anything
1362 if (TYPE_TAG_NAME (type) == NULL)
1363 fprintf_filtered (stream, "{...}");
1365 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1367 LONGEST lastval = 0;
1369 /* We can't handle this case perfectly, as DWARF does not
1370 tell us whether or not the underlying type was specified
1371 in the source (and other debug formats don't provide this
1372 at all). We choose to print the underlying type, if it
1373 has a name, when in C++ on the theory that it's better to
1374 print too much than too little; but conversely not to
1375 print something egregiously outside the current
1376 language's syntax. */
1377 if (current_language->la_language == language_cplus
1378 && TYPE_TARGET_TYPE (type) != NULL)
1380 struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
1382 if (TYPE_NAME (underlying) != NULL)
1383 fprintf_filtered (stream, ": %s ", TYPE_NAME (underlying));
1386 fprintf_filtered (stream, "{");
1387 len = TYPE_NFIELDS (type);
1388 for (i = 0; i < len; i++)
1392 fprintf_filtered (stream, ", ");
1394 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1395 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1397 fprintf_filtered (stream, " = %s",
1398 plongest (TYPE_FIELD_ENUMVAL (type, i)));
1399 lastval = TYPE_FIELD_ENUMVAL (type, i);
1403 fprintf_filtered (stream, "}");
1407 case TYPE_CODE_FLAGS:
1409 struct type_print_options local_flags = *flags;
1411 local_flags.local_typedefs = NULL;
1413 c_type_print_modifier (type, stream, 0, 1);
1414 fprintf_filtered (stream, "flag ");
1415 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1418 fputs_filtered (" ", stream);
1419 fprintf_filtered (stream, "{\n");
1420 if (TYPE_NFIELDS (type) == 0)
1422 if (TYPE_STUB (type))
1423 fprintfi_filtered (level + 4, stream,
1424 _("<incomplete type>\n"));
1426 fprintfi_filtered (level + 4, stream,
1427 _("<no data fields>\n"));
1429 len = TYPE_NFIELDS (type);
1430 for (i = 0; i < len; i++)
1433 print_spaces_filtered (level + 4, stream);
1434 /* We pass "show" here and not "show - 1" to get enum types
1435 printed. There's no other way to see them. */
1436 c_print_type (TYPE_FIELD_TYPE (type, i),
1437 TYPE_FIELD_NAME (type, i),
1438 stream, show, level + 4,
1440 fprintf_filtered (stream, " @%s",
1441 plongest (TYPE_FIELD_BITPOS (type, i)));
1442 if (TYPE_FIELD_BITSIZE (type, i) > 1)
1444 fprintf_filtered (stream, "-%s",
1445 plongest (TYPE_FIELD_BITPOS (type, i)
1446 + TYPE_FIELD_BITSIZE (type, i)
1449 fprintf_filtered (stream, ";\n");
1451 fprintfi_filtered (level, stream, "}");
1456 case TYPE_CODE_VOID:
1457 fprintf_filtered (stream, "void");
1460 case TYPE_CODE_UNDEF:
1461 fprintf_filtered (stream, _("struct <unknown>"));
1464 case TYPE_CODE_ERROR:
1465 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1468 case TYPE_CODE_RANGE:
1469 /* This should not occur. */
1470 fprintf_filtered (stream, _("<range type>"));
1473 case TYPE_CODE_NAMESPACE:
1474 fputs_filtered ("namespace ", stream);
1475 fputs_filtered (TYPE_TAG_NAME (type), stream);
1479 /* Handle types not explicitly handled by the other cases, such
1480 as fundamental types. For these, just print whatever the
1481 type name is, as recorded in the type itself. If there is no
1482 type name, then complain. */
1483 if (TYPE_NAME (type) != NULL)
1485 c_type_print_modifier (type, stream, 0, 1);
1486 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1490 /* At least for dump_symtab, it is important that this not
1492 fprintf_filtered (stream, _("<invalid type code %d>"),