1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2014 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 (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;
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 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");
277 /* Print any asterisks or open-parentheses needed before the
278 variable name (to describe its type).
280 On outermost call, pass 0 for PASSED_A_PTR.
281 On outermost call, SHOW > 0 means should ignore
282 any typename for TYPE and show its details.
283 SHOW is always zero on recursive calls.
285 NEED_POST_SPACE is non-zero when a space will be be needed
286 between a trailing qualifier and a field, variable, or function
290 c_type_print_varspec_prefix (struct type *type,
291 struct ui_file *stream,
292 int show, int passed_a_ptr,
294 const struct type_print_options *flags)
301 if (TYPE_NAME (type) && show <= 0)
306 switch (TYPE_CODE (type))
309 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
310 stream, show, 1, 1, flags);
311 fprintf_filtered (stream, "*");
312 c_type_print_modifier (type, stream, 1, need_post_space);
315 case TYPE_CODE_MEMBERPTR:
316 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
317 stream, show, 0, 0, flags);
318 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
320 print_name_maybe_canonical (name, flags, stream);
322 c_type_print_base (TYPE_DOMAIN_TYPE (type),
323 stream, -1, passed_a_ptr, flags);
324 fprintf_filtered (stream, "::*");
327 case TYPE_CODE_METHODPTR:
328 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
329 stream, show, 0, 0, flags);
330 fprintf_filtered (stream, "(");
331 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
333 print_name_maybe_canonical (name, flags, stream);
335 c_type_print_base (TYPE_DOMAIN_TYPE (type),
336 stream, -1, passed_a_ptr, flags);
337 fprintf_filtered (stream, "::*");
341 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
342 stream, show, 1, 0, flags);
343 fprintf_filtered (stream, "&");
344 c_type_print_modifier (type, stream, 1, need_post_space);
347 case TYPE_CODE_METHOD:
349 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
350 stream, show, 0, 0, flags);
352 fprintf_filtered (stream, "(");
355 case TYPE_CODE_ARRAY:
356 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
357 stream, show, 0, 0, flags);
359 fprintf_filtered (stream, "(");
362 case TYPE_CODE_TYPEDEF:
363 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
364 stream, show, passed_a_ptr, 0, flags);
367 case TYPE_CODE_UNDEF:
368 case TYPE_CODE_STRUCT:
369 case TYPE_CODE_UNION:
374 case TYPE_CODE_ERROR:
378 case TYPE_CODE_RANGE:
379 case TYPE_CODE_STRING:
380 case TYPE_CODE_COMPLEX:
381 case TYPE_CODE_NAMESPACE:
382 case TYPE_CODE_DECFLOAT:
383 /* These types need no prefix. They are listed here so that
384 gcc -Wall will reveal any types that haven't been handled. */
387 error (_("type not handled in c_type_print_varspec_prefix()"));
392 /* Print out "const" and "volatile" attributes,
393 and address space id if present.
394 TYPE is a pointer to the type being printed out.
395 STREAM is the output destination.
396 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
397 NEED_POST_SPACE = 1 indicates a final white space is needed. */
400 c_type_print_modifier (struct type *type, struct ui_file *stream,
401 int need_pre_space, int need_post_space)
403 int did_print_modifier = 0;
404 const char *address_space_id;
406 /* We don't print `const' qualifiers for references --- since all
407 operators affect the thing referenced, not the reference itself,
408 every reference is `const'. */
409 if (TYPE_CONST (type)
410 && TYPE_CODE (type) != TYPE_CODE_REF)
413 fprintf_filtered (stream, " ");
414 fprintf_filtered (stream, "const");
415 did_print_modifier = 1;
418 if (TYPE_VOLATILE (type))
420 if (did_print_modifier || need_pre_space)
421 fprintf_filtered (stream, " ");
422 fprintf_filtered (stream, "volatile");
423 did_print_modifier = 1;
426 if (TYPE_RESTRICT (type))
428 if (did_print_modifier || need_pre_space)
429 fprintf_filtered (stream, " ");
430 fprintf_filtered (stream, "restrict");
431 did_print_modifier = 1;
434 address_space_id = address_space_int_to_name (get_type_arch (type),
435 TYPE_INSTANCE_FLAGS (type));
436 if (address_space_id)
438 if (did_print_modifier || need_pre_space)
439 fprintf_filtered (stream, " ");
440 fprintf_filtered (stream, "@%s", address_space_id);
441 did_print_modifier = 1;
444 if (did_print_modifier && need_post_space)
445 fprintf_filtered (stream, " ");
449 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
450 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
451 in non-static methods, are displayed if LINKAGE_NAME is zero. If
452 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
453 parameter types get removed their possible const and volatile qualifiers to
454 match demangled linkage name parameters part of such function type.
455 LANGUAGE is the language in which TYPE was defined. This is a necessary
456 evil since this code is used by the C, C++, and Java backends. */
459 c_type_print_args (struct type *type, struct ui_file *stream,
460 int linkage_name, enum language language,
461 const struct type_print_options *flags)
466 fprintf_filtered (stream, "(");
468 for (i = 0; i < TYPE_NFIELDS (type); i++)
470 struct type *param_type;
472 if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
477 fprintf_filtered (stream, ", ");
481 param_type = TYPE_FIELD_TYPE (type, i);
483 if (language == language_cplus && linkage_name)
485 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
486 - Parameter declarations that differ only in the presence or
487 absence of const and/or volatile are equivalent.
489 And the const/volatile qualifiers are not present in the mangled
490 names as produced by GCC. */
492 param_type = make_cv_type (0, 0, param_type, NULL);
495 if (language == language_java)
496 java_print_type (param_type, "", stream, -1, 0, flags);
498 c_print_type (param_type, "", stream, -1, 0, flags);
502 if (printed_any && TYPE_VARARGS (type))
504 /* Print out a trailing ellipsis for varargs functions. Ignore
505 TYPE_VARARGS if the function has no named arguments; that
506 represents unprototyped (K&R style) C functions. */
507 if (printed_any && TYPE_VARARGS (type))
509 fprintf_filtered (stream, ", ");
511 fprintf_filtered (stream, "...");
514 else if (!printed_any
515 && ((TYPE_PROTOTYPED (type) && language != language_java)
516 || language == language_cplus))
517 fprintf_filtered (stream, "void");
519 fprintf_filtered (stream, ")");
522 /* Return true iff the j'th overloading of the i'th method of TYPE
523 is a type conversion operator, like `operator int () { ... }'.
524 When listing a class's methods, we don't print the return type of
528 is_type_conversion_operator (struct type *type, int i, int j)
530 /* I think the whole idea of recognizing type conversion operators
531 by their name is pretty terrible. But I don't think our present
532 data structure gives us any other way to tell. If you know of
533 some other way, feel free to rewrite this function. */
534 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
536 if (strncmp (name, "operator", 8) != 0)
540 if (! strchr (" \t\f\n\r", *name))
543 while (strchr (" \t\f\n\r", *name))
546 if (!('a' <= *name && *name <= 'z')
547 && !('A' <= *name && *name <= 'Z')
549 /* If this doesn't look like the start of an identifier, then it
550 isn't a type conversion operator. */
552 else if (strncmp (name, "new", 3) == 0)
554 else if (strncmp (name, "delete", 6) == 0)
557 /* If it doesn't look like new or delete, it's a type conversion
561 /* Is that really the end of the name? */
562 if (('a' <= *name && *name <= 'z')
563 || ('A' <= *name && *name <= 'Z')
564 || ('0' <= *name && *name <= '9')
566 /* No, so the identifier following "operator" must be a type name,
567 and this is a type conversion operator. */
570 /* That was indeed the end of the name, so it was `operator new' or
571 `operator delete', neither of which are type conversion
576 /* Given a C++ qualified identifier QID, strip off the qualifiers,
577 yielding the unqualified name. The return value is a pointer into
580 It's a pity we don't have this information in some more structured
581 form. Even the author of this function feels that writing little
582 parsers like this everywhere is stupid. */
585 remove_qualifiers (char *qid)
587 int quoted = 0; /* Zero if we're not in quotes;
588 '"' if we're in a double-quoted string;
589 '\'' if we're in a single-quoted string. */
590 int depth = 0; /* Number of unclosed parens we've seen. */
591 char *parenstack = (char *) alloca (strlen (qid));
593 char *last = 0; /* The character after the rightmost
594 `::' token we've seen so far. */
596 for (scan = qid; *scan; scan++)
602 else if (*scan == '\\' && *(scan + 1))
605 else if (scan[0] == ':' && scan[1] == ':')
607 /* If we're inside parenthesis (i.e., an argument list) or
608 angle brackets (i.e., a list of template arguments), then
609 we don't record the position of this :: token, since it's
610 not relevant to the top-level structure we're trying to
618 else if (*scan == '"' || *scan == '\'')
620 else if (*scan == '(')
621 parenstack[depth++] = ')';
622 else if (*scan == '[')
623 parenstack[depth++] = ']';
624 /* We're going to treat <> as a pair of matching characters,
625 since we're more likely to see those in template id's than
626 real less-than characters. What a crock. */
627 else if (*scan == '<')
628 parenstack[depth++] = '>';
629 else if (*scan == ')' || *scan == ']' || *scan == '>')
631 if (depth > 0 && parenstack[depth - 1] == *scan)
635 /* We're going to do a little error recovery here. If
636 we don't find a match for *scan on the paren stack,
637 but there is something lower on the stack that does
638 match, we pop the stack to that point. */
641 for (i = depth - 1; i >= 0; i--)
642 if (parenstack[i] == *scan)
654 /* We didn't find any :: tokens at the top level, so declare the
655 whole thing an unqualified identifier. */
659 /* Print any array sizes, function arguments or close parentheses
660 needed after the variable name (to describe its type).
661 Args work like c_type_print_varspec_prefix. */
664 c_type_print_varspec_suffix (struct type *type,
665 struct ui_file *stream,
666 int show, int passed_a_ptr,
668 const struct type_print_options *flags)
673 if (TYPE_NAME (type) && show <= 0)
678 switch (TYPE_CODE (type))
680 case TYPE_CODE_ARRAY:
682 LONGEST low_bound, high_bound;
683 int is_vector = TYPE_VECTOR (type);
686 fprintf_filtered (stream, ")");
688 fprintf_filtered (stream, (is_vector ?
689 " __attribute__ ((vector_size(" : "["));
690 /* Bounds are not yet resolved, print a bounds placeholder instead. */
691 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
692 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
693 fprintf_filtered (stream, "variable length");
694 else if (get_array_bounds (type, &low_bound, &high_bound))
695 fprintf_filtered (stream, "%s",
696 plongest (high_bound - low_bound + 1));
697 fprintf_filtered (stream, (is_vector ? ")))" : "]"));
699 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
704 case TYPE_CODE_MEMBERPTR:
705 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
709 case TYPE_CODE_METHODPTR:
710 fprintf_filtered (stream, ")");
711 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
717 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
721 case TYPE_CODE_METHOD:
724 fprintf_filtered (stream, ")");
726 c_type_print_args (type, stream, 0, current_language->la_language,
728 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
729 show, passed_a_ptr, 0, flags);
732 case TYPE_CODE_TYPEDEF:
733 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
734 show, passed_a_ptr, 0, flags);
737 case TYPE_CODE_UNDEF:
738 case TYPE_CODE_STRUCT:
739 case TYPE_CODE_UNION:
744 case TYPE_CODE_ERROR:
748 case TYPE_CODE_RANGE:
749 case TYPE_CODE_STRING:
750 case TYPE_CODE_COMPLEX:
751 case TYPE_CODE_NAMESPACE:
752 case TYPE_CODE_DECFLOAT:
753 /* These types do not need a suffix. They are listed so that
754 gcc -Wall will report types that may not have been
758 error (_("type not handled in c_type_print_varspec_suffix()"));
763 /* A helper for c_type_print_base that displays template
764 parameters and their bindings, if needed.
766 TABLE is the local bindings table to use. If NULL, no printing is
767 done. Note that, at this point, TABLE won't have any useful
768 information in it -- but it is also used as a flag to
769 print_name_maybe_canonical to activate searching the global typedef
772 TYPE is the type whose template arguments are being displayed.
774 STREAM is the stream on which to print. */
777 c_type_print_template_args (const struct type_print_options *flags,
778 struct type *type, struct ui_file *stream)
785 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
787 struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
789 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
795 fprintf_filtered (stream, _("[with %s = "),
796 SYMBOL_LINKAGE_NAME (sym));
801 fputs_filtered (", ", stream);
803 fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
806 c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
810 fputs_filtered (_("] "), stream);
813 /* Print the name of the type (or the ultimate pointer target,
814 function value or array element), or the description of a structure
817 SHOW positive means print details about the type (e.g. enum
818 values), and print structure elements passing SHOW - 1 for show.
820 SHOW negative means just print the type name or struct tag if there
821 is one. If there is no name, print something sensible but concise
824 SHOW zero means just print the type name or struct tag if there is
825 one. If there is no name, print something sensible but not as
826 concise like "struct {int x; int y;}".
828 LEVEL is the number of spaces to indent by.
829 We increase it for some recursive calls. */
832 c_type_print_base (struct type *type, struct ui_file *stream,
833 int show, int level, const struct type_print_options *flags)
839 s_none, s_public, s_private, s_protected
842 int need_access_label = 0;
849 fputs_filtered (_("<type unknown>"), stream);
853 /* When SHOW is zero or less, and there is a valid type name, then
854 always just print the type name directly from the type. */
855 /* If we have "typedef struct foo {. . .} bar;" do we want to print
856 it as "struct foo" or as "bar"? Pick the latter, because C++
857 folk tend to expect things like "class5 *foo" rather than "struct
861 && TYPE_NAME (type) != NULL)
863 c_type_print_modifier (type, stream, 0, 1);
864 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
868 CHECK_TYPEDEF (type);
870 switch (TYPE_CODE (type))
872 case TYPE_CODE_TYPEDEF:
873 /* If we get here, the typedef doesn't have a name, and we
874 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
875 gdb_assert (TYPE_NAME (type) == NULL);
876 gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
877 fprintf_filtered (stream, _("<unnamed typedef>"));
880 case TYPE_CODE_ARRAY:
882 case TYPE_CODE_MEMBERPTR:
885 case TYPE_CODE_METHOD:
886 case TYPE_CODE_METHODPTR:
887 c_type_print_base (TYPE_TARGET_TYPE (type),
888 stream, show, level, flags);
891 case TYPE_CODE_STRUCT:
892 case TYPE_CODE_UNION:
894 struct type_print_options local_flags = *flags;
895 struct type_print_options semi_local_flags = *flags;
896 struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
898 local_flags.local_typedefs = NULL;
899 semi_local_flags.local_typedefs = NULL;
903 if (flags->local_typedefs)
904 local_flags.local_typedefs
905 = copy_typedef_hash (flags->local_typedefs);
907 local_flags.local_typedefs = create_typedef_hash ();
909 make_cleanup_free_typedef_hash (local_flags.local_typedefs);
912 c_type_print_modifier (type, stream, 0, 1);
913 if (TYPE_CODE (type) == TYPE_CODE_UNION)
914 fprintf_filtered (stream, "union ");
915 else if (TYPE_DECLARED_CLASS (type))
916 fprintf_filtered (stream, "class ");
918 fprintf_filtered (stream, "struct ");
920 /* Print the tag if it exists. The HP aCC compiler emits a
921 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
922 enum}" tag for unnamed struct/union/enum's, which we don't
924 if (TYPE_TAG_NAME (type) != NULL
925 && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
927 /* When printing the tag name, we are still effectively
928 printing in the outer context, hence the use of FLAGS
930 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
932 fputs_filtered (" ", stream);
937 /* If we just printed a tag name, no need to print anything
939 if (TYPE_TAG_NAME (type) == NULL)
940 fprintf_filtered (stream, "{...}");
942 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
944 struct type *basetype;
947 c_type_print_template_args (&local_flags, type, stream);
949 /* Add in template parameters when printing derivation info. */
950 add_template_parameters (local_flags.local_typedefs, type);
951 cp_type_print_derivation_info (stream, type, &local_flags);
953 /* This holds just the global typedefs and the template
955 semi_local_flags.local_typedefs
956 = copy_typedef_hash (local_flags.local_typedefs);
957 if (semi_local_flags.local_typedefs)
958 make_cleanup_free_typedef_hash (semi_local_flags.local_typedefs);
960 /* Now add in the local typedefs. */
961 recursively_update_typedef_hash (local_flags.local_typedefs, type);
963 fprintf_filtered (stream, "{\n");
964 if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
965 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
967 if (TYPE_STUB (type))
968 fprintfi_filtered (level + 4, stream,
969 _("<incomplete type>\n"));
971 fprintfi_filtered (level + 4, stream,
972 _("<no data fields>\n"));
975 /* Start off with no specific section type, so we can print
976 one for the first field we find, and use that section type
977 thereafter until we find another type. */
979 section_type = s_none;
981 /* For a class, if all members are private, there's no need
982 for a "private:" label; similarly, for a struct or union
983 masquerading as a class, if all members are public, there's
984 no need for a "public:" label. */
986 if (TYPE_DECLARED_CLASS (type))
989 len = TYPE_NFIELDS (type);
990 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
991 if (!TYPE_FIELD_PRIVATE (type, i))
993 need_access_label = 1;
997 if (!need_access_label)
999 len2 = TYPE_NFN_FIELDS (type);
1000 for (j = 0; j < len2; j++)
1002 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1003 for (i = 0; i < len; i++)
1004 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1007 need_access_label = 1;
1010 if (need_access_label)
1018 len = TYPE_NFIELDS (type);
1019 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1020 if (TYPE_FIELD_PRIVATE (type, i)
1021 || TYPE_FIELD_PROTECTED (type, i))
1023 need_access_label = 1;
1027 if (!need_access_label)
1029 len2 = TYPE_NFN_FIELDS (type);
1030 for (j = 0; j < len2; j++)
1033 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1034 for (i = 0; i < len; i++)
1035 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1037 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1041 need_access_label = 1;
1044 if (need_access_label)
1050 /* If there is a base class for this type,
1051 do not print the field that it occupies. */
1053 len = TYPE_NFIELDS (type);
1054 vptr_fieldno = get_vptr_fieldno (type, &basetype);
1055 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1059 /* If we have a virtual table pointer, omit it. Even if
1060 virtual table pointers are not specifically marked in
1061 the debug info, they should be artificial. */
1062 if ((i == vptr_fieldno && type == basetype)
1063 || TYPE_FIELD_ARTIFICIAL (type, i))
1066 if (need_access_label)
1068 if (TYPE_FIELD_PROTECTED (type, i))
1070 if (section_type != s_protected)
1072 section_type = s_protected;
1073 fprintfi_filtered (level + 2, stream,
1077 else if (TYPE_FIELD_PRIVATE (type, i))
1079 if (section_type != s_private)
1081 section_type = s_private;
1082 fprintfi_filtered (level + 2, stream,
1088 if (section_type != s_public)
1090 section_type = s_public;
1091 fprintfi_filtered (level + 2, stream,
1097 print_spaces_filtered (level + 4, stream);
1098 if (field_is_static (&TYPE_FIELD (type, i)))
1099 fprintf_filtered (stream, "static ");
1100 c_print_type (TYPE_FIELD_TYPE (type, i),
1101 TYPE_FIELD_NAME (type, i),
1102 stream, show - 1, level + 4,
1104 if (!field_is_static (&TYPE_FIELD (type, i))
1105 && TYPE_FIELD_PACKED (type, i))
1107 /* It is a bitfield. This code does not attempt
1108 to look at the bitpos and reconstruct filler,
1109 unnamed fields. This would lead to misleading
1110 results if the compiler does not put out fields
1111 for such things (I don't know what it does). */
1112 fprintf_filtered (stream, " : %d",
1113 TYPE_FIELD_BITSIZE (type, i));
1115 fprintf_filtered (stream, ";\n");
1118 /* If there are both fields and methods, put a blank line
1119 between them. Make sure to count only method that we
1120 will display; artificial methods will be hidden. */
1121 len = TYPE_NFN_FIELDS (type);
1122 if (!flags->print_methods)
1125 for (i = 0; i < len; i++)
1127 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1128 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1131 for (j = 0; j < len2; j++)
1132 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1135 if (real_len > 0 && section_type != s_none)
1136 fprintf_filtered (stream, "\n");
1138 /* C++: print out the methods. */
1139 for (i = 0; i < len; i++)
1141 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1142 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1143 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1144 const char *name = type_name_no_tag (type);
1145 int is_constructor = name && strcmp (method_name,
1148 for (j = 0; j < len2; j++)
1150 const char *mangled_name;
1151 char *demangled_name;
1152 struct cleanup *inner_cleanup;
1153 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1154 int is_full_physname_constructor =
1155 TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1156 || is_constructor_name (physname)
1157 || is_destructor_name (physname)
1158 || method_name[0] == '~';
1160 /* Do not print out artificial methods. */
1161 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1164 inner_cleanup = make_cleanup (null_cleanup, NULL);
1167 if (TYPE_FN_FIELD_PROTECTED (f, j))
1169 if (section_type != s_protected)
1171 section_type = s_protected;
1172 fprintfi_filtered (level + 2, stream,
1176 else if (TYPE_FN_FIELD_PRIVATE (f, j))
1178 if (section_type != s_private)
1180 section_type = s_private;
1181 fprintfi_filtered (level + 2, stream,
1187 if (section_type != s_public)
1189 section_type = s_public;
1190 fprintfi_filtered (level + 2, stream,
1195 print_spaces_filtered (level + 4, stream);
1196 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1197 fprintf_filtered (stream, "virtual ");
1198 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1199 fprintf_filtered (stream, "static ");
1200 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1202 /* Keep GDB from crashing here. */
1203 fprintf_filtered (stream,
1204 _("<undefined type> %s;\n"),
1205 TYPE_FN_FIELD_PHYSNAME (f, j));
1208 else if (!is_constructor /* Constructors don't
1211 && !is_full_physname_constructor /* " " */
1212 && !is_type_conversion_operator (type, i, j))
1214 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1217 fputs_filtered (" ", stream);
1219 if (TYPE_FN_FIELD_STUB (f, j))
1223 /* Build something we can demangle. */
1224 tem = gdb_mangle_name (type, i, j);
1225 make_cleanup (xfree, tem);
1229 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1232 gdb_demangle (mangled_name,
1233 DMGL_ANSI | DMGL_PARAMS);
1234 if (demangled_name == NULL)
1236 /* In some cases (for instance with the HP
1237 demangling), if a function has more than 10
1238 arguments, the demangling will fail.
1239 Let's try to reconstruct the function
1240 signature from the symbol information. */
1241 if (!TYPE_FN_FIELD_STUB (f, j))
1243 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1244 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1246 cp_type_print_method_args (mtype,
1250 stream, &local_flags);
1253 fprintf_filtered (stream,
1254 _("<badly mangled name '%s'>"),
1260 char *demangled_no_class
1261 = remove_qualifiers (demangled_name);
1263 /* Get rid of the `static' appended by the
1265 p = strstr (demangled_no_class, " static");
1268 int length = p - demangled_no_class;
1269 char *demangled_no_static;
1272 = (char *) xmalloc (length + 1);
1273 strncpy (demangled_no_static,
1274 demangled_no_class, length);
1275 *(demangled_no_static + length) = '\0';
1276 fputs_filtered (demangled_no_static, stream);
1277 xfree (demangled_no_static);
1280 fputs_filtered (demangled_no_class, stream);
1281 xfree (demangled_name);
1284 do_cleanups (inner_cleanup);
1286 fprintf_filtered (stream, ";\n");
1290 /* Print typedefs defined in this class. */
1292 if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1294 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1295 fprintf_filtered (stream, "\n");
1297 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1299 struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1301 /* Dereference the typedef declaration itself. */
1302 gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1303 target = TYPE_TARGET_TYPE (target);
1305 print_spaces_filtered (level + 4, stream);
1306 fprintf_filtered (stream, "typedef ");
1308 /* We want to print typedefs with substitutions
1309 from the template parameters or globally-known
1310 typedefs but not local typedefs. */
1311 c_print_type (target,
1312 TYPE_TYPEDEF_FIELD_NAME (type, i),
1313 stream, show - 1, level + 4,
1315 fprintf_filtered (stream, ";\n");
1319 fprintfi_filtered (level, stream, "}");
1322 do_cleanups (local_cleanups);
1326 case TYPE_CODE_ENUM:
1327 c_type_print_modifier (type, stream, 0, 1);
1328 fprintf_filtered (stream, "enum ");
1329 if (TYPE_DECLARED_CLASS (type))
1330 fprintf_filtered (stream, "class ");
1331 /* Print the tag name if it exists.
1332 The aCC compiler emits a spurious
1333 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1334 tag for unnamed struct/union/enum's, which we don't
1336 if (TYPE_TAG_NAME (type) != NULL
1337 && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1339 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1341 fputs_filtered (" ", stream);
1347 /* If we just printed a tag name, no need to print anything
1349 if (TYPE_TAG_NAME (type) == NULL)
1350 fprintf_filtered (stream, "{...}");
1352 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1354 LONGEST lastval = 0;
1356 /* We can't handle this case perfectly, as DWARF does not
1357 tell us whether or not the underlying type was specified
1358 in the source (and other debug formats don't provide this
1359 at all). We choose to print the underlying type, if it
1360 has a name, when in C++ on the theory that it's better to
1361 print too much than too little; but conversely not to
1362 print something egregiously outside the current
1363 language's syntax. */
1364 if (current_language->la_language == language_cplus
1365 && TYPE_TARGET_TYPE (type) != NULL)
1367 struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
1369 if (TYPE_NAME (underlying) != NULL)
1370 fprintf_filtered (stream, ": %s ", TYPE_NAME (underlying));
1373 fprintf_filtered (stream, "{");
1374 len = TYPE_NFIELDS (type);
1375 for (i = 0; i < len; i++)
1379 fprintf_filtered (stream, ", ");
1381 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1382 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1384 fprintf_filtered (stream, " = %s",
1385 plongest (TYPE_FIELD_ENUMVAL (type, i)));
1386 lastval = TYPE_FIELD_ENUMVAL (type, i);
1390 fprintf_filtered (stream, "}");
1394 case TYPE_CODE_VOID:
1395 fprintf_filtered (stream, "void");
1398 case TYPE_CODE_UNDEF:
1399 fprintf_filtered (stream, _("struct <unknown>"));
1402 case TYPE_CODE_ERROR:
1403 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1406 case TYPE_CODE_RANGE:
1407 /* This should not occur. */
1408 fprintf_filtered (stream, _("<range type>"));
1411 case TYPE_CODE_NAMESPACE:
1412 fputs_filtered ("namespace ", stream);
1413 fputs_filtered (TYPE_TAG_NAME (type), stream);
1417 /* Handle types not explicitly handled by the other cases, such
1418 as fundamental types. For these, just print whatever the
1419 type name is, as recorded in the type itself. If there is no
1420 type name, then complain. */
1421 if (TYPE_NAME (type) != NULL)
1423 c_type_print_modifier (type, stream, 0, 1);
1424 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1428 /* At least for dump_symtab, it is important that this not
1430 fprintf_filtered (stream, _("<invalid type code %d>"),