1 /* Convert types from GDB to GCC
3 Copyright (C) 2014-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "common/preprocessor.h"
24 #include "compile-internal.h"
25 #include "compile-cplus.h"
26 #include "gdb_assert.h"
29 #include "cp-support.h"
36 #include "compile-c.h" /* Included for c_get_range_decl_name
40 /* Default compile flags for C++. */
42 const char *compile_cplus_instance::m_default_cflags
= "-std=gnu++11";
44 /* Flag to enable internal debugging. */
46 static int debug_compile_cplus_types
= 0;
48 /* Flag to enable internal scope switching debugging. */
50 static int debug_compile_cplus_scopes
= 0;
52 /* Forward declarations. */
54 static gcc_type
compile_cplus_convert_func (compile_cplus_instance
*instance
,
56 bool strip_artificial
);
58 /* See description in compile-cplus.h. */
60 gdb::unique_xmalloc_ptr
<char>
61 compile_cplus_instance::decl_name (const char *natural
)
63 if (natural
== nullptr)
66 char *name
= cp_func_name (natural
);
68 return gdb::unique_xmalloc_ptr
<char> (name
);
70 return gdb::unique_xmalloc_ptr
<char> (xstrdup (natural
));
73 /* Get the access flag for the NUM'th field of TYPE. */
75 static enum gcc_cp_symbol_kind
76 get_field_access_flag (const struct type
*type
, int num
)
78 if (TYPE_FIELD_PROTECTED (type
, num
))
79 return GCC_CP_ACCESS_PROTECTED
;
80 else if (TYPE_FIELD_PRIVATE (type
, num
))
81 return GCC_CP_ACCESS_PRIVATE
;
83 /* GDB assumes everything else is public. */
84 return GCC_CP_ACCESS_PUBLIC
;
87 /* Get the access flag for the NUM'th method of TYPE's FNI'th
90 enum gcc_cp_symbol_kind
91 get_method_access_flag (const struct type
*type
, int fni
, int num
)
93 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
);
95 /* If this type was not declared a class, everything is public. */
96 if (!TYPE_DECLARED_CLASS (type
))
97 return GCC_CP_ACCESS_PUBLIC
;
99 /* Otherwise, read accessibility from the fn_field. */
100 const struct fn_field
*methods
= TYPE_FN_FIELDLIST1 (type
, fni
);
101 if (TYPE_FN_FIELD_PROTECTED (methods
, num
))
102 return GCC_CP_ACCESS_PROTECTED
;
103 else if (TYPE_FN_FIELD_PRIVATE (methods
, num
))
104 return GCC_CP_ACCESS_PRIVATE
;
106 return GCC_CP_ACCESS_PUBLIC
;
109 /* A useful debugging function to output the scope SCOPE to stdout. */
111 static void __attribute__ ((used
))
112 debug_print_scope (const compile_scope
&scope
)
114 for (const auto &comp
: scope
)
116 const char *symbol
= (comp
.bsymbol
.symbol
!= nullptr
117 ? SYMBOL_NATURAL_NAME (comp
.bsymbol
.symbol
)
120 printf_unfiltered ("\tname = %s, symbol = %s\n", comp
.name
.c_str (),
125 /* See description in compile-cplus.h. */
128 type_name_to_scope (const char *type_name
, const struct block
*block
)
132 if (type_name
== nullptr)
134 /* An anonymous type. We cannot really do much here. We simply cannot
135 look up anonymous types easily/at all. */
139 const char *p
= type_name
;
140 std::string lookup_name
;
144 /* Create a string token of the first component of TYPE_NAME. */
145 int len
= cp_find_first_component (p
);
146 std::string
s (p
, len
);
148 /* Advance past the last token. */
151 /* Look up the symbol and decide when to stop. */
152 if (!lookup_name
.empty ())
156 /* Look up the resulting name. */
157 struct block_symbol bsymbol
158 = lookup_symbol (lookup_name
.c_str (), block
, VAR_DOMAIN
, nullptr);
160 if (bsymbol
.symbol
!= nullptr)
162 scope_component comp
= {s
, bsymbol
};
164 scope
.push_back (comp
);
166 if (TYPE_CODE (SYMBOL_TYPE (bsymbol
.symbol
)) != TYPE_CODE_NAMESPACE
)
180 /* This shouldn't happen since we are not attempting to
181 loop over user input. This name is generated by GDB
183 internal_error (__FILE__
, __LINE__
,
184 _("malformed TYPE_NAME during parsing"));
192 /* Compare two scope_components for equality. These are equal if the names
193 of the two components' are the same. */
196 operator== (const scope_component
&lhs
, const scope_component
&rhs
)
198 return lhs
.name
== rhs
.name
;
201 /* Compare two scope_components for inequality. These are not equal if
202 the two components' names are not equal. */
205 operator!= (const scope_component
&lhs
, const scope_component
&rhs
)
207 return lhs
.name
!= rhs
.name
;
210 /* Compare two compile_scopes for equality. These are equal if they are both
211 contain the same number of components and each component is equal. */
214 operator== (const compile_scope
&lhs
, const compile_scope
&rhs
)
216 if (lhs
.size () != rhs
.size ())
219 for (int i
= 0; i
< lhs
.size (); ++i
)
221 if (lhs
[i
] != rhs
[i
])
228 /* Compare two compile_scopes for inequality. These are inequal if they
229 contain unequal number of elements or if any of the components are not
233 operator!= (const compile_scope
&lhs
, const compile_scope
&rhs
)
235 if (lhs
.size () != rhs
.size ())
238 for (int i
= 0; i
< lhs
.size (); ++i
)
240 if (lhs
[i
] != rhs
[i
])
247 /* See description in compile-cplus.h. */
250 compile_cplus_instance::enter_scope (compile_scope
&new_scope
)
252 bool must_push
= m_scopes
.empty () || m_scopes
.back () != new_scope
;
254 new_scope
.m_pushed
= must_push
;
256 /* Save the new scope. */
257 m_scopes
.push_back (new_scope
);
261 if (debug_compile_cplus_scopes
)
262 fprintf_unfiltered (gdb_stdlog
, "entering new scope %p\n", new_scope
);
264 /* Push the global namespace. */
265 plugin ().push_namespace ("");
267 /* Push all other namespaces. Note that we do not push the last
268 scope_component -- that's the actual type we are converting. */
270 (new_scope
.begin (), new_scope
.end () - 1,
271 [this] (const scope_component
&comp
)
273 gdb_assert (TYPE_CODE (SYMBOL_TYPE (comp
.bsymbol
.symbol
))
274 == TYPE_CODE_NAMESPACE
);
276 const char *ns
= (comp
.name
== CP_ANONYMOUS_NAMESPACE_STR
? nullptr
277 : comp
.name
.c_str ());
279 this->plugin ().push_namespace (ns
);
284 if (debug_compile_cplus_scopes
)
286 fprintf_unfiltered (gdb_stdlog
, "staying in current scope -- "
287 "scopes are identical\n");
292 /* See description in compile-cplus.h. */
295 compile_cplus_instance::leave_scope ()
297 /* Get the current scope and remove it from the internal list of
299 compile_scope current
= m_scopes
.back ();
301 m_scopes
.pop_back ();
303 if (current
.m_pushed
)
305 if (debug_compile_cplus_scopes
)
306 fprintf_unfiltered (gdb_stdlog
, "leaving scope %p\n", current
);
308 /* Pop namespaces. */
310 (current
.begin (),current
.end () - 1,
311 [this] (const scope_component
&comp
) {
312 gdb_assert (TYPE_CODE (SYMBOL_TYPE (comp
.bsymbol
.symbol
))
313 == TYPE_CODE_NAMESPACE
);
314 this->plugin ().pop_binding_level (comp
.name
.c_str ());
317 /* Pop global namespace. */
318 plugin ().pop_binding_level ("");
322 if (debug_compile_cplus_scopes
)
323 fprintf_unfiltered (gdb_stdlog
,
324 "identical scopes -- not leaving scope\n");
328 /* See description in compile-cplus.h. */
331 compile_cplus_instance::new_scope (const char *type_name
, struct type
*type
)
333 /* Break the type name into components. If TYPE was defined in some
334 superclass, we do not process TYPE but process the enclosing type
336 compile_scope scope
= type_name_to_scope (type_name
, block ());
340 /* Get the name of the last component, which should be the
341 unqualified name of the type to process. */
342 scope_component
&comp
= scope
.back ();
344 if (!types_equal (type
, SYMBOL_TYPE (comp
.bsymbol
.symbol
))
345 && (m_scopes
.empty ()
346 || (m_scopes
.back ().back ().bsymbol
.symbol
347 != comp
.bsymbol
.symbol
)))
349 /* The type is defined inside another class(es). Convert that
350 type instead of defining this type. */
351 convert_type (SYMBOL_TYPE (comp
.bsymbol
.symbol
));
353 /* If the original type (passed in to us) is defined in a nested
354 class, the previous call will give us that type's gcc_type.
355 Upper layers are expecting to get the original type's
357 get_cached_type (type
, scope
.m_nested_type
);
363 if (TYPE_NAME (type
) == nullptr)
367 /* We don't have a qualified name for this to look up, but
368 we need a scope. We have to assume, then, that it is the same
369 as the current scope, if any. */
370 if (!m_scopes
.empty ())
372 scope
= m_scopes
.back ();
373 scope
.m_pushed
= false;
376 scope
.push_back (scope_component ());
382 decl_name (TYPE_NAME (type
)).get (),
383 lookup_symbol (TYPE_NAME (type
), block (), VAR_DOMAIN
, nullptr)
385 scope
.push_back (comp
);
389 /* There must be at least one component in the compile_scope. */
390 gdb_assert (scope
.size () > 0);
394 /* See description in compile-cplus.h. */
397 compile_cplus_instance::convert_reference_base
398 (gcc_type base
, enum gcc_cp_ref_qualifiers rquals
)
400 return this->plugin ().build_reference_type (base
, rquals
);
403 /* Convert a reference type to its gcc representation. */
406 compile_cplus_convert_reference (compile_cplus_instance
*instance
,
409 gcc_type target
= instance
->convert_type (TYPE_TARGET_TYPE (type
));
411 enum gcc_cp_ref_qualifiers quals
= GCC_CP_REF_QUAL_NONE
;
412 switch (TYPE_CODE (type
))
415 quals
= GCC_CP_REF_QUAL_LVALUE
;
417 case TYPE_CODE_RVALUE_REF
:
418 quals
= GCC_CP_REF_QUAL_RVALUE
;
421 gdb_assert_not_reached ("unexpected type code for reference type");
424 return instance
->convert_reference_base (target
, quals
);
427 /* See description in compile-cplus.h. */
430 compile_cplus_instance::convert_pointer_base(gcc_type target
)
432 return plugin ().build_pointer_type (target
);
435 /* Convert a pointer type to its gcc representation. */
438 compile_cplus_convert_pointer (compile_cplus_instance
*instance
,
441 gcc_type target
= instance
->convert_type (TYPE_TARGET_TYPE (type
));
443 return instance
->convert_pointer_base (target
);
446 /* Convert an array type to its gcc representation. */
449 compile_cplus_convert_array (compile_cplus_instance
*instance
,
452 struct type
*range
= TYPE_INDEX_TYPE (type
);
453 gcc_type element_type
= instance
->convert_type (TYPE_TARGET_TYPE (type
));
455 if (TYPE_LOW_BOUND_KIND (range
) != PROP_CONST
)
457 const char *s
= _("array type with non-constant"
458 " lower bound is not supported");
460 return instance
->plugin ().error (s
);
463 if (TYPE_LOW_BOUND (range
) != 0)
465 const char *s
= _("cannot convert array type with "
466 "non-zero lower bound to C");
468 return instance
->plugin ().error (s
);
471 if (TYPE_HIGH_BOUND_KIND (range
) == PROP_LOCEXPR
472 || TYPE_HIGH_BOUND_KIND (range
) == PROP_LOCLIST
)
474 if (TYPE_VECTOR (type
))
476 const char *s
= _("variably-sized vector type is not supported");
478 return instance
->plugin ().error (s
);
481 std::string upper_bound
482 = c_get_range_decl_name (&TYPE_RANGE_DATA (range
)->high
);
483 return instance
->plugin ().build_vla_array_type (element_type
,
484 upper_bound
.c_str ());
488 LONGEST low_bound
, high_bound
, count
;
490 if (get_array_bounds (type
, &low_bound
, &high_bound
) == 0)
494 gdb_assert (low_bound
== 0); /* Ensured above. */
495 count
= high_bound
+ 1;
498 if (TYPE_VECTOR (type
))
499 return instance
->plugin ().build_vector_type (element_type
, count
);
501 return instance
->plugin ().build_array_type (element_type
, count
);
505 /* Convert a typedef of TYPE. If not GCC_CP_ACCESS_NONE, NESTED_ACCESS
506 will define the accessibility of the typedef definition in its
510 compile_cplus_convert_typedef (compile_cplus_instance
*instance
,
512 enum gcc_cp_symbol_kind nested_access
)
514 compile_scope scope
= instance
->new_scope (TYPE_NAME (type
), type
);
516 if (scope
.nested_type () != GCC_TYPE_NONE
)
517 return scope
.nested_type ();
519 gdb::unique_xmalloc_ptr
<char> name
520 = compile_cplus_instance::decl_name (TYPE_NAME (type
));
522 /* Make sure the scope for this type has been pushed. */
523 instance
->enter_scope (scope
);
525 /* Convert the typedef's real type. */
526 gcc_type typedef_type
= instance
->convert_type (check_typedef (type
));
528 instance
->plugin ().build_decl ("typedef", name
.get (),
529 GCC_CP_SYMBOL_TYPEDEF
| nested_access
,
530 typedef_type
, 0, 0, nullptr, 0);
532 /* Completed this scope. */
533 instance
->leave_scope ();
537 /* Convert types defined in TYPE. */
540 compile_cplus_convert_type_defns (compile_cplus_instance
*instance
,
544 enum gcc_cp_symbol_kind accessibility
;
546 /* Convert typedefs. */
547 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
549 if (TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
))
550 accessibility
= GCC_CP_ACCESS_PROTECTED
;
551 else if (TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
552 accessibility
= GCC_CP_ACCESS_PRIVATE
;
554 accessibility
= GCC_CP_ACCESS_PUBLIC
;
555 instance
->convert_type (TYPE_TYPEDEF_FIELD_TYPE (type
, i
), accessibility
);
558 /* Convert nested types. */
559 for (i
= 0; i
< TYPE_NESTED_TYPES_COUNT (type
); ++i
)
561 if (TYPE_NESTED_TYPES_FIELD_PROTECTED (type
, i
))
562 accessibility
= GCC_CP_ACCESS_PROTECTED
;
563 else if (TYPE_NESTED_TYPES_FIELD_PRIVATE (type
, i
))
564 accessibility
= GCC_CP_ACCESS_PRIVATE
;
566 accessibility
= GCC_CP_ACCESS_PUBLIC
;
567 instance
->convert_type (TYPE_NESTED_TYPES_FIELD_TYPE (type
, i
),
572 /* Convert data members defined in TYPE, which should be struct/class/union
573 with gcc_type COMP_TYPE. */
576 compile_cplus_convert_struct_or_union_members
577 (compile_cplus_instance
*instance
, struct type
*type
, gcc_type comp_type
)
579 for (int i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); ++i
)
581 const char *field_name
= TYPE_FIELD_NAME (type
, i
);
583 if (TYPE_FIELD_IGNORE (type
, i
)
584 || TYPE_FIELD_ARTIFICIAL (type
, i
))
587 /* GDB records unnamed/anonymous fields with empty string names. */
588 if (*field_name
== '\0')
589 field_name
= nullptr;
592 = instance
->convert_type (TYPE_FIELD_TYPE (type
, i
));
594 if (field_is_static (&TYPE_FIELD (type
, i
)))
598 switch (TYPE_FIELD_LOC_KIND (type
, i
))
600 case FIELD_LOC_KIND_PHYSADDR
:
602 physaddr
= TYPE_FIELD_STATIC_PHYSADDR (type
, i
);
604 instance
->plugin ().build_decl
605 ("field physaddr", field_name
,
606 (GCC_CP_SYMBOL_VARIABLE
| get_field_access_flag (type
, i
)),
607 field_type
, nullptr, physaddr
, nullptr, 0);
611 case FIELD_LOC_KIND_PHYSNAME
:
613 const char *physname
= TYPE_FIELD_STATIC_PHYSNAME (type
, i
);
614 struct block_symbol sym
615 = lookup_symbol (physname
, instance
->block (),
616 VAR_DOMAIN
, nullptr);
618 if (sym
.symbol
== nullptr)
620 /* We didn't actually find the symbol. There's little
621 we can do but ignore this member. */
624 const char *filename
= symbol_symtab (sym
.symbol
)->filename
;
625 unsigned int line
= SYMBOL_LINE (sym
.symbol
);
627 physaddr
= SYMBOL_VALUE_ADDRESS (sym
.symbol
);
628 instance
->plugin ().build_decl
629 ("field physname", field_name
,
630 (GCC_CP_SYMBOL_VARIABLE
| get_field_access_flag (type
, i
)),
631 field_type
, nullptr, physaddr
, filename
, line
);
636 gdb_assert_not_reached
637 ("unexpected static field location kind");
642 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, i
);
643 enum gcc_cp_symbol_kind field_flags
= GCC_CP_SYMBOL_FIELD
644 | get_field_access_flag (type
, i
);
647 bitsize
= 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
));
649 instance
->plugin ().build_field
650 (field_name
, field_type
, field_flags
, bitsize
,
651 TYPE_FIELD_BITPOS (type
, i
));
656 /* Convert a method type to its gcc representation. */
659 compile_cplus_convert_method (compile_cplus_instance
*instance
,
660 struct type
*parent_type
,
661 struct type
*method_type
)
663 /* Get the actual function type of the method, the corresponding class's
664 type and corresponding qualifier flags. */
665 gcc_type func_type
= compile_cplus_convert_func (instance
, method_type
, true);
666 gcc_type class_type
= instance
->convert_type (parent_type
);
667 gcc_cp_qualifiers_flags quals
= (enum gcc_cp_qualifiers
) 0;
669 if (TYPE_CONST (method_type
))
670 quals
|= GCC_CP_QUALIFIER_CONST
;
671 if (TYPE_VOLATILE (method_type
))
672 quals
|= GCC_CP_QUALIFIER_VOLATILE
;
673 if (TYPE_RESTRICT (method_type
))
674 quals
|= GCC_CP_QUALIFIER_RESTRICT
;
676 /* Not yet implemented. */
677 gcc_cp_ref_qualifiers_flags rquals
= GCC_CP_REF_QUAL_NONE
;
679 return instance
->plugin ().build_method_type
680 (class_type
, func_type
, quals
, rquals
);
683 /* Convert a member or method pointer represented by TYPE. */
686 compile_cplus_convert_memberptr (compile_cplus_instance
*instance
,
689 struct type
*containing_class
= TYPE_SELF_TYPE (type
);
691 if (containing_class
== nullptr)
692 return GCC_TYPE_NONE
;
694 gcc_type class_type
= instance
->convert_type (containing_class
);
696 = instance
->convert_type (TYPE_TARGET_TYPE (type
));
698 return instance
->plugin ().build_pointer_to_member_type
699 (class_type
, member_type
);
702 /* Convert all methods defined in TYPE, which should be a class/struct/union
703 with gcc_type CLASS_TYPE. */
706 compile_cplus_convert_struct_or_union_methods (compile_cplus_instance
*instance
,
710 for (int i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
712 struct fn_field
*methods
= TYPE_FN_FIELDLIST1 (type
, i
);
713 gdb::unique_xmalloc_ptr
<char> overloaded_name
714 = compile_cplus_instance::decl_name (TYPE_FN_FIELDLIST_NAME (type
, i
));
716 /* Loop through the fieldlist, adding decls to the compiler's
717 representation of the class. */
718 for (int j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
720 /* Skip artificial methods. */
721 if (TYPE_FN_FIELD_ARTIFICIAL (methods
, j
))
724 gcc_cp_symbol_kind_flags sym_kind
= GCC_CP_SYMBOL_FUNCTION
;
725 gcc_type method_type
;
726 struct block_symbol sym
727 = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (methods
, j
),
728 instance
->block (), VAR_DOMAIN
, nullptr);
730 if (sym
.symbol
== nullptr)
732 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, j
))
734 /* This is beyond hacky, and is really only a workaround for
735 detecting pure virtual methods. */
736 method_type
= compile_cplus_convert_method
737 (instance
, type
, TYPE_FN_FIELD_TYPE (methods
, j
));
739 instance
->plugin ().build_decl
740 ("pure virtual method", overloaded_name
.get (),
742 | get_method_access_flag (type
, i
, j
)
743 | GCC_CP_FLAG_VIRTUAL_FUNCTION
744 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
),
745 method_type
, nullptr, 0, nullptr, 0);
749 /* This can happen if we have a DW_AT_declaration DIE
750 for the method, but no "definition"-type DIE (with
751 DW_AT_specification referencing the decl DIE), i.e.,
752 the compiler has probably optimized the method away.
754 In this case, all we can hope to do is issue a warning
755 to the user letting him know. If the user has not actually
756 requested using this method, things should still work. */
757 warning (_("Method %s appears to be optimized out.\n"
758 "All references to this method will be undefined."),
759 TYPE_FN_FIELD_PHYSNAME (methods
, j
));
763 const char *filename
= symbol_symtab (sym
.symbol
)->filename
;
764 unsigned int line
= SYMBOL_LINE (sym
.symbol
);
765 CORE_ADDR address
= BLOCK_START (SYMBOL_BLOCK_VALUE (sym
.symbol
));
768 if (TYPE_FN_FIELD_STATIC_P (methods
, j
))
770 kind
= "static method";
771 method_type
= compile_cplus_convert_func
772 (instance
, TYPE_FN_FIELD_TYPE (methods
, j
), true);
777 method_type
= (compile_cplus_convert_method
778 (instance
, type
, TYPE_FN_FIELD_TYPE (methods
, j
)));
781 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, j
))
782 sym_kind
|= GCC_CP_FLAG_VIRTUAL_FUNCTION
;
784 instance
->plugin ().build_decl
785 (kind
, overloaded_name
.get (),
786 sym_kind
| get_method_access_flag (type
, i
, j
),
787 method_type
, nullptr, address
, filename
, line
);
792 /* Convert a struct or union type to its gcc representation. If this type
793 was defined in another type, NESTED_ACCESS should indicate the
794 accessibility of this type. */
797 compile_cplus_convert_struct_or_union (compile_cplus_instance
*instance
,
799 enum gcc_cp_symbol_kind nested_access
)
801 const char *filename
= nullptr;
802 unsigned short line
= 0;
804 /* Get the decl name of this type. */
805 gdb::unique_xmalloc_ptr
<char> name
806 = compile_cplus_instance::decl_name (TYPE_NAME (type
));
808 /* Create a new scope for TYPE. */
809 compile_scope scope
= instance
->new_scope (TYPE_NAME (type
), type
);
811 if (scope
.nested_type () != GCC_TYPE_NONE
)
813 /* The type requested was actually defined inside another type,
814 such as a nested class definition. Return that type. */
815 return scope
.nested_type ();
818 /* Push all scopes. */
819 instance
->enter_scope (scope
);
821 /* First we create the resulting type and enter it into our hash
822 table. This lets recursive types work. */
825 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
827 const char *what
= TYPE_DECLARED_CLASS (type
) ? "struct" : "class";
829 resuld
= instance
->plugin ().build_decl
830 (what
, name
.get (), (GCC_CP_SYMBOL_CLASS
| nested_access
831 | (TYPE_DECLARED_CLASS (type
)
832 ? GCC_CP_FLAG_CLASS_NOFLAG
833 : GCC_CP_FLAG_CLASS_IS_STRUCT
)),
834 0, nullptr, 0, filename
, line
);
838 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
839 resuld
= instance
->plugin ().build_decl
840 ("union", name
.get (), GCC_CP_SYMBOL_UNION
| nested_access
,
841 0, nullptr, 0, filename
, line
);
845 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
847 struct gcc_vbase_array bases
;
848 int num_baseclasses
= TYPE_N_BASECLASSES (type
);
850 memset (&bases
, 0, sizeof (bases
));
852 if (num_baseclasses
> 0)
854 bases
.elements
= XNEWVEC (gcc_type
, num_baseclasses
);
855 bases
.flags
= XNEWVEC (enum gcc_cp_symbol_kind
, num_baseclasses
);
856 bases
.n_elements
= num_baseclasses
;
857 for (int i
= 0; i
< num_baseclasses
; ++i
)
859 struct type
*base_type
= TYPE_BASECLASS (type
, i
);
861 bases
.flags
[i
] = GCC_CP_SYMBOL_BASECLASS
862 | get_field_access_flag (type
, i
)
863 | (BASETYPE_VIA_VIRTUAL (type
, i
)
864 ? GCC_CP_FLAG_BASECLASS_VIRTUAL
865 : GCC_CP_FLAG_BASECLASS_NOFLAG
);
866 bases
.elements
[i
] = instance
->convert_type (base_type
);
870 result
= instance
->plugin ().start_class_type
871 (name
.get (), resuld
, &bases
, filename
, line
);
873 xfree (bases
.elements
);
877 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
878 result
= instance
->plugin ().start_class_type
879 (name
.get (), resuld
, nullptr, filename
, line
);
882 instance
->insert_type (type
, result
);
884 /* Add definitions. */
885 compile_cplus_convert_type_defns (instance
, type
);
888 compile_cplus_convert_struct_or_union_methods (instance
, type
, result
);
891 compile_cplus_convert_struct_or_union_members (instance
, type
, result
);
894 instance
->plugin ().finish_class_type (name
.get (), TYPE_LENGTH (type
));
896 /* Pop all scopes. */
897 instance
->leave_scope ();
901 /* Convert an enum type to its gcc representation. If this type
902 was defined in another type, NESTED_ACCESS should indicate the
903 accessibility of this type.*/
906 compile_cplus_convert_enum (compile_cplus_instance
*instance
, struct type
*type
,
907 enum gcc_cp_symbol_kind nested_access
)
909 int scoped_enum_p
= FALSE
;
911 /* Create a new scope for this type. */
912 compile_scope scope
= instance
->new_scope (TYPE_NAME (type
), type
);
914 if (scope
.nested_type () != GCC_TYPE_NONE
)
916 /* The type requested was actually defined inside another type,
917 such as a nested class definition. Return that type. */
918 return scope
.nested_type ();
921 gdb::unique_xmalloc_ptr
<char> name
922 = compile_cplus_instance::decl_name (TYPE_NAME (type
));
924 /* Push all scopes. */
925 instance
->enter_scope (scope
);
928 = instance
->plugin ().get_int_type (TYPE_UNSIGNED (type
),
929 TYPE_LENGTH (type
), nullptr);
931 = instance
->plugin ().start_enum_type (name
.get (), int_type
,
932 GCC_CP_SYMBOL_ENUM
| nested_access
934 ? GCC_CP_FLAG_ENUM_SCOPED
935 : GCC_CP_FLAG_ENUM_NOFLAG
),
937 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
939 gdb::unique_xmalloc_ptr
<char> fname
940 = compile_cplus_instance::decl_name (TYPE_FIELD_NAME (type
, i
));
942 if (TYPE_FIELD_LOC_KIND (type
, i
) != FIELD_LOC_KIND_ENUMVAL
946 instance
->plugin ().build_enum_constant (result
, fname
.get (),
947 TYPE_FIELD_ENUMVAL (type
, i
));
950 /* Finish enum definition and pop scopes. */
951 instance
->plugin ().finish_enum_type (result
);
952 instance
->leave_scope ();
956 /* Convert a function type to its gcc representation. This function does
957 not deal with function templates. */
960 compile_cplus_convert_func (compile_cplus_instance
*instance
,
961 struct type
*type
, bool strip_artificial
)
963 int is_varargs
= TYPE_VARARGS (type
);
964 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
966 /* Functions with no debug info have no return type. Ideally we'd
967 want to fallback to the type of the cast just before the
968 function, like GDB's built-in expression parser, but we don't
969 have access to that type here. For now, fallback to int, like
970 GDB's parser used to do. */
971 if (target_type
== nullptr)
973 if (TYPE_OBJFILE_OWNED (type
))
974 target_type
= objfile_type (TYPE_OWNER (type
).objfile
)->builtin_int
;
976 target_type
= builtin_type (TYPE_OWNER (type
).gdbarch
)->builtin_int
;
977 warning (_("function has unknown return type; assuming int"));
980 /* This approach means we can't make self-referential function
981 types. Those are impossible in C, though. */
982 gcc_type return_type
= instance
->convert_type (target_type
);
984 struct gcc_type_array array
=
985 { TYPE_NFIELDS (type
), XNEWVEC (gcc_type
, TYPE_NFIELDS (type
)) };
987 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
989 if (strip_artificial
&& TYPE_FIELD_ARTIFICIAL (type
, i
))
996 array
.elements
[i
- artificials
]
997 = instance
->convert_type (TYPE_FIELD_TYPE (type
, i
));
1001 /* We omit setting the argument types to `void' to be a little flexible
1002 with some minsyms like printf (compile-cplus.exp has examples). */
1003 gcc_type result
= instance
->plugin ().build_function_type
1004 (return_type
, &array
, is_varargs
);
1005 xfree (array
.elements
);
1009 /* Convert an integer type to its gcc representation. */
1012 compile_cplus_convert_int (compile_cplus_instance
*instance
, struct type
*type
)
1014 if (TYPE_NOSIGN (type
))
1016 gdb_assert (TYPE_LENGTH (type
) == 1);
1017 return instance
->plugin ().get_char_type ();
1020 return instance
->plugin ().get_int_type
1021 (TYPE_UNSIGNED (type
), TYPE_LENGTH (type
), TYPE_NAME (type
));
1024 /* Convert a floating-point type to its gcc representation. */
1027 compile_cplus_convert_float (compile_cplus_instance
*instance
,
1030 return instance
->plugin ().get_float_type
1031 (TYPE_LENGTH (type
), TYPE_NAME (type
));
1034 /* Convert the 'void' type to its gcc representation. */
1037 compile_cplus_convert_void (compile_cplus_instance
*instance
, struct type
*type
)
1039 return instance
->plugin ().get_void_type ();
1042 /* Convert a boolean type to its gcc representation. */
1045 compile_cplus_convert_bool (compile_cplus_instance
*instance
, struct type
*type
)
1047 return instance
->plugin ().get_bool_type ();
1050 /* See description in compile-cplus.h. */
1053 compile_cplus_instance::convert_qualified_base (gcc_type base
,
1054 gcc_cp_qualifiers_flags quals
)
1056 gcc_type result
= base
;
1058 if (quals
!= GCC_CP_REF_QUAL_NONE
)
1059 result
= plugin ().build_qualified_type (base
, quals
);
1064 /* See description in compile-cplus.h. */
1067 compile_cplus_convert_qualified (compile_cplus_instance
*instance
,
1070 struct type
*unqual
= make_unqualified_type (type
);
1071 gcc_cp_qualifiers_flags quals
= (enum gcc_cp_qualifiers
) 0;
1072 gcc_type unqual_converted
= instance
->convert_type (unqual
);
1074 if (TYPE_CONST (type
))
1075 quals
|= GCC_CP_QUALIFIER_CONST
;
1076 if (TYPE_VOLATILE (type
))
1077 quals
|= GCC_CP_QUALIFIER_VOLATILE
;
1078 if (TYPE_RESTRICT (type
))
1079 quals
|= GCC_CP_QUALIFIER_RESTRICT
;
1081 return instance
->convert_qualified_base (unqual_converted
, quals
);
1084 /* Convert a complex type to its gcc representation. */
1087 compile_cplus_convert_complex (compile_cplus_instance
*instance
,
1090 gcc_type base
= instance
->convert_type (TYPE_TARGET_TYPE (type
));
1092 return instance
->plugin ().build_complex_type (base
);
1095 /* Convert a namespace of TYPE. */
1098 compile_cplus_convert_namespace (compile_cplus_instance
*instance
,
1101 compile_scope scope
= instance
->new_scope (TYPE_NAME (type
), type
);
1102 gdb::unique_xmalloc_ptr
<char> name
1103 = compile_cplus_instance::decl_name (TYPE_NAME (type
));
1106 instance
->enter_scope (scope
);
1108 /* Convert this namespace. */
1109 instance
->plugin ().push_namespace (name
.get ());
1110 instance
->plugin ().pop_binding_level (name
.get ());
1113 instance
->leave_scope ();
1115 /* Namespaces are non-cacheable types. */
1116 return GCC_TYPE_NONE
;
1119 /* A helper function which knows how to convert most types from their
1120 gdb representation to the corresponding gcc form. This examines
1121 the TYPE and dispatches to the appropriate conversion function. It
1122 returns the gcc type.
1124 If the type was defined in another type, NESTED_ACCESS should indicate the
1125 accessibility of this type. */
1128 convert_type_cplus_basic (compile_cplus_instance
*instance
,
1130 enum gcc_cp_symbol_kind nested_access
)
1132 /* If we are converting a qualified type, first convert the
1133 unqualified type and then apply the qualifiers. */
1134 if ((TYPE_INSTANCE_FLAGS (type
) & (TYPE_INSTANCE_FLAG_CONST
1135 | TYPE_INSTANCE_FLAG_VOLATILE
1136 | TYPE_INSTANCE_FLAG_RESTRICT
)) != 0)
1137 return compile_cplus_convert_qualified (instance
, type
);
1139 switch (TYPE_CODE (type
))
1142 case TYPE_CODE_RVALUE_REF
:
1143 return compile_cplus_convert_reference (instance
, type
);
1146 return compile_cplus_convert_pointer (instance
, type
);
1148 case TYPE_CODE_ARRAY
:
1149 return compile_cplus_convert_array (instance
, type
);
1151 case TYPE_CODE_STRUCT
:
1152 case TYPE_CODE_UNION
:
1154 compile_cplus_convert_struct_or_union (instance
, type
, nested_access
);
1156 case TYPE_CODE_ENUM
:
1157 return compile_cplus_convert_enum (instance
, type
, nested_access
);
1159 case TYPE_CODE_FUNC
:
1160 return compile_cplus_convert_func (instance
, type
, false);
1162 case TYPE_CODE_METHOD
:
1164 compile_cplus_convert_method (instance
, TYPE_SELF_TYPE (type
), type
);
1166 case TYPE_CODE_MEMBERPTR
:
1167 case TYPE_CODE_METHODPTR
:
1168 return compile_cplus_convert_memberptr (instance
, type
);
1172 return compile_cplus_convert_int (instance
, type
);
1175 return compile_cplus_convert_float (instance
, type
);
1177 case TYPE_CODE_VOID
:
1178 return compile_cplus_convert_void (instance
, type
);
1180 case TYPE_CODE_BOOL
:
1181 return compile_cplus_convert_bool (instance
, type
);
1183 case TYPE_CODE_COMPLEX
:
1184 return compile_cplus_convert_complex (instance
, type
);
1186 case TYPE_CODE_NAMESPACE
:
1187 return compile_cplus_convert_namespace (instance
, type
);
1189 case TYPE_CODE_TYPEDEF
:
1190 return compile_cplus_convert_typedef (instance
, type
, nested_access
);
1196 std::string s
= string_printf (_("unhandled TYPE_CODE %d"),
1199 return instance
->plugin ().error (s
.c_str ());
1203 compile_cplus_instance::convert_type (struct type
*type
,
1204 enum gcc_cp_symbol_kind nested_access
)
1206 /* Check if TYPE has already been converted. */
1208 if (get_cached_type (type
, result
))
1211 /* It is the first time this type has been seen -- convert it
1212 and cache it, if appropriate.. */
1213 result
= convert_type_cplus_basic (this, type
, nested_access
);
1214 if (result
!= GCC_TYPE_NONE
)
1215 insert_type (type
, result
);
1220 compile_cplus_instance::gcc_cplus_enter_scope
1221 (void *datum
, struct gcc_cp_context
*gcc_context
)
1226 compile_cplus_instance::gcc_cplus_leave_scope
1227 (void *datum
, struct gcc_cp_context
*gcc_context
)
1233 /* Plug-in forwards. */
1235 /* C++ plug-in wrapper. */
1237 /* A result printer for plug-in calls that return a gcc_type or
1241 compile_cplus_debug_output_1 (gcc_type arg
)
1243 fprintf_unfiltered (gdb_stdlog
, "%lld", arg
);
1247 compile_cplus_debug_output_1 (const char *arg
)
1250 fputs_unfiltered ("NULL", gdb_stdlog
);
1252 fputs_unfiltered (arg
, gdb_stdlog
);
1256 compile_cplus_debug_output ()
1260 template <typename T
>
1262 compile_cplus_debug_output_1 (const T
*arg
)
1266 template <typename T
, typename
... Targs
>
1268 compile_cplus_debug_output (T arg
, Targs
... Args
)
1270 compile_cplus_debug_output_1 (arg
);
1271 fputc_unfiltered (' ', gdb_stdlog
);
1272 compile_cplus_debug_output (Args
...);
1275 #define FORWARD(OP,...) m_context->cp_ops->OP(m_context, ##__VA_ARGS__)
1276 #define OUTPUT_DEBUG_RESULT(R) \
1277 if (debug_compile_cplus_types) \
1279 fputs_unfiltered (": ", gdb_stdlog); \
1280 compile_cplus_debug_output (R); \
1281 fputc_unfiltered ('\n', gdb_stdlog); \
1284 #define GCC_METHOD0(R, N) \
1285 R gcc_cp_plugin::N () const \
1287 if (debug_compile_cplus_types) \
1288 compile_cplus_debug_output (STRINGIFY (N)); \
1289 auto result = FORWARD (N); \
1290 OUTPUT_DEBUG_RESULT (result); \
1293 #define GCC_METHOD1(R, N, A) \
1294 R gcc_cp_plugin::N (A a) const \
1296 if (debug_compile_cplus_types) \
1297 compile_cplus_debug_output (STRINGIFY (N), a); \
1298 auto result = FORWARD (N, a); \
1299 OUTPUT_DEBUG_RESULT (result); \
1302 #define GCC_METHOD2(R, N, A, B) \
1303 R gcc_cp_plugin::N (A a, B b) const \
1305 if (debug_compile_cplus_types) \
1306 compile_cplus_debug_output (STRINGIFY (N), a, b); \
1307 auto result = FORWARD (N, a, b); \
1308 OUTPUT_DEBUG_RESULT (result); \
1311 #define GCC_METHOD3(R, N, A, B, C) \
1312 R gcc_cp_plugin::N (A a, B b, C c) const \
1314 if (debug_compile_cplus_types) \
1315 compile_cplus_debug_output (STRINGIFY (N), a, b, c); \
1316 auto result = FORWARD (N, a, b, c); \
1317 OUTPUT_DEBUG_RESULT (result); \
1320 #define GCC_METHOD4(R, N, A, B, C, D) \
1321 R gcc_cp_plugin::N (A a, B b, C c, D d) const \
1323 if (debug_compile_cplus_types) \
1324 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d); \
1325 auto result = FORWARD (N, a, b, c, d); \
1326 OUTPUT_DEBUG_RESULT (result); \
1329 #define GCC_METHOD5(R, N, A, B, C, D, E) \
1330 R gcc_cp_plugin::N (A a, B b, C c, D d, E e) const \
1332 if (debug_compile_cplus_types) \
1333 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e); \
1334 auto result = FORWARD (N, a, b, c, d, e); \
1335 OUTPUT_DEBUG_RESULT (result); \
1338 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
1339 R gcc_cp_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \
1341 if (debug_compile_cplus_types) \
1342 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e, f, g); \
1343 auto result = FORWARD (N, a, b, c, d, e, f, g); \
1344 OUTPUT_DEBUG_RESULT (result); \
1348 #include "gcc-cp-fe.def"
1358 #undef OUTPUT_DEBUG_RESULT
1361 gcc_cp_plugin::build_decl (const char *debug_decltype
, const char *name
,
1362 enum gcc_cp_symbol_kind sym_kind
, gcc_type sym_type
,
1363 const char *substitution_name
, gcc_address address
,
1364 const char *filename
, unsigned int line_number
)
1366 if (debug_compile_cplus_types
)
1367 fprintf_unfiltered (gdb_stdlog
, "<%s> ", debug_decltype
);
1369 return build_decl (name
, sym_kind
, sym_type
, substitution_name
,
1370 address
, filename
, line_number
);
1374 gcc_cp_plugin::start_class_type (const char *debug_name
, gcc_decl typedecl
,
1375 const struct gcc_vbase_array
*base_classes
,
1376 const char *filename
, unsigned int line_number
)
1378 if (debug_compile_cplus_types
)
1379 fprintf_unfiltered (gdb_stdlog
, "<%s> ", debug_name
);
1381 return start_class_type (typedecl
, base_classes
, filename
, line_number
);
1385 gcc_cp_plugin::finish_class_type (const char *debug_name
,
1386 unsigned long size_in_bytes
)
1388 if (debug_compile_cplus_types
)
1389 fprintf_unfiltered (gdb_stdlog
, "<%s> ", debug_name
);
1391 return finish_class_type (size_in_bytes
);
1395 gcc_cp_plugin::pop_binding_level (const char *debug_name
)
1397 if (debug_compile_cplus_types
)
1398 fprintf_unfiltered (gdb_stdlog
, "<%s> ", debug_name
);
1400 return pop_binding_level ();
1404 _initialize_compile_cplus_types ()
1406 add_setshow_boolean_cmd ("compile-cplus-types", no_class
,
1407 &debug_compile_cplus_types
, _("\
1408 Set debugging of C++ compile type conversion."), _("\
1409 Show debugging of C++ compile type conversion."), _("\
1410 When enabled debugging messages are printed during C++ type conversion for\n\
1411 the compile commands."),
1417 add_setshow_boolean_cmd ("compile-cplus-scopes", no_class
,
1418 &debug_compile_cplus_scopes
, _("\
1419 Set debugging of C++ compile scopes."), _("\
1420 Show debugging of C++ compile scopes."), _("\
1421 When enabled debugging messages are printed about definition scopes during\n\
1422 C++ type conversion for the compile commands."),