1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2023 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 "gdbsupport/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
*,
61 int, int, enum language
);
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
)
87 gdb::unique_xmalloc_ptr
<char> s
;
90 s
= cp_canonicalize_string_full (name
,
91 find_typedef_for_canonicalize
,
94 gdb_puts (s
!= nullptr ? s
.get () : 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 ();
120 if (local_name
!= NULL
)
122 c_type_print_modifier (type
, stream
, 0, 1, language
);
123 gdb_puts (local_name
, stream
);
124 if (varstring
!= NULL
&& *varstring
!= '\0')
125 gdb_puts (" ", stream
);
129 c_type_print_base_1 (type
, stream
, show
, level
, language
, flags
, podata
);
130 if ((varstring
!= NULL
&& *varstring
!= '\0')
131 /* Need a space if going to print stars or brackets;
132 but not if we will print just a type name. */
133 || ((show
> 0 || type
->name () == 0)
134 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
135 || code
== TYPE_CODE_METHOD
136 || (code
== TYPE_CODE_ARRAY
137 && !type
->is_vector ())
138 || code
== TYPE_CODE_MEMBERPTR
139 || code
== TYPE_CODE_METHODPTR
140 || TYPE_IS_REFERENCE (type
))))
141 gdb_puts (" ", stream
);
142 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
143 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
144 language
, flags
, podata
);
147 if (varstring
!= NULL
)
149 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
150 fputs_styled (varstring
, function_name_style
.style (), stream
);
152 fputs_styled (varstring
, variable_name_style
.style (), stream
);
154 /* For demangled function names, we have the arglist as part of
155 the name, so don't print an additional pair of ()'s. */
156 if (local_name
== NULL
)
158 demangled_args
= strchr (varstring
, '(') != NULL
;
159 c_type_print_varspec_suffix (type
, stream
, show
,
169 c_print_type (struct type
*type
,
170 const char *varstring
,
171 struct ui_file
*stream
,
173 enum language language
,
174 const struct type_print_options
*flags
)
176 struct print_offset_data
podata (flags
);
178 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
182 /* Print a typedef using C syntax. TYPE is the underlying type.
183 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
187 c_print_typedef (struct type
*type
,
188 struct symbol
*new_symbol
,
189 struct ui_file
*stream
)
191 type
= check_typedef (type
);
192 gdb_printf (stream
, "typedef ");
193 type_print (type
, "", stream
, -1);
194 if ((new_symbol
->type ())->name () == 0
195 || strcmp ((new_symbol
->type ())->name (),
196 new_symbol
->linkage_name ()) != 0
197 || new_symbol
->type ()->code () == TYPE_CODE_TYPEDEF
)
198 gdb_printf (stream
, " %s", new_symbol
->print_name ());
199 gdb_printf (stream
, ";");
202 /* If TYPE is a derived type, then print out derivation information.
203 Print only the actual base classes of this type, not the base
204 classes of the base classes. I.e. for the derivation hierarchy:
207 class B : public A {int b; };
208 class C : public B {int c; };
210 Print the type of class C as:
216 Not as the following (like gdb used to), which is not legal C++
217 syntax for derived types and may be confused with the multiple
220 class C : public B : public A {
224 In general, gdb should try to print the types as closely as
225 possible to the form that they appear in the source code. */
228 cp_type_print_derivation_info (struct ui_file
*stream
,
230 const struct type_print_options
*flags
)
235 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
237 stream
->wrap_here (8);
238 gdb_puts (i
== 0 ? ": " : ", ", stream
);
239 gdb_printf (stream
, "%s%s ",
240 BASETYPE_VIA_PUBLIC (type
, i
)
241 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
242 ? "protected" : "private"),
243 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
244 name
= TYPE_BASECLASS (type
, i
)->name ();
246 print_name_maybe_canonical (name
, flags
, stream
);
248 gdb_printf (stream
, "(null)");
252 gdb_puts (" ", stream
);
256 /* Print the C++ method arguments ARGS to the file STREAM. */
259 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
260 const char *varstring
, int staticp
,
261 struct ui_file
*stream
,
262 enum language language
,
263 const struct type_print_options
*flags
)
265 struct field
*args
= mtype
->fields ();
266 int nargs
= mtype
->num_fields ();
267 int varargs
= mtype
->has_varargs ();
270 fprintf_symbol (stream
, prefix
,
271 language_cplus
, DMGL_ANSI
);
272 fprintf_symbol (stream
, varstring
,
273 language_cplus
, DMGL_ANSI
);
274 gdb_puts ("(", stream
);
276 int printed_args
= 0;
277 for (i
= 0; i
< nargs
; ++i
)
279 if (i
== 0 && !staticp
)
281 /* Skip the class variable. We keep this here to accommodate older
282 compilers and debug formats which may not support artificial
287 struct field arg
= args
[i
];
288 /* Skip any artificial arguments. */
289 if (FIELD_ARTIFICIAL (arg
))
292 if (printed_args
> 0)
294 gdb_printf (stream
, ", ");
295 stream
->wrap_here (8);
298 c_print_type (arg
.type (), "", stream
, 0, 0, language
, flags
);
304 if (printed_args
== 0)
305 gdb_printf (stream
, "...");
307 gdb_printf (stream
, ", ...");
309 else if (printed_args
== 0)
311 if (language
== language_cplus
)
312 gdb_printf (stream
, "void");
315 gdb_printf (stream
, ")");
317 /* For non-static methods, read qualifiers from the type of
323 gdb_assert (nargs
> 0);
324 gdb_assert (args
[0].type ()->code () == TYPE_CODE_PTR
);
325 domain
= args
[0].type ()->target_type ();
327 if (TYPE_CONST (domain
))
328 gdb_printf (stream
, " const");
330 if (TYPE_VOLATILE (domain
))
331 gdb_printf (stream
, " volatile");
333 if (TYPE_RESTRICT (domain
))
334 gdb_printf (stream
, (language
== language_cplus
338 if (TYPE_ATOMIC (domain
))
339 gdb_printf (stream
, " _Atomic");
344 /* Print any asterisks or open-parentheses needed before the
345 variable name (to describe its type).
347 On outermost call, pass 0 for PASSED_A_PTR.
348 On outermost call, SHOW > 0 means should ignore
349 any typename for TYPE and show its details.
350 SHOW is always zero on recursive calls.
352 NEED_POST_SPACE is non-zero when a space will be be needed
353 between a trailing qualifier and a field, variable, or function
357 c_type_print_varspec_prefix (struct type
*type
,
358 struct ui_file
*stream
,
359 int show
, int passed_a_ptr
,
361 enum language language
,
362 const struct type_print_options
*flags
,
363 struct print_offset_data
*podata
)
370 if (type
->name () && show
<= 0)
375 switch (type
->code ())
378 c_type_print_varspec_prefix (type
->target_type (),
379 stream
, show
, 1, 1, language
, flags
,
381 gdb_printf (stream
, "*");
382 c_type_print_modifier (type
, stream
, 1, need_post_space
, language
);
385 case TYPE_CODE_MEMBERPTR
:
386 c_type_print_varspec_prefix (type
->target_type (),
387 stream
, show
, 0, 0, language
, flags
, podata
);
388 name
= TYPE_SELF_TYPE (type
)->name ();
390 print_name_maybe_canonical (name
, flags
, stream
);
392 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
393 stream
, -1, passed_a_ptr
, language
, flags
,
395 gdb_printf (stream
, "::*");
398 case TYPE_CODE_METHODPTR
:
399 c_type_print_varspec_prefix (type
->target_type (),
400 stream
, show
, 0, 0, language
, flags
,
402 gdb_printf (stream
, "(");
403 name
= TYPE_SELF_TYPE (type
)->name ();
405 print_name_maybe_canonical (name
, flags
, stream
);
407 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
408 stream
, -1, passed_a_ptr
, language
, flags
,
410 gdb_printf (stream
, "::*");
414 case TYPE_CODE_RVALUE_REF
:
415 c_type_print_varspec_prefix (type
->target_type (),
416 stream
, show
, 1, 0, language
, flags
,
418 gdb_printf (stream
, type
->code () == TYPE_CODE_REF
? "&" : "&&");
419 c_type_print_modifier (type
, stream
, 1, need_post_space
, language
);
422 case TYPE_CODE_METHOD
:
424 c_type_print_varspec_prefix (type
->target_type (),
425 stream
, show
, 0, 0, language
, flags
,
428 gdb_printf (stream
, "(");
431 case TYPE_CODE_ARRAY
:
432 c_type_print_varspec_prefix (type
->target_type (),
433 stream
, show
, 0, need_post_space
,
434 language
, flags
, podata
);
436 gdb_printf (stream
, "(");
439 case TYPE_CODE_TYPEDEF
:
440 c_type_print_varspec_prefix (type
->target_type (),
441 stream
, show
, passed_a_ptr
, 0,
442 language
, flags
, podata
);
445 case TYPE_CODE_UNDEF
:
446 case TYPE_CODE_STRUCT
:
447 case TYPE_CODE_UNION
:
449 case TYPE_CODE_FLAGS
:
453 case TYPE_CODE_ERROR
:
457 case TYPE_CODE_RANGE
:
458 case TYPE_CODE_STRING
:
459 case TYPE_CODE_COMPLEX
:
460 case TYPE_CODE_NAMESPACE
:
461 case TYPE_CODE_DECFLOAT
:
462 case TYPE_CODE_FIXED_POINT
:
463 /* These types need no prefix. They are listed here so that
464 gcc -Wall will reveal any types that haven't been handled. */
467 error (_("type not handled in c_type_print_varspec_prefix()"));
472 /* Print out "const" and "volatile" attributes,
473 and address space id if present.
474 TYPE is a pointer to the type being printed out.
475 STREAM is the output destination.
476 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
477 NEED_POST_SPACE = 1 indicates a final white space is needed. */
480 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
481 int need_pre_space
, int need_post_space
,
482 enum language language
)
484 int did_print_modifier
= 0;
485 const char *address_space_id
;
487 /* We don't print `const' qualifiers for references --- since all
488 operators affect the thing referenced, not the reference itself,
489 every reference is `const'. */
490 if (TYPE_CONST (type
) && !TYPE_IS_REFERENCE (type
))
493 gdb_printf (stream
, " ");
494 gdb_printf (stream
, "const");
495 did_print_modifier
= 1;
498 if (TYPE_VOLATILE (type
))
500 if (did_print_modifier
|| need_pre_space
)
501 gdb_printf (stream
, " ");
502 gdb_printf (stream
, "volatile");
503 did_print_modifier
= 1;
506 if (TYPE_RESTRICT (type
))
508 if (did_print_modifier
|| need_pre_space
)
509 gdb_printf (stream
, " ");
510 gdb_printf (stream
, (language
== language_cplus
513 did_print_modifier
= 1;
516 if (TYPE_ATOMIC (type
))
518 if (did_print_modifier
|| need_pre_space
)
519 gdb_printf (stream
, " ");
520 gdb_printf (stream
, "_Atomic");
521 did_print_modifier
= 1;
525 = address_space_type_instance_flags_to_name (type
->arch (),
526 type
->instance_flags ());
527 if (address_space_id
)
529 if (did_print_modifier
|| need_pre_space
)
530 gdb_printf (stream
, " ");
531 gdb_printf (stream
, "@%s", address_space_id
);
532 did_print_modifier
= 1;
535 if (did_print_modifier
&& need_post_space
)
536 gdb_printf (stream
, " ");
540 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
541 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
542 in non-static methods, are displayed if LINKAGE_NAME is zero. If
543 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
544 parameter types get removed their possible const and volatile qualifiers to
545 match demangled linkage name parameters part of such function type.
546 LANGUAGE is the language in which TYPE was defined. This is a necessary
547 evil since this code is used by the C and C++. */
550 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
551 int linkage_name
, enum language language
,
552 const struct type_print_options
*flags
)
557 gdb_printf (stream
, "(");
559 for (i
= 0; i
< type
->num_fields (); i
++)
561 struct type
*param_type
;
563 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
568 gdb_printf (stream
, ", ");
569 stream
->wrap_here (4);
572 param_type
= type
->field (i
).type ();
574 if (language
== language_cplus
&& linkage_name
)
576 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
577 - Parameter declarations that differ only in the presence or
578 absence of const and/or volatile are equivalent.
580 And the const/volatile qualifiers are not present in the mangled
581 names as produced by GCC. */
583 param_type
= make_cv_type (0, 0, param_type
, NULL
);
586 c_print_type (param_type
, "", stream
, -1, 0, language
, flags
);
590 if (printed_any
&& type
->has_varargs ())
592 /* Print out a trailing ellipsis for varargs functions. Ignore
593 TYPE_VARARGS if the function has no named arguments; that
594 represents unprototyped (K&R style) C functions. */
595 if (printed_any
&& type
->has_varargs ())
597 gdb_printf (stream
, ", ");
598 stream
->wrap_here (4);
599 gdb_printf (stream
, "...");
602 else if (!printed_any
603 && (type
->is_prototyped () || language
== language_cplus
))
604 gdb_printf (stream
, "void");
606 gdb_printf (stream
, ")");
609 /* Return true iff the j'th overloading of the i'th method of TYPE
610 is a type conversion operator, like `operator int () { ... }'.
611 When listing a class's methods, we don't print the return type of
615 is_type_conversion_operator (struct type
*type
, int i
, int j
)
617 /* I think the whole idea of recognizing type conversion operators
618 by their name is pretty terrible. But I don't think our present
619 data structure gives us any other way to tell. If you know of
620 some other way, feel free to rewrite this function. */
621 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
623 if (!startswith (name
, CP_OPERATOR_STR
))
627 if (! strchr (" \t\f\n\r", *name
))
630 while (strchr (" \t\f\n\r", *name
))
633 if (!('a' <= *name
&& *name
<= 'z')
634 && !('A' <= *name
&& *name
<= 'Z')
636 /* If this doesn't look like the start of an identifier, then it
637 isn't a type conversion operator. */
639 else if (startswith (name
, "new"))
641 else if (startswith (name
, "delete"))
644 /* If it doesn't look like new or delete, it's a type conversion
648 /* Is that really the end of the name? */
649 if (('a' <= *name
&& *name
<= 'z')
650 || ('A' <= *name
&& *name
<= 'Z')
651 || ('0' <= *name
&& *name
<= '9')
653 /* No, so the identifier following "operator" must be a type name,
654 and this is a type conversion operator. */
657 /* That was indeed the end of the name, so it was `operator new' or
658 `operator delete', neither of which are type conversion
663 /* Given a C++ qualified identifier QID, strip off the qualifiers,
664 yielding the unqualified name. The return value is a pointer into
667 It's a pity we don't have this information in some more structured
668 form. Even the author of this function feels that writing little
669 parsers like this everywhere is stupid. */
672 remove_qualifiers (const char *qid
)
674 int quoted
= 0; /* Zero if we're not in quotes;
675 '"' if we're in a double-quoted string;
676 '\'' if we're in a single-quoted string. */
677 int depth
= 0; /* Number of unclosed parens we've seen. */
678 char *parenstack
= (char *) alloca (strlen (qid
));
680 const char *last
= 0; /* The character after the rightmost
681 `::' token we've seen so far. */
683 for (scan
= qid
; *scan
; scan
++)
689 else if (*scan
== '\\' && *(scan
+ 1))
692 else if (scan
[0] == ':' && scan
[1] == ':')
694 /* If we're inside parenthesis (i.e., an argument list) or
695 angle brackets (i.e., a list of template arguments), then
696 we don't record the position of this :: token, since it's
697 not relevant to the top-level structure we're trying to
705 else if (*scan
== '"' || *scan
== '\'')
707 else if (*scan
== '(')
708 parenstack
[depth
++] = ')';
709 else if (*scan
== '[')
710 parenstack
[depth
++] = ']';
711 /* We're going to treat <> as a pair of matching characters,
712 since we're more likely to see those in template id's than
713 real less-than characters. What a crock. */
714 else if (*scan
== '<')
715 parenstack
[depth
++] = '>';
716 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
718 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
722 /* We're going to do a little error recovery here. If
723 we don't find a match for *scan on the paren stack,
724 but there is something lower on the stack that does
725 match, we pop the stack to that point. */
728 for (i
= depth
- 1; i
>= 0; i
--)
729 if (parenstack
[i
] == *scan
)
741 /* We didn't find any :: tokens at the top level, so declare the
742 whole thing an unqualified identifier. */
746 /* Print any array sizes, function arguments or close parentheses
747 needed after the variable name (to describe its type).
748 Args work like c_type_print_varspec_prefix. */
751 c_type_print_varspec_suffix (struct type
*type
,
752 struct ui_file
*stream
,
753 int show
, int passed_a_ptr
,
755 enum language language
,
756 const struct type_print_options
*flags
)
761 if (type
->name () && show
<= 0)
766 switch (type
->code ())
768 case TYPE_CODE_ARRAY
:
770 LONGEST low_bound
, high_bound
;
771 int is_vector
= type
->is_vector ();
774 gdb_printf (stream
, ")");
776 gdb_printf (stream
, (is_vector
?
777 " __attribute__ ((vector_size(" : "["));
778 /* Bounds are not yet resolved, print a bounds placeholder instead. */
779 if (type
->bounds ()->high
.kind () == PROP_LOCEXPR
780 || type
->bounds ()->high
.kind () == PROP_LOCLIST
)
781 gdb_printf (stream
, "variable length");
782 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
783 gdb_printf (stream
, "%s",
784 plongest (high_bound
- low_bound
+ 1));
785 gdb_printf (stream
, (is_vector
? ")))" : "]"));
787 c_type_print_varspec_suffix (type
->target_type (), stream
,
788 show
, 0, 0, language
, flags
);
792 case TYPE_CODE_MEMBERPTR
:
793 c_type_print_varspec_suffix (type
->target_type (), stream
,
794 show
, 0, 0, language
, flags
);
797 case TYPE_CODE_METHODPTR
:
798 gdb_printf (stream
, ")");
799 c_type_print_varspec_suffix (type
->target_type (), stream
,
800 show
, 0, 0, language
, flags
);
805 case TYPE_CODE_RVALUE_REF
:
806 c_type_print_varspec_suffix (type
->target_type (), stream
,
807 show
, 1, 0, language
, flags
);
810 case TYPE_CODE_METHOD
:
813 gdb_printf (stream
, ")");
815 c_type_print_args (type
, stream
, 0, language
, flags
);
816 c_type_print_varspec_suffix (type
->target_type (), stream
,
817 show
, passed_a_ptr
, 0, language
, flags
);
820 case TYPE_CODE_TYPEDEF
:
821 c_type_print_varspec_suffix (type
->target_type (), stream
,
822 show
, passed_a_ptr
, 0, language
, flags
);
825 case TYPE_CODE_UNDEF
:
826 case TYPE_CODE_STRUCT
:
827 case TYPE_CODE_UNION
:
828 case TYPE_CODE_FLAGS
:
833 case TYPE_CODE_ERROR
:
837 case TYPE_CODE_RANGE
:
838 case TYPE_CODE_STRING
:
839 case TYPE_CODE_COMPLEX
:
840 case TYPE_CODE_NAMESPACE
:
841 case TYPE_CODE_DECFLOAT
:
842 case TYPE_CODE_FIXED_POINT
:
843 /* These types do not need a suffix. They are listed so that
844 gcc -Wall will report types that may not have been
848 error (_("type not handled in c_type_print_varspec_suffix()"));
853 /* A helper for c_type_print_base that displays template
854 parameters and their bindings, if needed.
856 TABLE is the local bindings table to use. If NULL, no printing is
857 done. Note that, at this point, TABLE won't have any useful
858 information in it -- but it is also used as a flag to
859 print_name_maybe_canonical to activate searching the global typedef
862 TYPE is the type whose template arguments are being displayed.
864 STREAM is the stream on which to print. */
867 c_type_print_template_args (const struct type_print_options
*flags
,
868 struct type
*type
, struct ui_file
*stream
,
869 enum language language
)
876 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
878 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
880 if (sym
->aclass () != LOC_TYPEDEF
)
885 stream
->wrap_here (4);
886 gdb_printf (stream
, _("[with %s = "), sym
->linkage_name ());
891 gdb_puts (", ", stream
);
892 stream
->wrap_here (9);
893 gdb_printf (stream
, "%s = ", sym
->linkage_name ());
896 c_print_type (sym
->type (), "", stream
, -1, 0, language
, flags
);
900 gdb_puts (_("] "), stream
);
903 /* Use 'print_spaces', but take into consideration the
904 type_print_options FLAGS in order to determine how many whitespaces
908 print_spaces_filtered_with_print_options
909 (int level
, struct ui_file
*stream
, const struct type_print_options
*flags
)
911 if (!flags
->print_offsets
)
912 print_spaces (level
, stream
);
914 print_spaces (level
+ print_offset_data::indentation
, stream
);
917 /* Output an access specifier to STREAM, if needed. LAST_ACCESS is the
918 last access specifier output (typically returned by this function). */
920 static enum access_specifier
921 output_access_specifier (struct ui_file
*stream
,
922 enum access_specifier last_access
,
923 int level
, bool is_protected
, bool is_private
,
924 const struct type_print_options
*flags
)
928 if (last_access
!= s_protected
)
930 last_access
= s_protected
;
931 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
932 gdb_printf (stream
, "protected:\n");
937 if (last_access
!= s_private
)
939 last_access
= s_private
;
940 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
941 gdb_printf (stream
, "private:\n");
946 if (last_access
!= s_public
)
948 last_access
= s_public
;
949 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
950 gdb_printf (stream
, "public:\n");
957 /* Return true if an access label (i.e., "public:", "private:",
958 "protected:") needs to be printed for TYPE. */
961 need_access_label_p (struct type
*type
)
963 if (type
->is_declared_class ())
966 for (int i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); i
++)
967 if (!TYPE_FIELD_PRIVATE (type
, i
))
970 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
971 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
972 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
976 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
977 if (!TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
983 for (int i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); i
++)
984 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
987 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
990 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
991 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
993 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
999 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
1000 if (TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
)
1001 || TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
1008 /* Helper function that temporarily disables FLAGS->PRINT_OFFSETS,
1009 calls 'c_print_type_1', and then reenables FLAGS->PRINT_OFFSETS if
1013 c_print_type_no_offsets (struct type
*type
,
1014 const char *varstring
,
1015 struct ui_file
*stream
,
1016 int show
, int level
,
1017 enum language language
,
1018 struct type_print_options
*flags
,
1019 struct print_offset_data
*podata
)
1021 unsigned int old_po
= flags
->print_offsets
;
1023 /* Temporarily disable print_offsets, because it would mess with
1025 flags
->print_offsets
= 0;
1026 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
1028 flags
->print_offsets
= old_po
;
1031 /* Helper for 'c_type_print_base' that handles structs and unions.
1032 For a description of the arguments, see 'c_type_print_base'. */
1035 c_type_print_base_struct_union (struct type
*type
, struct ui_file
*stream
,
1036 int show
, int level
,
1037 enum language language
,
1038 const struct type_print_options
*flags
,
1039 struct print_offset_data
*podata
)
1041 struct type_print_options local_flags
= *flags
;
1042 local_flags
.local_typedefs
= NULL
;
1044 std::unique_ptr
<typedef_hash_table
> hash_holder
;
1047 if (flags
->local_typedefs
)
1048 local_flags
.local_typedefs
1049 = new typedef_hash_table (*flags
->local_typedefs
);
1051 local_flags
.local_typedefs
= new typedef_hash_table ();
1053 hash_holder
.reset (local_flags
.local_typedefs
);
1056 c_type_print_modifier (type
, stream
, 0, 1, language
);
1057 if (type
->code () == TYPE_CODE_UNION
)
1058 gdb_printf (stream
, "union ");
1059 else if (type
->is_declared_class ())
1060 gdb_printf (stream
, "class ");
1062 gdb_printf (stream
, "struct ");
1064 /* Print the tag if it exists. The HP aCC compiler emits a
1065 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
1066 enum}" tag for unnamed struct/union/enum's, which we don't
1068 if (type
->name () != NULL
1069 && !startswith (type
->name (), "{unnamed"))
1071 /* When printing the tag name, we are still effectively
1072 printing in the outer context, hence the use of FLAGS
1074 print_name_maybe_canonical (type
->name (), flags
, stream
);
1076 gdb_puts (" ", stream
);
1081 /* If we just printed a tag name, no need to print anything
1083 if (type
->name () == NULL
)
1084 gdb_printf (stream
, "{...}");
1086 else if (show
> 0 || type
->name () == NULL
)
1088 struct type
*basetype
;
1091 c_type_print_template_args (&local_flags
, type
, stream
, language
);
1093 /* Add in template parameters when printing derivation info. */
1094 if (local_flags
.local_typedefs
!= NULL
)
1095 local_flags
.local_typedefs
->add_template_parameters (type
);
1096 cp_type_print_derivation_info (stream
, type
, &local_flags
);
1098 /* This holds just the global typedefs and the template
1100 struct type_print_options semi_local_flags
= *flags
;
1101 semi_local_flags
.local_typedefs
= NULL
;
1103 std::unique_ptr
<typedef_hash_table
> semi_holder
;
1104 if (local_flags
.local_typedefs
!= nullptr)
1106 semi_local_flags
.local_typedefs
1107 = new typedef_hash_table (*local_flags
.local_typedefs
);
1108 semi_holder
.reset (semi_local_flags
.local_typedefs
);
1110 /* Now add in the local typedefs. */
1111 local_flags
.local_typedefs
->recursively_update (type
);
1114 gdb_printf (stream
, "{\n");
1116 if (type
->num_fields () == 0 && TYPE_NFN_FIELDS (type
) == 0
1117 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
1119 print_spaces_filtered_with_print_options (level
+ 4, stream
, flags
);
1120 if (type
->is_stub ())
1121 gdb_printf (stream
, _("%p[<incomplete type>%p]\n"),
1122 metadata_style
.style ().ptr (), nullptr);
1124 gdb_printf (stream
, _("%p[<no data fields>%p]\n"),
1125 metadata_style
.style ().ptr (), nullptr);
1128 /* Start off with no specific section type, so we can print
1129 one for the first field we find, and use that section type
1130 thereafter until we find another type. */
1132 enum access_specifier section_type
= s_none
;
1134 /* For a class, if all members are private, there's no need
1135 for a "private:" label; similarly, for a struct or union
1136 masquerading as a class, if all members are public, there's
1137 no need for a "public:" label. */
1138 bool need_access_label
= need_access_label_p (type
);
1140 /* If there is a base class for this type,
1141 do not print the field that it occupies. */
1143 int len
= type
->num_fields ();
1144 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1146 struct print_offset_data
local_podata (flags
);
1148 for (int i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1152 /* If we have a virtual table pointer, omit it. Even if
1153 virtual table pointers are not specifically marked in
1154 the debug info, they should be artificial. */
1155 if ((i
== vptr_fieldno
&& type
== basetype
)
1156 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1159 if (need_access_label
)
1161 section_type
= output_access_specifier
1162 (stream
, section_type
, level
,
1163 TYPE_FIELD_PROTECTED (type
, i
),
1164 TYPE_FIELD_PRIVATE (type
, i
), flags
);
1167 bool is_static
= field_is_static (&type
->field (i
));
1169 if (flags
->print_offsets
)
1170 podata
->update (type
, i
, stream
);
1172 print_spaces (level
+ 4, stream
);
1174 gdb_printf (stream
, "static ");
1176 int newshow
= show
- 1;
1178 if (!is_static
&& flags
->print_offsets
1179 && (type
->field (i
).type ()->code () == TYPE_CODE_STRUCT
1180 || type
->field (i
).type ()->code () == TYPE_CODE_UNION
))
1182 /* If we're printing offsets and this field's type is
1183 either a struct or an union, then we're interested in
1187 /* Make sure we carry our offset when we expand the
1189 local_podata
.offset_bitpos
1190 = podata
->offset_bitpos
+ type
->field (i
).loc_bitpos ();
1191 /* We're entering a struct/union. Right now,
1192 PODATA->END_BITPOS points right *after* the
1193 struct/union. However, when printing the first field
1194 of this inner struct/union, the end_bitpos we're
1195 expecting is exactly at the beginning of the
1196 struct/union. Therefore, we subtract the length of
1197 the whole struct/union. */
1198 local_podata
.end_bitpos
1199 = podata
->end_bitpos
1200 - type
->field (i
).type ()->length () * TARGET_CHAR_BIT
;
1203 c_print_type_1 (type
->field (i
).type (),
1204 type
->field (i
).name (),
1205 stream
, newshow
, level
+ 4,
1206 language
, &local_flags
, &local_podata
);
1208 if (!is_static
&& TYPE_FIELD_PACKED (type
, i
))
1210 /* It is a bitfield. This code does not attempt
1211 to look at the bitpos and reconstruct filler,
1212 unnamed fields. This would lead to misleading
1213 results if the compiler does not put out fields
1214 for such things (I don't know what it does). */
1215 gdb_printf (stream
, " : %d",
1216 TYPE_FIELD_BITSIZE (type
, i
));
1218 gdb_printf (stream
, ";\n");
1221 /* If there are both fields and methods, put a blank line
1222 between them. Make sure to count only method that we
1223 will display; artificial methods will be hidden. */
1224 len
= TYPE_NFN_FIELDS (type
);
1225 if (!flags
->print_methods
)
1228 for (int i
= 0; i
< len
; i
++)
1230 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1231 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1234 for (j
= 0; j
< len2
; j
++)
1235 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1238 if (real_len
> 0 && section_type
!= s_none
)
1239 gdb_printf (stream
, "\n");
1241 /* C++: print out the methods. */
1242 for (int i
= 0; i
< len
; i
++)
1244 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1245 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1246 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1247 const char *name
= type
->name ();
1248 int is_constructor
= name
&& strcmp (method_name
,
1251 for (j
= 0; j
< len2
; j
++)
1253 const char *mangled_name
;
1254 gdb::unique_xmalloc_ptr
<char> mangled_name_holder
;
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 gdb_printf (stream
, "virtual ");
1276 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1277 gdb_printf (stream
, "static ");
1278 if (TYPE_FN_FIELD_TYPE (f
, j
)->target_type () == 0)
1280 /* Keep GDB from crashing here. */
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_FN_FIELD_TYPE (f
, j
)->target_type (),
1295 "", stream
, -1, 0, language
, &local_flags
, podata
);
1297 gdb_puts (" ", 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
);
1308 gdb::unique_xmalloc_ptr
<char> demangled_name
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 const char *demangled_no_class
1339 = remove_qualifiers (demangled_name
.get ());
1341 /* Get rid of the `static' appended by the
1343 p
= strstr (demangled_no_class
, " static");
1346 int length
= p
- demangled_no_class
;
1347 std::string
demangled_no_static (demangled_no_class
,
1349 gdb_puts (demangled_no_static
.c_str (), stream
);
1352 gdb_puts (demangled_no_class
, stream
);
1355 gdb_printf (stream
, ";\n");
1359 /* Print out nested types. */
1360 if (TYPE_NESTED_TYPES_COUNT (type
) != 0
1361 && semi_local_flags
.print_nested_type_limit
!= 0)
1363 if (semi_local_flags
.print_nested_type_limit
> 0)
1364 --semi_local_flags
.print_nested_type_limit
;
1366 if (type
->num_fields () != 0 || TYPE_NFN_FIELDS (type
) != 0)
1367 gdb_printf (stream
, "\n");
1369 for (int i
= 0; i
< TYPE_NESTED_TYPES_COUNT (type
); ++i
)
1371 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1373 c_print_type_no_offsets (TYPE_NESTED_TYPES_FIELD_TYPE (type
, i
),
1374 "", stream
, show
, level
+ 4,
1375 language
, &semi_local_flags
, podata
);
1376 gdb_printf (stream
, ";\n");
1380 /* Print typedefs defined in this class. */
1382 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1384 if (type
->num_fields () != 0 || TYPE_NFN_FIELDS (type
) != 0
1385 || TYPE_NESTED_TYPES_COUNT (type
) != 0)
1386 gdb_printf (stream
, "\n");
1388 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1390 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1392 /* Dereference the typedef declaration itself. */
1393 gdb_assert (target
->code () == TYPE_CODE_TYPEDEF
);
1394 target
= target
->target_type ();
1396 if (need_access_label
)
1398 section_type
= output_access_specifier
1399 (stream
, section_type
, level
,
1400 TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
),
1401 TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
), flags
);
1403 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1405 gdb_printf (stream
, "typedef ");
1407 /* We want to print typedefs with substitutions
1408 from the template parameters or globally-known
1409 typedefs but not local typedefs. */
1410 c_print_type_no_offsets (target
,
1411 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1412 stream
, show
- 1, level
+ 4,
1413 language
, &semi_local_flags
, podata
);
1414 gdb_printf (stream
, ";\n");
1418 if (flags
->print_offsets
)
1421 podata
->finish (type
, level
, stream
);
1423 print_spaces (print_offset_data::indentation
, stream
);
1425 print_spaces (2, stream
);
1428 gdb_printf (stream
, "%*s}", level
, "");
1432 /* Print the name of the type (or the ultimate pointer target,
1433 function value or array element), or the description of a structure
1436 SHOW positive means print details about the type (e.g. enum
1437 values), and print structure elements passing SHOW - 1 for show.
1439 SHOW negative means just print the type name or struct tag if there
1440 is one. If there is no name, print something sensible but concise
1441 like "struct {...}".
1443 SHOW zero means just print the type name or struct tag if there is
1444 one. If there is no name, print something sensible but not as
1445 concise like "struct {int x; int y;}".
1447 LEVEL is the number of spaces to indent by.
1448 We increase it for some recursive calls. */
1451 c_type_print_base_1 (struct type
*type
, struct ui_file
*stream
,
1452 int show
, int level
,
1453 enum language language
,
1454 const struct type_print_options
*flags
,
1455 struct print_offset_data
*podata
)
1464 fputs_styled (_("<type unknown>"), metadata_style
.style (), stream
);
1468 /* When SHOW is zero or less, and there is a valid type name, then
1469 always just print the type name directly from the type. */
1472 && type
->name () != NULL
)
1474 c_type_print_modifier (type
, stream
, 0, 1, language
);
1476 /* If we have "typedef struct foo {. . .} bar;" do we want to
1477 print it as "struct foo" or as "bar"? Pick the latter for
1478 C++, because C++ folk tend to expect things like "class5
1479 *foo" rather than "struct class5 *foo". We rather
1480 arbitrarily choose to make language_minimal work in a C-like
1482 if (language
== language_c
|| language
== language_minimal
)
1484 if (type
->code () == TYPE_CODE_UNION
)
1485 gdb_printf (stream
, "union ");
1486 else if (type
->code () == TYPE_CODE_STRUCT
)
1488 if (type
->is_declared_class ())
1489 gdb_printf (stream
, "class ");
1491 gdb_printf (stream
, "struct ");
1493 else if (type
->code () == TYPE_CODE_ENUM
)
1494 gdb_printf (stream
, "enum ");
1497 print_name_maybe_canonical (type
->name (), flags
, stream
);
1501 type
= check_typedef (type
);
1503 switch (type
->code ())
1505 case TYPE_CODE_TYPEDEF
:
1506 /* If we get here, the typedef doesn't have a name, and we
1507 couldn't resolve type::target_type. Not much we can do. */
1508 gdb_assert (type
->name () == NULL
);
1509 gdb_assert (type
->target_type () == NULL
);
1510 fprintf_styled (stream
, metadata_style
.style (),
1511 _("<unnamed typedef>"));
1514 case TYPE_CODE_FUNC
:
1515 case TYPE_CODE_METHOD
:
1516 if (type
->target_type () == NULL
)
1517 type_print_unknown_return_type (stream
);
1519 c_type_print_base_1 (type
->target_type (),
1520 stream
, show
, level
, language
, flags
, podata
);
1522 case TYPE_CODE_ARRAY
:
1524 case TYPE_CODE_MEMBERPTR
:
1526 case TYPE_CODE_RVALUE_REF
:
1527 case TYPE_CODE_METHODPTR
:
1528 c_type_print_base_1 (type
->target_type (),
1529 stream
, show
, level
, language
, flags
, podata
);
1532 case TYPE_CODE_STRUCT
:
1533 case TYPE_CODE_UNION
:
1534 c_type_print_base_struct_union (type
, stream
, show
, level
,
1535 language
, flags
, podata
);
1538 case TYPE_CODE_ENUM
:
1539 c_type_print_modifier (type
, stream
, 0, 1, language
);
1540 gdb_printf (stream
, "enum ");
1541 if (type
->is_declared_class ())
1542 gdb_printf (stream
, "class ");
1543 /* Print the tag name if it exists.
1544 The aCC compiler emits a spurious
1545 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1546 tag for unnamed struct/union/enum's, which we don't
1548 if (type
->name () != NULL
1549 && !startswith (type
->name (), "{unnamed"))
1551 print_name_maybe_canonical (type
->name (), flags
, stream
);
1553 gdb_puts (" ", stream
);
1556 stream
->wrap_here (4);
1559 /* If we just printed a tag name, no need to print anything
1561 if (type
->name () == NULL
)
1562 gdb_printf (stream
, "{...}");
1564 else if (show
> 0 || type
->name () == NULL
)
1566 LONGEST lastval
= 0;
1568 /* We can't handle this case perfectly, as DWARF does not
1569 tell us whether or not the underlying type was specified
1570 in the source (and other debug formats don't provide this
1571 at all). We choose to print the underlying type, if it
1572 has a name, when in C++ on the theory that it's better to
1573 print too much than too little; but conversely not to
1574 print something egregiously outside the current
1575 language's syntax. */
1576 if (language
== language_cplus
&& type
->target_type () != NULL
)
1578 struct type
*underlying
= check_typedef (type
->target_type ());
1580 if (underlying
->name () != NULL
)
1581 gdb_printf (stream
, ": %s ", underlying
->name ());
1584 gdb_printf (stream
, "{");
1585 len
= type
->num_fields ();
1586 for (i
= 0; i
< len
; i
++)
1590 gdb_printf (stream
, ", ");
1591 stream
->wrap_here (4);
1592 fputs_styled (type
->field (i
).name (),
1593 variable_name_style
.style (), stream
);
1594 if (lastval
!= type
->field (i
).loc_enumval ())
1596 gdb_printf (stream
, " = %s",
1597 plongest (type
->field (i
).loc_enumval ()));
1598 lastval
= type
->field (i
).loc_enumval ();
1602 gdb_printf (stream
, "}");
1606 case TYPE_CODE_FLAGS
:
1608 struct type_print_options local_flags
= *flags
;
1610 local_flags
.local_typedefs
= NULL
;
1612 c_type_print_modifier (type
, stream
, 0, 1, language
);
1613 gdb_printf (stream
, "flag ");
1614 print_name_maybe_canonical (type
->name (), flags
, stream
);
1617 gdb_puts (" ", stream
);
1618 gdb_printf (stream
, "{\n");
1619 if (type
->num_fields () == 0)
1621 if (type
->is_stub ())
1623 _("%*s%p[<incomplete type>%p]\n"),
1625 metadata_style
.style ().ptr (), nullptr);
1628 _("%*s%p[<no data fields>%p]\n"),
1630 metadata_style
.style ().ptr (), nullptr);
1632 len
= type
->num_fields ();
1633 for (i
= 0; i
< len
; i
++)
1636 print_spaces (level
+ 4, stream
);
1637 /* We pass "show" here and not "show - 1" to get enum types
1638 printed. There's no other way to see them. */
1639 c_print_type_1 (type
->field (i
).type (),
1640 type
->field (i
).name (),
1641 stream
, show
, level
+ 4,
1642 language
, &local_flags
, podata
);
1643 gdb_printf (stream
, " @%s",
1644 plongest (type
->field (i
).loc_bitpos ()));
1645 if (TYPE_FIELD_BITSIZE (type
, i
) > 1)
1647 gdb_printf (stream
, "-%s",
1648 plongest (type
->field (i
).loc_bitpos ()
1649 + TYPE_FIELD_BITSIZE (type
, i
)
1652 gdb_printf (stream
, ";\n");
1654 gdb_printf (stream
, "%*s}", level
, "");
1659 case TYPE_CODE_VOID
:
1660 gdb_printf (stream
, "void");
1663 case TYPE_CODE_UNDEF
:
1664 gdb_printf (stream
, _("struct <unknown>"));
1667 case TYPE_CODE_ERROR
:
1668 gdb_printf (stream
, "%s", TYPE_ERROR_NAME (type
));
1671 case TYPE_CODE_RANGE
:
1672 /* This should not occur. */
1673 fprintf_styled (stream
, metadata_style
.style (), _("<range type>"));
1676 case TYPE_CODE_FIXED_POINT
:
1677 print_type_fixed_point (type
, stream
);
1680 case TYPE_CODE_NAMESPACE
:
1681 gdb_puts ("namespace ", stream
);
1682 gdb_puts (type
->name (), 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 () != NULL
)
1692 c_type_print_modifier (type
, stream
, 0, 1, language
);
1693 print_name_maybe_canonical (type
->name (), 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 ());
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 (flags
);
1715 c_type_print_base_1 (type
, stream
, show
, level
,
1716 current_language
->la_language
, flags
, &podata
);