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"
33 #include "cp-support.h"
35 static void c_type_print_varspec_prefix (struct type *,
38 const struct type_print_options *);
40 /* Print "const", "volatile", or address space modifiers. */
41 static void c_type_print_modifier (struct type *,
46 /* A callback function for cp_canonicalize_string_full that uses
47 find_typedef_in_hash. */
50 find_typedef_for_canonicalize (struct type *t, void *data)
52 return find_typedef_in_hash ((const struct type_print_options *) data, t);
55 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
56 canonicalize NAME using the local typedefs first. */
59 print_name_maybe_canonical (const char *name,
60 const struct type_print_options *flags,
61 struct ui_file *stream)
66 s = cp_canonicalize_string_full (name,
67 find_typedef_for_canonicalize,
70 fputs_filtered (!s.empty () ? s.c_str () : name, stream);
75 /* LEVEL is the depth to indent lines by. */
78 c_print_type (struct type *type,
79 const char *varstring,
80 struct ui_file *stream,
82 const struct type_print_options *flags)
87 const char *local_name;
90 type = check_typedef (type);
92 local_name = find_typedef_in_hash (flags, type);
93 if (local_name != NULL)
95 fputs_filtered (local_name, stream);
96 if (varstring != NULL && *varstring != '\0')
97 fputs_filtered (" ", stream);
101 c_type_print_base (type, stream, show, level, flags);
102 code = TYPE_CODE (type);
103 if ((varstring != NULL && *varstring != '\0')
104 /* Need a space if going to print stars or brackets;
105 but not if we will print just a type name. */
106 || ((show > 0 || TYPE_NAME (type) == 0)
107 && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
108 || code == TYPE_CODE_METHOD
109 || (code == TYPE_CODE_ARRAY
110 && !TYPE_VECTOR (type))
111 || code == TYPE_CODE_MEMBERPTR
112 || code == TYPE_CODE_METHODPTR
113 || code == TYPE_CODE_REF)))
114 fputs_filtered (" ", stream);
115 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
116 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
120 if (varstring != NULL)
122 fputs_filtered (varstring, stream);
124 /* For demangled function names, we have the arglist as part of
125 the name, so don't print an additional pair of ()'s. */
126 if (local_name == NULL)
128 demangled_args = strchr (varstring, '(') != NULL;
129 c_type_print_varspec_suffix (type, stream, show,
136 /* Print a typedef using C syntax. TYPE is the underlying type.
137 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
141 c_print_typedef (struct type *type,
142 struct symbol *new_symbol,
143 struct ui_file *stream)
145 type = check_typedef (type);
146 fprintf_filtered (stream, "typedef ");
147 type_print (type, "", stream, 0);
148 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
149 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
150 SYMBOL_LINKAGE_NAME (new_symbol)) != 0
151 || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
152 fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
153 fprintf_filtered (stream, ";\n");
156 /* If TYPE is a derived type, then print out derivation information.
157 Print only the actual base classes of this type, not the base
158 classes of the base classes. I.e. for the derivation hierarchy:
161 class B : public A {int b; };
162 class C : public B {int c; };
164 Print the type of class C as:
170 Not as the following (like gdb used to), which is not legal C++
171 syntax for derived types and may be confused with the multiple
174 class C : public B : public A {
178 In general, gdb should try to print the types as closely as
179 possible to the form that they appear in the source code. */
182 cp_type_print_derivation_info (struct ui_file *stream,
184 const struct type_print_options *flags)
189 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
192 fputs_filtered (i == 0 ? ": " : ", ", stream);
193 fprintf_filtered (stream, "%s%s ",
194 BASETYPE_VIA_PUBLIC (type, i)
195 ? "public" : (TYPE_FIELD_PROTECTED (type, i)
196 ? "protected" : "private"),
197 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
198 name = type_name_no_tag (TYPE_BASECLASS (type, i));
200 print_name_maybe_canonical (name, flags, stream);
202 fprintf_filtered (stream, "(null)");
206 fputs_filtered (" ", stream);
210 /* Print the C++ method arguments ARGS to the file STREAM. */
213 cp_type_print_method_args (struct type *mtype, const char *prefix,
214 const char *varstring, int staticp,
215 struct ui_file *stream,
216 const struct type_print_options *flags)
218 struct field *args = TYPE_FIELDS (mtype);
219 int nargs = TYPE_NFIELDS (mtype);
220 int varargs = TYPE_VARARGS (mtype);
223 fprintf_symbol_filtered (stream, prefix,
224 language_cplus, DMGL_ANSI);
225 fprintf_symbol_filtered (stream, varstring,
226 language_cplus, DMGL_ANSI);
227 fputs_filtered ("(", stream);
229 /* Skip the class variable. */
235 c_print_type (args[i++].type, "", stream, 0, 0, flags);
237 if (i == nargs && varargs)
238 fprintf_filtered (stream, ", ...");
241 fprintf_filtered (stream, ", ");
247 fprintf_filtered (stream, "...");
248 else if (current_language->la_language == language_cplus)
249 fprintf_filtered (stream, "void");
251 fprintf_filtered (stream, ")");
253 /* For non-static methods, read qualifiers from the type of
259 gdb_assert (nargs > 0);
260 gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
261 domain = TYPE_TARGET_TYPE (args[0].type);
263 if (TYPE_CONST (domain))
264 fprintf_filtered (stream, " const");
266 if (TYPE_VOLATILE (domain))
267 fprintf_filtered (stream, " volatile");
269 if (TYPE_RESTRICT (domain))
270 fprintf_filtered (stream, " restrict");
272 if (TYPE_ATOMIC (domain))
273 fprintf_filtered (stream, " _Atomic");
278 /* Print any asterisks or open-parentheses needed before the
279 variable name (to describe its type).
281 On outermost call, pass 0 for PASSED_A_PTR.
282 On outermost call, SHOW > 0 means should ignore
283 any typename for TYPE and show its details.
284 SHOW is always zero on recursive calls.
286 NEED_POST_SPACE is non-zero when a space will be be needed
287 between a trailing qualifier and a field, variable, or function
291 c_type_print_varspec_prefix (struct type *type,
292 struct ui_file *stream,
293 int show, int passed_a_ptr,
295 const struct type_print_options *flags)
302 if (TYPE_NAME (type) && show <= 0)
307 switch (TYPE_CODE (type))
310 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
311 stream, show, 1, 1, flags);
312 fprintf_filtered (stream, "*");
313 c_type_print_modifier (type, stream, 1, need_post_space);
316 case TYPE_CODE_MEMBERPTR:
317 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
318 stream, show, 0, 0, flags);
319 name = type_name_no_tag (TYPE_SELF_TYPE (type));
321 print_name_maybe_canonical (name, flags, stream);
323 c_type_print_base (TYPE_SELF_TYPE (type),
324 stream, -1, passed_a_ptr, flags);
325 fprintf_filtered (stream, "::*");
328 case TYPE_CODE_METHODPTR:
329 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
330 stream, show, 0, 0, flags);
331 fprintf_filtered (stream, "(");
332 name = type_name_no_tag (TYPE_SELF_TYPE (type));
334 print_name_maybe_canonical (name, flags, stream);
336 c_type_print_base (TYPE_SELF_TYPE (type),
337 stream, -1, passed_a_ptr, flags);
338 fprintf_filtered (stream, "::*");
342 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
343 stream, show, 1, 0, flags);
344 fprintf_filtered (stream, "&");
345 c_type_print_modifier (type, stream, 1, need_post_space);
348 case TYPE_CODE_METHOD:
350 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
351 stream, show, 0, 0, flags);
353 fprintf_filtered (stream, "(");
356 case TYPE_CODE_ARRAY:
357 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
358 stream, show, 0, 0, flags);
360 fprintf_filtered (stream, "(");
363 case TYPE_CODE_TYPEDEF:
364 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
365 stream, show, passed_a_ptr, 0, flags);
368 case TYPE_CODE_UNDEF:
369 case TYPE_CODE_STRUCT:
370 case TYPE_CODE_UNION:
372 case TYPE_CODE_FLAGS:
376 case TYPE_CODE_ERROR:
380 case TYPE_CODE_RANGE:
381 case TYPE_CODE_STRING:
382 case TYPE_CODE_COMPLEX:
383 case TYPE_CODE_NAMESPACE:
384 case TYPE_CODE_DECFLOAT:
385 /* These types need no prefix. They are listed here so that
386 gcc -Wall will reveal any types that haven't been handled. */
389 error (_("type not handled in c_type_print_varspec_prefix()"));
394 /* Print out "const" and "volatile" attributes,
395 and address space id if present.
396 TYPE is a pointer to the type being printed out.
397 STREAM is the output destination.
398 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
399 NEED_POST_SPACE = 1 indicates a final white space is needed. */
402 c_type_print_modifier (struct type *type, struct ui_file *stream,
403 int need_pre_space, int need_post_space)
405 int did_print_modifier = 0;
406 const char *address_space_id;
408 /* We don't print `const' qualifiers for references --- since all
409 operators affect the thing referenced, not the reference itself,
410 every reference is `const'. */
411 if (TYPE_CONST (type)
412 && TYPE_CODE (type) != TYPE_CODE_REF)
415 fprintf_filtered (stream, " ");
416 fprintf_filtered (stream, "const");
417 did_print_modifier = 1;
420 if (TYPE_VOLATILE (type))
422 if (did_print_modifier || need_pre_space)
423 fprintf_filtered (stream, " ");
424 fprintf_filtered (stream, "volatile");
425 did_print_modifier = 1;
428 if (TYPE_RESTRICT (type))
430 if (did_print_modifier || need_pre_space)
431 fprintf_filtered (stream, " ");
432 fprintf_filtered (stream, "restrict");
433 did_print_modifier = 1;
436 if (TYPE_ATOMIC (type))
438 if (did_print_modifier || need_pre_space)
439 fprintf_filtered (stream, " ");
440 fprintf_filtered (stream, "_Atomic");
441 did_print_modifier = 1;
444 address_space_id = address_space_int_to_name (get_type_arch (type),
445 TYPE_INSTANCE_FLAGS (type));
446 if (address_space_id)
448 if (did_print_modifier || need_pre_space)
449 fprintf_filtered (stream, " ");
450 fprintf_filtered (stream, "@%s", address_space_id);
451 did_print_modifier = 1;
454 if (did_print_modifier && need_post_space)
455 fprintf_filtered (stream, " ");
459 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
460 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
461 in non-static methods, are displayed if LINKAGE_NAME is zero. If
462 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
463 parameter types get removed their possible const and volatile qualifiers to
464 match demangled linkage name parameters part of such function type.
465 LANGUAGE is the language in which TYPE was defined. This is a necessary
466 evil since this code is used by the C and C++. */
469 c_type_print_args (struct type *type, struct ui_file *stream,
470 int linkage_name, enum language language,
471 const struct type_print_options *flags)
476 fprintf_filtered (stream, "(");
478 for (i = 0; i < TYPE_NFIELDS (type); i++)
480 struct type *param_type;
482 if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
487 fprintf_filtered (stream, ", ");
491 param_type = TYPE_FIELD_TYPE (type, i);
493 if (language == language_cplus && linkage_name)
495 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
496 - Parameter declarations that differ only in the presence or
497 absence of const and/or volatile are equivalent.
499 And the const/volatile qualifiers are not present in the mangled
500 names as produced by GCC. */
502 param_type = make_cv_type (0, 0, param_type, NULL);
505 c_print_type (param_type, "", stream, -1, 0, flags);
509 if (printed_any && TYPE_VARARGS (type))
511 /* Print out a trailing ellipsis for varargs functions. Ignore
512 TYPE_VARARGS if the function has no named arguments; that
513 represents unprototyped (K&R style) C functions. */
514 if (printed_any && TYPE_VARARGS (type))
516 fprintf_filtered (stream, ", ");
518 fprintf_filtered (stream, "...");
521 else if (!printed_any
522 && (TYPE_PROTOTYPED (type) || language == language_cplus))
523 fprintf_filtered (stream, "void");
525 fprintf_filtered (stream, ")");
528 /* Return true iff the j'th overloading of the i'th method of TYPE
529 is a type conversion operator, like `operator int () { ... }'.
530 When listing a class's methods, we don't print the return type of
534 is_type_conversion_operator (struct type *type, int i, int j)
536 /* I think the whole idea of recognizing type conversion operators
537 by their name is pretty terrible. But I don't think our present
538 data structure gives us any other way to tell. If you know of
539 some other way, feel free to rewrite this function. */
540 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
542 if (!startswith (name, "operator"))
546 if (! strchr (" \t\f\n\r", *name))
549 while (strchr (" \t\f\n\r", *name))
552 if (!('a' <= *name && *name <= 'z')
553 && !('A' <= *name && *name <= 'Z')
555 /* If this doesn't look like the start of an identifier, then it
556 isn't a type conversion operator. */
558 else if (startswith (name, "new"))
560 else if (startswith (name, "delete"))
563 /* If it doesn't look like new or delete, it's a type conversion
567 /* Is that really the end of the name? */
568 if (('a' <= *name && *name <= 'z')
569 || ('A' <= *name && *name <= 'Z')
570 || ('0' <= *name && *name <= '9')
572 /* No, so the identifier following "operator" must be a type name,
573 and this is a type conversion operator. */
576 /* That was indeed the end of the name, so it was `operator new' or
577 `operator delete', neither of which are type conversion
582 /* Given a C++ qualified identifier QID, strip off the qualifiers,
583 yielding the unqualified name. The return value is a pointer into
586 It's a pity we don't have this information in some more structured
587 form. Even the author of this function feels that writing little
588 parsers like this everywhere is stupid. */
591 remove_qualifiers (char *qid)
593 int quoted = 0; /* Zero if we're not in quotes;
594 '"' if we're in a double-quoted string;
595 '\'' if we're in a single-quoted string. */
596 int depth = 0; /* Number of unclosed parens we've seen. */
597 char *parenstack = (char *) alloca (strlen (qid));
599 char *last = 0; /* The character after the rightmost
600 `::' token we've seen so far. */
602 for (scan = qid; *scan; scan++)
608 else if (*scan == '\\' && *(scan + 1))
611 else if (scan[0] == ':' && scan[1] == ':')
613 /* If we're inside parenthesis (i.e., an argument list) or
614 angle brackets (i.e., a list of template arguments), then
615 we don't record the position of this :: token, since it's
616 not relevant to the top-level structure we're trying to
624 else if (*scan == '"' || *scan == '\'')
626 else if (*scan == '(')
627 parenstack[depth++] = ')';
628 else if (*scan == '[')
629 parenstack[depth++] = ']';
630 /* We're going to treat <> as a pair of matching characters,
631 since we're more likely to see those in template id's than
632 real less-than characters. What a crock. */
633 else if (*scan == '<')
634 parenstack[depth++] = '>';
635 else if (*scan == ')' || *scan == ']' || *scan == '>')
637 if (depth > 0 && parenstack[depth - 1] == *scan)
641 /* We're going to do a little error recovery here. If
642 we don't find a match for *scan on the paren stack,
643 but there is something lower on the stack that does
644 match, we pop the stack to that point. */
647 for (i = depth - 1; i >= 0; i--)
648 if (parenstack[i] == *scan)
660 /* We didn't find any :: tokens at the top level, so declare the
661 whole thing an unqualified identifier. */
665 /* Print any array sizes, function arguments or close parentheses
666 needed after the variable name (to describe its type).
667 Args work like c_type_print_varspec_prefix. */
670 c_type_print_varspec_suffix (struct type *type,
671 struct ui_file *stream,
672 int show, int passed_a_ptr,
674 const struct type_print_options *flags)
679 if (TYPE_NAME (type) && show <= 0)
684 switch (TYPE_CODE (type))
686 case TYPE_CODE_ARRAY:
688 LONGEST low_bound, high_bound;
689 int is_vector = TYPE_VECTOR (type);
692 fprintf_filtered (stream, ")");
694 fprintf_filtered (stream, (is_vector ?
695 " __attribute__ ((vector_size(" : "["));
696 /* Bounds are not yet resolved, print a bounds placeholder instead. */
697 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
698 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
699 fprintf_filtered (stream, "variable length");
700 else if (get_array_bounds (type, &low_bound, &high_bound))
701 fprintf_filtered (stream, "%s",
702 plongest (high_bound - low_bound + 1));
703 fprintf_filtered (stream, (is_vector ? ")))" : "]"));
705 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
710 case TYPE_CODE_MEMBERPTR:
711 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
715 case TYPE_CODE_METHODPTR:
716 fprintf_filtered (stream, ")");
717 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
723 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
727 case TYPE_CODE_METHOD:
730 fprintf_filtered (stream, ")");
732 c_type_print_args (type, stream, 0, current_language->la_language,
734 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
735 show, passed_a_ptr, 0, flags);
738 case TYPE_CODE_TYPEDEF:
739 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
740 show, passed_a_ptr, 0, flags);
743 case TYPE_CODE_UNDEF:
744 case TYPE_CODE_STRUCT:
745 case TYPE_CODE_UNION:
746 case TYPE_CODE_FLAGS:
751 case TYPE_CODE_ERROR:
755 case TYPE_CODE_RANGE:
756 case TYPE_CODE_STRING:
757 case TYPE_CODE_COMPLEX:
758 case TYPE_CODE_NAMESPACE:
759 case TYPE_CODE_DECFLOAT:
760 /* These types do not need a suffix. They are listed so that
761 gcc -Wall will report types that may not have been
765 error (_("type not handled in c_type_print_varspec_suffix()"));
770 /* A helper for c_type_print_base that displays template
771 parameters and their bindings, if needed.
773 TABLE is the local bindings table to use. If NULL, no printing is
774 done. Note that, at this point, TABLE won't have any useful
775 information in it -- but it is also used as a flag to
776 print_name_maybe_canonical to activate searching the global typedef
779 TYPE is the type whose template arguments are being displayed.
781 STREAM is the stream on which to print. */
784 c_type_print_template_args (const struct type_print_options *flags,
785 struct type *type, struct ui_file *stream)
792 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
794 struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
796 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
802 fprintf_filtered (stream, _("[with %s = "),
803 SYMBOL_LINKAGE_NAME (sym));
808 fputs_filtered (", ", stream);
810 fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
813 c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
817 fputs_filtered (_("] "), stream);
820 /* Print the name of the type (or the ultimate pointer target,
821 function value or array element), or the description of a structure
824 SHOW positive means print details about the type (e.g. enum
825 values), and print structure elements passing SHOW - 1 for show.
827 SHOW negative means just print the type name or struct tag if there
828 is one. If there is no name, print something sensible but concise
831 SHOW zero means just print the type name or struct tag if there is
832 one. If there is no name, print something sensible but not as
833 concise like "struct {int x; int y;}".
835 LEVEL is the number of spaces to indent by.
836 We increase it for some recursive calls. */
839 c_type_print_base (struct type *type, struct ui_file *stream,
840 int show, int level, const struct type_print_options *flags)
846 s_none, s_public, s_private, s_protected
849 int need_access_label = 0;
856 fputs_filtered (_("<type unknown>"), stream);
860 /* When SHOW is zero or less, and there is a valid type name, then
861 always just print the type name directly from the type. */
862 /* If we have "typedef struct foo {. . .} bar;" do we want to print
863 it as "struct foo" or as "bar"? Pick the latter, because C++
864 folk tend to expect things like "class5 *foo" rather than "struct
868 && TYPE_NAME (type) != NULL)
870 c_type_print_modifier (type, stream, 0, 1);
871 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
875 type = check_typedef (type);
877 switch (TYPE_CODE (type))
879 case TYPE_CODE_TYPEDEF:
880 /* If we get here, the typedef doesn't have a name, and we
881 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
882 gdb_assert (TYPE_NAME (type) == NULL);
883 gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
884 fprintf_filtered (stream, _("<unnamed typedef>"));
887 case TYPE_CODE_ARRAY:
889 case TYPE_CODE_MEMBERPTR:
892 case TYPE_CODE_METHOD:
893 case TYPE_CODE_METHODPTR:
894 c_type_print_base (TYPE_TARGET_TYPE (type),
895 stream, show, level, flags);
898 case TYPE_CODE_STRUCT:
899 case TYPE_CODE_UNION:
901 struct type_print_options local_flags = *flags;
902 struct type_print_options semi_local_flags = *flags;
903 struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
905 local_flags.local_typedefs = NULL;
906 semi_local_flags.local_typedefs = NULL;
910 if (flags->local_typedefs)
911 local_flags.local_typedefs
912 = copy_typedef_hash (flags->local_typedefs);
914 local_flags.local_typedefs = create_typedef_hash ();
916 make_cleanup_free_typedef_hash (local_flags.local_typedefs);
919 c_type_print_modifier (type, stream, 0, 1);
920 if (TYPE_CODE (type) == TYPE_CODE_UNION)
921 fprintf_filtered (stream, "union ");
922 else if (TYPE_DECLARED_CLASS (type))
923 fprintf_filtered (stream, "class ");
925 fprintf_filtered (stream, "struct ");
927 /* Print the tag if it exists. The HP aCC compiler emits a
928 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
929 enum}" tag for unnamed struct/union/enum's, which we don't
931 if (TYPE_TAG_NAME (type) != NULL
932 && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
934 /* When printing the tag name, we are still effectively
935 printing in the outer context, hence the use of FLAGS
937 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
939 fputs_filtered (" ", stream);
944 /* If we just printed a tag name, no need to print anything
946 if (TYPE_TAG_NAME (type) == NULL)
947 fprintf_filtered (stream, "{...}");
949 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
951 struct type *basetype;
954 c_type_print_template_args (&local_flags, type, stream);
956 /* Add in template parameters when printing derivation info. */
957 add_template_parameters (local_flags.local_typedefs, type);
958 cp_type_print_derivation_info (stream, type, &local_flags);
960 /* This holds just the global typedefs and the template
962 semi_local_flags.local_typedefs
963 = copy_typedef_hash (local_flags.local_typedefs);
964 if (semi_local_flags.local_typedefs)
965 make_cleanup_free_typedef_hash (semi_local_flags.local_typedefs);
967 /* Now add in the local typedefs. */
968 recursively_update_typedef_hash (local_flags.local_typedefs, type);
970 fprintf_filtered (stream, "{\n");
971 if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
972 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
974 if (TYPE_STUB (type))
975 fprintfi_filtered (level + 4, stream,
976 _("<incomplete type>\n"));
978 fprintfi_filtered (level + 4, stream,
979 _("<no data fields>\n"));
982 /* Start off with no specific section type, so we can print
983 one for the first field we find, and use that section type
984 thereafter until we find another type. */
986 section_type = s_none;
988 /* For a class, if all members are private, there's no need
989 for a "private:" label; similarly, for a struct or union
990 masquerading as a class, if all members are public, there's
991 no need for a "public:" label. */
993 if (TYPE_DECLARED_CLASS (type))
996 len = TYPE_NFIELDS (type);
997 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
998 if (!TYPE_FIELD_PRIVATE (type, i))
1000 need_access_label = 1;
1004 if (!need_access_label)
1006 len2 = TYPE_NFN_FIELDS (type);
1007 for (j = 0; j < len2; j++)
1009 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1010 for (i = 0; i < len; i++)
1011 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1014 need_access_label = 1;
1017 if (need_access_label)
1025 len = TYPE_NFIELDS (type);
1026 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1027 if (TYPE_FIELD_PRIVATE (type, i)
1028 || TYPE_FIELD_PROTECTED (type, i))
1030 need_access_label = 1;
1034 if (!need_access_label)
1036 len2 = TYPE_NFN_FIELDS (type);
1037 for (j = 0; j < len2; j++)
1040 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1041 for (i = 0; i < len; i++)
1042 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1044 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1048 need_access_label = 1;
1051 if (need_access_label)
1057 /* If there is a base class for this type,
1058 do not print the field that it occupies. */
1060 len = TYPE_NFIELDS (type);
1061 vptr_fieldno = get_vptr_fieldno (type, &basetype);
1062 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1066 /* If we have a virtual table pointer, omit it. Even if
1067 virtual table pointers are not specifically marked in
1068 the debug info, they should be artificial. */
1069 if ((i == vptr_fieldno && type == basetype)
1070 || TYPE_FIELD_ARTIFICIAL (type, i))
1073 if (need_access_label)
1075 if (TYPE_FIELD_PROTECTED (type, i))
1077 if (section_type != s_protected)
1079 section_type = s_protected;
1080 fprintfi_filtered (level + 2, stream,
1084 else if (TYPE_FIELD_PRIVATE (type, i))
1086 if (section_type != s_private)
1088 section_type = s_private;
1089 fprintfi_filtered (level + 2, stream,
1095 if (section_type != s_public)
1097 section_type = s_public;
1098 fprintfi_filtered (level + 2, stream,
1104 print_spaces_filtered (level + 4, stream);
1105 if (field_is_static (&TYPE_FIELD (type, i)))
1106 fprintf_filtered (stream, "static ");
1107 c_print_type (TYPE_FIELD_TYPE (type, i),
1108 TYPE_FIELD_NAME (type, i),
1109 stream, show - 1, level + 4,
1111 if (!field_is_static (&TYPE_FIELD (type, i))
1112 && TYPE_FIELD_PACKED (type, i))
1114 /* It is a bitfield. This code does not attempt
1115 to look at the bitpos and reconstruct filler,
1116 unnamed fields. This would lead to misleading
1117 results if the compiler does not put out fields
1118 for such things (I don't know what it does). */
1119 fprintf_filtered (stream, " : %d",
1120 TYPE_FIELD_BITSIZE (type, i));
1122 fprintf_filtered (stream, ";\n");
1125 /* If there are both fields and methods, put a blank line
1126 between them. Make sure to count only method that we
1127 will display; artificial methods will be hidden. */
1128 len = TYPE_NFN_FIELDS (type);
1129 if (!flags->print_methods)
1132 for (i = 0; i < len; i++)
1134 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1135 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1138 for (j = 0; j < len2; j++)
1139 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1142 if (real_len > 0 && section_type != s_none)
1143 fprintf_filtered (stream, "\n");
1145 /* C++: print out the methods. */
1146 for (i = 0; i < len; i++)
1148 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1149 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1150 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1151 const char *name = type_name_no_tag (type);
1152 int is_constructor = name && strcmp (method_name,
1155 for (j = 0; j < len2; j++)
1157 const char *mangled_name;
1158 char *demangled_name;
1159 struct cleanup *inner_cleanup;
1160 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1161 int is_full_physname_constructor =
1162 TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1163 || is_constructor_name (physname)
1164 || is_destructor_name (physname)
1165 || method_name[0] == '~';
1167 /* Do not print out artificial methods. */
1168 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1171 inner_cleanup = make_cleanup (null_cleanup, NULL);
1174 if (TYPE_FN_FIELD_PROTECTED (f, j))
1176 if (section_type != s_protected)
1178 section_type = s_protected;
1179 fprintfi_filtered (level + 2, stream,
1183 else if (TYPE_FN_FIELD_PRIVATE (f, j))
1185 if (section_type != s_private)
1187 section_type = s_private;
1188 fprintfi_filtered (level + 2, stream,
1194 if (section_type != s_public)
1196 section_type = s_public;
1197 fprintfi_filtered (level + 2, stream,
1202 print_spaces_filtered (level + 4, stream);
1203 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1204 fprintf_filtered (stream, "virtual ");
1205 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1206 fprintf_filtered (stream, "static ");
1207 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1209 /* Keep GDB from crashing here. */
1210 fprintf_filtered (stream,
1211 _("<undefined type> %s;\n"),
1212 TYPE_FN_FIELD_PHYSNAME (f, j));
1215 else if (!is_constructor /* Constructors don't
1218 && !is_full_physname_constructor /* " " */
1219 && !is_type_conversion_operator (type, i, j))
1221 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1224 fputs_filtered (" ", stream);
1226 if (TYPE_FN_FIELD_STUB (f, j))
1230 /* Build something we can demangle. */
1231 tem = gdb_mangle_name (type, i, j);
1232 make_cleanup (xfree, tem);
1236 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1239 gdb_demangle (mangled_name,
1240 DMGL_ANSI | DMGL_PARAMS);
1241 if (demangled_name == NULL)
1243 /* In some cases (for instance with the HP
1244 demangling), if a function has more than 10
1245 arguments, the demangling will fail.
1246 Let's try to reconstruct the function
1247 signature from the symbol information. */
1248 if (!TYPE_FN_FIELD_STUB (f, j))
1250 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1251 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1253 cp_type_print_method_args (mtype,
1257 stream, &local_flags);
1260 fprintf_filtered (stream,
1261 _("<badly mangled name '%s'>"),
1267 char *demangled_no_class
1268 = remove_qualifiers (demangled_name);
1270 /* Get rid of the `static' appended by the
1272 p = strstr (demangled_no_class, " static");
1275 int length = p - demangled_no_class;
1276 char *demangled_no_static;
1279 = (char *) xmalloc (length + 1);
1280 strncpy (demangled_no_static,
1281 demangled_no_class, length);
1282 *(demangled_no_static + length) = '\0';
1283 fputs_filtered (demangled_no_static, stream);
1284 xfree (demangled_no_static);
1287 fputs_filtered (demangled_no_class, stream);
1288 xfree (demangled_name);
1291 do_cleanups (inner_cleanup);
1293 fprintf_filtered (stream, ";\n");
1297 /* Print typedefs defined in this class. */
1299 if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1301 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1302 fprintf_filtered (stream, "\n");
1304 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1306 struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1308 /* Dereference the typedef declaration itself. */
1309 gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1310 target = TYPE_TARGET_TYPE (target);
1312 print_spaces_filtered (level + 4, stream);
1313 fprintf_filtered (stream, "typedef ");
1315 /* We want to print typedefs with substitutions
1316 from the template parameters or globally-known
1317 typedefs but not local typedefs. */
1318 c_print_type (target,
1319 TYPE_TYPEDEF_FIELD_NAME (type, i),
1320 stream, show - 1, level + 4,
1322 fprintf_filtered (stream, ";\n");
1326 fprintfi_filtered (level, stream, "}");
1329 do_cleanups (local_cleanups);
1333 case TYPE_CODE_ENUM:
1334 c_type_print_modifier (type, stream, 0, 1);
1335 fprintf_filtered (stream, "enum ");
1336 if (TYPE_DECLARED_CLASS (type))
1337 fprintf_filtered (stream, "class ");
1338 /* Print the tag name if it exists.
1339 The aCC compiler emits a spurious
1340 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1341 tag for unnamed struct/union/enum's, which we don't
1343 if (TYPE_TAG_NAME (type) != NULL
1344 && !startswith (TYPE_TAG_NAME (type), "{unnamed"))
1346 print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1348 fputs_filtered (" ", stream);
1354 /* If we just printed a tag name, no need to print anything
1356 if (TYPE_TAG_NAME (type) == NULL)
1357 fprintf_filtered (stream, "{...}");
1359 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1361 LONGEST lastval = 0;
1363 /* We can't handle this case perfectly, as DWARF does not
1364 tell us whether or not the underlying type was specified
1365 in the source (and other debug formats don't provide this
1366 at all). We choose to print the underlying type, if it
1367 has a name, when in C++ on the theory that it's better to
1368 print too much than too little; but conversely not to
1369 print something egregiously outside the current
1370 language's syntax. */
1371 if (current_language->la_language == language_cplus
1372 && TYPE_TARGET_TYPE (type) != NULL)
1374 struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
1376 if (TYPE_NAME (underlying) != NULL)
1377 fprintf_filtered (stream, ": %s ", TYPE_NAME (underlying));
1380 fprintf_filtered (stream, "{");
1381 len = TYPE_NFIELDS (type);
1382 for (i = 0; i < len; i++)
1386 fprintf_filtered (stream, ", ");
1388 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1389 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1391 fprintf_filtered (stream, " = %s",
1392 plongest (TYPE_FIELD_ENUMVAL (type, i)));
1393 lastval = TYPE_FIELD_ENUMVAL (type, i);
1397 fprintf_filtered (stream, "}");
1401 case TYPE_CODE_FLAGS:
1403 struct type_print_options local_flags = *flags;
1405 local_flags.local_typedefs = NULL;
1407 c_type_print_modifier (type, stream, 0, 1);
1408 fprintf_filtered (stream, "flag ");
1409 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1412 fputs_filtered (" ", stream);
1413 fprintf_filtered (stream, "{\n");
1414 if (TYPE_NFIELDS (type) == 0)
1416 if (TYPE_STUB (type))
1417 fprintfi_filtered (level + 4, stream,
1418 _("<incomplete type>\n"));
1420 fprintfi_filtered (level + 4, stream,
1421 _("<no data fields>\n"));
1423 len = TYPE_NFIELDS (type);
1424 for (i = 0; i < len; i++)
1427 print_spaces_filtered (level + 4, stream);
1428 /* We pass "show" here and not "show - 1" to get enum types
1429 printed. There's no other way to see them. */
1430 c_print_type (TYPE_FIELD_TYPE (type, i),
1431 TYPE_FIELD_NAME (type, i),
1432 stream, show, level + 4,
1434 fprintf_filtered (stream, " @%s",
1435 plongest (TYPE_FIELD_BITPOS (type, i)));
1436 if (TYPE_FIELD_BITSIZE (type, i) > 1)
1438 fprintf_filtered (stream, "-%s",
1439 plongest (TYPE_FIELD_BITPOS (type, i)
1440 + TYPE_FIELD_BITSIZE (type, i)
1443 fprintf_filtered (stream, ";\n");
1445 fprintfi_filtered (level, stream, "}");
1450 case TYPE_CODE_VOID:
1451 fprintf_filtered (stream, "void");
1454 case TYPE_CODE_UNDEF:
1455 fprintf_filtered (stream, _("struct <unknown>"));
1458 case TYPE_CODE_ERROR:
1459 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1462 case TYPE_CODE_RANGE:
1463 /* This should not occur. */
1464 fprintf_filtered (stream, _("<range type>"));
1467 case TYPE_CODE_NAMESPACE:
1468 fputs_filtered ("namespace ", stream);
1469 fputs_filtered (TYPE_TAG_NAME (type), stream);
1473 /* Handle types not explicitly handled by the other cases, such
1474 as fundamental types. For these, just print whatever the
1475 type name is, as recorded in the type itself. If there is no
1476 type name, then complain. */
1477 if (TYPE_NAME (type) != NULL)
1479 c_type_print_modifier (type, stream, 0, 1);
1480 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1484 /* At least for dump_symtab, it is important that this not
1486 fprintf_filtered (stream, _("<invalid type code %d>"),