1 /* Convert types from GDB to GCC
3 Copyright (C) 2014-2023 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 "gdbsupport/preprocessor.h"
24 #include "compile-internal.h"
25 #include "compile-cplus.h"
26 #include "gdbsupport/gdb_assert.h"
29 #include "cp-support.h"
35 #include "compile-c.h"
38 /* Default compile flags for C++. */
40 const char *compile_cplus_instance::m_default_cflags
= "-std=gnu++11";
42 /* Flag to enable internal debugging. */
44 static bool debug_compile_cplus_types
= false;
46 /* Flag to enable internal scope switching debugging. */
48 static bool debug_compile_cplus_scopes
= false;
50 /* Forward declarations. */
52 static gcc_type
compile_cplus_convert_func (compile_cplus_instance
*instance
,
54 bool strip_artificial
);
56 /* See description in compile-cplus.h. */
58 gdb::unique_xmalloc_ptr
<char>
59 compile_cplus_instance::decl_name (const char *natural
)
61 if (natural
== nullptr)
64 gdb::unique_xmalloc_ptr
<char> name
= cp_func_name (natural
);
68 return make_unique_xstrdup (natural
);
71 /* Get the access flag for the NUM'th field of TYPE. */
73 static enum gcc_cp_symbol_kind
74 get_field_access_flag (const struct type
*type
, int num
)
76 if (TYPE_FIELD_PROTECTED (type
, num
))
77 return GCC_CP_ACCESS_PROTECTED
;
78 else if (TYPE_FIELD_PRIVATE (type
, num
))
79 return GCC_CP_ACCESS_PRIVATE
;
81 /* GDB assumes everything else is public. */
82 return GCC_CP_ACCESS_PUBLIC
;
85 /* Get the access flag for the NUM'th method of TYPE's FNI'th
88 enum gcc_cp_symbol_kind
89 get_method_access_flag (const struct type
*type
, int fni
, int num
)
91 gdb_assert (type
->code () == TYPE_CODE_STRUCT
);
93 /* If this type was not declared a class, everything is public. */
94 if (!type
->is_declared_class ())
95 return GCC_CP_ACCESS_PUBLIC
;
97 /* Otherwise, read accessibility from the fn_field. */
98 const struct fn_field
*methods
= TYPE_FN_FIELDLIST1 (type
, fni
);
99 if (TYPE_FN_FIELD_PROTECTED (methods
, num
))
100 return GCC_CP_ACCESS_PROTECTED
;
101 else if (TYPE_FN_FIELD_PRIVATE (methods
, num
))
102 return GCC_CP_ACCESS_PRIVATE
;
104 return GCC_CP_ACCESS_PUBLIC
;
107 /* A useful debugging function to output the scope SCOPE to stdout. */
109 static void __attribute__ ((used
))
110 debug_print_scope (const compile_scope
&scope
)
112 for (const auto &comp
: scope
)
114 const char *symbol
= (comp
.bsymbol
.symbol
!= nullptr
115 ? comp
.bsymbol
.symbol
->natural_name ()
118 printf_unfiltered ("\tname = %s, symbol = %s\n", comp
.name
.c_str (),
123 /* See description in compile-cplus.h. */
126 type_name_to_scope (const char *type_name
, const struct block
*block
)
130 if (type_name
== nullptr)
132 /* An anonymous type. We cannot really do much here. We simply cannot
133 look up anonymous types easily/at all. */
137 const char *p
= type_name
;
138 std::string lookup_name
;
142 /* Create a string token of the first component of TYPE_NAME. */
143 int len
= cp_find_first_component (p
);
144 std::string
s (p
, len
);
146 /* Advance past the last token. */
149 /* Look up the symbol and decide when to stop. */
150 if (!lookup_name
.empty ())
154 /* Look up the resulting name. */
155 struct block_symbol bsymbol
156 = lookup_symbol (lookup_name
.c_str (), block
, VAR_DOMAIN
, nullptr);
158 if (bsymbol
.symbol
!= nullptr)
160 scope_component comp
= {s
, bsymbol
};
162 scope
.push_back (comp
);
164 if (bsymbol
.symbol
->type ()->code () != TYPE_CODE_NAMESPACE
)
178 /* This shouldn't happen since we are not attempting to
179 loop over user input. This name is generated by GDB
181 internal_error (_("malformed TYPE_NAME during parsing"));
189 /* Compare two scope_components for equality. These are equal if the names
190 of the two components' are the same. */
193 operator== (const scope_component
&lhs
, const scope_component
&rhs
)
195 return lhs
.name
== rhs
.name
;
198 /* Compare two scope_components for inequality. These are not equal if
199 the two components' names are not equal. */
202 operator!= (const scope_component
&lhs
, const scope_component
&rhs
)
204 return lhs
.name
!= rhs
.name
;
207 /* Compare two compile_scopes for equality. These are equal if they are both
208 contain the same number of components and each component is equal. */
211 operator== (const compile_scope
&lhs
, const compile_scope
&rhs
)
213 if (lhs
.size () != rhs
.size ())
216 for (int i
= 0; i
< lhs
.size (); ++i
)
218 if (lhs
[i
] != rhs
[i
])
225 /* Compare two compile_scopes for inequality. These are inequal if they
226 contain unequal number of elements or if any of the components are not
230 operator!= (const compile_scope
&lhs
, const compile_scope
&rhs
)
232 if (lhs
.size () != rhs
.size ())
235 for (int i
= 0; i
< lhs
.size (); ++i
)
237 if (lhs
[i
] != rhs
[i
])
244 /* See description in compile-cplus.h. */
247 compile_cplus_instance::enter_scope (compile_scope
&&new_scope
)
249 bool must_push
= m_scopes
.empty () || m_scopes
.back () != new_scope
;
251 new_scope
.m_pushed
= must_push
;
253 /* Save the new scope. */
254 m_scopes
.push_back (std::move (new_scope
));
258 if (debug_compile_cplus_scopes
)
260 gdb_printf (gdb_stdlog
, "entering new scope %s\n",
261 host_address_to_string (&m_scopes
.back ()));
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 (m_scopes
.back ().begin (), m_scopes
.back ().end () - 1,
271 [this] (const scope_component
&comp
)
273 gdb_assert (comp
.bsymbol
.symbol
->type ()->code ()
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 gdb_printf (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
)
307 gdb_printf (gdb_stdlog
, "leaving scope %s\n",
308 host_address_to_string (¤t
));
311 /* Pop namespaces. */
313 (current
.begin (),current
.end () - 1,
314 [this] (const scope_component
&comp
) {
315 gdb_assert (comp
.bsymbol
.symbol
->type ()->code ()
316 == TYPE_CODE_NAMESPACE
);
317 this->plugin ().pop_binding_level (comp
.name
.c_str ());
320 /* Pop global namespace. */
321 plugin ().pop_binding_level ("");
325 if (debug_compile_cplus_scopes
)
326 gdb_printf (gdb_stdlog
,
327 "identical scopes -- not leaving scope\n");
331 /* See description in compile-cplus.h. */
334 compile_cplus_instance::new_scope (const char *type_name
, struct type
*type
)
336 /* Break the type name into components. If TYPE was defined in some
337 superclass, we do not process TYPE but process the enclosing type
339 compile_scope scope
= type_name_to_scope (type_name
, block ());
343 /* Get the name of the last component, which should be the
344 unqualified name of the type to process. */
345 scope_component
&comp
= scope
.back ();
347 if (!types_equal (type
, comp
.bsymbol
.symbol
->type ())
348 && (m_scopes
.empty ()
349 || (m_scopes
.back ().back ().bsymbol
.symbol
350 != comp
.bsymbol
.symbol
)))
352 /* The type is defined inside another class(es). Convert that
353 type instead of defining this type. */
354 convert_type (comp
.bsymbol
.symbol
->type ());
356 /* If the original type (passed in to us) is defined in a nested
357 class, the previous call will give us that type's gcc_type.
358 Upper layers are expecting to get the original type's
360 get_cached_type (type
, &scope
.m_nested_type
);
366 if (type
->name () == nullptr)
370 /* We don't have a qualified name for this to look up, but
371 we need a scope. We have to assume, then, that it is the same
372 as the current scope, if any. */
373 if (!m_scopes
.empty ())
375 scope
= m_scopes
.back ();
376 scope
.m_pushed
= false;
379 scope
.push_back (scope_component ());
385 decl_name (type
->name ()).get (),
386 lookup_symbol (type
->name (), block (), VAR_DOMAIN
, nullptr)
388 scope
.push_back (comp
);
392 /* There must be at least one component in the compile_scope. */
393 gdb_assert (scope
.size () > 0);
397 /* See description in compile-cplus.h. */
400 compile_cplus_instance::convert_reference_base
401 (gcc_type base
, enum gcc_cp_ref_qualifiers rquals
)
403 return this->plugin ().build_reference_type (base
, rquals
);
406 /* Convert a reference type to its gcc representation. */
409 compile_cplus_convert_reference (compile_cplus_instance
*instance
,
412 gcc_type target
= instance
->convert_type (type
->target_type ());
414 enum gcc_cp_ref_qualifiers quals
= GCC_CP_REF_QUAL_NONE
;
415 switch (type
->code ())
418 quals
= GCC_CP_REF_QUAL_LVALUE
;
420 case TYPE_CODE_RVALUE_REF
:
421 quals
= GCC_CP_REF_QUAL_RVALUE
;
424 gdb_assert_not_reached ("unexpected type code for reference type");
427 return instance
->convert_reference_base (target
, quals
);
430 /* See description in compile-cplus.h. */
433 compile_cplus_instance::convert_pointer_base(gcc_type target
)
435 return plugin ().build_pointer_type (target
);
438 /* Convert a pointer type to its gcc representation. */
441 compile_cplus_convert_pointer (compile_cplus_instance
*instance
,
444 gcc_type target
= instance
->convert_type (type
->target_type ());
446 return instance
->convert_pointer_base (target
);
449 /* Convert an array type to its gcc representation. */
452 compile_cplus_convert_array (compile_cplus_instance
*instance
,
455 struct type
*range
= type
->index_type ();
456 gcc_type element_type
= instance
->convert_type (type
->target_type ());
458 if (range
->bounds ()->low
.kind () != PROP_CONST
)
460 const char *s
= _("array type with non-constant"
461 " lower bound is not supported");
463 return instance
->plugin ().error (s
);
466 if (range
->bounds ()->low
.const_val () != 0)
468 const char *s
= _("cannot convert array type with "
469 "non-zero lower bound to C");
471 return instance
->plugin ().error (s
);
474 if (range
->bounds ()->high
.kind () == PROP_LOCEXPR
475 || range
->bounds ()->high
.kind () == PROP_LOCLIST
)
477 if (type
->is_vector ())
479 const char *s
= _("variably-sized vector type is not supported");
481 return instance
->plugin ().error (s
);
484 std::string upper_bound
485 = c_get_range_decl_name (&range
->bounds ()->high
);
486 return instance
->plugin ().build_vla_array_type (element_type
,
487 upper_bound
.c_str ());
491 LONGEST low_bound
, high_bound
, count
;
493 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
497 gdb_assert (low_bound
== 0); /* Ensured above. */
498 count
= high_bound
+ 1;
501 if (type
->is_vector ())
502 return instance
->plugin ().build_vector_type (element_type
, count
);
504 return instance
->plugin ().build_array_type (element_type
, count
);
508 /* Convert a typedef of TYPE. If not GCC_CP_ACCESS_NONE, NESTED_ACCESS
509 will define the accessibility of the typedef definition in its
513 compile_cplus_convert_typedef (compile_cplus_instance
*instance
,
515 enum gcc_cp_symbol_kind nested_access
)
517 compile_scope scope
= instance
->new_scope (type
->name (), type
);
519 if (scope
.nested_type () != GCC_TYPE_NONE
)
520 return scope
.nested_type ();
522 gdb::unique_xmalloc_ptr
<char> name
523 = compile_cplus_instance::decl_name (type
->name ());
525 /* Make sure the scope for this type has been pushed. */
526 instance
->enter_scope (std::move (scope
));
528 /* Convert the typedef's real type. */
529 gcc_type typedef_type
= instance
->convert_type (check_typedef (type
));
531 instance
->plugin ().build_decl ("typedef", name
.get (),
532 GCC_CP_SYMBOL_TYPEDEF
| nested_access
,
533 typedef_type
, 0, 0, nullptr, 0);
535 /* Completed this scope. */
536 instance
->leave_scope ();
540 /* Convert types defined in TYPE. */
543 compile_cplus_convert_type_defns (compile_cplus_instance
*instance
,
547 enum gcc_cp_symbol_kind accessibility
;
549 /* Convert typedefs. */
550 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
552 if (TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
))
553 accessibility
= GCC_CP_ACCESS_PROTECTED
;
554 else if (TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
555 accessibility
= GCC_CP_ACCESS_PRIVATE
;
557 accessibility
= GCC_CP_ACCESS_PUBLIC
;
558 instance
->convert_type (TYPE_TYPEDEF_FIELD_TYPE (type
, i
), accessibility
);
561 /* Convert nested types. */
562 for (i
= 0; i
< TYPE_NESTED_TYPES_COUNT (type
); ++i
)
564 if (TYPE_NESTED_TYPES_FIELD_PROTECTED (type
, i
))
565 accessibility
= GCC_CP_ACCESS_PROTECTED
;
566 else if (TYPE_NESTED_TYPES_FIELD_PRIVATE (type
, i
))
567 accessibility
= GCC_CP_ACCESS_PRIVATE
;
569 accessibility
= GCC_CP_ACCESS_PUBLIC
;
570 instance
->convert_type (TYPE_NESTED_TYPES_FIELD_TYPE (type
, i
),
575 /* Convert data members defined in TYPE, which should be struct/class/union
576 with gcc_type COMP_TYPE. */
579 compile_cplus_convert_struct_or_union_members
580 (compile_cplus_instance
*instance
, struct type
*type
, gcc_type comp_type
)
582 for (int i
= TYPE_N_BASECLASSES (type
); i
< type
->num_fields (); ++i
)
584 const char *field_name
= type
->field (i
).name ();
586 if (TYPE_FIELD_IGNORE (type
, i
)
587 || TYPE_FIELD_ARTIFICIAL (type
, i
))
590 /* GDB records unnamed/anonymous fields with empty string names. */
591 if (*field_name
== '\0')
592 field_name
= nullptr;
595 = instance
->convert_type (type
->field (i
).type ());
597 if (field_is_static (&type
->field (i
)))
601 switch (type
->field (i
).loc_kind ())
603 case FIELD_LOC_KIND_PHYSADDR
:
605 physaddr
= type
->field (i
).loc_physaddr ();
607 instance
->plugin ().build_decl
608 ("field physaddr", field_name
,
609 (GCC_CP_SYMBOL_VARIABLE
| get_field_access_flag (type
, i
)),
610 field_type
, nullptr, physaddr
, nullptr, 0);
614 case FIELD_LOC_KIND_PHYSNAME
:
616 const char *physname
= type
->field (i
).loc_physname ();
617 struct block_symbol sym
618 = lookup_symbol (physname
, instance
->block (),
619 VAR_DOMAIN
, nullptr);
621 if (sym
.symbol
== nullptr)
623 /* We didn't actually find the symbol. There's little
624 we can do but ignore this member. */
627 const char *filename
= sym
.symbol
->symtab ()->filename
;
628 unsigned int line
= sym
.symbol
->line ();
630 physaddr
= sym
.symbol
->value_address ();
631 instance
->plugin ().build_decl
632 ("field physname", field_name
,
633 (GCC_CP_SYMBOL_VARIABLE
| get_field_access_flag (type
, i
)),
634 field_type
, nullptr, physaddr
, filename
, line
);
639 gdb_assert_not_reached
640 ("unexpected static field location kind");
645 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, i
);
646 enum gcc_cp_symbol_kind field_flags
= GCC_CP_SYMBOL_FIELD
647 | get_field_access_flag (type
, i
);
650 bitsize
= 8 * type
->field (i
).type ()->length ();
652 instance
->plugin ().build_field
653 (field_name
, field_type
, field_flags
, bitsize
,
654 type
->field (i
).loc_bitpos ());
659 /* Convert a method type to its gcc representation. */
662 compile_cplus_convert_method (compile_cplus_instance
*instance
,
663 struct type
*parent_type
,
664 struct type
*method_type
)
666 /* Get the actual function type of the method, the corresponding class's
667 type and corresponding qualifier flags. */
668 gcc_type func_type
= compile_cplus_convert_func (instance
, method_type
, true);
669 gcc_type class_type
= instance
->convert_type (parent_type
);
670 gcc_cp_qualifiers_flags quals
= 0;
672 if (TYPE_CONST (method_type
))
673 quals
|= GCC_CP_QUALIFIER_CONST
;
674 if (TYPE_VOLATILE (method_type
))
675 quals
|= GCC_CP_QUALIFIER_VOLATILE
;
676 if (TYPE_RESTRICT (method_type
))
677 quals
|= GCC_CP_QUALIFIER_RESTRICT
;
679 /* Not yet implemented. */
680 gcc_cp_ref_qualifiers_flags rquals
= GCC_CP_REF_QUAL_NONE
;
682 return instance
->plugin ().build_method_type
683 (class_type
, func_type
, quals
.raw (), rquals
.raw ());
686 /* Convert a member or method pointer represented by TYPE. */
689 compile_cplus_convert_memberptr (compile_cplus_instance
*instance
,
692 struct type
*containing_class
= TYPE_SELF_TYPE (type
);
694 if (containing_class
== nullptr)
695 return GCC_TYPE_NONE
;
697 gcc_type class_type
= instance
->convert_type (containing_class
);
699 = instance
->convert_type (type
->target_type ());
701 return instance
->plugin ().build_pointer_to_member_type
702 (class_type
, member_type
);
705 /* Convert all methods defined in TYPE, which should be a class/struct/union
706 with gcc_type CLASS_TYPE. */
709 compile_cplus_convert_struct_or_union_methods (compile_cplus_instance
*instance
,
713 for (int i
= 0; i
< TYPE_NFN_FIELDS (type
); ++i
)
715 struct fn_field
*methods
= TYPE_FN_FIELDLIST1 (type
, i
);
716 gdb::unique_xmalloc_ptr
<char> overloaded_name
717 = compile_cplus_instance::decl_name (TYPE_FN_FIELDLIST_NAME (type
, i
));
719 /* Loop through the fieldlist, adding decls to the compiler's
720 representation of the class. */
721 for (int j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (type
, i
); ++j
)
723 /* Skip artificial methods. */
724 if (TYPE_FN_FIELD_ARTIFICIAL (methods
, j
))
727 gcc_cp_symbol_kind_flags sym_kind
= GCC_CP_SYMBOL_FUNCTION
;
728 gcc_type method_type
;
729 struct block_symbol sym
730 = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (methods
, j
),
731 instance
->block (), VAR_DOMAIN
, nullptr);
733 if (sym
.symbol
== nullptr)
735 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, j
))
737 /* This is beyond hacky, and is really only a workaround for
738 detecting pure virtual methods. */
739 method_type
= compile_cplus_convert_method
740 (instance
, type
, TYPE_FN_FIELD_TYPE (methods
, j
));
742 instance
->plugin ().build_decl
743 ("pure virtual method", overloaded_name
.get (),
745 | get_method_access_flag (type
, i
, j
)
746 | GCC_CP_FLAG_VIRTUAL_FUNCTION
747 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
).raw (),
748 method_type
, nullptr, 0, nullptr, 0);
752 /* This can happen if we have a DW_AT_declaration DIE
753 for the method, but no "definition"-type DIE (with
754 DW_AT_specification referencing the decl DIE), i.e.,
755 the compiler has probably optimized the method away.
757 In this case, all we can hope to do is issue a warning
758 to the user letting him know. If the user has not actually
759 requested using this method, things should still work. */
760 warning (_("Method %s appears to be optimized out.\n"
761 "All references to this method will be undefined."),
762 TYPE_FN_FIELD_PHYSNAME (methods
, j
));
766 const char *filename
= sym
.symbol
->symtab ()->filename
;
767 unsigned int line
= sym
.symbol
->line ();
768 CORE_ADDR address
= sym
.symbol
->value_block()->start ();
771 if (TYPE_FN_FIELD_STATIC_P (methods
, j
))
773 kind
= "static method";
774 method_type
= compile_cplus_convert_func
775 (instance
, TYPE_FN_FIELD_TYPE (methods
, j
), true);
780 method_type
= (compile_cplus_convert_method
781 (instance
, type
, TYPE_FN_FIELD_TYPE (methods
, j
)));
784 if (TYPE_FN_FIELD_VIRTUAL_P (methods
, j
))
785 sym_kind
|= GCC_CP_FLAG_VIRTUAL_FUNCTION
;
787 instance
->plugin ().build_decl
788 (kind
, overloaded_name
.get (),
789 (sym_kind
| get_method_access_flag (type
, i
, j
)).raw (),
790 method_type
, nullptr, address
, filename
, line
);
795 /* Convert a struct or union type to its gcc representation. If this type
796 was defined in another type, NESTED_ACCESS should indicate the
797 accessibility of this type. */
800 compile_cplus_convert_struct_or_union (compile_cplus_instance
*instance
,
802 enum gcc_cp_symbol_kind nested_access
)
804 const char *filename
= nullptr;
805 unsigned short line
= 0;
807 /* Get the decl name of this type. */
808 gdb::unique_xmalloc_ptr
<char> name
809 = compile_cplus_instance::decl_name (type
->name ());
811 /* Create a new scope for TYPE. */
812 compile_scope scope
= instance
->new_scope (type
->name (), type
);
814 if (scope
.nested_type () != GCC_TYPE_NONE
)
816 /* The type requested was actually defined inside another type,
817 such as a nested class definition. Return that type. */
818 return scope
.nested_type ();
821 /* Push all scopes. */
822 instance
->enter_scope (std::move (scope
));
824 /* First we create the resulting type and enter it into our hash
825 table. This lets recursive types work. */
828 if (type
->code () == TYPE_CODE_STRUCT
)
830 const char *what
= type
->is_declared_class () ? "class" : "struct";
832 resuld
= instance
->plugin ().build_decl
833 (what
, name
.get (), (GCC_CP_SYMBOL_CLASS
| nested_access
834 | (type
->is_declared_class ()
835 ? GCC_CP_FLAG_CLASS_NOFLAG
836 : GCC_CP_FLAG_CLASS_IS_STRUCT
)),
837 0, nullptr, 0, filename
, line
);
841 gdb_assert (type
->code () == TYPE_CODE_UNION
);
842 resuld
= instance
->plugin ().build_decl
843 ("union", name
.get (), GCC_CP_SYMBOL_UNION
| nested_access
,
844 0, nullptr, 0, filename
, line
);
848 if (type
->code () == TYPE_CODE_STRUCT
)
850 int num_baseclasses
= TYPE_N_BASECLASSES (type
);
851 std::vector
<gcc_type
> elements (num_baseclasses
);
852 std::vector
<enum gcc_cp_symbol_kind
> flags (num_baseclasses
);
854 struct gcc_vbase_array bases
{};
855 bases
.elements
= elements
.data ();
856 bases
.flags
= flags
.data ();
857 bases
.n_elements
= num_baseclasses
;
859 for (int i
= 0; i
< num_baseclasses
; ++i
)
861 struct type
*base_type
= TYPE_BASECLASS (type
, i
);
863 bases
.flags
[i
] = (GCC_CP_SYMBOL_BASECLASS
864 | get_field_access_flag (type
, i
)
865 | (BASETYPE_VIA_VIRTUAL (type
, i
)
866 ? GCC_CP_FLAG_BASECLASS_VIRTUAL
867 : GCC_CP_FLAG_BASECLASS_NOFLAG
));
868 bases
.elements
[i
] = instance
->convert_type (base_type
);
871 result
= instance
->plugin ().start_class_type
872 (name
.get (), resuld
, &bases
, filename
, line
);
876 gdb_assert (type
->code () == TYPE_CODE_UNION
);
877 result
= instance
->plugin ().start_class_type
878 (name
.get (), resuld
, nullptr, filename
, line
);
881 instance
->insert_type (type
, result
);
883 /* Add definitions. */
884 compile_cplus_convert_type_defns (instance
, type
);
887 compile_cplus_convert_struct_or_union_methods (instance
, type
, result
);
890 compile_cplus_convert_struct_or_union_members (instance
, type
, result
);
893 instance
->plugin ().finish_class_type (name
.get (), type
->length ());
895 /* Pop all scopes. */
896 instance
->leave_scope ();
900 /* Convert an enum type to its gcc representation. If this type
901 was defined in another type, NESTED_ACCESS should indicate the
902 accessibility of this type.*/
905 compile_cplus_convert_enum (compile_cplus_instance
*instance
, struct type
*type
,
906 enum gcc_cp_symbol_kind nested_access
)
908 bool scoped_enum_p
= false;
910 /* Create a new scope for this type. */
911 compile_scope scope
= instance
->new_scope (type
->name (), type
);
913 if (scope
.nested_type () != GCC_TYPE_NONE
)
915 /* The type requested was actually defined inside another type,
916 such as a nested class definition. Return that type. */
917 return scope
.nested_type ();
920 gdb::unique_xmalloc_ptr
<char> name
921 = compile_cplus_instance::decl_name (type
->name ());
923 /* Push all scopes. */
924 instance
->enter_scope (std::move (scope
));
927 = instance
->plugin ().get_int_type (type
->is_unsigned (),
928 type
->length (), nullptr);
930 = instance
->plugin ().start_enum_type (name
.get (), int_type
,
931 GCC_CP_SYMBOL_ENUM
| nested_access
933 ? GCC_CP_FLAG_ENUM_SCOPED
934 : GCC_CP_FLAG_ENUM_NOFLAG
),
936 for (int i
= 0; i
< type
->num_fields (); ++i
)
938 gdb::unique_xmalloc_ptr
<char> fname
939 = compile_cplus_instance::decl_name (type
->field (i
).name ());
941 if (type
->field (i
).loc_kind () != FIELD_LOC_KIND_ENUMVAL
945 instance
->plugin ().build_enum_constant (result
, fname
.get (),
946 type
->field (i
).loc_enumval ());
949 /* Finish enum definition and pop scopes. */
950 instance
->plugin ().finish_enum_type (result
);
951 instance
->leave_scope ();
955 /* Convert a function type to its gcc representation. This function does
956 not deal with function templates. */
959 compile_cplus_convert_func (compile_cplus_instance
*instance
,
960 struct type
*type
, bool strip_artificial
)
962 int is_varargs
= type
->has_varargs ();
963 struct type
*target_type
= type
->target_type ();
965 /* Functions with no debug info have no return type. Ideally we'd
966 want to fallback to the type of the cast just before the
967 function, like GDB's built-in expression parser, but we don't
968 have access to that type here. For now, fallback to int, like
969 GDB's parser used to do. */
970 if (target_type
== nullptr)
972 if (type
->is_objfile_owned ())
973 target_type
= objfile_type (type
->objfile_owner ())->builtin_int
;
975 target_type
= builtin_type (type
->arch_owner ())->builtin_int
;
976 warning (_("function has unknown return type; assuming int"));
979 /* This approach means we can't make self-referential function
980 types. Those are impossible in C, though. */
981 gcc_type return_type
= instance
->convert_type (target_type
);
983 std::vector
<gcc_type
> elements (type
->num_fields ());
984 struct gcc_type_array array
= { type
->num_fields (), elements
.data () };
986 for (int i
= 0; i
< type
->num_fields (); ++i
)
988 if (strip_artificial
&& TYPE_FIELD_ARTIFICIAL (type
, i
))
995 array
.elements
[i
- artificials
]
996 = instance
->convert_type (type
->field (i
).type ());
1000 /* We omit setting the argument types to `void' to be a little flexible
1001 with some minsyms like printf (compile-cplus.exp has examples). */
1002 gcc_type result
= instance
->plugin ().build_function_type
1003 (return_type
, &array
, is_varargs
);
1007 /* Convert an integer type to its gcc representation. */
1010 compile_cplus_convert_int (compile_cplus_instance
*instance
, struct type
*type
)
1012 if (type
->has_no_signedness ())
1014 gdb_assert (type
->length () == 1);
1015 return instance
->plugin ().get_char_type ();
1018 return instance
->plugin ().get_int_type
1019 (type
->is_unsigned (), type
->length (), type
->name ());
1022 /* Convert a floating-point type to its gcc representation. */
1025 compile_cplus_convert_float (compile_cplus_instance
*instance
,
1028 return instance
->plugin ().get_float_type
1029 (type
->length (), type
->name ());
1032 /* Convert the 'void' type to its gcc representation. */
1035 compile_cplus_convert_void (compile_cplus_instance
*instance
, struct type
*type
)
1037 return instance
->plugin ().get_void_type ();
1040 /* Convert a boolean type to its gcc representation. */
1043 compile_cplus_convert_bool (compile_cplus_instance
*instance
, struct type
*type
)
1045 return instance
->plugin ().get_bool_type ();
1048 /* See description in compile-cplus.h. */
1051 compile_cplus_instance::convert_qualified_base (gcc_type base
,
1052 gcc_cp_qualifiers_flags quals
)
1054 gcc_type result
= base
;
1057 result
= plugin ().build_qualified_type (base
, quals
.raw ());
1062 /* See description in compile-cplus.h. */
1065 compile_cplus_convert_qualified (compile_cplus_instance
*instance
,
1068 struct type
*unqual
= make_unqualified_type (type
);
1069 gcc_cp_qualifiers_flags quals
= (enum gcc_cp_qualifiers
) 0;
1070 gcc_type unqual_converted
= instance
->convert_type (unqual
);
1072 if (TYPE_CONST (type
))
1073 quals
|= GCC_CP_QUALIFIER_CONST
;
1074 if (TYPE_VOLATILE (type
))
1075 quals
|= GCC_CP_QUALIFIER_VOLATILE
;
1076 if (TYPE_RESTRICT (type
))
1077 quals
|= GCC_CP_QUALIFIER_RESTRICT
;
1079 return instance
->convert_qualified_base (unqual_converted
, quals
);
1082 /* Convert a complex type to its gcc representation. */
1085 compile_cplus_convert_complex (compile_cplus_instance
*instance
,
1088 gcc_type base
= instance
->convert_type (type
->target_type ());
1090 return instance
->plugin ().build_complex_type (base
);
1093 /* Convert a namespace of TYPE. */
1096 compile_cplus_convert_namespace (compile_cplus_instance
*instance
,
1099 compile_scope scope
= instance
->new_scope (type
->name (), type
);
1100 gdb::unique_xmalloc_ptr
<char> name
1101 = compile_cplus_instance::decl_name (type
->name ());
1104 instance
->enter_scope (std::move (scope
));
1106 /* Convert this namespace. */
1107 instance
->plugin ().push_namespace (name
.get ());
1108 instance
->plugin ().pop_binding_level (name
.get ());
1111 instance
->leave_scope ();
1113 /* Namespaces are non-cacheable types. */
1114 return GCC_TYPE_NONE
;
1117 /* A helper function which knows how to convert most types from their
1118 gdb representation to the corresponding gcc form. This examines
1119 the TYPE and dispatches to the appropriate conversion function. It
1120 returns the gcc type.
1122 If the type was defined in another type, NESTED_ACCESS should indicate the
1123 accessibility of this type. */
1126 convert_type_cplus_basic (compile_cplus_instance
*instance
,
1128 enum gcc_cp_symbol_kind nested_access
)
1130 /* If we are converting a qualified type, first convert the
1131 unqualified type and then apply the qualifiers. */
1132 if ((type
->instance_flags () & (TYPE_INSTANCE_FLAG_CONST
1133 | TYPE_INSTANCE_FLAG_VOLATILE
1134 | TYPE_INSTANCE_FLAG_RESTRICT
)) != 0)
1135 return compile_cplus_convert_qualified (instance
, type
);
1137 switch (type
->code ())
1140 case TYPE_CODE_RVALUE_REF
:
1141 return compile_cplus_convert_reference (instance
, type
);
1144 return compile_cplus_convert_pointer (instance
, type
);
1146 case TYPE_CODE_ARRAY
:
1147 return compile_cplus_convert_array (instance
, type
);
1149 case TYPE_CODE_STRUCT
:
1150 case TYPE_CODE_UNION
:
1152 compile_cplus_convert_struct_or_union (instance
, type
, nested_access
);
1154 case TYPE_CODE_ENUM
:
1155 return compile_cplus_convert_enum (instance
, type
, nested_access
);
1157 case TYPE_CODE_FUNC
:
1158 return compile_cplus_convert_func (instance
, type
, false);
1160 case TYPE_CODE_METHOD
:
1162 compile_cplus_convert_method (instance
, TYPE_SELF_TYPE (type
), type
);
1164 case TYPE_CODE_MEMBERPTR
:
1165 case TYPE_CODE_METHODPTR
:
1166 return compile_cplus_convert_memberptr (instance
, type
);
1170 return compile_cplus_convert_int (instance
, type
);
1173 return compile_cplus_convert_float (instance
, type
);
1175 case TYPE_CODE_VOID
:
1176 return compile_cplus_convert_void (instance
, type
);
1178 case TYPE_CODE_BOOL
:
1179 return compile_cplus_convert_bool (instance
, type
);
1181 case TYPE_CODE_COMPLEX
:
1182 return compile_cplus_convert_complex (instance
, type
);
1184 case TYPE_CODE_NAMESPACE
:
1185 return compile_cplus_convert_namespace (instance
, type
);
1187 case TYPE_CODE_TYPEDEF
:
1188 return compile_cplus_convert_typedef (instance
, type
, nested_access
);
1194 std::string s
= string_printf (_("unhandled TYPE_CODE %d"),
1197 return instance
->plugin ().error (s
.c_str ());
1201 compile_cplus_instance::convert_type (struct type
*type
,
1202 enum gcc_cp_symbol_kind nested_access
)
1204 /* Check if TYPE has already been converted. */
1206 if (get_cached_type (type
, &result
))
1209 /* It is the first time this type has been seen -- convert it
1210 and cache it, if appropriate.. */
1211 result
= convert_type_cplus_basic (this, type
, nested_access
);
1212 if (result
!= GCC_TYPE_NONE
)
1213 insert_type (type
, result
);
1218 compile_cplus_instance::gcc_cplus_enter_scope
1219 (void *datum
, struct gcc_cp_context
*gcc_context
)
1224 compile_cplus_instance::gcc_cplus_leave_scope
1225 (void *datum
, struct gcc_cp_context
*gcc_context
)
1231 /* Plug-in forwards. */
1233 /* C++ plug-in wrapper. */
1235 /* A result printer for plug-in calls that return a gcc_type or
1239 compile_cplus_debug_output_1 (ULONGEST arg
)
1241 gdb_printf (gdb_stdlog
, "%s", pulongest (arg
));
1245 compile_cplus_debug_output_1 (const char *arg
)
1248 gdb_puts ("NULL", gdb_stdlog
);
1250 gdb_puts (arg
, gdb_stdlog
);
1254 compile_cplus_debug_output ()
1258 template <typename T
>
1260 compile_cplus_debug_output_1 (const T
*arg
)
1264 template <typename T
, typename
... Targs
>
1266 compile_cplus_debug_output (T arg
, Targs
... Args
)
1268 compile_cplus_debug_output_1 (arg
);
1269 gdb_putc (' ', gdb_stdlog
);
1270 compile_cplus_debug_output (Args
...);
1273 #define FORWARD(OP,...) m_context->cp_ops->OP(m_context, ##__VA_ARGS__)
1274 #define OUTPUT_DEBUG_RESULT(R) \
1275 if (debug_compile_cplus_types) \
1277 gdb_puts (": ", gdb_stdlog); \
1278 compile_cplus_debug_output (R); \
1279 gdb_putc ('\n', gdb_stdlog); \
1282 #define GCC_METHOD0(R, N) \
1283 R gcc_cp_plugin::N () const \
1285 if (debug_compile_cplus_types) \
1286 compile_cplus_debug_output (STRINGIFY (N)); \
1287 auto result = FORWARD (N); \
1288 OUTPUT_DEBUG_RESULT (result); \
1291 #define GCC_METHOD1(R, N, A) \
1292 R gcc_cp_plugin::N (A a) const \
1294 if (debug_compile_cplus_types) \
1295 compile_cplus_debug_output (STRINGIFY (N), a); \
1296 auto result = FORWARD (N, a); \
1297 OUTPUT_DEBUG_RESULT (result); \
1300 #define GCC_METHOD2(R, N, A, B) \
1301 R gcc_cp_plugin::N (A a, B b) const \
1303 if (debug_compile_cplus_types) \
1304 compile_cplus_debug_output (STRINGIFY (N), a, b); \
1305 auto result = FORWARD (N, a, b); \
1306 OUTPUT_DEBUG_RESULT (result); \
1309 #define GCC_METHOD3(R, N, A, B, C) \
1310 R gcc_cp_plugin::N (A a, B b, C c) const \
1312 if (debug_compile_cplus_types) \
1313 compile_cplus_debug_output (STRINGIFY (N), a, b, c); \
1314 auto result = FORWARD (N, a, b, c); \
1315 OUTPUT_DEBUG_RESULT (result); \
1318 #define GCC_METHOD4(R, N, A, B, C, D) \
1319 R gcc_cp_plugin::N (A a, B b, C c, D d) const \
1321 if (debug_compile_cplus_types) \
1322 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d); \
1323 auto result = FORWARD (N, a, b, c, d); \
1324 OUTPUT_DEBUG_RESULT (result); \
1327 #define GCC_METHOD5(R, N, A, B, C, D, E) \
1328 R gcc_cp_plugin::N (A a, B b, C c, D d, E e) const \
1330 if (debug_compile_cplus_types) \
1331 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e); \
1332 auto result = FORWARD (N, a, b, c, d, e); \
1333 OUTPUT_DEBUG_RESULT (result); \
1336 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
1337 R gcc_cp_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \
1339 if (debug_compile_cplus_types) \
1340 compile_cplus_debug_output (STRINGIFY (N), a, b, c, d, e, f, g); \
1341 auto result = FORWARD (N, a, b, c, d, e, f, g); \
1342 OUTPUT_DEBUG_RESULT (result); \
1346 #include "gcc-cp-fe.def"
1356 #undef OUTPUT_DEBUG_RESULT
1359 gcc_cp_plugin::build_decl (const char *debug_decltype
, const char *name
,
1360 enum gcc_cp_symbol_kind sym_kind
, gcc_type sym_type
,
1361 const char *substitution_name
, gcc_address address
,
1362 const char *filename
, unsigned int line_number
)
1364 if (debug_compile_cplus_types
)
1365 gdb_printf (gdb_stdlog
, "<%s> ", debug_decltype
);
1367 return build_decl (name
, sym_kind
, sym_type
, substitution_name
,
1368 address
, filename
, line_number
);
1372 gcc_cp_plugin::start_class_type (const char *debug_name
, gcc_decl typedecl
,
1373 const struct gcc_vbase_array
*base_classes
,
1374 const char *filename
, unsigned int line_number
)
1376 if (debug_compile_cplus_types
)
1377 gdb_printf (gdb_stdlog
, "<%s> ", debug_name
);
1379 return start_class_type (typedecl
, base_classes
, filename
, line_number
);
1383 gcc_cp_plugin::finish_class_type (const char *debug_name
,
1384 unsigned long size_in_bytes
)
1386 if (debug_compile_cplus_types
)
1387 gdb_printf (gdb_stdlog
, "<%s> ", debug_name
);
1389 return finish_class_type (size_in_bytes
);
1393 gcc_cp_plugin::pop_binding_level (const char *debug_name
)
1395 if (debug_compile_cplus_types
)
1396 gdb_printf (gdb_stdlog
, "<%s> ", debug_name
);
1398 return pop_binding_level ();
1401 void _initialize_compile_cplus_types ();
1403 _initialize_compile_cplus_types ()
1405 add_setshow_boolean_cmd ("compile-cplus-types", no_class
,
1406 &debug_compile_cplus_types
, _("\
1407 Set debugging of C++ compile type conversion."), _("\
1408 Show debugging of C++ compile type conversion."), _("\
1409 When enabled debugging messages are printed during C++ type conversion for\n\
1410 the compile commands."),
1416 add_setshow_boolean_cmd ("compile-cplus-scopes", no_class
,
1417 &debug_compile_cplus_scopes
, _("\
1418 Set debugging of C++ compile scopes."), _("\
1419 Show debugging of C++ compile scopes."), _("\
1420 When enabled debugging messages are printed about definition scopes during\n\
1421 C++ type conversion for the compile commands."),