static void check_bases PROTO((tree, int *, int *, int *));
static void check_bases_and_members PROTO((tree, int *));
static void create_vtable_ptr PROTO((tree, int *, int *, int *, tree *, tree *));
+static void layout_class_type PROTO((tree, int *, int *, int *, tree *, tree *));
+static void fixup_pending_inline PROTO((struct pending_inline *));
+static void fixup_inline_methods PROTO((tree));
/* Variables shared between class.c and call.c. */
}
}
-/* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
- (or C++ class declaration).
-
- For C++, we must handle the building of derived classes.
- Also, C++ allows static class members. The way that this is
- handled is to keep the field name where it is (as the DECL_NAME
- of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
- of the field. layout_record and layout_union will know about this.
+/* Fixup the inline function given by INFO now that the class is
+ complete. */
- More C++ hair: inline functions have text in their
- DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
- meaningful tree structure. After the struct has been laid out, set
- things up so that this can happen.
+static void
+fixup_pending_inline (info)
+ struct pending_inline *info;
+{
+ if (info)
+ {
+ tree args;
+ tree fn = info->fndecl;
- And still more: virtual functions. In the case of single inheritance,
- when a new virtual function is seen which redefines a virtual function
- from the base class, the new virtual function is placed into
- the virtual function table at exactly the same address that
- it had in the base class. When this is extended to multiple
- inheritance, the same thing happens, except that multiple virtual
- function tables must be maintained. The first virtual function
- table is treated in exactly the same way as in the case of single
- inheritance. Additional virtual function tables have different
- DELTAs, which tell how to adjust `this' to point to the right thing.
+ args = DECL_ARGUMENTS (fn);
+ while (args)
+ {
+ DECL_CONTEXT (args) = fn;
+ args = TREE_CHAIN (args);
+ }
+ }
+}
- ATTRIBUTES is the set of decl attributes to be applied, if any. */
+/* Fixup the inline methods and friends in TYPE now that TYPE is
+ complete. */
-void
-finish_struct_1 (t)
- tree t;
+static void
+fixup_inline_methods (type)
+ tree type;
{
- tree x;
- int has_virtual;
- int max_has_virtual;
- tree pending_virtuals = NULL_TREE;
- tree pending_hard_virtuals = NULL_TREE;
- int n_fields = 0;
- tree vfield;
- int n_baseclasses;
- int empty = 1;
- tree inline_friends;
+ tree method = TYPE_METHODS (type);
- if (TYPE_SIZE (t))
+ if (method && TREE_CODE (method) == TREE_VEC)
{
- if (IS_AGGR_TYPE (t))
- cp_error ("redefinition of `%#T'", t);
+ if (TREE_VEC_ELT (method, 1))
+ method = TREE_VEC_ELT (method, 1);
+ else if (TREE_VEC_ELT (method, 0))
+ method = TREE_VEC_ELT (method, 0);
else
- my_friendly_abort (172);
- popclass ();
- return;
+ method = TREE_VEC_ELT (method, 2);
}
- GNU_xref_decl (current_function_decl, t);
-
- /* If this type was previously laid out as a forward reference,
- make sure we lay it out again. */
+ /* Do inline member functions. */
+ for (; method; method = TREE_CHAIN (method))
+ fixup_pending_inline (DECL_PENDING_INLINE_INFO (method));
- TYPE_SIZE (t) = NULL_TREE;
- CLASSTYPE_GOT_SEMICOLON (t) = 0;
-
- CLASSTYPE_VFIELD_PARENT (t) = -1;
- has_virtual = 0;
- max_has_virtual = 0;
- CLASSTYPE_RTTI (t) = NULL_TREE;
- n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
+ /* Do friends. */
+ for (method = CLASSTYPE_INLINE_FRIENDS (type);
+ method;
+ method = TREE_CHAIN (method))
+ fixup_pending_inline (DECL_PENDING_INLINE_INFO (TREE_VALUE (method)));
+}
- /* Do end-of-class semantic processing: checking the validity of the
- bases and members and adding implicitly generated methods. */
- check_bases_and_members (t, &empty);
+/* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
+ BINFO_OFFSETs for all of the base-classes. Position the vtable
+ pointer. */
+static void
+layout_class_type (t, empty_p, has_virtual_p, max_has_virtual_p,
+ pending_virtuals_p, pending_hard_virtuals_p)
+ tree t;
+ int *empty_p;
+ int *has_virtual_p;
+ int *max_has_virtual_p;
+ tree *pending_virtuals_p;
+ tree *pending_hard_virtuals_p;
+{
/* Add pointers to all of our virtual base-classes. */
- TYPE_FIELDS (t) = chainon (build_vbase_pointer_fields (t, &empty),
+ TYPE_FIELDS (t) = chainon (build_vbase_pointer_fields (t, empty_p),
TYPE_FIELDS (t));
/* Build FIELD_DECLs for all of the non-virtual base-types. */
- TYPE_FIELDS (t) = chainon (build_base_fields (t, &empty),
+ TYPE_FIELDS (t) = chainon (build_base_fields (t, empty_p),
TYPE_FIELDS (t));
/* Create a pointer to our virtual function table. */
- create_vtable_ptr (t, &empty, &has_virtual, &max_has_virtual,
- &pending_virtuals, &pending_hard_virtuals);
+ create_vtable_ptr (t, empty_p, has_virtual_p, max_has_virtual_p,
+ pending_virtuals_p, pending_hard_virtuals_p);
/* CLASSTYPE_INLINE_FRIENDS is really TYPE_NONCOPIED_PARTS. Thus,
we have to save this before we start modifying
TYPE_NONCOPIED_PARTS. */
- inline_friends = CLASSTYPE_INLINE_FRIENDS (t);
- CLASSTYPE_INLINE_FRIENDS (t) = NULL_TREE;
+ fixup_inline_methods (t);
/* We make all structures have at least one element, so that they
have non-zero size. The field that we add here is fake, in the
sense that, for example, we don't want people to be able to
initialize it later. So, we add it just long enough to let the
back-end lay out the type, and then remove it. */
- if (empty)
+ if (*empty_p)
{
tree decl = build_lang_decl
(FIELD_DECL, NULL_TREE, char_type_node);
/* If we added an extra field to make this class non-empty, remove
it now. */
- if (empty)
+ if (*empty_p)
TYPE_FIELDS (t) = TREE_CHAIN (TYPE_FIELDS (t));
/* Delete all zero-width bit-fields from the list of fields. Now
/* Remember the size and alignment of the class before adding
the virtual bases. */
- if (empty && flag_new_abi)
+ if (*empty_p && flag_new_abi)
CLASSTYPE_SIZE (t) = integer_zero_node;
else if (flag_new_abi && TYPE_HAS_COMPLEX_INIT_REF (t)
&& TYPE_HAS_COMPLEX_ASSIGN_REF (t))
/* Set the TYPE_DECL for this type to contain the right
value for DECL_OFFSET, so that we can use it as part
of a COMPONENT_REF for multiple inheritance. */
-
layout_decl (TYPE_MAIN_DECL (t), 0);
/* Now fix up any virtual base class types that we left lying
around. We must get these done before we try to lay out the
virtual function table. */
-
- if (n_baseclasses)
+ if (CLASSTYPE_N_BASECLASSES (t))
/* layout_basetypes will remove the base subobject fields. */
- max_has_virtual = layout_basetypes (t, max_has_virtual);
+ *max_has_virtual_p = layout_basetypes (t, *max_has_virtual_p);
+}
+
+/* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
+ (or C++ class declaration).
+
+ For C++, we must handle the building of derived classes.
+ Also, C++ allows static class members. The way that this is
+ handled is to keep the field name where it is (as the DECL_NAME
+ of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
+ of the field. layout_record and layout_union will know about this.
+
+ More C++ hair: inline functions have text in their
+ DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
+ meaningful tree structure. After the struct has been laid out, set
+ things up so that this can happen.
+
+ And still more: virtual functions. In the case of single inheritance,
+ when a new virtual function is seen which redefines a virtual function
+ from the base class, the new virtual function is placed into
+ the virtual function table at exactly the same address that
+ it had in the base class. When this is extended to multiple
+ inheritance, the same thing happens, except that multiple virtual
+ function tables must be maintained. The first virtual function
+ table is treated in exactly the same way as in the case of single
+ inheritance. Additional virtual function tables have different
+ DELTAs, which tell how to adjust `this' to point to the right thing.
+
+ ATTRIBUTES is the set of decl attributes to be applied, if any. */
+
+void
+finish_struct_1 (t)
+ tree t;
+{
+ tree x;
+ int has_virtual;
+ int max_has_virtual;
+ tree pending_virtuals = NULL_TREE;
+ tree pending_hard_virtuals = NULL_TREE;
+ int n_fields = 0;
+ tree vfield;
+ int n_baseclasses;
+ int empty = 1;
+
+ if (TYPE_SIZE (t))
+ {
+ if (IS_AGGR_TYPE (t))
+ cp_error ("redefinition of `%#T'", t);
+ else
+ my_friendly_abort (172);
+ popclass ();
+ return;
+ }
+
+ GNU_xref_decl (current_function_decl, t);
+
+ /* If this type was previously laid out as a forward reference,
+ make sure we lay it out again. */
+
+ TYPE_SIZE (t) = NULL_TREE;
+ CLASSTYPE_GOT_SEMICOLON (t) = 0;
+
+ CLASSTYPE_VFIELD_PARENT (t) = -1;
+ has_virtual = 0;
+ max_has_virtual = 0;
+ CLASSTYPE_RTTI (t) = NULL_TREE;
+ n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
+
+ /* Do end-of-class semantic processing: checking the validity of the
+ bases and members and adding implicitly generated methods. */
+ check_bases_and_members (t, &empty);
+
+ /* Layout the class itself. */
+ layout_class_type (t, &empty, &has_virtual, &max_has_virtual,
+ &pending_virtuals, &pending_hard_virtuals);
if (TYPE_USES_VIRTUAL_BASECLASSES (t))
{
}
}
- /* Write out inline function definitions. */
- do_inline_function_hair (t, inline_friends);
-
if (CLASSTYPE_VSIZE (t) != 0)
{
/* In addition to this one, all the other vfields should be listed. */
static int check_btype PROTO((tree));
static void build_mangled_name_for_type PROTO((tree));
static void build_mangled_name_for_type_with_Gcode PROTO((tree, int));
-static void fixup_pending_inline PROTO((struct pending_inline *));
# define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
# define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
value. */
static char digit_buffer[128];
-/* Fixup the inline function given by INFO now that the class is
- complete. */
-
-static void
-fixup_pending_inline (info)
- struct pending_inline *info;
-{
- if (info)
- {
- tree args;
- tree fn = info->fndecl;
-
- args = DECL_ARGUMENTS (fn);
- while (args)
- {
- DECL_CONTEXT (args) = fn;
- args = TREE_CHAIN (args);
- }
- }
-}
-
-/* Move inline function definitions out of structure so that they
- can be processed normally. CNAME is the name of the class
- we are working from, METHOD_LIST is the list of method lists
- of the structure. We delete friend methods here, after
- saving away their inline function definitions (if any). */
-
-void
-do_inline_function_hair (type, friend_list)
- tree type, friend_list;
-{
- tree method = TYPE_METHODS (type);
-
- if (method && TREE_CODE (method) == TREE_VEC)
- {
- if (TREE_VEC_ELT (method, 1))
- method = TREE_VEC_ELT (method, 1);
- else if (TREE_VEC_ELT (method, 0))
- method = TREE_VEC_ELT (method, 0);
- else
- method = TREE_VEC_ELT (method, 2);
- }
-
- /* Do inline member functions. */
- for (; method; method = TREE_CHAIN (method))
- fixup_pending_inline (DECL_PENDING_INLINE_INFO (method));
-
- /* Do friends. */
- for (; friend_list; friend_list = TREE_CHAIN (friend_list))
- fixup_pending_inline (DECL_PENDING_INLINE_INFO (TREE_VALUE (friend_list)));
-}
\f
/* Here is where overload code starts. */
projects / platform / upstream / linaro-gcc.git / commitdiff