1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2018 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 /* When printing the offsets of a struct and its fields (i.e., 'ptype
36 /o'; type_print_options::print_offsets), we use this many
37 characters when printing the offset information at the beginning of
38 the line. This is needed in order to generate the correct amount
39 of whitespaces when no offset info should be printed for a certain
41 #define OFFSET_SPC_LEN 23
43 /* A list of access specifiers used for printing. */
53 static void c_type_print_varspec_suffix (struct type *, struct ui_file *, int,
56 const struct type_print_options *);
58 static void c_type_print_varspec_prefix (struct type *,
62 const struct type_print_options *,
63 struct print_offset_data *);
65 /* Print "const", "volatile", or address space modifiers. */
66 static void c_type_print_modifier (struct type *,
70 static void c_type_print_base_1 (struct type *type, struct ui_file *stream,
71 int show, int level, enum language language,
72 const struct type_print_options *flags,
73 struct print_offset_data *podata);
76 /* A callback function for cp_canonicalize_string_full that uses
77 typedef_hash_table::find_typedef. */
80 find_typedef_for_canonicalize (struct type *t, void *data)
82 return typedef_hash_table::find_typedef
83 ((const struct type_print_options *) data, t);
86 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
87 canonicalize NAME using the local typedefs first. */
90 print_name_maybe_canonical (const char *name,
91 const struct type_print_options *flags,
92 struct ui_file *stream)
97 s = cp_canonicalize_string_full (name,
98 find_typedef_for_canonicalize,
101 fputs_filtered (!s.empty () ? s.c_str () : name, stream);
106 /* Helper function for c_print_type. */
109 c_print_type_1 (struct type *type,
110 const char *varstring,
111 struct ui_file *stream,
113 enum language language,
114 const struct type_print_options *flags,
115 struct print_offset_data *podata)
120 const char *local_name;
123 type = check_typedef (type);
125 local_name = typedef_hash_table::find_typedef (flags, type);
126 if (local_name != NULL)
128 fputs_filtered (local_name, stream);
129 if (varstring != NULL && *varstring != '\0')
130 fputs_filtered (" ", stream);
134 c_type_print_base_1 (type, stream, show, level, language, flags, podata);
135 code = TYPE_CODE (type);
136 if ((varstring != NULL && *varstring != '\0')
137 /* Need a space if going to print stars or brackets;
138 but not if we will print just a type name. */
139 || ((show > 0 || TYPE_NAME (type) == 0)
140 && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
141 || code == TYPE_CODE_METHOD
142 || (code == TYPE_CODE_ARRAY
143 && !TYPE_VECTOR (type))
144 || code == TYPE_CODE_MEMBERPTR
145 || code == TYPE_CODE_METHODPTR
146 || TYPE_IS_REFERENCE (type))))
147 fputs_filtered (" ", stream);
148 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
149 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
150 language, flags, podata);
153 if (varstring != NULL)
155 fputs_filtered (varstring, stream);
157 /* For demangled function names, we have the arglist as part of
158 the name, so don't print an additional pair of ()'s. */
159 if (local_name == NULL)
161 demangled_args = strchr (varstring, '(') != NULL;
162 c_type_print_varspec_suffix (type, stream, show,
169 /* LEVEL is the depth to indent lines by. */
172 c_print_type (struct type *type,
173 const char *varstring,
174 struct ui_file *stream,
176 const struct type_print_options *flags)
178 struct print_offset_data podata;
180 c_print_type_1 (type, varstring, stream, show, level,
181 current_language->la_language, flags, &podata);
188 c_print_type (struct type *type,
189 const char *varstring,
190 struct ui_file *stream,
192 enum language language,
193 const struct type_print_options *flags)
195 struct print_offset_data podata;
197 c_print_type_1 (type, varstring, stream, show, level, language, flags,
201 /* Print a typedef using C syntax. TYPE is the underlying type.
202 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
206 c_print_typedef (struct type *type,
207 struct symbol *new_symbol,
208 struct ui_file *stream)
210 type = check_typedef (type);
211 fprintf_filtered (stream, "typedef ");
212 type_print (type, "", stream, 0);
213 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
214 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
215 SYMBOL_LINKAGE_NAME (new_symbol)) != 0
216 || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
217 fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
218 fprintf_filtered (stream, ";\n");
221 /* If TYPE is a derived type, then print out derivation information.
222 Print only the actual base classes of this type, not the base
223 classes of the base classes. I.e. for the derivation hierarchy:
226 class B : public A {int b; };
227 class C : public B {int c; };
229 Print the type of class C as:
235 Not as the following (like gdb used to), which is not legal C++
236 syntax for derived types and may be confused with the multiple
239 class C : public B : public A {
243 In general, gdb should try to print the types as closely as
244 possible to the form that they appear in the source code. */
247 cp_type_print_derivation_info (struct ui_file *stream,
249 const struct type_print_options *flags)
254 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
257 fputs_filtered (i == 0 ? ": " : ", ", stream);
258 fprintf_filtered (stream, "%s%s ",
259 BASETYPE_VIA_PUBLIC (type, i)
260 ? "public" : (TYPE_FIELD_PROTECTED (type, i)
261 ? "protected" : "private"),
262 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
263 name = type_name_no_tag (TYPE_BASECLASS (type, i));
265 print_name_maybe_canonical (name, flags, stream);
267 fprintf_filtered (stream, "(null)");
271 fputs_filtered (" ", stream);
275 /* Print the C++ method arguments ARGS to the file STREAM. */
278 cp_type_print_method_args (struct type *mtype, const char *prefix,
279 const char *varstring, int staticp,
280 struct ui_file *stream,
281 enum language language,
282 const struct type_print_options *flags)
284 struct field *args = TYPE_FIELDS (mtype);
285 int nargs = TYPE_NFIELDS (mtype);
286 int varargs = TYPE_VARARGS (mtype);
289 fprintf_symbol_filtered (stream, prefix,
290 language_cplus, DMGL_ANSI);
291 fprintf_symbol_filtered (stream, varstring,
292 language_cplus, DMGL_ANSI);
293 fputs_filtered ("(", stream);
295 /* Skip the class variable. We keep this here to accommodate older
296 compilers and debug formats which may not support artificial
303 struct field arg = args[i++];
305 /* Skip any artificial arguments. */
306 if (FIELD_ARTIFICIAL (arg))
309 c_print_type (arg.type, "", stream, 0, 0, flags);
311 if (i == nargs && varargs)
312 fprintf_filtered (stream, ", ...");
315 fprintf_filtered (stream, ", ");
321 fprintf_filtered (stream, "...");
322 else if (language == language_cplus)
323 fprintf_filtered (stream, "void");
325 fprintf_filtered (stream, ")");
327 /* For non-static methods, read qualifiers from the type of
333 gdb_assert (nargs > 0);
334 gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
335 domain = TYPE_TARGET_TYPE (args[0].type);
337 if (TYPE_CONST (domain))
338 fprintf_filtered (stream, " const");
340 if (TYPE_VOLATILE (domain))
341 fprintf_filtered (stream, " volatile");
343 if (TYPE_RESTRICT (domain))
344 fprintf_filtered (stream, " restrict");
346 if (TYPE_ATOMIC (domain))
347 fprintf_filtered (stream, " _Atomic");
352 /* Print any asterisks or open-parentheses needed before the
353 variable name (to describe its type).
355 On outermost call, pass 0 for PASSED_A_PTR.
356 On outermost call, SHOW > 0 means should ignore
357 any typename for TYPE and show its details.
358 SHOW is always zero on recursive calls.
360 NEED_POST_SPACE is non-zero when a space will be be needed
361 between a trailing qualifier and a field, variable, or function
365 c_type_print_varspec_prefix (struct type *type,
366 struct ui_file *stream,
367 int show, int passed_a_ptr,
369 enum language language,
370 const struct type_print_options *flags,
371 struct print_offset_data *podata)
378 if (TYPE_NAME (type) && show <= 0)
383 switch (TYPE_CODE (type))
386 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
387 stream, show, 1, 1, language, flags,
389 fprintf_filtered (stream, "*");
390 c_type_print_modifier (type, stream, 1, need_post_space);
393 case TYPE_CODE_MEMBERPTR:
394 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
395 stream, show, 0, 0, language, flags,
397 name = type_name_no_tag (TYPE_SELF_TYPE (type));
399 print_name_maybe_canonical (name, flags, stream);
401 c_type_print_base_1 (TYPE_SELF_TYPE (type),
402 stream, -1, passed_a_ptr, language, flags,
404 fprintf_filtered (stream, "::*");
407 case TYPE_CODE_METHODPTR:
408 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
409 stream, show, 0, 0, language, flags,
411 fprintf_filtered (stream, "(");
412 name = type_name_no_tag (TYPE_SELF_TYPE (type));
414 print_name_maybe_canonical (name, flags, stream);
416 c_type_print_base_1 (TYPE_SELF_TYPE (type),
417 stream, -1, passed_a_ptr, language, flags,
419 fprintf_filtered (stream, "::*");
423 case TYPE_CODE_RVALUE_REF:
424 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
425 stream, show, 1, 0, language, flags,
427 fprintf_filtered (stream, TYPE_CODE(type) == TYPE_CODE_REF ? "&" : "&&");
428 c_type_print_modifier (type, stream, 1, need_post_space);
431 case TYPE_CODE_METHOD:
433 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
434 stream, show, 0, 0, language, flags,
437 fprintf_filtered (stream, "(");
440 case TYPE_CODE_ARRAY:
441 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
442 stream, show, 0, 0, language, flags,
445 fprintf_filtered (stream, "(");
448 case TYPE_CODE_TYPEDEF:
449 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
450 stream, show, passed_a_ptr, 0,
451 language, flags, podata);
454 case TYPE_CODE_UNDEF:
455 case TYPE_CODE_STRUCT:
456 case TYPE_CODE_UNION:
458 case TYPE_CODE_FLAGS:
462 case TYPE_CODE_ERROR:
466 case TYPE_CODE_RANGE:
467 case TYPE_CODE_STRING:
468 case TYPE_CODE_COMPLEX:
469 case TYPE_CODE_NAMESPACE:
470 case TYPE_CODE_DECFLOAT:
471 /* These types need no prefix. They are listed here so that
472 gcc -Wall will reveal any types that haven't been handled. */
475 error (_("type not handled in c_type_print_varspec_prefix()"));
480 /* Print out "const" and "volatile" attributes,
481 and address space id if present.
482 TYPE is a pointer to the type being printed out.
483 STREAM is the output destination.
484 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
485 NEED_POST_SPACE = 1 indicates a final white space is needed. */
488 c_type_print_modifier (struct type *type, struct ui_file *stream,
489 int need_pre_space, int need_post_space)
491 int did_print_modifier = 0;
492 const char *address_space_id;
494 /* We don't print `const' qualifiers for references --- since all
495 operators affect the thing referenced, not the reference itself,
496 every reference is `const'. */
497 if (TYPE_CONST (type) && !TYPE_IS_REFERENCE (type))
500 fprintf_filtered (stream, " ");
501 fprintf_filtered (stream, "const");
502 did_print_modifier = 1;
505 if (TYPE_VOLATILE (type))
507 if (did_print_modifier || need_pre_space)
508 fprintf_filtered (stream, " ");
509 fprintf_filtered (stream, "volatile");
510 did_print_modifier = 1;
513 if (TYPE_RESTRICT (type))
515 if (did_print_modifier || need_pre_space)
516 fprintf_filtered (stream, " ");
517 fprintf_filtered (stream, "restrict");
518 did_print_modifier = 1;
521 if (TYPE_ATOMIC (type))
523 if (did_print_modifier || need_pre_space)
524 fprintf_filtered (stream, " ");
525 fprintf_filtered (stream, "_Atomic");
526 did_print_modifier = 1;
529 address_space_id = address_space_int_to_name (get_type_arch (type),
530 TYPE_INSTANCE_FLAGS (type));
531 if (address_space_id)
533 if (did_print_modifier || need_pre_space)
534 fprintf_filtered (stream, " ");
535 fprintf_filtered (stream, "@%s", address_space_id);
536 did_print_modifier = 1;
539 if (did_print_modifier && need_post_space)
540 fprintf_filtered (stream, " ");
544 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
545 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
546 in non-static methods, are displayed if LINKAGE_NAME is zero. If
547 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
548 parameter types get removed their possible const and volatile qualifiers to
549 match demangled linkage name parameters part of such function type.
550 LANGUAGE is the language in which TYPE was defined. This is a necessary
551 evil since this code is used by the C and C++. */
554 c_type_print_args (struct type *type, struct ui_file *stream,
555 int linkage_name, enum language language,
556 const struct type_print_options *flags)
561 fprintf_filtered (stream, "(");
563 for (i = 0; i < TYPE_NFIELDS (type); i++)
565 struct type *param_type;
567 if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
572 fprintf_filtered (stream, ", ");
576 param_type = TYPE_FIELD_TYPE (type, i);
578 if (language == language_cplus && linkage_name)
580 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
581 - Parameter declarations that differ only in the presence or
582 absence of const and/or volatile are equivalent.
584 And the const/volatile qualifiers are not present in the mangled
585 names as produced by GCC. */
587 param_type = make_cv_type (0, 0, param_type, NULL);
590 c_print_type (param_type, "", stream, -1, 0, language, flags);
594 if (printed_any && TYPE_VARARGS (type))
596 /* Print out a trailing ellipsis for varargs functions. Ignore
597 TYPE_VARARGS if the function has no named arguments; that
598 represents unprototyped (K&R style) C functions. */
599 if (printed_any && TYPE_VARARGS (type))
601 fprintf_filtered (stream, ", ");
603 fprintf_filtered (stream, "...");
606 else if (!printed_any
607 && (TYPE_PROTOTYPED (type) || language == language_cplus))
608 fprintf_filtered (stream, "void");
610 fprintf_filtered (stream, ")");
613 /* Return true iff the j'th overloading of the i'th method of TYPE
614 is a type conversion operator, like `operator int () { ... }'.
615 When listing a class's methods, we don't print the return type of
619 is_type_conversion_operator (struct type *type, int i, int j)
621 /* I think the whole idea of recognizing type conversion operators
622 by their name is pretty terrible. But I don't think our present
623 data structure gives us any other way to tell. If you know of
624 some other way, feel free to rewrite this function. */
625 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
627 if (!startswith (name, CP_OPERATOR_STR))
631 if (! strchr (" \t\f\n\r", *name))
634 while (strchr (" \t\f\n\r", *name))
637 if (!('a' <= *name && *name <= 'z')
638 && !('A' <= *name && *name <= 'Z')
640 /* If this doesn't look like the start of an identifier, then it
641 isn't a type conversion operator. */
643 else if (startswith (name, "new"))
645 else if (startswith (name, "delete"))
648 /* If it doesn't look like new or delete, it's a type conversion
652 /* Is that really the end of the name? */
653 if (('a' <= *name && *name <= 'z')
654 || ('A' <= *name && *name <= 'Z')
655 || ('0' <= *name && *name <= '9')
657 /* No, so the identifier following "operator" must be a type name,
658 and this is a type conversion operator. */
661 /* That was indeed the end of the name, so it was `operator new' or
662 `operator delete', neither of which are type conversion
667 /* Given a C++ qualified identifier QID, strip off the qualifiers,
668 yielding the unqualified name. The return value is a pointer into
671 It's a pity we don't have this information in some more structured
672 form. Even the author of this function feels that writing little
673 parsers like this everywhere is stupid. */
676 remove_qualifiers (char *qid)
678 int quoted = 0; /* Zero if we're not in quotes;
679 '"' if we're in a double-quoted string;
680 '\'' if we're in a single-quoted string. */
681 int depth = 0; /* Number of unclosed parens we've seen. */
682 char *parenstack = (char *) alloca (strlen (qid));
684 char *last = 0; /* The character after the rightmost
685 `::' token we've seen so far. */
687 for (scan = qid; *scan; scan++)
693 else if (*scan == '\\' && *(scan + 1))
696 else if (scan[0] == ':' && scan[1] == ':')
698 /* If we're inside parenthesis (i.e., an argument list) or
699 angle brackets (i.e., a list of template arguments), then
700 we don't record the position of this :: token, since it's
701 not relevant to the top-level structure we're trying to
709 else if (*scan == '"' || *scan == '\'')
711 else if (*scan == '(')
712 parenstack[depth++] = ')';
713 else if (*scan == '[')
714 parenstack[depth++] = ']';
715 /* We're going to treat <> as a pair of matching characters,
716 since we're more likely to see those in template id's than
717 real less-than characters. What a crock. */
718 else if (*scan == '<')
719 parenstack[depth++] = '>';
720 else if (*scan == ')' || *scan == ']' || *scan == '>')
722 if (depth > 0 && parenstack[depth - 1] == *scan)
726 /* We're going to do a little error recovery here. If
727 we don't find a match for *scan on the paren stack,
728 but there is something lower on the stack that does
729 match, we pop the stack to that point. */
732 for (i = depth - 1; i >= 0; i--)
733 if (parenstack[i] == *scan)
745 /* We didn't find any :: tokens at the top level, so declare the
746 whole thing an unqualified identifier. */
750 /* Print any array sizes, function arguments or close parentheses
751 needed after the variable name (to describe its type).
752 Args work like c_type_print_varspec_prefix. */
755 c_type_print_varspec_suffix (struct type *type,
756 struct ui_file *stream,
757 int show, int passed_a_ptr,
759 enum language language,
760 const struct type_print_options *flags)
765 if (TYPE_NAME (type) && show <= 0)
770 switch (TYPE_CODE (type))
772 case TYPE_CODE_ARRAY:
774 LONGEST low_bound, high_bound;
775 int is_vector = TYPE_VECTOR (type);
778 fprintf_filtered (stream, ")");
780 fprintf_filtered (stream, (is_vector ?
781 " __attribute__ ((vector_size(" : "["));
782 /* Bounds are not yet resolved, print a bounds placeholder instead. */
783 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCEXPR
784 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type)) == PROP_LOCLIST)
785 fprintf_filtered (stream, "variable length");
786 else if (get_array_bounds (type, &low_bound, &high_bound))
787 fprintf_filtered (stream, "%s",
788 plongest (high_bound - low_bound + 1));
789 fprintf_filtered (stream, (is_vector ? ")))" : "]"));
791 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
792 show, 0, 0, language, flags);
796 case TYPE_CODE_MEMBERPTR:
797 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
798 show, 0, 0, language, flags);
801 case TYPE_CODE_METHODPTR:
802 fprintf_filtered (stream, ")");
803 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
804 show, 0, 0, language, flags);
809 case TYPE_CODE_RVALUE_REF:
810 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
811 show, 1, 0, language, flags);
814 case TYPE_CODE_METHOD:
817 fprintf_filtered (stream, ")");
819 c_type_print_args (type, stream, 0, language, flags);
820 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
821 show, passed_a_ptr, 0, language, flags);
824 case TYPE_CODE_TYPEDEF:
825 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
826 show, passed_a_ptr, 0, language, flags);
829 case TYPE_CODE_UNDEF:
830 case TYPE_CODE_STRUCT:
831 case TYPE_CODE_UNION:
832 case TYPE_CODE_FLAGS:
837 case TYPE_CODE_ERROR:
841 case TYPE_CODE_RANGE:
842 case TYPE_CODE_STRING:
843 case TYPE_CODE_COMPLEX:
844 case TYPE_CODE_NAMESPACE:
845 case TYPE_CODE_DECFLOAT:
846 /* These types do not need a suffix. They are listed so that
847 gcc -Wall will report types that may not have been
851 error (_("type not handled in c_type_print_varspec_suffix()"));
856 /* A helper for c_type_print_base that displays template
857 parameters and their bindings, if needed.
859 TABLE is the local bindings table to use. If NULL, no printing is
860 done. Note that, at this point, TABLE won't have any useful
861 information in it -- but it is also used as a flag to
862 print_name_maybe_canonical to activate searching the global typedef
865 TYPE is the type whose template arguments are being displayed.
867 STREAM is the stream on which to print. */
870 c_type_print_template_args (const struct type_print_options *flags,
871 struct type *type, struct ui_file *stream)
878 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
880 struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
882 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
888 fprintf_filtered (stream, _("[with %s = "),
889 SYMBOL_LINKAGE_NAME (sym));
894 fputs_filtered (", ", stream);
896 fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
899 c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
903 fputs_filtered (_("] "), stream);
906 /* Use 'print_spaces_filtered', but take into consideration the
907 type_print_options FLAGS in order to determine how many whitespaces
911 print_spaces_filtered_with_print_options
912 (int level, struct ui_file *stream, const struct type_print_options *flags)
914 if (!flags->print_offsets)
915 print_spaces_filtered (level, stream);
917 print_spaces_filtered (level + OFFSET_SPC_LEN, stream);
920 /* Output an access specifier to STREAM, if needed. LAST_ACCESS is the
921 last access specifier output (typically returned by this function). */
923 static enum access_specifier
924 output_access_specifier (struct ui_file *stream,
925 enum access_specifier last_access,
926 int level, bool is_protected, bool is_private,
927 const struct type_print_options *flags)
931 if (last_access != s_protected)
933 last_access = s_protected;
934 print_spaces_filtered_with_print_options (level + 2, stream, flags);
935 fprintf_filtered (stream, "protected:\n");
940 if (last_access != s_private)
942 last_access = s_private;
943 print_spaces_filtered_with_print_options (level + 2, stream, flags);
944 fprintf_filtered (stream, "private:\n");
949 if (last_access != s_public)
951 last_access = s_public;
952 print_spaces_filtered_with_print_options (level + 2, stream, flags);
953 fprintf_filtered (stream, "public:\n");
960 /* Print information about field at index FIELD_IDX of the union type
961 TYPE. Since union fields don't have the concept of offsets, we
962 just print their sizes.
964 The output is strongly based on pahole(1). */
967 c_print_type_union_field_offset (struct type *type, unsigned int field_idx,
968 struct ui_file *stream)
970 struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx));
972 fprintf_filtered (stream, "/* %4u */", TYPE_LENGTH (ftype));
975 /* Helper function for ptype/o implementation that prints information
976 about a hole, if necessary. STREAM is where to print. BITPOS is
977 the bitpos of the current field. PODATA is the offset-printing
978 state. FOR_WHAT is a string describing the purpose of the
982 maybe_print_hole (struct ui_file *stream, unsigned int bitpos,
983 struct print_offset_data *podata, const char *for_what)
985 /* We check for PODATA->END_BITPOS > 0 because there is a specific
986 scenario when PODATA->END_BITPOS can be zero and BITPOS can be >
987 0: when we are dealing with a struct/class with a virtual method.
988 Because of the vtable, the first field of the struct/class will
989 have an offset of sizeof (void *) (the size of the vtable). If
990 we do not check for PODATA->END_BITPOS > 0 here, GDB will report
991 a hole before the first field, which is not accurate. */
992 if (podata->end_bitpos > 0 && podata->end_bitpos < bitpos)
994 /* If PODATA->END_BITPOS is smaller than the current type's
995 bitpos, it means there's a hole in the struct, so we report
997 unsigned int hole = bitpos - podata->end_bitpos;
998 unsigned int hole_byte = hole / TARGET_CHAR_BIT;
999 unsigned int hole_bit = hole % TARGET_CHAR_BIT;
1002 fprintf_filtered (stream, "/* XXX %2u-bit %s */\n", hole_bit,
1006 fprintf_filtered (stream, "/* XXX %2u-byte %s */\n", hole_byte,
1011 /* Print information about field at index FIELD_IDX of the struct type
1014 PODATA->END_BITPOS is the one-past-the-end bit position of the
1015 previous field (where we expect this field to be if there is no
1016 hole). At the end, ENDPOS is updated to the one-past-the-end bit
1017 position of the current field.
1019 PODATA->OFFSET_BITPOS is the offset value we carry over when we are
1020 printing a struct that is inside another struct; this is useful so
1021 that the offset is constantly incremented (if we didn't carry it
1022 over, the offset would be reset to zero when printing the inner
1025 The output is strongly based on pahole(1). */
1028 c_print_type_struct_field_offset (struct type *type, unsigned int field_idx,
1029 struct ui_file *stream,
1030 struct print_offset_data *podata)
1032 struct type *ftype = check_typedef (TYPE_FIELD_TYPE (type, field_idx));
1033 unsigned int bitpos = TYPE_FIELD_BITPOS (type, field_idx);
1034 unsigned int fieldsize_byte = TYPE_LENGTH (ftype);
1035 unsigned int fieldsize_bit = fieldsize_byte * TARGET_CHAR_BIT;
1037 maybe_print_hole (stream, bitpos, podata, "hole");
1039 if (TYPE_FIELD_PACKED (type, field_idx))
1041 /* We're dealing with a bitfield. Print how many bits are left
1043 unsigned int bitsize = TYPE_FIELD_BITSIZE (type, field_idx);
1044 /* The bitpos relative to the beginning of our container
1046 unsigned int relative_bitpos;
1048 /* The following was copied from
1049 value.c:value_primitive_field. */
1050 if ((bitpos % fieldsize_bit) + bitsize <= fieldsize_bit)
1051 relative_bitpos = bitpos % fieldsize_bit;
1053 relative_bitpos = bitpos % TARGET_CHAR_BIT;
1055 /* This is the exact offset (in bits) of this bitfield. */
1056 unsigned int bit_offset
1057 = (bitpos - relative_bitpos) + podata->offset_bitpos;
1059 /* The position of the field, relative to the beginning of the
1060 struct, and how many bits are left to be used in this
1062 fprintf_filtered (stream, "/* %4u:%2u", bit_offset / TARGET_CHAR_BIT,
1063 fieldsize_bit - (relative_bitpos + bitsize));
1064 fieldsize_bit = bitsize;
1068 /* The position of the field, relative to the beginning of the
1070 fprintf_filtered (stream, "/* %4u",
1071 (bitpos + podata->offset_bitpos) / TARGET_CHAR_BIT);
1073 fprintf_filtered (stream, " ");
1076 fprintf_filtered (stream, " | %4u */", fieldsize_byte);
1078 podata->end_bitpos = bitpos + fieldsize_bit;
1081 /* Return true if an access label (i.e., "public:", "private:",
1082 "protected:") needs to be printed for TYPE. */
1085 need_access_label_p (struct type *type)
1087 if (TYPE_DECLARED_CLASS (type))
1090 for (int i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
1091 if (!TYPE_FIELD_PRIVATE (type, i))
1094 for (int j = 0; j < TYPE_NFN_FIELDS (type); j++)
1095 for (int i = 0; i < TYPE_FN_FIELDLIST_LENGTH (type, j); i++)
1096 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1100 for (int i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); ++i)
1101 if (!TYPE_TYPEDEF_FIELD_PRIVATE (type, i))
1107 for (int i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
1108 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
1111 for (int j = 0; j < TYPE_NFN_FIELDS (type); j++)
1114 for (int i = 0; i < TYPE_FN_FIELDLIST_LENGTH (type, j); i++)
1115 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1117 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1123 for (int i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); ++i)
1124 if (TYPE_TYPEDEF_FIELD_PROTECTED (type, i)
1125 || TYPE_TYPEDEF_FIELD_PRIVATE (type, i))
1132 /* Helper function that temporarily disables FLAGS->PRINT_OFFSETS,
1133 calls 'c_print_type_1', and then reenables FLAGS->PRINT_OFFSETS if
1137 c_print_type_no_offsets (struct type *type,
1138 const char *varstring,
1139 struct ui_file *stream,
1140 int show, int level,
1141 enum language language,
1142 struct type_print_options *flags,
1143 struct print_offset_data *podata)
1145 unsigned int old_po = flags->print_offsets;
1147 /* Temporarily disable print_offsets, because it would mess with
1149 flags->print_offsets = 0;
1150 c_print_type_1 (type, varstring, stream, show, level, language, flags,
1152 flags->print_offsets = old_po;
1155 /* Helper for 'c_type_print_base' that handles structs and unions.
1156 For a description of the arguments, see 'c_type_print_base'. */
1159 c_type_print_base_struct_union (struct type *type, struct ui_file *stream,
1160 int show, int level,
1161 enum language language,
1162 const struct type_print_options *flags,
1163 struct print_offset_data *podata)
1165 struct type_print_options local_flags = *flags;
1166 local_flags.local_typedefs = NULL;
1168 std::unique_ptr<typedef_hash_table> hash_holder;
1171 if (flags->local_typedefs)
1172 local_flags.local_typedefs
1173 = new typedef_hash_table (*flags->local_typedefs);
1175 local_flags.local_typedefs = new typedef_hash_table ();
1177 hash_holder.reset (local_flags.local_typedefs);
1180 c_type_print_modifier (type, stream, 0, 1);
1181 if (TYPE_CODE (type) == TYPE_CODE_UNION)
1182 fprintf_filtered (stream, "union ");
1183 else if (TYPE_DECLARED_CLASS (type))
1184 fprintf_filtered (stream, "class ");
1186 fprintf_filtered (stream, "struct ");
1188 /* Print the tag if it exists. The HP aCC compiler emits a
1189 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
1190 enum}" tag for unnamed struct/union/enum's, which we don't
1192 if (TYPE_NAME (type) != NULL
1193 && !startswith (TYPE_NAME (type), "{unnamed"))
1195 /* When printing the tag name, we are still effectively
1196 printing in the outer context, hence the use of FLAGS
1198 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1200 fputs_filtered (" ", stream);
1205 /* If we just printed a tag name, no need to print anything
1207 if (TYPE_NAME (type) == NULL)
1208 fprintf_filtered (stream, "{...}");
1210 else if (show > 0 || TYPE_NAME (type) == NULL)
1212 struct type *basetype;
1215 c_type_print_template_args (&local_flags, type, stream);
1217 /* Add in template parameters when printing derivation info. */
1218 if (local_flags.local_typedefs != NULL)
1219 local_flags.local_typedefs->add_template_parameters (type);
1220 cp_type_print_derivation_info (stream, type, &local_flags);
1222 /* This holds just the global typedefs and the template
1224 struct type_print_options semi_local_flags = *flags;
1225 semi_local_flags.local_typedefs = NULL;
1227 std::unique_ptr<typedef_hash_table> semi_holder;
1228 if (local_flags.local_typedefs != nullptr)
1230 semi_local_flags.local_typedefs
1231 = new typedef_hash_table (*local_flags.local_typedefs);
1232 semi_holder.reset (semi_local_flags.local_typedefs);
1234 /* Now add in the local typedefs. */
1235 local_flags.local_typedefs->recursively_update (type);
1238 fprintf_filtered (stream, "{\n");
1240 if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
1241 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
1243 if (TYPE_STUB (type))
1244 fprintfi_filtered (level + 4, stream,
1245 _("<incomplete type>\n"));
1247 fprintfi_filtered (level + 4, stream,
1248 _("<no data fields>\n"));
1251 /* Start off with no specific section type, so we can print
1252 one for the first field we find, and use that section type
1253 thereafter until we find another type. */
1255 enum access_specifier section_type = s_none;
1257 /* For a class, if all members are private, there's no need
1258 for a "private:" label; similarly, for a struct or union
1259 masquerading as a class, if all members are public, there's
1260 no need for a "public:" label. */
1261 bool need_access_label = need_access_label_p (type);
1263 /* If there is a base class for this type,
1264 do not print the field that it occupies. */
1266 int len = TYPE_NFIELDS (type);
1267 vptr_fieldno = get_vptr_fieldno (type, &basetype);
1269 struct print_offset_data local_podata;
1271 for (int i = TYPE_N_BASECLASSES (type); i < len; i++)
1275 /* If we have a virtual table pointer, omit it. Even if
1276 virtual table pointers are not specifically marked in
1277 the debug info, they should be artificial. */
1278 if ((i == vptr_fieldno && type == basetype)
1279 || TYPE_FIELD_ARTIFICIAL (type, i))
1282 if (need_access_label)
1284 section_type = output_access_specifier
1285 (stream, section_type, level,
1286 TYPE_FIELD_PROTECTED (type, i),
1287 TYPE_FIELD_PRIVATE (type, i), flags);
1290 bool is_static = field_is_static (&TYPE_FIELD (type, i));
1292 if (flags->print_offsets)
1296 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1298 c_print_type_struct_field_offset
1299 (type, i, stream, podata);
1301 else if (TYPE_CODE (type) == TYPE_CODE_UNION)
1302 c_print_type_union_field_offset (type, i, stream);
1305 print_spaces_filtered (OFFSET_SPC_LEN, stream);
1308 print_spaces_filtered (level + 4, stream);
1310 fprintf_filtered (stream, "static ");
1312 int newshow = show - 1;
1314 if (flags->print_offsets
1315 && (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_STRUCT
1316 || TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION))
1318 /* If we're printing offsets and this field's type is
1319 either a struct or an union, then we're interested in
1323 /* Make sure we carry our offset when we expand the
1325 local_podata.offset_bitpos
1326 = podata->offset_bitpos + TYPE_FIELD_BITPOS (type, i);
1327 /* We're entering a struct/union. Right now,
1328 PODATA->END_BITPOS points right *after* the
1329 struct/union. However, when printing the first field
1330 of this inner struct/union, the end_bitpos we're
1331 expecting is exactly at the beginning of the
1332 struct/union. Therefore, we subtract the length of
1333 the whole struct/union. */
1334 local_podata.end_bitpos
1335 = podata->end_bitpos
1336 - TYPE_LENGTH (TYPE_FIELD_TYPE (type, i)) * TARGET_CHAR_BIT;
1339 c_print_type_1 (TYPE_FIELD_TYPE (type, i),
1340 TYPE_FIELD_NAME (type, i),
1341 stream, newshow, level + 4,
1342 language, &local_flags, &local_podata);
1344 if (!is_static && TYPE_FIELD_PACKED (type, i))
1346 /* It is a bitfield. This code does not attempt
1347 to look at the bitpos and reconstruct filler,
1348 unnamed fields. This would lead to misleading
1349 results if the compiler does not put out fields
1350 for such things (I don't know what it does). */
1351 fprintf_filtered (stream, " : %d",
1352 TYPE_FIELD_BITSIZE (type, i));
1354 fprintf_filtered (stream, ";\n");
1357 /* If there are both fields and methods, put a blank line
1358 between them. Make sure to count only method that we
1359 will display; artificial methods will be hidden. */
1360 len = TYPE_NFN_FIELDS (type);
1361 if (!flags->print_methods)
1364 for (int i = 0; i < len; i++)
1366 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1367 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1370 for (j = 0; j < len2; j++)
1371 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1374 if (real_len > 0 && section_type != s_none)
1375 fprintf_filtered (stream, "\n");
1377 /* C++: print out the methods. */
1378 for (int i = 0; i < len; i++)
1380 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1381 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1382 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1383 const char *name = type_name_no_tag (type);
1384 int is_constructor = name && strcmp (method_name,
1387 for (j = 0; j < len2; j++)
1389 const char *mangled_name;
1390 gdb::unique_xmalloc_ptr<char> mangled_name_holder;
1391 char *demangled_name;
1392 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1393 int is_full_physname_constructor =
1394 TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1395 || is_constructor_name (physname)
1396 || is_destructor_name (physname)
1397 || method_name[0] == '~';
1399 /* Do not print out artificial methods. */
1400 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1404 section_type = output_access_specifier
1405 (stream, section_type, level,
1406 TYPE_FN_FIELD_PROTECTED (f, j),
1407 TYPE_FN_FIELD_PRIVATE (f, j), flags);
1409 print_spaces_filtered_with_print_options (level + 4, stream,
1411 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1412 fprintf_filtered (stream, "virtual ");
1413 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1414 fprintf_filtered (stream, "static ");
1415 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1417 /* Keep GDB from crashing here. */
1418 fprintf_filtered (stream,
1419 _("<undefined type> %s;\n"),
1420 TYPE_FN_FIELD_PHYSNAME (f, j));
1423 else if (!is_constructor /* Constructors don't
1426 && !is_full_physname_constructor /* " " */
1427 && !is_type_conversion_operator (type, i, j))
1429 c_print_type_no_offsets
1430 (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1431 "", stream, -1, 0, language, &local_flags, podata);
1433 fputs_filtered (" ", stream);
1435 if (TYPE_FN_FIELD_STUB (f, j))
1437 /* Build something we can demangle. */
1438 mangled_name_holder.reset (gdb_mangle_name (type, i, j));
1439 mangled_name = mangled_name_holder.get ();
1442 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1445 gdb_demangle (mangled_name,
1446 DMGL_ANSI | DMGL_PARAMS);
1447 if (demangled_name == NULL)
1449 /* In some cases (for instance with the HP
1450 demangling), if a function has more than 10
1451 arguments, the demangling will fail.
1452 Let's try to reconstruct the function
1453 signature from the symbol information. */
1454 if (!TYPE_FN_FIELD_STUB (f, j))
1456 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1457 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1459 cp_type_print_method_args (mtype,
1467 fprintf_filtered (stream,
1468 _("<badly mangled name '%s'>"),
1474 char *demangled_no_class
1475 = remove_qualifiers (demangled_name);
1477 /* Get rid of the `static' appended by the
1479 p = strstr (demangled_no_class, " static");
1482 int length = p - demangled_no_class;
1483 char *demangled_no_static;
1486 = (char *) xmalloc (length + 1);
1487 strncpy (demangled_no_static,
1488 demangled_no_class, length);
1489 *(demangled_no_static + length) = '\0';
1490 fputs_filtered (demangled_no_static, stream);
1491 xfree (demangled_no_static);
1494 fputs_filtered (demangled_no_class, stream);
1495 xfree (demangled_name);
1498 fprintf_filtered (stream, ";\n");
1502 /* Print out nested types. */
1503 if (TYPE_NESTED_TYPES_COUNT (type) != 0
1504 && semi_local_flags.print_nested_type_limit != 0)
1506 if (semi_local_flags.print_nested_type_limit > 0)
1507 --semi_local_flags.print_nested_type_limit;
1509 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1510 fprintf_filtered (stream, "\n");
1512 for (int i = 0; i < TYPE_NESTED_TYPES_COUNT (type); ++i)
1514 print_spaces_filtered_with_print_options (level + 4, stream,
1516 c_print_type_no_offsets (TYPE_NESTED_TYPES_FIELD_TYPE (type, i),
1517 "", stream, show, level + 4,
1518 language, &semi_local_flags, podata);
1519 fprintf_filtered (stream, ";\n");
1523 /* Print typedefs defined in this class. */
1525 if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1527 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0
1528 || TYPE_NESTED_TYPES_COUNT (type) != 0)
1529 fprintf_filtered (stream, "\n");
1531 for (int i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1533 struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1535 /* Dereference the typedef declaration itself. */
1536 gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1537 target = TYPE_TARGET_TYPE (target);
1539 if (need_access_label)
1541 section_type = output_access_specifier
1542 (stream, section_type, level,
1543 TYPE_TYPEDEF_FIELD_PROTECTED (type, i),
1544 TYPE_TYPEDEF_FIELD_PRIVATE (type, i), flags);
1546 print_spaces_filtered_with_print_options (level + 4, stream,
1548 fprintf_filtered (stream, "typedef ");
1550 /* We want to print typedefs with substitutions
1551 from the template parameters or globally-known
1552 typedefs but not local typedefs. */
1553 c_print_type_no_offsets (target,
1554 TYPE_TYPEDEF_FIELD_NAME (type, i),
1555 stream, show - 1, level + 4,
1556 language, &semi_local_flags, podata);
1557 fprintf_filtered (stream, ";\n");
1561 if (flags->print_offsets)
1565 unsigned int bitpos = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
1566 maybe_print_hole (stream, bitpos, podata, "padding");
1568 fputs_filtered ("\n", stream);
1569 print_spaces_filtered_with_print_options (level + 4,
1572 fprintf_filtered (stream, "/* total size (bytes): %4u */\n",
1573 TYPE_LENGTH (type));
1576 print_spaces_filtered (OFFSET_SPC_LEN, stream);
1578 print_spaces_filtered (2, stream);
1581 fprintfi_filtered (level, stream, "}");
1585 /* Print the name of the type (or the ultimate pointer target,
1586 function value or array element), or the description of a structure
1589 SHOW positive means print details about the type (e.g. enum
1590 values), and print structure elements passing SHOW - 1 for show.
1592 SHOW negative means just print the type name or struct tag if there
1593 is one. If there is no name, print something sensible but concise
1594 like "struct {...}".
1596 SHOW zero means just print the type name or struct tag if there is
1597 one. If there is no name, print something sensible but not as
1598 concise like "struct {int x; int y;}".
1600 LEVEL is the number of spaces to indent by.
1601 We increase it for some recursive calls. */
1604 c_type_print_base_1 (struct type *type, struct ui_file *stream,
1605 int show, int level,
1606 enum language language,
1607 const struct type_print_options *flags,
1608 struct print_offset_data *podata)
1617 fputs_filtered (_("<type unknown>"), stream);
1621 /* When SHOW is zero or less, and there is a valid type name, then
1622 always just print the type name directly from the type. */
1625 && TYPE_NAME (type) != NULL)
1627 c_type_print_modifier (type, stream, 0, 1);
1629 /* If we have "typedef struct foo {. . .} bar;" do we want to
1630 print it as "struct foo" or as "bar"? Pick the latter for
1631 C++, because C++ folk tend to expect things like "class5
1632 *foo" rather than "struct class5 *foo". We rather
1633 arbitrarily choose to make language_minimal work in a C-like
1635 if (language == language_c || language == language_minimal)
1637 if (TYPE_CODE (type) == TYPE_CODE_UNION)
1638 fprintf_filtered (stream, "union ");
1639 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1641 if (TYPE_DECLARED_CLASS (type))
1642 fprintf_filtered (stream, "class ");
1644 fprintf_filtered (stream, "struct ");
1646 else if (TYPE_CODE (type) == TYPE_CODE_ENUM)
1647 fprintf_filtered (stream, "enum ");
1650 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1654 type = check_typedef (type);
1656 switch (TYPE_CODE (type))
1658 case TYPE_CODE_TYPEDEF:
1659 /* If we get here, the typedef doesn't have a name, and we
1660 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
1661 gdb_assert (TYPE_NAME (type) == NULL);
1662 gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
1663 fprintf_filtered (stream, _("<unnamed typedef>"));
1666 case TYPE_CODE_FUNC:
1667 case TYPE_CODE_METHOD:
1668 if (TYPE_TARGET_TYPE (type) == NULL)
1669 type_print_unknown_return_type (stream);
1671 c_type_print_base_1 (TYPE_TARGET_TYPE (type),
1672 stream, show, level, language, flags, podata);
1674 case TYPE_CODE_ARRAY:
1676 case TYPE_CODE_MEMBERPTR:
1678 case TYPE_CODE_RVALUE_REF:
1679 case TYPE_CODE_METHODPTR:
1680 c_type_print_base_1 (TYPE_TARGET_TYPE (type),
1681 stream, show, level, language, flags, podata);
1684 case TYPE_CODE_STRUCT:
1685 case TYPE_CODE_UNION:
1686 c_type_print_base_struct_union (type, stream, show, level,
1687 language, flags, podata);
1690 case TYPE_CODE_ENUM:
1691 c_type_print_modifier (type, stream, 0, 1);
1692 fprintf_filtered (stream, "enum ");
1693 if (TYPE_DECLARED_CLASS (type))
1694 fprintf_filtered (stream, "class ");
1695 /* Print the tag name if it exists.
1696 The aCC compiler emits a spurious
1697 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1698 tag for unnamed struct/union/enum's, which we don't
1700 if (TYPE_NAME (type) != NULL
1701 && !startswith (TYPE_NAME (type), "{unnamed"))
1703 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1705 fputs_filtered (" ", stream);
1711 /* If we just printed a tag name, no need to print anything
1713 if (TYPE_NAME (type) == NULL)
1714 fprintf_filtered (stream, "{...}");
1716 else if (show > 0 || TYPE_NAME (type) == NULL)
1718 LONGEST lastval = 0;
1720 /* We can't handle this case perfectly, as DWARF does not
1721 tell us whether or not the underlying type was specified
1722 in the source (and other debug formats don't provide this
1723 at all). We choose to print the underlying type, if it
1724 has a name, when in C++ on the theory that it's better to
1725 print too much than too little; but conversely not to
1726 print something egregiously outside the current
1727 language's syntax. */
1728 if (language == language_cplus && TYPE_TARGET_TYPE (type) != NULL)
1730 struct type *underlying = check_typedef (TYPE_TARGET_TYPE (type));
1732 if (TYPE_NAME (underlying) != NULL)
1733 fprintf_filtered (stream, ": %s ", TYPE_NAME (underlying));
1736 fprintf_filtered (stream, "{");
1737 len = TYPE_NFIELDS (type);
1738 for (i = 0; i < len; i++)
1742 fprintf_filtered (stream, ", ");
1744 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1745 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1747 fprintf_filtered (stream, " = %s",
1748 plongest (TYPE_FIELD_ENUMVAL (type, i)));
1749 lastval = TYPE_FIELD_ENUMVAL (type, i);
1753 fprintf_filtered (stream, "}");
1757 case TYPE_CODE_FLAGS:
1759 struct type_print_options local_flags = *flags;
1761 local_flags.local_typedefs = NULL;
1763 c_type_print_modifier (type, stream, 0, 1);
1764 fprintf_filtered (stream, "flag ");
1765 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1768 fputs_filtered (" ", stream);
1769 fprintf_filtered (stream, "{\n");
1770 if (TYPE_NFIELDS (type) == 0)
1772 if (TYPE_STUB (type))
1773 fprintfi_filtered (level + 4, stream,
1774 _("<incomplete type>\n"));
1776 fprintfi_filtered (level + 4, stream,
1777 _("<no data fields>\n"));
1779 len = TYPE_NFIELDS (type);
1780 for (i = 0; i < len; i++)
1783 print_spaces_filtered (level + 4, stream);
1784 /* We pass "show" here and not "show - 1" to get enum types
1785 printed. There's no other way to see them. */
1786 c_print_type_1 (TYPE_FIELD_TYPE (type, i),
1787 TYPE_FIELD_NAME (type, i),
1788 stream, show, level + 4,
1789 language, &local_flags, podata);
1790 fprintf_filtered (stream, " @%s",
1791 plongest (TYPE_FIELD_BITPOS (type, i)));
1792 if (TYPE_FIELD_BITSIZE (type, i) > 1)
1794 fprintf_filtered (stream, "-%s",
1795 plongest (TYPE_FIELD_BITPOS (type, i)
1796 + TYPE_FIELD_BITSIZE (type, i)
1799 fprintf_filtered (stream, ";\n");
1801 fprintfi_filtered (level, stream, "}");
1806 case TYPE_CODE_VOID:
1807 fprintf_filtered (stream, "void");
1810 case TYPE_CODE_UNDEF:
1811 fprintf_filtered (stream, _("struct <unknown>"));
1814 case TYPE_CODE_ERROR:
1815 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1818 case TYPE_CODE_RANGE:
1819 /* This should not occur. */
1820 fprintf_filtered (stream, _("<range type>"));
1823 case TYPE_CODE_NAMESPACE:
1824 fputs_filtered ("namespace ", stream);
1825 fputs_filtered (TYPE_NAME (type), stream);
1829 /* Handle types not explicitly handled by the other cases, such
1830 as fundamental types. For these, just print whatever the
1831 type name is, as recorded in the type itself. If there is no
1832 type name, then complain. */
1833 if (TYPE_NAME (type) != NULL)
1835 c_type_print_modifier (type, stream, 0, 1);
1836 print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1840 /* At least for dump_symtab, it is important that this not
1842 fprintf_filtered (stream, _("<invalid type code %d>"),
1849 /* See c_type_print_base_1. */
1852 c_type_print_base (struct type *type, struct ui_file *stream,
1853 int show, int level,
1854 const struct type_print_options *flags)
1856 struct print_offset_data podata;
1858 c_type_print_base_1 (type, stream, show, level,
1859 current_language->la_language, flags, &podata);