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"
36 #include "cp-support.h"
38 static void c_type_print_varspec_prefix (struct type
*,
41 const struct type_print_options
*);
43 /* Print "const", "volatile", or address space modifiers. */
44 static void c_type_print_modifier (struct type
*,
49 /* A callback function for cp_canonicalize_string_full that uses
50 find_typedef_in_hash. */
53 find_typedef_for_canonicalize (struct type
*t
, void *data
)
55 return find_typedef_in_hash (data
, t
);
58 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
59 canonicalize NAME using the local typedefs first. */
62 print_name_maybe_canonical (const char *name
,
63 const struct type_print_options
*flags
,
64 struct ui_file
*stream
)
69 s
= cp_canonicalize_string_full (name
,
70 find_typedef_for_canonicalize
,
73 fputs_filtered (s
? s
: name
, stream
);
79 /* LEVEL is the depth to indent lines by. */
82 c_print_type (struct type
*type
,
83 const char *varstring
,
84 struct ui_file
*stream
,
86 const struct type_print_options
*flags
)
91 const char *local_name
;
96 local_name
= find_typedef_in_hash (flags
, type
);
97 if (local_name
!= NULL
)
99 fputs_filtered (local_name
, stream
);
100 if (varstring
!= NULL
&& *varstring
!= '\0')
101 fputs_filtered (" ", stream
);
105 c_type_print_base (type
, stream
, show
, level
, flags
);
106 code
= TYPE_CODE (type
);
107 if ((varstring
!= NULL
&& *varstring
!= '\0')
108 /* Need a space if going to print stars or brackets;
109 but not if we will print just a type name. */
110 || ((show
> 0 || TYPE_NAME (type
) == 0)
111 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
112 || code
== TYPE_CODE_METHOD
113 || (code
== TYPE_CODE_ARRAY
114 && !TYPE_VECTOR (type
))
115 || code
== TYPE_CODE_MEMBERPTR
116 || code
== TYPE_CODE_METHODPTR
117 || code
== TYPE_CODE_REF
)))
118 fputs_filtered (" ", stream
);
119 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
120 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
124 if (varstring
!= NULL
)
126 fputs_filtered (varstring
, stream
);
128 /* For demangled function names, we have the arglist as part of
129 the name, so don't print an additional pair of ()'s. */
130 if (local_name
== NULL
)
132 demangled_args
= strchr (varstring
, '(') != NULL
;
133 c_type_print_varspec_suffix (type
, stream
, show
,
140 /* Print a typedef using C syntax. TYPE is the underlying type.
141 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
145 c_print_typedef (struct type
*type
,
146 struct symbol
*new_symbol
,
147 struct ui_file
*stream
)
149 CHECK_TYPEDEF (type
);
150 fprintf_filtered (stream
, "typedef ");
151 type_print (type
, "", stream
, 0);
152 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
153 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
154 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
155 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
156 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
157 fprintf_filtered (stream
, ";\n");
160 /* If TYPE is a derived type, then print out derivation information.
161 Print only the actual base classes of this type, not the base
162 classes of the base classes. I.e. for the derivation hierarchy:
165 class B : public A {int b; };
166 class C : public B {int c; };
168 Print the type of class C as:
174 Not as the following (like gdb used to), which is not legal C++
175 syntax for derived types and may be confused with the multiple
178 class C : public B : public A {
182 In general, gdb should try to print the types as closely as
183 possible to the form that they appear in the source code. */
186 cp_type_print_derivation_info (struct ui_file
*stream
,
188 const struct type_print_options
*flags
)
193 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
196 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
197 fprintf_filtered (stream
, "%s%s ",
198 BASETYPE_VIA_PUBLIC (type
, i
)
199 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
200 ? "protected" : "private"),
201 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
202 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
204 print_name_maybe_canonical (name
, flags
, stream
);
206 fprintf_filtered (stream
, "(null)");
210 fputs_filtered (" ", stream
);
214 /* Print the C++ method arguments ARGS to the file STREAM. */
217 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
218 const char *varstring
, int staticp
,
219 struct ui_file
*stream
,
220 const struct type_print_options
*flags
)
222 struct field
*args
= TYPE_FIELDS (mtype
);
223 int nargs
= TYPE_NFIELDS (mtype
);
224 int varargs
= TYPE_VARARGS (mtype
);
227 fprintf_symbol_filtered (stream
, prefix
,
228 language_cplus
, DMGL_ANSI
);
229 fprintf_symbol_filtered (stream
, varstring
,
230 language_cplus
, DMGL_ANSI
);
231 fputs_filtered ("(", stream
);
233 /* Skip the class variable. */
239 c_print_type (args
[i
++].type
, "", stream
, 0, 0, flags
);
241 if (i
== nargs
&& varargs
)
242 fprintf_filtered (stream
, ", ...");
245 fprintf_filtered (stream
, ", ");
251 fprintf_filtered (stream
, "...");
252 else if (current_language
->la_language
== language_cplus
)
253 fprintf_filtered (stream
, "void");
255 fprintf_filtered (stream
, ")");
257 /* For non-static methods, read qualifiers from the type of
263 gdb_assert (nargs
> 0);
264 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
265 domain
= TYPE_TARGET_TYPE (args
[0].type
);
267 if (TYPE_CONST (domain
))
268 fprintf_filtered (stream
, " const");
270 if (TYPE_VOLATILE (domain
))
271 fprintf_filtered (stream
, " volatile");
273 if (TYPE_RESTRICT (domain
))
274 fprintf_filtered (stream
, " restrict");
279 /* Print any asterisks or open-parentheses needed before the
280 variable name (to describe its type).
282 On outermost call, pass 0 for PASSED_A_PTR.
283 On outermost call, SHOW > 0 means should ignore
284 any typename for TYPE and show its details.
285 SHOW is always zero on recursive calls.
287 NEED_POST_SPACE is non-zero when a space will be be needed
288 between a trailing qualifier and a field, variable, or function
292 c_type_print_varspec_prefix (struct type
*type
,
293 struct ui_file
*stream
,
294 int show
, int passed_a_ptr
,
296 const struct type_print_options
*flags
)
303 if (TYPE_NAME (type
) && show
<= 0)
308 switch (TYPE_CODE (type
))
311 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
312 stream
, show
, 1, 1, flags
);
313 fprintf_filtered (stream
, "*");
314 c_type_print_modifier (type
, stream
, 1, need_post_space
);
317 case TYPE_CODE_MEMBERPTR
:
318 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
319 stream
, show
, 0, 0, flags
);
320 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
322 print_name_maybe_canonical (name
, flags
, stream
);
324 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
325 stream
, -1, passed_a_ptr
, flags
);
326 fprintf_filtered (stream
, "::*");
329 case TYPE_CODE_METHODPTR
:
330 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
331 stream
, show
, 0, 0, flags
);
332 fprintf_filtered (stream
, "(");
333 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
335 print_name_maybe_canonical (name
, flags
, stream
);
337 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
338 stream
, -1, passed_a_ptr
, flags
);
339 fprintf_filtered (stream
, "::*");
343 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
344 stream
, show
, 1, 0, flags
);
345 fprintf_filtered (stream
, "&");
346 c_type_print_modifier (type
, stream
, 1, need_post_space
);
349 case TYPE_CODE_METHOD
:
351 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
352 stream
, show
, 0, 0, flags
);
354 fprintf_filtered (stream
, "(");
357 case TYPE_CODE_ARRAY
:
358 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
359 stream
, show
, 0, 0, flags
);
361 fprintf_filtered (stream
, "(");
364 case TYPE_CODE_TYPEDEF
:
365 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
366 stream
, show
, passed_a_ptr
, 0, flags
);
369 case TYPE_CODE_UNDEF
:
370 case TYPE_CODE_STRUCT
:
371 case TYPE_CODE_UNION
:
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 address_space_id
= address_space_int_to_name (get_type_arch (type
),
437 TYPE_INSTANCE_FLAGS (type
));
438 if (address_space_id
)
440 if (did_print_modifier
|| need_pre_space
)
441 fprintf_filtered (stream
, " ");
442 fprintf_filtered (stream
, "@%s", address_space_id
);
443 did_print_modifier
= 1;
446 if (did_print_modifier
&& need_post_space
)
447 fprintf_filtered (stream
, " ");
451 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
452 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
453 in non-static methods, are displayed if LINKAGE_NAME is zero. If
454 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
455 parameter types get removed their possible const and volatile qualifiers to
456 match demangled linkage name parameters part of such function type.
457 LANGUAGE is the language in which TYPE was defined. This is a necessary
458 evil since this code is used by the C, C++, and Java backends. */
461 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
462 int linkage_name
, enum language language
,
463 const struct type_print_options
*flags
)
468 fprintf_filtered (stream
, "(");
470 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
472 struct type
*param_type
;
474 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
479 fprintf_filtered (stream
, ", ");
483 param_type
= TYPE_FIELD_TYPE (type
, i
);
485 if (language
== language_cplus
&& linkage_name
)
487 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
488 - Parameter declarations that differ only in the presence or
489 absence of const and/or volatile are equivalent.
491 And the const/volatile qualifiers are not present in the mangled
492 names as produced by GCC. */
494 param_type
= make_cv_type (0, 0, param_type
, NULL
);
497 if (language
== language_java
)
498 java_print_type (param_type
, "", stream
, -1, 0, flags
);
500 c_print_type (param_type
, "", stream
, -1, 0, flags
);
504 if (printed_any
&& TYPE_VARARGS (type
))
506 /* Print out a trailing ellipsis for varargs functions. Ignore
507 TYPE_VARARGS if the function has no named arguments; that
508 represents unprototyped (K&R style) C functions. */
509 if (printed_any
&& TYPE_VARARGS (type
))
511 fprintf_filtered (stream
, ", ");
513 fprintf_filtered (stream
, "...");
516 else if (!printed_any
517 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
518 || language
== language_cplus
))
519 fprintf_filtered (stream
, "void");
521 fprintf_filtered (stream
, ")");
524 /* Return true iff the j'th overloading of the i'th method of TYPE
525 is a type conversion operator, like `operator int () { ... }'.
526 When listing a class's methods, we don't print the return type of
530 is_type_conversion_operator (struct type
*type
, int i
, int j
)
532 /* I think the whole idea of recognizing type conversion operators
533 by their name is pretty terrible. But I don't think our present
534 data structure gives us any other way to tell. If you know of
535 some other way, feel free to rewrite this function. */
536 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
538 if (strncmp (name
, "operator", 8) != 0)
542 if (! strchr (" \t\f\n\r", *name
))
545 while (strchr (" \t\f\n\r", *name
))
548 if (!('a' <= *name
&& *name
<= 'z')
549 && !('A' <= *name
&& *name
<= 'Z')
551 /* If this doesn't look like the start of an identifier, then it
552 isn't a type conversion operator. */
554 else if (strncmp (name
, "new", 3) == 0)
556 else if (strncmp (name
, "delete", 6) == 0)
559 /* If it doesn't look like new or delete, it's a type conversion
563 /* Is that really the end of the name? */
564 if (('a' <= *name
&& *name
<= 'z')
565 || ('A' <= *name
&& *name
<= 'Z')
566 || ('0' <= *name
&& *name
<= '9')
568 /* No, so the identifier following "operator" must be a type name,
569 and this is a type conversion operator. */
572 /* That was indeed the end of the name, so it was `operator new' or
573 `operator delete', neither of which are type conversion
578 /* Given a C++ qualified identifier QID, strip off the qualifiers,
579 yielding the unqualified name. The return value is a pointer into
582 It's a pity we don't have this information in some more structured
583 form. Even the author of this function feels that writing little
584 parsers like this everywhere is stupid. */
587 remove_qualifiers (char *qid
)
589 int quoted
= 0; /* Zero if we're not in quotes;
590 '"' if we're in a double-quoted string;
591 '\'' if we're in a single-quoted string. */
592 int depth
= 0; /* Number of unclosed parens we've seen. */
593 char *parenstack
= (char *) alloca (strlen (qid
));
595 char *last
= 0; /* The character after the rightmost
596 `::' token we've seen so far. */
598 for (scan
= qid
; *scan
; scan
++)
604 else if (*scan
== '\\' && *(scan
+ 1))
607 else if (scan
[0] == ':' && scan
[1] == ':')
609 /* If we're inside parenthesis (i.e., an argument list) or
610 angle brackets (i.e., a list of template arguments), then
611 we don't record the position of this :: token, since it's
612 not relevant to the top-level structure we're trying to
620 else if (*scan
== '"' || *scan
== '\'')
622 else if (*scan
== '(')
623 parenstack
[depth
++] = ')';
624 else if (*scan
== '[')
625 parenstack
[depth
++] = ']';
626 /* We're going to treat <> as a pair of matching characters,
627 since we're more likely to see those in template id's than
628 real less-than characters. What a crock. */
629 else if (*scan
== '<')
630 parenstack
[depth
++] = '>';
631 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
633 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
637 /* We're going to do a little error recovery here. If
638 we don't find a match for *scan on the paren stack,
639 but there is something lower on the stack that does
640 match, we pop the stack to that point. */
643 for (i
= depth
- 1; i
>= 0; i
--)
644 if (parenstack
[i
] == *scan
)
656 /* We didn't find any :: tokens at the top level, so declare the
657 whole thing an unqualified identifier. */
661 /* Print any array sizes, function arguments or close parentheses
662 needed after the variable name (to describe its type).
663 Args work like c_type_print_varspec_prefix. */
666 c_type_print_varspec_suffix (struct type
*type
,
667 struct ui_file
*stream
,
668 int show
, int passed_a_ptr
,
670 const struct type_print_options
*flags
)
675 if (TYPE_NAME (type
) && show
<= 0)
680 switch (TYPE_CODE (type
))
682 case TYPE_CODE_ARRAY
:
684 LONGEST low_bound
, high_bound
;
685 int is_vector
= TYPE_VECTOR (type
);
688 fprintf_filtered (stream
, ")");
690 fprintf_filtered (stream
, (is_vector
?
691 " __attribute__ ((vector_size(" : "["));
692 /* Bounds are not yet resolved, print a bounds placeholder instead. */
693 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
694 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
695 fprintf_filtered (stream
, "variable length");
696 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
697 fprintf_filtered (stream
, "%s",
698 plongest (high_bound
- low_bound
+ 1));
699 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
701 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
706 case TYPE_CODE_MEMBERPTR
:
707 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
711 case TYPE_CODE_METHODPTR
:
712 fprintf_filtered (stream
, ")");
713 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
719 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
723 case TYPE_CODE_METHOD
:
726 fprintf_filtered (stream
, ")");
728 c_type_print_args (type
, stream
, 0, current_language
->la_language
,
730 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
731 show
, passed_a_ptr
, 0, flags
);
734 case TYPE_CODE_TYPEDEF
:
735 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
736 show
, passed_a_ptr
, 0, flags
);
739 case TYPE_CODE_UNDEF
:
740 case TYPE_CODE_STRUCT
:
741 case TYPE_CODE_UNION
:
746 case TYPE_CODE_ERROR
:
750 case TYPE_CODE_RANGE
:
751 case TYPE_CODE_STRING
:
752 case TYPE_CODE_COMPLEX
:
753 case TYPE_CODE_NAMESPACE
:
754 case TYPE_CODE_DECFLOAT
:
755 /* These types do not need a suffix. They are listed so that
756 gcc -Wall will report types that may not have been
760 error (_("type not handled in c_type_print_varspec_suffix()"));
765 /* A helper for c_type_print_base that displays template
766 parameters and their bindings, if needed.
768 TABLE is the local bindings table to use. If NULL, no printing is
769 done. Note that, at this point, TABLE won't have any useful
770 information in it -- but it is also used as a flag to
771 print_name_maybe_canonical to activate searching the global typedef
774 TYPE is the type whose template arguments are being displayed.
776 STREAM is the stream on which to print. */
779 c_type_print_template_args (const struct type_print_options
*flags
,
780 struct type
*type
, struct ui_file
*stream
)
787 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
789 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
791 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
797 fprintf_filtered (stream
, _("[with %s = "),
798 SYMBOL_LINKAGE_NAME (sym
));
803 fputs_filtered (", ", stream
);
805 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
808 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
812 fputs_filtered (_("] "), stream
);
815 /* Print the name of the type (or the ultimate pointer target,
816 function value or array element), or the description of a structure
819 SHOW positive means print details about the type (e.g. enum
820 values), and print structure elements passing SHOW - 1 for show.
822 SHOW negative means just print the type name or struct tag if there
823 is one. If there is no name, print something sensible but concise
826 SHOW zero means just print the type name or struct tag if there is
827 one. If there is no name, print something sensible but not as
828 concise like "struct {int x; int y;}".
830 LEVEL is the number of spaces to indent by.
831 We increase it for some recursive calls. */
834 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
835 int show
, int level
, const struct type_print_options
*flags
)
841 s_none
, s_public
, s_private
, s_protected
844 int need_access_label
= 0;
851 fputs_filtered (_("<type unknown>"), stream
);
855 /* When SHOW is zero or less, and there is a valid type name, then
856 always just print the type name directly from the type. */
857 /* If we have "typedef struct foo {. . .} bar;" do we want to print
858 it as "struct foo" or as "bar"? Pick the latter, because C++
859 folk tend to expect things like "class5 *foo" rather than "struct
863 && TYPE_NAME (type
) != NULL
)
865 c_type_print_modifier (type
, stream
, 0, 1);
866 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
870 CHECK_TYPEDEF (type
);
872 switch (TYPE_CODE (type
))
874 case TYPE_CODE_TYPEDEF
:
875 /* If we get here, the typedef doesn't have a name, and we
876 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
877 gdb_assert (TYPE_NAME (type
) == NULL
);
878 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
879 fprintf_filtered (stream
, _("<unnamed typedef>"));
882 case TYPE_CODE_ARRAY
:
884 case TYPE_CODE_MEMBERPTR
:
887 case TYPE_CODE_METHOD
:
888 case TYPE_CODE_METHODPTR
:
889 c_type_print_base (TYPE_TARGET_TYPE (type
),
890 stream
, show
, level
, flags
);
893 case TYPE_CODE_STRUCT
:
894 case TYPE_CODE_UNION
:
896 struct type_print_options local_flags
= *flags
;
897 struct type_print_options semi_local_flags
= *flags
;
898 struct cleanup
*local_cleanups
= make_cleanup (null_cleanup
, NULL
);
900 local_flags
.local_typedefs
= NULL
;
901 semi_local_flags
.local_typedefs
= NULL
;
905 if (flags
->local_typedefs
)
906 local_flags
.local_typedefs
907 = copy_typedef_hash (flags
->local_typedefs
);
909 local_flags
.local_typedefs
= create_typedef_hash ();
911 make_cleanup_free_typedef_hash (local_flags
.local_typedefs
);
914 c_type_print_modifier (type
, stream
, 0, 1);
915 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
916 fprintf_filtered (stream
, "union ");
917 else if (TYPE_DECLARED_CLASS (type
))
918 fprintf_filtered (stream
, "class ");
920 fprintf_filtered (stream
, "struct ");
922 /* Print the tag if it exists. The HP aCC compiler emits a
923 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
924 enum}" tag for unnamed struct/union/enum's, which we don't
926 if (TYPE_TAG_NAME (type
) != NULL
927 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
929 /* When printing the tag name, we are still effectively
930 printing in the outer context, hence the use of FLAGS
932 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
934 fputs_filtered (" ", stream
);
939 /* If we just printed a tag name, no need to print anything
941 if (TYPE_TAG_NAME (type
) == NULL
)
942 fprintf_filtered (stream
, "{...}");
944 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
946 struct type
*basetype
;
949 c_type_print_template_args (&local_flags
, type
, stream
);
951 /* Add in template parameters when printing derivation info. */
952 add_template_parameters (local_flags
.local_typedefs
, type
);
953 cp_type_print_derivation_info (stream
, type
, &local_flags
);
955 /* This holds just the global typedefs and the template
957 semi_local_flags
.local_typedefs
958 = copy_typedef_hash (local_flags
.local_typedefs
);
959 if (semi_local_flags
.local_typedefs
)
960 make_cleanup_free_typedef_hash (semi_local_flags
.local_typedefs
);
962 /* Now add in the local typedefs. */
963 recursively_update_typedef_hash (local_flags
.local_typedefs
, type
);
965 fprintf_filtered (stream
, "{\n");
966 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
967 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
969 if (TYPE_STUB (type
))
970 fprintfi_filtered (level
+ 4, stream
,
971 _("<incomplete type>\n"));
973 fprintfi_filtered (level
+ 4, stream
,
974 _("<no data fields>\n"));
977 /* Start off with no specific section type, so we can print
978 one for the first field we find, and use that section type
979 thereafter until we find another type. */
981 section_type
= s_none
;
983 /* For a class, if all members are private, there's no need
984 for a "private:" label; similarly, for a struct or union
985 masquerading as a class, if all members are public, there's
986 no need for a "public:" label. */
988 if (TYPE_DECLARED_CLASS (type
))
991 len
= TYPE_NFIELDS (type
);
992 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
993 if (!TYPE_FIELD_PRIVATE (type
, i
))
995 need_access_label
= 1;
999 if (!need_access_label
)
1001 len2
= TYPE_NFN_FIELDS (type
);
1002 for (j
= 0; j
< len2
; j
++)
1004 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1005 for (i
= 0; i
< len
; i
++)
1006 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1009 need_access_label
= 1;
1012 if (need_access_label
)
1020 len
= TYPE_NFIELDS (type
);
1021 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1022 if (TYPE_FIELD_PRIVATE (type
, i
)
1023 || TYPE_FIELD_PROTECTED (type
, i
))
1025 need_access_label
= 1;
1029 if (!need_access_label
)
1031 len2
= TYPE_NFN_FIELDS (type
);
1032 for (j
= 0; j
< len2
; j
++)
1035 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1036 for (i
= 0; i
< len
; i
++)
1037 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
1039 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1043 need_access_label
= 1;
1046 if (need_access_label
)
1052 /* If there is a base class for this type,
1053 do not print the field that it occupies. */
1055 len
= TYPE_NFIELDS (type
);
1056 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1057 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1061 /* If we have a virtual table pointer, omit it. Even if
1062 virtual table pointers are not specifically marked in
1063 the debug info, they should be artificial. */
1064 if ((i
== vptr_fieldno
&& type
== basetype
)
1065 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1068 if (need_access_label
)
1070 if (TYPE_FIELD_PROTECTED (type
, i
))
1072 if (section_type
!= s_protected
)
1074 section_type
= s_protected
;
1075 fprintfi_filtered (level
+ 2, stream
,
1079 else if (TYPE_FIELD_PRIVATE (type
, i
))
1081 if (section_type
!= s_private
)
1083 section_type
= s_private
;
1084 fprintfi_filtered (level
+ 2, stream
,
1090 if (section_type
!= s_public
)
1092 section_type
= s_public
;
1093 fprintfi_filtered (level
+ 2, stream
,
1099 print_spaces_filtered (level
+ 4, stream
);
1100 if (field_is_static (&TYPE_FIELD (type
, i
)))
1101 fprintf_filtered (stream
, "static ");
1102 c_print_type (TYPE_FIELD_TYPE (type
, i
),
1103 TYPE_FIELD_NAME (type
, i
),
1104 stream
, show
- 1, level
+ 4,
1106 if (!field_is_static (&TYPE_FIELD (type
, i
))
1107 && TYPE_FIELD_PACKED (type
, i
))
1109 /* It is a bitfield. This code does not attempt
1110 to look at the bitpos and reconstruct filler,
1111 unnamed fields. This would lead to misleading
1112 results if the compiler does not put out fields
1113 for such things (I don't know what it does). */
1114 fprintf_filtered (stream
, " : %d",
1115 TYPE_FIELD_BITSIZE (type
, i
));
1117 fprintf_filtered (stream
, ";\n");
1120 /* If there are both fields and methods, put a blank line
1121 between them. Make sure to count only method that we
1122 will display; artificial methods will be hidden. */
1123 len
= TYPE_NFN_FIELDS (type
);
1124 if (!flags
->print_methods
)
1127 for (i
= 0; i
< len
; i
++)
1129 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1130 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1133 for (j
= 0; j
< len2
; j
++)
1134 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1137 if (real_len
> 0 && section_type
!= s_none
)
1138 fprintf_filtered (stream
, "\n");
1140 /* C++: print out the methods. */
1141 for (i
= 0; i
< len
; i
++)
1143 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1144 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1145 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1146 const char *name
= type_name_no_tag (type
);
1147 int is_constructor
= name
&& strcmp (method_name
,
1150 for (j
= 0; j
< len2
; j
++)
1152 const char *mangled_name
;
1153 char *demangled_name
;
1154 struct cleanup
*inner_cleanup
;
1155 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1156 int is_full_physname_constructor
=
1157 TYPE_FN_FIELD_CONSTRUCTOR (f
, j
)
1158 || is_constructor_name (physname
)
1159 || is_destructor_name (physname
)
1160 || method_name
[0] == '~';
1162 /* Do not print out artificial methods. */
1163 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1166 inner_cleanup
= make_cleanup (null_cleanup
, NULL
);
1169 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1171 if (section_type
!= s_protected
)
1173 section_type
= s_protected
;
1174 fprintfi_filtered (level
+ 2, stream
,
1178 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1180 if (section_type
!= s_private
)
1182 section_type
= s_private
;
1183 fprintfi_filtered (level
+ 2, stream
,
1189 if (section_type
!= s_public
)
1191 section_type
= s_public
;
1192 fprintfi_filtered (level
+ 2, stream
,
1197 print_spaces_filtered (level
+ 4, stream
);
1198 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1199 fprintf_filtered (stream
, "virtual ");
1200 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1201 fprintf_filtered (stream
, "static ");
1202 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1204 /* Keep GDB from crashing here. */
1205 fprintf_filtered (stream
,
1206 _("<undefined type> %s;\n"),
1207 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1210 else if (!is_constructor
/* Constructors don't
1213 && !is_full_physname_constructor
/* " " */
1214 && !is_type_conversion_operator (type
, i
, j
))
1216 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1219 fputs_filtered (" ", stream
);
1221 if (TYPE_FN_FIELD_STUB (f
, j
))
1225 /* Build something we can demangle. */
1226 tem
= gdb_mangle_name (type
, i
, j
);
1227 make_cleanup (xfree
, tem
);
1231 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1234 gdb_demangle (mangled_name
,
1235 DMGL_ANSI
| DMGL_PARAMS
);
1236 if (demangled_name
== NULL
)
1238 /* In some cases (for instance with the HP
1239 demangling), if a function has more than 10
1240 arguments, the demangling will fail.
1241 Let's try to reconstruct the function
1242 signature from the symbol information. */
1243 if (!TYPE_FN_FIELD_STUB (f
, j
))
1245 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1246 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1248 cp_type_print_method_args (mtype
,
1252 stream
, &local_flags
);
1255 fprintf_filtered (stream
,
1256 _("<badly mangled name '%s'>"),
1262 char *demangled_no_class
1263 = remove_qualifiers (demangled_name
);
1265 /* Get rid of the `static' appended by the
1267 p
= strstr (demangled_no_class
, " static");
1270 int length
= p
- demangled_no_class
;
1271 char *demangled_no_static
;
1274 = (char *) xmalloc (length
+ 1);
1275 strncpy (demangled_no_static
,
1276 demangled_no_class
, length
);
1277 *(demangled_no_static
+ length
) = '\0';
1278 fputs_filtered (demangled_no_static
, stream
);
1279 xfree (demangled_no_static
);
1282 fputs_filtered (demangled_no_class
, stream
);
1283 xfree (demangled_name
);
1286 do_cleanups (inner_cleanup
);
1288 fprintf_filtered (stream
, ";\n");
1292 /* Print typedefs defined in this class. */
1294 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1296 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1297 fprintf_filtered (stream
, "\n");
1299 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1301 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1303 /* Dereference the typedef declaration itself. */
1304 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1305 target
= TYPE_TARGET_TYPE (target
);
1307 print_spaces_filtered (level
+ 4, stream
);
1308 fprintf_filtered (stream
, "typedef ");
1310 /* We want to print typedefs with substitutions
1311 from the template parameters or globally-known
1312 typedefs but not local typedefs. */
1313 c_print_type (target
,
1314 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1315 stream
, show
- 1, level
+ 4,
1317 fprintf_filtered (stream
, ";\n");
1321 fprintfi_filtered (level
, stream
, "}");
1324 do_cleanups (local_cleanups
);
1328 case TYPE_CODE_ENUM
:
1329 c_type_print_modifier (type
, stream
, 0, 1);
1330 fprintf_filtered (stream
, "enum ");
1331 if (TYPE_DECLARED_CLASS (type
))
1332 fprintf_filtered (stream
, "class ");
1333 /* Print the tag name if it exists.
1334 The aCC compiler emits a spurious
1335 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1336 tag for unnamed struct/union/enum's, which we don't
1338 if (TYPE_TAG_NAME (type
) != NULL
1339 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1341 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
1343 fputs_filtered (" ", stream
);
1349 /* If we just printed a tag name, no need to print anything
1351 if (TYPE_TAG_NAME (type
) == NULL
)
1352 fprintf_filtered (stream
, "{...}");
1354 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1356 LONGEST lastval
= 0;
1358 /* We can't handle this case perfectly, as DWARF does not
1359 tell us whether or not the underlying type was specified
1360 in the source (and other debug formats don't provide this
1361 at all). We choose to print the underlying type, if it
1362 has a name, when in C++ on the theory that it's better to
1363 print too much than too little; but conversely not to
1364 print something egregiously outside the current
1365 language's syntax. */
1366 if (current_language
->la_language
== language_cplus
1367 && TYPE_TARGET_TYPE (type
) != NULL
)
1369 struct type
*underlying
= check_typedef (TYPE_TARGET_TYPE (type
));
1371 if (TYPE_NAME (underlying
) != NULL
)
1372 fprintf_filtered (stream
, ": %s ", TYPE_NAME (underlying
));
1375 fprintf_filtered (stream
, "{");
1376 len
= TYPE_NFIELDS (type
);
1377 for (i
= 0; i
< len
; i
++)
1381 fprintf_filtered (stream
, ", ");
1383 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1384 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1386 fprintf_filtered (stream
, " = %s",
1387 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1388 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1392 fprintf_filtered (stream
, "}");
1396 case TYPE_CODE_VOID
:
1397 fprintf_filtered (stream
, "void");
1400 case TYPE_CODE_UNDEF
:
1401 fprintf_filtered (stream
, _("struct <unknown>"));
1404 case TYPE_CODE_ERROR
:
1405 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1408 case TYPE_CODE_RANGE
:
1409 /* This should not occur. */
1410 fprintf_filtered (stream
, _("<range type>"));
1413 case TYPE_CODE_NAMESPACE
:
1414 fputs_filtered ("namespace ", stream
);
1415 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1419 /* Handle types not explicitly handled by the other cases, such
1420 as fundamental types. For these, just print whatever the
1421 type name is, as recorded in the type itself. If there is no
1422 type name, then complain. */
1423 if (TYPE_NAME (type
) != NULL
)
1425 c_type_print_modifier (type
, stream
, 0, 1);
1426 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1430 /* At least for dump_symtab, it is important that this not
1432 fprintf_filtered (stream
, _("<invalid type code %d>"),