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
? s
: name
, stream
);
76 /* LEVEL is the depth to indent lines by. */
79 c_print_type (struct type
*type
,
80 const char *varstring
,
81 struct ui_file
*stream
,
83 const struct type_print_options
*flags
)
88 const char *local_name
;
91 type
= check_typedef (type
);
93 local_name
= find_typedef_in_hash (flags
, type
);
94 if (local_name
!= NULL
)
96 fputs_filtered (local_name
, stream
);
97 if (varstring
!= NULL
&& *varstring
!= '\0')
98 fputs_filtered (" ", stream
);
102 c_type_print_base (type
, stream
, show
, level
, flags
);
103 code
= TYPE_CODE (type
);
104 if ((varstring
!= NULL
&& *varstring
!= '\0')
105 /* Need a space if going to print stars or brackets;
106 but not if we will print just a type name. */
107 || ((show
> 0 || TYPE_NAME (type
) == 0)
108 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
109 || code
== TYPE_CODE_METHOD
110 || (code
== TYPE_CODE_ARRAY
111 && !TYPE_VECTOR (type
))
112 || code
== TYPE_CODE_MEMBERPTR
113 || code
== TYPE_CODE_METHODPTR
114 || code
== TYPE_CODE_REF
)))
115 fputs_filtered (" ", stream
);
116 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
117 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
121 if (varstring
!= NULL
)
123 fputs_filtered (varstring
, stream
);
125 /* For demangled function names, we have the arglist as part of
126 the name, so don't print an additional pair of ()'s. */
127 if (local_name
== NULL
)
129 demangled_args
= strchr (varstring
, '(') != NULL
;
130 c_type_print_varspec_suffix (type
, stream
, show
,
137 /* Print a typedef using C syntax. TYPE is the underlying type.
138 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
142 c_print_typedef (struct type
*type
,
143 struct symbol
*new_symbol
,
144 struct ui_file
*stream
)
146 type
= check_typedef (type
);
147 fprintf_filtered (stream
, "typedef ");
148 type_print (type
, "", stream
, 0);
149 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
150 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
151 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
152 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
153 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
154 fprintf_filtered (stream
, ";\n");
157 /* If TYPE is a derived type, then print out derivation information.
158 Print only the actual base classes of this type, not the base
159 classes of the base classes. I.e. for the derivation hierarchy:
162 class B : public A {int b; };
163 class C : public B {int c; };
165 Print the type of class C as:
171 Not as the following (like gdb used to), which is not legal C++
172 syntax for derived types and may be confused with the multiple
175 class C : public B : public A {
179 In general, gdb should try to print the types as closely as
180 possible to the form that they appear in the source code. */
183 cp_type_print_derivation_info (struct ui_file
*stream
,
185 const struct type_print_options
*flags
)
190 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
193 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
194 fprintf_filtered (stream
, "%s%s ",
195 BASETYPE_VIA_PUBLIC (type
, i
)
196 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
197 ? "protected" : "private"),
198 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
199 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
201 print_name_maybe_canonical (name
, flags
, stream
);
203 fprintf_filtered (stream
, "(null)");
207 fputs_filtered (" ", stream
);
211 /* Print the C++ method arguments ARGS to the file STREAM. */
214 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
215 const char *varstring
, int staticp
,
216 struct ui_file
*stream
,
217 const struct type_print_options
*flags
)
219 struct field
*args
= TYPE_FIELDS (mtype
);
220 int nargs
= TYPE_NFIELDS (mtype
);
221 int varargs
= TYPE_VARARGS (mtype
);
224 fprintf_symbol_filtered (stream
, prefix
,
225 language_cplus
, DMGL_ANSI
);
226 fprintf_symbol_filtered (stream
, varstring
,
227 language_cplus
, DMGL_ANSI
);
228 fputs_filtered ("(", stream
);
230 /* Skip the class variable. */
236 c_print_type (args
[i
++].type
, "", stream
, 0, 0, flags
);
238 if (i
== nargs
&& varargs
)
239 fprintf_filtered (stream
, ", ...");
242 fprintf_filtered (stream
, ", ");
248 fprintf_filtered (stream
, "...");
249 else if (current_language
->la_language
== language_cplus
)
250 fprintf_filtered (stream
, "void");
252 fprintf_filtered (stream
, ")");
254 /* For non-static methods, read qualifiers from the type of
260 gdb_assert (nargs
> 0);
261 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
262 domain
= TYPE_TARGET_TYPE (args
[0].type
);
264 if (TYPE_CONST (domain
))
265 fprintf_filtered (stream
, " const");
267 if (TYPE_VOLATILE (domain
))
268 fprintf_filtered (stream
, " volatile");
270 if (TYPE_RESTRICT (domain
))
271 fprintf_filtered (stream
, " restrict");
273 if (TYPE_ATOMIC (domain
))
274 fprintf_filtered (stream
, " _Atomic");
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_SELF_TYPE (type
));
322 print_name_maybe_canonical (name
, flags
, stream
);
324 c_type_print_base (TYPE_SELF_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_SELF_TYPE (type
));
335 print_name_maybe_canonical (name
, flags
, stream
);
337 c_type_print_base (TYPE_SELF_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
:
373 case TYPE_CODE_FLAGS
:
377 case TYPE_CODE_ERROR
:
381 case TYPE_CODE_RANGE
:
382 case TYPE_CODE_STRING
:
383 case TYPE_CODE_COMPLEX
:
384 case TYPE_CODE_NAMESPACE
:
385 case TYPE_CODE_DECFLOAT
:
386 /* These types need no prefix. They are listed here so that
387 gcc -Wall will reveal any types that haven't been handled. */
390 error (_("type not handled in c_type_print_varspec_prefix()"));
395 /* Print out "const" and "volatile" attributes,
396 and address space id if present.
397 TYPE is a pointer to the type being printed out.
398 STREAM is the output destination.
399 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
400 NEED_POST_SPACE = 1 indicates a final white space is needed. */
403 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
404 int need_pre_space
, int need_post_space
)
406 int did_print_modifier
= 0;
407 const char *address_space_id
;
409 /* We don't print `const' qualifiers for references --- since all
410 operators affect the thing referenced, not the reference itself,
411 every reference is `const'. */
412 if (TYPE_CONST (type
)
413 && TYPE_CODE (type
) != TYPE_CODE_REF
)
416 fprintf_filtered (stream
, " ");
417 fprintf_filtered (stream
, "const");
418 did_print_modifier
= 1;
421 if (TYPE_VOLATILE (type
))
423 if (did_print_modifier
|| need_pre_space
)
424 fprintf_filtered (stream
, " ");
425 fprintf_filtered (stream
, "volatile");
426 did_print_modifier
= 1;
429 if (TYPE_RESTRICT (type
))
431 if (did_print_modifier
|| need_pre_space
)
432 fprintf_filtered (stream
, " ");
433 fprintf_filtered (stream
, "restrict");
434 did_print_modifier
= 1;
437 if (TYPE_ATOMIC (type
))
439 if (did_print_modifier
|| need_pre_space
)
440 fprintf_filtered (stream
, " ");
441 fprintf_filtered (stream
, "_Atomic");
442 did_print_modifier
= 1;
445 address_space_id
= address_space_int_to_name (get_type_arch (type
),
446 TYPE_INSTANCE_FLAGS (type
));
447 if (address_space_id
)
449 if (did_print_modifier
|| need_pre_space
)
450 fprintf_filtered (stream
, " ");
451 fprintf_filtered (stream
, "@%s", address_space_id
);
452 did_print_modifier
= 1;
455 if (did_print_modifier
&& need_post_space
)
456 fprintf_filtered (stream
, " ");
460 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
461 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
462 in non-static methods, are displayed if LINKAGE_NAME is zero. If
463 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
464 parameter types get removed their possible const and volatile qualifiers to
465 match demangled linkage name parameters part of such function type.
466 LANGUAGE is the language in which TYPE was defined. This is a necessary
467 evil since this code is used by the C and C++. */
470 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
471 int linkage_name
, enum language language
,
472 const struct type_print_options
*flags
)
477 fprintf_filtered (stream
, "(");
479 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
481 struct type
*param_type
;
483 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
488 fprintf_filtered (stream
, ", ");
492 param_type
= TYPE_FIELD_TYPE (type
, i
);
494 if (language
== language_cplus
&& linkage_name
)
496 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
497 - Parameter declarations that differ only in the presence or
498 absence of const and/or volatile are equivalent.
500 And the const/volatile qualifiers are not present in the mangled
501 names as produced by GCC. */
503 param_type
= make_cv_type (0, 0, param_type
, NULL
);
506 c_print_type (param_type
, "", stream
, -1, 0, flags
);
510 if (printed_any
&& TYPE_VARARGS (type
))
512 /* Print out a trailing ellipsis for varargs functions. Ignore
513 TYPE_VARARGS if the function has no named arguments; that
514 represents unprototyped (K&R style) C functions. */
515 if (printed_any
&& TYPE_VARARGS (type
))
517 fprintf_filtered (stream
, ", ");
519 fprintf_filtered (stream
, "...");
522 else if (!printed_any
523 && (TYPE_PROTOTYPED (type
) || language
== language_cplus
))
524 fprintf_filtered (stream
, "void");
526 fprintf_filtered (stream
, ")");
529 /* Return true iff the j'th overloading of the i'th method of TYPE
530 is a type conversion operator, like `operator int () { ... }'.
531 When listing a class's methods, we don't print the return type of
535 is_type_conversion_operator (struct type
*type
, int i
, int j
)
537 /* I think the whole idea of recognizing type conversion operators
538 by their name is pretty terrible. But I don't think our present
539 data structure gives us any other way to tell. If you know of
540 some other way, feel free to rewrite this function. */
541 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
543 if (!startswith (name
, "operator"))
547 if (! strchr (" \t\f\n\r", *name
))
550 while (strchr (" \t\f\n\r", *name
))
553 if (!('a' <= *name
&& *name
<= 'z')
554 && !('A' <= *name
&& *name
<= 'Z')
556 /* If this doesn't look like the start of an identifier, then it
557 isn't a type conversion operator. */
559 else if (startswith (name
, "new"))
561 else if (startswith (name
, "delete"))
564 /* If it doesn't look like new or delete, it's a type conversion
568 /* Is that really the end of the name? */
569 if (('a' <= *name
&& *name
<= 'z')
570 || ('A' <= *name
&& *name
<= 'Z')
571 || ('0' <= *name
&& *name
<= '9')
573 /* No, so the identifier following "operator" must be a type name,
574 and this is a type conversion operator. */
577 /* That was indeed the end of the name, so it was `operator new' or
578 `operator delete', neither of which are type conversion
583 /* Given a C++ qualified identifier QID, strip off the qualifiers,
584 yielding the unqualified name. The return value is a pointer into
587 It's a pity we don't have this information in some more structured
588 form. Even the author of this function feels that writing little
589 parsers like this everywhere is stupid. */
592 remove_qualifiers (char *qid
)
594 int quoted
= 0; /* Zero if we're not in quotes;
595 '"' if we're in a double-quoted string;
596 '\'' if we're in a single-quoted string. */
597 int depth
= 0; /* Number of unclosed parens we've seen. */
598 char *parenstack
= (char *) alloca (strlen (qid
));
600 char *last
= 0; /* The character after the rightmost
601 `::' token we've seen so far. */
603 for (scan
= qid
; *scan
; scan
++)
609 else if (*scan
== '\\' && *(scan
+ 1))
612 else if (scan
[0] == ':' && scan
[1] == ':')
614 /* If we're inside parenthesis (i.e., an argument list) or
615 angle brackets (i.e., a list of template arguments), then
616 we don't record the position of this :: token, since it's
617 not relevant to the top-level structure we're trying to
625 else if (*scan
== '"' || *scan
== '\'')
627 else if (*scan
== '(')
628 parenstack
[depth
++] = ')';
629 else if (*scan
== '[')
630 parenstack
[depth
++] = ']';
631 /* We're going to treat <> as a pair of matching characters,
632 since we're more likely to see those in template id's than
633 real less-than characters. What a crock. */
634 else if (*scan
== '<')
635 parenstack
[depth
++] = '>';
636 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
638 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
642 /* We're going to do a little error recovery here. If
643 we don't find a match for *scan on the paren stack,
644 but there is something lower on the stack that does
645 match, we pop the stack to that point. */
648 for (i
= depth
- 1; i
>= 0; i
--)
649 if (parenstack
[i
] == *scan
)
661 /* We didn't find any :: tokens at the top level, so declare the
662 whole thing an unqualified identifier. */
666 /* Print any array sizes, function arguments or close parentheses
667 needed after the variable name (to describe its type).
668 Args work like c_type_print_varspec_prefix. */
671 c_type_print_varspec_suffix (struct type
*type
,
672 struct ui_file
*stream
,
673 int show
, int passed_a_ptr
,
675 const struct type_print_options
*flags
)
680 if (TYPE_NAME (type
) && show
<= 0)
685 switch (TYPE_CODE (type
))
687 case TYPE_CODE_ARRAY
:
689 LONGEST low_bound
, high_bound
;
690 int is_vector
= TYPE_VECTOR (type
);
693 fprintf_filtered (stream
, ")");
695 fprintf_filtered (stream
, (is_vector
?
696 " __attribute__ ((vector_size(" : "["));
697 /* Bounds are not yet resolved, print a bounds placeholder instead. */
698 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
699 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
700 fprintf_filtered (stream
, "variable length");
701 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
702 fprintf_filtered (stream
, "%s",
703 plongest (high_bound
- low_bound
+ 1));
704 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
706 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
711 case TYPE_CODE_MEMBERPTR
:
712 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
716 case TYPE_CODE_METHODPTR
:
717 fprintf_filtered (stream
, ")");
718 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
724 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
728 case TYPE_CODE_METHOD
:
731 fprintf_filtered (stream
, ")");
733 c_type_print_args (type
, stream
, 0, current_language
->la_language
,
735 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
736 show
, passed_a_ptr
, 0, flags
);
739 case TYPE_CODE_TYPEDEF
:
740 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
741 show
, passed_a_ptr
, 0, flags
);
744 case TYPE_CODE_UNDEF
:
745 case TYPE_CODE_STRUCT
:
746 case TYPE_CODE_UNION
:
747 case TYPE_CODE_FLAGS
:
752 case TYPE_CODE_ERROR
:
756 case TYPE_CODE_RANGE
:
757 case TYPE_CODE_STRING
:
758 case TYPE_CODE_COMPLEX
:
759 case TYPE_CODE_NAMESPACE
:
760 case TYPE_CODE_DECFLOAT
:
761 /* These types do not need a suffix. They are listed so that
762 gcc -Wall will report types that may not have been
766 error (_("type not handled in c_type_print_varspec_suffix()"));
771 /* A helper for c_type_print_base that displays template
772 parameters and their bindings, if needed.
774 TABLE is the local bindings table to use. If NULL, no printing is
775 done. Note that, at this point, TABLE won't have any useful
776 information in it -- but it is also used as a flag to
777 print_name_maybe_canonical to activate searching the global typedef
780 TYPE is the type whose template arguments are being displayed.
782 STREAM is the stream on which to print. */
785 c_type_print_template_args (const struct type_print_options
*flags
,
786 struct type
*type
, struct ui_file
*stream
)
793 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
795 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
797 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
803 fprintf_filtered (stream
, _("[with %s = "),
804 SYMBOL_LINKAGE_NAME (sym
));
809 fputs_filtered (", ", stream
);
811 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
814 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
818 fputs_filtered (_("] "), stream
);
821 /* Print the name of the type (or the ultimate pointer target,
822 function value or array element), or the description of a structure
825 SHOW positive means print details about the type (e.g. enum
826 values), and print structure elements passing SHOW - 1 for show.
828 SHOW negative means just print the type name or struct tag if there
829 is one. If there is no name, print something sensible but concise
832 SHOW zero means just print the type name or struct tag if there is
833 one. If there is no name, print something sensible but not as
834 concise like "struct {int x; int y;}".
836 LEVEL is the number of spaces to indent by.
837 We increase it for some recursive calls. */
840 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
841 int show
, int level
, const struct type_print_options
*flags
)
847 s_none
, s_public
, s_private
, s_protected
850 int need_access_label
= 0;
857 fputs_filtered (_("<type unknown>"), stream
);
861 /* When SHOW is zero or less, and there is a valid type name, then
862 always just print the type name directly from the type. */
863 /* If we have "typedef struct foo {. . .} bar;" do we want to print
864 it as "struct foo" or as "bar"? Pick the latter, because C++
865 folk tend to expect things like "class5 *foo" rather than "struct
869 && TYPE_NAME (type
) != NULL
)
871 c_type_print_modifier (type
, stream
, 0, 1);
872 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
876 type
= check_typedef (type
);
878 switch (TYPE_CODE (type
))
880 case TYPE_CODE_TYPEDEF
:
881 /* If we get here, the typedef doesn't have a name, and we
882 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
883 gdb_assert (TYPE_NAME (type
) == NULL
);
884 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
885 fprintf_filtered (stream
, _("<unnamed typedef>"));
888 case TYPE_CODE_ARRAY
:
890 case TYPE_CODE_MEMBERPTR
:
893 case TYPE_CODE_METHOD
:
894 case TYPE_CODE_METHODPTR
:
895 c_type_print_base (TYPE_TARGET_TYPE (type
),
896 stream
, show
, level
, flags
);
899 case TYPE_CODE_STRUCT
:
900 case TYPE_CODE_UNION
:
902 struct type_print_options local_flags
= *flags
;
903 struct type_print_options semi_local_flags
= *flags
;
904 struct cleanup
*local_cleanups
= make_cleanup (null_cleanup
, NULL
);
906 local_flags
.local_typedefs
= NULL
;
907 semi_local_flags
.local_typedefs
= NULL
;
911 if (flags
->local_typedefs
)
912 local_flags
.local_typedefs
913 = copy_typedef_hash (flags
->local_typedefs
);
915 local_flags
.local_typedefs
= create_typedef_hash ();
917 make_cleanup_free_typedef_hash (local_flags
.local_typedefs
);
920 c_type_print_modifier (type
, stream
, 0, 1);
921 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
922 fprintf_filtered (stream
, "union ");
923 else if (TYPE_DECLARED_CLASS (type
))
924 fprintf_filtered (stream
, "class ");
926 fprintf_filtered (stream
, "struct ");
928 /* Print the tag if it exists. The HP aCC compiler emits a
929 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
930 enum}" tag for unnamed struct/union/enum's, which we don't
932 if (TYPE_TAG_NAME (type
) != NULL
933 && !startswith (TYPE_TAG_NAME (type
), "{unnamed"))
935 /* When printing the tag name, we are still effectively
936 printing in the outer context, hence the use of FLAGS
938 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
940 fputs_filtered (" ", stream
);
945 /* If we just printed a tag name, no need to print anything
947 if (TYPE_TAG_NAME (type
) == NULL
)
948 fprintf_filtered (stream
, "{...}");
950 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
952 struct type
*basetype
;
955 c_type_print_template_args (&local_flags
, type
, stream
);
957 /* Add in template parameters when printing derivation info. */
958 add_template_parameters (local_flags
.local_typedefs
, type
);
959 cp_type_print_derivation_info (stream
, type
, &local_flags
);
961 /* This holds just the global typedefs and the template
963 semi_local_flags
.local_typedefs
964 = copy_typedef_hash (local_flags
.local_typedefs
);
965 if (semi_local_flags
.local_typedefs
)
966 make_cleanup_free_typedef_hash (semi_local_flags
.local_typedefs
);
968 /* Now add in the local typedefs. */
969 recursively_update_typedef_hash (local_flags
.local_typedefs
, type
);
971 fprintf_filtered (stream
, "{\n");
972 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
973 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
975 if (TYPE_STUB (type
))
976 fprintfi_filtered (level
+ 4, stream
,
977 _("<incomplete type>\n"));
979 fprintfi_filtered (level
+ 4, stream
,
980 _("<no data fields>\n"));
983 /* Start off with no specific section type, so we can print
984 one for the first field we find, and use that section type
985 thereafter until we find another type. */
987 section_type
= s_none
;
989 /* For a class, if all members are private, there's no need
990 for a "private:" label; similarly, for a struct or union
991 masquerading as a class, if all members are public, there's
992 no need for a "public:" label. */
994 if (TYPE_DECLARED_CLASS (type
))
997 len
= TYPE_NFIELDS (type
);
998 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
999 if (!TYPE_FIELD_PRIVATE (type
, i
))
1001 need_access_label
= 1;
1005 if (!need_access_label
)
1007 len2
= TYPE_NFN_FIELDS (type
);
1008 for (j
= 0; j
< len2
; j
++)
1010 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1011 for (i
= 0; i
< len
; i
++)
1012 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1015 need_access_label
= 1;
1018 if (need_access_label
)
1026 len
= TYPE_NFIELDS (type
);
1027 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1028 if (TYPE_FIELD_PRIVATE (type
, i
)
1029 || TYPE_FIELD_PROTECTED (type
, i
))
1031 need_access_label
= 1;
1035 if (!need_access_label
)
1037 len2
= TYPE_NFN_FIELDS (type
);
1038 for (j
= 0; j
< len2
; j
++)
1041 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1042 for (i
= 0; i
< len
; i
++)
1043 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
1045 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1049 need_access_label
= 1;
1052 if (need_access_label
)
1058 /* If there is a base class for this type,
1059 do not print the field that it occupies. */
1061 len
= TYPE_NFIELDS (type
);
1062 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1063 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1067 /* If we have a virtual table pointer, omit it. Even if
1068 virtual table pointers are not specifically marked in
1069 the debug info, they should be artificial. */
1070 if ((i
== vptr_fieldno
&& type
== basetype
)
1071 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1074 if (need_access_label
)
1076 if (TYPE_FIELD_PROTECTED (type
, i
))
1078 if (section_type
!= s_protected
)
1080 section_type
= s_protected
;
1081 fprintfi_filtered (level
+ 2, stream
,
1085 else if (TYPE_FIELD_PRIVATE (type
, i
))
1087 if (section_type
!= s_private
)
1089 section_type
= s_private
;
1090 fprintfi_filtered (level
+ 2, stream
,
1096 if (section_type
!= s_public
)
1098 section_type
= s_public
;
1099 fprintfi_filtered (level
+ 2, stream
,
1105 print_spaces_filtered (level
+ 4, stream
);
1106 if (field_is_static (&TYPE_FIELD (type
, i
)))
1107 fprintf_filtered (stream
, "static ");
1108 c_print_type (TYPE_FIELD_TYPE (type
, i
),
1109 TYPE_FIELD_NAME (type
, i
),
1110 stream
, show
- 1, level
+ 4,
1112 if (!field_is_static (&TYPE_FIELD (type
, i
))
1113 && TYPE_FIELD_PACKED (type
, i
))
1115 /* It is a bitfield. This code does not attempt
1116 to look at the bitpos and reconstruct filler,
1117 unnamed fields. This would lead to misleading
1118 results if the compiler does not put out fields
1119 for such things (I don't know what it does). */
1120 fprintf_filtered (stream
, " : %d",
1121 TYPE_FIELD_BITSIZE (type
, i
));
1123 fprintf_filtered (stream
, ";\n");
1126 /* If there are both fields and methods, put a blank line
1127 between them. Make sure to count only method that we
1128 will display; artificial methods will be hidden. */
1129 len
= TYPE_NFN_FIELDS (type
);
1130 if (!flags
->print_methods
)
1133 for (i
= 0; i
< len
; i
++)
1135 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1136 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1139 for (j
= 0; j
< len2
; j
++)
1140 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1143 if (real_len
> 0 && section_type
!= s_none
)
1144 fprintf_filtered (stream
, "\n");
1146 /* C++: print out the methods. */
1147 for (i
= 0; i
< len
; i
++)
1149 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1150 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1151 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1152 const char *name
= type_name_no_tag (type
);
1153 int is_constructor
= name
&& strcmp (method_name
,
1156 for (j
= 0; j
< len2
; j
++)
1158 const char *mangled_name
;
1159 char *demangled_name
;
1160 struct cleanup
*inner_cleanup
;
1161 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1162 int is_full_physname_constructor
=
1163 TYPE_FN_FIELD_CONSTRUCTOR (f
, j
)
1164 || is_constructor_name (physname
)
1165 || is_destructor_name (physname
)
1166 || method_name
[0] == '~';
1168 /* Do not print out artificial methods. */
1169 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1172 inner_cleanup
= make_cleanup (null_cleanup
, NULL
);
1175 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1177 if (section_type
!= s_protected
)
1179 section_type
= s_protected
;
1180 fprintfi_filtered (level
+ 2, stream
,
1184 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1186 if (section_type
!= s_private
)
1188 section_type
= s_private
;
1189 fprintfi_filtered (level
+ 2, stream
,
1195 if (section_type
!= s_public
)
1197 section_type
= s_public
;
1198 fprintfi_filtered (level
+ 2, stream
,
1203 print_spaces_filtered (level
+ 4, stream
);
1204 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1205 fprintf_filtered (stream
, "virtual ");
1206 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1207 fprintf_filtered (stream
, "static ");
1208 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1210 /* Keep GDB from crashing here. */
1211 fprintf_filtered (stream
,
1212 _("<undefined type> %s;\n"),
1213 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1216 else if (!is_constructor
/* Constructors don't
1219 && !is_full_physname_constructor
/* " " */
1220 && !is_type_conversion_operator (type
, i
, j
))
1222 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1225 fputs_filtered (" ", stream
);
1227 if (TYPE_FN_FIELD_STUB (f
, j
))
1231 /* Build something we can demangle. */
1232 tem
= gdb_mangle_name (type
, i
, j
);
1233 make_cleanup (xfree
, tem
);
1237 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1240 gdb_demangle (mangled_name
,
1241 DMGL_ANSI
| DMGL_PARAMS
);
1242 if (demangled_name
== NULL
)
1244 /* In some cases (for instance with the HP
1245 demangling), if a function has more than 10
1246 arguments, the demangling will fail.
1247 Let's try to reconstruct the function
1248 signature from the symbol information. */
1249 if (!TYPE_FN_FIELD_STUB (f
, j
))
1251 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1252 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1254 cp_type_print_method_args (mtype
,
1258 stream
, &local_flags
);
1261 fprintf_filtered (stream
,
1262 _("<badly mangled name '%s'>"),
1268 char *demangled_no_class
1269 = remove_qualifiers (demangled_name
);
1271 /* Get rid of the `static' appended by the
1273 p
= strstr (demangled_no_class
, " static");
1276 int length
= p
- demangled_no_class
;
1277 char *demangled_no_static
;
1280 = (char *) xmalloc (length
+ 1);
1281 strncpy (demangled_no_static
,
1282 demangled_no_class
, length
);
1283 *(demangled_no_static
+ length
) = '\0';
1284 fputs_filtered (demangled_no_static
, stream
);
1285 xfree (demangled_no_static
);
1288 fputs_filtered (demangled_no_class
, stream
);
1289 xfree (demangled_name
);
1292 do_cleanups (inner_cleanup
);
1294 fprintf_filtered (stream
, ";\n");
1298 /* Print typedefs defined in this class. */
1300 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1302 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1303 fprintf_filtered (stream
, "\n");
1305 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1307 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1309 /* Dereference the typedef declaration itself. */
1310 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1311 target
= TYPE_TARGET_TYPE (target
);
1313 print_spaces_filtered (level
+ 4, stream
);
1314 fprintf_filtered (stream
, "typedef ");
1316 /* We want to print typedefs with substitutions
1317 from the template parameters or globally-known
1318 typedefs but not local typedefs. */
1319 c_print_type (target
,
1320 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1321 stream
, show
- 1, level
+ 4,
1323 fprintf_filtered (stream
, ";\n");
1327 fprintfi_filtered (level
, stream
, "}");
1330 do_cleanups (local_cleanups
);
1334 case TYPE_CODE_ENUM
:
1335 c_type_print_modifier (type
, stream
, 0, 1);
1336 fprintf_filtered (stream
, "enum ");
1337 if (TYPE_DECLARED_CLASS (type
))
1338 fprintf_filtered (stream
, "class ");
1339 /* Print the tag name if it exists.
1340 The aCC compiler emits a spurious
1341 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1342 tag for unnamed struct/union/enum's, which we don't
1344 if (TYPE_TAG_NAME (type
) != NULL
1345 && !startswith (TYPE_TAG_NAME (type
), "{unnamed"))
1347 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
1349 fputs_filtered (" ", stream
);
1355 /* If we just printed a tag name, no need to print anything
1357 if (TYPE_TAG_NAME (type
) == NULL
)
1358 fprintf_filtered (stream
, "{...}");
1360 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1362 LONGEST lastval
= 0;
1364 /* We can't handle this case perfectly, as DWARF does not
1365 tell us whether or not the underlying type was specified
1366 in the source (and other debug formats don't provide this
1367 at all). We choose to print the underlying type, if it
1368 has a name, when in C++ on the theory that it's better to
1369 print too much than too little; but conversely not to
1370 print something egregiously outside the current
1371 language's syntax. */
1372 if (current_language
->la_language
== language_cplus
1373 && TYPE_TARGET_TYPE (type
) != NULL
)
1375 struct type
*underlying
= check_typedef (TYPE_TARGET_TYPE (type
));
1377 if (TYPE_NAME (underlying
) != NULL
)
1378 fprintf_filtered (stream
, ": %s ", TYPE_NAME (underlying
));
1381 fprintf_filtered (stream
, "{");
1382 len
= TYPE_NFIELDS (type
);
1383 for (i
= 0; i
< len
; i
++)
1387 fprintf_filtered (stream
, ", ");
1389 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1390 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1392 fprintf_filtered (stream
, " = %s",
1393 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1394 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1398 fprintf_filtered (stream
, "}");
1402 case TYPE_CODE_FLAGS
:
1404 struct type_print_options local_flags
= *flags
;
1406 local_flags
.local_typedefs
= NULL
;
1408 c_type_print_modifier (type
, stream
, 0, 1);
1409 fprintf_filtered (stream
, "flag ");
1410 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1413 fputs_filtered (" ", stream
);
1414 fprintf_filtered (stream
, "{\n");
1415 if (TYPE_NFIELDS (type
) == 0)
1417 if (TYPE_STUB (type
))
1418 fprintfi_filtered (level
+ 4, stream
,
1419 _("<incomplete type>\n"));
1421 fprintfi_filtered (level
+ 4, stream
,
1422 _("<no data fields>\n"));
1424 len
= TYPE_NFIELDS (type
);
1425 for (i
= 0; i
< len
; i
++)
1428 print_spaces_filtered (level
+ 4, stream
);
1429 /* We pass "show" here and not "show - 1" to get enum types
1430 printed. There's no other way to see them. */
1431 c_print_type (TYPE_FIELD_TYPE (type
, i
),
1432 TYPE_FIELD_NAME (type
, i
),
1433 stream
, show
, level
+ 4,
1435 fprintf_filtered (stream
, " @%s",
1436 plongest (TYPE_FIELD_BITPOS (type
, i
)));
1437 if (TYPE_FIELD_BITSIZE (type
, i
) > 1)
1439 fprintf_filtered (stream
, "-%s",
1440 plongest (TYPE_FIELD_BITPOS (type
, i
)
1441 + TYPE_FIELD_BITSIZE (type
, i
)
1444 fprintf_filtered (stream
, ";\n");
1446 fprintfi_filtered (level
, stream
, "}");
1451 case TYPE_CODE_VOID
:
1452 fprintf_filtered (stream
, "void");
1455 case TYPE_CODE_UNDEF
:
1456 fprintf_filtered (stream
, _("struct <unknown>"));
1459 case TYPE_CODE_ERROR
:
1460 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1463 case TYPE_CODE_RANGE
:
1464 /* This should not occur. */
1465 fprintf_filtered (stream
, _("<range type>"));
1468 case TYPE_CODE_NAMESPACE
:
1469 fputs_filtered ("namespace ", stream
);
1470 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1474 /* Handle types not explicitly handled by the other cases, such
1475 as fundamental types. For these, just print whatever the
1476 type name is, as recorded in the type itself. If there is no
1477 type name, then complain. */
1478 if (TYPE_NAME (type
) != NULL
)
1480 c_type_print_modifier (type
, stream
, 0, 1);
1481 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1485 /* At least for dump_symtab, it is important that this not
1487 fprintf_filtered (stream
, _("<invalid type code %d>"),