diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6fd7c0d1fef..6e1cb900c63 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,7 @@ +2001-02-12 Mark Mitchell + + Remove old ABI support. + 2001-02-11 Mark Mitchell * decl2.c (flag_vtable_thunks): Always set it to 1. diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 59bed97d92d..7cb34bd1724 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -2355,9 +2355,7 @@ build_user_type_conversion_1 (totype, expr, flags) if (IS_AGGR_TYPE (totype)) ctors = lookup_fnfields (TYPE_BINFO (totype), - (flag_new_abi - ? complete_ctor_identifier - : ctor_identifier), + complete_ctor_identifier, 0); if (IS_AGGR_TYPE (fromtype)) @@ -4415,25 +4413,12 @@ build_new_method_call (instance, name, args, basetype_path, flags) pretty_name = (constructor_p ? constructor_name (basetype) : dtor_identifier); - if (!flag_new_abi) - { - /* Add the in-charge parameter as an implicit first argument. */ - if (!constructor_p - || TYPE_USES_VIRTUAL_BASECLASSES (basetype)) - args = tree_cons (NULL_TREE, - in_charge_arg_for_name (name), - args); - - /* We want to call the normal constructor function under the - old ABI. */ - name = constructor_p ? ctor_identifier : dtor_identifier; - } /* If we're a call to a constructor or destructor for a subobject that uses virtual base classes, then we need to pass down a pointer to a VTT for the subobject. */ - else if ((name == base_ctor_identifier - || name == base_dtor_identifier) - && TYPE_USES_VIRTUAL_BASECLASSES (basetype)) + if ((name == base_ctor_identifier + || name == base_dtor_identifier) + && TYPE_USES_VIRTUAL_BASECLASSES (basetype)) { tree vtt; tree sub_vtt; diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 376260b0d6a..3f50da33108 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -143,7 +143,7 @@ static void check_field_decl PARAMS ((tree, tree, int *, int *, int *, int *)); static void check_field_decls PARAMS ((tree, tree *, int *, int *, int *, int *)); static void build_base_field PARAMS ((record_layout_info, tree, int *, - unsigned int *, splay_tree)); + splay_tree)); static void build_base_fields PARAMS ((record_layout_info, int *, splay_tree)); static tree build_vbase_pointer_fields PARAMS ((record_layout_info, int *)); @@ -182,7 +182,7 @@ static void layout_empty_base PARAMS ((tree, tree, splay_tree)); static void accumulate_vtbl_inits PARAMS ((tree, tree, tree, tree, tree)); static tree dfs_accumulate_vtbl_inits PARAMS ((tree, tree, tree, tree, tree)); -static void set_vindex PARAMS ((tree, tree, int *)); +static void set_vindex PARAMS ((tree, int *)); static void build_rtti_vtbl_entries PARAMS ((tree, tree, vtbl_init_data *)); static void build_vcall_and_vbase_vtbl_entries PARAMS ((tree, vtbl_init_data *)); @@ -663,11 +663,7 @@ static tree get_vtable_name (type) tree type; { - if (flag_new_abi) - return mangle_vtbl_for_type (type); - else - return build_overload_with_type (get_identifier (VTABLE_NAME_PREFIX), - type); + return mangle_vtbl_for_type (type); } /* Return an IDENTIFIER_NODE for the name of the virtual table table @@ -677,11 +673,7 @@ tree get_vtt_name (type) tree type; { - if (flag_new_abi) - return mangle_vtt_for_type (type); - else - return build_overload_with_type (get_identifier (VTT_NAME_PREFIX), - type); + return mangle_vtt_for_type (type); } /* Return the offset to the main vtable for a given base BINFO. */ @@ -1086,35 +1078,17 @@ modify_vtable_entry (t, binfo, fndecl, delta, virtuals) } } -/* Return the index (in the virtual function table) of the first - virtual function. */ - -int -first_vfun_index (t) - tree t; -{ - /* Under the old ABI, the offset-to-top and RTTI entries are at - indices zero and one; under the new ABI, the first virtual - function is at index zero. */ - if (!CLASSTYPE_COM_INTERFACE (t) && !flag_new_abi) - return flag_vtable_thunks ? 2 : 1; - - return 0; -} - /* Set DECL_VINDEX for DECL. VINDEX_P is the number of virtual functions present in the vtable so far. */ static void -set_vindex (t, decl, vfuns_p) - tree t; +set_vindex (decl, vfuns_p) tree decl; int *vfuns_p; { int vindex; vindex = (*vfuns_p)++; - vindex += first_vfun_index (t); DECL_VINDEX (decl) = build_shared_int_cst (vindex); } @@ -1158,7 +1132,7 @@ add_virtual_function (new_virtuals_p, overridden_virtuals_p, CLASSTYPE_RTTI (t) = t; /* Now assign virtual dispatch information. */ - set_vindex (t, fndecl, vfuns_p); + set_vindex (fndecl, vfuns_p); DECL_VIRTUAL_CONTEXT (fndecl) = t; /* Save the state we've computed on the NEW_VIRTUALS list. */ @@ -1942,9 +1916,6 @@ determine_primary_base (t, vfuns_p) = tree_cons (base_binfo, VF_BASETYPE_VALUE (vfields), CLASSTYPE_VFIELDS (t)); - - if (!flag_new_abi && *vfuns_p == 0) - set_primary_base (t, base_binfo, vfuns_p); } } } @@ -1994,7 +1965,7 @@ determine_primary_base (t, vfuns_p) /* The new ABI allows for the use of a "nearly-empty" virtual base class as the primary base class if no non-virtual polymorphic base can be found. */ - if (flag_new_abi && !CLASSTYPE_HAS_PRIMARY_BASE_P (t)) + if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) { /* If not NULL, this is the best primary base candidate we have found so far. */ @@ -2744,37 +2715,32 @@ update_vtable_entry_for_fn (t, binfo, fn, virtuals) /* Under the new ABI, we will convert to an intermediate virtual base first, and then use the vcall offset located there to finish the conversion. */ - if (flag_new_abi) + while (b) { - while (b) - { - /* If we find BINFO, then the final overrider is in a class - derived from BINFO, so the thunks can be generated with - the final overrider. */ - if (!virtual_base - && same_type_p (BINFO_TYPE (b), BINFO_TYPE (binfo))) - generate_thunk_with_vtable_p = 0; + /* If we find BINFO, then the final overrider is in a class + derived from BINFO, so the thunks can be generated with + the final overrider. */ + if (!virtual_base + && same_type_p (BINFO_TYPE (b), BINFO_TYPE (binfo))) + generate_thunk_with_vtable_p = 0; /* If we find the final overrider, then we can stop walking. */ - if (same_type_p (BINFO_TYPE (b), - BINFO_TYPE (TREE_VALUE (overrider)))) - break; + if (same_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 and the final overrider. */ - if (!virtual_base && TREE_VIA_VIRTUAL (b)) - { - generate_thunk_with_vtable_p = 1; - virtual_base = b; - } - - b = BINFO_INHERITANCE_CHAIN (b); + if (!virtual_base && TREE_VIA_VIRTUAL (b)) + { + generate_thunk_with_vtable_p = 1; + virtual_base = b; } + + b = BINFO_INHERITANCE_CHAIN (b); } - else - virtual_base = NULL_TREE; if (virtual_base) /* The `this' pointer needs to be adjusted to the nearest virtual @@ -2822,8 +2788,7 @@ dfs_modify_vtables (binfo, data) /* If we're supporting RTTI then we always need a new vtable to point to the RTTI information. Under the new ABI we may need a new vtable to contain vcall and vbase offsets. */ - if (flag_rtti || flag_new_abi) - make_new_vtable (t, binfo); + 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 @@ -2884,7 +2849,7 @@ modify_all_vtables (t, vfuns_p, overridden_virtuals) || !value_member (fn, BINFO_VIRTUALS (binfo))) { /* Set the vtable index. */ - set_vindex (t, fn, vfuns_p); + set_vindex (fn, vfuns_p); /* We don't need to convert to a base class when calling this function. */ DECL_VIRTUAL_CONTEXT (fn) = t; @@ -3954,10 +3919,10 @@ layout_nonempty_base_or_field (rli, decl, binfo, offsets) empty class, have non-zero size, any overlap can happen only with a direct or indirect base-class -- it can't happen with a data member. */ - if (flag_new_abi && layout_conflict_p (TREE_TYPE (decl), - offset, - offsets, - field_p)) + if (layout_conflict_p (TREE_TYPE (decl), + 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 @@ -4033,11 +3998,10 @@ layout_empty_base (binfo, eoc, offsets) class. OFFSETS gives the location of empty base subobjects. */ static void -build_base_field (rli, binfo, empty_p, base_align, offsets) +build_base_field (rli, binfo, empty_p, offsets) record_layout_info rli; tree binfo; int *empty_p; - unsigned int *base_align; splay_tree offsets; { tree basetype = BINFO_TYPE (binfo); @@ -4056,20 +4020,6 @@ build_base_field (rli, binfo, empty_p, base_align, offsets) DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype); - if (! flag_new_abi) - { - /* Brain damage for backwards compatibility. For no good - reason, the old basetype layout made every base have at least - as large as the alignment for the bases up to that point, - gratuitously wasting space. So we do the same thing here. */ - *base_align = MAX (*base_align, DECL_ALIGN (decl)); - DECL_SIZE (decl) - = size_binop (MAX_EXPR, DECL_SIZE (decl), bitsize_int (*base_align)); - DECL_SIZE_UNIT (decl) - = size_binop (MAX_EXPR, DECL_SIZE_UNIT (decl), - size_int (*base_align / BITS_PER_UNIT)); - } - if (!integer_zerop (DECL_SIZE (decl))) { /* The containing class is non-empty because it has a non-empty @@ -4120,13 +4070,12 @@ build_base_fields (rli, empty_p, offsets) tree rec = rli->t; int n_baseclasses = CLASSTYPE_N_BASECLASSES (rec); int i; - unsigned int base_align = 0; /* Under the new ABI, the primary base class is always allocated first. */ - if (flag_new_abi && CLASSTYPE_HAS_PRIMARY_BASE_P (rec)) + if (CLASSTYPE_HAS_PRIMARY_BASE_P (rec)) build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (rec), - empty_p, &base_align, offsets); + empty_p, offsets); /* Now allocate the rest of the bases. */ for (i = 0; i < n_baseclasses; ++i) @@ -4137,7 +4086,7 @@ build_base_fields (rli, empty_p, offsets) /* Under the new ABI, the primary base was already allocated above, so we don't need to allocate it again here. */ - if (flag_new_abi && base_binfo == CLASSTYPE_PRIMARY_BINFO (rec)) + if (base_binfo == CLASSTYPE_PRIMARY_BINFO (rec)) continue; /* A primary virtual base class is allocated just like any other @@ -4147,7 +4096,7 @@ build_base_fields (rli, empty_p, offsets) && !BINFO_PRIMARY_P (base_binfo)) continue; - build_base_field (rli, base_binfo, empty_p, &base_align, offsets); + build_base_field (rli, base_binfo, empty_p, offsets); } } @@ -4196,18 +4145,13 @@ check_methods (t) [class.free]) requires that the second argument be set correctly. */ second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (x))); - /* This is overly conservative, but we must maintain this - behavior for backwards compatibility. */ - if (!flag_new_abi && second_parm != void_list_node) - TYPE_VEC_DELETE_TAKES_SIZE (t) = 1; /* Under the new ABI, we choose only those function that are explicitly declared as `operator delete[] (void *, size_t)'. */ - else if (flag_new_abi - && !seen_one_arg_array_delete_p - && second_parm - && TREE_CHAIN (second_parm) == void_list_node - && same_type_p (TREE_VALUE (second_parm), sizetype)) + if (!seen_one_arg_array_delete_p + && second_parm + && TREE_CHAIN (second_parm) == void_list_node + && same_type_p (TREE_VALUE (second_parm), sizetype)) TYPE_VEC_DELETE_TAKES_SIZE (t) = 1; /* If there's no second parameter, then this is the usual deallocation function. */ @@ -4351,9 +4295,8 @@ clone_function_decl (fn, update_method_vec_p) tree clone; /* Avoid inappropriate cloning. */ - if (! flag_new_abi - || (TREE_CHAIN (fn) - && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))) + if (TREE_CHAIN (fn) + && DECL_CLONED_FUNCTION (TREE_CHAIN (fn))) return; if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)) @@ -4398,10 +4341,6 @@ clone_constructors_and_destructors (t) { tree fns; - /* We only clone constructors and destructors under the new ABI. */ - if (!flag_new_abi) - return; - /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail out now. */ if (!CLASSTYPE_METHOD_VEC (t)) @@ -4540,8 +4479,7 @@ create_vtable_ptr (t, empty_p, vfuns_p, /* Loop over the virtual functions, adding them to our various vtables. */ for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn)) - if (DECL_VINDEX (fn) - && !(flag_new_abi && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))) + if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)) add_virtual_function (new_virtuals_p, overridden_virtuals_p, vfuns_p, fn, t); @@ -4580,7 +4518,7 @@ create_vtable_ptr (t, empty_p, vfuns_p, t, empty_p); - if (flag_new_abi && CLASSTYPE_N_BASECLASSES (t)) + if (CLASSTYPE_N_BASECLASSES (t)) /* If there were any baseclasses, they can't possibly be at offset zero any more, because that's where the vtable pointer is. So, converting to a base class is going to @@ -4755,22 +4693,15 @@ layout_virtual_bases (t, offsets) ABI, these are allocated according to a depth-first left-to-right postorder traversal; in the new ABI, inheritance graph order is used instead. */ - for (vbases = (flag_new_abi - ? TYPE_BINFO (t) - : CLASSTYPE_VBASECLASSES (t)); + for (vbases = TYPE_BINFO (t); vbases; vbases = TREE_CHAIN (vbases)) { tree vbase; - if (flag_new_abi) - { - if (!TREE_VIA_VIRTUAL (vbases)) - continue; - vbase = binfo_for_vbase (BINFO_TYPE (vbases), t); - } - else - vbase = TREE_VALUE (vbases); + if (!TREE_VIA_VIRTUAL (vbases)) + continue; + vbase = binfo_for_vbase (BINFO_TYPE (vbases), t); if (!BINFO_PRIMARY_P (vbase)) { @@ -4781,13 +4712,7 @@ layout_virtual_bases (t, offsets) basetype = BINFO_TYPE (vbase); - if (flag_new_abi) - desired_align = CLASSTYPE_ALIGN (basetype); - else - /* Under the old ABI, virtual bases were aligned as for the - entire base object (including its virtual bases). That's - wasteful, in general. */ - desired_align = TYPE_ALIGN (basetype); + desired_align = CLASSTYPE_ALIGN (basetype); TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), desired_align); /* Add padding so that we can put the virtual base class at an @@ -4796,7 +4721,7 @@ layout_virtual_bases (t, offsets) /* Under the new ABI, we try to squish empty virtual bases in just like ordinary empty bases. */ - if (flag_new_abi && is_empty_class (basetype)) + if (is_empty_class (basetype)) layout_empty_base (vbase, size_int (CEIL (dsize, BITS_PER_UNIT)), offsets); @@ -4945,7 +4870,7 @@ layout_class_type (t, empty_p, vfuns_p, /* Under the new ABI, the vptr is always the first thing in the class. */ - if (flag_new_abi && vptr) + if (vptr) { TYPE_FIELDS (t) = chainon (vptr, TYPE_FIELDS (t)); place_field (rli, vptr); @@ -4986,12 +4911,7 @@ layout_class_type (t, empty_p, vfuns_p, rules, but the back-end can't handle bitfields longer than a `long long', so we use the same mechanism. */ if (DECL_C_BIT_FIELD (field) - && ((flag_new_abi - && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field))) - || (!flag_new_abi - && 0 < compare_tree_int (DECL_SIZE (field), - TYPE_PRECISION - (long_long_unsigned_type_node))))) + && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field))) { integer_type_kind itk; tree integer_type; @@ -5049,10 +4969,6 @@ layout_class_type (t, empty_p, vfuns_p, if (TREE_CODE (rli_size_unit_so_far (rli)) == INTEGER_CST && compare_tree_int (rli_size_unit_so_far (rli), eoc) < 0) { - /* We don't handle zero-sized base classes specially under the - old ABI, so if we get here, we had better be operating under - the new ABI rules. */ - my_friendly_assert (flag_new_abi, 20000321); rli->offset = size_binop (MAX_EXPR, rli->offset, size_int (eoc + 1)); rli->bitpos = bitsize_zero_node; } @@ -5073,14 +4989,6 @@ layout_class_type (t, empty_p, vfuns_p, TREE_STATIC (TYPE_NONCOPIED_PARTS (t)) = 1; } - /* Under the old ABI, the vptr comes at the very end of the - class. */ - if (!flag_new_abi && vptr) - { - place_field (rli, vptr); - TYPE_FIELDS (t) = chainon (TYPE_FIELDS (t), vptr); - } - /* Let the back-end lay out the type. Note that at this point we have only included non-virtual base-classes; we will lay out the virtual base classes later. So, the TYPE_SIZE/TYPE_ALIGN after @@ -5094,21 +5002,16 @@ layout_class_type (t, empty_p, vfuns_p, /* Remember the size and alignment of the class before adding the virtual bases. */ - if (*empty_p && flag_new_abi) + if (*empty_p) { CLASSTYPE_SIZE (t) = bitsize_zero_node; CLASSTYPE_SIZE_UNIT (t) = size_zero_node; } - else if (flag_new_abi) + else { CLASSTYPE_SIZE (t) = TYPE_BINFO_SIZE (t); CLASSTYPE_SIZE_UNIT (t) = TYPE_BINFO_SIZE_UNIT (t); } - else - { - CLASSTYPE_SIZE (t) = TYPE_SIZE (t); - CLASSTYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (t); - } CLASSTYPE_ALIGN (t) = TYPE_ALIGN (t); CLASSTYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (t); @@ -6493,23 +6396,13 @@ int is_empty_class (type) tree type; { - tree t; - if (type == error_mark_node) return 0; if (! IS_AGGR_TYPE (type)) return 0; - if (flag_new_abi) - return integer_zerop (CLASSTYPE_SIZE (type)); - - if (TYPE_BINFO_BASETYPES (type)) - return 0; - t = TYPE_FIELDS (type); - while (t && TREE_CODE (t) != FIELD_DECL) - t = TREE_CHAIN (t); - return (t == NULL_TREE); + return integer_zerop (CLASSTYPE_SIZE (type)); } /* Find the enclosing class of the given NODE. NODE can be a *_DECL or @@ -6894,10 +6787,6 @@ build_vtt (t) tree vtt; tree index; - /* Under the old ABI, we don't use VTTs. */ - if (!flag_new_abi) - return; - /* Build up the initializers for the VTT. */ inits = NULL_TREE; index = size_zero_node; @@ -7194,10 +7083,7 @@ build_ctor_vtbl_group (binfo, t) tree vbase; /* See if we've already create this construction vtable group. */ - if (flag_new_abi) - id = mangle_ctor_vtbl_for_type (t, binfo); - else - id = get_ctor_vtbl_name (t, binfo); + id = mangle_ctor_vtbl_for_type (t, binfo); if (IDENTIFIER_GLOBAL_VALUE (id)) return; diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 43a97143e25..eb7afc04ff5 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -213,10 +213,6 @@ Boston, MA 02111-1307, USA. */ /* ABI control. */ -/* Nonzero to enable experimental ABI changes. */ - -extern int flag_new_abi; - /* Nonzero to use __cxa_atexit, rather than atexit, to register destructors for local statics and global objects. */ @@ -238,12 +234,12 @@ extern int flag_huge_objects; /* Nonzero if virtual base class offsets are stored in the virtual function table. Zero if, instead, a pointer to the virtual base is stored in the object itself. */ -#define vbase_offsets_in_vtable_p() (flag_new_abi) +#define vbase_offsets_in_vtable_p() (1) /* Nonzero if displacements to the `this' pointer to use when calling virtual functions in a virtual base class are present in the vtable. */ -#define vcall_offsets_in_vtable_p() (flag_new_abi) +#define vcall_offsets_in_vtable_p() (1) /* Nonzero if a derived class that needs a vptr should always get one, even if a non-primary base class already has one. For example, @@ -255,7 +251,7 @@ extern int flag_huge_objects; one could either reuse the vptr in `S' for `T', or create a new vptr for `T'. If this flag is nonzero we choose the latter alternative; otherwise, we choose the former. */ -#define vptrs_present_everywhere_p() (flag_new_abi) +#define vptrs_present_everywhere_p() (1) /* Nonzero if the vtable for a derived class should contain the virtual functions from the primary base and all virtual functions @@ -263,16 +259,16 @@ extern int flag_huge_objects; only those virtual functions from the primary base together with the functions declared in the derived class (but not in any base class). */ -#define all_overridden_vfuns_in_vtables_p() (flag_new_abi) +#define all_overridden_vfuns_in_vtables_p() (1) /* Nonzero if we use access type_info objects directly, and use the cross-vendor layout for them. Zero if we use an accessor function to get the type_info object address. */ -#define new_abi_rtti_p() (flag_new_abi) +#define new_abi_rtti_p() (1) /* Nonzero if primary and secondary vtables are combined into a single vtable. */ -#define merge_primary_and_secondary_vtables_p() (flag_new_abi) +#define merge_primary_and_secondary_vtables_p() (1) /* Language-dependent contents of an identifier. */ @@ -2681,9 +2677,7 @@ extern int flag_new_for_scope; pointer to member function. TYPE_PTRMEMFUNC_P _must_ be true, before using this macro. */ #define TYPE_PTRMEMFUNC_FN_TYPE(NODE) \ - (flag_new_abi \ - ? (TREE_TYPE (TYPE_FIELDS (NODE))) \ - : (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (NODE)))))))) + (TREE_TYPE (TYPE_FIELDS (NODE))) /* Returns `A' for a type like `int (A::*)(double)' */ #define TYPE_PTRMEMFUNC_OBJECT_TYPE(NODE) \ @@ -3739,7 +3733,6 @@ extern void push_lang_context PARAMS ((tree)); extern void pop_lang_context PARAMS ((void)); extern tree instantiate_type PARAMS ((tree, tree, enum instantiate_type_flags)); extern void print_class_statistics PARAMS ((void)); -extern int first_vfun_index PARAMS ((tree)); extern void build_self_reference PARAMS ((void)); extern void warn_hidden PARAMS ((tree)); extern tree get_enclosing_class PARAMS ((tree)); @@ -4097,22 +4090,13 @@ extern int cp_type_qual_from_rid PARAMS ((tree)); /* in method.c */ extern void init_method PARAMS ((void)); -extern char *build_overload_name PARAMS ((tree, int, int)); -extern tree build_static_name PARAMS ((tree, tree)); -extern tree build_decl_overload_real PARAMS ((tree, tree, tree, tree, - tree, int)); extern void set_mangled_name_for_decl PARAMS ((tree)); -extern tree build_typename_overload PARAMS ((tree)); -extern tree build_overload_with_type PARAMS ((tree, tree)); -extern tree build_destructor_name PARAMS ((tree)); extern tree build_opfncall PARAMS ((enum tree_code, int, tree, tree, tree)); extern tree hack_identifier PARAMS ((tree, tree)); extern tree make_thunk PARAMS ((tree, tree, tree, int)); extern void use_thunk PARAMS ((tree, int)); extern void synthesize_method PARAMS ((tree)); -extern tree get_id_2 PARAMS ((const char *, tree)); extern tree implicitly_declare_fn PARAMS ((special_function_kind, tree, int)); -extern tree get_ctor_vtbl_name PARAMS ((tree, tree)); /* In optimize.c */ extern void optimize_function PARAMS ((tree)); @@ -4191,7 +4175,6 @@ extern tree get_tinfo_decl PARAMS((tree)); extern tree get_typeid PARAMS((tree)); extern tree get_typeid_1 PARAMS((tree)); extern tree build_dynamic_cast PARAMS((tree, tree)); -extern void synthesize_tinfo_fn PARAMS((tree)); extern void emit_support_tinfos PARAMS((void)); extern int tinfo_decl_p PARAMS((tree, void *)); extern int emit_tinfo_decl PARAMS((tree *, void *)); @@ -4500,7 +4483,7 @@ extern int cp_type_quals PARAMS ((tree)); extern int cp_has_mutable_p PARAMS ((tree)); extern int at_least_as_qualified_p PARAMS ((tree, tree)); extern int more_qualified_p PARAMS ((tree, tree)); -extern tree build_ptrmemfunc1 PARAMS ((tree, tree, tree, tree, tree)); +extern tree build_ptrmemfunc1 PARAMS ((tree, tree, tree)); extern void expand_ptrmemfunc_cst PARAMS ((tree, tree *, tree *, tree *, tree *)); extern tree delta2_from_ptrmemfunc PARAMS ((tree)); extern tree pfn_from_ptrmemfunc PARAMS ((tree)); diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 9fa2a665e15..1f74eb463ab 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -258,7 +258,7 @@ cp_convert_to_pointer (type, expr, force) if (TYPE_PTRMEMFUNC_P (type)) return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0); - if (flag_new_abi && TYPE_PTRMEM_P (type)) + if (TYPE_PTRMEM_P (type)) /* Under the new ABI, a NULL pointer-to-member is represented by -1, not by zero. */ expr = build_int_2 (-1, -1); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index dcf84e6ddac..ead15dbdd76 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -51,15 +51,10 @@ extern tree global_namespace; extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree)); #ifndef BOOL_TYPE_SIZE -#ifdef SLOW_BYTE_ACCESS /* In the new ABI, `bool' has size and alignment `1', on all platforms. */ -#define BOOL_TYPE_SIZE \ - ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE)) -#else #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE #endif -#endif static tree grokparms PARAMS ((tree)); static const char *redeclaration_error_message PARAMS ((tree, tree)); @@ -149,7 +144,7 @@ static void end_cleanup_fn PARAMS ((void)); static tree cp_make_fname_decl PARAMS ((tree, const char *, int)); static void initialize_predefined_identifiers PARAMS ((void)); static tree check_special_function_return_type - PARAMS ((special_function_kind, tree, tree, tree)); + PARAMS ((special_function_kind, tree, tree)); static tree push_cp_library_fn PARAMS ((enum tree_code, tree)); static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree)); static void store_parm_decls PARAMS ((tree)); @@ -2844,13 +2839,7 @@ pushtag (name, type, globalize) VARRAY_PUSH_TREE (local_classes, type); if (!uses_template_parms (type)) - { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (d) = mangle_type (type); - else - DECL_ASSEMBLER_NAME (d) - = get_identifier (build_overload_name (type, 1, 1)); - } + DECL_ASSEMBLER_NAME (d) = mangle_type (type); } if (b->parm_flag == 2) { @@ -6307,8 +6296,8 @@ init_decl_processing () /* Check to see that the user did not specify an invalid combination of command-line options. */ - if (flag_new_abi && !flag_vtable_thunks) - error ("the new ABI requires vtable thunks"); + if (!flag_vtable_thunks) + error ("the ABI requires vtable thunks"); /* Create all the identifiers we need. */ initialize_predefined_identifiers (); @@ -6411,17 +6400,8 @@ init_decl_processing () record_builtin_type (RID_MAX, NULL_PTR, string_type_node); #endif - if (flag_new_abi) - delta_type_node = ptrdiff_type_node; - else if (flag_huge_objects) - delta_type_node = long_integer_type_node; - else - delta_type_node = short_integer_type_node; - - if (flag_new_abi) - vtable_index_type = ptrdiff_type_node; - else - vtable_index_type = delta_type_node; + delta_type_node = ptrdiff_type_node; + vtable_index_type = ptrdiff_type_node; vtt_parm_type = build_pointer_type (const_ptr_type_node); lang_type_promotes_to = convert_type_from_ellipsis; @@ -6490,12 +6470,9 @@ init_decl_processing () layout_type (vtbl_ptr_type_node); record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node); - if (flag_new_abi) - { - push_namespace (get_identifier ("__cxxabiv1")); - abi_node = current_namespace; - pop_namespace (); - } + push_namespace (get_identifier ("__cxxabiv1")); + abi_node = current_namespace; + pop_namespace (); global_type_node = make_node (LANG_TYPE); record_unknown_type (global_type_node, "global type"); @@ -6521,10 +6498,7 @@ init_decl_processing () } abort_fndecl - = build_library_fn_ptr ((flag_new_abi - ? "__cxa_pure_virtual" - : "__pure_virtual"), - void_ftype); + = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype); /* Perform other language dependent initializations. */ init_class_processing (); @@ -7534,13 +7508,7 @@ maybe_commonize_var (decl) which we can't if it has been initialized. */ if (TREE_PUBLIC (decl)) - { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); - else - DECL_ASSEMBLER_NAME (decl) - = build_static_name (current_function_decl, DECL_NAME (decl)); - } + DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); else { cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl); @@ -8977,13 +8945,7 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace) /* DECL_ASSEMBLER_NAME is needed only for full-instantiated templates. */ if (!uses_template_parms (decl)) - { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); - else - DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, - declarator); - } + DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); } else { @@ -9008,13 +8970,7 @@ grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace) context = DECL_CONTEXT (decl); if (declarator && context && current_lang_name != lang_name_c) - { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); - else - DECL_ASSEMBLER_NAME (decl) - = build_static_name (context, declarator); - } + DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); } if (in_namespace) @@ -9079,7 +9035,6 @@ build_ptrmemfunc_type (type) { tree fields[4]; tree t; - tree u; tree unqualified_variant = NULL_TREE; if (type == error_mark_node) @@ -9104,30 +9059,10 @@ build_ptrmemfunc_type (type) /* ... and not really an aggregate. */ SET_IS_AGGR_TYPE (t, 0); - if (!flag_new_abi) - { - u = make_aggr_type (UNION_TYPE); - SET_IS_AGGR_TYPE (u, 0); - fields[0] = build_decl (FIELD_DECL, pfn_identifier, type); - fields[1] = build_decl (FIELD_DECL, delta2_identifier, - delta_type_node); - finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node); - TYPE_NAME (u) = NULL_TREE; - - fields[0] = build_decl (FIELD_DECL, delta_identifier, - delta_type_node); - fields[1] = build_decl (FIELD_DECL, index_identifier, - delta_type_node); - fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u); - finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node); - } - else - { - fields[0] = build_decl (FIELD_DECL, pfn_identifier, type); - fields[1] = build_decl (FIELD_DECL, delta_identifier, - delta_type_node); - finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node); - } + fields[0] = build_decl (FIELD_DECL, pfn_identifier, type); + fields[1] = build_decl (FIELD_DECL, delta_identifier, + delta_type_node); + finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node); /* Zap out the name so that the back-end will give us the debugging information for this anonymous RECORD_TYPE. */ @@ -9399,17 +9334,15 @@ create_array_type_for_decl (name, type, size) /* Check that it's OK to declare a function with the indicated TYPE. SFK indicates the kind of special function (if any) that this - function is. CTYPE is the class of which this function is a - member. OPTYPE is the type given in a conversion operator + function is. OPTYPE is the type given in a conversion operator declaration. Returns the actual return type of the function; that may be different than TYPE if an error occurs, or for certain special functions. */ static tree -check_special_function_return_type (sfk, type, ctype, optype) +check_special_function_return_type (sfk, type, optype) special_function_kind sfk; tree type; - tree ctype; tree optype; { switch (sfk) @@ -9418,9 +9351,8 @@ check_special_function_return_type (sfk, type, ctype, optype) if (type) cp_error ("return type specification for constructor invalid"); - /* In the old ABI, we return `this'; in the new ABI we don't - bother. */ - type = flag_new_abi ? void_type_node : build_pointer_type (ctype); + /* In the new ABI constructors do not return a value. */ + type = void_type_node; break; case sfk_destructor: @@ -10030,7 +9962,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) if (sfk != sfk_none) type = check_special_function_return_type (sfk, type, - ctor_return_type, ctor_return_type); else if (type == NULL_TREE) { @@ -11048,24 +10979,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist) DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)) = TYPE_IDENTIFIER (type); - if (flag_new_abi) - DECL_ASSEMBLER_NAME (decl) = mangle_type (type); - else - { - /* XXX Temporarily set the scope. - When returning, start_decl expects it as NULL_TREE, - and will then then set it using pushdecl. */ - my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404); - if (current_class_type) - DECL_CONTEXT (decl) = current_class_type; - else - DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace); - - DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl); - DECL_ASSEMBLER_NAME (decl) - = get_identifier (build_overload_name (type, 1, 1)); - DECL_CONTEXT (decl) = NULL_TREE; - } + DECL_ASSEMBLER_NAME (decl) = mangle_type (type); /* FIXME remangle member functions; member functions of a type with external linkage have external linkage. */ @@ -13637,16 +13551,6 @@ start_function (declspecs, declarator, attrs, flags) dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); DECL_CONTEXT (dtor_label) = current_function_decl; } - /* Under the old ABI we return `this' from constructors, so we make - ordinary `return' statements in constructors jump to CTOR_LABEL; - from there we return `this'. Under the new ABI, we don't bother - with any of this. By not setting CTOR_LABEL the remainder of the - machinery is automatically disabled. */ - else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1)) - { - ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); - DECL_CONTEXT (ctor_label) = current_function_decl; - } store_parm_decls (current_function_parms); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 442b31bf37d..08960969781 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -415,10 +415,6 @@ int flag_new_for_scope = 1; int flag_weak = 1; -/* Nonzero to enable experimental ABI changes. */ - -int flag_new_abi = 1; - /* Nonzero to use __cxa_atexit, rather than atexit, to register destructors for local statics and global objects. */ @@ -620,17 +616,6 @@ cxx_decode_option (argc, argv) flag_external_templates = 1; cp_deprecated ("-fexternal-templates"); } - else if (!strcmp (p, "new-abi")) - { - flag_new_abi = 1; - flag_do_squangling = 1; - flag_vtable_thunks = 1; - } - else if (!strcmp (p, "no-new-abi")) - { - flag_new_abi = 0; - flag_do_squangling = 0; - } else if ((option_value = skip_leading_substring (p, "template-depth-"))) max_tinst_depth @@ -995,7 +980,7 @@ maybe_retrofit_in_chrg (fn) /* If this is a subobject constructor or destructor, our caller will pass us a pointer to our VTT. */ - if (flag_new_abi && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) + if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn))) { DECL_VTT_PARM (fn) = build_artificial_parm (vtt_parm_identifier, vtt_parm_type); @@ -1081,12 +1066,7 @@ grokclassfn (ctype, function, flags, quals) if (flags == DTOR_FLAG) { DECL_DESTRUCTOR_P (function) = 1; - - if (flag_new_abi) - set_mangled_name_for_decl (function); - else - DECL_ASSEMBLER_NAME (function) = build_destructor_name (ctype); - + set_mangled_name_for_decl (function); TYPE_HAS_DESTRUCTOR (ctype) = 1; } else @@ -1560,11 +1540,7 @@ finish_static_data_member_decl (decl, init, asmspec_tree, flags) if (!asmspec && current_class_type) { DECL_INITIAL (decl) = error_mark_node; - if (flag_new_abi) - DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); - else - DECL_ASSEMBLER_NAME (decl) - = build_static_name (current_class_type, DECL_NAME (decl)); + DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); } if (! processing_template_decl) { @@ -1699,13 +1675,7 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist) name for this TYPE_DECL. */ DECL_ASSEMBLER_NAME (value) = DECL_NAME (value); if (!uses_template_parms (value)) - { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (value) = mangle_type (TREE_TYPE (value)); - else - DECL_ASSEMBLER_NAME (value) = - get_identifier (build_overload_name (TREE_TYPE (value), 1, 1)); - } + DECL_ASSEMBLER_NAME (value) = mangle_type (TREE_TYPE (value)); if (processing_template_decl) value = push_template_decl (value); @@ -1886,10 +1856,7 @@ grokoptypename (declspecs, declarator) tree declspecs, declarator; { tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL_TREE); - if (flag_new_abi) - return mangle_conv_op_name_for_type (t); - else - return build_typename_overload (t); + return mangle_conv_op_name_for_type (t); } /* When a function is declared with an initializer, @@ -2757,9 +2724,7 @@ import_export_decl (decl) tree ctype = DECL_CONTEXT (decl); import_export_class (ctype); if (CLASSTYPE_INTERFACE_KNOWN (ctype) - && (flag_new_abi - ? (! DECL_THIS_INLINE (decl)) - : (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl)))) + && ! DECL_THIS_INLINE (decl)) { DECL_NOT_REALLY_EXTERN (decl) = ! (CLASSTYPE_INTERFACE_ONLY (ctype) @@ -2846,23 +2811,7 @@ get_guard (decl) tree sname; tree guard; - /* For a local variable, under the old ABI, we do not try to get a - unique mangled name for the DECL. */ - if (!flag_new_abi && DECL_FUNCTION_SCOPE_P (decl)) - { - guard = get_temp_name (integer_type_node); - cp_finish_decl (guard, NULL_TREE, NULL_TREE, 0); - return guard; - } - - if (!flag_new_abi) - /* For struct X foo __attribute__((weak)), there is a counter - __snfoo. Since base is already an assembler name, sname should - be globally unique */ - sname = get_id_2 ("__sn", DECL_ASSEMBLER_NAME (decl)); - else - sname = mangle_guard_variable (decl); - + sname = mangle_guard_variable (decl); guard = IDENTIFIER_GLOBAL_VALUE (sname); if (! guard) { @@ -2870,11 +2819,7 @@ get_guard (decl) /* Under the new ABI, we use a type that is big enough to contain a mutex as well as an integer counter. */ - if (flag_new_abi) - guard_type = long_long_integer_type_node; - else - guard_type = integer_type_node; - + guard_type = long_long_integer_type_node; guard = build_decl (VAR_DECL, sname, guard_type); /* The guard should have the same linkage as what it guards. */ @@ -2900,9 +2845,6 @@ static tree get_guard_bits (guard) tree guard; { - if (!flag_new_abi) - return guard; - /* Under the new ABI, we only set the first byte of the guard, in order to leave room for a mutex in the high-order bits. */ guard = build1 (ADDR_EXPR, @@ -3358,7 +3300,7 @@ start_static_initialization_or_destruction (decl, initp) /* Under the new ABI, we have not already set the GUARD, so we must do so now. */ - if (guard && initp && flag_new_abi) + if (guard && initp) finish_expr_stmt (set_guard (guard)); return guard_if_stmt; @@ -3724,10 +3666,7 @@ finish_file () finish_function doesn't clean things up, and we end up with CURRENT_FUNCTION_DECL set. */ push_to_top_level (); - if (DECL_TINFO_FN_P (decl)) - synthesize_tinfo_fn (decl); - else - synthesize_method (decl); + synthesize_method (decl); pop_from_top_level (); reconsider = 1; } diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 5ecdab71fed..30912362f08 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -1963,7 +1963,7 @@ dump_expr (t, flags) t = TYPE_METHOD_BASETYPE (t); virtuals = TYPE_BINFO_VIRTUALS (TYPE_MAIN_VARIANT (t)); - n = tree_low_cst (idx, 0) - first_vfun_index (t); + n = tree_low_cst (idx, 0); /* Map vtable index back one, to allow for the null pointer to member. */ diff --git a/gcc/cp/except.c b/gcc/cp/except.c index bcca6863bcb..e53582100e3 100644 --- a/gcc/cp/except.c +++ b/gcc/cp/except.c @@ -867,8 +867,6 @@ expand_throw (exp) tree arg_types; arg_types = void_list_node; - if (!flag_new_abi) - arg_types = tree_cons (NULL_TREE, integer_type_node, arg_types); arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types); cleanup_type = (build_pointer_type (build_function_type (void_type_node, arg_types))); @@ -927,9 +925,7 @@ expand_throw (exp) if (TYPE_HAS_DESTRUCTOR (TREE_TYPE (object))) { cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)), - (flag_new_abi - ? complete_dtor_identifier - : dtor_identifier), + complete_dtor_identifier, 0); cleanup = TREE_VALUE (cleanup); mark_used (cleanup); diff --git a/gcc/cp/expr.c b/gcc/cp/expr.c index 603984ad017..fc22460ff97 100644 --- a/gcc/cp/expr.c +++ b/gcc/cp/expr.c @@ -56,18 +56,6 @@ cplus_expand_constant (cst) { /* Find the offset for the field. */ tree offset = byte_position (member); - - if (flag_new_abi) - /* Under the new ABI, we use -1 to represent the NULL - pointer; non-NULL values simply contain the offset of - the data member. */ - ; - else - /* We offset all pointer to data members by 1 so that we - can distinguish between a null pointer to data member - and the first data member of a structure. */ - offset = size_binop (PLUS_EXPR, offset, size_one_node); - cst = fold (build1 (NOP_EXPR, type, offset)); } else @@ -75,7 +63,7 @@ cplus_expand_constant (cst) tree delta, idx, pfn, delta2; expand_ptrmemfunc_cst (cst, &delta, &idx, &pfn, &delta2); - cst = build_ptrmemfunc1 (type, delta, idx, pfn, delta2); + cst = build_ptrmemfunc1 (type, delta, pfn); } } break; diff --git a/gcc/cp/init.c b/gcc/cp/init.c index e7d62934d6d..4e68b645b73 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1954,14 +1954,6 @@ resolve_offset_ref (exp) addr = convert_pointer_to (basetype, addr); member = cp_convert (ptrdiff_type_node, member); - if (!flag_new_abi) - /* Pointer to data members are offset by one, so that a null - pointer with a real value of 0 is distinguishable from an - offset of the first member of a structure. */ - member = cp_build_binary_op (MINUS_EXPR, member, - cp_convert (ptrdiff_type_node, - integer_one_node)); - return build1 (INDIRECT_REF, type, build (PLUS_EXPR, build_pointer_type (type), addr, member)); @@ -2224,20 +2216,17 @@ build_java_class_ref (type) } /* Mangle the class$ field, new and old ABI */ - if (flag_new_abi) - { - tree field; - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) - if (DECL_NAME (field) == CL_suffix) - { - name = mangle_decl (field); - break; - } - if (!field) - internal_error ("Can't find class$"); + { + tree field; + for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + if (DECL_NAME (field) == CL_suffix) + { + name = mangle_decl (field); + break; + } + if (!field) + internal_error ("Can't find class$"); } - else - name = build_static_name (type, CL_suffix); class_decl = IDENTIFIER_GLOBAL_VALUE (name); if (class_decl == NULL_TREE) @@ -2264,27 +2253,17 @@ get_cookie_size (type) { tree cookie_size; - if (flag_new_abi) - { - /* Under the new ABI, we need to allocate an additional max - (sizeof (size_t), alignof (true_type)) bytes. */ - tree sizetype_size; - tree type_align; - - sizetype_size = size_in_bytes (sizetype); - type_align = size_int (TYPE_ALIGN_UNIT (type)); - if (INT_CST_LT_UNSIGNED (type_align, sizetype_size)) - cookie_size = sizetype_size; - else - cookie_size = type_align; - } + /* Under the new ABI, we need to allocate an additional max + (sizeof (size_t), alignof (true_type)) bytes. */ + tree sizetype_size; + tree type_align; + + sizetype_size = size_in_bytes (sizetype); + type_align = size_int (TYPE_ALIGN_UNIT (type)); + if (INT_CST_LT_UNSIGNED (type_align, sizetype_size)) + cookie_size = sizetype_size; else - { - if (TYPE_ALIGN (type) > TYPE_ALIGN (BI_header_type)) - return size_int (TYPE_ALIGN_UNIT (type)); - else - return size_in_bytes (BI_header_type); - } + cookie_size = type_align; return cookie_size; } @@ -2386,7 +2365,7 @@ build_new_1 (exp) else if (placement && !TREE_CHAIN (placement) && same_type_p (TREE_TYPE (TREE_VALUE (placement)), ptr_type_node)) - use_cookie = (!flag_new_abi || !use_global_new); + use_cookie = !use_global_new; /* Otherwise, we need the cookie. */ else use_cookie = 1; @@ -2481,23 +2460,13 @@ build_new_1 (exp) tree cookie; /* Store the number of bytes allocated so that we can know how - many elements to destroy later. */ - if (flag_new_abi) - { - /* Under the new ABI, we use the last sizeof (size_t) bytes - to store the number of elements. */ - cookie = build (MINUS_EXPR, build_pointer_type (sizetype), - alloc_node, size_in_bytes (sizetype)); - cookie = build_indirect_ref (cookie, NULL_PTR); - } - else - { - cookie = build (MINUS_EXPR, build_pointer_type (BI_header_type), - alloc_node, cookie_size); - cookie = build_indirect_ref (cookie, NULL_PTR); - cookie = build_component_ref (cookie, nelts_identifier, - NULL_TREE, 0); - } + many elements to destroy later. Under the new ABI, we use + the last sizeof (size_t) bytes to store the number of + elements. */ + cookie = build (MINUS_EXPR, build_pointer_type (sizetype), + alloc_node, size_in_bytes (sizetype)); + cookie = build_indirect_ref (cookie, NULL_PTR); + cookie_expr = build (MODIFY_EXPR, void_type_node, cookie, nelts); TREE_SIDE_EFFECTS (cookie_expr) = 1; } @@ -3412,24 +3381,11 @@ build_vec_delete (base, maxindex, auto_delete_vec, use_global_delete) tree cookie_addr; type = strip_array_types (TREE_TYPE (type)); - if (flag_new_abi) - { - cookie_addr = build (MINUS_EXPR, - build_pointer_type (sizetype), - base, - TYPE_SIZE_UNIT (sizetype)); - maxindex = build_indirect_ref (cookie_addr, NULL_PTR); - } - else - { - tree cookie; - - cookie_addr = build (MINUS_EXPR, build_pointer_type (BI_header_type), - base, get_cookie_size (type)); - cookie = build_indirect_ref (cookie_addr, NULL_PTR); - maxindex = build_component_ref (cookie, nelts_identifier, - NULL_TREE, 0); - } + cookie_addr = build (MINUS_EXPR, + build_pointer_type (sizetype), + base, + TYPE_SIZE_UNIT (sizetype)); + maxindex = build_indirect_ref (cookie_addr, NULL_PTR); } else if (TREE_CODE (type) == ARRAY_TYPE) { diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index 58ab5d3aed4..f493928faaf 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -339,7 +339,7 @@ init_operators () : &operator_name_info[(int) CODE]); \ oni->identifier = identifier; \ oni->name = NAME; \ - oni->mangled_name = flag_new_abi ? NEW_MANGLING : OLD_MANGLING; + oni->mangled_name = NEW_MANGLING; #include "operators.def" #undef DEF_OPERATOR diff --git a/gcc/cp/method.c b/gcc/cp/method.c index 72702b402f1..a2b0a5aaea4 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -61,1851 +61,38 @@ struct pending_inline *pending_inlines; #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free -/* Obstack where we build text strings for overloading, etc. */ -static struct obstack scratch_obstack; -static char *scratch_firstobj; - -static void icat PARAMS ((HOST_WIDE_INT)); -static void dicat PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT)); -static int old_backref_index PARAMS ((tree)); -static int flush_repeats PARAMS ((int, tree)); -static void build_overload_identifier PARAMS ((tree)); -static void build_overload_nested_name PARAMS ((tree)); -static void mangle_expression PARAMS ((tree)); -static void build_overload_int PARAMS ((tree, mangling_flags)); -static void build_overload_identifier PARAMS ((tree)); -static void build_qualified_name PARAMS ((tree)); -static void build_overload_value PARAMS ((tree, tree, mangling_flags)); -static void issue_nrepeats PARAMS ((int, tree)); -static char *build_mangled_name PARAMS ((tree,int,int)); -static void process_modifiers PARAMS ((tree)); -static void process_overload_item PARAMS ((tree,int)); static void do_build_assign_ref PARAMS ((tree)); static void do_build_copy_constructor PARAMS ((tree)); -static void build_template_template_parm_names PARAMS ((tree)); -static void build_template_parm_names PARAMS ((tree, tree)); -static void build_underscore_int PARAMS ((int)); -static void start_squangling PARAMS ((void)); -static void end_squangling PARAMS ((void)); -static int check_ktype PARAMS ((tree, int)); -static int issue_ktype PARAMS ((tree)); -static void build_overload_scope_ref PARAMS ((tree)); -static void build_mangled_template_parm_index PARAMS ((const char *, tree)); #if HOST_BITS_PER_WIDE_INT >= 64 static void build_mangled_C99_name PARAMS ((int)); #endif -static int is_back_referenceable_type PARAMS ((tree)); -static int check_btype PARAMS ((tree)); -static void build_mangled_name_for_type PARAMS ((tree)); -static void build_mangled_name_for_type_with_Gcode PARAMS ((tree, int)); static tree synthesize_exception_spec PARAMS ((tree, tree (*) (tree, void *), void *)); static tree locate_dtor PARAMS ((tree, void *)); static tree locate_ctor PARAMS ((tree, void *)); static tree locate_copy PARAMS ((tree, void *)); -# define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0) -# define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C))) -# define OB_PUTC2(C1,C2) \ - (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2))) -# define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1)) -# define OB_PUTID(ID) \ - (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \ - IDENTIFIER_LENGTH (ID))) -# define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S))) -# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0')) -# define OB_LAST() (obstack_next_free (&scratch_obstack)[-1]) - -/* type tables for K and B type compression */ -static varray_type btypelist; -static varray_type ktypelist; - -/* number of each type seen */ -static size_t maxbtype; -static size_t maxktype; - -/* Array of types seen so far in top-level call to `build_mangled_name'. - Allocated and deallocated by caller. */ -static varray_type typevec; - -/* Number of types interned by `build_mangled_name' so far. */ -static size_t maxtype; - /* Called once to initialize method.c. */ void init_method () { - gcc_obstack_init (&scratch_obstack); - scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0); - ggc_add_tree_varray_root (&btypelist, 1); - ggc_add_tree_varray_root (&ktypelist, 1); - ggc_add_tree_varray_root (&typevec, 1); - if (flag_new_abi) - init_mangle (); + init_mangle (); } -/* This must be large enough to hold any printed integer or floating-point - value. */ -static char digit_buffer[128]; - -/* Here is where overload code starts. */ - -/* Nonzero if we should not try folding parameter types. */ -static int nofold; - -/* Nonzero if an underscore is required before adding a digit to the - mangled name currently being built. */ -static int numeric_output_need_bar; - -static inline void -start_squangling () -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200005222); - - if (flag_do_squangling) - { - nofold = 0; - maxbtype = 0; - maxktype = 0; - VARRAY_TREE_INIT (btypelist, 50, "btypelist"); - VARRAY_TREE_INIT (ktypelist, 50, "ktypelist"); - } -} - -static inline void -end_squangling () -{ - if (flag_do_squangling) - { - VARRAY_FREE (ktypelist); - VARRAY_FREE (btypelist); - maxbtype = 0; - maxktype = 0; - } -} - -/* Code to concatenate an asciified integer to a string. */ - -static inline void -icat (i) - HOST_WIDE_INT i; -{ - unsigned HOST_WIDE_INT ui; - - /* Handle this case first, to go really quickly. For many common values, - the result of ui/10 below is 1. */ - if (i == 1) - { - OB_PUTC ('1'); - return; - } - - if (i >= 0) - ui = i; - else - { - OB_PUTC ('m'); - ui = -i; - } - - if (ui >= 10) - icat (ui / 10); - - OB_PUTC ('0' + (ui % 10)); -} - -static void -dicat (lo, hi) - HOST_WIDE_INT lo, hi; -{ - unsigned HOST_WIDE_INT ulo, uhi, qlo, qhi; - - if (hi >= 0) - { - uhi = hi; - ulo = lo; - } - else - { - uhi = (lo == 0 ? -hi : -hi-1); - ulo = -lo; - } - if (uhi == 0 - && ulo < ((unsigned HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT - 1))) - { - icat (ulo); - return; - } - /* Divide 2^HOST_WIDE_INT*uhi+ulo by 10. */ - qhi = uhi / 10; - uhi = uhi % 10; - qlo = uhi * (((unsigned HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT - 1)) / 5); - qlo += ulo / 10; - ulo = ulo % 10; - ulo += uhi * (((unsigned HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT - 1)) % 5) - * 2; - qlo += ulo / 10; - ulo = ulo % 10; - /* Quotient is 2^HOST_WIDE_INT*qhi+qlo, remainder is ulo. */ - dicat (qlo, qhi); - OB_PUTC ('0' + ulo); -} - -/* Returns the index of TYPE in the typevec, or -1 if it's not there. */ - -static inline int -old_backref_index (type) - tree type; -{ - size_t tindex; - - if (! is_back_referenceable_type (type)) - return -1; - - /* The entry for this parm is at maxtype-1, so don't look there for - something to repeat. */ - for (tindex = 0; tindex < maxtype - 1; ++tindex) - if (same_type_p (VARRAY_TREE (typevec, tindex), type)) - break; - - if (tindex == maxtype - 1) - return -1; - - return tindex; -} - -/* Old mangling style: If TYPE has already been used in the parameter list, - emit a backward reference and return non-zero; otherwise, return 0. - - NREPEATS is the number of repeats we've recorded of this type, or 0 if - this is the first time we've seen it and we're just looking to see if - it had been used before. */ - -static inline int -flush_repeats (nrepeats, type) - int nrepeats; - tree type; -{ - int tindex = old_backref_index (type); - - if (tindex == -1) - { - my_friendly_assert (nrepeats == 0, 990316); - return 0; - } - - if (nrepeats > 1) - { - OB_PUTC ('N'); - icat (nrepeats); - if (nrepeats > 9) - OB_PUTC ('_'); - } - else - OB_PUTC ('T'); - icat (tindex); - if (tindex > 9) - OB_PUTC ('_'); - - return 1; -} - -/* Returns nonzero iff this is a type to which we will want to make - back-references (using the `B' code). */ - -static int -is_back_referenceable_type (type) - tree type; -{ - /* For some reason, the Java folks don't want back refs on these. */ - if (TYPE_FOR_JAVA (type)) - return 0; - - switch (TREE_CODE (type)) - { - case BOOLEAN_TYPE: - if (!flag_do_squangling) - /* Even though the mangling of this is just `b', we did - historically generate back-references for it. */ - return 1; - /* Fall through. */ - - case INTEGER_TYPE: - case REAL_TYPE: - case VOID_TYPE: - /* These types have single-character manglings, so there's no - point in generating back-references. */ - return 0; - - case TEMPLATE_TYPE_PARM: - /* It would be a bit complex to demangle signatures correctly if - we generated back-references to these, and the manglings of - type parameters are short. */ - return 0; - - default: - return 1; - } -} - -/* Issue the squangling code indicating NREPEATS repetitions of TYPE, - which was the last parameter type output. */ - -static void -issue_nrepeats (nrepeats, type) - int nrepeats; - tree type; -{ - if (nrepeats == 1 && !is_back_referenceable_type (type)) - /* For types whose manglings are short, don't bother using the - repetition code if there's only one repetition, since the - repetition code will be about as long as the ordinary mangling. */ - build_mangled_name_for_type (type); - else - { - OB_PUTC ('n'); - icat (nrepeats); - if (nrepeats > 9) - OB_PUTC ('_'); - } -} - -/* Check to see if a tree node has been entered into the Kcode typelist. - If not, add it. Returns -1 if it isn't found, otherwise returns the - index. */ - -static int -check_ktype (node, add) - tree node; - int add; -{ - size_t x; - tree localnode = node; - - if (ktypelist == NULL) - return -1; - - if (TREE_CODE (node) == TYPE_DECL) - localnode = TREE_TYPE (node); - - for (x = 0; x < maxktype; x++) - { - if (same_type_p (localnode, VARRAY_TREE (ktypelist, x))) - return x; - } - /* Didn't find it, so add it here. */ - if (add) - { - if (VARRAY_SIZE (ktypelist) <= maxktype) - VARRAY_GROW (ktypelist, - VARRAY_SIZE (ktypelist) * 3 / 2); - VARRAY_TREE (ktypelist, maxktype) = localnode; - maxktype++; - } - return -1; -} - - -static inline int -issue_ktype (decl) - tree decl; -{ - int kindex; - kindex = check_ktype (decl, FALSE); - if (kindex != -1) - { - OB_PUTC ('K'); - icat (kindex); - if (kindex > 9) - OB_PUTC ('_'); - return TRUE; - } - return FALSE; -} - -/* Build a representation for DECL, which may be an entity not at - global scope. If so, a marker indicating that the name is - qualified has already been output, but the qualifying context has - not. */ - -static void -build_overload_nested_name (decl) - tree decl; -{ - tree context; - - if (ktypelist && issue_ktype (decl)) - return; - - if (decl == global_namespace) - return; - - context = CP_DECL_CONTEXT (decl); - - /* try to issue a K type, and if we can't continue the normal path */ - if (!(ktypelist && issue_ktype (context))) - { - /* For a template type parameter, we want to output an 'Xn' - rather than 'T' or some such. */ - if (TREE_CODE (context) == TEMPLATE_TYPE_PARM - || TREE_CODE (context) == TEMPLATE_TEMPLATE_PARM - || TREE_CODE (context) == BOUND_TEMPLATE_TEMPLATE_PARM) - build_mangled_name_for_type (context); - else - { - if (TYPE_P (context)) - context = TYPE_NAME (context); - build_overload_nested_name (context); - } - } - - if (TREE_CODE (decl) == FUNCTION_DECL) - { - static int static_labelno; - - tree name = DECL_ASSEMBLER_NAME (decl); - char *label; - - ASM_FORMAT_PRIVATE_NAME (label, IDENTIFIER_POINTER (name), static_labelno); - static_labelno++; - - if (numeric_output_need_bar) - OB_PUTC ('_'); - icat (strlen (label)); - OB_PUTCP (label); - numeric_output_need_bar = 1; - } - else if (TREE_CODE (decl) == NAMESPACE_DECL) - build_overload_identifier (DECL_NAME (decl)); - else /* TYPE_DECL */ - build_overload_identifier (decl); -} - -/* Output the decimal representation of I. If I > 9, the decimal - representation is preceeded and followed by an underscore. */ - -static void -build_underscore_int (i) - int i; -{ - if (i > 9) - OB_PUTC ('_'); - icat (i); - if (i > 9) - OB_PUTC ('_'); -} - -static void -build_overload_scope_ref (value) - tree value; -{ - OB_PUTC2 ('Q', '2'); - numeric_output_need_bar = 0; - build_mangled_name_for_type (TREE_OPERAND (value, 0)); - build_overload_identifier (TREE_OPERAND (value, 1)); -} - -/* VALUE is a complex expression. Produce an appropriate mangling. - (We are forced to mangle complex expressions when dealing with - templates, and an expression involving template parameters appears - in the type of a function parameter.) */ - -static void -mangle_expression (value) - tree value; -{ - if (TREE_CODE (value) == SCOPE_REF) - { - build_overload_scope_ref (value); - return; - } - - OB_PUTC ('E'); - numeric_output_need_bar = 0; - - if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (value)))) - { - int i; - int operands = TREE_CODE_LENGTH (TREE_CODE (value)); - const char *name; - - name = operator_name_info[TREE_CODE (value)].mangled_name; - if (name == NULL) - /* On some erroneous inputs, we can get here with VALUE a - LOOKUP_EXPR. We must survive this routine in order to issue - a sensible error message, so we fall through to the case - below. */ - goto bad_value; - - for (i = 0; i < operands; ++i) - { - tree operand; - enum tree_code tc; - - /* We just outputted either the `E' or the name of the - operator. */ - numeric_output_need_bar = 0; - - if (i != 0) - /* Skip the leading underscores. */ - OB_PUTCP (name + 2); - - operand = TREE_OPERAND (value, i); - tc = TREE_CODE (operand); - - if (TREE_CODE_CLASS (tc) == 't') - /* We can get here with sizeof, e.g.: - - template void f(A); */ - build_mangled_name_for_type (operand); - else - build_overload_value (TREE_TYPE (operand), - operand, - mf_maybe_uninstantiated); - } - } - else - { - /* We don't ever want this output, but it's - inconvenient not to be able to build the string. - This should cause assembler errors we'll notice. */ - - static int n; - bad_value: - sprintf (digit_buffer, " *%d", n++); - OB_PUTCP (digit_buffer); - } - - OB_PUTC ('W'); - numeric_output_need_bar = 0; -} - -/* Encoding for an INTEGER_CST value. */ - -static void -build_overload_int (value, flags) - tree value; - mangling_flags flags; -{ - int multiple_words_p = 0; - int multiple_digits_p = 0; - - if ((flags & mf_maybe_uninstantiated) && TREE_CODE (value) != INTEGER_CST) - { - mangle_expression (value); - return; - } - - /* Unless we were looking at an uninstantiated template, integers - should always be represented by constants. */ - my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243); - - /* If value doesn't fit in a single HOST_WIDE_INT, we must use a - special output routine that can deal with this. */ - if (! host_integerp (value, 0)) - { - multiple_words_p = 1; - /* And there is certainly going to be more than one digit. */ - multiple_digits_p = 1; - } - else - multiple_digits_p = ((HOST_WIDE_INT) TREE_INT_CST_LOW (value) > 9 - || (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < -9); - - /* If necessary, add a leading underscore. */ - if (multiple_digits_p && (flags & mf_use_underscores_around_value)) - OB_PUTC ('_'); - - /* Output the number itself. */ - if (multiple_words_p) - dicat (TREE_INT_CST_LOW (value), TREE_INT_CST_HIGH (value)); - else - icat (TREE_INT_CST_LOW (value)); - - if (flags & mf_use_underscores_around_value) - { - if (multiple_digits_p) - OB_PUTC ('_'); - /* Whether or not there were multiple digits, we don't need an - underscore. We've either terminated the number with an - underscore, or else it only had one digit. */ - numeric_output_need_bar = 0; - } - else - /* We just output a numeric value. */ - numeric_output_need_bar = 1; -} - - -/* Output S followed by a representation of the TEMPLATE_PARM_INDEX - supplied in INDEX. */ - -static void -build_mangled_template_parm_index (s, index) - const char *s; - tree index; -{ - OB_PUTCP (s); - build_underscore_int (TEMPLATE_PARM_IDX (index)); - /* We use the LEVEL, not the ORIG_LEVEL, because the mangling is a - representation of the function from the point of view of its - type. */ - build_underscore_int (TEMPLATE_PARM_LEVEL (index)); -} - - -/* Mangling for C99 integer types (and Cygnus extensions for 128-bit - and other types) is based on the letter "I" followed by the hex - representations of the bitsize for the type in question. For - encodings that result in larger than two digits, a leading and - trailing underscore is added. - - Thus: - int1_t = 001 = I01 - int8_t = 008 = I08 - int16_t = 010 = I10 - int24_t = 018 = I18 - int32_t = 020 = I20 - int64_t = 040 = I40 - int80_t = 050 = I50 - int128_t = 080 = I80 - int256_t = 100 = I_100_ - int512_t = 200 = I_200_ - - Given an integer in decimal format, mangle according to this scheme. */ - -#if HOST_BITS_PER_WIDE_INT >= 64 -static void -build_mangled_C99_name (bits) - int bits; -{ - char mangled[10] = ""; - - if (bits > 255) - sprintf (mangled, "I_%x_", bits); - else - sprintf (mangled, "I%.2x", bits); - - OB_PUTCP (mangled); -} -#endif - -static void -build_overload_value (type, value, flags) - tree type, value; - mangling_flags flags; -{ - my_friendly_assert (TYPE_P (type), 0); - - while (TREE_CODE (value) == NON_LVALUE_EXPR - || TREE_CODE (value) == NOP_EXPR) - value = TREE_OPERAND (value, 0); - - if (numeric_output_need_bar) - { - OB_PUTC ('_'); - numeric_output_need_bar = 0; - } - - if (TREE_CODE (value) == TEMPLATE_PARM_INDEX) - { - build_mangled_template_parm_index ("Y", value); - return; - } - - if (TYPE_PTRMEM_P (type)) - { - if (TREE_CODE (value) != PTRMEM_CST) - /* We should have already rejected this pointer to member, - since it is not a constant. */ - my_friendly_abort (0); - - /* Get the actual FIELD_DECL. */ - value = PTRMEM_CST_MEMBER (value); - my_friendly_assert (TREE_CODE (value) == FIELD_DECL, 0); - - /* Output the name of the field. */ - build_overload_identifier (DECL_NAME (value)); - return; - } - else if (INTEGRAL_TYPE_P (type)) - { - build_overload_int (value, flags); - return; - } - - /* The only case where we use the extra underscores here is when - forming the mangling for an integral non-type template argument. - If that didn't happen, stop now. */ - flags &= ~mf_use_underscores_around_value; - - switch (TREE_CODE (type)) - { - case REAL_TYPE: - { - REAL_VALUE_TYPE val; - char *bufp = digit_buffer; - - /* We must handle non-constants in templates. */ - if (TREE_CODE (value) != REAL_CST) - { - mangle_expression (value); - break; - } - - val = TREE_REAL_CST (value); - if (REAL_VALUE_ISNAN (val)) - { - sprintf (bufp, "NaN"); - } - else - { - if (REAL_VALUE_NEGATIVE (val)) - { - val = REAL_VALUE_NEGATE (val); - *bufp++ = 'm'; - } - if (REAL_VALUE_ISINF (val)) - { - sprintf (bufp, "Infinity"); - } - else - { - REAL_VALUE_TO_DECIMAL (val, "%.20e", bufp); - bufp = (char *) strchr (bufp, 'e'); - if (!bufp) - strcat (digit_buffer, "e0"); - else - { - char *p; - bufp++; - if (*bufp == '-') - { - *bufp++ = 'm'; - } - p = bufp; - if (*p == '+') - p++; - while (*p == '0') - p++; - if (*p == 0) - { - *bufp++ = '0'; - *bufp = 0; - } - else if (p != bufp) - { - while (*p) - *bufp++ = *p++; - *bufp = 0; - } - } -#ifdef NO_DOT_IN_LABEL - bufp = (char *) strchr (bufp, '.'); - if (bufp) - *bufp = '_'; -#endif - } - } - OB_PUTCP (digit_buffer); - numeric_output_need_bar = 1; - return; - } - case POINTER_TYPE: - if (TREE_CODE (value) == INTEGER_CST) - { - build_overload_int (value, flags); - return; - } - else if (TREE_CODE (value) == TEMPLATE_PARM_INDEX) - { - build_mangled_template_parm_index ("", value); - numeric_output_need_bar = 1; - return; - } - - value = TREE_OPERAND (value, 0); - - /* Fall through. */ - - case REFERENCE_TYPE: - if (TREE_CODE (value) == ADDR_EXPR) - value = TREE_OPERAND (value, 0); - - if (TREE_CODE (value) == VAR_DECL) - { - my_friendly_assert (DECL_NAME (value) != 0, 245); - build_overload_identifier (DECL_ASSEMBLER_NAME (value)); - return; - } - else if (TREE_CODE (value) == FUNCTION_DECL) - { - my_friendly_assert (DECL_NAME (value) != 0, 246); - build_overload_identifier (DECL_ASSEMBLER_NAME (value)); - return; - } - else if (TREE_CODE (value) == SCOPE_REF) - build_overload_scope_ref (value); - else - my_friendly_abort (71); - break; /* not really needed */ - - case RECORD_TYPE: - { - tree delta; - tree idx; - tree pfn; - tree delta2; - tree fn; - - my_friendly_assert (TYPE_PTRMEMFUNC_P (type), 0); - - /* We'll get a ADDR_EXPR of a SCOPE_REF here if we're - mangling, an instantiation of something like: - - template class C {}; - template C x(); - - We mangle the return type of the function, and that - contains template parameters. */ - if (TREE_CODE (value) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (value, 0)) == SCOPE_REF) - { - build_overload_scope_ref (TREE_OPERAND (value, 0)); - break; - } - - my_friendly_assert (TREE_CODE (value) == PTRMEM_CST, 0); - - expand_ptrmemfunc_cst (value, &delta, &idx, &pfn, &delta2); - fn = PTRMEM_CST_MEMBER (value); - build_overload_int (delta, flags); - OB_PUTC ('_'); - if (!flag_new_abi) - { - build_overload_int (idx, flags); - OB_PUTC ('_'); - } - else if (DECL_VIRTUAL_P (fn)) - { - build_overload_int (DECL_VINDEX (fn), flags); - OB_PUTC ('_'); - } - - if (!DECL_VIRTUAL_P (fn)) - { - numeric_output_need_bar = 0; - build_overload_identifier (DECL_ASSEMBLER_NAME (fn)); - } - else if (!flag_new_abi) - { - OB_PUTC ('i'); - build_overload_int (delta2, flags); - } - } - break; - - default: - sorry ("conversion of %s as template parameter", - tree_code_name [(int) TREE_CODE (type)]); - my_friendly_abort (72); - } -} - - -/* Add encodings for the declaration of template template parameters. - PARMLIST must be a TREE_VEC. */ - -static void -build_template_template_parm_names (parmlist) - tree parmlist; -{ - int i, nparms; - - my_friendly_assert (TREE_CODE (parmlist) == TREE_VEC, 990228); - nparms = TREE_VEC_LENGTH (parmlist); - icat (nparms); - for (i = 0; i < nparms; i++) - { - tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i)); - if (TREE_CODE (parm) == TYPE_DECL) - { - /* This parameter is a type. */ - OB_PUTC ('Z'); - } - else if (TREE_CODE (parm) == TEMPLATE_DECL) - { - /* This parameter is a template. */ - OB_PUTC ('z'); - build_template_template_parm_names (DECL_INNERMOST_TEMPLATE_PARMS (parm)); - } - else - /* It's a PARM_DECL. */ - build_mangled_name_for_type (TREE_TYPE (parm)); - } -} - - -/* Add encodings for the vector of template parameters in PARMLIST, - given the vector of arguments to be substituted in ARGLIST. */ - -static void -build_template_parm_names (parmlist, arglist) - tree parmlist; - tree arglist; -{ - int i, nparms; - tree inner_args = INNERMOST_TEMPLATE_ARGS (arglist); - - nparms = TREE_VEC_LENGTH (parmlist); - icat (nparms); - for (i = 0; i < nparms; i++) - { - tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i)); - tree arg = TREE_VEC_ELT (inner_args, i); - if (TREE_CODE (parm) == TYPE_DECL) - { - /* This parameter is a type. */ - OB_PUTC ('Z'); - build_mangled_name_for_type (arg); - } - else if (TREE_CODE (parm) == TEMPLATE_DECL) - { - /* This parameter is a template. */ - if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM) - /* Output parameter declaration, argument index and level. */ - build_mangled_name_for_type (arg); - else - { - /* A TEMPLATE_DECL node, output the parameter declaration - and template name */ - - OB_PUTC ('z'); - build_template_template_parm_names - (DECL_INNERMOST_TEMPLATE_PARMS (parm)); - icat (IDENTIFIER_LENGTH (DECL_NAME (arg))); - OB_PUTID (DECL_NAME (arg)); - } - } - else - { - parm = tsubst (parm, inner_args, /*complain=*/1, NULL_TREE); - /* It's a PARM_DECL. */ - build_mangled_name_for_type (TREE_TYPE (parm)); - build_overload_value (TREE_TYPE (parm), arg, - ((mf_maybe_uninstantiated - * uses_template_parms (arglist)) - | mf_use_underscores_around_value)); - } - } - } - -/* Output the representation for NAME, which is either a TYPE_DECL or - an IDENTIFIER. */ - -static void -build_overload_identifier (name) - tree name; -{ - if (TREE_CODE (name) == TYPE_DECL - && CLASS_TYPE_P (TREE_TYPE (name)) - && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (name)) - && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (TREE_TYPE (name))) - || (TREE_CODE (CP_DECL_CONTEXT (CLASSTYPE_TI_TEMPLATE - (TREE_TYPE (name)))) - == FUNCTION_DECL))) - { - /* NAME is the TYPE_DECL for a template specialization. */ - tree template, parmlist, arglist, tname; - template = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (name)); - arglist = CLASSTYPE_TI_ARGS (TREE_TYPE (name)); - tname = DECL_NAME (template); - parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template); - OB_PUTC ('t'); - icat (IDENTIFIER_LENGTH (tname)); - OB_PUTID (tname); - build_template_parm_names (parmlist, arglist); - } - else - { - if (TREE_CODE (name) == TYPE_DECL) - name = DECL_NAME (name); - if (numeric_output_need_bar) - { - OB_PUTC ('_'); - numeric_output_need_bar = 0; - } - icat (IDENTIFIER_LENGTH (name)); - OB_PUTID (name); - } -} - -/* Given DECL, either a class TYPE, TYPE_DECL or FUNCTION_DECL, produce - the mangling for it. Used by build_mangled_name and build_static_name. */ - -static void -build_qualified_name (decl) - tree decl; -{ - tree context; - int i = 1; - - if (TYPE_P (decl)) - decl = TYPE_NAME (decl); - - /* If DECL_ASSEMBLER_NAME has been set properly, use it. */ - if (TREE_CODE (decl) == TYPE_DECL - && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) && !flag_do_squangling) - { - tree id = DECL_ASSEMBLER_NAME (decl); - OB_PUTID (id); - if (ISDIGIT (IDENTIFIER_POINTER (id) [IDENTIFIER_LENGTH (id) - 1])) - numeric_output_need_bar = 1; - return; - } - - context = decl; - /* If we can't find a Ktype, do it the hard way. */ - if (check_ktype (context, FALSE) == -1) - { - /* Count type and namespace scopes. */ - while (1) - { - context = CP_DECL_CONTEXT (context); - if (context == global_namespace) - break; - i += 1; - if (check_ktype (context, FALSE) != -1) - /* Found one! */ - break; - if (TYPE_P (context)) - context = TYPE_NAME (context); - } - } - - if (i > 1) - { - OB_PUTC ('Q'); - build_underscore_int (i); - numeric_output_need_bar = 0; - } - build_overload_nested_name (decl); -} - -/* Output the mangled representation for TYPE. If EXTRA_GCODE is - non-zero, mangled names for structure/union types are intentionally - mangled differently from the method described in the ARM. */ - -static void -build_mangled_name_for_type_with_Gcode (type, extra_Gcode) - tree type; - int extra_Gcode; -{ - if (TYPE_PTRMEMFUNC_P (type)) - type = TYPE_PTRMEMFUNC_FN_TYPE (type); - process_modifiers (type); - process_overload_item (type, extra_Gcode); -} - -/* Like build_mangled_name_for_type_with_Gcode, but never outputs the - `G'. */ - -static void -build_mangled_name_for_type (type) - tree type; -{ - build_mangled_name_for_type_with_Gcode (type, 0); -} - -/* Given a list of parameters in PARMTYPES, create an unambiguous - overload string. Should distinguish any type that C (or C++) can - distinguish. I.e., pointers to functions are treated correctly. - - Caller must deal with whether a final `e' goes on the end or not. - - Any default conversions must take place before this function - is called. - - BEGIN and END control initialization and finalization of the - obstack where we build the string. */ - -char * -build_overload_name (parmtypes, begin, end) - tree parmtypes; - int begin, end; -{ - char *ret; - - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200005221); - - start_squangling (); - ret = build_mangled_name (parmtypes, begin, end); - end_squangling (); - return ret ; -} - -/* Output the mangled representation for PARMTYPES. If PARMTYPES is a - TREE_LIST, then it is a list of parameter types. Otherwise, - PARMTYPES must be a single type. */ - -static char * -build_mangled_name (parmtypes, begin, end) - tree parmtypes; - int begin, end; -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200004105); - - if (begin) - OB_INIT (); - - if (TREE_CODE (parmtypes) != TREE_LIST) - /* There is only one type. */ - build_mangled_name_for_type (parmtypes); - else - { - /* There are several types in a parameter list. */ - int nrepeats = 0; - int old_style_repeats = !flag_do_squangling && !nofold && typevec; - tree last_type = NULL_TREE; - - for (; parmtypes && parmtypes != void_list_node; - parmtypes = TREE_CHAIN (parmtypes)) - { - /* We used to call canonical_type_variant here, but that isn't - good enough; it doesn't handle pointers to typedef types. So - we can't just set TREE_USED to say we've seen a type already; - we have to check each of the earlier types with same_type_p. */ - tree parmtype = TREE_VALUE (parmtypes); - - if (old_style_repeats) - { - /* Every argument gets counted. */ - my_friendly_assert (maxtype < VARRAY_SIZE (typevec), 387); - VARRAY_TREE (typevec, maxtype) = parmtype; - maxtype++; - } - - if (last_type && same_type_p (parmtype, last_type)) - { - if (flag_do_squangling - || (old_style_repeats - && is_back_referenceable_type (parmtype))) - { - /* The next type is the same as this one. Keep - track of the repetition, and output the repeat - count later. */ - nrepeats++; - continue; - } - } - else if (nrepeats != 0) - { - /* Indicate how many times the previous parameter was - repeated. */ - if (old_style_repeats) - flush_repeats (nrepeats, last_type); - else - issue_nrepeats (nrepeats, last_type); - nrepeats = 0; - } - - /* Insead of protecting flush_repeats() against - error_mark_node, we can do it here. Since we wouldn't - add anything for an ERROR_MARK anyway, it's ok to skip - the mangling for this type. */ - if (old_style_repeats && parmtype == error_mark_node) - { - last_type = NULL_TREE; - continue; - } - - last_type = parmtype; - - /* Note that for bug-compatibility with 2.7.2, we can't build up - repeats of types other than the most recent one. So we call - flush_repeats every round, if we get this far. */ - if (old_style_repeats && flush_repeats (0, parmtype)) - continue; - - /* Output the PARMTYPE. */ - build_mangled_name_for_type_with_Gcode (parmtype, 1); - } - - /* Output the repeat count for the last parameter, if - necessary. */ - if (nrepeats != 0) - { - if (old_style_repeats) - flush_repeats (nrepeats, last_type); - else - issue_nrepeats (nrepeats, last_type); - nrepeats = 0; - } - - if (!parmtypes) - /* The parameter list ends in an ellipsis. */ - OB_PUTC ('e'); - } - - if (end) - OB_FINISH (); - return (char *) obstack_base (&scratch_obstack); -} - -/* Emit modifiers such as constant, read-only, and volatile. */ - -static void -process_modifiers (parmtype) - tree parmtype; -{ - /* Note that here we do not use CP_TYPE_CONST_P and friends because - we describe types recursively; we will get the `const' in - `const int ()[10]' when processing the `const int' part. */ - if (TYPE_READONLY (parmtype)) - OB_PUTC ('C'); - if (TREE_CODE (parmtype) == INTEGER_TYPE - && ! same_type_p (parmtype, char_type_node) - && ! same_type_p (parmtype, wchar_type_node) - && (TYPE_MAIN_VARIANT (parmtype) - == unsigned_type (TYPE_MAIN_VARIANT (parmtype))) - && ! TYPE_FOR_JAVA (parmtype)) - OB_PUTC ('U'); - if (TYPE_VOLATILE (parmtype)) - OB_PUTC ('V'); - /* It would be better to use `R' for `restrict', but that's already - used for reference types. And `r' is used for `long double'. */ - if (TYPE_RESTRICT (parmtype)) - OB_PUTC ('u'); -} - -/* Check to see if TYPE has been entered into the Bcode typelist. If - so, return 1 and emit a backreference to TYPE. Otherwise, add TYPE - to the list of back-referenceable types and return 0. */ - -static int -check_btype (type) - tree type; -{ - size_t x; - - if (btypelist == NULL) - return 0; - - if (!is_back_referenceable_type (type)) - return 0; - - for (x = 0; x < maxbtype; x++) - if (same_type_p (type, VARRAY_TREE (btypelist, x))) - { - OB_PUTC ('B'); - icat (x); - if (x > 9) - OB_PUTC ('_'); - return 1 ; - } - - if (VARRAY_SIZE (btypelist) <= maxbtype) - /* Enlarge the table. */ - VARRAY_GROW (btypelist, - VARRAY_SIZE (btypelist) * 3 / 2); - - /* Register the TYPE. */ - VARRAY_TREE (btypelist, maxbtype) = type; - maxbtype++; - - return 0; -} - -/* Emit the correct code for various node types. */ - -static void -process_overload_item (parmtype, extra_Gcode) - tree parmtype; - int extra_Gcode; -{ - tree tmp; - - numeric_output_need_bar = 0; - - /* Our caller should have already handed any qualifiers, so pull out the - TYPE_MAIN_VARIANT to avoid typedef confusion. Except we can't do that - for arrays, because they are transparent to qualifiers. Sigh. */ - if (TREE_CODE (parmtype) == ARRAY_TYPE) - parmtype = canonical_type_variant (parmtype); - else - parmtype = TYPE_MAIN_VARIANT (parmtype); - - /* These tree types are considered modifiers for B code squangling, - and therefore should not get entries in the Btypelist. They are, - however, repeatable types. */ - - switch (TREE_CODE (parmtype)) - { - case REFERENCE_TYPE: - OB_PUTC ('R'); - goto more; - - case ARRAY_TYPE: - { - OB_PUTC ('A'); - if (TYPE_DOMAIN (parmtype) == NULL_TREE) - OB_PUTC ('_'); - else - { - tree length = array_type_nelts (parmtype); - if (TREE_CODE (length) != INTEGER_CST || flag_do_squangling) - { - if (TREE_CODE (length) == MINUS_EXPR - && TREE_OPERAND (length, 1) == integer_one_node) - length = TREE_OPERAND (length, 0); - else - length = fold (build (PLUS_EXPR, TREE_TYPE (length), - length, integer_one_node)); - STRIP_NOPS (length); - } - build_overload_value (sizetype, length, 1); - } - if (numeric_output_need_bar && ! flag_do_squangling) - OB_PUTC ('_'); - goto more; - } - - case POINTER_TYPE: - OB_PUTC ('P'); - more: - build_mangled_name_for_type (TREE_TYPE (parmtype)); - return; - break; - - default: - break; - } - - if (flag_do_squangling && check_btype (parmtype)) - /* If PARMTYPE is already in the list of back-referenceable types, - then check_btype will output the appropriate reference, and - there's nothing more to do. */ - return; - - switch (TREE_CODE (parmtype)) - { - case OFFSET_TYPE: - OB_PUTC ('O'); - build_mangled_name_for_type (TYPE_OFFSET_BASETYPE (parmtype)); - OB_PUTC ('_'); - build_mangled_name_for_type (TREE_TYPE (parmtype)); - break; - - case FUNCTION_TYPE: - case METHOD_TYPE: - { - tree parms = TYPE_ARG_TYPES (parmtype); - - /* Rather than implementing a reentrant TYPEVEC, we turn off - repeat codes here, unless we're squangling. Squangling - doesn't make use of the TYPEVEC, so there's no reentrancy - problem. */ - int old_nofold = nofold; - if (!flag_do_squangling) - nofold = 1; - - if (TREE_CODE (parmtype) == METHOD_TYPE) - { - /* Mark this as a method. */ - OB_PUTC ('M'); - /* Output the class of which this method is a member. */ - build_mangled_name_for_type (TYPE_METHOD_BASETYPE (parmtype)); - /* Output any qualifiers for the `this' parameter. */ - process_modifiers (TREE_TYPE (TREE_VALUE (parms))); - } - - /* Output the parameter types. */ - OB_PUTC ('F'); - if (parms == NULL_TREE) - OB_PUTC ('e'); - else if (parms == void_list_node) - OB_PUTC ('v'); - else - build_mangled_name (parms, 0, 0); - - /* Output the return type. */ - OB_PUTC ('_'); - build_mangled_name_for_type (TREE_TYPE (parmtype)); - - nofold = old_nofold; - break; - } - - case INTEGER_TYPE: - iagain: - if (parmtype == integer_type_node - || parmtype == unsigned_type_node - || parmtype == java_int_type_node) - OB_PUTC ('i'); - else if (parmtype == long_integer_type_node - || parmtype == long_unsigned_type_node) - OB_PUTC ('l'); - else if (parmtype == short_integer_type_node - || parmtype == short_unsigned_type_node - || parmtype == java_short_type_node) - OB_PUTC ('s'); - else if (parmtype == signed_char_type_node) - { - OB_PUTC ('S'); - OB_PUTC ('c'); - } - else if (parmtype == char_type_node - || parmtype == unsigned_char_type_node - || parmtype == java_byte_type_node) - OB_PUTC ('c'); - else if (parmtype == wchar_type_node - || parmtype == java_char_type_node) - OB_PUTC ('w'); - else if (parmtype == long_long_integer_type_node - || parmtype == long_long_unsigned_type_node - || parmtype == java_long_type_node) - OB_PUTC ('x'); - else if (parmtype == java_boolean_type_node) - OB_PUTC ('b'); - /* Handle intSI_type_node and such like their C++ equivalents. */ - else if (tmp = type_for_mode (TYPE_MODE (parmtype), - TREE_UNSIGNED (parmtype)), - parmtype != tmp) - { - parmtype = tmp; - goto iagain; - } -#if HOST_BITS_PER_WIDE_INT >= 64 - else - { - int bits = TREE_INT_CST_LOW (TYPE_SIZE (parmtype)); - build_mangled_C99_name (bits); - } -#else - else - my_friendly_abort (73); -#endif - break; - - case BOOLEAN_TYPE: - OB_PUTC ('b'); - break; - - case REAL_TYPE: - if (parmtype == long_double_type_node) - OB_PUTC ('r'); - else if (parmtype == double_type_node - || parmtype == java_double_type_node) - OB_PUTC ('d'); - else if (parmtype == float_type_node - || parmtype == java_float_type_node) - OB_PUTC ('f'); - else my_friendly_abort (74); - break; - - case COMPLEX_TYPE: - OB_PUTC ('J'); - build_mangled_name_for_type (TREE_TYPE (parmtype)); - break; - - case VECTOR_TYPE: - OB_PUTC ('o'); - build_mangled_name_for_type (TREE_TYPE (parmtype)); - break; - - case VOID_TYPE: - OB_PUTC ('v'); - break; - - case ERROR_MARK: /* not right, but nothing is anyway */ - break; - - /* have to do these */ - case UNION_TYPE: - case RECORD_TYPE: - { - if (extra_Gcode) - OB_PUTC ('G'); /* make it look incompatible with AT&T */ - /* drop through into next case */ - } - case ENUMERAL_TYPE: - { - tree name = TYPE_NAME (parmtype); - - my_friendly_assert (TREE_CODE (name) == TYPE_DECL, 248); - - build_qualified_name (name); - break; - } - - case UNKNOWN_TYPE: - /* This will take some work. */ - OB_PUTC ('?'); - break; - - case BOUND_TEMPLATE_TEMPLATE_PARM: - /* Find and output the original template parameter - declaration. */ - build_mangled_template_parm_index ("tzX", - TEMPLATE_TYPE_PARM_INDEX - (parmtype)); - build_template_parm_names - (DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (parmtype)), - TYPE_TI_ARGS (parmtype)); - break; - - case TEMPLATE_TEMPLATE_PARM: - build_mangled_template_parm_index ("ZzX", - TEMPLATE_TYPE_PARM_INDEX - (parmtype)); - build_template_template_parm_names - (DECL_INNERMOST_TEMPLATE_PARMS (TYPE_STUB_DECL (parmtype))); - break; - - case TEMPLATE_TYPE_PARM: - build_mangled_template_parm_index ("X", - TEMPLATE_TYPE_PARM_INDEX - (parmtype)); - break; - - case TYPENAME_TYPE: - /* When mangling the type of a function template whose - declaration looks like: - - template void foo(typename T::U) - - we have to mangle these. */ - build_qualified_name (parmtype); - break; - - default: - my_friendly_abort (75); - } - -} - -/* Produce the mangling for a variable named NAME in CONTEXT, which can - be either a class TYPE or a FUNCTION_DECL. */ - -tree -build_static_name (context, name) - tree context, name; -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200004106); - - OB_INIT (); - numeric_output_need_bar = 0; - start_squangling (); -#ifdef JOINER - OB_PUTC ('_'); - build_qualified_name (context); - OB_PUTC (JOINER); -#else - OB_PUTS ("__static_"); - build_qualified_name (context); - OB_PUTC ('_'); -#endif - OB_PUTID (name); - OB_FINISH (); - end_squangling (); - - return get_identifier ((char *)obstack_base (&scratch_obstack)); -} - -/* FOR_METHOD should be 1 if the declaration in question is for a member - of a class (including a static member) and 2 if the declaration is - for a constructor. */ -tree -build_decl_overload_real (decl, parms, ret_type, tparms, targs, - for_method) - tree decl; - tree parms; - tree ret_type; - tree tparms; - tree targs; - int for_method; -{ - const char *name; - enum tree_code operator_code; - - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 20000410); - - operator_code = DECL_OVERLOADED_OPERATOR_P (decl); - if (!DECL_CONV_FN_P (decl) && operator_code) - { - /* member operators new and delete look like methods at this - point. */ - if (! for_method && CP_DECL_CONTEXT (decl) == global_namespace - && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST - && TREE_CHAIN (parms) == void_list_node) - switch (operator_code) - { - case DELETE_EXPR: - return get_identifier ("__builtin_delete"); - case VEC_DELETE_EXPR: - return get_identifier ("__builtin_vec_delete"); - case NEW_EXPR: - return get_identifier ("__builtin_new"); - case VEC_NEW_EXPR: - return get_identifier ("__builtin_vec_new"); - default: - break; - } - - if (DECL_ASSIGNMENT_OPERATOR_P (decl)) - name = assignment_operator_name_info[(int) operator_code].mangled_name; - else - name = operator_name_info[(int) operator_code].mangled_name; - } - else - name = IDENTIFIER_POINTER (DECL_NAME (decl)); - - start_squangling (); - OB_INIT (); - if (for_method != 2) - OB_PUTCP (name); - /* Otherwise, we can divine that this is a constructor, - and figure out its name without any extra encoding. */ - - OB_PUTC2 ('_', '_'); - numeric_output_need_bar = 0; - - if (tparms) - { - OB_PUTC ('H'); - build_template_parm_names (tparms, targs); - OB_PUTC ('_'); - } - else if (!for_method && CP_DECL_CONTEXT (decl) == global_namespace) - OB_PUTC ('F'); - - if (!for_method && CP_DECL_CONTEXT (decl) != global_namespace) - /* qualify with namespace */ - build_qualified_name (CP_DECL_CONTEXT (decl)); - - if (parms == NULL_TREE) - OB_PUTC ('e'); - else if (parms == void_list_node) - OB_PUTC ('v'); - else - { - if (!flag_do_squangling) - { - /* Allocate typevec array. */ - size_t typevec_size = list_length (parms); - maxtype = 0; - if (!for_method && CP_DECL_CONTEXT (decl) != global_namespace) - /* The namespace of a global function needs one slot. */ - typevec_size++; - VARRAY_TREE_INIT (typevec, typevec_size, "typevec"); - } - nofold = 0; - - if (for_method) - { - tree this_type = TREE_TYPE (TREE_VALUE (parms)); - - build_mangled_name_for_type (this_type); - - if (!flag_do_squangling) - { - my_friendly_assert (maxtype < VARRAY_SIZE (typevec), 387); - VARRAY_TREE (typevec, maxtype) = this_type; - maxtype++; - } - - if (TREE_CHAIN (parms)) - build_mangled_name (TREE_CHAIN (parms), 0, 0); - else - OB_PUTC ('e'); - } - else - { - /* the namespace qualifier for a global function - will count as type */ - if (CP_DECL_CONTEXT (decl) != global_namespace - && !flag_do_squangling) - { - my_friendly_assert (maxtype < VARRAY_SIZE (typevec), 387); - VARRAY_TREE (typevec, maxtype) = CP_DECL_CONTEXT (decl); - maxtype++; - } - build_mangled_name (parms, 0, 0); - } - - if (!flag_do_squangling) - /* Deallocate typevec array. */ - VARRAY_FREE (typevec); - } - - if (ret_type != NULL_TREE && for_method != 2) - { - /* Add the return type. */ - OB_PUTC ('_'); - build_mangled_name_for_type (ret_type); - } - - OB_FINISH (); - end_squangling (); - { - tree n = get_identifier (obstack_base (&scratch_obstack)); - return n; - } -} - /* Set the mangled name (DECL_ASSEMBLER_NAME) for DECL. */ void set_mangled_name_for_decl (decl) tree decl; { - tree parm_types; - if (processing_template_decl) /* There's no need to mangle the name of a template function. */ return; - if (flag_new_abi) - { - DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); - return; - } - - if (DECL_EXTERN_C_P (decl)) - { - /* In extern "C" we have to mangle at least overloaded operators, - because they contain characters invalid in assembler. */ - enum tree_code code = DECL_OVERLOADED_OPERATOR_P (decl); - const char *name; - - if (code) - { - if (DECL_ASSIGNMENT_OPERATOR_P (decl)) - name = assignment_operator_name_info[(int) code].mangled_name; - else - name = operator_name_info[(int) code].mangled_name; - DECL_ASSEMBLER_NAME (decl) = get_identifier (name); - return; - } - } - - parm_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); - - if (DECL_STATIC_FUNCTION_P (decl)) - parm_types = - hash_tree_chain (build_pointer_type (DECL_CONTEXT (decl)), - parm_types); - else - /* The only member functions whose type is a FUNCTION_TYPE, rather - than a METHOD_TYPE, should be static members. */ - my_friendly_assert (!DECL_CONTEXT (decl) - || !IS_AGGR_TYPE_CODE (TREE_CODE (DECL_CONTEXT (decl))) - || TREE_CODE (TREE_TYPE (decl)) != FUNCTION_TYPE, - 0); - - DECL_ASSEMBLER_NAME (decl) - = build_decl_overload_real (decl, parm_types, NULL_TREE, - NULL_TREE, NULL_TREE, - DECL_FUNCTION_MEMBER_P (decl) - + DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)); + DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl); } -/* Build an overload name for the type expression TYPE. */ - -tree -build_typename_overload (type) - tree type; -{ - tree id; - - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200004108); - - OB_INIT (); - OB_PUTS (OPERATOR_TYPENAME_FORMAT); - nofold = 1; - start_squangling (); - build_mangled_name (type, 0, 1); - id = get_identifier (obstack_base (&scratch_obstack)); - IDENTIFIER_OPNAME_P (id) = 1; - IDENTIFIER_TYPENAME_P (id) = 1; - TREE_TYPE (id) = type; - end_squangling (); - return id; -} - -tree -build_overload_with_type (name, type) - tree name, type; -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200004109); - - OB_INIT (); - OB_PUTID (name); - nofold = 1; - - start_squangling (); - build_mangled_name (type, 0, 1); - end_squangling (); - return get_identifier (obstack_base (&scratch_obstack)); -} - -tree -get_id_2 (name, name2) - const char *name; - tree name2; -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 20000411); - - OB_INIT (); - OB_PUTCP (name); - OB_PUTID (name2); - OB_FINISH (); - return get_identifier (obstack_base (&scratch_obstack)); -} - -/* Returns the name of a construction vtable group. TYPE is the most - derived class in the hierarhcy. BINFO is the most derived class in - the construction vtable group. */ - -tree -get_ctor_vtbl_name (type, binfo) - tree type; - tree binfo; -{ - /* This function is obsoleted by the new ABI. */ - my_friendly_assert (!flag_new_abi, 200005220); - - start_squangling (); - OB_INIT (); - OB_PUTCP (CTOR_VTBL_NAME_PREFIX); - build_mangled_name (type, 0, 0); - OB_PUTC ('_'); - build_mangled_name (BINFO_TYPE (binfo), 0, 0); - OB_PUTC ('_'); - build_overload_int (BINFO_OFFSET (binfo), mf_none); - OB_FINISH (); - end_squangling (); - return get_identifier (obstack_base (&scratch_obstack)); -} - -/* Returns a DECL_ASSEMBLER_NAME for the destructor of type TYPE. */ - -tree -build_destructor_name (type) - tree type; -{ - return build_overload_with_type (get_identifier (DESTRUCTOR_DECL_PREFIX), - type); -} /* Given a tree_code CODE, and some arguments (at least one), attempt to use an overloaded operator on the arguments. @@ -2145,31 +332,8 @@ make_thunk (function, delta, vcall_index, generate_with_vtable_p) if (TREE_CODE (func_decl) != FUNCTION_DECL) abort (); - if (flag_new_abi) - thunk_id = mangle_thunk (TREE_OPERAND (function, 0), - delta, vcall_offset); - else - { - OB_INIT (); - OB_PUTS ("__thunk_"); - if (d > 0) - { - OB_PUTC ('n'); - icat (d); - } - else - icat (-d); - OB_PUTC ('_'); - if (vcall_index) - { - icat (tree_low_cst (vcall_index, 0)); - OB_PUTC ('_'); - } - OB_PUTID (DECL_ASSEMBLER_NAME (func_decl)); - OB_FINISH (); - thunk_id = get_identifier (obstack_base (&scratch_obstack)); - } - + thunk_id = mangle_thunk (TREE_OPERAND (function, 0), + delta, vcall_offset); thunk = IDENTIFIER_GLOBAL_VALUE (thunk_id); if (thunk && !DECL_THUNK_P (thunk)) { diff --git a/gcc/cp/optimize.c b/gcc/cp/optimize.c index 16d3a4798d6..c6d43b9991f 100644 --- a/gcc/cp/optimize.c +++ b/gcc/cp/optimize.c @@ -1,5 +1,5 @@ /* Perform optimizations on tree structure. - Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc. Written by Mark Michell (mark@codesourcery.com). This file is part of GNU CC. @@ -914,10 +914,6 @@ maybe_clone_body (fn) inline_data id; tree clone; - /* We don't clone constructors and destructors under the old ABI. */ - if (!flag_new_abi) - return 0; - /* We only clone constructors and destructors. */ if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)) diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 181a00eb77b..aa77e638636 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -4222,11 +4222,7 @@ lookup_template_class (d1, arglist, in_decl, context, entering_scope, complain) DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl); if (!is_partial_instantiation) { - if (flag_new_abi) - DECL_ASSEMBLER_NAME (type_decl) = mangle_decl (type_decl); - else - DECL_ASSEMBLER_NAME (type_decl) - = get_identifier (build_overload_name (t, 1, 1)); + DECL_ASSEMBLER_NAME (type_decl) = mangle_decl (type_decl); /* For backwards compatibility; code that uses -fexternal-templates expects looking up a template to @@ -5817,14 +5813,9 @@ tsubst_decl (t, args, type) /*entering_scope=*/1); if (member && DECL_CONV_FN_P (r)) - { - /* Type-conversion operator. Reconstruct the name, in - case it's the name of one of the template's parameters. */ - if (flag_new_abi) - DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type)); - else - DECL_NAME (r) = build_typename_overload (TREE_TYPE (type)); - } + /* Type-conversion operator. Reconstruct the name, in + case it's the name of one of the template's parameters. */ + DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type)); DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args, /*complain=*/1, t); @@ -5860,12 +5851,7 @@ tsubst_decl (t, args, type) /* Set the mangled name for R. */ if (DECL_DESTRUCTOR_P (t)) - { - if (flag_new_abi) - set_mangled_name_for_decl (r); - else - DECL_ASSEMBLER_NAME (r) = build_destructor_name (ctx); - } + set_mangled_name_for_decl (r); else { /* Instantiations of template functions must be mangled @@ -7223,10 +7209,7 @@ tsubst_copy (t, args, complain, in_decl) if (IDENTIFIER_TYPENAME_P (t)) { tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl); - if (flag_new_abi) - return mangle_conv_op_name_for_type (new_type); - else - return (build_typename_overload (new_type)); + return mangle_conv_op_name_for_type (new_type); } else return t; @@ -10321,90 +10304,11 @@ static void set_mangled_name_for_template_decl (decl) tree decl; { - tree context = NULL_TREE; - tree fn_type; - tree ret_type; - tree parm_types; - tree tparms; - tree targs; - my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0); my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0); /* Under the new ABI, we don't need special machinery. */ - if (flag_new_abi) - { - set_mangled_name_for_decl (decl); - return; - } - - /* The names of template functions must be mangled so as to indicate - what template is being specialized with what template arguments. - For example, each of the following three functions must get - different mangled names: - - void f(int); - template <> void f<7>(int); - template <> void f<8>(int); */ - - targs = DECL_TI_ARGS (decl); - if (uses_template_parms (targs)) - /* This DECL is for a partial instantiation. There's no need to - mangle the name of such an entity. */ - return; - - /* We now compute the PARMS and RET_TYPE to give to - build_decl_overload_real. The PARMS and RET_TYPE are the - parameter and return types of the template, after all but the - innermost template arguments have been substituted, not the - parameter and return types of the function DECL. For example, - given: - - template T f(T); - - both PARMS and RET_TYPE should be `T' even if DECL is `int f(int)'. - A more subtle example is: - - template struct S { template void f(T, U); } - - Here, if DECL is `void S::f(int, double)', PARMS should be - {int, U}. Thus, the args that we want to subsitute into the - return and parameter type for the function are those in TARGS, - with the innermost level omitted. */ - fn_type = get_mostly_instantiated_function_type (decl, &context, &tparms); - - /* Now, get the innermost parameters and arguments, and figure out - the parameter and return types. */ - tparms = INNERMOST_TEMPLATE_PARMS (tparms); - targs = INNERMOST_TEMPLATE_ARGS (targs); - ret_type = TREE_TYPE (fn_type); - parm_types = TYPE_ARG_TYPES (fn_type); - - /* For a static member function, we generate a fake `this' pointer, - for the purposes of mangling. This indicates of which class the - function is a member. Because of: - - [class.static] - - There shall not be a static and a nonstatic member function - with the same name and the same parameter types - - we don't have to worry that this will result in a clash with a - non-static member function. */ - if (DECL_STATIC_FUNCTION_P (decl)) - parm_types = hash_tree_chain (build_pointer_type (context), parm_types); - - /* There should be the same number of template parameters as - template arguments. */ - my_friendly_assert (TREE_VEC_LENGTH (tparms) == TREE_VEC_LENGTH (targs), - 0); - - /* Actually set the DECL_ASSEMBLER_NAME. */ - DECL_ASSEMBLER_NAME (decl) - = build_decl_overload_real (decl, parm_types, ret_type, - tparms, targs, - DECL_FUNCTION_MEMBER_P (decl) - + DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)); + set_mangled_name_for_decl (decl); } /* Return truthvalue if we're processing a template different from diff --git a/gcc/cp/repo.c b/gcc/cp/repo.c index 8feab839038..e86e1f0805b 100644 --- a/gcc/cp/repo.c +++ b/gcc/cp/repo.c @@ -1,5 +1,5 @@ /* Code to maintain a C++ template repository. - Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc. + Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001 Free Software Foundation, Inc. Contributed by Jason Merrill (jason@cygnus.com) This file is part of GNU CC. @@ -107,25 +107,6 @@ repo_get_id (t) vtable = get_vtbl_decl_for_binfo (TYPE_BINFO (t)); - /* If we don't have a primary vtable, try looking for a secondary - vtable. */ - if (vtable == NULL_TREE && !flag_new_abi - && TYPE_USES_VIRTUAL_BASECLASSES (t)) - { - tree binfos = BINFO_BASETYPES (TYPE_BINFO (t)); - int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; - for (i = 0; i < n_baselinks; ++i) - { - tree base_binfo = TREE_VEC_ELT (binfos, i); - if (TREE_VIA_VIRTUAL (base_binfo)) - { - vtable = get_vtbl_decl_for_binfo (base_binfo); - if (vtable) - break; - } - } - } - t = vtable; if (t == NULL_TREE) return t; diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index 8be6f7e1087..b1acc5eb85f 100644 --- a/gcc/cp/rtti.c +++ b/gcc/cp/rtti.c @@ -43,16 +43,10 @@ extern struct obstack permanent_obstack; static tree build_headof_sub PARAMS((tree)); static tree build_headof PARAMS((tree)); -static tree get_tinfo_var PARAMS((tree)); static tree ifnonnull PARAMS((tree, tree)); static tree tinfo_name PARAMS((tree)); static tree get_base_offset PARAMS((tree, tree)); static tree build_dynamic_cast_1 PARAMS((tree, tree)); -static void expand_si_desc PARAMS((tree, tree)); -static void expand_class_desc PARAMS((tree, tree)); -static void expand_attr_desc PARAMS((tree, tree)); -static void expand_ptr_desc PARAMS((tree, tree)); -static void expand_generic_desc PARAMS((tree, tree, const char *)); static tree throw_bad_cast PARAMS((void)); static tree throw_bad_typeid PARAMS((void)); static tree get_tinfo_decl_dynamic PARAMS((tree)); @@ -182,9 +176,7 @@ build_headof (exp) static tree throw_bad_cast () { - tree fn = get_identifier (flag_new_abi - ? "__cxa_bad_cast" : - "__throw_bad_cast"); + tree fn = get_identifier ("__cxa_bad_cast"); if (IDENTIFIER_GLOBAL_VALUE (fn)) fn = IDENTIFIER_GLOBAL_VALUE (fn); else @@ -197,9 +189,7 @@ throw_bad_cast () static tree throw_bad_typeid () { - tree fn = get_identifier (flag_new_abi - ? "__cxa_bad_typeid" - : "__throw_bad_typeid"); + tree fn = get_identifier ("__cxa_bad_typeid"); if (IDENTIFIER_GLOBAL_VALUE (fn)) fn = IDENTIFIER_GLOBAL_VALUE (fn); else @@ -330,49 +320,6 @@ build_typeid (exp) return convert_from_reference (exp); } -static tree -get_tinfo_var (type) - tree type; -{ - tree tname = build_overload_with_type (tinfo_var_id, type); - tree arrtype; - int size; - - my_friendly_assert (!new_abi_rtti_p (), 20000118); - if (IDENTIFIER_GLOBAL_VALUE (tname)) - return IDENTIFIER_GLOBAL_VALUE (tname); - - /* Figure out how much space we need to allocate for the type_info object. - If our struct layout or the type_info classes are changed, this will - need to be modified. */ - if (TYPE_QUALS (type) != TYPE_UNQUALIFIED) - size = 3 * POINTER_SIZE + INT_TYPE_SIZE; - else if (TREE_CODE (type) == POINTER_TYPE - && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE - || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)) - size = 3 * POINTER_SIZE; - else if (IS_AGGR_TYPE (type)) - { - if (CLASSTYPE_N_BASECLASSES (type) == 0) - size = 2 * POINTER_SIZE; - else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type) - && (TREE_VIA_PUBLIC - (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)))) - size = 3 * POINTER_SIZE; - else - size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype); - } - else - size = 2 * POINTER_SIZE; - - /* The type for a character array of the appropriate size. */ - arrtype = build_cplus_array_type - (unsigned_char_type_node, - build_index_type (size_int (size / BITS_PER_UNIT - 1))); - - return declare_global_var (tname, arrtype); -} - /* Generate the NTBS name of a type. */ static tree tinfo_name (type) @@ -381,10 +328,7 @@ tinfo_name (type) const char *name; tree name_string; - if (flag_new_abi) - name = mangle_type_string (type); - else - name = build_overload_name (type, 1, 1); + name = mangle_type_string (type); name_string = combine_strings (build_string (strlen (name) + 1, name)); return name_string; } @@ -410,24 +354,11 @@ get_tinfo_decl (type) type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type))); - if (flag_new_abi) - name = mangle_typeinfo_for_type (type); - else - name = build_overload_with_type (tinfo_decl_id, type); + name = mangle_typeinfo_for_type (type); d = IDENTIFIER_GLOBAL_VALUE (name); if (d) /* OK */; - else if (!new_abi_rtti_p ()) - { - /* The tinfo decl is a function returning a reference to the - type_info object. */ - d = push_library_fn (name, tinfo_decl_type); - DECL_NOT_REALLY_EXTERN (d) = 1; - SET_DECL_TINFO_FN_P (d); - TREE_TYPE (name) = type; - defer_fn (d); - } else { /* The tinfo decl is the type_info object itself. We make all @@ -889,381 +820,6 @@ build_dynamic_cast (type, expr) return convert_from_reference (build_dynamic_cast_1 (type, expr)); } -/* Build and initialize various sorts of descriptors. Every descriptor - node has a name associated with it (the name created by mangling). - For this reason, we use the identifier as our access to the __*_desc - nodes, instead of sticking them directly in the types. Otherwise we - would burden all built-in types (and pointer types) with slots that - we don't necessarily want to use. - - For each descriptor we build, we build a variable that contains - the descriptor's information. When we need this info at runtime, - all we need is access to these variables. - - Note: these constructors always return the address of the descriptor - info, since that is simplest for their mutual interaction. */ - -/* Build an initializer for a __si_type_info node. */ - -static void -expand_si_desc (tdecl, type) - tree tdecl; - tree type; -{ - tree t, elems, fn; - tree name_string = tinfo_name (type); - - type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)); - finish_expr_stmt (get_typeid_1 (type)); - t = decay_conversion (get_tinfo_var (type)); - elems = tree_cons - (NULL_TREE, decay_conversion (tdecl), tree_cons - (NULL_TREE, decay_conversion (name_string), tree_cons - (NULL_TREE, t, NULL_TREE))); - - fn = get_identifier ("__rtti_si"); - if (IDENTIFIER_GLOBAL_VALUE (fn)) - fn = IDENTIFIER_GLOBAL_VALUE (fn); - else - { - tree tmp; - tmp = tree_cons - (NULL_TREE, ptr_type_node, tree_cons - (NULL_TREE, const_string_type_node, tree_cons - (NULL_TREE, build_pointer_type (type_info_type_node), - void_list_node))); - fn = push_void_library_fn (fn, tmp); - } - - fn = build_call (fn, elems); - finish_expr_stmt (fn); -} - -/* Build an initializer for a __class_type_info node. */ - -static void -expand_class_desc (tdecl, type) - tree tdecl; - tree type; -{ - tree name_string; - tree fn, tmp; - - int i = CLASSTYPE_N_BASECLASSES (type); - int base_cnt = 0; - tree binfos = TYPE_BINFO_BASETYPES (type); - tree base, elems, access, offset, isvir; - tree elt, elts = NULL_TREE; - - if (base_desc_type_node == NULL_TREE) - { - tree fields [4]; - - /* A reasonably close approximation of __class_type_info::base_info */ - - base_desc_type_node = make_aggr_type (RECORD_TYPE); - - /* Actually const __user_type_info * */ - fields [0] = build_decl - (FIELD_DECL, NULL_TREE, - build_pointer_type (build_qualified_type - (type_info_type_node, - TYPE_QUAL_CONST))); - fields [1] = build_decl - (FIELD_DECL, NULL_TREE, - flag_new_abi ? intSI_type_node : unsigned_intSI_type_node); - DECL_BIT_FIELD (fields[1]) = 1; - DECL_SIZE (fields[1]) = bitsize_int (29); - - fields [2] = build_decl (FIELD_DECL, NULL_TREE, boolean_type_node); - DECL_BIT_FIELD (fields[2]) = 1; - DECL_SIZE (fields[2]) = bitsize_one_node; - - /* Actually enum access */ - fields [3] = build_decl (FIELD_DECL, NULL_TREE, integer_type_node); - DECL_BIT_FIELD (fields[3]) = 1; - DECL_SIZE (fields[3]) = bitsize_int (2); - - finish_builtin_type (base_desc_type_node, "__base_info", fields, - 3, ptr_type_node); - } - - while (--i >= 0) - { - tree binfo = TREE_VEC_ELT (binfos, i); - - finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo))); - base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo))); - offset = get_base_offset (binfo, type); - - if (TREE_VIA_PUBLIC (binfo)) - access = access_public_node; - else if (TREE_VIA_PROTECTED (binfo)) - access = access_protected_node; - else - access = access_private_node; - if (TREE_VIA_VIRTUAL (binfo)) - isvir = boolean_true_node; - else - isvir = boolean_false_node; - - elt = build - (CONSTRUCTOR, base_desc_type_node, NULL_TREE, tree_cons - (NULL_TREE, base, tree_cons - (NULL_TREE, offset, tree_cons - (NULL_TREE, isvir, tree_cons - (NULL_TREE, access, NULL_TREE))))); - TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1; - elts = tree_cons (NULL_TREE, elt, elts); - base_cnt++; - } - - name_string = tinfo_name (type); - - { - tree arrtype = build_array_type (base_desc_type_node, NULL_TREE); - elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts); - TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts) - = TREE_STATIC (elts) = 1; - complete_array_type (arrtype, elts, 1); - } - - elems = tree_cons - (NULL_TREE, decay_conversion (tdecl), tree_cons - (NULL_TREE, decay_conversion (name_string), tree_cons - (NULL_TREE, decay_conversion (elts), tree_cons - (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)), - NULL_TREE)))); - - fn = get_identifier ("__rtti_class"); - if (IDENTIFIER_GLOBAL_VALUE (fn)) - fn = IDENTIFIER_GLOBAL_VALUE (fn); - else - { - tmp = tree_cons - (NULL_TREE, ptr_type_node, tree_cons - (NULL_TREE, const_string_type_node, tree_cons - (NULL_TREE, build_pointer_type (base_desc_type_node), tree_cons - (NULL_TREE, sizetype, void_list_node)))); - - fn = push_void_library_fn (fn, tmp); - } - - fn = build_call (fn, elems); - finish_expr_stmt (fn); -} - -/* Build an initializer for a __pointer_type_info node. */ - -static void -expand_ptr_desc (tdecl, type) - tree tdecl; - tree type; -{ - tree t, elems, fn; - tree name_string = tinfo_name (type); - - type = TREE_TYPE (type); - finish_expr_stmt (get_typeid_1 (type)); - t = decay_conversion (get_tinfo_var (type)); - elems = tree_cons - (NULL_TREE, decay_conversion (tdecl), tree_cons - (NULL_TREE, decay_conversion (name_string), tree_cons - (NULL_TREE, t, NULL_TREE))); - - fn = get_identifier ("__rtti_ptr"); - if (IDENTIFIER_GLOBAL_VALUE (fn)) - fn = IDENTIFIER_GLOBAL_VALUE (fn); - else - { - tree tmp; - tmp = tree_cons - (NULL_TREE, ptr_type_node, tree_cons - (NULL_TREE, const_string_type_node, tree_cons - (NULL_TREE, build_pointer_type (type_info_type_node), - void_list_node))); - fn = push_void_library_fn (fn, tmp); - } - - fn = build_call (fn, elems); - finish_expr_stmt (fn); -} - -/* Build an initializer for a __attr_type_info node. */ - -static void -expand_attr_desc (tdecl, type) - tree tdecl; - tree type; -{ - tree elems, t, fn; - tree name_string = tinfo_name (type); - tree attrval = build_int_2 (TYPE_QUALS (type), 0); - - finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type))); - t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type))); - elems = tree_cons - (NULL_TREE, decay_conversion (tdecl), tree_cons - (NULL_TREE, decay_conversion (name_string), tree_cons - (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE)))); - - fn = get_identifier ("__rtti_attr"); - if (IDENTIFIER_GLOBAL_VALUE (fn)) - fn = IDENTIFIER_GLOBAL_VALUE (fn); - else - { - tree tmp; - tmp = tree_cons - (NULL_TREE, ptr_type_node, tree_cons - (NULL_TREE, const_string_type_node, tree_cons - (NULL_TREE, integer_type_node, tree_cons - (NULL_TREE, build_pointer_type (type_info_type_node), - void_list_node)))); - fn = push_void_library_fn (fn, tmp); - } - - fn = build_call (fn, elems); - finish_expr_stmt (fn); -} - -/* Build an initializer for a type_info node that just has a name. */ - -static void -expand_generic_desc (tdecl, type, fnname) - tree tdecl; - tree type; - const char *fnname; -{ - tree name_string = tinfo_name (type); - tree elems = tree_cons - (NULL_TREE, decay_conversion (tdecl), tree_cons - (NULL_TREE, decay_conversion (name_string), NULL_TREE)); - - tree fn = get_identifier (fnname); - if (IDENTIFIER_GLOBAL_VALUE (fn)) - fn = IDENTIFIER_GLOBAL_VALUE (fn); - else - { - tree tmp; - tmp = tree_cons - (NULL_TREE, ptr_type_node, tree_cons - (NULL_TREE, const_string_type_node, void_list_node)); - fn = push_void_library_fn (fn, tmp); - } - - fn = build_call (fn, elems); - finish_expr_stmt (fn); -} - -/* Generate the code for a type_info initialization function. - Note that we take advantage of the passage - - 5.2.7 Type identification [expr.typeid] - - Whether or not the destructor is called for the type_info object at the - end of the program is unspecified. - - and don't bother to arrange for these objects to be destroyed. It - doesn't matter, anyway, since the destructors don't do anything. - - This must only be called from toplevel (i.e. from finish_file)! */ - -void -synthesize_tinfo_fn (fndecl) - tree fndecl; -{ - tree type = TREE_TYPE (DECL_NAME (fndecl)); - tree tmp, addr, tdecl; - tree compound_stmt; - tree if_stmt; - tree then_clause; - - my_friendly_assert (!new_abi_rtti_p (), 20000118); - if (at_eof) - { - import_export_decl (fndecl); - if (DECL_REALLY_EXTERN (fndecl)) - return; - } - - /* Declare the static typeinfo variable. */ - tdecl = get_tinfo_var (type); - DECL_EXTERNAL (tdecl) = 0; - TREE_STATIC (tdecl) = 1; - DECL_COMMON (tdecl) = 1; - TREE_USED (tdecl) = 1; - DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node); - DECL_USER_ALIGN (tdecl) = 0; - cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0); - - /* Begin processing the function. */ - start_function (NULL_TREE, fndecl, NULL_TREE, - SF_DEFAULT | SF_PRE_PARSED); - DECL_DEFER_OUTPUT (fndecl) = 1; - clear_last_expr (); - - /* Begin the body of the function. */ - compound_stmt = begin_compound_stmt (/*has_no_scope=*/0); - - /* For convenience, we save away the address of the static - variable. */ - addr = decay_conversion (tdecl); - - /* If the first word of the array (the vtable) is non-zero, we've already - initialized the object, so don't do it again. */ - if_stmt = begin_if_stmt (); - tmp = cp_convert (build_pointer_type (ptr_type_node), addr); - tmp = build_indirect_ref (tmp, 0); - tmp = cp_build_binary_op (EQ_EXPR, tmp, integer_zero_node); - finish_if_stmt_cond (tmp, if_stmt); - then_clause = begin_compound_stmt (/*has_no_scope=*/0); - - if (TREE_CODE (type) == FUNCTION_TYPE) - expand_generic_desc (tdecl, type, "__rtti_func"); - else if (TREE_CODE (type) == ARRAY_TYPE) - expand_generic_desc (tdecl, type, "__rtti_array"); - else if (TYPE_QUALS (type) != TYPE_UNQUALIFIED) - expand_attr_desc (tdecl, type); - else if (TREE_CODE (type) == POINTER_TYPE) - { - if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE) - expand_generic_desc (tdecl, type, "__rtti_ptmd"); - else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE) - expand_generic_desc (tdecl, type, "__rtti_ptmf"); - else - expand_ptr_desc (tdecl, type); - } - else if (TYPE_PTRMEMFUNC_P (type)) - expand_generic_desc (tdecl, type, "__rtti_ptmf"); - else if (IS_AGGR_TYPE (type)) - { - if (CLASSTYPE_N_BASECLASSES (type) == 0) - expand_generic_desc (tdecl, type, "__rtti_user"); - else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type) - && (TREE_VIA_PUBLIC - (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)))) - expand_si_desc (tdecl, type); - else - expand_class_desc (tdecl, type); - } - else if (TREE_CODE (type) == ENUMERAL_TYPE) - expand_generic_desc (tdecl, type, "__rtti_user"); - else - my_friendly_abort (252); - - finish_compound_stmt (/*has_no_scope=*/0, then_clause); - finish_then_clause (if_stmt); - finish_if_stmt (); - - /* OK, now return the type_info object. */ - tmp = cp_convert (build_pointer_type (type_info_type_node), addr); - tmp = build_indirect_ref (tmp, 0); - finish_return_stmt (tmp); - /* Finish the function body. */ - finish_compound_stmt (/*has_no_scope=*/0, compound_stmt); - expand_body (finish_function (0)); -} - /* Return the runtime bit mask encoding the qualifiers of TYPE. */ static int @@ -1328,10 +884,7 @@ tinfo_base_init (desc, target) NULL_TREE); tree name_string = tinfo_name (target); - if (flag_new_abi) - name_name = mangle_typeinfo_string_for_type (target); - else - name_name = build_overload_with_type (tinfo_var_id, target); + name_name = mangle_typeinfo_string_for_type (target); name_decl = build_lang_decl (VAR_DECL, name_name, name_type); DECL_ARTIFICIAL (name_decl) = 1; @@ -1340,13 +893,10 @@ tinfo_base_init (desc, target) DECL_EXTERNAL (name_decl) = 0; TREE_PUBLIC (name_decl) = 1; comdat_linkage (name_decl); - if (flag_new_abi) - /* The new ABI specifies the external name of the string - containing the type's name. */ - DECL_ASSEMBLER_NAME (name_decl) - = mangle_typeinfo_string_for_type (target); - else - DECL_ASSEMBLER_NAME (name_decl) = DECL_NAME (name_decl); + /* The new ABI specifies the external name of the string + containing the type's name. */ + DECL_ASSEMBLER_NAME (name_decl) + = mangle_typeinfo_string_for_type (target); DECL_INITIAL (name_decl) = name_string; cp_finish_decl (name_decl, name_string, NULL_TREE, 0); pushdecl_top_level (name_decl); @@ -1809,16 +1359,13 @@ create_pseudo_type_info VPARAMS((const char *real_name, int ident, ...)) /* Under the new ABI, we need to point into the middle of the vtable. */ - if (flag_new_abi) - { - vtable_decl = build (PLUS_EXPR, - TREE_TYPE (vtable_decl), - vtable_decl, - size_binop (MULT_EXPR, - size_int (2), - TYPE_SIZE_UNIT (vtable_entry_type))); - TREE_CONSTANT (vtable_decl) = 1; - } + vtable_decl = build (PLUS_EXPR, + TREE_TYPE (vtable_decl), + vtable_decl, + size_binop (MULT_EXPR, + size_int (2), + TYPE_SIZE_UNIT (vtable_entry_type))); + TREE_CONSTANT (vtable_decl) = 1; /* First field is the pseudo type_info base class. */ fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node); diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 620d7592085..8a6378d1d18 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -2507,8 +2507,7 @@ expand_upcast_fixups (binfo, addr, orig_addr, vbase, vbase_addr, t, *vbase_offsets = delta; } - for (virtuals = BINFO_VIRTUALS (binfo), - n = first_vfun_index (BINFO_TYPE (binfo)); + for (virtuals = BINFO_VIRTUALS (binfo), n = 0; virtuals; virtuals = TREE_CHAIN (virtuals), ++n) { diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index d027726b3da..f7199f0b0da 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -883,7 +883,7 @@ debug_binfo (elem) fprintf (stderr, "no vtable decl yet\n"); fprintf (stderr, "virtuals:\n"); virtuals = BINFO_VIRTUALS (elem); - n = first_vfun_index (BINFO_TYPE (elem)); + n = 0; while (virtuals) { @@ -2229,9 +2229,6 @@ cp_valid_lang_attribute (attr_name, attr_args, decl, type) return 0; } - if (!flag_new_abi) - /* The v3 ABI is already COM compliant; don't set this flag. */ - CLASSTYPE_COM_INTERFACE (type) = 1; return 1; } else if (is_attribute_p ("init_priority", attr_name)) diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index ef2a9217a81..6cc1969a01b 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -2884,35 +2884,20 @@ get_member_function_from_ptrfunc (instance_ptrptr, function) load-with-sign-extend, while the second used normal load then shift to sign-extend. An optimizer flaw, perhaps, but it's easier to make this change. */ - if (flag_new_abi) - { - idx = cp_build_binary_op (TRUNC_DIV_EXPR, - build1 (NOP_EXPR, vtable_index_type, e3), - TYPE_SIZE_UNIT (vtable_entry_type)); - e1 = cp_build_binary_op (BIT_AND_EXPR, - build1 (NOP_EXPR, vtable_index_type, e3), - integer_one_node); - } - else - { - idx = save_expr (default_conversion - (build_component_ref (function, - index_identifier, - NULL_TREE, 0))); - e1 = cp_build_binary_op (GE_EXPR, idx, integer_zero_node); - idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node); - } + idx = cp_build_binary_op (TRUNC_DIV_EXPR, + build1 (NOP_EXPR, vtable_index_type, e3), + TYPE_SIZE_UNIT (vtable_entry_type)); + e1 = cp_build_binary_op (BIT_AND_EXPR, + build1 (NOP_EXPR, vtable_index_type, e3), + integer_one_node); vtbl = convert_pointer_to (ptr_type_node, instance); delta = cp_convert (ptrdiff_type_node, build_component_ref (function, delta_identifier, NULL_TREE, 0)); - if (flag_new_abi) - /* DELTA2 is the amount by which to adjust the `this' pointer - to find the vtbl. */ - delta2 = delta; - else - delta2 = DELTA2_FROM_PTRMEMFUNC (function); + /* DELTA2 is the amount by which to adjust the `this' pointer + to find the vtbl. */ + delta2 = delta; vtbl = build (PLUS_EXPR, build_pointer_type (build_pointer_type (vtable_entry_type)), @@ -3630,16 +3615,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) } else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1)) { - if (flag_new_abi) - { - op0 = build_component_ref (op0, pfn_identifier, NULL_TREE, 0); - op1 = cp_convert (TREE_TYPE (op0), integer_zero_node); - } - else - { - op0 = build_component_ref (op0, index_identifier, NULL_TREE, 0); - op1 = integer_zero_node; - } + op0 = build_component_ref (op0, pfn_identifier, NULL_TREE, 0); + op1 = cp_convert (TREE_TYPE (op0), integer_zero_node); result_type = TREE_TYPE (op0); } else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0)) @@ -3652,80 +3629,38 @@ build_binary_op (code, orig_op0, orig_op1, convert_p) /* E1 and E2 are for scratch. */ tree e1; tree e2; + tree pfn0; + tree pfn1; + tree delta0; + tree delta1; if (TREE_SIDE_EFFECTS (op0)) op0 = save_expr (op0); if (TREE_SIDE_EFFECTS (op1)) op1 = save_expr (op1); - if (flag_new_abi) - { - /* We generate: + /* We generate: - (op0.pfn == op1.pfn - && (!op0.pfn || op0.delta == op1.delta)) - - The reason for the `!op0.pfn' bit is that a NULL - pointer-to-member is any member with a zero PFN; the - DELTA field is unspecified. */ - tree pfn0; - tree pfn1; - tree delta0; - tree delta1; - - pfn0 = pfn_from_ptrmemfunc (op0); - pfn1 = pfn_from_ptrmemfunc (op1); - delta0 = build_component_ref (op0, delta_identifier, - NULL_TREE, 0); - delta1 = build_component_ref (op1, delta_identifier, - NULL_TREE, 0); - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); - e2 = cp_build_binary_op (EQ_EXPR, - pfn0, - cp_convert (TREE_TYPE (pfn0), - integer_zero_node)); - e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2); - e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1); - e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); - } - else - { - /* The code we generate for the test is: - - (op0.index == op1.index - && op0.delta == op1.delta - && (op1.index == -1 ? op0.pfn == op1.pfn - : op0.delta2 == op1.delta2)) */ - - tree index0 = build_component_ref (op0, index_identifier, - NULL_TREE, 0); - tree index1 - = save_expr (build_component_ref (op1, index_identifier, - NULL_TREE, 0)); - tree delta0 = build_component_ref (op0, delta_identifier, - NULL_TREE, 0); - tree delta1 = build_component_ref (op1, delta_identifier, - NULL_TREE, 0); - tree pfn0 = PFN_FROM_PTRMEMFUNC (op0); - tree pfn1 = PFN_FROM_PTRMEMFUNC (op1); - tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0); - tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1); - tree e3; - tree integer_neg_one_node - = cp_build_binary_op (MINUS_EXPR, integer_zero_node, - integer_one_node); - e1 = cp_build_binary_op (EQ_EXPR, index1, integer_neg_one_node); - /* We can't use build_binary_op for this cmp because it - would get confused by the ptr to method types and - think we want pmfs. */ - e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1); - e3 = cp_build_binary_op (EQ_EXPR, delta20, delta21); - e = build_conditional_expr (e1, e2, e3); - e1 = cp_build_binary_op (EQ_EXPR, index0, index1); - e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e); - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); - e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e); - } + (op0.pfn == op1.pfn + && (!op0.pfn || op0.delta == op1.delta)) + + The reason for the `!op0.pfn' bit is that a NULL + pointer-to-member is any member with a zero PFN; the + DELTA field is unspecified. */ + pfn0 = pfn_from_ptrmemfunc (op0); + pfn1 = pfn_from_ptrmemfunc (op1); + delta0 = build_component_ref (op0, delta_identifier, + NULL_TREE, 0); + delta1 = build_component_ref (op1, delta_identifier, + NULL_TREE, 0); + e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); + e2 = cp_build_binary_op (EQ_EXPR, + pfn0, + cp_convert (TREE_TYPE (pfn0), + integer_zero_node)); + e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2); + e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1); + e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); if (code == EQ_EXPR) return e; return cp_build_binary_op (EQ_EXPR, e, integer_zero_node); @@ -6025,8 +5960,8 @@ get_delta_difference (from, to, force) the other components as specified. */ tree -build_ptrmemfunc1 (type, delta, idx, pfn, delta2) - tree type, delta, idx, pfn, delta2; +build_ptrmemfunc1 (type, delta, pfn) + tree type, delta, pfn; { tree u = NULL_TREE; tree delta_field; @@ -6038,24 +5973,12 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2) int allconstant, allsimple; /* Pull the FIELD_DECLs out of the type. */ - if (flag_new_abi) - { - pfn_field = TYPE_FIELDS (type); - delta_field = TREE_CHAIN (pfn_field); - idx_field = NULL_TREE; - pfn_or_delta2_field = NULL_TREE; - delta2_field = NULL_TREE; - subtype = NULL_TREE; - } - else - { - delta_field = TYPE_FIELDS (type); - idx_field = TREE_CHAIN (delta_field); - pfn_or_delta2_field = TREE_CHAIN (idx_field); - subtype = TREE_TYPE (pfn_or_delta2_field); - pfn_field = TYPE_FIELDS (subtype); - delta2_field = TREE_CHAIN (pfn_field); - } + pfn_field = TYPE_FIELDS (type); + delta_field = TREE_CHAIN (pfn_field); + idx_field = NULL_TREE; + pfn_or_delta2_field = NULL_TREE; + delta2_field = NULL_TREE; + subtype = NULL_TREE; /* Make sure DELTA has the type we want. */ delta = convert_and_check (delta_type_node, delta); @@ -6069,9 +5992,6 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2) if (pfn) { /* A non-virtual function. */ - if (!flag_new_abi) - u = build_tree_list (pfn_field, pfn); - allconstant &= TREE_CONSTANT (pfn); allsimple &= (initializer_constant_valid_p (pfn, TREE_TYPE (pfn)) != NULL_TREE); @@ -6079,39 +5999,14 @@ build_ptrmemfunc1 (type, delta, idx, pfn, delta2) else { /* A virtual function. */ - if (flag_new_abi) - { - allconstant &= TREE_CONSTANT (pfn); - allsimple &= (initializer_constant_valid_p (pfn, TREE_TYPE (pfn)) - != NULL_TREE); - } - else - { - idx = convert_and_check (delta_type_node, idx); - u = build_tree_list (delta2_field, delta2); - - allconstant &= TREE_CONSTANT (idx) && TREE_CONSTANT (delta2); - allsimple &= ((initializer_constant_valid_p (idx, TREE_TYPE (idx)) - != NULL_TREE) - && (initializer_constant_valid_p (delta2, - TREE_TYPE (delta2)) - != NULL_TREE)); - } + allconstant &= TREE_CONSTANT (pfn); + allsimple &= (initializer_constant_valid_p (pfn, TREE_TYPE (pfn)) + != NULL_TREE); } /* Finish creating the initializer. */ - if (flag_new_abi) - u = tree_cons (pfn_field, pfn, - build_tree_list (delta_field, delta)); - else - { - u = build (CONSTRUCTOR, subtype, NULL_TREE, u); - u = tree_cons (delta_field, delta, - tree_cons (idx_field, - idx, - build_tree_list (pfn_or_delta2_field, - u))); - } + u = tree_cons (pfn_field, pfn, + build_tree_list (delta_field, delta)); u = build (CONSTRUCTOR, type, NULL_TREE, u); TREE_CONSTANT (u) = allconstant; TREE_STATIC (u) = allconstant && allsimple; @@ -6141,12 +6036,9 @@ build_ptrmemfunc (type, pfn, force) /* Handle multiple conversions of pointer to member functions. */ if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn))) { - tree idx = integer_zero_node; tree delta = integer_zero_node; - tree delta2 = integer_zero_node; tree npfn = NULL_TREE; - tree ndelta, ndelta2; - tree e1, e2, e3, n; + tree n; if (!force && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn)) @@ -6172,56 +6064,13 @@ build_ptrmemfunc (type, pfn, force) if (TREE_SIDE_EFFECTS (pfn)) pfn = save_expr (pfn); - if (flag_new_abi) - { - /* Under the new ABI, the conversion is easy. Just adjust - the DELTA field. */ - npfn = build_component_ref (pfn, pfn_identifier, NULL_TREE, 0); - delta = build_component_ref (pfn, delta_identifier, NULL_TREE, 0); - delta = cp_convert (ptrdiff_type_node, delta); - delta = cp_build_binary_op (PLUS_EXPR, delta, n); - return build_ptrmemfunc1 (to_type, delta, NULL_TREE, npfn, - NULL_TREE); - } - - if (TREE_CODE (pfn) == PTRMEM_CST) - { - /* We could just build the resulting CONSTRUCTOR now, but we - don't, relying on the general machinery below, together - with constant-folding, to do the right thing. */ - expand_ptrmemfunc_cst (pfn, &ndelta, &idx, &npfn, &ndelta2); - if (npfn) - /* This constant points to a non-virtual function. - NDELTA2 will be NULL, but it's value doesn't really - matter since we won't use it anyhow. */ - ndelta2 = integer_zero_node; - } - else - { - ndelta = cp_convert (ptrdiff_type_node, - build_component_ref (pfn, - delta_identifier, - NULL_TREE, 0)); - ndelta2 = cp_convert (ptrdiff_type_node, - DELTA2_FROM_PTRMEMFUNC (pfn)); - idx = build_component_ref (pfn, index_identifier, NULL_TREE, 0); - } - - delta = cp_build_binary_op (PLUS_EXPR, ndelta, n); - delta2 = cp_build_binary_op (PLUS_EXPR, ndelta2, n); - e1 = fold (build (GT_EXPR, boolean_type_node, idx, integer_zero_node)); - - /* If it's a virtual function, this is what we want. */ - e2 = build_ptrmemfunc1 (to_type, delta, idx, NULL_TREE, delta2); - - pfn = PFN_FROM_PTRMEMFUNC (pfn); - npfn = build1 (NOP_EXPR, type, pfn); - TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn); - - /* But if it's a non-virtual function, or NULL, we use this - instead. */ - e3 = build_ptrmemfunc1 (to_type, delta, idx, npfn, NULL_TREE); - return build_conditional_expr (e1, e2, e3); + /* Under the new ABI, the conversion is easy. Just adjust + the DELTA field. */ + npfn = build_component_ref (pfn, pfn_identifier, NULL_TREE, 0); + delta = build_component_ref (pfn, delta_identifier, NULL_TREE, 0); + delta = cp_convert (ptrdiff_type_node, delta); + delta = cp_build_binary_op (PLUS_EXPR, delta, n); + return build_ptrmemfunc1 (to_type, delta, npfn); } /* Handle null pointer to member function conversions. */ @@ -6229,8 +6078,8 @@ build_ptrmemfunc (type, pfn, force) { pfn = build_c_cast (type, integer_zero_node); return build_ptrmemfunc1 (to_type, - integer_zero_node, integer_zero_node, - pfn, NULL_TREE); + integer_zero_node, + pfn); } if (type_unknown_p (pfn)) @@ -6273,10 +6122,7 @@ expand_ptrmemfunc_cst (cst, delta, idx, pfn, delta2) if (!DECL_VIRTUAL_P (fn)) { - if (!flag_new_abi) - *idx = build_int_2 (-1, -1); - else - *idx = NULL_TREE; + *idx = NULL_TREE; *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn)); *delta2 = NULL_TREE; } @@ -6290,26 +6136,16 @@ expand_ptrmemfunc_cst (cst, delta, idx, pfn, delta2) *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta), *delta, BINFO_OFFSET (binfo))); - if (!flag_new_abi) - { - /* Map everything down one to make room for the null PMF. */ - *idx = fold (build (PLUS_EXPR, integer_type_node, - DECL_VINDEX (fn), integer_one_node)); - *pfn = NULL_TREE; - } - else - { - /* Under the new ABI, we set PFN to the vtable offset, plus - one, at which the function can be found. */ - *idx = NULL_TREE; - *pfn = fold (build (MULT_EXPR, integer_type_node, - DECL_VINDEX (fn), - TYPE_SIZE_UNIT (vtable_entry_type))); - *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn, - integer_one_node)); - *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type), - *pfn)); - } + /* Under the new ABI, we set PFN to the vtable offset, plus + one, at which the function can be found. */ + *idx = NULL_TREE; + *pfn = fold (build (MULT_EXPR, integer_type_node, + DECL_VINDEX (fn), + TYPE_SIZE_UNIT (vtable_entry_type))); + *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn, + integer_one_node)); + *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type), + *pfn)); /* Offset from an object of PTR_CLASS to the vptr for ORIG_CLASS. */ *delta2 = fold (build (PLUS_EXPR, integer_type_node, *delta, @@ -6324,7 +6160,7 @@ tree delta2_from_ptrmemfunc (t) tree t; { - my_friendly_assert (!flag_new_abi, 20000221); + my_friendly_assert (0, 20000221); if (TREE_CODE (t) == PTRMEM_CST) { @@ -6364,14 +6200,7 @@ pfn_from_ptrmemfunc (t) return pfn; } - if (flag_new_abi) - return build_component_ref (t, pfn_identifier, NULL_TREE, 0); - else - return (build_component_ref - (build_component_ref (t, - pfn_or_delta2_identifier, NULL_TREE, - 0), - pfn_identifier, NULL_TREE, 0)); + return build_component_ref (t, pfn_identifier, NULL_TREE, 0); } /* Expression EXPR is about to be implicitly converted to TYPE. Warn @@ -6778,11 +6607,6 @@ check_return_expr (retval) return NULL_TREE; } - /* Under the old ABI, constructors actually always return `this', - even though in C++ you can't return a value from a constructor. */ - if (!flag_new_abi && DECL_CONSTRUCTOR_P (current_function_decl)) - retval = current_class_ptr; - /* When no explicit return-value is given in a function with a named return value, the named return value is used. */ result = DECL_RESULT (current_function_decl);