1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2019 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 "cli/cli-style.h"
32 #include "typeprint.h"
34 #include "cp-support.h"
36 /* A list of access specifiers used for printing. */
46 static void c_type_print_varspec_suffix (struct type
*, struct ui_file
*, int,
49 const struct type_print_options
*);
51 static void c_type_print_varspec_prefix (struct type
*,
55 const struct type_print_options
*,
56 struct print_offset_data
*);
58 /* Print "const", "volatile", or address space modifiers. */
59 static void c_type_print_modifier (struct type
*,
63 static void c_type_print_base_1 (struct type
*type
, struct ui_file
*stream
,
64 int show
, int level
, enum language language
,
65 const struct type_print_options
*flags
,
66 struct print_offset_data
*podata
);
69 /* A callback function for cp_canonicalize_string_full that uses
70 typedef_hash_table::find_typedef. */
73 find_typedef_for_canonicalize (struct type
*t
, void *data
)
75 return typedef_hash_table::find_typedef
76 ((const struct type_print_options
*) data
, t
);
79 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
80 canonicalize NAME using the local typedefs first. */
83 print_name_maybe_canonical (const char *name
,
84 const struct type_print_options
*flags
,
85 struct ui_file
*stream
)
90 s
= cp_canonicalize_string_full (name
,
91 find_typedef_for_canonicalize
,
94 fputs_filtered (!s
.empty () ? s
.c_str () : name
, stream
);
99 /* Helper function for c_print_type. */
102 c_print_type_1 (struct type
*type
,
103 const char *varstring
,
104 struct ui_file
*stream
,
106 enum language language
,
107 const struct type_print_options
*flags
,
108 struct print_offset_data
*podata
)
113 const char *local_name
;
116 type
= check_typedef (type
);
118 local_name
= typedef_hash_table::find_typedef (flags
, type
);
119 code
= TYPE_CODE (type
);
120 if (local_name
!= NULL
)
122 fputs_filtered (local_name
, stream
);
123 if (varstring
!= NULL
&& *varstring
!= '\0')
124 fputs_filtered (" ", stream
);
128 c_type_print_base_1 (type
, stream
, show
, level
, language
, flags
, podata
);
129 if ((varstring
!= NULL
&& *varstring
!= '\0')
130 /* Need a space if going to print stars or brackets;
131 but not if we will print just a type name. */
132 || ((show
> 0 || TYPE_NAME (type
) == 0)
133 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
134 || code
== TYPE_CODE_METHOD
135 || (code
== TYPE_CODE_ARRAY
136 && !TYPE_VECTOR (type
))
137 || code
== TYPE_CODE_MEMBERPTR
138 || code
== TYPE_CODE_METHODPTR
139 || TYPE_IS_REFERENCE (type
))))
140 fputs_filtered (" ", stream
);
141 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
142 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
143 language
, flags
, podata
);
146 if (varstring
!= NULL
)
148 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
149 fputs_styled (varstring
, function_name_style
.style (), stream
);
151 fputs_filtered (varstring
, stream
);
153 /* For demangled function names, we have the arglist as part of
154 the name, so don't print an additional pair of ()'s. */
155 if (local_name
== NULL
)
157 demangled_args
= strchr (varstring
, '(') != NULL
;
158 c_type_print_varspec_suffix (type
, stream
, show
,
165 /* LEVEL is the depth to indent lines by. */
168 c_print_type (struct type
*type
,
169 const char *varstring
,
170 struct ui_file
*stream
,
172 const struct type_print_options
*flags
)
174 struct print_offset_data podata
;
176 c_print_type_1 (type
, varstring
, stream
, show
, level
,
177 current_language
->la_language
, flags
, &podata
);
184 c_print_type (struct type
*type
,
185 const char *varstring
,
186 struct ui_file
*stream
,
188 enum language language
,
189 const struct type_print_options
*flags
)
191 struct print_offset_data podata
;
193 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
197 /* Print a typedef using C syntax. TYPE is the underlying type.
198 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
202 c_print_typedef (struct type
*type
,
203 struct symbol
*new_symbol
,
204 struct ui_file
*stream
)
206 type
= check_typedef (type
);
207 fprintf_filtered (stream
, "typedef ");
208 type_print (type
, "", stream
, -1);
209 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
210 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
211 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
212 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
213 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
214 fprintf_filtered (stream
, ";\n");
217 /* If TYPE is a derived type, then print out derivation information.
218 Print only the actual base classes of this type, not the base
219 classes of the base classes. I.e. for the derivation hierarchy:
222 class B : public A {int b; };
223 class C : public B {int c; };
225 Print the type of class C as:
231 Not as the following (like gdb used to), which is not legal C++
232 syntax for derived types and may be confused with the multiple
235 class C : public B : public A {
239 In general, gdb should try to print the types as closely as
240 possible to the form that they appear in the source code. */
243 cp_type_print_derivation_info (struct ui_file
*stream
,
245 const struct type_print_options
*flags
)
250 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
253 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
254 fprintf_filtered (stream
, "%s%s ",
255 BASETYPE_VIA_PUBLIC (type
, i
)
256 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
257 ? "protected" : "private"),
258 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
259 name
= TYPE_NAME (TYPE_BASECLASS (type
, i
));
261 print_name_maybe_canonical (name
, flags
, stream
);
263 fprintf_filtered (stream
, "(null)");
267 fputs_filtered (" ", stream
);
271 /* Print the C++ method arguments ARGS to the file STREAM. */
274 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
275 const char *varstring
, int staticp
,
276 struct ui_file
*stream
,
277 enum language language
,
278 const struct type_print_options
*flags
)
280 struct field
*args
= TYPE_FIELDS (mtype
);
281 int nargs
= TYPE_NFIELDS (mtype
);
282 int varargs
= TYPE_VARARGS (mtype
);
285 fprintf_symbol_filtered (stream
, prefix
,
286 language_cplus
, DMGL_ANSI
);
287 fprintf_symbol_filtered (stream
, varstring
,
288 language_cplus
, DMGL_ANSI
);
289 fputs_filtered ("(", stream
);
291 /* Skip the class variable. We keep this here to accommodate older
292 compilers and debug formats which may not support artificial
299 struct field arg
= args
[i
++];
301 /* Skip any artificial arguments. */
302 if (FIELD_ARTIFICIAL (arg
))
305 c_print_type (arg
.type
, "", stream
, 0, 0, flags
);
307 if (i
== nargs
&& varargs
)
308 fprintf_filtered (stream
, ", ...");
311 fprintf_filtered (stream
, ", ");
317 fprintf_filtered (stream
, "...");
318 else if (language
== language_cplus
)
319 fprintf_filtered (stream
, "void");
321 fprintf_filtered (stream
, ")");
323 /* For non-static methods, read qualifiers from the type of
329 gdb_assert (nargs
> 0);
330 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
331 domain
= TYPE_TARGET_TYPE (args
[0].type
);
333 if (TYPE_CONST (domain
))
334 fprintf_filtered (stream
, " const");
336 if (TYPE_VOLATILE (domain
))
337 fprintf_filtered (stream
, " volatile");
339 if (TYPE_RESTRICT (domain
))
340 fprintf_filtered (stream
, " restrict");
342 if (TYPE_ATOMIC (domain
))
343 fprintf_filtered (stream
, " _Atomic");
348 /* Print any asterisks or open-parentheses needed before the
349 variable name (to describe its type).
351 On outermost call, pass 0 for PASSED_A_PTR.
352 On outermost call, SHOW > 0 means should ignore
353 any typename for TYPE and show its details.
354 SHOW is always zero on recursive calls.
356 NEED_POST_SPACE is non-zero when a space will be be needed
357 between a trailing qualifier and a field, variable, or function
361 c_type_print_varspec_prefix (struct type
*type
,
362 struct ui_file
*stream
,
363 int show
, int passed_a_ptr
,
365 enum language language
,
366 const struct type_print_options
*flags
,
367 struct print_offset_data
*podata
)
374 if (TYPE_NAME (type
) && show
<= 0)
379 switch (TYPE_CODE (type
))
382 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
383 stream
, show
, 1, 1, language
, flags
,
385 fprintf_filtered (stream
, "*");
386 c_type_print_modifier (type
, stream
, 1, need_post_space
);
389 case TYPE_CODE_MEMBERPTR
:
390 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
391 stream
, show
, 0, 0, language
, flags
, podata
);
392 name
= TYPE_NAME (TYPE_SELF_TYPE (type
));
394 print_name_maybe_canonical (name
, flags
, stream
);
396 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
397 stream
, -1, passed_a_ptr
, language
, flags
,
399 fprintf_filtered (stream
, "::*");
402 case TYPE_CODE_METHODPTR
:
403 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
404 stream
, show
, 0, 0, language
, flags
,
406 fprintf_filtered (stream
, "(");
407 name
= TYPE_NAME (TYPE_SELF_TYPE (type
));
409 print_name_maybe_canonical (name
, flags
, stream
);
411 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
412 stream
, -1, passed_a_ptr
, language
, flags
,
414 fprintf_filtered (stream
, "::*");
418 case TYPE_CODE_RVALUE_REF
:
419 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
420 stream
, show
, 1, 0, language
, flags
,
422 fprintf_filtered (stream
, TYPE_CODE(type
) == TYPE_CODE_REF
? "&" : "&&");
423 c_type_print_modifier (type
, stream
, 1, need_post_space
);
426 case TYPE_CODE_METHOD
:
428 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
429 stream
, show
, 0, 0, language
, flags
,
432 fprintf_filtered (stream
, "(");
435 case TYPE_CODE_ARRAY
:
436 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
437 stream
, show
, 0, 0, language
, flags
,
440 fprintf_filtered (stream
, "(");
443 case TYPE_CODE_TYPEDEF
:
444 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
445 stream
, show
, passed_a_ptr
, 0,
446 language
, flags
, podata
);
449 case TYPE_CODE_UNDEF
:
450 case TYPE_CODE_STRUCT
:
451 case TYPE_CODE_UNION
:
453 case TYPE_CODE_FLAGS
:
457 case TYPE_CODE_ERROR
:
461 case TYPE_CODE_RANGE
:
462 case TYPE_CODE_STRING
:
463 case TYPE_CODE_COMPLEX
:
464 case TYPE_CODE_NAMESPACE
:
465 case TYPE_CODE_DECFLOAT
:
466 /* These types need no prefix. They are listed here so that
467 gcc -Wall will reveal any types that haven't been handled. */
470 error (_("type not handled in c_type_print_varspec_prefix()"));
475 /* Print out "const" and "volatile" attributes,
476 and address space id if present.
477 TYPE is a pointer to the type being printed out.
478 STREAM is the output destination.
479 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
480 NEED_POST_SPACE = 1 indicates a final white space is needed. */
483 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
484 int need_pre_space
, int need_post_space
)
486 int did_print_modifier
= 0;
487 const char *address_space_id
;
489 /* We don't print `const' qualifiers for references --- since all
490 operators affect the thing referenced, not the reference itself,
491 every reference is `const'. */
492 if (TYPE_CONST (type
) && !TYPE_IS_REFERENCE (type
))
495 fprintf_filtered (stream
, " ");
496 fprintf_filtered (stream
, "const");
497 did_print_modifier
= 1;
500 if (TYPE_VOLATILE (type
))
502 if (did_print_modifier
|| need_pre_space
)
503 fprintf_filtered (stream
, " ");
504 fprintf_filtered (stream
, "volatile");
505 did_print_modifier
= 1;
508 if (TYPE_RESTRICT (type
))
510 if (did_print_modifier
|| need_pre_space
)
511 fprintf_filtered (stream
, " ");
512 fprintf_filtered (stream
, "restrict");
513 did_print_modifier
= 1;
516 if (TYPE_ATOMIC (type
))
518 if (did_print_modifier
|| need_pre_space
)
519 fprintf_filtered (stream
, " ");
520 fprintf_filtered (stream
, "_Atomic");
521 did_print_modifier
= 1;
524 address_space_id
= address_space_int_to_name (get_type_arch (type
),
525 TYPE_INSTANCE_FLAGS (type
));
526 if (address_space_id
)
528 if (did_print_modifier
|| need_pre_space
)
529 fprintf_filtered (stream
, " ");
530 fprintf_filtered (stream
, "@%s", address_space_id
);
531 did_print_modifier
= 1;
534 if (did_print_modifier
&& need_post_space
)
535 fprintf_filtered (stream
, " ");
539 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
540 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
541 in non-static methods, are displayed if LINKAGE_NAME is zero. If
542 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
543 parameter types get removed their possible const and volatile qualifiers to
544 match demangled linkage name parameters part of such function type.
545 LANGUAGE is the language in which TYPE was defined. This is a necessary
546 evil since this code is used by the C and C++. */
549 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
550 int linkage_name
, enum language language
,
551 const struct type_print_options
*flags
)
556 fprintf_filtered (stream
, "(");
558 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
560 struct type
*param_type
;
562 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
567 fprintf_filtered (stream
, ", ");
571 param_type
= TYPE_FIELD_TYPE (type
, i
);
573 if (language
== language_cplus
&& linkage_name
)
575 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
576 - Parameter declarations that differ only in the presence or
577 absence of const and/or volatile are equivalent.
579 And the const/volatile qualifiers are not present in the mangled
580 names as produced by GCC. */
582 param_type
= make_cv_type (0, 0, param_type
, NULL
);
585 c_print_type (param_type
, "", stream
, -1, 0, language
, flags
);
589 if (printed_any
&& TYPE_VARARGS (type
))
591 /* Print out a trailing ellipsis for varargs functions. Ignore
592 TYPE_VARARGS if the function has no named arguments; that
593 represents unprototyped (K&R style) C functions. */
594 if (printed_any
&& TYPE_VARARGS (type
))
596 fprintf_filtered (stream
, ", ");
598 fprintf_filtered (stream
, "...");
601 else if (!printed_any
602 && (TYPE_PROTOTYPED (type
) || language
== language_cplus
))
603 fprintf_filtered (stream
, "void");
605 fprintf_filtered (stream
, ")");
608 /* Return true iff the j'th overloading of the i'th method of TYPE
609 is a type conversion operator, like `operator int () { ... }'.
610 When listing a class's methods, we don't print the return type of
614 is_type_conversion_operator (struct type
*type
, int i
, int j
)
616 /* I think the whole idea of recognizing type conversion operators
617 by their name is pretty terrible. But I don't think our present
618 data structure gives us any other way to tell. If you know of
619 some other way, feel free to rewrite this function. */
620 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
622 if (!startswith (name
, CP_OPERATOR_STR
))
626 if (! strchr (" \t\f\n\r", *name
))
629 while (strchr (" \t\f\n\r", *name
))
632 if (!('a' <= *name
&& *name
<= 'z')
633 && !('A' <= *name
&& *name
<= 'Z')
635 /* If this doesn't look like the start of an identifier, then it
636 isn't a type conversion operator. */
638 else if (startswith (name
, "new"))
640 else if (startswith (name
, "delete"))
643 /* If it doesn't look like new or delete, it's a type conversion
647 /* Is that really the end of the name? */
648 if (('a' <= *name
&& *name
<= 'z')
649 || ('A' <= *name
&& *name
<= 'Z')
650 || ('0' <= *name
&& *name
<= '9')
652 /* No, so the identifier following "operator" must be a type name,
653 and this is a type conversion operator. */
656 /* That was indeed the end of the name, so it was `operator new' or
657 `operator delete', neither of which are type conversion
662 /* Given a C++ qualified identifier QID, strip off the qualifiers,
663 yielding the unqualified name. The return value is a pointer into
666 It's a pity we don't have this information in some more structured
667 form. Even the author of this function feels that writing little
668 parsers like this everywhere is stupid. */
671 remove_qualifiers (char *qid
)
673 int quoted
= 0; /* Zero if we're not in quotes;
674 '"' if we're in a double-quoted string;
675 '\'' if we're in a single-quoted string. */
676 int depth
= 0; /* Number of unclosed parens we've seen. */
677 char *parenstack
= (char *) alloca (strlen (qid
));
679 char *last
= 0; /* The character after the rightmost
680 `::' token we've seen so far. */
682 for (scan
= qid
; *scan
; scan
++)
688 else if (*scan
== '\\' && *(scan
+ 1))
691 else if (scan
[0] == ':' && scan
[1] == ':')
693 /* If we're inside parenthesis (i.e., an argument list) or
694 angle brackets (i.e., a list of template arguments), then
695 we don't record the position of this :: token, since it's
696 not relevant to the top-level structure we're trying to
704 else if (*scan
== '"' || *scan
== '\'')
706 else if (*scan
== '(')
707 parenstack
[depth
++] = ')';
708 else if (*scan
== '[')
709 parenstack
[depth
++] = ']';
710 /* We're going to treat <> as a pair of matching characters,
711 since we're more likely to see those in template id's than
712 real less-than characters. What a crock. */
713 else if (*scan
== '<')
714 parenstack
[depth
++] = '>';
715 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
717 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
721 /* We're going to do a little error recovery here. If
722 we don't find a match for *scan on the paren stack,
723 but there is something lower on the stack that does
724 match, we pop the stack to that point. */
727 for (i
= depth
- 1; i
>= 0; i
--)
728 if (parenstack
[i
] == *scan
)
740 /* We didn't find any :: tokens at the top level, so declare the
741 whole thing an unqualified identifier. */
745 /* Print any array sizes, function arguments or close parentheses
746 needed after the variable name (to describe its type).
747 Args work like c_type_print_varspec_prefix. */
750 c_type_print_varspec_suffix (struct type
*type
,
751 struct ui_file
*stream
,
752 int show
, int passed_a_ptr
,
754 enum language language
,
755 const struct type_print_options
*flags
)
760 if (TYPE_NAME (type
) && show
<= 0)
765 switch (TYPE_CODE (type
))
767 case TYPE_CODE_ARRAY
:
769 LONGEST low_bound
, high_bound
;
770 int is_vector
= TYPE_VECTOR (type
);
773 fprintf_filtered (stream
, ")");
775 fprintf_filtered (stream
, (is_vector
?
776 " __attribute__ ((vector_size(" : "["));
777 /* Bounds are not yet resolved, print a bounds placeholder instead. */
778 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
779 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
780 fprintf_filtered (stream
, "variable length");
781 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
782 fprintf_filtered (stream
, "%s",
783 plongest (high_bound
- low_bound
+ 1));
784 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
786 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
787 show
, 0, 0, language
, flags
);
791 case TYPE_CODE_MEMBERPTR
:
792 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
793 show
, 0, 0, language
, flags
);
796 case TYPE_CODE_METHODPTR
:
797 fprintf_filtered (stream
, ")");
798 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
799 show
, 0, 0, language
, flags
);
804 case TYPE_CODE_RVALUE_REF
:
805 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
806 show
, 1, 0, language
, flags
);
809 case TYPE_CODE_METHOD
:
812 fprintf_filtered (stream
, ")");
814 c_type_print_args (type
, stream
, 0, language
, flags
);
815 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
816 show
, passed_a_ptr
, 0, language
, flags
);
819 case TYPE_CODE_TYPEDEF
:
820 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
821 show
, passed_a_ptr
, 0, language
, flags
);
824 case TYPE_CODE_UNDEF
:
825 case TYPE_CODE_STRUCT
:
826 case TYPE_CODE_UNION
:
827 case TYPE_CODE_FLAGS
:
832 case TYPE_CODE_ERROR
:
836 case TYPE_CODE_RANGE
:
837 case TYPE_CODE_STRING
:
838 case TYPE_CODE_COMPLEX
:
839 case TYPE_CODE_NAMESPACE
:
840 case TYPE_CODE_DECFLOAT
:
841 /* These types do not need a suffix. They are listed so that
842 gcc -Wall will report types that may not have been
846 error (_("type not handled in c_type_print_varspec_suffix()"));
851 /* A helper for c_type_print_base that displays template
852 parameters and their bindings, if needed.
854 TABLE is the local bindings table to use. If NULL, no printing is
855 done. Note that, at this point, TABLE won't have any useful
856 information in it -- but it is also used as a flag to
857 print_name_maybe_canonical to activate searching the global typedef
860 TYPE is the type whose template arguments are being displayed.
862 STREAM is the stream on which to print. */
865 c_type_print_template_args (const struct type_print_options
*flags
,
866 struct type
*type
, struct ui_file
*stream
)
873 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
875 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
877 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
883 fprintf_filtered (stream
, _("[with %s = "),
884 SYMBOL_LINKAGE_NAME (sym
));
889 fputs_filtered (", ", stream
);
891 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
894 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
898 fputs_filtered (_("] "), stream
);
901 /* Use 'print_spaces_filtered', but take into consideration the
902 type_print_options FLAGS in order to determine how many whitespaces
906 print_spaces_filtered_with_print_options
907 (int level
, struct ui_file
*stream
, const struct type_print_options
*flags
)
909 if (!flags
->print_offsets
)
910 print_spaces_filtered (level
, stream
);
912 print_spaces_filtered (level
+ print_offset_data::indentation
, stream
);
915 /* Output an access specifier to STREAM, if needed. LAST_ACCESS is the
916 last access specifier output (typically returned by this function). */
918 static enum access_specifier
919 output_access_specifier (struct ui_file
*stream
,
920 enum access_specifier last_access
,
921 int level
, bool is_protected
, bool is_private
,
922 const struct type_print_options
*flags
)
926 if (last_access
!= s_protected
)
928 last_access
= s_protected
;
929 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
930 fprintf_filtered (stream
, "protected:\n");
935 if (last_access
!= s_private
)
937 last_access
= s_private
;
938 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
939 fprintf_filtered (stream
, "private:\n");
944 if (last_access
!= s_public
)
946 last_access
= s_public
;
947 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
948 fprintf_filtered (stream
, "public:\n");
955 /* Return true if an access label (i.e., "public:", "private:",
956 "protected:") needs to be printed for TYPE. */
959 need_access_label_p (struct type
*type
)
961 if (TYPE_DECLARED_CLASS (type
))
964 for (int i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
965 if (!TYPE_FIELD_PRIVATE (type
, i
))
968 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
969 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
970 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
974 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
975 if (!TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
981 for (int i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
982 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
985 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
988 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
989 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
991 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
997 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
998 if (TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
)
999 || TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
1006 /* Helper function that temporarily disables FLAGS->PRINT_OFFSETS,
1007 calls 'c_print_type_1', and then reenables FLAGS->PRINT_OFFSETS if
1011 c_print_type_no_offsets (struct type
*type
,
1012 const char *varstring
,
1013 struct ui_file
*stream
,
1014 int show
, int level
,
1015 enum language language
,
1016 struct type_print_options
*flags
,
1017 struct print_offset_data
*podata
)
1019 unsigned int old_po
= flags
->print_offsets
;
1021 /* Temporarily disable print_offsets, because it would mess with
1023 flags
->print_offsets
= 0;
1024 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
1026 flags
->print_offsets
= old_po
;
1029 /* Helper for 'c_type_print_base' that handles structs and unions.
1030 For a description of the arguments, see 'c_type_print_base'. */
1033 c_type_print_base_struct_union (struct type
*type
, struct ui_file
*stream
,
1034 int show
, int level
,
1035 enum language language
,
1036 const struct type_print_options
*flags
,
1037 struct print_offset_data
*podata
)
1039 struct type_print_options local_flags
= *flags
;
1040 local_flags
.local_typedefs
= NULL
;
1042 std::unique_ptr
<typedef_hash_table
> hash_holder
;
1045 if (flags
->local_typedefs
)
1046 local_flags
.local_typedefs
1047 = new typedef_hash_table (*flags
->local_typedefs
);
1049 local_flags
.local_typedefs
= new typedef_hash_table ();
1051 hash_holder
.reset (local_flags
.local_typedefs
);
1054 c_type_print_modifier (type
, stream
, 0, 1);
1055 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
1056 fprintf_filtered (stream
, "union ");
1057 else if (TYPE_DECLARED_CLASS (type
))
1058 fprintf_filtered (stream
, "class ");
1060 fprintf_filtered (stream
, "struct ");
1062 /* Print the tag if it exists. The HP aCC compiler emits a
1063 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
1064 enum}" tag for unnamed struct/union/enum's, which we don't
1066 if (TYPE_NAME (type
) != NULL
1067 && !startswith (TYPE_NAME (type
), "{unnamed"))
1069 /* When printing the tag name, we are still effectively
1070 printing in the outer context, hence the use of FLAGS
1072 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1074 fputs_filtered (" ", stream
);
1079 /* If we just printed a tag name, no need to print anything
1081 if (TYPE_NAME (type
) == NULL
)
1082 fprintf_filtered (stream
, "{...}");
1084 else if (show
> 0 || TYPE_NAME (type
) == NULL
)
1086 struct type
*basetype
;
1089 c_type_print_template_args (&local_flags
, type
, stream
);
1091 /* Add in template parameters when printing derivation info. */
1092 if (local_flags
.local_typedefs
!= NULL
)
1093 local_flags
.local_typedefs
->add_template_parameters (type
);
1094 cp_type_print_derivation_info (stream
, type
, &local_flags
);
1096 /* This holds just the global typedefs and the template
1098 struct type_print_options semi_local_flags
= *flags
;
1099 semi_local_flags
.local_typedefs
= NULL
;
1101 std::unique_ptr
<typedef_hash_table
> semi_holder
;
1102 if (local_flags
.local_typedefs
!= nullptr)
1104 semi_local_flags
.local_typedefs
1105 = new typedef_hash_table (*local_flags
.local_typedefs
);
1106 semi_holder
.reset (semi_local_flags
.local_typedefs
);
1108 /* Now add in the local typedefs. */
1109 local_flags
.local_typedefs
->recursively_update (type
);
1112 fprintf_filtered (stream
, "{\n");
1114 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
1115 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
1117 if (TYPE_STUB (type
))
1118 fprintfi_filtered (level
+ 4, stream
,
1119 _("%p[<incomplete type>%p]\n"),
1120 metadata_style
.style ().ptr (), nullptr);
1122 fprintfi_filtered (level
+ 4, stream
,
1123 _("%p[<no data fields>%p]\n"),
1124 metadata_style
.style ().ptr (), nullptr);
1127 /* Start off with no specific section type, so we can print
1128 one for the first field we find, and use that section type
1129 thereafter until we find another type. */
1131 enum access_specifier section_type
= s_none
;
1133 /* For a class, if all members are private, there's no need
1134 for a "private:" label; similarly, for a struct or union
1135 masquerading as a class, if all members are public, there's
1136 no need for a "public:" label. */
1137 bool need_access_label
= need_access_label_p (type
);
1139 /* If there is a base class for this type,
1140 do not print the field that it occupies. */
1142 int len
= TYPE_NFIELDS (type
);
1143 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1145 struct print_offset_data local_podata
;
1147 for (int i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1151 /* If we have a virtual table pointer, omit it. Even if
1152 virtual table pointers are not specifically marked in
1153 the debug info, they should be artificial. */
1154 if ((i
== vptr_fieldno
&& type
== basetype
)
1155 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1158 if (need_access_label
)
1160 section_type
= output_access_specifier
1161 (stream
, section_type
, level
,
1162 TYPE_FIELD_PROTECTED (type
, i
),
1163 TYPE_FIELD_PRIVATE (type
, i
), flags
);
1166 bool is_static
= field_is_static (&TYPE_FIELD (type
, i
));
1168 if (flags
->print_offsets
)
1169 podata
->update (type
, i
, stream
);
1171 print_spaces_filtered (level
+ 4, stream
);
1173 fprintf_filtered (stream
, "static ");
1175 int newshow
= show
- 1;
1177 if (!is_static
&& flags
->print_offsets
1178 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_STRUCT
1179 || TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
))
1181 /* If we're printing offsets and this field's type is
1182 either a struct or an union, then we're interested in
1186 /* Make sure we carry our offset when we expand the
1188 local_podata
.offset_bitpos
1189 = podata
->offset_bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
1190 /* We're entering a struct/union. Right now,
1191 PODATA->END_BITPOS points right *after* the
1192 struct/union. However, when printing the first field
1193 of this inner struct/union, the end_bitpos we're
1194 expecting is exactly at the beginning of the
1195 struct/union. Therefore, we subtract the length of
1196 the whole struct/union. */
1197 local_podata
.end_bitpos
1198 = podata
->end_bitpos
1199 - TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
)) * TARGET_CHAR_BIT
;
1202 c_print_type_1 (TYPE_FIELD_TYPE (type
, i
),
1203 TYPE_FIELD_NAME (type
, i
),
1204 stream
, newshow
, level
+ 4,
1205 language
, &local_flags
, &local_podata
);
1207 if (!is_static
&& TYPE_FIELD_PACKED (type
, i
))
1209 /* It is a bitfield. This code does not attempt
1210 to look at the bitpos and reconstruct filler,
1211 unnamed fields. This would lead to misleading
1212 results if the compiler does not put out fields
1213 for such things (I don't know what it does). */
1214 fprintf_filtered (stream
, " : %d",
1215 TYPE_FIELD_BITSIZE (type
, i
));
1217 fprintf_filtered (stream
, ";\n");
1220 /* If there are both fields and methods, put a blank line
1221 between them. Make sure to count only method that we
1222 will display; artificial methods will be hidden. */
1223 len
= TYPE_NFN_FIELDS (type
);
1224 if (!flags
->print_methods
)
1227 for (int i
= 0; i
< len
; i
++)
1229 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1230 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1233 for (j
= 0; j
< len2
; j
++)
1234 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1237 if (real_len
> 0 && section_type
!= s_none
)
1238 fprintf_filtered (stream
, "\n");
1240 /* C++: print out the methods. */
1241 for (int i
= 0; i
< len
; i
++)
1243 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1244 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1245 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1246 const char *name
= TYPE_NAME (type
);
1247 int is_constructor
= name
&& strcmp (method_name
,
1250 for (j
= 0; j
< len2
; j
++)
1252 const char *mangled_name
;
1253 gdb::unique_xmalloc_ptr
<char> mangled_name_holder
;
1254 char *demangled_name
;
1255 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1256 int is_full_physname_constructor
=
1257 TYPE_FN_FIELD_CONSTRUCTOR (f
, j
)
1258 || is_constructor_name (physname
)
1259 || is_destructor_name (physname
)
1260 || method_name
[0] == '~';
1262 /* Do not print out artificial methods. */
1263 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1267 section_type
= output_access_specifier
1268 (stream
, section_type
, level
,
1269 TYPE_FN_FIELD_PROTECTED (f
, j
),
1270 TYPE_FN_FIELD_PRIVATE (f
, j
), flags
);
1272 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1274 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1275 fprintf_filtered (stream
, "virtual ");
1276 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1277 fprintf_filtered (stream
, "static ");
1278 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1280 /* Keep GDB from crashing here. */
1281 fprintf_filtered (stream
,
1282 _("%p[<undefined type>%p] %s;\n"),
1283 metadata_style
.style ().ptr (), nullptr,
1284 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1287 else if (!is_constructor
/* Constructors don't
1290 && !is_full_physname_constructor
/* " " */
1291 && !is_type_conversion_operator (type
, i
, j
))
1293 c_print_type_no_offsets
1294 (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1295 "", stream
, -1, 0, language
, &local_flags
, podata
);
1297 fputs_filtered (" ", stream
);
1299 if (TYPE_FN_FIELD_STUB (f
, j
))
1301 /* Build something we can demangle. */
1302 mangled_name_holder
.reset (gdb_mangle_name (type
, i
, j
));
1303 mangled_name
= mangled_name_holder
.get ();
1306 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1309 gdb_demangle (mangled_name
,
1310 DMGL_ANSI
| DMGL_PARAMS
);
1311 if (demangled_name
== NULL
)
1313 /* In some cases (for instance with the HP
1314 demangling), if a function has more than 10
1315 arguments, the demangling will fail.
1316 Let's try to reconstruct the function
1317 signature from the symbol information. */
1318 if (!TYPE_FN_FIELD_STUB (f
, j
))
1320 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1321 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1323 cp_type_print_method_args (mtype
,
1331 fprintf_styled (stream
, metadata_style
.style (),
1332 _("<badly mangled name '%s'>"),
1338 char *demangled_no_class
1339 = remove_qualifiers (demangled_name
);
1341 /* Get rid of the `static' appended by the
1343 p
= strstr (demangled_no_class
, " static");
1346 int length
= p
- demangled_no_class
;
1347 char *demangled_no_static
;
1350 = (char *) xmalloc (length
+ 1);
1351 strncpy (demangled_no_static
,
1352 demangled_no_class
, length
);
1353 *(demangled_no_static
+ length
) = '\0';
1354 fputs_filtered (demangled_no_static
, stream
);
1355 xfree (demangled_no_static
);
1358 fputs_filtered (demangled_no_class
, stream
);
1359 xfree (demangled_name
);
1362 fprintf_filtered (stream
, ";\n");
1366 /* Print out nested types. */
1367 if (TYPE_NESTED_TYPES_COUNT (type
) != 0
1368 && semi_local_flags
.print_nested_type_limit
!= 0)
1370 if (semi_local_flags
.print_nested_type_limit
> 0)
1371 --semi_local_flags
.print_nested_type_limit
;
1373 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1374 fprintf_filtered (stream
, "\n");
1376 for (int i
= 0; i
< TYPE_NESTED_TYPES_COUNT (type
); ++i
)
1378 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1380 c_print_type_no_offsets (TYPE_NESTED_TYPES_FIELD_TYPE (type
, i
),
1381 "", stream
, show
, level
+ 4,
1382 language
, &semi_local_flags
, podata
);
1383 fprintf_filtered (stream
, ";\n");
1387 /* Print typedefs defined in this class. */
1389 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1391 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0
1392 || TYPE_NESTED_TYPES_COUNT (type
) != 0)
1393 fprintf_filtered (stream
, "\n");
1395 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1397 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1399 /* Dereference the typedef declaration itself. */
1400 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1401 target
= TYPE_TARGET_TYPE (target
);
1403 if (need_access_label
)
1405 section_type
= output_access_specifier
1406 (stream
, section_type
, level
,
1407 TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
),
1408 TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
), flags
);
1410 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1412 fprintf_filtered (stream
, "typedef ");
1414 /* We want to print typedefs with substitutions
1415 from the template parameters or globally-known
1416 typedefs but not local typedefs. */
1417 c_print_type_no_offsets (target
,
1418 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1419 stream
, show
- 1, level
+ 4,
1420 language
, &semi_local_flags
, podata
);
1421 fprintf_filtered (stream
, ";\n");
1425 if (flags
->print_offsets
)
1428 podata
->finish (type
, level
, stream
);
1430 print_spaces_filtered (print_offset_data::indentation
, stream
);
1432 print_spaces_filtered (2, stream
);
1435 fprintfi_filtered (level
, stream
, "}");
1439 /* Print the name of the type (or the ultimate pointer target,
1440 function value or array element), or the description of a structure
1443 SHOW positive means print details about the type (e.g. enum
1444 values), and print structure elements passing SHOW - 1 for show.
1446 SHOW negative means just print the type name or struct tag if there
1447 is one. If there is no name, print something sensible but concise
1448 like "struct {...}".
1450 SHOW zero means just print the type name or struct tag if there is
1451 one. If there is no name, print something sensible but not as
1452 concise like "struct {int x; int y;}".
1454 LEVEL is the number of spaces to indent by.
1455 We increase it for some recursive calls. */
1458 c_type_print_base_1 (struct type
*type
, struct ui_file
*stream
,
1459 int show
, int level
,
1460 enum language language
,
1461 const struct type_print_options
*flags
,
1462 struct print_offset_data
*podata
)
1471 fputs_styled (_("<type unknown>"), metadata_style
.style (), stream
);
1475 /* When SHOW is zero or less, and there is a valid type name, then
1476 always just print the type name directly from the type. */
1479 && TYPE_NAME (type
) != NULL
)
1481 c_type_print_modifier (type
, stream
, 0, 1);
1483 /* If we have "typedef struct foo {. . .} bar;" do we want to
1484 print it as "struct foo" or as "bar"? Pick the latter for
1485 C++, because C++ folk tend to expect things like "class5
1486 *foo" rather than "struct class5 *foo". We rather
1487 arbitrarily choose to make language_minimal work in a C-like
1489 if (language
== language_c
|| language
== language_minimal
)
1491 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
1492 fprintf_filtered (stream
, "union ");
1493 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1495 if (TYPE_DECLARED_CLASS (type
))
1496 fprintf_filtered (stream
, "class ");
1498 fprintf_filtered (stream
, "struct ");
1500 else if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
1501 fprintf_filtered (stream
, "enum ");
1504 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1508 type
= check_typedef (type
);
1510 switch (TYPE_CODE (type
))
1512 case TYPE_CODE_TYPEDEF
:
1513 /* If we get here, the typedef doesn't have a name, and we
1514 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
1515 gdb_assert (TYPE_NAME (type
) == NULL
);
1516 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
1517 fprintf_styled (stream
, metadata_style
.style (),
1518 _("<unnamed typedef>"));
1521 case TYPE_CODE_FUNC
:
1522 case TYPE_CODE_METHOD
:
1523 if (TYPE_TARGET_TYPE (type
) == NULL
)
1524 type_print_unknown_return_type (stream
);
1526 c_type_print_base_1 (TYPE_TARGET_TYPE (type
),
1527 stream
, show
, level
, language
, flags
, podata
);
1529 case TYPE_CODE_ARRAY
:
1531 case TYPE_CODE_MEMBERPTR
:
1533 case TYPE_CODE_RVALUE_REF
:
1534 case TYPE_CODE_METHODPTR
:
1535 c_type_print_base_1 (TYPE_TARGET_TYPE (type
),
1536 stream
, show
, level
, language
, flags
, podata
);
1539 case TYPE_CODE_STRUCT
:
1540 case TYPE_CODE_UNION
:
1541 c_type_print_base_struct_union (type
, stream
, show
, level
,
1542 language
, flags
, podata
);
1545 case TYPE_CODE_ENUM
:
1546 c_type_print_modifier (type
, stream
, 0, 1);
1547 fprintf_filtered (stream
, "enum ");
1548 if (TYPE_DECLARED_CLASS (type
))
1549 fprintf_filtered (stream
, "class ");
1550 /* Print the tag name if it exists.
1551 The aCC compiler emits a spurious
1552 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1553 tag for unnamed struct/union/enum's, which we don't
1555 if (TYPE_NAME (type
) != NULL
1556 && !startswith (TYPE_NAME (type
), "{unnamed"))
1558 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1560 fputs_filtered (" ", stream
);
1566 /* If we just printed a tag name, no need to print anything
1568 if (TYPE_NAME (type
) == NULL
)
1569 fprintf_filtered (stream
, "{...}");
1571 else if (show
> 0 || TYPE_NAME (type
) == NULL
)
1573 LONGEST lastval
= 0;
1575 /* We can't handle this case perfectly, as DWARF does not
1576 tell us whether or not the underlying type was specified
1577 in the source (and other debug formats don't provide this
1578 at all). We choose to print the underlying type, if it
1579 has a name, when in C++ on the theory that it's better to
1580 print too much than too little; but conversely not to
1581 print something egregiously outside the current
1582 language's syntax. */
1583 if (language
== language_cplus
&& TYPE_TARGET_TYPE (type
) != NULL
)
1585 struct type
*underlying
= check_typedef (TYPE_TARGET_TYPE (type
));
1587 if (TYPE_NAME (underlying
) != NULL
)
1588 fprintf_filtered (stream
, ": %s ", TYPE_NAME (underlying
));
1591 fprintf_filtered (stream
, "{");
1592 len
= TYPE_NFIELDS (type
);
1593 for (i
= 0; i
< len
; i
++)
1597 fprintf_filtered (stream
, ", ");
1599 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1600 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1602 fprintf_filtered (stream
, " = %s",
1603 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1604 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1608 fprintf_filtered (stream
, "}");
1612 case TYPE_CODE_FLAGS
:
1614 struct type_print_options local_flags
= *flags
;
1616 local_flags
.local_typedefs
= NULL
;
1618 c_type_print_modifier (type
, stream
, 0, 1);
1619 fprintf_filtered (stream
, "flag ");
1620 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1623 fputs_filtered (" ", stream
);
1624 fprintf_filtered (stream
, "{\n");
1625 if (TYPE_NFIELDS (type
) == 0)
1627 if (TYPE_STUB (type
))
1628 fprintfi_filtered (level
+ 4, stream
,
1629 _("%p[<incomplete type>%p]\n"),
1630 metadata_style
.style ().ptr (), nullptr);
1632 fprintfi_filtered (level
+ 4, stream
,
1633 _("%p[<no data fields>%p]\n"),
1634 metadata_style
.style ().ptr (), nullptr);
1636 len
= TYPE_NFIELDS (type
);
1637 for (i
= 0; i
< len
; i
++)
1640 print_spaces_filtered (level
+ 4, stream
);
1641 /* We pass "show" here and not "show - 1" to get enum types
1642 printed. There's no other way to see them. */
1643 c_print_type_1 (TYPE_FIELD_TYPE (type
, i
),
1644 TYPE_FIELD_NAME (type
, i
),
1645 stream
, show
, level
+ 4,
1646 language
, &local_flags
, podata
);
1647 fprintf_filtered (stream
, " @%s",
1648 plongest (TYPE_FIELD_BITPOS (type
, i
)));
1649 if (TYPE_FIELD_BITSIZE (type
, i
) > 1)
1651 fprintf_filtered (stream
, "-%s",
1652 plongest (TYPE_FIELD_BITPOS (type
, i
)
1653 + TYPE_FIELD_BITSIZE (type
, i
)
1656 fprintf_filtered (stream
, ";\n");
1658 fprintfi_filtered (level
, stream
, "}");
1663 case TYPE_CODE_VOID
:
1664 fprintf_filtered (stream
, "void");
1667 case TYPE_CODE_UNDEF
:
1668 fprintf_filtered (stream
, _("struct <unknown>"));
1671 case TYPE_CODE_ERROR
:
1672 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1675 case TYPE_CODE_RANGE
:
1676 /* This should not occur. */
1677 fprintf_styled (stream
, metadata_style
.style (), _("<range type>"));
1680 case TYPE_CODE_NAMESPACE
:
1681 fputs_filtered ("namespace ", stream
);
1682 fputs_filtered (TYPE_NAME (type
), stream
);
1686 /* Handle types not explicitly handled by the other cases, such
1687 as fundamental types. For these, just print whatever the
1688 type name is, as recorded in the type itself. If there is no
1689 type name, then complain. */
1690 if (TYPE_NAME (type
) != NULL
)
1692 c_type_print_modifier (type
, stream
, 0, 1);
1693 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1697 /* At least for dump_symtab, it is important that this not
1699 fprintf_styled (stream
, metadata_style
.style (),
1700 _("<invalid type code %d>"), TYPE_CODE (type
));
1706 /* See c_type_print_base_1. */
1709 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
1710 int show
, int level
,
1711 const struct type_print_options
*flags
)
1713 struct print_offset_data podata
;
1715 c_type_print_base_1 (type
, stream
, show
, level
,
1716 current_language
->la_language
, flags
, &podata
);