diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/cp/class.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/cp/class.c | 8041 |
1 files changed, 0 insertions, 8041 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/cp/class.c b/gcc-4.2.1-5666.3/gcc/cp/class.c deleted file mode 100644 index 82c5b2aa5..000000000 --- a/gcc-4.2.1-5666.3/gcc/cp/class.c +++ /dev/null @@ -1,8041 +0,0 @@ -/* Functions related to building classes and their related objects. - Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. - Contributed by Michael Tiemann (tiemann@cygnus.com) - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to -the Free Software Foundation, 51 Franklin Street, Fifth Floor, -Boston, MA 02110-1301, USA. */ - - -/* High-level class interface. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "tree.h" -#include "cp-tree.h" -#include "flags.h" -#include "rtl.h" -#include "output.h" -#include "toplev.h" -#include "target.h" -#include "convert.h" -/* APPLE LOCAL KEXT */ -#include "tree-iterator.h" -#include "cgraph.h" -#include "tree-dump.h" - -/* The number of nested classes being processed. If we are not in the - scope of any class, this is zero. */ - -int current_class_depth; - -/* In order to deal with nested classes, we keep a stack of classes. - The topmost entry is the innermost class, and is the entry at index - CURRENT_CLASS_DEPTH */ - -typedef struct class_stack_node { - /* The name of the class. */ - tree name; - - /* The _TYPE node for the class. */ - tree type; - - /* The access specifier pending for new declarations in the scope of - this class. */ - tree access; - - /* If were defining TYPE, the names used in this class. */ - splay_tree names_used; - - /* Nonzero if this class is no longer open, because of a call to - push_to_top_level. */ - size_t hidden; -}* class_stack_node_t; - -typedef struct vtbl_init_data_s -{ - /* The base for which we're building initializers. */ - tree binfo; - /* The type of the most-derived type. */ - tree derived; - /* The binfo for the dynamic type. This will be TYPE_BINFO (derived), - unless ctor_vtbl_p is true. */ - tree rtti_binfo; - /* The negative-index vtable initializers built up so far. These - are in order from least negative index to most negative index. */ - tree inits; - /* The last (i.e., most negative) entry in INITS. */ - tree* last_init; - /* The binfo for the virtual base for which we're building - vcall offset initializers. */ - tree vbase; - /* The functions in vbase for which we have already provided vcall - offsets. */ - VEC(tree,gc) *fns; - /* The vtable index of the next vcall or vbase offset. */ - tree index; - /* Nonzero if we are building the initializer for the primary - vtable. */ - int primary_vtbl_p; - /* Nonzero if we are building the initializer for a construction - vtable. */ - int ctor_vtbl_p; - /* True when adding vcall offset entries to the vtable. False when - merely computing the indices. */ - bool generate_vcall_entries; -} vtbl_init_data; - -/* The type of a function passed to walk_subobject_offsets. */ -typedef int (*subobject_offset_fn) (tree, tree, splay_tree); - -/* The stack itself. This is a dynamically resized array. The - number of elements allocated is CURRENT_CLASS_STACK_SIZE. */ -static int current_class_stack_size; -static class_stack_node_t current_class_stack; - -/* The size of the largest empty class seen in this translation unit. */ -static GTY (()) tree sizeof_biggest_empty_class; - -/* An array of all local classes present in this translation unit, in - declaration order. */ -VEC(tree,gc) *local_classes; - -static tree get_vfield_name (tree); -static void finish_struct_anon (tree); -static tree get_vtable_name (tree); -static tree get_basefndecls (tree, tree); -static int build_primary_vtable (tree, tree); -static int build_secondary_vtable (tree); -static void finish_vtbls (tree); -static void modify_vtable_entry (tree, tree, tree, tree, tree *); -static void finish_struct_bits (tree); -static int alter_access (tree, tree, tree); -static void handle_using_decl (tree, tree); -static tree dfs_modify_vtables (tree, void *); -static tree modify_all_vtables (tree, tree); -static void determine_primary_bases (tree); -static void finish_struct_methods (tree); -static void maybe_warn_about_overly_private_class (tree); -static int method_name_cmp (const void *, const void *); -static int resort_method_name_cmp (const void *, const void *); -static void add_implicitly_declared_members (tree, int, int); -static tree fixed_type_or_null (tree, int *, int *); -static tree build_simple_base_path (tree expr, tree binfo); -static tree build_vtbl_ref_1 (tree, tree); -static tree build_vtbl_initializer (tree, tree, tree, tree, int *); -static int count_fields (tree); -static int add_fields_to_record_type (tree, struct sorted_fields_type*, int); -static void check_bitfield_decl (tree); -static void check_field_decl (tree, tree, int *, int *, int *); -static void check_field_decls (tree, tree *, int *, int *); -static tree *build_base_field (record_layout_info, tree, splay_tree, tree *); -static void build_base_fields (record_layout_info, splay_tree, tree *); -static void check_methods (tree); -static void remove_zero_width_bit_fields (tree); -static void check_bases (tree, int *, int *); -static void check_bases_and_members (tree); -static tree create_vtable_ptr (tree, tree *); -static void include_empty_classes (record_layout_info); -static void layout_class_type (tree, tree *); -static void fixup_pending_inline (tree); -static void fixup_inline_methods (tree); -static void propagate_binfo_offsets (tree, tree); -static void layout_virtual_bases (record_layout_info, splay_tree); -static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *); -static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *); -static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *); -static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *); -static void add_vcall_offset (tree, tree, vtbl_init_data *); -static void layout_vtable_decl (tree, int); -static tree dfs_find_final_overrider_pre (tree, void *); -static tree dfs_find_final_overrider_post (tree, void *); -static tree find_final_overrider (tree, tree, tree); -static int make_new_vtable (tree, tree); -static tree get_primary_binfo (tree); -static int maybe_indent_hierarchy (FILE *, int, int); -static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int); -static void dump_class_hierarchy (tree); -static void dump_class_hierarchy_1 (FILE *, int, tree); -static void dump_array (FILE *, tree); -static void dump_vtable (tree, tree, tree); -static void dump_vtt (tree, tree); -static void dump_thunk (FILE *, int, tree); -static tree build_vtable (tree, tree, tree); -static void initialize_vtable (tree, tree); -static void layout_nonempty_base_or_field (record_layout_info, - tree, tree, splay_tree); -static tree end_of_class (tree, int); -static bool layout_empty_base (tree, tree, splay_tree); -static void accumulate_vtbl_inits (tree, tree, tree, tree, tree); -static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree, - tree); -static void build_rtti_vtbl_entries (tree, vtbl_init_data *); -static void build_vcall_and_vbase_vtbl_entries (tree, vtbl_init_data *); -static void clone_constructors_and_destructors (tree); -static tree build_clone (tree, tree); -static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned); -static void build_ctor_vtbl_group (tree, tree); -static void build_vtt (tree); -static tree binfo_ctor_vtable (tree); -static tree *build_vtt_inits (tree, tree, tree *, tree *); -static tree dfs_build_secondary_vptr_vtt_inits (tree, void *); -static tree dfs_fixup_binfo_vtbls (tree, void *); -static int record_subobject_offset (tree, tree, splay_tree); -static int check_subobject_offset (tree, tree, splay_tree); -static int walk_subobject_offsets (tree, subobject_offset_fn, - tree, splay_tree, tree, int); -static void record_subobject_offsets (tree, tree, splay_tree, bool); -static int layout_conflict_p (tree, tree, splay_tree, int); -static int splay_tree_compare_integer_csts (splay_tree_key k1, - splay_tree_key k2); -static void warn_about_ambiguous_bases (tree); -static bool type_requires_array_cookie (tree); -static bool contains_empty_class_p (tree); -static bool base_derived_from (tree, tree); -static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree); -static tree end_of_base (tree); -static tree get_vcall_index (tree, tree); - -/* Variables shared between class.c and call.c. */ - -#ifdef GATHER_STATISTICS -int n_vtables = 0; -int n_vtable_entries = 0; -int n_vtable_searches = 0; -int n_vtable_elems = 0; -int n_convert_harshness = 0; -int n_compute_conversion_costs = 0; -int n_inner_fields_searched = 0; -#endif - -/* Convert to or from a base subobject. EXPR is an expression of type - `A' or `A*', an expression of type `B' or `B*' is returned. To - convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for - the B base instance within A. To convert base A to derived B, CODE - is MINUS_EXPR and BINFO is the binfo for the A instance within B. - In this latter case, A must not be a morally virtual base of B. - NONNULL is true if EXPR is known to be non-NULL (this is only - needed when EXPR is of pointer type). CV qualifiers are preserved - from EXPR. */ - -tree -build_base_path (enum tree_code code, - tree expr, - tree binfo, - int nonnull) -{ - tree v_binfo = NULL_TREE; - tree d_binfo = NULL_TREE; - tree probe; - tree offset; - tree target_type; - tree null_test = NULL; - tree ptr_target_type; - int fixed_type_p; - int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE; - bool has_empty = false; - bool virtual_access; - - if (expr == error_mark_node || binfo == error_mark_node || !binfo) - return error_mark_node; - - for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) - { - d_binfo = probe; - if (is_empty_class (BINFO_TYPE (probe))) - has_empty = true; - if (!v_binfo && BINFO_VIRTUAL_P (probe)) - v_binfo = probe; - } - - probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); - if (want_pointer) - probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe)); - - gcc_assert ((code == MINUS_EXPR - && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), probe)) - || (code == PLUS_EXPR - && SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe))); - - if (binfo == d_binfo) - /* Nothing to do. */ - return expr; - - if (code == MINUS_EXPR && v_binfo) - { - error ("cannot convert from base %qT to derived type %qT via virtual base %qT", - BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo)); - return error_mark_node; - } - - if (!want_pointer) - /* This must happen before the call to save_expr. */ - expr = build_unary_op (ADDR_EXPR, expr, 0); - - offset = BINFO_OFFSET (binfo); - fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull); - target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo); - - /* Do we need to look in the vtable for the real offset? */ - virtual_access = (v_binfo && fixed_type_p <= 0); - - /* Do we need to check for a null pointer? */ - if (want_pointer && !nonnull) - { - /* If we know the conversion will not actually change the value - of EXPR, then we can avoid testing the expression for NULL. - We have to avoid generating a COMPONENT_REF for a base class - field, because other parts of the compiler know that such - expressions are always non-NULL. */ - if (!virtual_access && integer_zerop (offset)) - { - tree class_type; - /* TARGET_TYPE has been extracted from BINFO, and, is - therefore always cv-unqualified. Extract the - cv-qualifiers from EXPR so that the expression returned - matches the input. */ - class_type = TREE_TYPE (TREE_TYPE (expr)); - target_type - = cp_build_qualified_type (target_type, - cp_type_quals (class_type)); - return build_nop (build_pointer_type (target_type), expr); - } - null_test = error_mark_node; - } - - /* Protect against multiple evaluation if necessary. */ - if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access)) - expr = save_expr (expr); - - /* Now that we've saved expr, build the real null test. */ - if (null_test) - { - tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node); - null_test = fold_build2 (NE_EXPR, boolean_type_node, - expr, zero); - } - - /* If this is a simple base reference, express it as a COMPONENT_REF. */ - if (code == PLUS_EXPR && !virtual_access - /* We don't build base fields for empty bases, and they aren't very - interesting to the optimizers anyway. */ - && !has_empty) - { - expr = build_indirect_ref (expr, NULL); - expr = build_simple_base_path (expr, binfo); - if (want_pointer) - expr = build_address (expr); - target_type = TREE_TYPE (expr); - goto out; - } - - if (virtual_access) - { - /* Going via virtual base V_BINFO. We need the static offset - from V_BINFO to BINFO, and the dynamic offset from D_BINFO to - V_BINFO. That offset is an entry in D_BINFO's vtable. */ - tree v_offset; - - if (fixed_type_p < 0 && in_base_initializer) - { - /* In a base member initializer, we cannot rely on the - vtable being set up. We have to indirect via the - vtt_parm. */ - tree t; - - t = TREE_TYPE (TYPE_VFIELD (current_class_type)); - t = build_pointer_type (t); - v_offset = convert (t, current_vtt_parm); - v_offset = build_indirect_ref (v_offset, NULL); - } - else - v_offset = build_vfield_ref (build_indirect_ref (expr, NULL), - TREE_TYPE (TREE_TYPE (expr))); - - v_offset = build2 (PLUS_EXPR, TREE_TYPE (v_offset), - v_offset, BINFO_VPTR_FIELD (v_binfo)); - v_offset = build1 (NOP_EXPR, - build_pointer_type (ptrdiff_type_node), - v_offset); - v_offset = build_indirect_ref (v_offset, NULL); - TREE_CONSTANT (v_offset) = 1; - TREE_INVARIANT (v_offset) = 1; - - offset = convert_to_integer (ptrdiff_type_node, - size_diffop (offset, - BINFO_OFFSET (v_binfo))); - - if (!integer_zerop (offset)) - v_offset = build2 (code, ptrdiff_type_node, v_offset, offset); - - if (fixed_type_p < 0) - /* Negative fixed_type_p means this is a constructor or destructor; - virtual base layout is fixed in in-charge [cd]tors, but not in - base [cd]tors. */ - offset = build3 (COND_EXPR, ptrdiff_type_node, - build2 (EQ_EXPR, boolean_type_node, - current_in_charge_parm, integer_zero_node), - v_offset, - convert_to_integer (ptrdiff_type_node, - BINFO_OFFSET (binfo))); - else - offset = v_offset; - } - - target_type = cp_build_qualified_type - (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr)))); - ptr_target_type = build_pointer_type (target_type); - if (want_pointer) - target_type = ptr_target_type; - - expr = build1 (NOP_EXPR, ptr_target_type, expr); - - if (!integer_zerop (offset)) - expr = build2 (code, ptr_target_type, expr, offset); - else - null_test = NULL; - - if (!want_pointer) - expr = build_indirect_ref (expr, NULL); - - out: - if (null_test) - expr = fold_build3 (COND_EXPR, target_type, null_test, expr, - fold_build1 (NOP_EXPR, target_type, - integer_zero_node)); - - return expr; -} - -/* Subroutine of build_base_path; EXPR and BINFO are as in that function. - Perform a derived-to-base conversion by recursively building up a - sequence of COMPONENT_REFs to the appropriate base fields. */ - -static tree -build_simple_base_path (tree expr, tree binfo) -{ - tree type = BINFO_TYPE (binfo); - tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo); - tree field; - - if (d_binfo == NULL_TREE) - { - tree temp; - - gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type); - - /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' - into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only - an lvalue in the frontend; only _DECLs and _REFs are lvalues - in the backend. */ - temp = unary_complex_lvalue (ADDR_EXPR, expr); - if (temp) - expr = build_indirect_ref (temp, NULL); - - return expr; - } - - /* Recurse. */ - expr = build_simple_base_path (expr, d_binfo); - - for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo)); - field; field = TREE_CHAIN (field)) - /* Is this the base field created by build_base_field? */ - if (TREE_CODE (field) == FIELD_DECL - && DECL_FIELD_IS_BASE (field) - && TREE_TYPE (field) == type) - { - /* We don't use build_class_member_access_expr here, as that - has unnecessary checks, and more importantly results in - recursive calls to dfs_walk_once. */ - int type_quals = cp_type_quals (TREE_TYPE (expr)); - - expr = build3 (COMPONENT_REF, - cp_build_qualified_type (type, type_quals), - expr, field, NULL_TREE); - expr = fold_if_not_in_template (expr); - - /* Mark the expression const or volatile, as appropriate. - Even though we've dealt with the type above, we still have - to mark the expression itself. */ - if (type_quals & TYPE_QUAL_CONST) - TREE_READONLY (expr) = 1; - if (type_quals & TYPE_QUAL_VOLATILE) - TREE_THIS_VOLATILE (expr) = 1; - - return expr; - } - - /* Didn't find the base field?!? */ - gcc_unreachable (); -} - -/* Convert OBJECT to the base TYPE. OBJECT is an expression whose - type is a class type or a pointer to a class type. In the former - case, TYPE is also a class type; in the latter it is another - pointer type. If CHECK_ACCESS is true, an error message is emitted - if TYPE is inaccessible. If OBJECT has pointer type, the value is - assumed to be non-NULL. */ - -tree -convert_to_base (tree object, tree type, bool check_access, bool nonnull) -{ - tree binfo; - tree object_type; - - if (TYPE_PTR_P (TREE_TYPE (object))) - { - object_type = TREE_TYPE (TREE_TYPE (object)); - type = TREE_TYPE (type); - } - else - object_type = TREE_TYPE (object); - - binfo = lookup_base (object_type, type, - check_access ? ba_check : ba_unique, - NULL); - if (!binfo || binfo == error_mark_node) - return error_mark_node; - - return build_base_path (PLUS_EXPR, object, binfo, nonnull); -} - -/* EXPR is an expression with unqualified class type. BASE is a base - binfo of that class type. Returns EXPR, converted to the BASE - type. This function assumes that EXPR is the most derived class; - therefore virtual bases can be found at their static offsets. */ - -tree -convert_to_base_statically (tree expr, tree base) -{ - tree expr_type; - - expr_type = TREE_TYPE (expr); - if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type)) - { - tree pointer_type; - - pointer_type = build_pointer_type (expr_type); - expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1); - if (!integer_zerop (BINFO_OFFSET (base))) - expr = build2 (PLUS_EXPR, pointer_type, expr, - build_nop (pointer_type, BINFO_OFFSET (base))); - expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr); - expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr); - } - - return expr; -} - - -tree -build_vfield_ref (tree datum, tree type) -{ - tree vfield, vcontext; - - if (datum == error_mark_node) - return error_mark_node; - - /* First, convert to the requested type. */ - if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type)) - datum = convert_to_base (datum, type, /*check_access=*/false, - /*nonnull=*/true); - - /* Second, the requested type may not be the owner of its own vptr. - If not, convert to the base class that owns it. We cannot use - convert_to_base here, because VCONTEXT may appear more than once - in the inheritance hierarchy of TYPE, and thus direct conversion - between the types may be ambiguous. Following the path back up - one step at a time via primary bases avoids the problem. */ - vfield = TYPE_VFIELD (type); - vcontext = DECL_CONTEXT (vfield); - while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type)) - { - datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type)); - type = TREE_TYPE (datum); - } - - return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE); -} - -/* Given an object INSTANCE, return an expression which yields the - vtable element corresponding to INDEX. There are many special - cases for INSTANCE which we take care of here, mainly to avoid - creating extra tree nodes when we don't have to. */ - -static tree -build_vtbl_ref_1 (tree instance, tree idx) -{ - tree aref; - tree vtbl = NULL_TREE; - - /* Try to figure out what a reference refers to, and - access its virtual function table directly. */ - - int cdtorp = 0; - tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp); - - tree basetype = non_reference (TREE_TYPE (instance)); - - if (fixed_type && !cdtorp) - { - tree binfo = lookup_base (fixed_type, basetype, - ba_unique | ba_quiet, NULL); - if (binfo) - vtbl = unshare_expr (BINFO_VTABLE (binfo)); - } - - if (!vtbl) - vtbl = build_vfield_ref (instance, basetype); - - assemble_external (vtbl); - - /* APPLE LOCAL begin KEXT double destructor */ -#ifdef ADJUST_VTABLE_INDEX - ADJUST_VTABLE_INDEX (idx, vtbl); -#endif - /* APPLE LOCAL end KEXT double destructor */ - - aref = build_array_ref (vtbl, idx); - TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx); - TREE_INVARIANT (aref) = TREE_CONSTANT (aref); - - return aref; -} - -tree -build_vtbl_ref (tree instance, tree idx) -{ - tree aref = build_vtbl_ref_1 (instance, idx); - - return aref; -} - -/* Given a stable object pointer INSTANCE_PTR, return an expression which - yields a function pointer corresponding to vtable element INDEX. */ - -tree -build_vfn_ref (tree instance_ptr, tree idx) -{ - tree aref; - - aref = build_vtbl_ref_1 (build_indirect_ref (instance_ptr, 0), idx); - - /* When using function descriptors, the address of the - vtable entry is treated as a function pointer. */ - if (TARGET_VTABLE_USES_DESCRIPTORS) - aref = build1 (NOP_EXPR, TREE_TYPE (aref), - build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1)); - - /* Remember this as a method reference, for later devirtualization. */ - aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx); - - return aref; -} - -/* APPLE LOCAL begin KEXT indirect-virtual-calls --sts */ -/* Given a VTBL and an IDX, return an expression for the function - pointer located at the indicated index. BASETYPE is the static - type of the object containing the vtable. */ - -tree -build_vfn_ref_using_vtable (tree vtbl, tree idx) -{ - tree aref; - - vtbl = unshare_expr (vtbl); - assemble_external (vtbl); - - /* APPLE LOCAL KEXT double destructor */ -#ifdef ADJUST_VTABLE_INDEX - ADJUST_VTABLE_INDEX (idx, vtbl); -#endif - - aref = build_array_ref (vtbl, idx); - TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx); - TREE_INVARIANT (aref) = TREE_CONSTANT (aref); - - return aref; -} -/* APPLE LOCAL end KEXT indirect-virtual-calls --sts */ - -/* Return the name of the virtual function table (as an IDENTIFIER_NODE) - for the given TYPE. */ - -static tree -get_vtable_name (tree type) -{ - return mangle_vtbl_for_type (type); -} - -/* DECL is an entity associated with TYPE, like a virtual table or an - implicitly generated constructor. Determine whether or not DECL - should have external or internal linkage at the object file - level. This routine does not deal with COMDAT linkage and other - similar complexities; it simply sets TREE_PUBLIC if it possible for - entities in other translation units to contain copies of DECL, in - the abstract. */ - -void -set_linkage_according_to_type (tree type, tree decl) -{ - /* If TYPE involves a local class in a function with internal - linkage, then DECL should have internal linkage too. Other local - classes have no linkage -- but if their containing functions - have external linkage, it makes sense for DECL to have external - linkage too. That will allow template definitions to be merged, - for example. */ - if (no_linkage_check (type, /*relaxed_p=*/true)) - { - TREE_PUBLIC (decl) = 0; - DECL_INTERFACE_KNOWN (decl) = 1; - } - else - TREE_PUBLIC (decl) = 1; -} - -/* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE. - (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.) - Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */ - -static tree -build_vtable (tree class_type, tree name, tree vtable_type) -{ - tree decl; - - decl = build_lang_decl (VAR_DECL, name, vtable_type); - /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME - now to avoid confusion in mangle_decl. */ - SET_DECL_ASSEMBLER_NAME (decl, name); - DECL_CONTEXT (decl) = class_type; - DECL_ARTIFICIAL (decl) = 1; - TREE_STATIC (decl) = 1; - TREE_READONLY (decl) = 1; - DECL_VIRTUAL_P (decl) = 1; - DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN; - DECL_VTABLE_OR_VTT_P (decl) = 1; - /* At one time the vtable info was grabbed 2 words at a time. This - fails on sparc unless you have 8-byte alignment. (tiemann) */ - DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node), - DECL_ALIGN (decl)); - set_linkage_according_to_type (class_type, decl); - /* The vtable has not been defined -- yet. */ - DECL_EXTERNAL (decl) = 1; - DECL_NOT_REALLY_EXTERN (decl) = 1; - - /* Mark the VAR_DECL node representing the vtable itself as a - "gratuitous" one, thereby forcing dwarfout.c to ignore it. It - is rather important that such things be ignored because any - effort to actually generate DWARF for them will run into - trouble when/if we encounter code like: - - #pragma interface - struct S { virtual void member (); }; - - because the artificial declaration of the vtable itself (as - manufactured by the g++ front end) will say that the vtable is - a static member of `S' but only *after* the debug output for - the definition of `S' has already been output. This causes - grief because the DWARF entry for the definition of the vtable - will try to refer back to an earlier *declaration* of the - vtable as a static member of `S' and there won't be one. We - might be able to arrange to have the "vtable static member" - attached to the member list for `S' before the debug info for - `S' get written (which would solve the problem) but that would - require more intrusive changes to the g++ front end. */ - DECL_IGNORED_P (decl) = 1; - - return decl; -} - -/* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic, - or even complete. If this does not exist, create it. If COMPLETE is - nonzero, then complete the definition of it -- that will render it - impossible to actually build the vtable, but is useful to get at those - which are known to exist in the runtime. */ - -tree -get_vtable_decl (tree type, int complete) -{ - tree decl; - - if (CLASSTYPE_VTABLES (type)) - return CLASSTYPE_VTABLES (type); - - decl = build_vtable (type, get_vtable_name (type), vtbl_type_node); - CLASSTYPE_VTABLES (type) = decl; - - if (complete) - { - DECL_EXTERNAL (decl) = 1; - finish_decl (decl, NULL_TREE, NULL_TREE); - } - - return decl; -} - -/* Build the primary virtual function table for TYPE. If BINFO is - non-NULL, build the vtable starting with the initial approximation - that it is the same as the one which is the head of the association - list. Returns a nonzero value if a new vtable is actually - created. */ - -static int -build_primary_vtable (tree binfo, tree type) -{ - tree decl; - tree virtuals; - - decl = get_vtable_decl (type, /*complete=*/0); - - if (binfo) - { - if (BINFO_NEW_VTABLE_MARKED (binfo)) - /* We have already created a vtable for this base, so there's - no need to do it again. */ - return 0; - - virtuals = copy_list (BINFO_VIRTUALS (binfo)); - TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo)); - DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl)); - DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl)); - } - else - { - gcc_assert (TREE_TYPE (decl) == vtbl_type_node); - virtuals = NULL_TREE; - } - -#ifdef GATHER_STATISTICS - n_vtables += 1; - n_vtable_elems += list_length (virtuals); -#endif - - /* Initialize the association list for this type, based - on our first approximation. */ - BINFO_VTABLE (TYPE_BINFO (type)) = decl; - BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals; - SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type)); - return 1; -} - -/* Give BINFO a new virtual function table which is initialized - with a skeleton-copy of its original initialization. The only - entry that changes is the `delta' entry, so we can really - share a lot of structure. - - FOR_TYPE is the most derived type which caused this table to - be needed. - - Returns nonzero if we haven't met BINFO before. - - The order in which vtables are built (by calling this function) for - an object must remain the same, otherwise a binary incompatibility - can result. */ - -static int -build_secondary_vtable (tree binfo) -{ - if (BINFO_NEW_VTABLE_MARKED (binfo)) - /* We already created a vtable for this base. There's no need to - do it again. */ - return 0; - - /* Remember that we've created a vtable for this BINFO, so that we - don't try to do so again. */ - SET_BINFO_NEW_VTABLE_MARKED (binfo); - - /* Make fresh virtual list, so we can smash it later. */ - BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo)); - - /* Secondary vtables are laid out as part of the same structure as - the primary vtable. */ - BINFO_VTABLE (binfo) = NULL_TREE; - return 1; -} - -/* Create a new vtable for BINFO which is the hierarchy dominated by - T. Return nonzero if we actually created a new vtable. */ - -static int -make_new_vtable (tree t, tree binfo) -{ - if (binfo == TYPE_BINFO (t)) - /* In this case, it is *type*'s vtable we are modifying. We start - with the approximation that its vtable is that of the - immediate base class. */ - return build_primary_vtable (binfo, t); - else - /* This is our very own copy of `basetype' to play with. Later, - we will fill in all the virtual functions that override the - virtual functions in these base classes which are not defined - by the current type. */ - return build_secondary_vtable (binfo); -} - -/* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO - (which is in the hierarchy dominated by T) list FNDECL as its - BV_FN. DELTA is the required constant adjustment from the `this' - pointer where the vtable entry appears to the `this' required when - the function is actually called. */ - -static void -modify_vtable_entry (tree t, - tree binfo, - tree fndecl, - tree delta, - tree *virtuals) -{ - tree v; - - v = *virtuals; - - if (fndecl != BV_FN (v) - || !tree_int_cst_equal (delta, BV_DELTA (v))) - { - /* We need a new vtable for BINFO. */ - if (make_new_vtable (t, binfo)) - { - /* If we really did make a new vtable, we also made a copy - of the BINFO_VIRTUALS list. Now, we have to find the - corresponding entry in that list. */ - *virtuals = BINFO_VIRTUALS (binfo); - while (BV_FN (*virtuals) != BV_FN (v)) - *virtuals = TREE_CHAIN (*virtuals); - v = *virtuals; - } - - BV_DELTA (v) = delta; - BV_VCALL_INDEX (v) = NULL_TREE; - BV_FN (v) = fndecl; - } -} - - -/* Add method METHOD to class TYPE. If USING_DECL is non-null, it is - the USING_DECL naming METHOD. Returns true if the method could be - added to the method vec. */ - -bool -add_method (tree type, tree method, tree using_decl) -{ - unsigned slot; - tree overload; - bool template_conv_p = false; - bool conv_p; - VEC(tree,gc) *method_vec; - bool complete_p; - bool insert_p = false; - tree current_fns; - - if (method == error_mark_node) - return false; - - complete_p = COMPLETE_TYPE_P (type); - conv_p = DECL_CONV_FN_P (method); - if (conv_p) - template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL - && DECL_TEMPLATE_CONV_FN_P (method)); - - method_vec = CLASSTYPE_METHOD_VEC (type); - if (!method_vec) - { - /* Make a new method vector. We start with 8 entries. We must - allocate at least two (for constructors and destructors), and - we're going to end up with an assignment operator at some - point as well. */ - method_vec = VEC_alloc (tree, gc, 8); - /* Create slots for constructors and destructors. */ - VEC_quick_push (tree, method_vec, NULL_TREE); - VEC_quick_push (tree, method_vec, NULL_TREE); - CLASSTYPE_METHOD_VEC (type) = method_vec; - } - - /* Maintain TYPE_HAS_CONSTRUCTOR, etc. */ - grok_special_member_properties (method); - - /* Constructors and destructors go in special slots. */ - if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method)) - slot = CLASSTYPE_CONSTRUCTOR_SLOT; - else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method)) - { - slot = CLASSTYPE_DESTRUCTOR_SLOT; - - if (TYPE_FOR_JAVA (type)) - { - if (!DECL_ARTIFICIAL (method)) - error ("Java class %qT cannot have a destructor", type); - else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) - error ("Java class %qT cannot have an implicit non-trivial " - "destructor", - type); - } - } - else - { - tree m; - - insert_p = true; - /* See if we already have an entry with this name. */ - for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; - VEC_iterate (tree, method_vec, slot, m); - ++slot) - { - m = OVL_CURRENT (m); - if (template_conv_p) - { - if (TREE_CODE (m) == TEMPLATE_DECL - && DECL_TEMPLATE_CONV_FN_P (m)) - insert_p = false; - break; - } - if (conv_p && !DECL_CONV_FN_P (m)) - break; - if (DECL_NAME (m) == DECL_NAME (method)) - { - insert_p = false; - break; - } - if (complete_p - && !DECL_CONV_FN_P (m) - && DECL_NAME (m) > DECL_NAME (method)) - break; - } - } - current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot); - - if (processing_template_decl) - /* TYPE is a template class. Don't issue any errors now; wait - until instantiation time to complain. */ - ; - else - { - tree fns; - - /* Check to see if we've already got this method. */ - for (fns = current_fns; fns; fns = OVL_NEXT (fns)) - { - tree fn = OVL_CURRENT (fns); - tree fn_type; - tree method_type; - tree parms1; - tree parms2; - - if (TREE_CODE (fn) != TREE_CODE (method)) - continue; - - /* [over.load] Member function declarations with the - same name and the same parameter types cannot be - overloaded if any of them is a static member - function declaration. - - [namespace.udecl] When a using-declaration brings names - from a base class into a derived class scope, member - functions in the derived class override and/or hide member - functions with the same name and parameter types in a base - class (rather than conflicting). */ - fn_type = TREE_TYPE (fn); - method_type = TREE_TYPE (method); - parms1 = TYPE_ARG_TYPES (fn_type); - parms2 = TYPE_ARG_TYPES (method_type); - - /* Compare the quals on the 'this' parm. Don't compare - the whole types, as used functions are treated as - coming from the using class in overload resolution. */ - if (! DECL_STATIC_FUNCTION_P (fn) - && ! DECL_STATIC_FUNCTION_P (method) - && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1))) - != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2))))) - continue; - - /* For templates, the return type and template parameters - must be identical. */ - if (TREE_CODE (fn) == TEMPLATE_DECL - && (!same_type_p (TREE_TYPE (fn_type), - TREE_TYPE (method_type)) - || !comp_template_parms (DECL_TEMPLATE_PARMS (fn), - DECL_TEMPLATE_PARMS (method)))) - continue; - - if (! DECL_STATIC_FUNCTION_P (fn)) - parms1 = TREE_CHAIN (parms1); - if (! DECL_STATIC_FUNCTION_P (method)) - parms2 = TREE_CHAIN (parms2); - - if (compparms (parms1, parms2) - && (!DECL_CONV_FN_P (fn) - || same_type_p (TREE_TYPE (fn_type), - TREE_TYPE (method_type)))) - { - if (using_decl) - { - if (DECL_CONTEXT (fn) == type) - /* Defer to the local function. */ - return false; - if (DECL_CONTEXT (fn) == DECL_CONTEXT (method)) - error ("repeated using declaration %q+D", using_decl); - else - error ("using declaration %q+D conflicts with a previous using declaration", - using_decl); - } - else - { - error ("%q+#D cannot be overloaded", method); - error ("with %q+#D", fn); - } - - /* We don't call duplicate_decls here to merge the - declarations because that will confuse things if the - methods have inline definitions. In particular, we - will crash while processing the definitions. */ - return false; - } - } - } - - /* A class should never have more than one destructor. */ - if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method)) - return false; - - /* Add the new binding. */ - overload = build_overload (method, current_fns); - - if (conv_p) - TYPE_HAS_CONVERSION (type) = 1; - else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p) - push_class_level_binding (DECL_NAME (method), overload); - - if (insert_p) - { - bool reallocated; - - /* We only expect to add few methods in the COMPLETE_P case, so - just make room for one more method in that case. */ - if (complete_p) - reallocated = VEC_reserve_exact (tree, gc, method_vec, 1); - else - reallocated = VEC_reserve (tree, gc, method_vec, 1); - if (reallocated) - CLASSTYPE_METHOD_VEC (type) = method_vec; - if (slot == VEC_length (tree, method_vec)) - VEC_quick_push (tree, method_vec, overload); - else - VEC_quick_insert (tree, method_vec, slot, overload); - } - else - /* Replace the current slot. */ - VEC_replace (tree, method_vec, slot, overload); - return true; -} - -/* Subroutines of finish_struct. */ - -/* Change the access of FDECL to ACCESS in T. Return 1 if change was - legit, otherwise return 0. */ - -static int -alter_access (tree t, tree fdecl, tree access) -{ - tree elem; - - if (!DECL_LANG_SPECIFIC (fdecl)) - retrofit_lang_decl (fdecl); - - gcc_assert (!DECL_DISCRIMINATOR_P (fdecl)); - - elem = purpose_member (t, DECL_ACCESS (fdecl)); - if (elem) - { - if (TREE_VALUE (elem) != access) - { - if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL) - error ("conflicting access specifications for method" - " %q+D, ignored", TREE_TYPE (fdecl)); - else - error ("conflicting access specifications for field %qE, ignored", - DECL_NAME (fdecl)); - } - else - { - /* They're changing the access to the same thing they changed - it to before. That's OK. */ - ; - } - } - else - { - perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl); - DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl)); - return 1; - } - return 0; -} - -/* Process the USING_DECL, which is a member of T. */ - -static void -handle_using_decl (tree using_decl, tree t) -{ - tree decl = USING_DECL_DECLS (using_decl); - tree name = DECL_NAME (using_decl); - tree access - = TREE_PRIVATE (using_decl) ? access_private_node - : TREE_PROTECTED (using_decl) ? access_protected_node - : access_public_node; - tree flist = NULL_TREE; - tree old_value; - - gcc_assert (!processing_template_decl && decl); - - old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false); - if (old_value) - { - if (is_overloaded_fn (old_value)) - old_value = OVL_CURRENT (old_value); - - if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t) - /* OK */; - else - old_value = NULL_TREE; - } - - cp_emit_debug_info_for_using (decl, USING_DECL_SCOPE (using_decl)); - - if (is_overloaded_fn (decl)) - flist = decl; - - if (! old_value) - ; - else if (is_overloaded_fn (old_value)) - { - if (flist) - /* It's OK to use functions from a base when there are functions with - the same name already present in the current class. */; - else - { - error ("%q+D invalid in %q#T", using_decl, t); - error (" because of local method %q+#D with same name", - OVL_CURRENT (old_value)); - return; - } - } - else if (!DECL_ARTIFICIAL (old_value)) - { - error ("%q+D invalid in %q#T", using_decl, t); - error (" because of local member %q+#D with same name", old_value); - return; - } - - /* Make type T see field decl FDECL with access ACCESS. */ - if (flist) - for (; flist; flist = OVL_NEXT (flist)) - { - add_method (t, OVL_CURRENT (flist), using_decl); - alter_access (t, OVL_CURRENT (flist), access); - } - else - alter_access (t, decl, access); -} - -/* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P, - and NO_CONST_ASN_REF_P. Also set flag bits in T based on - properties of the bases. */ - -static void -check_bases (tree t, - int* cant_have_const_ctor_p, - int* no_const_asn_ref_p) -{ - int i; - int seen_non_virtual_nearly_empty_base_p; - tree base_binfo; - tree binfo; - - seen_non_virtual_nearly_empty_base_p = 0; - - for (binfo = TYPE_BINFO (t), i = 0; - BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) - { - tree basetype = TREE_TYPE (base_binfo); - - gcc_assert (COMPLETE_TYPE_P (basetype)); - - /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P - here because the case of virtual functions but non-virtual - dtor is handled in finish_struct_1. */ - if (!TYPE_POLYMORPHIC_P (basetype)) - warning (OPT_Weffc__, - "base class %q#T has a non-virtual destructor", basetype); - - /* If the base class doesn't have copy constructors or - assignment operators that take const references, then the - derived class cannot have such a member automatically - generated. */ - if (! TYPE_HAS_CONST_INIT_REF (basetype)) - *cant_have_const_ctor_p = 1; - if (TYPE_HAS_ASSIGN_REF (basetype) - && !TYPE_HAS_CONST_ASSIGN_REF (basetype)) - *no_const_asn_ref_p = 1; - - if (BINFO_VIRTUAL_P (base_binfo)) - /* A virtual base does not effect nearly emptiness. */ - ; - else if (CLASSTYPE_NEARLY_EMPTY_P (basetype)) - { - if (seen_non_virtual_nearly_empty_base_p) - /* And if there is more than one nearly empty base, then the - derived class is not nearly empty either. */ - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - else - /* Remember we've seen one. */ - seen_non_virtual_nearly_empty_base_p = 1; - } - else if (!is_empty_class (basetype)) - /* If the base class is not empty or nearly empty, then this - class cannot be nearly empty. */ - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - - /* A lot of properties from the bases also apply to the derived - class. */ - TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype); - TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) - |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype); - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - if (CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (basetype) - || CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (basetype)) - CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (t) = 1; - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - - TYPE_HAS_COMPLEX_ASSIGN_REF (t) - |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype); - TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype); - TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype); - CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) - |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype); - } -} - -/* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for - those that are primaries. Sets BINFO_LOST_PRIMARY_P for those - that have had a nearly-empty virtual primary base stolen by some - other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for - T. */ - -static void -determine_primary_bases (tree t) -{ - unsigned i; - tree primary = NULL_TREE; - tree type_binfo = TYPE_BINFO (t); - tree base_binfo; - - /* Determine the primary bases of our bases. */ - for (base_binfo = TREE_CHAIN (type_binfo); base_binfo; - base_binfo = TREE_CHAIN (base_binfo)) - { - tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo)); - - /* See if we're the non-virtual primary of our inheritance - chain. */ - if (!BINFO_VIRTUAL_P (base_binfo)) - { - tree parent = BINFO_INHERITANCE_CHAIN (base_binfo); - tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent)); - - if (parent_primary - && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), - BINFO_TYPE (parent_primary))) - /* We are the primary binfo. */ - BINFO_PRIMARY_P (base_binfo) = 1; - } - /* Determine if we have a virtual primary base, and mark it so. - */ - if (primary && BINFO_VIRTUAL_P (primary)) - { - tree this_primary = copied_binfo (primary, base_binfo); - - if (BINFO_PRIMARY_P (this_primary)) - /* Someone already claimed this base. */ - BINFO_LOST_PRIMARY_P (base_binfo) = 1; - else - { - tree delta; - - BINFO_PRIMARY_P (this_primary) = 1; - BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo; - - /* A virtual binfo might have been copied from within - another hierarchy. As we're about to use it as a - primary base, make sure the offsets match. */ - delta = size_diffop (convert (ssizetype, - BINFO_OFFSET (base_binfo)), - convert (ssizetype, - BINFO_OFFSET (this_primary))); - - propagate_binfo_offsets (this_primary, delta); - } - } - } - - /* First look for a dynamic direct non-virtual base. */ - for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++) - { - tree basetype = BINFO_TYPE (base_binfo); - - if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo)) - { - primary = base_binfo; - goto found; - } - } - - /* A "nearly-empty" virtual base class can be the primary base - class, if no non-virtual polymorphic base can be found. Look for - a nearly-empty virtual dynamic base that is not already a primary - base of something in the hierarchy. If there is no such base, - just pick the first nearly-empty virtual base. */ - - for (base_binfo = TREE_CHAIN (type_binfo); base_binfo; - base_binfo = TREE_CHAIN (base_binfo)) - if (BINFO_VIRTUAL_P (base_binfo) - && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo))) - { - if (!BINFO_PRIMARY_P (base_binfo)) - { - /* Found one that is not primary. */ - primary = base_binfo; - goto found; - } - else if (!primary) - /* Remember the first candidate. */ - primary = base_binfo; - } - - found: - /* If we've got a primary base, use it. */ - if (primary) - { - tree basetype = BINFO_TYPE (primary); - - CLASSTYPE_PRIMARY_BINFO (t) = primary; - if (BINFO_PRIMARY_P (primary)) - /* We are stealing a primary base. */ - BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1; - BINFO_PRIMARY_P (primary) = 1; - if (BINFO_VIRTUAL_P (primary)) - { - tree delta; - - BINFO_INHERITANCE_CHAIN (primary) = type_binfo; - /* A virtual binfo might have been copied from within - another hierarchy. As we're about to use it as a primary - base, make sure the offsets match. */ - delta = size_diffop (ssize_int (0), - convert (ssizetype, BINFO_OFFSET (primary))); - - propagate_binfo_offsets (primary, delta); - } - - primary = TYPE_BINFO (basetype); - - TYPE_VFIELD (t) = TYPE_VFIELD (basetype); - BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary); - BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary); - } -} - -/* Set memoizing fields and bits of T (and its variants) for later - use. */ - -static void -finish_struct_bits (tree t) -{ - tree variants; - - /* Fix up variants (if any). */ - for (variants = TYPE_NEXT_VARIANT (t); - variants; - variants = TYPE_NEXT_VARIANT (variants)) - { - /* These fields are in the _TYPE part of the node, not in - the TYPE_LANG_SPECIFIC component, so they are not shared. */ - TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t); - TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t); - TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants) - = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t); - - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (variants) = - CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (t); - CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (variants) = - CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (t); - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - - TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t); - - TYPE_BINFO (variants) = TYPE_BINFO (t); - - /* Copy whatever these are holding today. */ - TYPE_VFIELD (variants) = TYPE_VFIELD (t); - TYPE_METHODS (variants) = TYPE_METHODS (t); - TYPE_FIELDS (variants) = TYPE_FIELDS (t); - } - - if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t)) - /* For a class w/o baseclasses, 'finish_struct' has set - CLASSTYPE_PURE_VIRTUALS correctly (by definition). - Similarly for a class whose base classes do not have vtables. - When neither of these is true, we might have removed abstract - virtuals (by providing a definition), added some (by declaring - new ones), or redeclared ones from a base class. We need to - recalculate what's really an abstract virtual at this point (by - looking in the vtables). */ - get_pure_virtuals (t); - - /* If this type has a copy constructor or a destructor, force its - mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be - nonzero. This will cause it to be passed by invisible reference - and prevent it from being returned in a register. */ - if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) - { - tree variants; - DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode; - for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants)) - { - TYPE_MODE (variants) = BLKmode; - TREE_ADDRESSABLE (variants) = 1; - } - } -} - -/* Issue warnings about T having private constructors, but no friends, - and so forth. - - HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or - static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any - non-private static member functions. */ - -static void -maybe_warn_about_overly_private_class (tree t) -{ - int has_member_fn = 0; - int has_nonprivate_method = 0; - tree fn; - - if (!warn_ctor_dtor_privacy - /* If the class has friends, those entities might create and - access instances, so we should not warn. */ - || (CLASSTYPE_FRIEND_CLASSES (t) - || DECL_FRIENDLIST (TYPE_MAIN_DECL (t))) - /* We will have warned when the template was declared; there's - no need to warn on every instantiation. */ - || CLASSTYPE_TEMPLATE_INSTANTIATION (t)) - /* There's no reason to even consider warning about this - class. */ - return; - - /* We only issue one warning, if more than one applies, because - otherwise, on code like: - - class A { - // Oops - forgot `public:' - A(); - A(const A&); - ~A(); - }; - - we warn several times about essentially the same problem. */ - - /* Check to see if all (non-constructor, non-destructor) member - functions are private. (Since there are no friends or - non-private statics, we can't ever call any of the private member - functions.) */ - for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn)) - /* We're not interested in compiler-generated methods; they don't - provide any way to call private members. */ - if (!DECL_ARTIFICIAL (fn)) - { - if (!TREE_PRIVATE (fn)) - { - if (DECL_STATIC_FUNCTION_P (fn)) - /* A non-private static member function is just like a - friend; it can create and invoke private member - functions, and be accessed without a class - instance. */ - return; - - has_nonprivate_method = 1; - /* Keep searching for a static member function. */ - } - else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn)) - has_member_fn = 1; - } - - if (!has_nonprivate_method && has_member_fn) - { - /* There are no non-private methods, and there's at least one - private member function that isn't a constructor or - destructor. (If all the private members are - constructors/destructors we want to use the code below that - issues error messages specifically referring to - constructors/destructors.) */ - unsigned i; - tree binfo = TYPE_BINFO (t); - - for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++) - if (BINFO_BASE_ACCESS (binfo, i) != access_private_node) - { - has_nonprivate_method = 1; - break; - } - if (!has_nonprivate_method) - { - warning (OPT_Wctor_dtor_privacy, - "all member functions in class %qT are private", t); - return; - } - } - - /* Even if some of the member functions are non-private, the class - won't be useful for much if all the constructors or destructors - are private: such an object can never be created or destroyed. */ - fn = CLASSTYPE_DESTRUCTORS (t); - if (fn && TREE_PRIVATE (fn)) - { - warning (OPT_Wctor_dtor_privacy, - "%q#T only defines a private destructor and has no friends", - t); - return; - } - - if (TYPE_HAS_CONSTRUCTOR (t) - /* Implicitly generated constructors are always public. */ - && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t) - || !CLASSTYPE_LAZY_COPY_CTOR (t))) - { - int nonprivate_ctor = 0; - - /* If a non-template class does not define a copy - constructor, one is defined for it, enabling it to avoid - this warning. For a template class, this does not - happen, and so we would normally get a warning on: - - template <class T> class C { private: C(); }; - - To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All - complete non-template or fully instantiated classes have this - flag set. */ - if (!TYPE_HAS_INIT_REF (t)) - nonprivate_ctor = 1; - else - for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn)) - { - tree ctor = OVL_CURRENT (fn); - /* Ideally, we wouldn't count copy constructors (or, in - fact, any constructor that takes an argument of the - class type as a parameter) because such things cannot - be used to construct an instance of the class unless - you already have one. But, for now at least, we're - more generous. */ - if (! TREE_PRIVATE (ctor)) - { - nonprivate_ctor = 1; - break; - } - } - - if (nonprivate_ctor == 0) - { - warning (OPT_Wctor_dtor_privacy, - "%q#T only defines private constructors and has no friends", - t); - return; - } - } -} - -static struct { - gt_pointer_operator new_value; - void *cookie; -} resort_data; - -/* Comparison function to compare two TYPE_METHOD_VEC entries by name. */ - -static int -method_name_cmp (const void* m1_p, const void* m2_p) -{ - const tree *const m1 = (const tree *) m1_p; - const tree *const m2 = (const tree *) m2_p; - - if (*m1 == NULL_TREE && *m2 == NULL_TREE) - return 0; - if (*m1 == NULL_TREE) - return -1; - if (*m2 == NULL_TREE) - return 1; - if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2))) - return -1; - return 1; -} - -/* This routine compares two fields like method_name_cmp but using the - pointer operator in resort_field_decl_data. */ - -static int -resort_method_name_cmp (const void* m1_p, const void* m2_p) -{ - const tree *const m1 = (const tree *) m1_p; - const tree *const m2 = (const tree *) m2_p; - if (*m1 == NULL_TREE && *m2 == NULL_TREE) - return 0; - if (*m1 == NULL_TREE) - return -1; - if (*m2 == NULL_TREE) - return 1; - { - tree d1 = DECL_NAME (OVL_CURRENT (*m1)); - tree d2 = DECL_NAME (OVL_CURRENT (*m2)); - resort_data.new_value (&d1, resort_data.cookie); - resort_data.new_value (&d2, resort_data.cookie); - if (d1 < d2) - return -1; - } - return 1; -} - -/* Resort TYPE_METHOD_VEC because pointers have been reordered. */ - -void -resort_type_method_vec (void* obj, - void* orig_obj ATTRIBUTE_UNUSED , - gt_pointer_operator new_value, - void* cookie) -{ - VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj; - int len = VEC_length (tree, method_vec); - size_t slot; - tree fn; - - /* The type conversion ops have to live at the front of the vec, so we - can't sort them. */ - for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; - VEC_iterate (tree, method_vec, slot, fn); - ++slot) - if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) - break; - - if (len - slot > 1) - { - resort_data.new_value = new_value; - resort_data.cookie = cookie; - qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree), - resort_method_name_cmp); - } -} - -/* Warn about duplicate methods in fn_fields. - - Sort methods that are not special (i.e., constructors, destructors, - and type conversion operators) so that we can find them faster in - search. */ - -static void -finish_struct_methods (tree t) -{ - tree fn_fields; - VEC(tree,gc) *method_vec; - int slot, len; - - method_vec = CLASSTYPE_METHOD_VEC (t); - if (!method_vec) - return; - - len = VEC_length (tree, method_vec); - - /* Clear DECL_IN_AGGR_P for all functions. */ - for (fn_fields = TYPE_METHODS (t); fn_fields; - fn_fields = TREE_CHAIN (fn_fields)) - DECL_IN_AGGR_P (fn_fields) = 0; - - /* Issue warnings about private constructors and such. If there are - no methods, then some public defaults are generated. */ - maybe_warn_about_overly_private_class (t); - - /* The type conversion ops have to live at the front of the vec, so we - can't sort them. */ - for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; - VEC_iterate (tree, method_vec, slot, fn_fields); - ++slot) - if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields))) - break; - if (len - slot > 1) - qsort (VEC_address (tree, method_vec) + slot, - len-slot, sizeof (tree), method_name_cmp); -} - -/* Make BINFO's vtable have N entries, including RTTI entries, - vbase and vcall offsets, etc. Set its type and call the backend - to lay it out. */ - -static void -layout_vtable_decl (tree binfo, int n) -{ - tree atype; - tree vtable; - /* APPLE LOCAL begin KEXT terminated-vtables */ - int n_entries = n; - - /* Enlarge suggested vtable size by one entry; it will be filled - with a zero word. Darwin kernel dynamic-driver loader looks - for this value to find vtable ends for patching. */ - if (TARGET_KEXTABI) - n_entries += 1; - /* APPLE LOCAL end KEXT terminated-vtables */ - - atype = build_cplus_array_type (vtable_entry_type, - /* APPLE LOCAL KEXT terminated-vtables */ - build_index_type (size_int (n_entries - 1))); - layout_type (atype); - - /* We may have to grow the vtable. */ - vtable = get_vtbl_decl_for_binfo (binfo); - if (!same_type_p (TREE_TYPE (vtable), atype)) - { - TREE_TYPE (vtable) = atype; - DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE; - layout_decl (vtable, 0); - } -} - -/* True iff FNDECL and BASE_FNDECL (both non-static member functions) - have the same signature. */ - -int -same_signature_p (tree fndecl, tree base_fndecl) -{ - /* One destructor overrides another if they are the same kind of - destructor. */ - if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl) - && special_function_p (base_fndecl) == special_function_p (fndecl)) - return 1; - /* But a non-destructor never overrides a destructor, nor vice - versa, nor do different kinds of destructors override - one-another. For example, a complete object destructor does not - override a deleting destructor. */ - if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl)) - return 0; - - if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl) - || (DECL_CONV_FN_P (fndecl) - && DECL_CONV_FN_P (base_fndecl) - && same_type_p (DECL_CONV_FN_TYPE (fndecl), - DECL_CONV_FN_TYPE (base_fndecl)))) - { - tree types, base_types; - types = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); - base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl)); - if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types))) - == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types)))) - && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types))) - return 1; - } - return 0; -} - -/* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a - subobject. */ - -static bool -base_derived_from (tree derived, tree base) -{ - tree probe; - - for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) - { - if (probe == derived) - return true; - else if (BINFO_VIRTUAL_P (probe)) - /* If we meet a virtual base, we can't follow the inheritance - any more. See if the complete type of DERIVED contains - such a virtual base. */ - return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived)) - != NULL_TREE); - } - return false; -} - -typedef struct find_final_overrider_data_s { - /* The function for which we are trying to find a final overrider. */ - tree fn; - /* The base class in which the function was declared. */ - tree declaring_base; - /* The candidate overriders. */ - tree candidates; - /* Path to most derived. */ - VEC(tree,heap) *path; -} find_final_overrider_data; - -/* Add the overrider along the current path to FFOD->CANDIDATES. - Returns true if an overrider was found; false otherwise. */ - -static bool -dfs_find_final_overrider_1 (tree binfo, - find_final_overrider_data *ffod, - unsigned depth) -{ - tree method; - - /* If BINFO is not the most derived type, try a more derived class. - A definition there will overrider a definition here. */ - if (depth) - { - depth--; - if (dfs_find_final_overrider_1 - (VEC_index (tree, ffod->path, depth), ffod, depth)) - return true; - } - - method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn); - if (method) - { - tree *candidate = &ffod->candidates; - - /* Remove any candidates overridden by this new function. */ - while (*candidate) - { - /* If *CANDIDATE overrides METHOD, then METHOD - cannot override anything else on the list. */ - if (base_derived_from (TREE_VALUE (*candidate), binfo)) - return true; - /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */ - if (base_derived_from (binfo, TREE_VALUE (*candidate))) - *candidate = TREE_CHAIN (*candidate); - else - candidate = &TREE_CHAIN (*candidate); - } - - /* Add the new function. */ - ffod->candidates = tree_cons (method, binfo, ffod->candidates); - return true; - } - - return false; -} - -/* Called from find_final_overrider via dfs_walk. */ - -static tree -dfs_find_final_overrider_pre (tree binfo, void *data) -{ - find_final_overrider_data *ffod = (find_final_overrider_data *) data; - - if (binfo == ffod->declaring_base) - dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path)); - VEC_safe_push (tree, heap, ffod->path, binfo); - - return NULL_TREE; -} - -static tree -dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data) -{ - find_final_overrider_data *ffod = (find_final_overrider_data *) data; - VEC_pop (tree, ffod->path); - - return NULL_TREE; -} - -/* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for - FN and whose TREE_VALUE is the binfo for the base where the - overriding occurs. BINFO (in the hierarchy dominated by the binfo - DERIVED) is the base object in which FN is declared. */ - -static tree -find_final_overrider (tree derived, tree binfo, tree fn) -{ - find_final_overrider_data ffod; - - /* Getting this right is a little tricky. This is valid: - - struct S { virtual void f (); }; - struct T { virtual void f (); }; - struct U : public S, public T { }; - - even though calling `f' in `U' is ambiguous. But, - - struct R { virtual void f(); }; - struct S : virtual public R { virtual void f (); }; - struct T : virtual public R { virtual void f (); }; - struct U : public S, public T { }; - - is not -- there's no way to decide whether to put `S::f' or - `T::f' in the vtable for `R'. - - The solution is to look at all paths to BINFO. If we find - different overriders along any two, then there is a problem. */ - if (DECL_THUNK_P (fn)) - fn = THUNK_TARGET (fn); - - /* Determine the depth of the hierarchy. */ - ffod.fn = fn; - ffod.declaring_base = binfo; - ffod.candidates = NULL_TREE; - ffod.path = VEC_alloc (tree, heap, 30); - - dfs_walk_all (derived, dfs_find_final_overrider_pre, - dfs_find_final_overrider_post, &ffod); - - VEC_free (tree, heap, ffod.path); - - /* If there was no winner, issue an error message. */ - if (!ffod.candidates || TREE_CHAIN (ffod.candidates)) - return error_mark_node; - - return ffod.candidates; -} - -/* Return the index of the vcall offset for FN when TYPE is used as a - virtual base. */ - -static tree -get_vcall_index (tree fn, tree type) -{ - VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type); - tree_pair_p p; - unsigned ix; - - for (ix = 0; VEC_iterate (tree_pair_s, indices, ix, p); ix++) - if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose)) - || same_signature_p (fn, p->purpose)) - return p->value; - - /* There should always be an appropriate index. */ - gcc_unreachable (); -} - -/* Update an entry in the vtable for BINFO, which is in the hierarchy - dominated by T. FN has been overridden in BINFO; VIRTUALS points to the - corresponding position in the BINFO_VIRTUALS list. */ - -static void -update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals, - unsigned ix) -{ - tree b; - tree overrider; - tree delta; - tree virtual_base; - tree first_defn; - tree overrider_fn, overrider_target; - tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn; - tree over_return, base_return; - bool lost = false; - - /* Find the nearest primary base (possibly binfo itself) which defines - this function; this is the class the caller will convert to when - calling FN through BINFO. */ - for (b = binfo; ; b = get_primary_binfo (b)) - { - gcc_assert (b); - if (look_for_overrides_here (BINFO_TYPE (b), target_fn)) - break; - - /* The nearest definition is from a lost primary. */ - if (BINFO_LOST_PRIMARY_P (b)) - lost = true; - } - first_defn = b; - - /* Find the final overrider. */ - overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn); - if (overrider == error_mark_node) - { - error ("no unique final overrider for %qD in %qT", target_fn, t); - return; - } - overrider_target = overrider_fn = TREE_PURPOSE (overrider); - - /* Check for adjusting covariant return types. */ - over_return = TREE_TYPE (TREE_TYPE (overrider_target)); - base_return = TREE_TYPE (TREE_TYPE (target_fn)); - - if (POINTER_TYPE_P (over_return) - && TREE_CODE (over_return) == TREE_CODE (base_return) - && CLASS_TYPE_P (TREE_TYPE (over_return)) - && CLASS_TYPE_P (TREE_TYPE (base_return)) - /* If the overrider is invalid, don't even try. */ - && !DECL_INVALID_OVERRIDER_P (overrider_target)) - { - /* If FN is a covariant thunk, we must figure out the adjustment - to the final base FN was converting to. As OVERRIDER_TARGET might - also be converting to the return type of FN, we have to - combine the two conversions here. */ - tree fixed_offset, virtual_offset; - - over_return = TREE_TYPE (over_return); - base_return = TREE_TYPE (base_return); - - if (DECL_THUNK_P (fn)) - { - gcc_assert (DECL_RESULT_THUNK_P (fn)); - fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn)); - virtual_offset = THUNK_VIRTUAL_OFFSET (fn); - } - else - fixed_offset = virtual_offset = NULL_TREE; - - if (virtual_offset) - /* Find the equivalent binfo within the return type of the - overriding function. We will want the vbase offset from - there. */ - virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset), - over_return); - else if (!same_type_ignoring_top_level_qualifiers_p - (over_return, base_return)) - { - /* There was no existing virtual thunk (which takes - precedence). So find the binfo of the base function's - return type within the overriding function's return type. - We cannot call lookup base here, because we're inside a - dfs_walk, and will therefore clobber the BINFO_MARKED - flags. Fortunately we know the covariancy is valid (it - has already been checked), so we can just iterate along - the binfos, which have been chained in inheritance graph - order. Of course it is lame that we have to repeat the - search here anyway -- we should really be caching pieces - of the vtable and avoiding this repeated work. */ - tree thunk_binfo, base_binfo; - - /* Find the base binfo within the overriding function's - return type. We will always find a thunk_binfo, except - when the covariancy is invalid (which we will have - already diagnosed). */ - for (base_binfo = TYPE_BINFO (base_return), - thunk_binfo = TYPE_BINFO (over_return); - thunk_binfo; - thunk_binfo = TREE_CHAIN (thunk_binfo)) - if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo), - BINFO_TYPE (base_binfo))) - break; - - /* See if virtual inheritance is involved. */ - for (virtual_offset = thunk_binfo; - virtual_offset; - virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset)) - if (BINFO_VIRTUAL_P (virtual_offset)) - break; - - if (virtual_offset - || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo))) - { - tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo)); - - if (virtual_offset) - { - /* We convert via virtual base. Adjust the fixed - offset to be from there. */ - offset = size_diffop - (offset, convert - (ssizetype, BINFO_OFFSET (virtual_offset))); - } - if (fixed_offset) - /* There was an existing fixed offset, this must be - from the base just converted to, and the base the - FN was thunking to. */ - fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset); - else - fixed_offset = offset; - } - } - - if (fixed_offset || virtual_offset) - /* Replace the overriding function with a covariant thunk. We - will emit the overriding function in its own slot as - well. */ - overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0, - fixed_offset, virtual_offset); - } - else - gcc_assert (!DECL_THUNK_P (fn)); - - /* Assume that we will produce a thunk that convert all the way to - the final overrider, and not to an intermediate virtual base. */ - virtual_base = NULL_TREE; - - /* See if we can convert to an intermediate virtual base first, and then - use the vcall offset located there to finish the conversion. */ - for (; b; b = BINFO_INHERITANCE_CHAIN (b)) - { - /* If we find the final overrider, then we can stop - walking. */ - if (SAME_BINFO_TYPE_P (BINFO_TYPE (b), - BINFO_TYPE (TREE_VALUE (overrider)))) - break; - - /* If we find a virtual base, and we haven't yet found the - overrider, then there is a virtual base between the - declaring base (first_defn) and the final overrider. */ - if (BINFO_VIRTUAL_P (b)) - { - virtual_base = b; - break; - } - } - - if (overrider_fn != overrider_target && !virtual_base) - { - /* The ABI specifies that a covariant thunk includes a mangling - for a this pointer adjustment. This-adjusting thunks that - override a function from a virtual base have a vcall - adjustment. When the virtual base in question is a primary - virtual base, we know the adjustments are zero, (and in the - non-covariant case, we would not use the thunk). - Unfortunately we didn't notice this could happen, when - designing the ABI and so never mandated that such a covariant - thunk should be emitted. Because we must use the ABI mandated - name, we must continue searching from the binfo where we - found the most recent definition of the function, towards the - primary binfo which first introduced the function into the - vtable. If that enters a virtual base, we must use a vcall - this-adjusting thunk. Bleah! */ - tree probe = first_defn; - - while ((probe = get_primary_binfo (probe)) - && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix) - if (BINFO_VIRTUAL_P (probe)) - virtual_base = probe; - - if (virtual_base) - /* Even if we find a virtual base, the correct delta is - between the overrider and the binfo we're building a vtable - for. */ - goto virtual_covariant; - } - - /* Compute the constant adjustment to the `this' pointer. The - `this' pointer, when this function is called, will point at BINFO - (or one of its primary bases, which are at the same offset). */ - if (virtual_base) - /* The `this' pointer needs to be adjusted from the declaration to - the nearest virtual base. */ - delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)), - convert (ssizetype, BINFO_OFFSET (first_defn))); - else if (lost) - /* If the nearest definition is in a lost primary, we don't need an - entry in our vtable. Except possibly in a constructor vtable, - if we happen to get our primary back. In that case, the offset - will be zero, as it will be a primary base. */ - delta = size_zero_node; - else - /* The `this' pointer needs to be adjusted from pointing to - BINFO to pointing at the base where the final overrider - appears. */ - virtual_covariant: - delta = size_diffop (convert (ssizetype, - BINFO_OFFSET (TREE_VALUE (overrider))), - convert (ssizetype, BINFO_OFFSET (binfo))); - - modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals); - - if (virtual_base) - BV_VCALL_INDEX (*virtuals) - = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base)); - else - BV_VCALL_INDEX (*virtuals) = NULL_TREE; -} - -/* Called from modify_all_vtables via dfs_walk. */ - -static tree -dfs_modify_vtables (tree binfo, void* data) -{ - tree t = (tree) data; - tree virtuals; - tree old_virtuals; - unsigned ix; - - if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) - /* A base without a vtable needs no modification, and its bases - are uninteresting. */ - return dfs_skip_bases; - - if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t) - && !CLASSTYPE_HAS_PRIMARY_BASE_P (t)) - /* Don't do the primary vtable, if it's new. */ - return NULL_TREE; - - if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo)) - /* There's no need to modify the vtable for a non-virtual primary - base; we're not going to use that vtable anyhow. We do still - need to do this for virtual primary bases, as they could become - non-primary in a construction vtable. */ - return NULL_TREE; - - make_new_vtable (t, binfo); - - /* Now, go through each of the virtual functions in the virtual - function table for BINFO. Find the final overrider, and update - the BINFO_VIRTUALS list appropriately. */ - for (ix = 0, virtuals = BINFO_VIRTUALS (binfo), - old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo))); - virtuals; - ix++, virtuals = TREE_CHAIN (virtuals), - old_virtuals = TREE_CHAIN (old_virtuals)) - update_vtable_entry_for_fn (t, - binfo, - BV_FN (old_virtuals), - &virtuals, ix); - - return NULL_TREE; -} - -/* Update all of the primary and secondary vtables for T. Create new - vtables as required, and initialize their RTTI information. Each - of the functions in VIRTUALS is declared in T and may override a - virtual function from a base class; find and modify the appropriate - entries to point to the overriding functions. Returns a list, in - declaration order, of the virtual functions that are declared in T, - but do not appear in the primary base class vtable, and which - should therefore be appended to the end of the vtable for T. */ - -static tree -modify_all_vtables (tree t, tree virtuals) -{ - tree binfo = TYPE_BINFO (t); - tree *fnsp; - - /* Update all of the vtables. */ - dfs_walk_once (binfo, dfs_modify_vtables, NULL, t); - - /* Add virtual functions not already in our primary vtable. These - will be both those introduced by this class, and those overridden - from secondary bases. It does not include virtuals merely - inherited from secondary bases. */ - for (fnsp = &virtuals; *fnsp; ) - { - tree fn = TREE_VALUE (*fnsp); - - if (!value_member (fn, BINFO_VIRTUALS (binfo)) - || DECL_VINDEX (fn) == error_mark_node) - { - /* We don't need to adjust the `this' pointer when - calling this function. */ - BV_DELTA (*fnsp) = integer_zero_node; - BV_VCALL_INDEX (*fnsp) = NULL_TREE; - - /* This is a function not already in our vtable. Keep it. */ - fnsp = &TREE_CHAIN (*fnsp); - } - else - /* We've already got an entry for this function. Skip it. */ - *fnsp = TREE_CHAIN (*fnsp); - } - - return virtuals; -} - -/* Get the base virtual function declarations in T that have the - indicated NAME. */ - -static tree -get_basefndecls (tree name, tree t) -{ - tree methods; - tree base_fndecls = NULL_TREE; - int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t)); - int i; - - /* Find virtual functions in T with the indicated NAME. */ - i = lookup_fnfields_1 (t, name); - if (i != -1) - for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i); - methods; - methods = OVL_NEXT (methods)) - { - tree method = OVL_CURRENT (methods); - - if (TREE_CODE (method) == FUNCTION_DECL - && DECL_VINDEX (method)) - base_fndecls = tree_cons (NULL_TREE, method, base_fndecls); - } - - if (base_fndecls) - return base_fndecls; - - for (i = 0; i < n_baseclasses; i++) - { - tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i)); - base_fndecls = chainon (get_basefndecls (name, basetype), - base_fndecls); - } - - return base_fndecls; -} - -/* If this declaration supersedes the declaration of - a method declared virtual in the base class, then - mark this field as being virtual as well. */ - -void -check_for_override (tree decl, tree ctype) -{ - if (TREE_CODE (decl) == TEMPLATE_DECL) - /* In [temp.mem] we have: - - A specialization of a member function template does not - override a virtual function from a base class. */ - return; - if ((DECL_DESTRUCTOR_P (decl) - || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) - || DECL_CONV_FN_P (decl)) - && look_for_overrides (ctype, decl) - && !DECL_STATIC_FUNCTION_P (decl)) - /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor - the error_mark_node so that we know it is an overriding - function. */ - DECL_VINDEX (decl) = decl; - - if (DECL_VIRTUAL_P (decl)) - { - if (!DECL_VINDEX (decl)) - DECL_VINDEX (decl) = error_mark_node; - IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1; - if (DECL_DLLIMPORT_P (decl)) - { - /* When we handled the dllimport attribute we may not have known - that this function is virtual We can't use dllimport - semantics for a virtual method because we need to initialize - the vtable entry with a constant address. */ - DECL_DLLIMPORT_P (decl) = 0; - DECL_ATTRIBUTES (decl) - = remove_attribute ("dllimport", DECL_ATTRIBUTES (decl)); - } - } -} - -/* Warn about hidden virtual functions that are not overridden in t. - We know that constructors and destructors don't apply. */ - -static void -warn_hidden (tree t) -{ - VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t); - tree fns; - size_t i; - - /* We go through each separately named virtual function. */ - for (i = CLASSTYPE_FIRST_CONVERSION_SLOT; - VEC_iterate (tree, method_vec, i, fns); - ++i) - { - tree fn; - tree name; - tree fndecl; - tree base_fndecls; - tree base_binfo; - tree binfo; - int j; - - /* All functions in this slot in the CLASSTYPE_METHOD_VEC will - have the same name. Figure out what name that is. */ - name = DECL_NAME (OVL_CURRENT (fns)); - /* There are no possibly hidden functions yet. */ - base_fndecls = NULL_TREE; - /* Iterate through all of the base classes looking for possibly - hidden functions. */ - for (binfo = TYPE_BINFO (t), j = 0; - BINFO_BASE_ITERATE (binfo, j, base_binfo); j++) - { - tree basetype = BINFO_TYPE (base_binfo); - base_fndecls = chainon (get_basefndecls (name, basetype), - base_fndecls); - } - - /* If there are no functions to hide, continue. */ - if (!base_fndecls) - continue; - - /* Remove any overridden functions. */ - for (fn = fns; fn; fn = OVL_NEXT (fn)) - { - fndecl = OVL_CURRENT (fn); - if (DECL_VINDEX (fndecl)) - { - tree *prev = &base_fndecls; - - while (*prev) - /* If the method from the base class has the same - signature as the method from the derived class, it - has been overridden. */ - if (same_signature_p (fndecl, TREE_VALUE (*prev))) - *prev = TREE_CHAIN (*prev); - else - prev = &TREE_CHAIN (*prev); - } - } - - /* Now give a warning for all base functions without overriders, - as they are hidden. */ - while (base_fndecls) - { - /* Here we know it is a hider, and no overrider exists. */ - warning (0, "%q+D was hidden", TREE_VALUE (base_fndecls)); - warning (0, " by %q+D", fns); - base_fndecls = TREE_CHAIN (base_fndecls); - } - } -} - -/* Check for things that are invalid. There are probably plenty of other - things we should check for also. */ - -static void -finish_struct_anon (tree t) -{ - tree field; - - for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) - { - if (TREE_STATIC (field)) - continue; - if (TREE_CODE (field) != FIELD_DECL) - continue; - - if (DECL_NAME (field) == NULL_TREE - && ANON_AGGR_TYPE_P (TREE_TYPE (field))) - { - tree elt = TYPE_FIELDS (TREE_TYPE (field)); - for (; elt; elt = TREE_CHAIN (elt)) - { - /* We're generally only interested in entities the user - declared, but we also find nested classes by noticing - the TYPE_DECL that we create implicitly. You're - allowed to put one anonymous union inside another, - though, so we explicitly tolerate that. We use - TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that - we also allow unnamed types used for defining fields. */ - if (DECL_ARTIFICIAL (elt) - && (!DECL_IMPLICIT_TYPEDEF_P (elt) - || TYPE_ANONYMOUS_P (TREE_TYPE (elt)))) - continue; - - if (TREE_CODE (elt) != FIELD_DECL) - { - pedwarn ("%q+#D invalid; an anonymous union can " - "only have non-static data members", elt); - continue; - } - - if (TREE_PRIVATE (elt)) - pedwarn ("private member %q+#D in anonymous union", elt); - else if (TREE_PROTECTED (elt)) - pedwarn ("protected member %q+#D in anonymous union", elt); - - TREE_PRIVATE (elt) = TREE_PRIVATE (field); - TREE_PROTECTED (elt) = TREE_PROTECTED (field); - } - } - } -} - -/* Add T to CLASSTYPE_DECL_LIST of current_class_type which - will be used later during class template instantiation. - When FRIEND_P is zero, T can be a static member data (VAR_DECL), - a non-static member data (FIELD_DECL), a member function - (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE), - a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL) - When FRIEND_P is nonzero, T is either a friend class - (RECORD_TYPE, TEMPLATE_DECL) or a friend function - (FUNCTION_DECL, TEMPLATE_DECL). */ - -void -maybe_add_class_template_decl_list (tree type, tree t, int friend_p) -{ - /* Save some memory by not creating TREE_LIST if TYPE is not template. */ - if (CLASSTYPE_TEMPLATE_INFO (type)) - CLASSTYPE_DECL_LIST (type) - = tree_cons (friend_p ? NULL_TREE : type, - t, CLASSTYPE_DECL_LIST (type)); -} - -/* Create default constructors, assignment operators, and so forth for - the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR, - and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, - the class cannot have a default constructor, copy constructor - taking a const reference argument, or an assignment operator taking - a const reference, respectively. */ - -static void -add_implicitly_declared_members (tree t, - int cant_have_const_cctor, - int cant_have_const_assignment) -{ - /* Destructor. */ - if (!CLASSTYPE_DESTRUCTORS (t)) - { - /* In general, we create destructors lazily. */ - CLASSTYPE_LAZY_DESTRUCTOR (t) = 1; - /* However, if the implicit destructor is non-trivial - destructor, we sometimes have to create it at this point. */ - if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) - { - bool lazy_p = true; - - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - /* Since this is an empty destructor, it can only be nontrivial - because one of its base classes has a destructor that must be - called. */ - CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (t) = 1; - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - - if (TYPE_FOR_JAVA (t)) - /* If this a Java class, any non-trivial destructor is - invalid, even if compiler-generated. Therefore, if the - destructor is non-trivial we create it now. */ - lazy_p = false; - else - { - tree binfo; - tree base_binfo; - int ix; - - /* If the implicit destructor will be virtual, then we must - generate it now because (unfortunately) we do not - generate virtual tables lazily. */ - binfo = TYPE_BINFO (t); - for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) - { - tree base_type; - tree dtor; - - base_type = BINFO_TYPE (base_binfo); - dtor = CLASSTYPE_DESTRUCTORS (base_type); - if (dtor && DECL_VIRTUAL_P (dtor)) - { - lazy_p = false; - break; - } - } - } - - /* If we can't get away with being lazy, generate the destructor - now. */ - if (!lazy_p) - lazily_declare_fn (sfk_destructor, t); - } - } - - /* Default constructor. */ - if (! TYPE_HAS_CONSTRUCTOR (t)) - { - TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1; - CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1; - } - - /* Copy constructor. */ - if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t)) - { - TYPE_HAS_INIT_REF (t) = 1; - TYPE_HAS_CONST_INIT_REF (t) = !cant_have_const_cctor; - CLASSTYPE_LAZY_COPY_CTOR (t) = 1; - TYPE_HAS_CONSTRUCTOR (t) = 1; - } - - /* If there is no assignment operator, one will be created if and - when it is needed. For now, just record whether or not the type - of the parameter to the assignment operator will be a const or - non-const reference. */ - if (!TYPE_HAS_ASSIGN_REF (t) && !TYPE_FOR_JAVA (t)) - { - TYPE_HAS_ASSIGN_REF (t) = 1; - TYPE_HAS_CONST_ASSIGN_REF (t) = !cant_have_const_assignment; - CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 1; - } -} - -/* Subroutine of finish_struct_1. Recursively count the number of fields - in TYPE, including anonymous union members. */ - -static int -count_fields (tree fields) -{ - tree x; - int n_fields = 0; - for (x = fields; x; x = TREE_CHAIN (x)) - { - if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) - n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x))); - else - n_fields += 1; - } - return n_fields; -} - -/* Subroutine of finish_struct_1. Recursively add all the fields in the - TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */ - -static int -add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx) -{ - tree x; - for (x = fields; x; x = TREE_CHAIN (x)) - { - if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) - idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx); - else - field_vec->elts[idx++] = x; - } - return idx; -} - -/* FIELD is a bit-field. We are finishing the processing for its - enclosing type. Issue any appropriate messages and set appropriate - flags. */ - -static void -check_bitfield_decl (tree field) -{ - tree type = TREE_TYPE (field); - tree w; - - /* Extract the declared width of the bitfield, which has been - temporarily stashed in DECL_INITIAL. */ - w = DECL_INITIAL (field); - gcc_assert (w != NULL_TREE); - /* Remove the bit-field width indicator so that the rest of the - compiler does not treat that value as an initializer. */ - DECL_INITIAL (field) = NULL_TREE; - - /* Detect invalid bit-field type. */ - if (!INTEGRAL_TYPE_P (type)) - { - error ("bit-field %q+#D with non-integral type", field); - TREE_TYPE (field) = error_mark_node; - w = error_mark_node; - } - else - { - /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */ - STRIP_NOPS (w); - - /* detect invalid field size. */ - w = integral_constant_value (w); - - if (TREE_CODE (w) != INTEGER_CST) - { - error ("bit-field %q+D width not an integer constant", field); - w = error_mark_node; - } - else if (tree_int_cst_sgn (w) < 0) - { - error ("negative width in bit-field %q+D", field); - w = error_mark_node; - } - else if (integer_zerop (w) && DECL_NAME (field) != 0) - { - error ("zero width for bit-field %q+D", field); - w = error_mark_node; - } - else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0 - && TREE_CODE (type) != ENUMERAL_TYPE - && TREE_CODE (type) != BOOLEAN_TYPE) - warning (0, "width of %q+D exceeds its type", field); - else if (TREE_CODE (type) == ENUMERAL_TYPE - && (0 > compare_tree_int (w, - min_precision (TYPE_MIN_VALUE (type), - TYPE_UNSIGNED (type))) - || 0 > compare_tree_int (w, - min_precision - (TYPE_MAX_VALUE (type), - TYPE_UNSIGNED (type))))) - warning (0, "%q+D is too small to hold all values of %q#T", field, type); - } - - if (w != error_mark_node) - { - DECL_SIZE (field) = convert (bitsizetype, w); - DECL_BIT_FIELD (field) = 1; - } - else - { - /* Non-bit-fields are aligned for their type. */ - DECL_BIT_FIELD (field) = 0; - CLEAR_DECL_C_BIT_FIELD (field); - } -} - -/* FIELD is a non bit-field. We are finishing the processing for its - enclosing type T. Issue any appropriate messages and set appropriate - flags. */ - -static void -check_field_decl (tree field, - tree t, - int* cant_have_const_ctor, - int* no_const_asn_ref, - int* any_default_members) -{ - tree type = strip_array_types (TREE_TYPE (field)); - - /* An anonymous union cannot contain any fields which would change - the settings of CANT_HAVE_CONST_CTOR and friends. */ - if (ANON_UNION_TYPE_P (type)) - ; - /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous - structs. So, we recurse through their fields here. */ - else if (ANON_AGGR_TYPE_P (type)) - { - tree fields; - - for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields)) - if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field)) - check_field_decl (fields, t, cant_have_const_ctor, - no_const_asn_ref, any_default_members); - } - /* Check members with class type for constructors, destructors, - etc. */ - else if (CLASS_TYPE_P (type)) - { - /* Never let anything with uninheritable virtuals - make it through without complaint. */ - abstract_virtuals_error (field, type); - - if (TREE_CODE (t) == UNION_TYPE) - { - if (TYPE_NEEDS_CONSTRUCTING (type)) - error ("member %q+#D with constructor not allowed in union", - field); - if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) - error ("member %q+#D with destructor not allowed in union", field); - if (TYPE_HAS_COMPLEX_ASSIGN_REF (type)) - error ("member %q+#D with copy assignment operator not allowed in union", - field); - } - else - { - TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type); - TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) - |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type); - TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type); - TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type); - } - - if (!TYPE_HAS_CONST_INIT_REF (type)) - *cant_have_const_ctor = 1; - - if (!TYPE_HAS_CONST_ASSIGN_REF (type)) - *no_const_asn_ref = 1; - } - if (DECL_INITIAL (field) != NULL_TREE) - { - /* `build_class_init_list' does not recognize - non-FIELD_DECLs. */ - if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0) - error ("multiple fields in union %qT initialized", t); - *any_default_members = 1; - } -} - -/* Check the data members (both static and non-static), class-scoped - typedefs, etc., appearing in the declaration of T. Issue - appropriate diagnostics. Sets ACCESS_DECLS to a list (in - declaration order) of access declarations; each TREE_VALUE in this - list is a USING_DECL. - - In addition, set the following flags: - - EMPTY_P - The class is empty, i.e., contains no non-static data members. - - CANT_HAVE_CONST_CTOR_P - This class cannot have an implicitly generated copy constructor - taking a const reference. - - CANT_HAVE_CONST_ASN_REF - This class cannot have an implicitly generated assignment - operator taking a const reference. - - All of these flags should be initialized before calling this - function. - - Returns a pointer to the end of the TYPE_FIELDs chain; additional - fields can be added by adding to this chain. */ - -static void -check_field_decls (tree t, tree *access_decls, - int *cant_have_const_ctor_p, - int *no_const_asn_ref_p) -{ - tree *field; - tree *next; - bool has_pointers; - int any_default_members; - int cant_pack = 0; - - /* Assume there are no access declarations. */ - *access_decls = NULL_TREE; - /* Assume this class has no pointer members. */ - has_pointers = false; - /* Assume none of the members of this class have default - initializations. */ - any_default_members = 0; - - for (field = &TYPE_FIELDS (t); *field; field = next) - { - tree x = *field; - tree type = TREE_TYPE (x); - - next = &TREE_CHAIN (x); - - if (TREE_CODE (x) == USING_DECL) - { - /* Prune the access declaration from the list of fields. */ - *field = TREE_CHAIN (x); - - /* Save the access declarations for our caller. */ - *access_decls = tree_cons (NULL_TREE, x, *access_decls); - - /* Since we've reset *FIELD there's no reason to skip to the - next field. */ - next = field; - continue; - } - - if (TREE_CODE (x) == TYPE_DECL - || TREE_CODE (x) == TEMPLATE_DECL) - continue; - - /* If we've gotten this far, it's a data member, possibly static, - or an enumerator. */ - DECL_CONTEXT (x) = t; - - /* When this goes into scope, it will be a non-local reference. */ - DECL_NONLOCAL (x) = 1; - - if (TREE_CODE (t) == UNION_TYPE) - { - /* [class.union] - - If a union contains a static data member, or a member of - reference type, the program is ill-formed. */ - if (TREE_CODE (x) == VAR_DECL) - { - error ("%q+D may not be static because it is a member of a union", x); - continue; - } - if (TREE_CODE (type) == REFERENCE_TYPE) - { - error ("%q+D may not have reference type %qT because" - " it is a member of a union", - x, type); - continue; - } - } - - /* Perform error checking that did not get done in - grokdeclarator. */ - if (TREE_CODE (type) == FUNCTION_TYPE) - { - error ("field %q+D invalidly declared function type", x); - type = build_pointer_type (type); - TREE_TYPE (x) = type; - } - else if (TREE_CODE (type) == METHOD_TYPE) - { - error ("field %q+D invalidly declared method type", x); - type = build_pointer_type (type); - TREE_TYPE (x) = type; - } - - if (type == error_mark_node) - continue; - - if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL) - continue; - - /* Now it can only be a FIELD_DECL. */ - - if (TREE_PRIVATE (x) || TREE_PROTECTED (x)) - CLASSTYPE_NON_AGGREGATE (t) = 1; - - /* If this is of reference type, check if it needs an init. - Also do a little ANSI jig if necessary. */ - if (TREE_CODE (type) == REFERENCE_TYPE) - { - CLASSTYPE_NON_POD_P (t) = 1; - if (DECL_INITIAL (x) == NULL_TREE) - SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); - - /* ARM $12.6.2: [A member initializer list] (or, for an - aggregate, initialization by a brace-enclosed list) is the - only way to initialize nonstatic const and reference - members. */ - TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1; - - if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t) - && extra_warnings) - warning (OPT_Wextra, "non-static reference %q+#D in class without a constructor", x); - } - - type = strip_array_types (type); - - if (TYPE_PACKED (t)) - { - if (!pod_type_p (type) && !TYPE_PACKED (type)) - { - warning - (0, - "ignoring packed attribute because of unpacked non-POD field %q+#D", - x); - cant_pack = 1; - } - else if (TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT) - DECL_PACKED (x) = 1; - } - - if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x))) - /* We don't treat zero-width bitfields as making a class - non-empty. */ - ; - else - { - /* The class is non-empty. */ - CLASSTYPE_EMPTY_P (t) = 0; - /* The class is not even nearly empty. */ - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - /* If one of the data members contains an empty class, - so does T. */ - if (CLASS_TYPE_P (type) - && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type)) - CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; - } - - /* This is used by -Weffc++ (see below). Warn only for pointers - to members which might hold dynamic memory. So do not warn - for pointers to functions or pointers to members. */ - if (TYPE_PTR_P (type) - && !TYPE_PTRFN_P (type) - && !TYPE_PTR_TO_MEMBER_P (type)) - has_pointers = true; - - if (CLASS_TYPE_P (type)) - { - if (CLASSTYPE_REF_FIELDS_NEED_INIT (type)) - SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); - if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)) - SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); - } - - if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type)) - CLASSTYPE_HAS_MUTABLE (t) = 1; - - if (! pod_type_p (type)) - /* DR 148 now allows pointers to members (which are POD themselves), - to be allowed in POD structs. */ - CLASSTYPE_NON_POD_P (t) = 1; - - if (! zero_init_p (type)) - CLASSTYPE_NON_ZERO_INIT_P (t) = 1; - - /* If any field is const, the structure type is pseudo-const. */ - if (CP_TYPE_CONST_P (type)) - { - C_TYPE_FIELDS_READONLY (t) = 1; - if (DECL_INITIAL (x) == NULL_TREE) - SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); - - /* ARM $12.6.2: [A member initializer list] (or, for an - aggregate, initialization by a brace-enclosed list) is the - only way to initialize nonstatic const and reference - members. */ - TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1; - - if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t) - && extra_warnings) - warning (OPT_Wextra, "non-static const member %q+#D in class without a constructor", x); - } - /* A field that is pseudo-const makes the structure likewise. */ - else if (CLASS_TYPE_P (type)) - { - C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type); - SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, - CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) - | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)); - } - - /* Core issue 80: A nonstatic data member is required to have a - different name from the class iff the class has a - user-defined constructor. */ - if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t)) - pedwarn ("field %q+#D with same name as class", x); - - /* We set DECL_C_BIT_FIELD in grokbitfield. - If the type and width are valid, we'll also set DECL_BIT_FIELD. */ - if (DECL_C_BIT_FIELD (x)) - check_bitfield_decl (x); - else - check_field_decl (x, t, - cant_have_const_ctor_p, - no_const_asn_ref_p, - &any_default_members); - } - - /* Effective C++ rule 11: if a class has dynamic memory held by pointers, - it should also define a copy constructor and an assignment operator to - implement the correct copy semantic (deep vs shallow, etc.). As it is - not feasible to check whether the constructors do allocate dynamic memory - and store it within members, we approximate the warning like this: - - -- Warn only if there are members which are pointers - -- Warn only if there is a non-trivial constructor (otherwise, - there cannot be memory allocated). - -- Warn only if there is a non-trivial destructor. We assume that the - user at least implemented the cleanup correctly, and a destructor - is needed to free dynamic memory. - - This seems enough for practical purposes. */ - if (warn_ecpp - && has_pointers - && TYPE_HAS_CONSTRUCTOR (t) - && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) - && !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t))) - { - warning (OPT_Weffc__, "%q#T has pointer data members", t); - - if (! TYPE_HAS_INIT_REF (t)) - { - warning (OPT_Weffc__, - " but does not override %<%T(const %T&)%>", t, t); - if (!TYPE_HAS_ASSIGN_REF (t)) - warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t); - } - else if (! TYPE_HAS_ASSIGN_REF (t)) - warning (OPT_Weffc__, - " but does not override %<operator=(const %T&)%>", t); - } - - /* If any of the fields couldn't be packed, unset TYPE_PACKED. */ - if (cant_pack) - TYPE_PACKED (t) = 0; - - /* Check anonymous struct/anonymous union fields. */ - finish_struct_anon (t); - - /* We've built up the list of access declarations in reverse order. - Fix that now. */ - *access_decls = nreverse (*access_decls); -} - -/* If TYPE is an empty class type, records its OFFSET in the table of - OFFSETS. */ - -static int -record_subobject_offset (tree type, tree offset, splay_tree offsets) -{ - splay_tree_node n; - - if (!is_empty_class (type)) - return 0; - - /* Record the location of this empty object in OFFSETS. */ - n = splay_tree_lookup (offsets, (splay_tree_key) offset); - if (!n) - n = splay_tree_insert (offsets, - (splay_tree_key) offset, - (splay_tree_value) NULL_TREE); - n->value = ((splay_tree_value) - tree_cons (NULL_TREE, - type, - (tree) n->value)); - - return 0; -} - -/* Returns nonzero if TYPE is an empty class type and there is - already an entry in OFFSETS for the same TYPE as the same OFFSET. */ - -static int -check_subobject_offset (tree type, tree offset, splay_tree offsets) -{ - splay_tree_node n; - tree t; - - if (!is_empty_class (type)) - return 0; - - /* Record the location of this empty object in OFFSETS. */ - n = splay_tree_lookup (offsets, (splay_tree_key) offset); - if (!n) - return 0; - - for (t = (tree) n->value; t; t = TREE_CHAIN (t)) - if (same_type_p (TREE_VALUE (t), type)) - return 1; - - return 0; -} - -/* Walk through all the subobjects of TYPE (located at OFFSET). Call - F for every subobject, passing it the type, offset, and table of - OFFSETS. If VBASES_P is one, then virtual non-primary bases should - be traversed. - - If MAX_OFFSET is non-NULL, then subobjects with an offset greater - than MAX_OFFSET will not be walked. - - If F returns a nonzero value, the traversal ceases, and that value - is returned. Otherwise, returns zero. */ - -static int -walk_subobject_offsets (tree type, - subobject_offset_fn f, - tree offset, - splay_tree offsets, - tree max_offset, - int vbases_p) -{ - int r = 0; - tree type_binfo = NULL_TREE; - - /* If this OFFSET is bigger than the MAX_OFFSET, then we should - stop. */ - if (max_offset && INT_CST_LT (max_offset, offset)) - return 0; - - if (type == error_mark_node) - return 0; - - if (!TYPE_P (type)) - { - if (abi_version_at_least (2)) - type_binfo = type; - type = BINFO_TYPE (type); - } - - if (CLASS_TYPE_P (type)) - { - tree field; - tree binfo; - int i; - - /* Avoid recursing into objects that are not interesting. */ - if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type)) - return 0; - - /* Record the location of TYPE. */ - r = (*f) (type, offset, offsets); - if (r) - return r; - - /* Iterate through the direct base classes of TYPE. */ - if (!type_binfo) - type_binfo = TYPE_BINFO (type); - for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++) - { - tree binfo_offset; - - if (abi_version_at_least (2) - && BINFO_VIRTUAL_P (binfo)) - continue; - - if (!vbases_p - && BINFO_VIRTUAL_P (binfo) - && !BINFO_PRIMARY_P (binfo)) - continue; - - if (!abi_version_at_least (2)) - binfo_offset = size_binop (PLUS_EXPR, - offset, - BINFO_OFFSET (binfo)); - else - { - tree orig_binfo; - /* We cannot rely on BINFO_OFFSET being set for the base - class yet, but the offsets for direct non-virtual - bases can be calculated by going back to the TYPE. */ - orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i); - binfo_offset = size_binop (PLUS_EXPR, - offset, - BINFO_OFFSET (orig_binfo)); - } - - r = walk_subobject_offsets (binfo, - f, - binfo_offset, - offsets, - max_offset, - (abi_version_at_least (2) - ? /*vbases_p=*/0 : vbases_p)); - if (r) - return r; - } - - if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type)) - { - unsigned ix; - VEC(tree,gc) *vbases; - - /* Iterate through the virtual base classes of TYPE. In G++ - 3.2, we included virtual bases in the direct base class - loop above, which results in incorrect results; the - correct offsets for virtual bases are only known when - working with the most derived type. */ - if (vbases_p) - for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0; - VEC_iterate (tree, vbases, ix, binfo); ix++) - { - r = walk_subobject_offsets (binfo, - f, - size_binop (PLUS_EXPR, - offset, - BINFO_OFFSET (binfo)), - offsets, - max_offset, - /*vbases_p=*/0); - if (r) - return r; - } - else - { - /* We still have to walk the primary base, if it is - virtual. (If it is non-virtual, then it was walked - above.) */ - tree vbase = get_primary_binfo (type_binfo); - - if (vbase && BINFO_VIRTUAL_P (vbase) - && BINFO_PRIMARY_P (vbase) - && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo) - { - r = (walk_subobject_offsets - (vbase, f, offset, - offsets, max_offset, /*vbases_p=*/0)); - if (r) - return r; - } - } - } - - /* Iterate through the fields of TYPE. */ - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) - if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field)) - { - tree field_offset; - - if (abi_version_at_least (2)) - field_offset = byte_position (field); - else - /* In G++ 3.2, DECL_FIELD_OFFSET was used. */ - field_offset = DECL_FIELD_OFFSET (field); - - r = walk_subobject_offsets (TREE_TYPE (field), - f, - size_binop (PLUS_EXPR, - offset, - field_offset), - offsets, - max_offset, - /*vbases_p=*/1); - if (r) - return r; - } - } - else if (TREE_CODE (type) == ARRAY_TYPE) - { - tree element_type = strip_array_types (type); - tree domain = TYPE_DOMAIN (type); - tree index; - - /* Avoid recursing into objects that are not interesting. */ - if (!CLASS_TYPE_P (element_type) - || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type)) - return 0; - - /* Step through each of the elements in the array. */ - for (index = size_zero_node; - /* G++ 3.2 had an off-by-one error here. */ - (abi_version_at_least (2) - ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index) - : INT_CST_LT (index, TYPE_MAX_VALUE (domain))); - index = size_binop (PLUS_EXPR, index, size_one_node)) - { - r = walk_subobject_offsets (TREE_TYPE (type), - f, - offset, - offsets, - max_offset, - /*vbases_p=*/1); - if (r) - return r; - offset = size_binop (PLUS_EXPR, offset, - TYPE_SIZE_UNIT (TREE_TYPE (type))); - /* If this new OFFSET is bigger than the MAX_OFFSET, then - there's no point in iterating through the remaining - elements of the array. */ - if (max_offset && INT_CST_LT (max_offset, offset)) - break; - } - } - - return 0; -} - -/* Record all of the empty subobjects of TYPE (either a type or a - binfo). If IS_DATA_MEMBER is true, then a non-static data member - is being placed at OFFSET; otherwise, it is a base class that is - being placed at OFFSET. */ - -static void -record_subobject_offsets (tree type, - tree offset, - splay_tree offsets, - bool is_data_member) -{ - tree max_offset; - /* If recording subobjects for a non-static data member or a - non-empty base class , we do not need to record offsets beyond - the size of the biggest empty class. Additional data members - will go at the end of the class. Additional base classes will go - either at offset zero (if empty, in which case they cannot - overlap with offsets past the size of the biggest empty class) or - at the end of the class. - - However, if we are placing an empty base class, then we must record - all offsets, as either the empty class is at offset zero (where - other empty classes might later be placed) or at the end of the - class (where other objects might then be placed, so other empty - subobjects might later overlap). */ - if (is_data_member - || !is_empty_class (BINFO_TYPE (type))) - max_offset = sizeof_biggest_empty_class; - else - max_offset = NULL_TREE; - walk_subobject_offsets (type, record_subobject_offset, offset, - offsets, max_offset, is_data_member); -} - -/* Returns nonzero if any of the empty subobjects of TYPE (located at - OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero, - virtual bases of TYPE are examined. */ - -static int -layout_conflict_p (tree type, - tree offset, - splay_tree offsets, - int vbases_p) -{ - splay_tree_node max_node; - - /* Get the node in OFFSETS that indicates the maximum offset where - an empty subobject is located. */ - max_node = splay_tree_max (offsets); - /* If there aren't any empty subobjects, then there's no point in - performing this check. */ - if (!max_node) - return 0; - - return walk_subobject_offsets (type, check_subobject_offset, offset, - offsets, (tree) (max_node->key), - vbases_p); -} - -/* DECL is a FIELD_DECL corresponding either to a base subobject of a - non-static data member of the type indicated by RLI. BINFO is the - binfo corresponding to the base subobject, OFFSETS maps offsets to - types already located at those offsets. This function determines - the position of the DECL. */ - -static void -layout_nonempty_base_or_field (record_layout_info rli, - tree decl, - tree binfo, - splay_tree offsets) -{ - tree offset = NULL_TREE; - bool field_p; - tree type; - - if (binfo) - { - /* For the purposes of determining layout conflicts, we want to - use the class type of BINFO; TREE_TYPE (DECL) will be the - CLASSTYPE_AS_BASE version, which does not contain entries for - zero-sized bases. */ - type = TREE_TYPE (binfo); - field_p = false; - } - else - { - type = TREE_TYPE (decl); - field_p = true; - } - - /* Try to place the field. It may take more than one try if we have - a hard time placing the field without putting two objects of the - same type at the same address. */ - while (1) - { - struct record_layout_info_s old_rli = *rli; - - /* Place this field. */ - place_field (rli, decl); - offset = byte_position (decl); - - /* We have to check to see whether or not there is already - something of the same type at the offset we're about to use. - For example, consider: - - struct S {}; - struct T : public S { int i; }; - struct U : public S, public T {}; - - Here, we put S at offset zero in U. Then, we can't put T at - offset zero -- its S component would be at the same address - as the S we already allocated. So, we have to skip ahead. - Since all data members, including those whose type is an - empty class, have nonzero size, any overlap can happen only - with a direct or indirect base-class -- it can't happen with - a data member. */ - /* In a union, overlap is permitted; all members are placed at - offset zero. */ - if (TREE_CODE (rli->t) == UNION_TYPE) - break; - /* G++ 3.2 did not check for overlaps when placing a non-empty - virtual base. */ - if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo)) - break; - if (layout_conflict_p (field_p ? type : binfo, offset, - offsets, field_p)) - { - /* Strip off the size allocated to this field. That puts us - at the first place we could have put the field with - proper alignment. */ - *rli = old_rli; - - /* Bump up by the alignment required for the type. */ - rli->bitpos - = size_binop (PLUS_EXPR, rli->bitpos, - bitsize_int (binfo - ? CLASSTYPE_ALIGN (type) - : TYPE_ALIGN (type))); - normalize_rli (rli); - } - else - /* There was no conflict. We're done laying out this field. */ - break; - } - - /* Now that we know where it will be placed, update its - BINFO_OFFSET. */ - if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo))) - /* Indirect virtual bases may have a nonzero BINFO_OFFSET at - this point because their BINFO_OFFSET is copied from another - hierarchy. Therefore, we may not need to add the entire - OFFSET. */ - propagate_binfo_offsets (binfo, - size_diffop (convert (ssizetype, offset), - convert (ssizetype, - BINFO_OFFSET (binfo)))); -} - -/* Returns true if TYPE is empty and OFFSET is nonzero. */ - -static int -empty_base_at_nonzero_offset_p (tree type, - tree offset, - splay_tree offsets ATTRIBUTE_UNUSED) -{ - return is_empty_class (type) && !integer_zerop (offset); -} - -/* Layout the empty base BINFO. EOC indicates the byte currently just - past the end of the class, and should be correctly aligned for a - class of the type indicated by BINFO; OFFSETS gives the offsets of - the empty bases allocated so far. T is the most derived - type. Return nonzero iff we added it at the end. */ - -static bool -layout_empty_base (tree binfo, tree eoc, splay_tree offsets) -{ - tree alignment; - tree basetype = BINFO_TYPE (binfo); - bool atend = false; - - /* This routine should only be used for empty classes. */ - gcc_assert (is_empty_class (basetype)); - alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype)); - - if (!integer_zerop (BINFO_OFFSET (binfo))) - { - if (abi_version_at_least (2)) - propagate_binfo_offsets - (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo))); - else - warning (OPT_Wabi, - "offset of empty base %qT may not be ABI-compliant and may" - "change in a future version of GCC", - BINFO_TYPE (binfo)); - } - - /* This is an empty base class. We first try to put it at offset - zero. */ - if (layout_conflict_p (binfo, - BINFO_OFFSET (binfo), - offsets, - /*vbases_p=*/0)) - { - /* That didn't work. Now, we move forward from the next - available spot in the class. */ - atend = true; - propagate_binfo_offsets (binfo, convert (ssizetype, eoc)); - while (1) - { - if (!layout_conflict_p (binfo, - BINFO_OFFSET (binfo), - offsets, - /*vbases_p=*/0)) - /* We finally found a spot where there's no overlap. */ - break; - - /* There's overlap here, too. Bump along to the next spot. */ - propagate_binfo_offsets (binfo, alignment); - } - } - return atend; -} - -/* Layout the base given by BINFO in the class indicated by RLI. - *BASE_ALIGN is a running maximum of the alignments of - any base class. OFFSETS gives the location of empty base - subobjects. T is the most derived type. Return nonzero if the new - object cannot be nearly-empty. A new FIELD_DECL is inserted at - *NEXT_FIELD, unless BINFO is for an empty base class. - - Returns the location at which the next field should be inserted. */ - -static tree * -build_base_field (record_layout_info rli, tree binfo, - splay_tree offsets, tree *next_field) -{ - tree t = rli->t; - tree basetype = BINFO_TYPE (binfo); - - if (!COMPLETE_TYPE_P (basetype)) - /* This error is now reported in xref_tag, thus giving better - location information. */ - return next_field; - - /* Place the base class. */ - if (!is_empty_class (basetype)) - { - tree decl; - - /* The containing class is non-empty because it has a non-empty - base class. */ - CLASSTYPE_EMPTY_P (t) = 0; - - /* Create the FIELD_DECL. */ - decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype)); - DECL_ARTIFICIAL (decl) = 1; - DECL_IGNORED_P (decl) = 1; - DECL_FIELD_CONTEXT (decl) = t; - DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype); - DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype); - DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); - DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype); - DECL_MODE (decl) = TYPE_MODE (basetype); - DECL_FIELD_IS_BASE (decl) = 1; - - /* Try to place the field. It may take more than one try if we - have a hard time placing the field without putting two - objects of the same type at the same address. */ - layout_nonempty_base_or_field (rli, decl, binfo, offsets); - /* Add the new FIELD_DECL to the list of fields for T. */ - TREE_CHAIN (decl) = *next_field; - *next_field = decl; - next_field = &TREE_CHAIN (decl); - } - else - { - tree eoc; - bool atend; - - /* On some platforms (ARM), even empty classes will not be - byte-aligned. */ - eoc = round_up (rli_size_unit_so_far (rli), - CLASSTYPE_ALIGN_UNIT (basetype)); - atend = layout_empty_base (binfo, eoc, offsets); - /* A nearly-empty class "has no proper base class that is empty, - not morally virtual, and at an offset other than zero." */ - if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t)) - { - if (atend) - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - /* The check above (used in G++ 3.2) is insufficient because - an empty class placed at offset zero might itself have an - empty base at a nonzero offset. */ - else if (walk_subobject_offsets (basetype, - empty_base_at_nonzero_offset_p, - size_zero_node, - /*offsets=*/NULL, - /*max_offset=*/NULL_TREE, - /*vbases_p=*/true)) - { - if (abi_version_at_least (2)) - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - else - warning (OPT_Wabi, - "class %qT will be considered nearly empty in a " - "future version of GCC", t); - } - } - - /* We do not create a FIELD_DECL for empty base classes because - it might overlap some other field. We want to be able to - create CONSTRUCTORs for the class by iterating over the - FIELD_DECLs, and the back end does not handle overlapping - FIELD_DECLs. */ - - /* An empty virtual base causes a class to be non-empty - -- but in that case we do not need to clear CLASSTYPE_EMPTY_P - here because that was already done when the virtual table - pointer was created. */ - } - - /* Record the offsets of BINFO and its base subobjects. */ - record_subobject_offsets (binfo, - BINFO_OFFSET (binfo), - offsets, - /*is_data_member=*/false); - - return next_field; -} - -/* Layout all of the non-virtual base classes. Record empty - subobjects in OFFSETS. T is the most derived type. Return nonzero - if the type cannot be nearly empty. The fields created - corresponding to the base classes will be inserted at - *NEXT_FIELD. */ - -static void -build_base_fields (record_layout_info rli, - splay_tree offsets, tree *next_field) -{ - /* Chain to hold all the new FIELD_DECLs which stand in for base class - subobjects. */ - tree t = rli->t; - int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t)); - int i; - - /* The primary base class is always allocated first. */ - if (CLASSTYPE_HAS_PRIMARY_BASE_P (t)) - next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t), - offsets, next_field); - - /* Now allocate the rest of the bases. */ - for (i = 0; i < n_baseclasses; ++i) - { - tree base_binfo; - - base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i); - - /* The primary base was already allocated above, so we don't - need to allocate it again here. */ - if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t)) - continue; - - /* Virtual bases are added at the end (a primary virtual base - will have already been added). */ - if (BINFO_VIRTUAL_P (base_binfo)) - continue; - - next_field = build_base_field (rli, base_binfo, - offsets, next_field); - } -} - -/* Go through the TYPE_METHODS of T issuing any appropriate - diagnostics, figuring out which methods override which other - methods, and so forth. */ - -static void -check_methods (tree t) -{ - tree x; - - for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x)) - { - check_for_override (x, t); - if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x)) - error ("initializer specified for non-virtual method %q+D", x); - /* The name of the field is the original field name - Save this in auxiliary field for later overloading. */ - if (DECL_VINDEX (x)) - { - TYPE_POLYMORPHIC_P (t) = 1; - if (DECL_PURE_VIRTUAL_P (x)) - VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x); - } - /* All user-declared destructors are non-trivial. */ - if (DECL_DESTRUCTOR_P (x)) - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - { - TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1; - - /* Conservatively assume that destructor body is nontrivial. Will - be unmarked during parsing of function body if it happens to be - trivial. */ - CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (t) = 1; - } - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - } -} - -/* FN is a constructor or destructor. Clone the declaration to create - a specialized in-charge or not-in-charge version, as indicated by - NAME. */ - -static tree -build_clone (tree fn, tree name) -{ - tree parms; - tree clone; - - /* Copy the function. */ - clone = copy_decl (fn); - /* Remember where this function came from. */ - DECL_CLONED_FUNCTION (clone) = fn; - DECL_ABSTRACT_ORIGIN (clone) = fn; - /* Reset the function name. */ - DECL_NAME (clone) = name; - SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE); - /* There's no pending inline data for this function. */ - DECL_PENDING_INLINE_INFO (clone) = NULL; - DECL_PENDING_INLINE_P (clone) = 0; - /* And it hasn't yet been deferred. */ - DECL_DEFERRED_FN (clone) = 0; - - /* The base-class destructor is not virtual. */ - if (name == base_dtor_identifier) - { - DECL_VIRTUAL_P (clone) = 0; - if (TREE_CODE (clone) != TEMPLATE_DECL) - DECL_VINDEX (clone) = NULL_TREE; - } - - /* If there was an in-charge parameter, drop it from the function - type. */ - if (DECL_HAS_IN_CHARGE_PARM_P (clone)) - { - tree basetype; - tree parmtypes; - tree exceptions; - - exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); - basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); - parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone)); - /* Skip the `this' parameter. */ - parmtypes = TREE_CHAIN (parmtypes); - /* Skip the in-charge parameter. */ - parmtypes = TREE_CHAIN (parmtypes); - /* And the VTT parm, in a complete [cd]tor. */ - if (DECL_HAS_VTT_PARM_P (fn) - && ! DECL_NEEDS_VTT_PARM_P (clone)) - parmtypes = TREE_CHAIN (parmtypes); - /* If this is subobject constructor or destructor, add the vtt - parameter. */ - TREE_TYPE (clone) - = build_method_type_directly (basetype, - TREE_TYPE (TREE_TYPE (clone)), - parmtypes); - if (exceptions) - TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), - exceptions); - TREE_TYPE (clone) - = cp_build_type_attribute_variant (TREE_TYPE (clone), - TYPE_ATTRIBUTES (TREE_TYPE (fn))); - } - - /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL - aren't function parameters; those are the template parameters. */ - if (TREE_CODE (clone) != TEMPLATE_DECL) - { - DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone)); - /* Remove the in-charge parameter. */ - if (DECL_HAS_IN_CHARGE_PARM_P (clone)) - { - TREE_CHAIN (DECL_ARGUMENTS (clone)) - = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone))); - DECL_HAS_IN_CHARGE_PARM_P (clone) = 0; - } - /* And the VTT parm, in a complete [cd]tor. */ - if (DECL_HAS_VTT_PARM_P (fn)) - { - if (DECL_NEEDS_VTT_PARM_P (clone)) - DECL_HAS_VTT_PARM_P (clone) = 1; - else - { - TREE_CHAIN (DECL_ARGUMENTS (clone)) - = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone))); - DECL_HAS_VTT_PARM_P (clone) = 0; - } - } - - for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms)) - { - DECL_CONTEXT (parms) = clone; - cxx_dup_lang_specific_decl (parms); - } - } - - /* Create the RTL for this function. */ - SET_DECL_RTL (clone, NULL_RTX); - rest_of_decl_compilation (clone, /*top_level=*/1, at_eof); - - /* Make it easy to find the CLONE given the FN. */ - TREE_CHAIN (clone) = TREE_CHAIN (fn); - TREE_CHAIN (fn) = clone; - - /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */ - if (TREE_CODE (clone) == TEMPLATE_DECL) - { - tree result; - - DECL_TEMPLATE_RESULT (clone) - = build_clone (DECL_TEMPLATE_RESULT (clone), name); - result = DECL_TEMPLATE_RESULT (clone); - DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result)); - DECL_TI_TEMPLATE (result) = clone; - } - else if (pch_file) - note_decl_for_pch (clone); - - return clone; -} - -/* Produce declarations for all appropriate clones of FN. If - UPDATE_METHOD_VEC_P is nonzero, the clones are added to the - CLASTYPE_METHOD_VEC as well. */ - -void -clone_function_decl (tree fn, int update_method_vec_p) -{ - tree clone; - - /* Avoid inappropriate cloning. */ - if (TREE_CHAIN (fn) - && DECL_CLONED_FUNCTION (TREE_CHAIN (fn))) - return; - - if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)) - { - /* For each constructor, we need two variants: an in-charge version - and a not-in-charge version. */ - clone = build_clone (fn, complete_ctor_identifier); - if (update_method_vec_p) - add_method (DECL_CONTEXT (clone), clone, NULL_TREE); - clone = build_clone (fn, base_ctor_identifier); - if (update_method_vec_p) - add_method (DECL_CONTEXT (clone), clone, NULL_TREE); - } - else - { - gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)); - - /* For each destructor, we need three variants: an in-charge - version, a not-in-charge version, and an in-charge deleting - version. We clone the deleting version first because that - means it will go second on the TYPE_METHODS list -- and that - corresponds to the correct layout order in the virtual - function table. - - For a non-virtual destructor, we do not build a deleting - destructor. */ - if (DECL_VIRTUAL_P (fn)) - { - clone = build_clone (fn, deleting_dtor_identifier); - if (update_method_vec_p) - add_method (DECL_CONTEXT (clone), clone, NULL_TREE); - } - - /* APPLE LOCAL begin KEXT double destructor */ - /* Don't use the complete dtor. */ - if (TARGET_KEXTABI != 1 - || ! has_apple_kext_compatibility_attr_p (DECL_CONTEXT (fn))) - { - clone = build_clone (fn, complete_dtor_identifier); - if (update_method_vec_p) - add_method (DECL_CONTEXT (clone), clone, NULL_TREE); - } - /* APPLE LOCAL end KEXT double destructor */ - - clone = build_clone (fn, base_dtor_identifier); - if (update_method_vec_p) - add_method (DECL_CONTEXT (clone), clone, NULL_TREE); - } - - /* Note that this is an abstract function that is never emitted. */ - DECL_ABSTRACT (fn) = 1; -} - -/* DECL is an in charge constructor, which is being defined. This will - have had an in class declaration, from whence clones were - declared. An out-of-class definition can specify additional default - arguments. As it is the clones that are involved in overload - resolution, we must propagate the information from the DECL to its - clones. */ - -void -adjust_clone_args (tree decl) -{ - tree clone; - - for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone); - clone = TREE_CHAIN (clone)) - { - tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone)); - tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl)); - tree decl_parms, clone_parms; - - clone_parms = orig_clone_parms; - - /* Skip the 'this' parameter. */ - orig_clone_parms = TREE_CHAIN (orig_clone_parms); - orig_decl_parms = TREE_CHAIN (orig_decl_parms); - - if (DECL_HAS_IN_CHARGE_PARM_P (decl)) - orig_decl_parms = TREE_CHAIN (orig_decl_parms); - if (DECL_HAS_VTT_PARM_P (decl)) - orig_decl_parms = TREE_CHAIN (orig_decl_parms); - - clone_parms = orig_clone_parms; - if (DECL_HAS_VTT_PARM_P (clone)) - clone_parms = TREE_CHAIN (clone_parms); - - for (decl_parms = orig_decl_parms; decl_parms; - decl_parms = TREE_CHAIN (decl_parms), - clone_parms = TREE_CHAIN (clone_parms)) - { - gcc_assert (same_type_p (TREE_TYPE (decl_parms), - TREE_TYPE (clone_parms))); - - if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms)) - { - /* A default parameter has been added. Adjust the - clone's parameters. */ - tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); - tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); - tree type; - - clone_parms = orig_decl_parms; - - if (DECL_HAS_VTT_PARM_P (clone)) - { - clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms), - TREE_VALUE (orig_clone_parms), - clone_parms); - TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms); - } - type = build_method_type_directly (basetype, - TREE_TYPE (TREE_TYPE (clone)), - clone_parms); - if (exceptions) - type = build_exception_variant (type, exceptions); - TREE_TYPE (clone) = type; - - clone_parms = NULL_TREE; - break; - } - } - gcc_assert (!clone_parms); - } -} - -/* For each of the constructors and destructors in T, create an - in-charge and not-in-charge variant. */ - -static void -clone_constructors_and_destructors (tree t) -{ - tree fns; - - /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail - out now. */ - if (!CLASSTYPE_METHOD_VEC (t)) - return; - - for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) - clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); - for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns)) - clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); -} - -/* Remove all zero-width bit-fields from T. */ - -static void -remove_zero_width_bit_fields (tree t) -{ - tree *fieldsp; - - fieldsp = &TYPE_FIELDS (t); - while (*fieldsp) - { - if (TREE_CODE (*fieldsp) == FIELD_DECL - && DECL_C_BIT_FIELD (*fieldsp) - && DECL_INITIAL (*fieldsp)) - *fieldsp = TREE_CHAIN (*fieldsp); - else - fieldsp = &TREE_CHAIN (*fieldsp); - } -} - -/* Returns TRUE iff we need a cookie when dynamically allocating an - array whose elements have the indicated class TYPE. */ - -static bool -type_requires_array_cookie (tree type) -{ - tree fns; - bool has_two_argument_delete_p = false; - - gcc_assert (CLASS_TYPE_P (type)); - - /* If there's a non-trivial destructor, we need a cookie. In order - to iterate through the array calling the destructor for each - element, we'll have to know how many elements there are. */ - if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) - return true; - - /* If the usual deallocation function is a two-argument whose second - argument is of type `size_t', then we have to pass the size of - the array to the deallocation function, so we will need to store - a cookie. */ - fns = lookup_fnfields (TYPE_BINFO (type), - ansi_opname (VEC_DELETE_EXPR), - /*protect=*/0); - /* If there are no `operator []' members, or the lookup is - ambiguous, then we don't need a cookie. */ - if (!fns || fns == error_mark_node) - return false; - /* Loop through all of the functions. */ - for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns)) - { - tree fn; - tree second_parm; - - /* Select the current function. */ - fn = OVL_CURRENT (fns); - /* See if this function is a one-argument delete function. If - it is, then it will be the usual deallocation function. */ - second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn))); - if (second_parm == void_list_node) - return false; - /* Otherwise, if we have a two-argument function and the second - argument is `size_t', it will be the usual deallocation - function -- unless there is one-argument function, too. */ - if (TREE_CHAIN (second_parm) == void_list_node - && same_type_p (TREE_VALUE (second_parm), sizetype)) - has_two_argument_delete_p = true; - } - - return has_two_argument_delete_p; -} - -/* Check the validity of the bases and members declared in T. Add any - implicitly-generated functions (like copy-constructors and - assignment operators). Compute various flag bits (like - CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++ - level: i.e., independently of the ABI in use. */ - -static void -check_bases_and_members (tree t) -{ - /* Nonzero if the implicitly generated copy constructor should take - a non-const reference argument. */ - int cant_have_const_ctor; - /* Nonzero if the implicitly generated assignment operator - should take a non-const reference argument. */ - int no_const_asn_ref; - tree access_decls; - - /* By default, we use const reference arguments and generate default - constructors. */ - cant_have_const_ctor = 0; - no_const_asn_ref = 0; - - /* Check all the base-classes. */ - check_bases (t, &cant_have_const_ctor, - &no_const_asn_ref); - - /* Check all the method declarations. */ - check_methods (t); - - /* Check all the data member declarations. We cannot call - check_field_decls until we have called check_bases check_methods, - as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR - being set appropriately. */ - check_field_decls (t, &access_decls, - &cant_have_const_ctor, - &no_const_asn_ref); - - /* A nearly-empty class has to be vptr-containing; a nearly empty - class contains just a vptr. */ - if (!TYPE_CONTAINS_VPTR_P (t)) - CLASSTYPE_NEARLY_EMPTY_P (t) = 0; - - /* Do some bookkeeping that will guide the generation of implicitly - declared member functions. */ - TYPE_HAS_COMPLEX_INIT_REF (t) - |= (TYPE_HAS_INIT_REF (t) || TYPE_CONTAINS_VPTR_P (t)); - TYPE_NEEDS_CONSTRUCTING (t) - |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_CONTAINS_VPTR_P (t)); - CLASSTYPE_NON_AGGREGATE (t) - |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_POLYMORPHIC_P (t)); - CLASSTYPE_NON_POD_P (t) - |= (CLASSTYPE_NON_AGGREGATE (t) - || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) - || TYPE_HAS_ASSIGN_REF (t)); - TYPE_HAS_COMPLEX_ASSIGN_REF (t) - |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t); - - /* Synthesize any needed methods. */ - add_implicitly_declared_members (t, - cant_have_const_ctor, - no_const_asn_ref); - - /* Create the in-charge and not-in-charge variants of constructors - and destructors. */ - clone_constructors_and_destructors (t); - - /* Process the using-declarations. */ - for (; access_decls; access_decls = TREE_CHAIN (access_decls)) - handle_using_decl (TREE_VALUE (access_decls), t); - - /* Build and sort the CLASSTYPE_METHOD_VEC. */ - finish_struct_methods (t); - - /* Figure out whether or not we will need a cookie when dynamically - allocating an array of this type. */ - TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie - = type_requires_array_cookie (t); -} - -/* If T needs a pointer to its virtual function table, set TYPE_VFIELD - accordingly. If a new vfield was created (because T doesn't have a - primary base class), then the newly created field is returned. It - is not added to the TYPE_FIELDS list; it is the caller's - responsibility to do that. Accumulate declared virtual functions - on VIRTUALS_P. */ - -static tree -create_vtable_ptr (tree t, tree* virtuals_p) -{ - tree fn; - - /* Collect the virtual functions declared in T. */ - for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn)) - if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn) - && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST) - { - tree new_virtual = make_node (TREE_LIST); - - BV_FN (new_virtual) = fn; - BV_DELTA (new_virtual) = integer_zero_node; - BV_VCALL_INDEX (new_virtual) = NULL_TREE; - - TREE_CHAIN (new_virtual) = *virtuals_p; - *virtuals_p = new_virtual; - } - - /* If we couldn't find an appropriate base class, create a new field - here. Even if there weren't any new virtual functions, we might need a - new virtual function table if we're supposed to include vptrs in - all classes that need them. */ - if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t))) - { - /* We build this decl with vtbl_ptr_type_node, which is a - `vtable_entry_type*'. It might seem more precise to use - `vtable_entry_type (*)[N]' where N is the number of virtual - functions. However, that would require the vtable pointer in - base classes to have a different type than the vtable pointer - in derived classes. We could make that happen, but that - still wouldn't solve all the problems. In particular, the - type-based alias analysis code would decide that assignments - to the base class vtable pointer can't alias assignments to - the derived class vtable pointer, since they have different - types. Thus, in a derived class destructor, where the base - class constructor was inlined, we could generate bad code for - setting up the vtable pointer. - - Therefore, we use one type for all vtable pointers. We still - use a type-correct type; it's just doesn't indicate the array - bounds. That's better than using `void*' or some such; it's - cleaner, and it let's the alias analysis code know that these - stores cannot alias stores to void*! */ - tree field; - - field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node); - DECL_VIRTUAL_P (field) = 1; - DECL_ARTIFICIAL (field) = 1; - DECL_FIELD_CONTEXT (field) = t; - DECL_FCONTEXT (field) = t; - - TYPE_VFIELD (t) = field; - - /* This class is non-empty. */ - CLASSTYPE_EMPTY_P (t) = 0; - - return field; - } - - return NULL_TREE; -} - -/* Fixup the inline function given by INFO now that the class is - complete. */ - -static void -fixup_pending_inline (tree fn) -{ - if (DECL_PENDING_INLINE_INFO (fn)) - { - tree args = DECL_ARGUMENTS (fn); - while (args) - { - DECL_CONTEXT (args) = fn; - args = TREE_CHAIN (args); - } - } -} - -/* Fixup the inline methods and friends in TYPE now that TYPE is - complete. */ - -static void -fixup_inline_methods (tree type) -{ - tree method = TYPE_METHODS (type); - VEC(tree,gc) *friends; - unsigned ix; - - 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 (method); - - /* Do friends. */ - for (friends = CLASSTYPE_INLINE_FRIENDS (type), ix = 0; - VEC_iterate (tree, friends, ix, method); ix++) - fixup_pending_inline (method); - CLASSTYPE_INLINE_FRIENDS (type) = NULL; -} - -/* Add OFFSET to all base types of BINFO which is a base in the - hierarchy dominated by T. - - OFFSET, which is a type offset, is number of bytes. */ - -static void -propagate_binfo_offsets (tree binfo, tree offset) -{ - int i; - tree primary_binfo; - tree base_binfo; - - /* Update BINFO's offset. */ - BINFO_OFFSET (binfo) - = convert (sizetype, - size_binop (PLUS_EXPR, - convert (ssizetype, BINFO_OFFSET (binfo)), - offset)); - - /* Find the primary base class. */ - primary_binfo = get_primary_binfo (binfo); - - if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo) - propagate_binfo_offsets (primary_binfo, offset); - - /* Scan all of the bases, pushing the BINFO_OFFSET adjust - downwards. */ - for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - { - /* Don't do the primary base twice. */ - if (base_binfo == primary_binfo) - continue; - - if (BINFO_VIRTUAL_P (base_binfo)) - continue; - - propagate_binfo_offsets (base_binfo, offset); - } -} - -/* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update - TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of - empty subobjects of T. */ - -static void -layout_virtual_bases (record_layout_info rli, splay_tree offsets) -{ - tree vbase; - tree t = rli->t; - bool first_vbase = true; - tree *next_field; - - if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0) - return; - - if (!abi_version_at_least(2)) - { - /* In G++ 3.2, we incorrectly rounded the size before laying out - the virtual bases. */ - finish_record_layout (rli, /*free_p=*/false); -#ifdef STRUCTURE_SIZE_BOUNDARY - /* Packed structures don't need to have minimum size. */ - if (! TYPE_PACKED (t)) - TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY); -#endif - rli->offset = TYPE_SIZE_UNIT (t); - rli->bitpos = bitsize_zero_node; - rli->record_align = TYPE_ALIGN (t); - } - - /* Find the last field. The artificial fields created for virtual - bases will go after the last extant field to date. */ - next_field = &TYPE_FIELDS (t); - while (*next_field) - next_field = &TREE_CHAIN (*next_field); - - /* Go through the virtual bases, allocating space for each virtual - base that is not already a primary base class. These are - allocated in inheritance graph order. */ - for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) - { - if (!BINFO_VIRTUAL_P (vbase)) - continue; - - if (!BINFO_PRIMARY_P (vbase)) - { - tree basetype = TREE_TYPE (vbase); - - /* This virtual base is not a primary base of any class in the - hierarchy, so we have to add space for it. */ - next_field = build_base_field (rli, vbase, - offsets, next_field); - - /* If the first virtual base might have been placed at a - lower address, had we started from CLASSTYPE_SIZE, rather - than TYPE_SIZE, issue a warning. There can be both false - positives and false negatives from this warning in rare - cases; to deal with all the possibilities would probably - require performing both layout algorithms and comparing - the results which is not particularly tractable. */ - if (warn_abi - && first_vbase - && (tree_int_cst_lt - (size_binop (CEIL_DIV_EXPR, - round_up (CLASSTYPE_SIZE (t), - CLASSTYPE_ALIGN (basetype)), - bitsize_unit_node), - BINFO_OFFSET (vbase)))) - warning (OPT_Wabi, - "offset of virtual base %qT is not ABI-compliant and " - "may change in a future version of GCC", - basetype); - - first_vbase = false; - } - } -} - -/* Returns the offset of the byte just past the end of the base class - BINFO. */ - -static tree -end_of_base (tree binfo) -{ - tree size; - - if (is_empty_class (BINFO_TYPE (binfo))) - /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to - allocate some space for it. It cannot have virtual bases, so - TYPE_SIZE_UNIT is fine. */ - size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo)); - else - size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo)); - - return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size); -} - -/* Returns the offset of the byte just past the end of the base class - with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then - only non-virtual bases are included. */ - -static tree -end_of_class (tree t, int include_virtuals_p) -{ - tree result = size_zero_node; - VEC(tree,gc) *vbases; - tree binfo; - tree base_binfo; - tree offset; - int i; - - for (binfo = TYPE_BINFO (t), i = 0; - BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - { - if (!include_virtuals_p - && BINFO_VIRTUAL_P (base_binfo) - && (!BINFO_PRIMARY_P (base_binfo) - || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t))) - continue; - - offset = end_of_base (base_binfo); - if (INT_CST_LT_UNSIGNED (result, offset)) - result = offset; - } - - /* G++ 3.2 did not check indirect virtual bases. */ - if (abi_version_at_least (2) && include_virtuals_p) - for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0; - VEC_iterate (tree, vbases, i, base_binfo); i++) - { - offset = end_of_base (base_binfo); - if (INT_CST_LT_UNSIGNED (result, offset)) - result = offset; - } - - return result; -} - -/* Warn about bases of T that are inaccessible because they are - ambiguous. For example: - - struct S {}; - struct T : public S {}; - struct U : public S, public T {}; - - Here, `(S*) new U' is not allowed because there are two `S' - subobjects of U. */ - -static void -warn_about_ambiguous_bases (tree t) -{ - int i; - VEC(tree,gc) *vbases; - tree basetype; - tree binfo; - tree base_binfo; - - /* If there are no repeated bases, nothing can be ambiguous. */ - if (!CLASSTYPE_REPEATED_BASE_P (t)) - return; - - /* Check direct bases. */ - for (binfo = TYPE_BINFO (t), i = 0; - BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - { - basetype = BINFO_TYPE (base_binfo); - - if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL)) - warning (0, "direct base %qT inaccessible in %qT due to ambiguity", - basetype, t); - } - - /* Check for ambiguous virtual bases. */ - if (extra_warnings) - for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0; - VEC_iterate (tree, vbases, i, binfo); i++) - { - basetype = BINFO_TYPE (binfo); - - if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL)) - warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity", - basetype, t); - } -} - -/* Compare two INTEGER_CSTs K1 and K2. */ - -static int -splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2) -{ - return tree_int_cst_compare ((tree) k1, (tree) k2); -} - -/* Increase the size indicated in RLI to account for empty classes - that are "off the end" of the class. */ - -static void -include_empty_classes (record_layout_info rli) -{ - tree eoc; - tree rli_size; - - /* It might be the case that we grew the class to allocate a - zero-sized base class. That won't be reflected in RLI, yet, - because we are willing to overlay multiple bases at the same - offset. However, now we need to make sure that RLI is big enough - to reflect the entire class. */ - eoc = end_of_class (rli->t, - CLASSTYPE_AS_BASE (rli->t) != NULL_TREE); - rli_size = rli_size_unit_so_far (rli); - if (TREE_CODE (rli_size) == INTEGER_CST - && INT_CST_LT_UNSIGNED (rli_size, eoc)) - { - if (!abi_version_at_least (2)) - /* In version 1 of the ABI, the size of a class that ends with - a bitfield was not rounded up to a whole multiple of a - byte. Because rli_size_unit_so_far returns only the number - of fully allocated bytes, any extra bits were not included - in the size. */ - rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT); - else - /* The size should have been rounded to a whole byte. */ - gcc_assert (tree_int_cst_equal - (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT))); - rli->bitpos - = size_binop (PLUS_EXPR, - rli->bitpos, - size_binop (MULT_EXPR, - convert (bitsizetype, - size_binop (MINUS_EXPR, - eoc, rli_size)), - bitsize_int (BITS_PER_UNIT))); - normalize_rli (rli); - } -} - -/* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate - BINFO_OFFSETs for all of the base-classes. Position the vtable - pointer. Accumulate declared virtual functions on VIRTUALS_P. */ - -static void -layout_class_type (tree t, tree *virtuals_p) -{ - tree non_static_data_members; - tree field; - tree vptr; - record_layout_info rli; - /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of - types that appear at that offset. */ - splay_tree empty_base_offsets; - /* True if the last field layed out was a bit-field. */ - bool last_field_was_bitfield = false; - /* The location at which the next field should be inserted. */ - tree *next_field; - /* T, as a base class. */ - tree base_t; - - /* Keep track of the first non-static data member. */ - non_static_data_members = TYPE_FIELDS (t); - - /* Start laying out the record. */ - rli = start_record_layout (t); - - /* Mark all the primary bases in the hierarchy. */ - determine_primary_bases (t); - - /* Create a pointer to our virtual function table. */ - vptr = create_vtable_ptr (t, virtuals_p); - - /* The vptr is always the first thing in the class. */ - if (vptr) - { - TREE_CHAIN (vptr) = TYPE_FIELDS (t); - TYPE_FIELDS (t) = vptr; - next_field = &TREE_CHAIN (vptr); - place_field (rli, vptr); - } - else - next_field = &TYPE_FIELDS (t); - - /* Build FIELD_DECLs for all of the non-virtual base-types. */ - empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts, - NULL, NULL); - build_base_fields (rli, empty_base_offsets, next_field); - - /* Layout the non-static data members. */ - for (field = non_static_data_members; field; field = TREE_CHAIN (field)) - { - tree type; - tree padding; - - /* We still pass things that aren't non-static data members to - the back-end, in case it wants to do something with them. */ - if (TREE_CODE (field) != FIELD_DECL) - { - place_field (rli, field); - /* If the static data member has incomplete type, keep track - of it so that it can be completed later. (The handling - of pending statics in finish_record_layout is - insufficient; consider: - - struct S1; - struct S2 { static S1 s1; }; - - At this point, finish_record_layout will be called, but - S1 is still incomplete.) */ - if (TREE_CODE (field) == VAR_DECL) - { - maybe_register_incomplete_var (field); - /* The visibility of static data members is determined - at their point of declaration, not their point of - definition. */ - determine_visibility (field); - } - continue; - } - /* APPLE LOCAL begin radar 4592503 */ - if (c_dialect_objc ()) - objc_checkon_weak_attribute (field); - /* APPLE LOCAL end radar 4592503 */ - - type = TREE_TYPE (field); - if (type == error_mark_node) - continue; - - padding = NULL_TREE; - - /* If this field is a bit-field whose width is greater than its - type, then there are some special rules for allocating - it. */ - if (DECL_C_BIT_FIELD (field) - && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field))) - { - integer_type_kind itk; - tree integer_type; - bool was_unnamed_p = false; - /* We must allocate the bits as if suitably aligned for the - longest integer type that fits in this many bits. type - of the field. Then, we are supposed to use the left over - bits as additional padding. */ - for (itk = itk_char; itk != itk_none; ++itk) - if (INT_CST_LT (DECL_SIZE (field), - TYPE_SIZE (integer_types[itk]))) - break; - - /* ITK now indicates a type that is too large for the - field. We have to back up by one to find the largest - type that fits. */ - integer_type = integer_types[itk - 1]; - - /* Figure out how much additional padding is required. GCC - 3.2 always created a padding field, even if it had zero - width. */ - if (!abi_version_at_least (2) - || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field))) - { - if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE) - /* In a union, the padding field must have the full width - of the bit-field; all fields start at offset zero. */ - padding = DECL_SIZE (field); - else - { - if (TREE_CODE (t) == UNION_TYPE) - warning (OPT_Wabi, "size assigned to %qT may not be " - "ABI-compliant and may change in a future " - "version of GCC", - t); - padding = size_binop (MINUS_EXPR, DECL_SIZE (field), - TYPE_SIZE (integer_type)); - } - } -#ifdef PCC_BITFIELD_TYPE_MATTERS - /* An unnamed bitfield does not normally affect the - alignment of the containing class on a target where - PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not - make any exceptions for unnamed bitfields when the - bitfields are longer than their types. Therefore, we - temporarily give the field a name. */ - if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field)) - { - was_unnamed_p = true; - DECL_NAME (field) = make_anon_name (); - } -#endif - DECL_SIZE (field) = TYPE_SIZE (integer_type); - DECL_ALIGN (field) = TYPE_ALIGN (integer_type); - DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type); - layout_nonempty_base_or_field (rli, field, NULL_TREE, - empty_base_offsets); - if (was_unnamed_p) - DECL_NAME (field) = NULL_TREE; - /* Now that layout has been performed, set the size of the - field to the size of its declared type; the rest of the - field is effectively invisible. */ - DECL_SIZE (field) = TYPE_SIZE (type); - /* We must also reset the DECL_MODE of the field. */ - if (abi_version_at_least (2)) - DECL_MODE (field) = TYPE_MODE (type); - else if (warn_abi - && DECL_MODE (field) != TYPE_MODE (type)) - /* Versions of G++ before G++ 3.4 did not reset the - DECL_MODE. */ - warning (OPT_Wabi, - "the offset of %qD may not be ABI-compliant and may " - "change in a future version of GCC", field); - } - else - layout_nonempty_base_or_field (rli, field, NULL_TREE, - empty_base_offsets); - - /* Remember the location of any empty classes in FIELD. */ - if (abi_version_at_least (2)) - record_subobject_offsets (TREE_TYPE (field), - byte_position(field), - empty_base_offsets, - /*is_data_member=*/true); - - /* If a bit-field does not immediately follow another bit-field, - and yet it starts in the middle of a byte, we have failed to - comply with the ABI. */ - if (warn_abi - && DECL_C_BIT_FIELD (field) - /* The TREE_NO_WARNING flag gets set by Objective-C when - laying out an Objective-C class. The ObjC ABI differs - from the C++ ABI, and so we do not want a warning - here. */ - && !TREE_NO_WARNING (field) - && !last_field_was_bitfield - && !integer_zerop (size_binop (TRUNC_MOD_EXPR, - DECL_FIELD_BIT_OFFSET (field), - bitsize_unit_node))) - warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may " - "change in a future version of GCC", field); - - /* G++ used to use DECL_FIELD_OFFSET as if it were the byte - offset of the field. */ - if (warn_abi - && !tree_int_cst_equal (DECL_FIELD_OFFSET (field), - byte_position (field)) - && contains_empty_class_p (TREE_TYPE (field))) - warning (OPT_Wabi, "%q+D contains empty classes which may cause base " - "classes to be placed at different locations in a " - "future version of GCC", field); - - /* The middle end uses the type of expressions to determine the - possible range of expression values. In order to optimize - "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end - must be made aware of the width of "i", via its type. - - Because C++ does not have integer types of arbitrary width, - we must (for the purposes of the front end) convert from the - type assigned here to the declared type of the bitfield - whenever a bitfield expression is used as an rvalue. - Similarly, when assigning a value to a bitfield, the value - must be converted to the type given the bitfield here. */ - if (DECL_C_BIT_FIELD (field)) - { - tree ftype; - unsigned HOST_WIDE_INT width; - ftype = TREE_TYPE (field); - width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1); - if (width != TYPE_PRECISION (ftype)) - TREE_TYPE (field) - = c_build_bitfield_integer_type (width, - TYPE_UNSIGNED (ftype)); - } - - /* If we needed additional padding after this field, add it - now. */ - if (padding) - { - tree padding_field; - - padding_field = build_decl (FIELD_DECL, - NULL_TREE, - char_type_node); - DECL_BIT_FIELD (padding_field) = 1; - DECL_SIZE (padding_field) = padding; - DECL_CONTEXT (padding_field) = t; - DECL_ARTIFICIAL (padding_field) = 1; - DECL_IGNORED_P (padding_field) = 1; - layout_nonempty_base_or_field (rli, padding_field, - NULL_TREE, - empty_base_offsets); - } - - last_field_was_bitfield = DECL_C_BIT_FIELD (field); - } - - if (abi_version_at_least (2) && !integer_zerop (rli->bitpos)) - { - /* Make sure that we are on a byte boundary so that the size of - the class without virtual bases will always be a round number - of bytes. */ - rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT); - normalize_rli (rli); - } - - /* G++ 3.2 does not allow virtual bases to be overlaid with tail - padding. */ - if (!abi_version_at_least (2)) - include_empty_classes(rli); - - /* Delete all zero-width bit-fields from the list of fields. Now - that the type is laid out they are no longer important. */ - remove_zero_width_bit_fields (t); - - /* Create the version of T used for virtual bases. We do not use - make_aggr_type for this version; this is an artificial type. For - a POD type, we just reuse T. */ - if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t)) - { - base_t = make_node (TREE_CODE (t)); - - /* Set the size and alignment for the new type. In G++ 3.2, all - empty classes were considered to have size zero when used as - base classes. */ - if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t)) - { - TYPE_SIZE (base_t) = bitsize_zero_node; - TYPE_SIZE_UNIT (base_t) = size_zero_node; - if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli))) - warning (OPT_Wabi, - "layout of classes derived from empty class %qT " - "may change in a future version of GCC", - t); - } - else - { - tree eoc; - - /* If the ABI version is not at least two, and the last - field was a bit-field, RLI may not be on a byte - boundary. In particular, rli_size_unit_so_far might - indicate the last complete byte, while rli_size_so_far - indicates the total number of bits used. Therefore, - rli_size_so_far, rather than rli_size_unit_so_far, is - used to compute TYPE_SIZE_UNIT. */ - eoc = end_of_class (t, /*include_virtuals_p=*/0); - TYPE_SIZE_UNIT (base_t) - = size_binop (MAX_EXPR, - convert (sizetype, - size_binop (CEIL_DIV_EXPR, - rli_size_so_far (rli), - bitsize_int (BITS_PER_UNIT))), - eoc); - TYPE_SIZE (base_t) - = size_binop (MAX_EXPR, - rli_size_so_far (rli), - size_binop (MULT_EXPR, - convert (bitsizetype, eoc), - bitsize_int (BITS_PER_UNIT))); - } - TYPE_ALIGN (base_t) = rli->record_align; - TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t); - - /* Copy the fields from T. */ - next_field = &TYPE_FIELDS (base_t); - for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) - if (TREE_CODE (field) == FIELD_DECL) - { - *next_field = build_decl (FIELD_DECL, - DECL_NAME (field), - TREE_TYPE (field)); - DECL_CONTEXT (*next_field) = base_t; - DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field); - DECL_FIELD_BIT_OFFSET (*next_field) - = DECL_FIELD_BIT_OFFSET (field); - DECL_SIZE (*next_field) = DECL_SIZE (field); - DECL_MODE (*next_field) = DECL_MODE (field); - next_field = &TREE_CHAIN (*next_field); - } - - /* Record the base version of the type. */ - CLASSTYPE_AS_BASE (t) = base_t; - TYPE_CONTEXT (base_t) = t; - } - else - CLASSTYPE_AS_BASE (t) = t; - - /* Every empty class contains an empty class. */ - if (CLASSTYPE_EMPTY_P (t)) - CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; - - /* 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. As a side-effect, this will remove the - base subobject fields. */ - layout_virtual_bases (rli, empty_base_offsets); - - /* Make sure that empty classes are reflected in RLI at this - point. */ - include_empty_classes(rli); - - /* Make sure not to create any structures with zero size. */ - if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t)) - place_field (rli, - build_decl (FIELD_DECL, NULL_TREE, char_type_node)); - - /* Let the back-end lay out the type. */ - finish_record_layout (rli, /*free_p=*/true); - - /* Warn about bases that can't be talked about due to ambiguity. */ - warn_about_ambiguous_bases (t); - - /* Now that we're done with layout, give the base fields the real types. */ - for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) - if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field))) - TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field)); - - /* Clean up. */ - splay_tree_delete (empty_base_offsets); - - if (CLASSTYPE_EMPTY_P (t) - && tree_int_cst_lt (sizeof_biggest_empty_class, - TYPE_SIZE_UNIT (t))) - sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t); -} - -/* Determine the "key method" for the class type indicated by TYPE, - and set CLASSTYPE_KEY_METHOD accordingly. */ - -void -determine_key_method (tree type) -{ - tree method; - - if (TYPE_FOR_JAVA (type) - || processing_template_decl - || CLASSTYPE_TEMPLATE_INSTANTIATION (type) - || CLASSTYPE_INTERFACE_KNOWN (type)) - return; - - /* The key method is the first non-pure virtual function that is not - inline at the point of class definition. On some targets the - key function may not be inline; those targets should not call - this function until the end of the translation unit. */ - for (method = TYPE_METHODS (type); method != NULL_TREE; - method = TREE_CHAIN (method)) - if (DECL_VINDEX (method) != NULL_TREE - && ! DECL_DECLARED_INLINE_P (method) - && ! DECL_PURE_VIRTUAL_P (method)) - { - CLASSTYPE_KEY_METHOD (type) = method; - break; - } - - return; -} - -/* Perform processing required when the definition of T (a class type) - is complete. */ - -void -finish_struct_1 (tree t) -{ - tree x; - /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */ - tree virtuals = NULL_TREE; - int n_fields = 0; - - if (COMPLETE_TYPE_P (t)) - { - gcc_assert (IS_AGGR_TYPE (t)); - error ("redefinition of %q#T", t); - popclass (); - return; - } - - /* If this type was previously laid out as a forward reference, - make sure we lay it out again. */ - TYPE_SIZE (t) = NULL_TREE; - CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE; - - fixup_inline_methods (t); - - /* Make assumptions about the class; we'll reset the flags if - necessary. */ - CLASSTYPE_EMPTY_P (t) = 1; - CLASSTYPE_NEARLY_EMPTY_P (t) = 1; - CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0; - - /* Do end-of-class semantic processing: checking the validity of the - bases and members and add implicitly generated methods. */ - check_bases_and_members (t); - - /* Find the key method. */ - if (TYPE_CONTAINS_VPTR_P (t)) - { - /* The Itanium C++ ABI permits the key method to be chosen when - the class is defined -- even though the key method so - selected may later turn out to be an inline function. On - some systems (such as ARM Symbian OS) the key method cannot - be determined until the end of the translation unit. On such - systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which - will cause the class to be added to KEYED_CLASSES. Then, in - finish_file we will determine the key method. */ - if (targetm.cxx.key_method_may_be_inline ()) - determine_key_method (t); - - /* If a polymorphic class has no key method, we may emit the vtable - in every translation unit where the class definition appears. */ - if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE) - keyed_classes = tree_cons (NULL_TREE, t, keyed_classes); - } - - /* Layout the class itself. */ - layout_class_type (t, &virtuals); - if (CLASSTYPE_AS_BASE (t) != t) - /* We use the base type for trivial assignments, and hence it - needs a mode. */ - compute_record_mode (CLASSTYPE_AS_BASE (t)); - - virtuals = modify_all_vtables (t, nreverse (virtuals)); - - /* If necessary, create the primary vtable for this class. */ - if (virtuals || TYPE_CONTAINS_VPTR_P (t)) - { - /* We must enter these virtuals into the table. */ - if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) - build_primary_vtable (NULL_TREE, t); - else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t))) - /* Here we know enough to change the type of our virtual - function table, but we will wait until later this function. */ - build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t); - } - - if (TYPE_CONTAINS_VPTR_P (t)) - { - int vindex; - tree fn; - - if (BINFO_VTABLE (TYPE_BINFO (t))) - gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t)))); - if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) - gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE); - - /* Add entries for virtual functions introduced by this class. */ - BINFO_VIRTUALS (TYPE_BINFO (t)) - = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals); - - /* Set DECL_VINDEX for all functions declared in this class. */ - for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t)); - fn; - fn = TREE_CHAIN (fn), - vindex += (TARGET_VTABLE_USES_DESCRIPTORS - ? TARGET_VTABLE_USES_DESCRIPTORS : 1)) - { - tree fndecl = BV_FN (fn); - - if (DECL_THUNK_P (fndecl)) - /* A thunk. We should never be calling this entry directly - from this vtable -- we'd use the entry for the non - thunk base function. */ - DECL_VINDEX (fndecl) = NULL_TREE; - else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST) - DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex); - } - } - - finish_struct_bits (t); - - /* Complete the rtl for any static member objects of the type we're - working on. */ - for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x)) - if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x) - && TREE_TYPE (x) != error_mark_node - && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t)) - DECL_MODE (x) = TYPE_MODE (t); - - /* Done with FIELDS...now decide whether to sort these for - faster lookups later. - - We use a small number because most searches fail (succeeding - ultimately as the search bores through the inheritance - hierarchy), and we want this failure to occur quickly. */ - - n_fields = count_fields (TYPE_FIELDS (t)); - if (n_fields > 7) - { - struct sorted_fields_type *field_vec = GGC_NEWVAR - (struct sorted_fields_type, - sizeof (struct sorted_fields_type) + n_fields * sizeof (tree)); - field_vec->len = n_fields; - add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0); - qsort (field_vec->elts, n_fields, sizeof (tree), - field_decl_cmp); - if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t))) - retrofit_lang_decl (TYPE_MAIN_DECL (t)); - DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec; - } - - /* Complain if one of the field types requires lower visibility. */ - constrain_class_visibility (t); - - /* Make the rtl for any new vtables we have created, and unmark - the base types we marked. */ - finish_vtbls (t); - - /* Build the VTT for T. */ - build_vtt (t); - - /* This warning does not make sense for Java classes, since they - cannot have destructors. */ - if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t)) - { - tree dtor; - - dtor = CLASSTYPE_DESTRUCTORS (t); - /* Warn only if the dtor is non-private or the class has - friends. */ - if (/* An implicitly declared destructor is always public. And, - if it were virtual, we would have created it by now. */ - !dtor - || (!DECL_VINDEX (dtor) - && (!TREE_PRIVATE (dtor) - || CLASSTYPE_FRIEND_CLASSES (t) - || DECL_FRIENDLIST (TYPE_MAIN_DECL (t))))) - warning (0, "%q#T has virtual functions but non-virtual destructor", - t); - } - - complete_vars (t); - - if (warn_overloaded_virtual) - warn_hidden (t); - - /* Class layout, assignment of virtual table slots, etc., is now - complete. Give the back end a chance to tweak the visibility of - the class or perform any other required target modifications. */ - targetm.cxx.adjust_class_at_definition (t); - - maybe_suppress_debug_info (t); - - dump_class_hierarchy (t); - - /* Finish debugging output for this type. */ - /* APPLE LOCAL 4167759 */ - cp_set_decl_ignore_flag (t, 1); - rest_of_type_compilation (t, ! LOCAL_CLASS_P (t)); - /* APPLE LOCAL 4167759 */ - cp_set_decl_ignore_flag (t, 0); -} - -/* When T was built up, the member declarations were added in reverse - order. Rearrange them to declaration order. */ - -void -unreverse_member_declarations (tree t) -{ - tree next; - tree prev; - tree x; - - /* The following lists are all in reverse order. Put them in - declaration order now. */ - TYPE_METHODS (t) = nreverse (TYPE_METHODS (t)); - CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t)); - - /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in - reverse order, so we can't just use nreverse. */ - prev = NULL_TREE; - for (x = TYPE_FIELDS (t); - x && TREE_CODE (x) != TYPE_DECL; - x = next) - { - next = TREE_CHAIN (x); - TREE_CHAIN (x) = prev; - prev = x; - } - if (prev) - { - TREE_CHAIN (TYPE_FIELDS (t)) = x; - if (prev) - TYPE_FIELDS (t) = prev; - } -} - -tree -finish_struct (tree t, tree attributes) -{ - location_t saved_loc = input_location; - - /* Now that we've got all the field declarations, reverse everything - as necessary. */ - unreverse_member_declarations (t); - - cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); - - /* Nadger the current location so that diagnostics point to the start of - the struct, not the end. */ - input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t)); - - if (processing_template_decl) - { - tree x; - - finish_struct_methods (t); - TYPE_SIZE (t) = bitsize_zero_node; - TYPE_SIZE_UNIT (t) = size_zero_node; - - /* We need to emit an error message if this type was used as a parameter - and it is an abstract type, even if it is a template. We construct - a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into - account and we call complete_vars with this type, which will check - the PARM_DECLS. Note that while the type is being defined, - CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends - (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */ - CLASSTYPE_PURE_VIRTUALS (t) = NULL; - for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x)) - if (DECL_PURE_VIRTUAL_P (x)) - VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x); - complete_vars (t); - } - else - finish_struct_1 (t); - - input_location = saved_loc; - - TYPE_BEING_DEFINED (t) = 0; - - if (current_class_type) - popclass (); - else - error ("trying to finish struct, but kicked out due to previous parse errors"); - - if (processing_template_decl && at_function_scope_p ()) - add_stmt (build_min (TAG_DEFN, t)); - - return t; -} - -/* Return the dynamic type of INSTANCE, if known. - Used to determine whether the virtual function table is needed - or not. - - *NONNULL is set iff INSTANCE can be known to be nonnull, regardless - of our knowledge of its type. *NONNULL should be initialized - before this function is called. */ - -static tree -fixed_type_or_null (tree instance, int* nonnull, int* cdtorp) -{ - switch (TREE_CODE (instance)) - { - case INDIRECT_REF: - if (POINTER_TYPE_P (TREE_TYPE (instance))) - return NULL_TREE; - else - return fixed_type_or_null (TREE_OPERAND (instance, 0), - nonnull, cdtorp); - - case CALL_EXPR: - /* This is a call to a constructor, hence it's never zero. */ - if (TREE_HAS_CONSTRUCTOR (instance)) - { - if (nonnull) - *nonnull = 1; - return TREE_TYPE (instance); - } - return NULL_TREE; - - case SAVE_EXPR: - /* This is a call to a constructor, hence it's never zero. */ - if (TREE_HAS_CONSTRUCTOR (instance)) - { - if (nonnull) - *nonnull = 1; - return TREE_TYPE (instance); - } - return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); - - case PLUS_EXPR: - case MINUS_EXPR: - if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR) - return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); - if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST) - /* Propagate nonnull. */ - return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); - return NULL_TREE; - - case NOP_EXPR: - case CONVERT_EXPR: - return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); - - case ADDR_EXPR: - instance = TREE_OPERAND (instance, 0); - if (nonnull) - { - /* Just because we see an ADDR_EXPR doesn't mean we're dealing - with a real object -- given &p->f, p can still be null. */ - tree t = get_base_address (instance); - /* ??? Probably should check DECL_WEAK here. */ - if (t && DECL_P (t)) - *nonnull = 1; - } - return fixed_type_or_null (instance, nonnull, cdtorp); - - case COMPONENT_REF: - /* If this component is really a base class reference, then the field - itself isn't definitive. */ - if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1))) - return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp); - return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp); - - case VAR_DECL: - case FIELD_DECL: - if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE - && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance)))) - { - if (nonnull) - *nonnull = 1; - return TREE_TYPE (TREE_TYPE (instance)); - } - /* fall through... */ - case TARGET_EXPR: - case PARM_DECL: - case RESULT_DECL: - if (IS_AGGR_TYPE (TREE_TYPE (instance))) - { - if (nonnull) - *nonnull = 1; - return TREE_TYPE (instance); - } - else if (instance == current_class_ptr) - { - if (nonnull) - *nonnull = 1; - - /* if we're in a ctor or dtor, we know our type. */ - if (DECL_LANG_SPECIFIC (current_function_decl) - && (DECL_CONSTRUCTOR_P (current_function_decl) - || DECL_DESTRUCTOR_P (current_function_decl))) - { - if (cdtorp) - *cdtorp = 1; - return TREE_TYPE (TREE_TYPE (instance)); - } - } - else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE) - { - /* We only need one hash table because it is always left empty. */ - static htab_t ht; - if (!ht) - ht = htab_create (37, - htab_hash_pointer, - htab_eq_pointer, - /*htab_del=*/NULL); - - /* Reference variables should be references to objects. */ - if (nonnull) - *nonnull = 1; - - /* Enter the INSTANCE in a table to prevent recursion; a - variable's initializer may refer to the variable - itself. */ - if (TREE_CODE (instance) == VAR_DECL - && DECL_INITIAL (instance) - && !htab_find (ht, instance)) - { - tree type; - void **slot; - - slot = htab_find_slot (ht, instance, INSERT); - *slot = instance; - type = fixed_type_or_null (DECL_INITIAL (instance), - nonnull, cdtorp); - htab_remove_elt (ht, instance); - - return type; - } - } - return NULL_TREE; - - default: - return NULL_TREE; - } -} - -/* Return nonzero if the dynamic type of INSTANCE is known, and - equivalent to the static type. We also handle the case where - INSTANCE is really a pointer. Return negative if this is a - ctor/dtor. There the dynamic type is known, but this might not be - the most derived base of the original object, and hence virtual - bases may not be layed out according to this type. - - Used to determine whether the virtual function table is needed - or not. - - *NONNULL is set iff INSTANCE can be known to be nonnull, regardless - of our knowledge of its type. *NONNULL should be initialized - before this function is called. */ - -int -resolves_to_fixed_type_p (tree instance, int* nonnull) -{ - tree t = TREE_TYPE (instance); - int cdtorp = 0; - - tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp); - if (fixed == NULL_TREE) - return 0; - if (POINTER_TYPE_P (t)) - t = TREE_TYPE (t); - if (!same_type_ignoring_top_level_qualifiers_p (t, fixed)) - return 0; - return cdtorp ? -1 : 1; -} - - -void -init_class_processing (void) -{ - current_class_depth = 0; - current_class_stack_size = 10; - current_class_stack - = XNEWVEC (struct class_stack_node, current_class_stack_size); - local_classes = VEC_alloc (tree, gc, 8); - sizeof_biggest_empty_class = size_zero_node; - - ridpointers[(int) RID_PUBLIC] = access_public_node; - ridpointers[(int) RID_PRIVATE] = access_private_node; - ridpointers[(int) RID_PROTECTED] = access_protected_node; -} - -/* Restore the cached PREVIOUS_CLASS_LEVEL. */ - -static void -restore_class_cache (void) -{ - tree type; - - /* We are re-entering the same class we just left, so we don't - have to search the whole inheritance matrix to find all the - decls to bind again. Instead, we install the cached - class_shadowed list and walk through it binding names. */ - push_binding_level (previous_class_level); - class_binding_level = previous_class_level; - /* Restore IDENTIFIER_TYPE_VALUE. */ - for (type = class_binding_level->type_shadowed; - type; - type = TREE_CHAIN (type)) - SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type)); -} - -/* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as - appropriate for TYPE. - - So that we may avoid calls to lookup_name, we cache the _TYPE - nodes of local TYPE_DECLs in the TREE_TYPE field of the name. - - For multiple inheritance, we perform a two-pass depth-first search - of the type lattice. */ - -void -pushclass (tree type) -{ - class_stack_node_t csn; - - type = TYPE_MAIN_VARIANT (type); - - /* Make sure there is enough room for the new entry on the stack. */ - if (current_class_depth + 1 >= current_class_stack_size) - { - current_class_stack_size *= 2; - current_class_stack - = XRESIZEVEC (struct class_stack_node, current_class_stack, - current_class_stack_size); - } - - /* Insert a new entry on the class stack. */ - csn = current_class_stack + current_class_depth; - csn->name = current_class_name; - csn->type = current_class_type; - csn->access = current_access_specifier; - csn->names_used = 0; - csn->hidden = 0; - current_class_depth++; - - /* Now set up the new type. */ - current_class_name = TYPE_NAME (type); - if (TREE_CODE (current_class_name) == TYPE_DECL) - current_class_name = DECL_NAME (current_class_name); - current_class_type = type; - - /* By default, things in classes are private, while things in - structures or unions are public. */ - current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type) - ? access_private_node - : access_public_node); - - if (previous_class_level - && type != previous_class_level->this_entity - && current_class_depth == 1) - { - /* Forcibly remove any old class remnants. */ - invalidate_class_lookup_cache (); - } - - if (!previous_class_level - || type != previous_class_level->this_entity - || current_class_depth > 1) - pushlevel_class (); - else - restore_class_cache (); -} - -/* When we exit a toplevel class scope, we save its binding level so - that we can restore it quickly. Here, we've entered some other - class, so we must invalidate our cache. */ - -void -invalidate_class_lookup_cache (void) -{ - previous_class_level = NULL; -} - -/* Get out of the current class scope. If we were in a class scope - previously, that is the one popped to. */ - -void -popclass (void) -{ - poplevel_class (); - - current_class_depth--; - current_class_name = current_class_stack[current_class_depth].name; - current_class_type = current_class_stack[current_class_depth].type; - current_access_specifier = current_class_stack[current_class_depth].access; - if (current_class_stack[current_class_depth].names_used) - splay_tree_delete (current_class_stack[current_class_depth].names_used); -} - -/* Mark the top of the class stack as hidden. */ - -void -push_class_stack (void) -{ - if (current_class_depth) - ++current_class_stack[current_class_depth - 1].hidden; -} - -/* Mark the top of the class stack as un-hidden. */ - -void -pop_class_stack (void) -{ - if (current_class_depth) - --current_class_stack[current_class_depth - 1].hidden; -} - -/* Returns 1 if the class type currently being defined is either T or - a nested type of T. */ - -bool -currently_open_class (tree t) -{ - int i; - - /* We start looking from 1 because entry 0 is from global scope, - and has no type. */ - for (i = current_class_depth; i > 0; --i) - { - tree c; - if (i == current_class_depth) - c = current_class_type; - else - { - if (current_class_stack[i].hidden) - break; - c = current_class_stack[i].type; - } - if (!c) - continue; - if (same_type_p (c, t)) - return true; - } - return false; -} - -/* If either current_class_type or one of its enclosing classes are derived - from T, return the appropriate type. Used to determine how we found - something via unqualified lookup. */ - -tree -currently_open_derived_class (tree t) -{ - int i; - - /* The bases of a dependent type are unknown. */ - if (dependent_type_p (t)) - return NULL_TREE; - - if (!current_class_type) - return NULL_TREE; - - if (DERIVED_FROM_P (t, current_class_type)) - return current_class_type; - - for (i = current_class_depth - 1; i > 0; --i) - { - if (current_class_stack[i].hidden) - break; - if (DERIVED_FROM_P (t, current_class_stack[i].type)) - return current_class_stack[i].type; - } - - return NULL_TREE; -} - -/* When entering a class scope, all enclosing class scopes' names with - static meaning (static variables, static functions, types and - enumerators) have to be visible. This recursive function calls - pushclass for all enclosing class contexts until global or a local - scope is reached. TYPE is the enclosed class. */ - -void -push_nested_class (tree type) -{ - tree context; - - /* A namespace might be passed in error cases, like A::B:C. */ - if (type == NULL_TREE - || type == error_mark_node - || TREE_CODE (type) == NAMESPACE_DECL - || ! IS_AGGR_TYPE (type) - || TREE_CODE (type) == TEMPLATE_TYPE_PARM - || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM) - return; - - context = DECL_CONTEXT (TYPE_MAIN_DECL (type)); - - if (context && CLASS_TYPE_P (context)) - push_nested_class (context); - pushclass (type); -} - -/* Undoes a push_nested_class call. */ - -void -pop_nested_class (void) -{ - tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type)); - - popclass (); - if (context && CLASS_TYPE_P (context)) - pop_nested_class (); -} - -/* Returns the number of extern "LANG" blocks we are nested within. */ - -int -current_lang_depth (void) -{ - return VEC_length (tree, current_lang_base); -} - -/* Set global variables CURRENT_LANG_NAME to appropriate value - so that behavior of name-mangling machinery is correct. */ - -void -push_lang_context (tree name) -{ - VEC_safe_push (tree, gc, current_lang_base, current_lang_name); - - if (name == lang_name_cplusplus) - { - current_lang_name = name; - } - else if (name == lang_name_java) - { - current_lang_name = name; - /* DECL_IGNORED_P is initially set for these types, to avoid clutter. - (See record_builtin_java_type in decl.c.) However, that causes - incorrect debug entries if these types are actually used. - So we re-enable debug output after extern "Java". */ - DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0; - DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0; - } - else if (name == lang_name_c) - { - current_lang_name = name; - } - else - error ("language string %<\"%E\"%> not recognized", name); -} - -/* Get out of the current language scope. */ - -void -pop_lang_context (void) -{ - current_lang_name = VEC_pop (tree, current_lang_base); -} - -/* Type instantiation routines. */ - -/* Given an OVERLOAD and a TARGET_TYPE, return the function that - matches the TARGET_TYPE. If there is no satisfactory match, return - error_mark_node, and issue an error & warning messages under - control of FLAGS. Permit pointers to member function if FLAGS - permits. If TEMPLATE_ONLY, the name of the overloaded function was - a template-id, and EXPLICIT_TARGS are the explicitly provided - template arguments. If OVERLOAD is for one or more member - functions, then ACCESS_PATH is the base path used to reference - those member functions. */ - -static tree -resolve_address_of_overloaded_function (tree target_type, - tree overload, - tsubst_flags_t flags, - bool template_only, - tree explicit_targs, - tree access_path) -{ - /* Here's what the standard says: - - [over.over] - - If the name is a function template, template argument deduction - is done, and if the argument deduction succeeds, the deduced - arguments are used to generate a single template function, which - is added to the set of overloaded functions considered. - - Non-member functions and static member functions match targets of - type "pointer-to-function" or "reference-to-function." Nonstatic - member functions match targets of type "pointer-to-member - function;" the function type of the pointer to member is used to - select the member function from the set of overloaded member - functions. If a nonstatic member function is selected, the - reference to the overloaded function name is required to have the - form of a pointer to member as described in 5.3.1. - - If more than one function is selected, any template functions in - the set are eliminated if the set also contains a non-template - function, and any given template function is eliminated if the - set contains a second template function that is more specialized - than the first according to the partial ordering rules 14.5.5.2. - After such eliminations, if any, there shall remain exactly one - selected function. */ - - int is_ptrmem = 0; - int is_reference = 0; - /* We store the matches in a TREE_LIST rooted here. The functions - are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy - interoperability with most_specialized_instantiation. */ - tree matches = NULL_TREE; - tree fn; - - /* By the time we get here, we should be seeing only real - pointer-to-member types, not the internal POINTER_TYPE to - METHOD_TYPE representation. */ - gcc_assert (TREE_CODE (target_type) != POINTER_TYPE - || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE); - - gcc_assert (is_overloaded_fn (overload)); - - /* Check that the TARGET_TYPE is reasonable. */ - if (TYPE_PTRFN_P (target_type)) - /* This is OK. */; - else if (TYPE_PTRMEMFUNC_P (target_type)) - /* This is OK, too. */ - is_ptrmem = 1; - else if (TREE_CODE (target_type) == FUNCTION_TYPE) - { - /* This is OK, too. This comes from a conversion to reference - type. */ - target_type = build_reference_type (target_type); - is_reference = 1; - } - else - { - if (flags & tf_error) - error ("cannot resolve overloaded function %qD based on" - " conversion to type %qT", - DECL_NAME (OVL_FUNCTION (overload)), target_type); - return error_mark_node; - } - - /* If we can find a non-template function that matches, we can just - use it. There's no point in generating template instantiations - if we're just going to throw them out anyhow. But, of course, we - can only do this when we don't *need* a template function. */ - if (!template_only) - { - tree fns; - - for (fns = overload; fns; fns = OVL_NEXT (fns)) - { - tree fn = OVL_CURRENT (fns); - tree fntype; - - if (TREE_CODE (fn) == TEMPLATE_DECL) - /* We're not looking for templates just yet. */ - continue; - - if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) - != is_ptrmem) - /* We're looking for a non-static member, and this isn't - one, or vice versa. */ - continue; - - /* Ignore functions which haven't been explicitly - declared. */ - if (DECL_ANTICIPATED (fn)) - continue; - - /* See if there's a match. */ - fntype = TREE_TYPE (fn); - if (is_ptrmem) - fntype = build_ptrmemfunc_type (build_pointer_type (fntype)); - else if (!is_reference) - fntype = build_pointer_type (fntype); - - if (can_convert_arg (target_type, fntype, fn, LOOKUP_NORMAL)) - matches = tree_cons (fn, NULL_TREE, matches); - } - } - - /* Now, if we've already got a match (or matches), there's no need - to proceed to the template functions. But, if we don't have a - match we need to look at them, too. */ - if (!matches) - { - tree target_fn_type; - tree target_arg_types; - tree target_ret_type; - tree fns; - - if (is_ptrmem) - target_fn_type - = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type)); - else - target_fn_type = TREE_TYPE (target_type); - target_arg_types = TYPE_ARG_TYPES (target_fn_type); - target_ret_type = TREE_TYPE (target_fn_type); - - /* Never do unification on the 'this' parameter. */ - if (TREE_CODE (target_fn_type) == METHOD_TYPE) - target_arg_types = TREE_CHAIN (target_arg_types); - - for (fns = overload; fns; fns = OVL_NEXT (fns)) - { - tree fn = OVL_CURRENT (fns); - tree instantiation; - tree instantiation_type; - tree targs; - - if (TREE_CODE (fn) != TEMPLATE_DECL) - /* We're only looking for templates. */ - continue; - - if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) - != is_ptrmem) - /* We're not looking for a non-static member, and this is - one, or vice versa. */ - continue; - - /* Try to do argument deduction. */ - targs = make_tree_vec (DECL_NTPARMS (fn)); - if (fn_type_unification (fn, explicit_targs, targs, - target_arg_types, target_ret_type, - DEDUCE_EXACT, LOOKUP_NORMAL)) - /* Argument deduction failed. */ - continue; - - /* Instantiate the template. */ - instantiation = instantiate_template (fn, targs, flags); - if (instantiation == error_mark_node) - /* Instantiation failed. */ - continue; - - /* See if there's a match. */ - instantiation_type = TREE_TYPE (instantiation); - if (is_ptrmem) - instantiation_type = - build_ptrmemfunc_type (build_pointer_type (instantiation_type)); - else if (!is_reference) - instantiation_type = build_pointer_type (instantiation_type); - if (can_convert_arg (target_type, instantiation_type, instantiation, - LOOKUP_NORMAL)) - matches = tree_cons (instantiation, fn, matches); - } - - /* Now, remove all but the most specialized of the matches. */ - if (matches) - { - tree match = most_specialized_instantiation (matches); - - if (match != error_mark_node) - matches = tree_cons (TREE_PURPOSE (match), - NULL_TREE, - NULL_TREE); - } - } - - /* Now we should have exactly one function in MATCHES. */ - if (matches == NULL_TREE) - { - /* There were *no* matches. */ - if (flags & tf_error) - { - error ("no matches converting function %qD to type %q#T", - DECL_NAME (OVL_FUNCTION (overload)), - target_type); - - /* print_candidates expects a chain with the functions in - TREE_VALUE slots, so we cons one up here (we're losing anyway, - so why be clever?). */ - for (; overload; overload = OVL_NEXT (overload)) - matches = tree_cons (NULL_TREE, OVL_CURRENT (overload), - matches); - - print_candidates (matches); - } - return error_mark_node; - } - else if (TREE_CHAIN (matches)) - { - /* There were too many matches. */ - - if (flags & tf_error) - { - tree match; - - error ("converting overloaded function %qD to type %q#T is ambiguous", - DECL_NAME (OVL_FUNCTION (overload)), - target_type); - - /* Since print_candidates expects the functions in the - TREE_VALUE slot, we flip them here. */ - for (match = matches; match; match = TREE_CHAIN (match)) - TREE_VALUE (match) = TREE_PURPOSE (match); - - print_candidates (matches); - } - - return error_mark_node; - } - - /* Good, exactly one match. Now, convert it to the correct type. */ - fn = TREE_PURPOSE (matches); - - if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) - && !(flags & tf_ptrmem_ok) && !flag_ms_extensions) - { - static int explained; - - if (!(flags & tf_error)) - return error_mark_node; - - pedwarn ("assuming pointer to member %qD", fn); - if (!explained) - { - pedwarn ("(a pointer to member can only be formed with %<&%E%>)", fn); - explained = 1; - } - } - - /* If we're doing overload resolution purely for the purpose of - determining conversion sequences, we should not consider the - function used. If this conversion sequence is selected, the - function will be marked as used at this point. */ - if (!(flags & tf_conv)) - { - mark_used (fn); - /* We could not check access when this expression was originally - created since we did not know at that time to which function - the expression referred. */ - if (DECL_FUNCTION_MEMBER_P (fn)) - { - gcc_assert (access_path); - perform_or_defer_access_check (access_path, fn, fn); - } - } - - if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type)) - return build_unary_op (ADDR_EXPR, fn, 0); - else - { - /* The target must be a REFERENCE_TYPE. Above, build_unary_op - will mark the function as addressed, but here we must do it - explicitly. */ - cxx_mark_addressable (fn); - - return fn; - } -} - -/* This function will instantiate the type of the expression given in - RHS to match the type of LHSTYPE. If errors exist, then return - error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then - we complain on errors. If we are not complaining, never modify rhs, - as overload resolution wants to try many possible instantiations, in - the hope that at least one will work. - - For non-recursive calls, LHSTYPE should be a function, pointer to - function, or a pointer to member function. */ - -tree -instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) -{ - tsubst_flags_t flags_in = flags; - tree access_path = NULL_TREE; - - flags &= ~tf_ptrmem_ok; - - if (TREE_CODE (lhstype) == UNKNOWN_TYPE) - { - if (flags & tf_error) - error ("not enough type information"); - return error_mark_node; - } - - if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs))) - { - if (same_type_p (lhstype, TREE_TYPE (rhs))) - return rhs; - if (flag_ms_extensions - && TYPE_PTRMEMFUNC_P (lhstype) - && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs))) - /* Microsoft allows `A::f' to be resolved to a - pointer-to-member. */ - ; - else - { - if (flags & tf_error) - error ("argument of type %qT does not match %qT", - TREE_TYPE (rhs), lhstype); - return error_mark_node; - } - } - - if (TREE_CODE (rhs) == BASELINK) - { - access_path = BASELINK_ACCESS_BINFO (rhs); - rhs = BASELINK_FUNCTIONS (rhs); - } - - /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot - deduce any type information. */ - if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR) - { - if (flags & tf_error) - error ("not enough type information"); - return error_mark_node; - } - - /* There only a few kinds of expressions that may have a type - dependent on overload resolution. */ - gcc_assert (TREE_CODE (rhs) == ADDR_EXPR - || TREE_CODE (rhs) == COMPONENT_REF - || TREE_CODE (rhs) == COMPOUND_EXPR - || really_overloaded_fn (rhs)); - - /* We don't overwrite rhs if it is an overloaded function. - Copying it would destroy the tree link. */ - if (TREE_CODE (rhs) != OVERLOAD) - rhs = copy_node (rhs); - - /* This should really only be used when attempting to distinguish - what sort of a pointer to function we have. For now, any - arithmetic operation which is not supported on pointers - is rejected as an error. */ - - switch (TREE_CODE (rhs)) - { - case COMPONENT_REF: - { - tree member = TREE_OPERAND (rhs, 1); - - member = instantiate_type (lhstype, member, flags); - if (member != error_mark_node - && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0))) - /* Do not lose object's side effects. */ - return build2 (COMPOUND_EXPR, TREE_TYPE (member), - TREE_OPERAND (rhs, 0), member); - return member; - } - - case OFFSET_REF: - rhs = TREE_OPERAND (rhs, 1); - if (BASELINK_P (rhs)) - return instantiate_type (lhstype, rhs, flags_in); - - /* This can happen if we are forming a pointer-to-member for a - member template. */ - gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR); - - /* Fall through. */ - - case TEMPLATE_ID_EXPR: - { - tree fns = TREE_OPERAND (rhs, 0); - tree args = TREE_OPERAND (rhs, 1); - - return - resolve_address_of_overloaded_function (lhstype, fns, flags_in, - /*template_only=*/true, - args, access_path); - } - - case OVERLOAD: - case FUNCTION_DECL: - return - resolve_address_of_overloaded_function (lhstype, rhs, flags_in, - /*template_only=*/false, - /*explicit_targs=*/NULL_TREE, - access_path); - - case COMPOUND_EXPR: - TREE_OPERAND (rhs, 0) - = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags); - if (TREE_OPERAND (rhs, 0) == error_mark_node) - return error_mark_node; - TREE_OPERAND (rhs, 1) - = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags); - if (TREE_OPERAND (rhs, 1) == error_mark_node) - return error_mark_node; - - TREE_TYPE (rhs) = lhstype; - return rhs; - - case ADDR_EXPR: - { - if (PTRMEM_OK_P (rhs)) - flags |= tf_ptrmem_ok; - - return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags); - } - - case ERROR_MARK: - return error_mark_node; - - default: - gcc_unreachable (); - } - return error_mark_node; -} - -/* Return the name of the virtual function pointer field - (as an IDENTIFIER_NODE) for the given TYPE. Note that - this may have to look back through base types to find the - ultimate field name. (For single inheritance, these could - all be the same name. Who knows for multiple inheritance). */ - -static tree -get_vfield_name (tree type) -{ - tree binfo, base_binfo; - char *buf; - - for (binfo = TYPE_BINFO (type); - BINFO_N_BASE_BINFOS (binfo); - binfo = base_binfo) - { - base_binfo = BINFO_BASE_BINFO (binfo, 0); - - if (BINFO_VIRTUAL_P (base_binfo) - || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo))) - break; - } - - type = BINFO_TYPE (binfo); - buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT) - + TYPE_NAME_LENGTH (type) + 2); - sprintf (buf, VFIELD_NAME_FORMAT, - IDENTIFIER_POINTER (constructor_name (type))); - return get_identifier (buf); -} - -void -print_class_statistics (void) -{ -#ifdef GATHER_STATISTICS - fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness); - fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs); - if (n_vtables) - { - fprintf (stderr, "vtables = %d; vtable searches = %d\n", - n_vtables, n_vtable_searches); - fprintf (stderr, "vtable entries = %d; vtable elems = %d\n", - n_vtable_entries, n_vtable_elems); - } -#endif -} - -/* Build a dummy reference to ourselves so Derived::Base (and A::A) works, - according to [class]: - The class-name is also inserted - into the scope of the class itself. For purposes of access checking, - the inserted class name is treated as if it were a public member name. */ - -void -build_self_reference (void) -{ - tree name = constructor_name (current_class_type); - tree value = build_lang_decl (TYPE_DECL, name, current_class_type); - tree saved_cas; - - DECL_NONLOCAL (value) = 1; - DECL_CONTEXT (value) = current_class_type; - DECL_ARTIFICIAL (value) = 1; - SET_DECL_SELF_REFERENCE_P (value); - - if (processing_template_decl) - value = push_template_decl (value); - - saved_cas = current_access_specifier; - current_access_specifier = access_public_node; - finish_member_declaration (value); - current_access_specifier = saved_cas; -} - -/* Returns 1 if TYPE contains only padding bytes. */ - -int -is_empty_class (tree type) -{ - if (type == error_mark_node) - return 0; - - if (! IS_AGGR_TYPE (type)) - return 0; - - /* In G++ 3.2, whether or not a class was empty was determined by - looking at its size. */ - if (abi_version_at_least (2)) - return CLASSTYPE_EMPTY_P (type); - else - return integer_zerop (CLASSTYPE_SIZE (type)); -} - -/* Returns true if TYPE contains an empty class. */ - -static bool -contains_empty_class_p (tree type) -{ - if (is_empty_class (type)) - return true; - if (CLASS_TYPE_P (type)) - { - tree field; - tree binfo; - tree base_binfo; - int i; - - for (binfo = TYPE_BINFO (type), i = 0; - BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - if (contains_empty_class_p (BINFO_TYPE (base_binfo))) - return true; - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) - if (TREE_CODE (field) == FIELD_DECL - && !DECL_ARTIFICIAL (field) - && is_empty_class (TREE_TYPE (field))) - return true; - } - else if (TREE_CODE (type) == ARRAY_TYPE) - return contains_empty_class_p (TREE_TYPE (type)); - return false; -} - -/* Note that NAME was looked up while the current class was being - defined and that the result of that lookup was DECL. */ - -void -maybe_note_name_used_in_class (tree name, tree decl) -{ - splay_tree names_used; - - /* If we're not defining a class, there's nothing to do. */ - if (!(innermost_scope_kind() == sk_class - && TYPE_BEING_DEFINED (current_class_type))) - return; - - /* If there's already a binding for this NAME, then we don't have - anything to worry about. */ - if (lookup_member (current_class_type, name, - /*protect=*/0, /*want_type=*/false)) - return; - - if (!current_class_stack[current_class_depth - 1].names_used) - current_class_stack[current_class_depth - 1].names_used - = splay_tree_new (splay_tree_compare_pointers, 0, 0); - names_used = current_class_stack[current_class_depth - 1].names_used; - - splay_tree_insert (names_used, - (splay_tree_key) name, - (splay_tree_value) decl); -} - -/* Note that NAME was declared (as DECL) in the current class. Check - to see that the declaration is valid. */ - -void -note_name_declared_in_class (tree name, tree decl) -{ - splay_tree names_used; - splay_tree_node n; - - /* Look to see if we ever used this name. */ - names_used - = current_class_stack[current_class_depth - 1].names_used; - if (!names_used) - return; - - n = splay_tree_lookup (names_used, (splay_tree_key) name); - if (n) - { - /* [basic.scope.class] - - A name N used in a class S shall refer to the same declaration - in its context and when re-evaluated in the completed scope of - S. */ - error ("declaration of %q#D", decl); - error ("changes meaning of %qD from %q+#D", - DECL_NAME (OVL_CURRENT (decl)), (tree) n->value); - } -} - -/* Returns the VAR_DECL for the complete vtable associated with BINFO. - Secondary vtables are merged with primary vtables; this function - will return the VAR_DECL for the primary vtable. */ - -tree -get_vtbl_decl_for_binfo (tree binfo) -{ - tree decl; - - decl = BINFO_VTABLE (binfo); - if (decl && TREE_CODE (decl) == PLUS_EXPR) - { - gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR); - decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0); - } - if (decl) - gcc_assert (TREE_CODE (decl) == VAR_DECL); - return decl; -} - - -/* Returns the binfo for the primary base of BINFO. If the resulting - BINFO is a virtual base, and it is inherited elsewhere in the - hierarchy, then the returned binfo might not be the primary base of - BINFO in the complete object. Check BINFO_PRIMARY_P or - BINFO_LOST_PRIMARY_P to be sure. */ - -static tree -get_primary_binfo (tree binfo) -{ - tree primary_base; - - primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo)); - if (!primary_base) - return NULL_TREE; - - return copied_binfo (primary_base, binfo); -} - -/* If INDENTED_P is zero, indent to INDENT. Return nonzero. */ - -static int -maybe_indent_hierarchy (FILE * stream, int indent, int indented_p) -{ - if (!indented_p) - fprintf (stream, "%*s", indent, ""); - return 1; -} - -/* Dump the offsets of all the bases rooted at BINFO to STREAM. - INDENT should be zero when called from the top level; it is - incremented recursively. IGO indicates the next expected BINFO in - inheritance graph ordering. */ - -static tree -dump_class_hierarchy_r (FILE *stream, - int flags, - tree binfo, - tree igo, - int indent) -{ - int indented = 0; - tree base_binfo; - int i; - - indented = maybe_indent_hierarchy (stream, indent, 0); - fprintf (stream, "%s (0x%lx) ", - type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER), - (unsigned long) binfo); - if (binfo != igo) - { - fprintf (stream, "alternative-path\n"); - return igo; - } - igo = TREE_CHAIN (binfo); - - fprintf (stream, HOST_WIDE_INT_PRINT_DEC, - tree_low_cst (BINFO_OFFSET (binfo), 0)); - if (is_empty_class (BINFO_TYPE (binfo))) - fprintf (stream, " empty"); - else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo))) - fprintf (stream, " nearly-empty"); - if (BINFO_VIRTUAL_P (binfo)) - fprintf (stream, " virtual"); - fprintf (stream, "\n"); - - indented = 0; - if (BINFO_PRIMARY_P (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " primary-for %s (0x%lx)", - type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)), - TFF_PLAIN_IDENTIFIER), - (unsigned long)BINFO_INHERITANCE_CHAIN (binfo)); - } - if (BINFO_LOST_PRIMARY_P (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " lost-primary"); - } - if (indented) - fprintf (stream, "\n"); - - if (!(flags & TDF_SLIM)) - { - int indented = 0; - - if (BINFO_SUBVTT_INDEX (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " subvttidx=%s", - expr_as_string (BINFO_SUBVTT_INDEX (binfo), - TFF_PLAIN_IDENTIFIER)); - } - if (BINFO_VPTR_INDEX (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " vptridx=%s", - expr_as_string (BINFO_VPTR_INDEX (binfo), - TFF_PLAIN_IDENTIFIER)); - } - if (BINFO_VPTR_FIELD (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " vbaseoffset=%s", - expr_as_string (BINFO_VPTR_FIELD (binfo), - TFF_PLAIN_IDENTIFIER)); - } - if (BINFO_VTABLE (binfo)) - { - indented = maybe_indent_hierarchy (stream, indent + 3, indented); - fprintf (stream, " vptr=%s", - expr_as_string (BINFO_VTABLE (binfo), - TFF_PLAIN_IDENTIFIER)); - } - - if (indented) - fprintf (stream, "\n"); - } - - for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) - igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2); - - return igo; -} - -/* Dump the BINFO hierarchy for T. */ - -static void -dump_class_hierarchy_1 (FILE *stream, int flags, tree t) -{ - fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER)); - fprintf (stream, " size=%lu align=%lu\n", - (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT), - (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT)); - fprintf (stream, " base size=%lu base align=%lu\n", - (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0) - / BITS_PER_UNIT), - (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t)) - / BITS_PER_UNIT)); - dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0); - fprintf (stream, "\n"); -} - -/* Debug interface to hierarchy dumping. */ - -void -debug_class (tree t) -{ - dump_class_hierarchy_1 (stderr, TDF_SLIM, t); -} - -static void -dump_class_hierarchy (tree t) -{ - int flags; - FILE *stream = dump_begin (TDI_class, &flags); - - if (stream) - { - dump_class_hierarchy_1 (stream, flags, t); - dump_end (TDI_class, stream); - } -} - -static void -dump_array (FILE * stream, tree decl) -{ - tree value; - unsigned HOST_WIDE_INT ix; - HOST_WIDE_INT elt; - tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl))); - - elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0) - / BITS_PER_UNIT); - fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER)); - fprintf (stream, " %s entries", - expr_as_string (size_binop (PLUS_EXPR, size, size_one_node), - TFF_PLAIN_IDENTIFIER)); - fprintf (stream, "\n"); - - FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)), - ix, value) - fprintf (stream, "%-4ld %s\n", (long)(ix * elt), - expr_as_string (value, TFF_PLAIN_IDENTIFIER)); -} - -static void -dump_vtable (tree t, tree binfo, tree vtable) -{ - int flags; - FILE *stream = dump_begin (TDI_class, &flags); - - if (!stream) - return; - - if (!(flags & TDF_SLIM)) - { - int ctor_vtbl_p = TYPE_BINFO (t) != binfo; - - fprintf (stream, "%s for %s", - ctor_vtbl_p ? "Construction vtable" : "Vtable", - type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER)); - if (ctor_vtbl_p) - { - if (!BINFO_VIRTUAL_P (binfo)) - fprintf (stream, " (0x%lx instance)", (unsigned long)binfo); - fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER)); - } - fprintf (stream, "\n"); - dump_array (stream, vtable); - fprintf (stream, "\n"); - } - - dump_end (TDI_class, stream); -} - -static void -dump_vtt (tree t, tree vtt) -{ - int flags; - FILE *stream = dump_begin (TDI_class, &flags); - - if (!stream) - return; - - if (!(flags & TDF_SLIM)) - { - fprintf (stream, "VTT for %s\n", - type_as_string (t, TFF_PLAIN_IDENTIFIER)); - dump_array (stream, vtt); - fprintf (stream, "\n"); - } - - dump_end (TDI_class, stream); -} - -/* Dump a function or thunk and its thunkees. */ - -static void -dump_thunk (FILE *stream, int indent, tree thunk) -{ - static const char spaces[] = " "; - tree name = DECL_NAME (thunk); - tree thunks; - - fprintf (stream, "%.*s%p %s %s", indent, spaces, - (void *)thunk, - !DECL_THUNK_P (thunk) ? "function" - : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk", - name ? IDENTIFIER_POINTER (name) : "<unset>"); - if (DECL_THUNK_P (thunk)) - { - HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk); - tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk); - - fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust); - if (!virtual_adjust) - /*NOP*/; - else if (DECL_THIS_THUNK_P (thunk)) - fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC, - tree_low_cst (virtual_adjust, 0)); - else - fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)", - tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0), - type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE)); - if (THUNK_ALIAS (thunk)) - fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk)); - } - fprintf (stream, "\n"); - for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks)) - dump_thunk (stream, indent + 2, thunks); -} - -/* Dump the thunks for FN. */ - -void -debug_thunks (tree fn) -{ - dump_thunk (stderr, 0, fn); -} - -/* Virtual function table initialization. */ - -/* Create all the necessary vtables for T and its base classes. */ - -static void -finish_vtbls (tree t) -{ - tree list; - tree vbase; - - /* We lay out the primary and secondary vtables in one contiguous - vtable. The primary vtable is first, followed by the non-virtual - secondary vtables in inheritance graph order. */ - list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE); - accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), - TYPE_BINFO (t), t, list); - - /* Then come the virtual bases, also in inheritance graph order. */ - for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) - { - if (!BINFO_VIRTUAL_P (vbase)) - continue; - accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list); - } - - if (BINFO_VTABLE (TYPE_BINFO (t))) - initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list)); -} - -/* Initialize the vtable for BINFO with the INITS. */ - -static void -initialize_vtable (tree binfo, tree inits) -{ - tree decl; - - layout_vtable_decl (binfo, list_length (inits)); - decl = get_vtbl_decl_for_binfo (binfo); - initialize_artificial_var (decl, inits); - dump_vtable (BINFO_TYPE (binfo), binfo, decl); -} - -/* Build the VTT (virtual table table) for T. - A class requires a VTT if it has virtual bases. - - This holds - 1 - primary virtual pointer for complete object T - 2 - secondary VTTs for each direct non-virtual base of T which requires a - VTT - 3 - secondary virtual pointers for each direct or indirect base of T which - has virtual bases or is reachable via a virtual path from T. - 4 - secondary VTTs for each direct or indirect virtual base of T. - - Secondary VTTs look like complete object VTTs without part 4. */ - -static void -build_vtt (tree t) -{ - tree inits; - tree type; - tree vtt; - tree index; - - /* Build up the initializers for the VTT. */ - inits = NULL_TREE; - index = size_zero_node; - build_vtt_inits (TYPE_BINFO (t), t, &inits, &index); - - /* If we didn't need a VTT, we're done. */ - if (!inits) - return; - - /* Figure out the type of the VTT. */ - type = build_index_type (size_int (list_length (inits) - 1)); - type = build_cplus_array_type (const_ptr_type_node, type); - - /* Now, build the VTT object itself. */ - vtt = build_vtable (t, mangle_vtt_for_type (t), type); - initialize_artificial_var (vtt, inits); - /* Add the VTT to the vtables list. */ - TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t)); - TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt; - - dump_vtt (t, vtt); -} - -/* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with - PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo, - and CHAIN the vtable pointer for this binfo after construction is - complete. VALUE can also be another BINFO, in which case we recurse. */ - -static tree -binfo_ctor_vtable (tree binfo) -{ - tree vt; - - while (1) - { - vt = BINFO_VTABLE (binfo); - if (TREE_CODE (vt) == TREE_LIST) - vt = TREE_VALUE (vt); - if (TREE_CODE (vt) == TREE_BINFO) - binfo = vt; - else - break; - } - - return vt; -} - -/* Data for secondary VTT initialization. */ -typedef struct secondary_vptr_vtt_init_data_s -{ - /* Is this the primary VTT? */ - bool top_level_p; - - /* Current index into the VTT. */ - tree index; - - /* TREE_LIST of initializers built up. */ - tree inits; - - /* The type being constructed by this secondary VTT. */ - tree type_being_constructed; -} secondary_vptr_vtt_init_data; - -/* Recursively build the VTT-initializer for BINFO (which is in the - hierarchy dominated by T). INITS points to the end of the initializer - list to date. INDEX is the VTT index where the next element will be - replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e. - not a subvtt for some base of T). When that is so, we emit the sub-VTTs - for virtual bases of T. When it is not so, we build the constructor - vtables for the BINFO-in-T variant. */ - -static tree * -build_vtt_inits (tree binfo, tree t, tree *inits, tree *index) -{ - int i; - tree b; - tree init; - tree secondary_vptrs; - secondary_vptr_vtt_init_data data; - int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t); - - /* We only need VTTs for subobjects with virtual bases. */ - if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))) - return inits; - - /* We need to use a construction vtable if this is not the primary - VTT. */ - if (!top_level_p) - { - build_ctor_vtbl_group (binfo, t); - - /* Record the offset in the VTT where this sub-VTT can be found. */ - BINFO_SUBVTT_INDEX (binfo) = *index; - } - - /* Add the address of the primary vtable for the complete object. */ - init = binfo_ctor_vtable (binfo); - *inits = build_tree_list (NULL_TREE, init); - inits = &TREE_CHAIN (*inits); - if (top_level_p) - { - gcc_assert (!BINFO_VPTR_INDEX (binfo)); - BINFO_VPTR_INDEX (binfo) = *index; - } - *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node)); - - /* Recursively add the secondary VTTs for non-virtual bases. */ - for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i) - if (!BINFO_VIRTUAL_P (b)) - inits = build_vtt_inits (b, t, inits, index); - - /* Add secondary virtual pointers for all subobjects of BINFO with - either virtual bases or reachable along a virtual path, except - subobjects that are non-virtual primary bases. */ - data.top_level_p = top_level_p; - data.index = *index; - data.inits = NULL; - data.type_being_constructed = BINFO_TYPE (binfo); - - dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data); - - *index = data.index; - - /* The secondary vptrs come back in reverse order. After we reverse - them, and add the INITS, the last init will be the first element - of the chain. */ - secondary_vptrs = data.inits; - if (secondary_vptrs) - { - *inits = nreverse (secondary_vptrs); - inits = &TREE_CHAIN (secondary_vptrs); - gcc_assert (*inits == NULL_TREE); - } - - if (top_level_p) - /* Add the secondary VTTs for virtual bases in inheritance graph - order. */ - for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b)) - { - if (!BINFO_VIRTUAL_P (b)) - continue; - - inits = build_vtt_inits (b, t, inits, index); - } - else - /* Remove the ctor vtables we created. */ - dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo); - - return inits; -} - -/* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base - in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */ - -static tree -dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_) -{ - secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_; - - /* We don't care about bases that don't have vtables. */ - if (!TYPE_VFIELD (BINFO_TYPE (binfo))) - return dfs_skip_bases; - - /* We're only interested in proper subobjects of the type being - constructed. */ - if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed)) - return NULL_TREE; - - /* We're only interested in bases with virtual bases or reachable - via a virtual path from the type being constructed. */ - if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)) - || binfo_via_virtual (binfo, data->type_being_constructed))) - return dfs_skip_bases; - - /* We're not interested in non-virtual primary bases. */ - if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo)) - return NULL_TREE; - - /* Record the index where this secondary vptr can be found. */ - if (data->top_level_p) - { - gcc_assert (!BINFO_VPTR_INDEX (binfo)); - BINFO_VPTR_INDEX (binfo) = data->index; - - if (BINFO_VIRTUAL_P (binfo)) - { - /* It's a primary virtual base, and this is not a - construction vtable. Find the base this is primary of in - the inheritance graph, and use that base's vtable - now. */ - while (BINFO_PRIMARY_P (binfo)) - binfo = BINFO_INHERITANCE_CHAIN (binfo); - } - } - - /* Add the initializer for the secondary vptr itself. */ - data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits); - - /* Advance the vtt index. */ - data->index = size_binop (PLUS_EXPR, data->index, - TYPE_SIZE_UNIT (ptr_type_node)); - - return NULL_TREE; -} - -/* Called from build_vtt_inits via dfs_walk. After building - constructor vtables and generating the sub-vtt from them, we need - to restore the BINFO_VTABLES that were scribbled on. DATA is the - binfo of the base whose sub vtt was generated. */ - -static tree -dfs_fixup_binfo_vtbls (tree binfo, void* data) -{ - tree vtable = BINFO_VTABLE (binfo); - - if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) - /* If this class has no vtable, none of its bases do. */ - return dfs_skip_bases; - - if (!vtable) - /* This might be a primary base, so have no vtable in this - hierarchy. */ - return NULL_TREE; - - /* If we scribbled the construction vtable vptr into BINFO, clear it - out now. */ - if (TREE_CODE (vtable) == TREE_LIST - && (TREE_PURPOSE (vtable) == (tree) data)) - BINFO_VTABLE (binfo) = TREE_CHAIN (vtable); - - return NULL_TREE; -} - -/* Build the construction vtable group for BINFO which is in the - hierarchy dominated by T. */ - -static void -build_ctor_vtbl_group (tree binfo, tree t) -{ - tree list; - tree type; - tree vtbl; - tree inits; - tree id; - tree vbase; - - /* See if we've already created this construction vtable group. */ - id = mangle_ctor_vtbl_for_type (t, binfo); - if (IDENTIFIER_GLOBAL_VALUE (id)) - return; - - gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)); - /* Build a version of VTBL (with the wrong type) for use in - constructing the addresses of secondary vtables in the - construction vtable group. */ - vtbl = build_vtable (t, id, ptr_type_node); - DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1; - list = build_tree_list (vtbl, NULL_TREE); - accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)), - binfo, t, list); - - /* Add the vtables for each of our virtual bases using the vbase in T - binfo. */ - for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); - vbase; - vbase = TREE_CHAIN (vbase)) - { - tree b; - - if (!BINFO_VIRTUAL_P (vbase)) - continue; - b = copied_binfo (vbase, binfo); - - accumulate_vtbl_inits (b, vbase, binfo, t, list); - } - inits = TREE_VALUE (list); - - /* Figure out the type of the construction vtable. */ - type = build_index_type (size_int (list_length (inits) - 1)); - type = build_cplus_array_type (vtable_entry_type, type); - TREE_TYPE (vtbl) = type; - - /* Initialize the construction vtable. */ - CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl); - initialize_artificial_var (vtbl, inits); - dump_vtable (t, binfo, vtbl); -} - -/* Add the vtbl initializers for BINFO (and its bases other than - non-virtual primaries) to the list of INITS. BINFO is in the - hierarchy dominated by T. RTTI_BINFO is the binfo within T of - the constructor the vtbl inits should be accumulated for. (If this - is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).) - ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO). - BINFO is the active base equivalent of ORIG_BINFO in the inheritance - graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE, - but are not necessarily the same in terms of layout. */ - -static void -accumulate_vtbl_inits (tree binfo, - tree orig_binfo, - tree rtti_binfo, - tree t, - tree inits) -{ - int i; - tree base_binfo; - int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); - - gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo))); - - /* If it doesn't have a vptr, we don't do anything. */ - if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) - return; - - /* If we're building a construction vtable, we're not interested in - subobjects that don't require construction vtables. */ - if (ctor_vtbl_p - && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)) - && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo))) - return; - - /* Build the initializers for the BINFO-in-T vtable. */ - TREE_VALUE (inits) - = chainon (TREE_VALUE (inits), - dfs_accumulate_vtbl_inits (binfo, orig_binfo, - rtti_binfo, t, inits)); - - /* Walk the BINFO and its bases. We walk in preorder so that as we - initialize each vtable we can figure out at what offset the - secondary vtable lies from the primary vtable. We can't use - dfs_walk here because we need to iterate through bases of BINFO - and RTTI_BINFO simultaneously. */ - for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - { - /* Skip virtual bases. */ - if (BINFO_VIRTUAL_P (base_binfo)) - continue; - accumulate_vtbl_inits (base_binfo, - BINFO_BASE_BINFO (orig_binfo, i), - rtti_binfo, t, - inits); - } -} - -/* Called from accumulate_vtbl_inits. Returns the initializers for - the BINFO vtable. */ - -static tree -dfs_accumulate_vtbl_inits (tree binfo, - tree orig_binfo, - tree rtti_binfo, - tree t, - tree l) -{ - tree inits = NULL_TREE; - tree vtbl = NULL_TREE; - int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); - - if (ctor_vtbl_p - && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo)) - { - /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a - primary virtual base. If it is not the same primary in - the hierarchy of T, we'll need to generate a ctor vtable - for it, to place at its location in T. If it is the same - primary, we still need a VTT entry for the vtable, but it - should point to the ctor vtable for the base it is a - primary for within the sub-hierarchy of RTTI_BINFO. - - There are three possible cases: - - 1) We are in the same place. - 2) We are a primary base within a lost primary virtual base of - RTTI_BINFO. - 3) We are primary to something not a base of RTTI_BINFO. */ - - tree b; - tree last = NULL_TREE; - - /* First, look through the bases we are primary to for RTTI_BINFO - or a virtual base. */ - b = binfo; - while (BINFO_PRIMARY_P (b)) - { - b = BINFO_INHERITANCE_CHAIN (b); - last = b; - if (BINFO_VIRTUAL_P (b) || b == rtti_binfo) - goto found; - } - /* If we run out of primary links, keep looking down our - inheritance chain; we might be an indirect primary. */ - for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b)) - if (BINFO_VIRTUAL_P (b) || b == rtti_binfo) - break; - found: - - /* If we found RTTI_BINFO, this is case 1. If we found a virtual - base B and it is a base of RTTI_BINFO, this is case 2. In - either case, we share our vtable with LAST, i.e. the - derived-most base within B of which we are a primary. */ - if (b == rtti_binfo - || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo)))) - /* Just set our BINFO_VTABLE to point to LAST, as we may not have - set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in - binfo_ctor_vtable after everything's been set up. */ - vtbl = last; - - /* Otherwise, this is case 3 and we get our own. */ - } - else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo)) - return inits; - - if (!vtbl) - { - tree index; - int non_fn_entries; - - /* Compute the initializer for this vtable. */ - inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo, - &non_fn_entries); - - /* Figure out the position to which the VPTR should point. */ - vtbl = TREE_PURPOSE (l); - vtbl = build_address (vtbl); - /* ??? We should call fold_convert to convert the address to - vtbl_ptr_type_node, which is the type of elements in the - vtable. However, the resulting NOP_EXPRs confuse other parts - of the C++ front end. */ - gcc_assert (TREE_CODE (vtbl) == ADDR_EXPR); - TREE_TYPE (vtbl) = vtbl_ptr_type_node; - index = size_binop (PLUS_EXPR, - size_int (non_fn_entries), - size_int (list_length (TREE_VALUE (l)))); - index = size_binop (MULT_EXPR, - TYPE_SIZE_UNIT (vtable_entry_type), - index); - /* APPLE LOCAL begin KEXT double destructor */ -#ifdef VPTR_INITIALIZER_ADJUSTMENT - /* Subtract VPTR_INITIALIZER_ADJUSTMENT from INDEX. */ - if (TARGET_KEXTABI == 1 && !ctor_vtbl_p && ! BINFO_PRIMARY_P (binfo) - && TREE_CODE (index) == INTEGER_CST - && TREE_INT_CST_LOW (index) >= VPTR_INITIALIZER_ADJUSTMENT - && TREE_INT_CST_HIGH (index) == 0) - index = fold (build2 (MINUS_EXPR, - TREE_TYPE (index), index, - size_int (VPTR_INITIALIZER_ADJUSTMENT))); -#endif - /* APPLE LOCAL end KEXT double destructor */ - - vtbl = build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index); - } - - if (ctor_vtbl_p) - /* For a construction vtable, we can't overwrite BINFO_VTABLE. - So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will - straighten this out. */ - BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo)); - else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo)) - inits = NULL_TREE; - else - /* For an ordinary vtable, set BINFO_VTABLE. */ - BINFO_VTABLE (binfo) = vtbl; - - return inits; -} - -static GTY(()) tree abort_fndecl_addr; - -/* Construct the initializer for BINFO's virtual function table. BINFO - is part of the hierarchy dominated by T. If we're building a - construction vtable, the ORIG_BINFO is the binfo we should use to - find the actual function pointers to put in the vtable - but they - can be overridden on the path to most-derived in the graph that - ORIG_BINFO belongs. Otherwise, - ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the - BINFO that should be indicated by the RTTI information in the - vtable; it will be a base class of T, rather than T itself, if we - are building a construction vtable. - - The value returned is a TREE_LIST suitable for wrapping in a - CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If - NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the - number of non-function entries in the vtable. - - It might seem that this function should never be called with a - BINFO for which BINFO_PRIMARY_P holds, the vtable for such a - base is always subsumed by a derived class vtable. However, when - we are building construction vtables, we do build vtables for - primary bases; we need these while the primary base is being - constructed. */ - -static tree -build_vtbl_initializer (tree binfo, - tree orig_binfo, - tree t, - tree rtti_binfo, - int* non_fn_entries_p) -{ - tree v, b; - tree vfun_inits; - vtbl_init_data vid; - unsigned ix; - tree vbinfo; - VEC(tree,gc) *vbases; - - /* Initialize VID. */ - memset (&vid, 0, sizeof (vid)); - vid.binfo = binfo; - vid.derived = t; - vid.rtti_binfo = rtti_binfo; - vid.last_init = &vid.inits; - vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t); - vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); - vid.generate_vcall_entries = true; - /* The first vbase or vcall offset is at index -3 in the vtable. */ - vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); - - /* Add entries to the vtable for RTTI. */ - build_rtti_vtbl_entries (binfo, &vid); - - /* Create an array for keeping track of the functions we've - processed. When we see multiple functions with the same - signature, we share the vcall offsets. */ - vid.fns = VEC_alloc (tree, gc, 32); - /* Add the vcall and vbase offset entries. */ - build_vcall_and_vbase_vtbl_entries (binfo, &vid); - - /* Clear BINFO_VTABLE_PATH_MARKED; it's set by - build_vbase_offset_vtbl_entries. */ - for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0; - VEC_iterate (tree, vbases, ix, vbinfo); ix++) - BINFO_VTABLE_PATH_MARKED (vbinfo) = 0; - - /* If the target requires padding between data entries, add that now. */ - if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1) - { - tree cur, *prev; - - for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur)) - { - tree add = cur; - int i; - - for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i) - add = tree_cons (NULL_TREE, - build1 (NOP_EXPR, vtable_entry_type, - null_pointer_node), - add); - *prev = add; - } - } - - if (non_fn_entries_p) - *non_fn_entries_p = list_length (vid.inits); - - /* Go through all the ordinary virtual functions, building up - initializers. */ - vfun_inits = NULL_TREE; - for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v)) - { - tree delta; - tree vcall_index; - tree fn, fn_original; - tree init = NULL_TREE; - - fn = BV_FN (v); - fn_original = fn; - if (DECL_THUNK_P (fn)) - { - if (!DECL_NAME (fn)) - finish_thunk (fn); - if (THUNK_ALIAS (fn)) - { - fn = THUNK_ALIAS (fn); - BV_FN (v) = fn; - } - fn_original = THUNK_TARGET (fn); - } - - /* If the only definition of this function signature along our - primary base chain is from a lost primary, this vtable slot will - never be used, so just zero it out. This is important to avoid - requiring extra thunks which cannot be generated with the function. - - We first check this in update_vtable_entry_for_fn, so we handle - restored primary bases properly; we also need to do it here so we - zero out unused slots in ctor vtables, rather than filling themff - with erroneous values (though harmless, apart from relocation - costs). */ - for (b = binfo; ; b = get_primary_binfo (b)) - { - /* We found a defn before a lost primary; go ahead as normal. */ - if (look_for_overrides_here (BINFO_TYPE (b), fn_original)) - break; - - /* The nearest definition is from a lost primary; clear the - slot. */ - if (BINFO_LOST_PRIMARY_P (b)) - { - init = size_zero_node; - break; - } - } - - if (! init) - { - /* Pull the offset for `this', and the function to call, out of - the list. */ - delta = BV_DELTA (v); - vcall_index = BV_VCALL_INDEX (v); - - gcc_assert (TREE_CODE (delta) == INTEGER_CST); - gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); - - /* You can't call an abstract virtual function; it's abstract. - So, we replace these functions with __pure_virtual. */ - if (DECL_PURE_VIRTUAL_P (fn_original)) - { - fn = abort_fndecl; - if (abort_fndecl_addr == NULL) - abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn); - init = abort_fndecl_addr; - } - else - { - if (!integer_zerop (delta) || vcall_index) - { - fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index); - if (!DECL_NAME (fn)) - finish_thunk (fn); - } - /* Take the address of the function, considering it to be of an - appropriate generic type. */ - init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn); - } - } - - /* And add it to the chain of initializers. */ - if (TARGET_VTABLE_USES_DESCRIPTORS) - { - int i; - if (init == size_zero_node) - for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) - vfun_inits = tree_cons (NULL_TREE, init, vfun_inits); - else - for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) - { - tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node, - TREE_OPERAND (init, 0), - build_int_cst (NULL_TREE, i)); - TREE_CONSTANT (fdesc) = 1; - TREE_INVARIANT (fdesc) = 1; - - vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits); - } - } - else - vfun_inits = tree_cons (NULL_TREE, init, vfun_inits); - } - - /* The initializers for virtual functions were built up in reverse - order; straighten them out now. */ - vfun_inits = nreverse (vfun_inits); - - /* The negative offset initializers are also in reverse order. */ - vid.inits = nreverse (vid.inits); - - /* Chain the two together. */ - return chainon (vid.inits, vfun_inits); -} - -/* Adds to vid->inits the initializers for the vbase and vcall - offsets in BINFO, which is in the hierarchy dominated by T. */ - -static void -build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid) -{ - tree b; - - /* If this is a derived class, we must first create entries - corresponding to the primary base class. */ - b = get_primary_binfo (binfo); - if (b) - build_vcall_and_vbase_vtbl_entries (b, vid); - - /* Add the vbase entries for this base. */ - build_vbase_offset_vtbl_entries (binfo, vid); - /* Add the vcall entries for this base. */ - build_vcall_offset_vtbl_entries (binfo, vid); -} - -/* Returns the initializers for the vbase offset entries in the vtable - for BINFO (which is part of the class hierarchy dominated by T), in - reverse order. VBASE_OFFSET_INDEX gives the vtable index - where the next vbase offset will go. */ - -static void -build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) -{ - tree vbase; - tree t; - tree non_primary_binfo; - - /* If there are no virtual baseclasses, then there is nothing to - do. */ - if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))) - return; - - t = vid->derived; - - /* We might be a primary base class. Go up the inheritance hierarchy - until we find the most derived class of which we are a primary base: - it is the offset of that which we need to use. */ - non_primary_binfo = binfo; - while (BINFO_INHERITANCE_CHAIN (non_primary_binfo)) - { - tree b; - - /* If we have reached a virtual base, then it must be a primary - base (possibly multi-level) of vid->binfo, or we wouldn't - have called build_vcall_and_vbase_vtbl_entries for it. But it - might be a lost primary, so just skip down to vid->binfo. */ - if (BINFO_VIRTUAL_P (non_primary_binfo)) - { - non_primary_binfo = vid->binfo; - break; - } - - b = BINFO_INHERITANCE_CHAIN (non_primary_binfo); - if (get_primary_binfo (b) != non_primary_binfo) - break; - non_primary_binfo = b; - } - - /* Go through the virtual bases, adding the offsets. */ - for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); - vbase; - vbase = TREE_CHAIN (vbase)) - { - tree b; - tree delta; - - if (!BINFO_VIRTUAL_P (vbase)) - continue; - - /* Find the instance of this virtual base in the complete - object. */ - b = copied_binfo (vbase, binfo); - - /* If we've already got an offset for this virtual base, we - don't need another one. */ - if (BINFO_VTABLE_PATH_MARKED (b)) - continue; - BINFO_VTABLE_PATH_MARKED (b) = 1; - - /* Figure out where we can find this vbase offset. */ - delta = size_binop (MULT_EXPR, - vid->index, - convert (ssizetype, - TYPE_SIZE_UNIT (vtable_entry_type))); - if (vid->primary_vtbl_p) - BINFO_VPTR_FIELD (b) = delta; - - if (binfo != TYPE_BINFO (t)) - /* The vbase offset had better be the same. */ - gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase))); - - /* The next vbase will come at a more negative offset. */ - vid->index = size_binop (MINUS_EXPR, vid->index, - ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); - - /* The initializer is the delta from BINFO to this virtual base. - The vbase offsets go in reverse inheritance-graph order, and - we are walking in inheritance graph order so these end up in - the right order. */ - delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo)); - - *vid->last_init - = build_tree_list (NULL_TREE, - fold_build1 (NOP_EXPR, - vtable_entry_type, - delta)); - vid->last_init = &TREE_CHAIN (*vid->last_init); - } -} - -/* Adds the initializers for the vcall offset entries in the vtable - for BINFO (which is part of the class hierarchy dominated by VID->DERIVED) - to VID->INITS. */ - -static void -build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) -{ - /* We only need these entries if this base is a virtual base. We - compute the indices -- but do not add to the vtable -- when - building the main vtable for a class. */ - if (BINFO_VIRTUAL_P (binfo) || binfo == TYPE_BINFO (vid->derived)) - { - /* We need a vcall offset for each of the virtual functions in this - vtable. For example: - - class A { virtual void f (); }; - class B1 : virtual public A { virtual void f (); }; - class B2 : virtual public A { virtual void f (); }; - class C: public B1, public B2 { virtual void f (); }; - - A C object has a primary base of B1, which has a primary base of A. A - C also has a secondary base of B2, which no longer has a primary base - of A. So the B2-in-C construction vtable needs a secondary vtable for - A, which will adjust the A* to a B2* to call f. We have no way of - knowing what (or even whether) this offset will be when we define B2, - so we store this "vcall offset" in the A sub-vtable and look it up in - a "virtual thunk" for B2::f. - - We need entries for all the functions in our primary vtable and - in our non-virtual bases' secondary vtables. */ - vid->vbase = binfo; - /* If we are just computing the vcall indices -- but do not need - the actual entries -- not that. */ - if (!BINFO_VIRTUAL_P (binfo)) - vid->generate_vcall_entries = false; - /* Now, walk through the non-virtual bases, adding vcall offsets. */ - add_vcall_offset_vtbl_entries_r (binfo, vid); - } -} - -/* Build vcall offsets, starting with those for BINFO. */ - -static void -add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid) -{ - int i; - tree primary_binfo; - tree base_binfo; - - /* Don't walk into virtual bases -- except, of course, for the - virtual base for which we are building vcall offsets. Any - primary virtual base will have already had its offsets generated - through the recursion in build_vcall_and_vbase_vtbl_entries. */ - if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo) - return; - - /* If BINFO has a primary base, process it first. */ - primary_binfo = get_primary_binfo (binfo); - if (primary_binfo) - add_vcall_offset_vtbl_entries_r (primary_binfo, vid); - - /* Add BINFO itself to the list. */ - add_vcall_offset_vtbl_entries_1 (binfo, vid); - - /* Scan the non-primary bases of BINFO. */ - for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - if (base_binfo != primary_binfo) - add_vcall_offset_vtbl_entries_r (base_binfo, vid); -} - -/* Called from build_vcall_offset_vtbl_entries_r. */ - -static void -add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid) -{ - /* Make entries for the rest of the virtuals. */ - if (abi_version_at_least (2)) - { - tree orig_fn; - - /* The ABI requires that the methods be processed in declaration - order. G++ 3.2 used the order in the vtable. */ - for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo)); - orig_fn; - orig_fn = TREE_CHAIN (orig_fn)) - if (DECL_VINDEX (orig_fn)) - add_vcall_offset (orig_fn, binfo, vid); - } - else - { - tree derived_virtuals; - tree base_virtuals; - tree orig_virtuals; - /* If BINFO is a primary base, the most derived class which has - BINFO as a primary base; otherwise, just BINFO. */ - tree non_primary_binfo; - - /* We might be a primary base class. Go up the inheritance hierarchy - until we find the most derived class of which we are a primary base: - it is the BINFO_VIRTUALS there that we need to consider. */ - non_primary_binfo = binfo; - while (BINFO_INHERITANCE_CHAIN (non_primary_binfo)) - { - tree b; - - /* If we have reached a virtual base, then it must be vid->vbase, - because we ignore other virtual bases in - add_vcall_offset_vtbl_entries_r. In turn, it must be a primary - base (possibly multi-level) of vid->binfo, or we wouldn't - have called build_vcall_and_vbase_vtbl_entries for it. But it - might be a lost primary, so just skip down to vid->binfo. */ - if (BINFO_VIRTUAL_P (non_primary_binfo)) - { - gcc_assert (non_primary_binfo == vid->vbase); - non_primary_binfo = vid->binfo; - break; - } - - b = BINFO_INHERITANCE_CHAIN (non_primary_binfo); - if (get_primary_binfo (b) != non_primary_binfo) - break; - non_primary_binfo = b; - } - - if (vid->ctor_vtbl_p) - /* For a ctor vtable we need the equivalent binfo within the hierarchy - where rtti_binfo is the most derived type. */ - non_primary_binfo - = original_binfo (non_primary_binfo, vid->rtti_binfo); - - for (base_virtuals = BINFO_VIRTUALS (binfo), - derived_virtuals = BINFO_VIRTUALS (non_primary_binfo), - orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo))); - base_virtuals; - base_virtuals = TREE_CHAIN (base_virtuals), - derived_virtuals = TREE_CHAIN (derived_virtuals), - orig_virtuals = TREE_CHAIN (orig_virtuals)) - { - tree orig_fn; - - /* Find the declaration that originally caused this function to - be present in BINFO_TYPE (binfo). */ - orig_fn = BV_FN (orig_virtuals); - - /* When processing BINFO, we only want to generate vcall slots for - function slots introduced in BINFO. So don't try to generate - one if the function isn't even defined in BINFO. */ - if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn))) - continue; - - add_vcall_offset (orig_fn, binfo, vid); - } - } -} - -/* Add a vcall offset entry for ORIG_FN to the vtable. */ - -static void -add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid) -{ - size_t i; - tree vcall_offset; - tree derived_entry; - - /* If there is already an entry for a function with the same - signature as FN, then we do not need a second vcall offset. - Check the list of functions already present in the derived - class vtable. */ - for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i) - { - if (same_signature_p (derived_entry, orig_fn) - /* We only use one vcall offset for virtual destructors, - even though there are two virtual table entries. */ - || (DECL_DESTRUCTOR_P (derived_entry) - && DECL_DESTRUCTOR_P (orig_fn))) - return; - } - - /* If we are building these vcall offsets as part of building - the vtable for the most derived class, remember the vcall - offset. */ - if (vid->binfo == TYPE_BINFO (vid->derived)) - { - tree_pair_p elt = VEC_safe_push (tree_pair_s, gc, - CLASSTYPE_VCALL_INDICES (vid->derived), - NULL); - elt->purpose = orig_fn; - elt->value = vid->index; - } - - /* The next vcall offset will be found at a more negative - offset. */ - vid->index = size_binop (MINUS_EXPR, vid->index, - ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); - - /* Keep track of this function. */ - VEC_safe_push (tree, gc, vid->fns, orig_fn); - - if (vid->generate_vcall_entries) - { - tree base; - tree fn; - - /* Find the overriding function. */ - fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn); - if (fn == error_mark_node) - vcall_offset = build1 (NOP_EXPR, vtable_entry_type, - integer_zero_node); - else - { - base = TREE_VALUE (fn); - - /* The vbase we're working on is a primary base of - vid->binfo. But it might be a lost primary, so its - BINFO_OFFSET might be wrong, so we just use the - BINFO_OFFSET from vid->binfo. */ - vcall_offset = size_diffop (BINFO_OFFSET (base), - BINFO_OFFSET (vid->binfo)); - vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type, - vcall_offset); - } - /* Add the initializer to the vtable. */ - *vid->last_init = build_tree_list (NULL_TREE, vcall_offset); - vid->last_init = &TREE_CHAIN (*vid->last_init); - } -} - -/* Return vtbl initializers for the RTTI entries corresponding to the - BINFO's vtable. The RTTI entries should indicate the object given - by VID->rtti_binfo. */ - -static void -build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid) -{ - tree b; - tree t; - tree basetype; - tree offset; - tree decl; - tree init; - - basetype = BINFO_TYPE (binfo); - t = BINFO_TYPE (vid->rtti_binfo); - - /* To find the complete object, we will first convert to our most - primary base, and then add the offset in the vtbl to that value. */ - b = binfo; - while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b)) - && !BINFO_LOST_PRIMARY_P (b)) - { - tree primary_base; - - primary_base = get_primary_binfo (b); - gcc_assert (BINFO_PRIMARY_P (primary_base) - && BINFO_INHERITANCE_CHAIN (primary_base) == b); - b = primary_base; - } - offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b)); - - /* The second entry is the address of the typeinfo object. */ - if (flag_rtti) - decl = build_address (get_tinfo_decl (t)); - else - decl = integer_zero_node; - - /* Convert the declaration to a type that can be stored in the - vtable. */ - init = build_nop (vfunc_ptr_type_node, decl); - *vid->last_init = build_tree_list (NULL_TREE, init); - vid->last_init = &TREE_CHAIN (*vid->last_init); - - /* Add the offset-to-top entry. It comes earlier in the vtable than - the typeinfo entry. Convert the offset to look like a - function pointer, so that we can put it in the vtable. */ - init = build_nop (vfunc_ptr_type_node, offset); - *vid->last_init = build_tree_list (NULL_TREE, init); - vid->last_init = &TREE_CHAIN (*vid->last_init); -} - -/* Fold a OBJ_TYPE_REF expression to the address of a function. - KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */ - -tree -cp_fold_obj_type_ref (tree ref, tree known_type) -{ - HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1); - HOST_WIDE_INT i = 0; - tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type)); - tree fndecl; - - while (i != index) - { - i += (TARGET_VTABLE_USES_DESCRIPTORS - ? TARGET_VTABLE_USES_DESCRIPTORS : 1); - v = TREE_CHAIN (v); - } - - fndecl = BV_FN (v); - -#ifdef ENABLE_CHECKING - gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref), - DECL_VINDEX (fndecl))); -#endif - - cgraph_node (fndecl)->local.vtable_method = true; - - return build_address (fndecl); -} - -/* APPLE LOCAL begin KEXT double destructor */ -#ifndef TARGET_SUPPORTS_KEXTABI1 -#define TARGET_SUPPORTS_KEXTABI1 0 -#endif -/* Return whether CLASS or any of its primary ancestors have the - "apple_kext_compatibility" attribute, in which case the - non-deleting destructor is not emitted. Only single - inheritance heirarchies can have this tag. */ -int -has_apple_kext_compatibility_attr_p (tree class) -{ - if (! TARGET_SUPPORTS_KEXTABI1) - return 0; - - while (class != NULL) - { - tree base_binfo; - - if (TREE_CODE (class) == ARRAY_TYPE) - { - class = TREE_TYPE (class); - continue; - } - - if (BINFO_N_BASE_BINFOS (TYPE_BINFO (class)) > 1) - return 0; - - if (lookup_attribute ("apple_kext_compatibility", - TYPE_ATTRIBUTES (class))) - return 1; - - /* If there are no more base classes, we're done. */ - if (BINFO_N_BASE_BINFOS (TYPE_BINFO (class)) < 1) - break; - - base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (class), 0); - if (base_binfo - && ! BINFO_VIRTUAL_P (base_binfo)) - class = BINFO_TYPE (base_binfo); - else - break; - } - - return 0; -} - -/* Walk through a function body and return true if nothing in there - would cause us to generate code. */ -static int -compound_body_is_empty_p (tree t) -{ - while (t && t != error_mark_node) - { - enum tree_code tc = TREE_CODE (t); - if (tc == BIND_EXPR) - { - if (BIND_EXPR_VARS (t) == 0 - && compound_body_is_empty_p (BIND_EXPR_BODY (t))) - t = TREE_CHAIN (t); - else - return 0; - } - else if (tc == STATEMENT_LIST) - { - tree_stmt_iterator iter; - - for (iter = tsi_start (t); !tsi_end_p (iter); tsi_next (&iter)) - if (! compound_body_is_empty_p (tsi_stmt (iter))) - return 0; - return 1; - } - else - return 0; - } - /* We hit the end of the body function without seeing anything. */ - return 1; -} - -/* TRUE if we have an operator delete which is empty (i.e., NO CODE!) */ -int -has_empty_operator_delete_p (tree class) -{ - if (! class) - return 0; - - if (BINFO_N_BASE_BINFOS (TYPE_BINFO (class)) > 1) - return 0; - - if (TYPE_GETS_DELETE (class)) - { - tree f = lookup_fnfields (TYPE_BINFO (class), - ansi_opname (DELETE_EXPR), 0); - - if (f == error_mark_node) - return 0; - - if (BASELINK_P (f)) - f = BASELINK_FUNCTIONS (f); - - if (OVL_CURRENT (f)) - { - f = OVL_CURRENT (f); - - /* We've overridden TREE_SIDE_EFFECTS for C++ operator deletes - to mean that the function is empty. */ - if (TREE_SIDE_EFFECTS (f)) - return 1; - - /* Otherwise, it could be an inline but empty function. */ - if (DECL_SAVED_TREE (f)) - return compound_body_is_empty_p (DECL_SAVED_TREE (f)); - } - } - - return 0; -} -/* APPLE LOCAL end KEXT double destructor */ - -/* APPLE LOCAL begin 4167759 */ -/* Set DECL_IGNORED_P flag for ctors and dtors associated - with TYPE using VALUE. */ - -void cp_set_decl_ignore_flag (tree type, int value) -{ - tree m; - tree methods = TYPE_METHODS (type); - - if (!flag_limit_debug_info) - return; - - if (methods == NULL_TREE) - return; - - if (TREE_CODE (methods) != TREE_VEC) - m = methods; - else if (TREE_VEC_ELT (methods, 0) != NULL_TREE) - m = TREE_VEC_ELT (methods, 0); - else - m = TREE_VEC_ELT (methods, 1); - - for (; m; m = TREE_CHAIN (m)) - { - - if (DECL_NAME (m) == base_ctor_identifier - || DECL_NAME (m) == complete_ctor_identifier - || DECL_NAME (m) == complete_dtor_identifier - || DECL_NAME (m) == base_dtor_identifier - || DECL_NAME (m) == deleting_dtor_identifier) - DECL_IGNORED_P (m) = value; - } -} -/* APPLE LOCAL end 4167759 */ -#include "gt-cp-class.h" |