From 3cb98335f5a6d00604531c7874c897d91ac8a4d6 Mon Sep 17 00:00:00 2001 From: nathan Date: Mon, 5 Jul 2004 09:35:44 +0000 Subject: [PATCH] * c-tree.h (TYPE_ACTUAL_ARG_TYPES): Use TYPE_LANG_SLOT_1. * dwarf2out.c (add_data_member_location_attribute): Check for TREE_BINFO. * tree.c (tree_node_kinds): Add "binfos". (binfo_lang_slots): New. (make_node_stat): Add TREE_BINFO. (make_tree_binfo_stat): New. (tree_node_structure): Add TREE_BINFO. * tree.def (TREE_BINFO): New. * tree.h (REC_OR_UNION_CHECK): Rename to ... (RECORD_OR_UNION_CHECK): ... here. (NOT_RECORD_OR_UNION_CHECK): New. (TRE_VIA_VIRTUAL): Allow TREE_LIST or TREE_BINFO. (TYPE_FIELDS, TYPE_METHODS, TYPE_VFIELD): Adjust for RECORD_OR_UNION_CHECK. (TYPE_BINFO): Use RECORD_OR_UNION_CHECK. (TYPE_LANG_SLOT_1): New. (BINFO_TYPE, BINFO_OFFSET, BINFO_VTABLE, BINFO_VIRTUALS, BINFO_BASETYPES, TYPE_BINFO_BASETYPES, BINFO_VPTR_FIELD, BINFO_BASEACCESSES, BINFO_INHERITANCE_CHAIN): Adjust. (BINFO_ELTS): Remove. (BINFO_LANG_SLOT): New. (struct tree_binfo): New. (binfo_lang_slots): Declare. (enum tree_node_structure_enum): Add TS_BINFO. (union tree_node): Add binfo. (make_tree_binfo_stat): Declare. (make_tree_binfo): New. (enum tree_node_kind): Add binfo_kind. * cp/call.c (enforce_access): Expect TREE_BINFO. * cp/class.c (binfo_ctor_vtable): Check TREE_BINFO. * cp/cp-tree.h (RECORD_OR_UNION_TYPE_CHECK): Remove. (BINFO_SUBVTT_INDEX, BINFO_VPTR_INDEX, BINFO_PRIMARY_BASE_OF): Adjust. (BINFO_LANG_ELTS): Remove. (BINFO_LANG_SLOTS): New. (TYPE_RAISES_EXCEPTIONS, ENUM_TEMPLATE_INFO): Use TYPE_LANG_SLOT_1. (CLASSTYPE_TEMPLATE_INFO): Adjust. * cp/pt.c (tsubst): Split TREE_BINFO case from TREE_VEC case. * cp/search.c (lookup_member): Check TREE_BINFO. * cp/semantics.c (perform_or_defer_access_check): Likewise. (check_accessibility_of_qualified_id): Check deferred_access_no_check. * cp/tree.c (make_binfo): Use make_tree_binfo. * java/class.c (make_class): Use make_tree_binfo. (set_super_info, add_interface_do): Likewise. * java/java-tree.h (CLASS_HAS_SUPER_FLAG): Expect a BINFO. * objc/objc-act.c (start_class, objc_declare_protocols, start_protocols): Use TYPE_LANG_SLOT_1. * objc/objc-act.h (CLASS_BINFO_ELTS, PROTOCOL_BINFO_ELTS): Rename to ... (CLASS_LANG_SLOT_ELTS, PROTOCOL_LANG_SLOT_ELTS): ... here. (CLASS_IVARS, CLASS_RAW_IVARS, CLASS_STATIC_TEMPLATE, CLASS_CATEGORY_LIST, CLASS_PROTOCOL_LIST, CLASS_OWN_IVARS, PROTOCOL_LIST, PROTOCOL_FORWARD_DECL): Use TYPE_LANG_SLOT_1. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@84110 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 41 +++++++++++++++++++++++++++++ gcc/c-tree.h | 2 +- gcc/cp/ChangeLog | 18 +++++++++++++ gcc/cp/call.c | 2 +- gcc/cp/class.c | 2 +- gcc/cp/cp-tree.h | 20 +++++++------- gcc/cp/pt.c | 41 +++++++++++++++-------------- gcc/cp/search.c | 2 +- gcc/cp/semantics.c | 6 ++++- gcc/cp/tree.c | 4 +-- gcc/dwarf2out.c | 2 +- gcc/java/ChangeLog | 8 +++++- gcc/java/class.c | 6 ++--- gcc/java/java-tree.h | 4 +-- gcc/objc/objc-act.c | 7 ++--- gcc/objc/objc-act.h | 20 +++++++------- gcc/tree.c | 40 ++++++++++++++++++++++++++++ gcc/tree.def | 4 +++ gcc/tree.h | 73 ++++++++++++++++++++++++++++++++++++---------------- 19 files changed, 222 insertions(+), 80 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e609cab..33b69c2 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,44 @@ +2004-07-05 Nathan Sidwell + + * c-tree.h (TYPE_ACTUAL_ARG_TYPES): Use TYPE_LANG_SLOT_1. + * dwarf2out.c (add_data_member_location_attribute): Check for + TREE_BINFO. + * tree.c (tree_node_kinds): Add "binfos". + (binfo_lang_slots): New. + (make_node_stat): Add TREE_BINFO. + (make_tree_binfo_stat): New. + (tree_node_structure): Add TREE_BINFO. + * tree.def (TREE_BINFO): New. + * tree.h (REC_OR_UNION_CHECK): Rename to ... + (RECORD_OR_UNION_CHECK): ... here. + (NOT_RECORD_OR_UNION_CHECK): New. + (TRE_VIA_VIRTUAL): Allow TREE_LIST or TREE_BINFO. + (TYPE_FIELDS, TYPE_METHODS, TYPE_VFIELD): Adjust for + RECORD_OR_UNION_CHECK. + (TYPE_BINFO): Use RECORD_OR_UNION_CHECK. + (TYPE_LANG_SLOT_1): New. + (BINFO_TYPE, BINFO_OFFSET, BINFO_VTABLE, BINFO_VIRTUALS, + BINFO_BASETYPES, TYPE_BINFO_BASETYPES, BINFO_VPTR_FIELD, + BINFO_BASEACCESSES, BINFO_INHERITANCE_CHAIN): Adjust. + (BINFO_ELTS): Remove. + (BINFO_LANG_SLOT): New. + (struct tree_binfo): New. + (binfo_lang_slots): Declare. + (enum tree_node_structure_enum): Add TS_BINFO. + (union tree_node): Add binfo. + (make_tree_binfo_stat): Declare. + (make_tree_binfo): New. + (enum tree_node_kind): Add binfo_kind. + + * objc/objc-act.c (start_class, objc_declare_protocols, + start_protocols): Use TYPE_LANG_SLOT_1. + * objc/objc-act.h (CLASS_BINFO_ELTS, PROTOCOL_BINFO_ELTS): Rename + to ... + (CLASS_LANG_SLOT_ELTS, PROTOCOL_LANG_SLOT_ELTS): ... here. + (CLASS_IVARS, CLASS_RAW_IVARS, CLASS_STATIC_TEMPLATE, + CLASS_CATEGORY_LIST, CLASS_PROTOCOL_LIST, CLASS_OWN_IVARS, + PROTOCOL_LIST, PROTOCOL_FORWARD_DECL): Use TYPE_LANG_SLOT_1. + 2004-07-05 Steven Bosscher * rtl.h (struct rtx_def): Remove the integrated flag. diff --git a/gcc/c-tree.h b/gcc/c-tree.h index 10c96d4..ad731d4 100644 --- a/gcc/c-tree.h +++ b/gcc/c-tree.h @@ -114,7 +114,7 @@ struct lang_type GTY(()) /* For FUNCTION_TYPE, a hidden list of types of arguments. The same as TYPE_ARG_TYPES for functions with prototypes, but created for functions without prototypes. */ -#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_BINFO (NODE) +#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_LANG_SLOT_1 (NODE) /* Save and restore the variables in this file and elsewhere that keep track of the progress of compilation of the current function. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index a15f152..f611cb3 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,21 @@ +2004-07-05 Nathan Sidwell + + * call.c (enforce_access): Expect TREE_BINFO. + * class.c (binfo_ctor_vtable): Check TREE_BINFO. + * cp-tree.h (RECORD_OR_UNION_TYPE_CHECK): Remove. + (BINFO_SUBVTT_INDEX, BINFO_VPTR_INDEX, BINFO_PRIMARY_BASE_OF): + Adjust. + (BINFO_LANG_ELTS): Remove. + (BINFO_LANG_SLOTS): New. + (TYPE_RAISES_EXCEPTIONS, ENUM_TEMPLATE_INFO): Use TYPE_LANG_SLOT_1. + (CLASSTYPE_TEMPLATE_INFO): Adjust. + * pt.c (tsubst): Split TREE_BINFO case from TREE_VEC case. + * search.c (lookup_member): Check TREE_BINFO. + * semantics.c (perform_or_defer_access_check): Likewise. + (check_accessibility_of_qualified_id): Check + deferred_access_no_check. + * tree.c (make_binfo): Use make_tree_binfo. + 2004-07-04 Mark Mitchell * method.c (implicitly_declare_fn): Set linkage of generated diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 76f0291..82355c29 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -4049,7 +4049,7 @@ build_op_delete_call (enum tree_code code, tree addr, tree size, bool enforce_access (tree basetype_path, tree decl) { - my_friendly_assert (TREE_CODE (basetype_path) == TREE_VEC, 20030624); + my_friendly_assert (TREE_CODE (basetype_path) == TREE_BINFO, 20030624); if (!accessible_p (basetype_path, decl)) { diff --git a/gcc/cp/class.c b/gcc/cp/class.c index fdf15e1..85f8864 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -6873,7 +6873,7 @@ binfo_ctor_vtable (tree binfo) vt = BINFO_VTABLE (binfo); if (TREE_CODE (vt) == TREE_LIST) vt = TREE_VALUE (vt); - if (TREE_CODE (vt) == TREE_VEC) + if (TREE_CODE (vt) == TREE_BINFO) binfo = vt; else break; diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 8dfe109..4ae4f44 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -119,7 +119,7 @@ struct diagnostic_context; forth as a substitute for the mark bits provided in `lang_type'. At present, only the six low-order bits are used. - TYPE_BINFO + TYPE_LANG_SLOT_1 For an ENUMERAL_TYPE, this is ENUM_TEMPLATE_INFO. For a FUNCTION_TYPE or METHOD_TYPE, this is TYPE_RAISES_EXCEPTIONS @@ -169,9 +169,6 @@ struct diagnostic_context; #define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \ TREE_CHECK4(NODE,VAR_DECL,FUNCTION_DECL,TYPE_DECL,TEMPLATE_DECL) -#define RECORD_OR_UNION_TYPE_CHECK(NODE) \ - TREE_CHECK2(NODE,RECORD_TYPE,UNION_TYPE) - #define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \ TREE_CHECK(NODE,BOUND_TEMPLATE_TEMPLATE_PARM) @@ -1436,21 +1433,21 @@ struct lang_type GTY(()) /* The index in the VTT where this subobject's sub-VTT can be found. NULL_TREE if there is no sub-VTT. */ -#define BINFO_SUBVTT_INDEX(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 0) +#define BINFO_SUBVTT_INDEX(NODE) BINFO_LANG_SLOT(NODE, 0) /* The index in the VTT where the vptr for this subobject can be found. NULL_TREE if there is no secondary vptr in the VTT. */ -#define BINFO_VPTR_INDEX(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 1) +#define BINFO_VPTR_INDEX(NODE) BINFO_LANG_SLOT(NODE, 1) /* The binfo of which NODE is a primary base. (This is different from BINFO_INHERITANCE_CHAIN for virtual base because a virtual base is sometimes a primary base for a class for which it is not an immediate base.) */ -#define BINFO_PRIMARY_BASE_OF(NODE) TREE_VEC_ELT (NODE, BINFO_ELTS + 2) +#define BINFO_PRIMARY_BASE_OF(NODE) BINFO_LANG_SLOT(NODE, 2) /* C++ binfos have 3 additional entries. */ -#define BINFO_LANG_ELTS (BINFO_ELTS + 3) +#define BINFO_LANG_SLOTS (3) /* Nonzero if this binfo is for a dependent base - one that should not be searched. */ @@ -1528,7 +1525,7 @@ struct lang_type GTY(()) this type can raise. Each TREE_VALUE is a _TYPE. The TREE_VALUE will be NULL_TREE to indicate a throw specification of `()', or no exceptions allowed. */ -#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_BINFO (NODE) +#define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_LANG_SLOT_1 (NODE) /* For FUNCTION_TYPE or METHOD_TYPE, return 1 iff it is declared `throw()'. */ #define TYPE_NOTHROW_P(NODE) \ @@ -2087,13 +2084,14 @@ struct lang_decl GTY(()) /* Template information for a RECORD_TYPE or UNION_TYPE. */ #define CLASSTYPE_TEMPLATE_INFO(NODE) \ - (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_TYPE_CHECK (NODE))->template_info) + (LANG_TYPE_CLASS_CHECK (RECORD_OR_UNION_CHECK (NODE))->template_info) /* Template information for an ENUMERAL_TYPE. Although an enumeration may not be a primary template, it may be declared within the scope of a primary template and the enumeration constants may depend on non-type template parameters. */ -#define ENUM_TEMPLATE_INFO(NODE) (TYPE_BINFO (ENUMERAL_TYPE_CHECK (NODE))) +#define ENUM_TEMPLATE_INFO(NODE) \ + (TYPE_LANG_SLOT_1 (ENUMERAL_TYPE_CHECK (NODE))) /* Template information for a template template parameter. */ #define TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO(NODE) \ diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 88a77a5..ca52f65 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -6877,29 +6877,30 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) return t; return hash_tree_cons (purpose, value, chain); } - case TREE_VEC: - if (type != NULL_TREE) - { - /* A binfo node. We always need to make a copy, of the node - itself and of its BINFO_BASETYPES. */ - - t = copy_node (t); - - /* Make sure type isn't a typedef copy. */ - type = BINFO_TYPE (TYPE_BINFO (type)); + + case TREE_BINFO: + /* A binfo node. We always need to make a copy, of the node + itself and of its BINFO_BASETYPES. */ + my_friendly_assert (type, 20040628); + + t = copy_node (t); - TREE_TYPE (t) = complete_type (type); - if (IS_AGGR_TYPE (type)) - { - BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type); - BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type); - if (TYPE_BINFO_BASETYPES (type) != NULL_TREE) - BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type)); - } - return t; + /* Make sure type isn't a typedef copy. */ + type = BINFO_TYPE (TYPE_BINFO (type)); + + TREE_TYPE (t) = complete_type (type); + if (IS_AGGR_TYPE (type)) + { + BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (type); + BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (type); + if (TYPE_BINFO_BASETYPES (type) != NULL_TREE) + BINFO_BASETYPES (t) = copy_node (TYPE_BINFO_BASETYPES (type)); } + return t; - /* Otherwise, a vector of template arguments. */ + case TREE_VEC: + /* A vector of template arguments. */ + my_friendly_assert (!type, 20040628); return tsubst_template_args (t, args, complain, in_decl); case POINTER_TYPE: diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 4bf87a3..b28d7a2 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -1248,7 +1248,7 @@ lookup_member (tree xbasetype, tree name, int protect, bool want_type) my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030624); - if (TREE_CODE (xbasetype) == TREE_VEC) + if (TREE_CODE (xbasetype) == TREE_BINFO) { type = BINFO_TYPE (xbasetype); basetype_path = xbasetype; diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 5974a7a..15cd946 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -306,7 +306,7 @@ perform_or_defer_access_check (tree binfo, tree decl) if (deferred_access_no_check) return; - my_friendly_assert (TREE_CODE (binfo) == TREE_VEC, 20030623); + my_friendly_assert (TREE_CODE (binfo) == TREE_BINFO, 20030623); ptr = VEC_last (deferred_access, deferred_access_stack); @@ -1337,6 +1337,10 @@ check_accessibility_of_qualified_id (tree decl, { tree scope; tree qualifying_type = NULL_TREE; + + /* If we're not checking, return imediately. */ + if (deferred_access_no_check) + return; /* Determine the SCOPE of DECL. */ scope = context_for_name_lookup (decl); diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index deee9dc..c91164d 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -771,10 +771,10 @@ hash_chainon (tree list1, tree list2) tree make_binfo (tree offset, tree binfo, tree vtable, tree virtuals) { - tree new_binfo = make_tree_vec (BINFO_LANG_ELTS); + tree new_binfo = make_tree_binfo (BINFO_LANG_SLOTS); tree type; - if (TREE_CODE (binfo) == TREE_VEC) + if (TREE_CODE (binfo) == TREE_BINFO) { type = BINFO_TYPE (binfo); BINFO_DEPENDENT_BASE_P (new_binfo) = BINFO_DEPENDENT_BASE_P (binfo); diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 282ccab..f954b82 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -9468,7 +9468,7 @@ add_data_member_location_attribute (dw_die_ref die, tree decl) HOST_WIDE_INT offset; dw_loc_descr_ref loc_descr = 0; - if (TREE_CODE (decl) == TREE_VEC) + if (TREE_CODE (decl) == TREE_BINFO) { /* We're working on the TAG_inheritance for a base class. */ if (TREE_VIA_VIRTUAL (decl) && is_cxx ()) diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index 1c558ae..671c865 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,9 @@ +2004-07-05 Nathan Sidwell + + * class.c (make_class): Use make_tree_binfo. + (set_super_info, add_interface_do): Likewise. + * java-tree.h (CLASS_HAS_SUPER_FLAG): Expect a BINFO. + 2004-07-04 Ranjit Mathew * verify.c: Correct array element access formatting thinko. @@ -8161,7 +8167,7 @@ properly initialize `finished_label'. Don't emit gotos for empty try statements. -2000-03-19 Martin v. Löwis +2000-03-19 Martin v. Löwis * except.c (emit_handlers): Clear catch_clauses_last. diff --git a/gcc/java/class.c b/gcc/java/class.c index 3c0538a..1083efb 100644 --- a/gcc/java/class.c +++ b/gcc/java/class.c @@ -318,7 +318,7 @@ make_class (void) { tree type; type = make_node (RECORD_TYPE); - TYPE_BINFO (type) = make_tree_vec (BINFO_ELTS); + TYPE_BINFO (type) = make_tree_binfo (0); MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type); return type; @@ -480,7 +480,7 @@ set_super_info (int access_flags, tree this_class, TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers); if (super_class) { - tree super_binfo = make_tree_vec (BINFO_ELTS); + tree super_binfo = make_tree_binfo (0); BINFO_TYPE (super_binfo) = super_class; BINFO_OFFSET (super_binfo) = integer_zero_node; TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0) @@ -612,7 +612,7 @@ common_enclosing_context_p (tree type1, tree type2) static void add_interface_do (tree basetype_vec, tree interface_class, int i) { - tree interface_binfo = make_tree_vec (BINFO_ELTS); + tree interface_binfo = make_tree_binfo (0); BINFO_TYPE (interface_binfo) = interface_class; BINFO_OFFSET (interface_binfo) = integer_zero_node; BINFO_VPTR_FIELD (interface_binfo) = integer_zero_node; diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h index 6ebf6db..792f2ac 100644 --- a/gcc/java/java-tree.h +++ b/gcc/java/java-tree.h @@ -48,7 +48,7 @@ struct JCF; SUPPRESS_UNREACHABLE_ERROR (for other _EXPR nodes) ANONYMOUS_CLASS_P (in RECORD_TYPE) ARG_FINAL_P (in TREE_LIST) - 1: CLASS_HAS_SUPER_FLAG (in TREE_VEC). + 1: CLASS_HAS_SUPER_FLAG (in TREE_BINFO). IS_A_CLASSFILE_NAME (in IDENTIFIER_NODE) COMPOUND_ASSIGN_P (in EXPR (binop_*)) LOCAL_CLASS_P (in RECORD_TYPE) @@ -122,7 +122,7 @@ struct JCF; /* True if the class whose TYPE_BINFO this is has a superclass. (True of all classes except Object.) */ -#define CLASS_HAS_SUPER_FLAG(BINFO) TREE_LANG_FLAG_1 (TREE_VEC_CHECK (BINFO)) +#define CLASS_HAS_SUPER_FLAG(BINFO) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (BINFO)) #define CLASS_HAS_SUPER(TYPE) CLASS_HAS_SUPER_FLAG (TYPE_BINFO (TYPE)) /* Return the supertype of class TYPE, or NULL_TREE is it has none. */ diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index 2ecd030..4526e18 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -6761,7 +6761,7 @@ start_class (enum tree_code code, tree class_name, tree super_name, } class = make_node (code); - TYPE_BINFO (class) = make_tree_vec (CLASS_BINFO_ELTS); + TYPE_LANG_SLOT_1 (class) = make_tree_vec (CLASS_LANG_SLOT_ELTS); CLASS_NAME (class) = class_name; CLASS_SUPER_NAME (class) = super_name; @@ -7050,7 +7050,8 @@ objc_declare_protocols (tree names) { tree protocol = make_node (PROTOCOL_INTERFACE_TYPE); - TYPE_BINFO (protocol) = make_tree_vec (2); + TYPE_LANG_SLOT_1 (protocol) + = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); PROTOCOL_NAME (protocol) = name; PROTOCOL_LIST (protocol) = NULL_TREE; add_protocol (protocol); @@ -7081,7 +7082,7 @@ start_protocol (enum tree_code code, tree name, tree list) if (!protocol) { protocol = make_node (code); - TYPE_BINFO (protocol) = make_tree_vec (2); + TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); PROTOCOL_NAME (protocol) = name; PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list); diff --git a/gcc/objc/objc-act.h b/gcc/objc/objc-act.h index 2472bfe..dab0950 100644 --- a/gcc/objc/objc-act.h +++ b/gcc/objc/objc-act.h @@ -82,8 +82,8 @@ tree build_encode_expr (tree); /* Objective-C structures */ -#define CLASS_BINFO_ELTS 6 -#define PROTOCOL_BINFO_ELTS 2 +#define CLASS_LANG_SLOT_ELTS 6 +#define PROTOCOL_LANG_SLOT_ELTS 2 /* KEYWORD_DECL */ #define KEYWORD_KEY_NAME(DECL) ((DECL)->decl.name) @@ -101,19 +101,19 @@ tree build_encode_expr (tree); PROTOCOL_INTERFACE_TYPE */ #define CLASS_NAME(CLASS) ((CLASS)->type.name) #define CLASS_SUPER_NAME(CLASS) (TYPE_CHECK (CLASS)->type.context) -#define CLASS_IVARS(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 0) -#define CLASS_RAW_IVARS(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 1) +#define CLASS_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0) +#define CLASS_RAW_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1) #define CLASS_NST_METHODS(CLASS) ((CLASS)->type.minval) #define CLASS_CLS_METHODS(CLASS) ((CLASS)->type.maxval) -#define CLASS_STATIC_TEMPLATE(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 2) -#define CLASS_CATEGORY_LIST(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 3) -#define CLASS_PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 4) -#define CLASS_OWN_IVARS(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 5) +#define CLASS_STATIC_TEMPLATE(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 2) +#define CLASS_CATEGORY_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 3) +#define CLASS_PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 4) +#define CLASS_OWN_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 5) #define PROTOCOL_NAME(CLASS) ((CLASS)->type.name) -#define PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 0) +#define PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0) #define PROTOCOL_NST_METHODS(CLASS) ((CLASS)->type.minval) #define PROTOCOL_CLS_METHODS(CLASS) ((CLASS)->type.maxval) -#define PROTOCOL_FORWARD_DECL(CLASS) TREE_VEC_ELT (TYPE_BINFO (CLASS), 1) +#define PROTOCOL_FORWARD_DECL(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1) #define PROTOCOL_DEFINED(CLASS) TREE_USED (CLASS) /* We need to distinguish TYPE_PROTOCOL_LISTs from TYPE_CONTEXTs, both of which are stored in the same accessor slot. */ diff --git a/gcc/tree.c b/gcc/tree.c index 64d2dd5..a4bbd66 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -71,6 +71,7 @@ static const char * const tree_node_kind_names[] = { "perm_tree_lists", "temp_tree_lists", "vecs", + "binfos", "phi_nodes", "ssa names", "random kinds", @@ -93,6 +94,9 @@ struct type_hash GTY(()) tree type; }; +/* Additional language-dependent binfo slots. */ +unsigned binfo_lang_slots; + /* Initial size of the hash table (rounded to next prime). */ #define TYPE_HASH_INITIAL_SIZE 1000 @@ -267,6 +271,8 @@ make_node_stat (enum tree_code code MEM_STAT_DECL) kind = id_kind; else if (code == TREE_VEC) kind = vec_kind; + else if (code == TREE_BINFO) + kind = binfo_kind; else if (code == PHI_NODE) kind = phi_kind; else if (code == SSA_NAME) @@ -573,6 +579,39 @@ build_complex (tree type, tree real, tree imag) return t; } +/* Build a BINFO with LEN language slots. */ + +tree +make_tree_binfo_stat (unsigned lang_slots MEM_STAT_DECL) +{ + tree t; + static unsigned length; + + if (!length) + { + length = (offsetof (struct tree_binfo, lang_slots) + + (sizeof (((struct tree_binfo *)0)->lang_slots[0]) + * lang_slots)); + binfo_lang_slots = lang_slots; + } + else if (binfo_lang_slots != lang_slots) + abort (); + +#ifdef GATHER_STATISTICS + tree_node_counts[(int) binfo_kind]++; + tree_node_sizes[(int) binfo_kind] += length; +#endif + + t = ggc_alloc_zone_stat (length, tree_zone PASS_MEM_STAT); + + memset (t, 0, length); + + TREE_SET_CODE (t, TREE_BINFO); + + return t; +} + + /* Build a newly constructed TREE_VEC node of length LEN. */ tree @@ -1493,6 +1532,7 @@ tree_node_structure (tree t) case PLACEHOLDER_EXPR: return TS_COMMON; case STATEMENT_LIST: return TS_STATEMENT_LIST; case BLOCK: return TS_BLOCK; + case TREE_BINFO: return TS_BINFO; case VALUE_HANDLE: return TS_VALUE_HANDLE; default: diff --git a/gcc/tree.def b/gcc/tree.def index bb49981..79dcd94 100644 --- a/gcc/tree.def +++ b/gcc/tree.def @@ -903,6 +903,10 @@ DEFTREECODE (STATEMENT_LIST, "statement_list", 'x', 0) the same value, they will be assigned the same value handle. */ DEFTREECODE (VALUE_HANDLE, "value_handle", 'x', 0) +/* Base class information. Holds information about a class as a + baseclass of itself or another class. */ +DEFTREECODE (TREE_BINFO, "tree_binfo", 'x', 0) + /* Local variables: mode:c diff --git a/gcc/tree.h b/gcc/tree.h index 3d2f188..fc854d5 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -203,7 +203,7 @@ struct tree_common GTY(()) TREE_STATIC in VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR TREE_VIA_VIRTUAL in - TREE_LIST or TREE_VEC + TREE_LIST or TREE_BINFO TREE_CONSTANT_OVERFLOW in INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST TREE_SYMBOL_REFERENCED in @@ -558,9 +558,11 @@ extern void tree_operand_check_failed (int, enum tree_code, #define SET_OR_ARRAY_CHECK(T) \ TREE_CHECK2 (T, ARRAY_TYPE, SET_TYPE) -#define REC_OR_UNION_CHECK(T) \ +#define RECORD_OR_UNION_CHECK(T) \ TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) - +#define NOT_RECORD_OR_UNION_CHECK(T) \ + TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) + #define NUMERICAL_TYPE_CHECK(T) \ TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, \ CHAR_TYPE, REAL_TYPE) @@ -736,10 +738,10 @@ extern void tree_operand_check_failed (int, enum tree_code, implicitly and should not lead to any sort of warning. */ #define TREE_NO_WARNING(NODE) ((NODE)->common.nowarning_flag) -/* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation +/* Nonzero for a TREE_LIST or TREE_BINFO node means that the derivation chain is via a `virtual' declaration. */ #define TREE_VIA_VIRTUAL(NODE) \ - (TREE_CHECK2 (NODE, TREE_LIST, TREE_VEC)->common.static_flag) + (TREE_CHECK2 (NODE, TREE_LIST, TREE_BINFO)->common.static_flag) /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means there was an overflow in folding. This is distinct from @@ -1366,9 +1368,9 @@ struct tree_block GTY(()) #define TYPE_ORIG_SIZE_TYPE(NODE) (INTEGER_TYPE_CHECK (NODE)->type.values) #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values) #define TYPE_DOMAIN(NODE) (SET_OR_ARRAY_CHECK (NODE)->type.values) -#define TYPE_FIELDS(NODE) (REC_OR_UNION_CHECK (NODE)->type.values) -#define TYPE_METHODS(NODE) (REC_OR_UNION_CHECK (NODE)->type.maxval) -#define TYPE_VFIELD(NODE) (REC_OR_UNION_CHECK (NODE)->type.minval) +#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values) +#define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval) +#define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval) #define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values) #define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval) #define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval) @@ -1393,10 +1395,12 @@ struct tree_block GTY(()) structure containing an array. */ #define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values) -/* For aggregate types, information about this type, as a base type - for itself. Used in a language-dependent way for types that are - neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE. */ -#define TYPE_BINFO(NODE) (TYPE_CHECK (NODE)->type.binfo) +/* For record and union types, information about this type, as a base type + for itself. */ +#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo) + +/* For non record and union types, used in a language-dependent way. */ +#define TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK(NODE)->type.binfo) /* The (language-specific) typed-based alias set for this type. Objects whose TYPE_ALIAS_SETs are different cannot alias each @@ -1594,7 +1598,7 @@ struct tree_type GTY(()) of D acting as a basetype for C by looking at C's binfo's basetypes. */ /* The actual data type node being inherited in this basetype. */ -#define BINFO_TYPE(NODE) TREE_TYPE (NODE) +#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE)) /* The offset where this basetype appears in its containing type. BINFO_OFFSET slot holds the offset (in bytes) @@ -1602,7 +1606,7 @@ struct tree_type GTY(()) object that is allocated on behalf of this `type'. This is always 0 except when there is multiple inheritance. */ -#define BINFO_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1) +#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset) #define TYPE_BINFO_OFFSET(NODE) BINFO_OFFSET (TYPE_BINFO (NODE)) #define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE))) @@ -1610,13 +1614,13 @@ struct tree_type GTY(()) function tables provide a mechanism for run-time method dispatching. The entries of a virtual function table are language-dependent. */ -#define BINFO_VTABLE(NODE) TREE_VEC_ELT ((NODE), 2) +#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable) #define TYPE_BINFO_VTABLE(NODE) BINFO_VTABLE (TYPE_BINFO (NODE)) /* The virtual functions in the virtual function table. This is a TREE_LIST that is used as an initial approximation for building a virtual function table for this basetype. */ -#define BINFO_VIRTUALS(NODE) TREE_VEC_ELT ((NODE), 3) +#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals) #define TYPE_BINFO_VIRTUALS(NODE) BINFO_VIRTUALS (TYPE_BINFO (NODE)) /* A vector of binfos for the direct basetypes inherited by this @@ -1630,8 +1634,8 @@ struct tree_type GTY(()) base types at the end of this TREE_VEC (instead of using another TREE_VEC). This would simplify the calculation of how many basetypes a given type had. */ -#define BINFO_BASETYPES(NODE) TREE_VEC_ELT ((NODE), 4) -#define TYPE_BINFO_BASETYPES(NODE) TREE_VEC_ELT (TYPE_BINFO (NODE), 4) +#define BINFO_BASETYPES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_types) +#define TYPE_BINFO_BASETYPES(NODE) BINFO_BASETYPES (TYPE_BINFO (NODE)) /* The number of basetypes for NODE. */ #define BINFO_N_BASETYPES(NODE) \ @@ -1647,18 +1651,18 @@ struct tree_type GTY(()) base. The actual contents are language-dependent. In the C++ front-end this field is an INTEGER_CST giving an offset into the vtable where the offset to the virtual base can be found. */ -#define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT (NODE, 5) +#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field) /* Indicates the accesses this binfo has to its bases. The values are access_public_node, access_protected_node or access_private_node. If this array is not present, public access is implied. */ -#define BINFO_BASEACCESSES(NODE) TREE_VEC_ELT ((NODE), 6) +#define BINFO_BASEACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses) #define BINFO_BASEACCESS(NODE,N) TREE_VEC_ELT (BINFO_BASEACCESSES(NODE), (N)) /* Number of language independent elements in a binfo. Languages may add additional trailing elements. */ -#define BINFO_ELTS 7 +#define BINFO_LANG_SLOT(NODE,N) (TREE_BINFO_CHECK(NODE)->binfo.lang_slots[N]) /* Slot used to build a chain that represents a use of inheritance. For example, if X is derived from Y, and Y is derived from Z, @@ -1671,7 +1675,25 @@ struct tree_type GTY(()) consing new space pointing to binfo nodes). It is up to the language-dependent front-ends to maintain this information as necessary. */ -#define BINFO_INHERITANCE_CHAIN(NODE) TREE_VEC_ELT ((NODE), 0) +#define BINFO_INHERITANCE_CHAIN(NODE) \ + (TREE_BINFO_CHECK(NODE)->binfo.inheritance) + +struct tree_binfo GTY (()) +{ + struct tree_common common; + + tree offset; + tree vtable; + tree virtuals; + tree base_types; + tree vptr_field; + tree base_accesses; + tree inheritance; + + tree GTY ((length ("binfo_lang_slots"))) lang_slots[1]; +}; +extern GTY (()) unsigned binfo_lang_slots; + /* Define fields and accessors for nodes representing declared names. */ @@ -2313,6 +2335,7 @@ enum tree_node_structure_enum { TS_SSA_NAME, TS_PHI_NODE, TS_BLOCK, + TS_BINFO, TS_STATEMENT_LIST, TS_VALUE_HANDLE, LAST_TS_ENUM @@ -2340,6 +2363,7 @@ union tree_node GTY ((ptr_alias (union lang_tree_node), struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi; struct tree_block GTY ((tag ("TS_BLOCK"))) block; + struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo; struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle; }; @@ -2587,6 +2611,10 @@ extern tree copy_node_stat (tree MEM_STAT_DECL); extern tree copy_list (tree); +/* Make a BINFO. */ +extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL); +#define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO) + /* Make a TREE_VEC. */ extern tree make_tree_vec_stat (int MEM_STAT_DECL); @@ -3727,6 +3755,7 @@ typedef enum perm_list_kind, temp_list_kind, vec_kind, + binfo_kind, phi_kind, ssa_name_kind, x_kind, -- 2.7.4