X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcp%2Ftypeck2.c;h=e31d87b16986074aea3913bf60f2f240d6af2456;hb=5e016dfc61b8e84dcbd0df9a4807394e1ca173bf;hp=46874865d2539473b9f1c9619df79fce2c14082d;hpb=d29afff056da57fb85f6847401bd9c30a15f9030;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index 46874865d25..e31d87b1698 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -1,7 +1,7 @@ /* Report error messages, build initializers, and perform some front-end optimizations for C++ compiler. Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2004 + 1999, 2000, 2001, 2002, 2004, 2005, 2006 Free Software Foundation, Inc. Hacked by Michael Tiemann (tiemann@cygnus.com) @@ -19,18 +19,14 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +the Free Software Foundation, 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ /* This file is part of the C++ front end. It contains routines to build C++ expressions given their operands, including computing the types of the result, C and C++ specific error - checks, and some optimization. - - There are also routines to build RETURN_STMT nodes and CASE_STMT nodes, - and to process initializations in declarations (since they work - like a strange sort of assignment). */ + checks, and some optimization. */ #include "config.h" #include "system.h" @@ -43,7 +39,9 @@ Boston, MA 02111-1307, USA. */ #include "output.h" #include "diagnostic.h" -static tree process_init_constructor (tree, tree, tree *); +static tree +process_init_constructor (tree type, tree init); + /* Print an error message stemming from an attempt to use BASETYPE as a base class for TYPE. */ @@ -53,14 +51,14 @@ error_not_base_type (tree basetype, tree type) { if (TREE_CODE (basetype) == FUNCTION_DECL) basetype = DECL_CONTEXT (basetype); - error ("type `%T' is not a base type for type `%T'", basetype, type); + error ("type %qT is not a base type for type %qT", basetype, type); return error_mark_node; } tree binfo_or_else (tree base, tree type) { - tree binfo = lookup_base (type, base, ba_ignore, NULL); + tree binfo = lookup_base (type, base, ba_unique, NULL); if (binfo == error_mark_node) return NULL_TREE; @@ -78,7 +76,7 @@ void readonly_error (tree arg, const char* string, int soft) { const char *fmt; - void (*fn) (const char *, ...); + void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); if (soft) fn = pedwarn; @@ -88,9 +86,9 @@ readonly_error (tree arg, const char* string, int soft) if (TREE_CODE (arg) == COMPONENT_REF) { if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) - fmt = "%s of data-member `%D' in read-only structure"; + fmt = "%s of data-member %qD in read-only structure"; else - fmt = "%s of read-only data-member `%D'"; + fmt = "%s of read-only data-member %qD"; (*fn) (fmt, string, TREE_OPERAND (arg, 1)); } else if (TREE_CODE (arg) == VAR_DECL) @@ -98,26 +96,141 @@ readonly_error (tree arg, const char* string, int soft) if (DECL_LANG_SPECIFIC (arg) && DECL_IN_AGGR_P (arg) && !TREE_STATIC (arg)) - fmt = "%s of constant field `%D'"; + fmt = "%s of constant field %qD"; else - fmt = "%s of read-only variable `%D'"; + fmt = "%s of read-only variable %qD"; (*fn) (fmt, string, arg); } else if (TREE_CODE (arg) == PARM_DECL) - (*fn) ("%s of read-only parameter `%D'", string, arg); + (*fn) ("%s of read-only parameter %qD", string, arg); else if (TREE_CODE (arg) == INDIRECT_REF - && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE - && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL - || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) - (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0)); + && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE + && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL + || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) + (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0)); else if (TREE_CODE (arg) == RESULT_DECL) - (*fn) ("%s of read-only named return value `%D'", string, arg); + (*fn) ("%s of read-only named return value %qD", string, arg); else if (TREE_CODE (arg) == FUNCTION_DECL) - (*fn) ("%s of function `%D'", string, arg); + (*fn) ("%s of function %qD", string, arg); else (*fn) ("%s of read-only location", string); } + +/* Structure that holds information about declarations whose type was + incomplete and we could not check whether it was abstract or not. */ + +struct pending_abstract_type GTY((chain_next ("%h.next"))) +{ + /* Declaration which we are checking for abstractness. It is either + a DECL node, or an IDENTIFIER_NODE if we do not have a full + declaration available. */ + tree decl; + + /* Type which will be checked for abstractness. */ + tree type; + + /* Position of the declaration. This is only needed for IDENTIFIER_NODEs, + because DECLs already carry locus information. */ + location_t locus; + + /* Link to the next element in list. */ + struct pending_abstract_type* next; +}; + + +/* Compute the hash value of the node VAL. This function is used by the + hash table abstract_pending_vars. */ + +static hashval_t +pat_calc_hash (const void* val) +{ + const struct pending_abstract_type *pat = + (const struct pending_abstract_type *) val; + return (hashval_t) TYPE_UID (pat->type); +} + + +/* Compare node VAL1 with the type VAL2. This function is used by the + hash table abstract_pending_vars. */ + +static int +pat_compare (const void* val1, const void* val2) +{ + const struct pending_abstract_type *pat1 = + (const struct pending_abstract_type *) val1; + tree type2 = (tree)val2; + + return (pat1->type == type2); +} + +/* Hash table that maintains pending_abstract_type nodes, for which we still + need to check for type abstractness. The key of the table is the type + of the declaration. */ +static GTY ((param_is (struct pending_abstract_type))) +htab_t abstract_pending_vars = NULL; + + +/* This function is called after TYPE is completed, and will check if there + are pending declarations for which we still need to verify the abstractness + of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE + turned out to be incomplete. */ + +void +complete_type_check_abstract (tree type) +{ + void **slot; + struct pending_abstract_type *pat; + location_t cur_loc = input_location; + + gcc_assert (COMPLETE_TYPE_P (type)); + + if (!abstract_pending_vars) + return; + + /* Retrieve the list of pending declarations for this type. */ + slot = htab_find_slot_with_hash (abstract_pending_vars, type, + (hashval_t)TYPE_UID (type), NO_INSERT); + if (!slot) + return; + pat = (struct pending_abstract_type*)*slot; + gcc_assert (pat); + + /* If the type is not abstract, do not do anything. */ + if (CLASSTYPE_PURE_VIRTUALS (type)) + { + struct pending_abstract_type *prev = 0, *next; + + /* Reverse the list to emit the errors in top-down order. */ + for (; pat; pat = next) + { + next = pat->next; + pat->next = prev; + prev = pat; + } + pat = prev; + + /* Go through the list, and call abstract_virtuals_error for each + element: it will issue a diagnostic if the type is abstract. */ + while (pat) + { + gcc_assert (type == pat->type); + + /* Tweak input_location so that the diagnostic appears at the correct + location. Notice that this is only needed if the decl is an + IDENTIFIER_NODE. */ + input_location = pat->locus; + abstract_virtuals_error (pat->decl, pat->type); + pat = pat->next; + } + } + + htab_clear_slot (abstract_pending_vars, slot); + + input_location = cur_loc; +} + + /* If TYPE has abstract virtual functions, issue an error about trying to create an object of that type. DECL is the object declared, or NULL_TREE if the declaration is unavailable. Returns 1 if an error @@ -126,57 +239,101 @@ readonly_error (tree arg, const char* string, int soft) int abstract_virtuals_error (tree decl, tree type) { - tree u; - tree tu; + VEC(tree,gc) *pure; - if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type)) + /* This function applies only to classes. Any other entity can never + be abstract. */ + if (!CLASS_TYPE_P (type)) return 0; + /* If the type is incomplete, we register it within a hash table, + so that we can check again once it is completed. This makes sense + only for objects for which we have a declaration or at least a + name. */ + if (!COMPLETE_TYPE_P (type)) + { + void **slot; + struct pending_abstract_type *pat; + + gcc_assert (!decl || DECL_P (decl) + || TREE_CODE (decl) == IDENTIFIER_NODE); + + if (!abstract_pending_vars) + abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash, + &pat_compare, NULL); + + slot = htab_find_slot_with_hash (abstract_pending_vars, type, + (hashval_t)TYPE_UID (type), INSERT); + + pat = GGC_NEW (struct pending_abstract_type); + pat->type = type; + pat->decl = decl; + pat->locus = ((decl && DECL_P (decl)) + ? DECL_SOURCE_LOCATION (decl) + : input_location); + + pat->next = (struct pending_abstract_type *) *slot; + *slot = pat; + + return 0; + } + if (!TYPE_SIZE (type)) /* TYPE is being defined, and during that time CLASSTYPE_PURE_VIRTUALS holds the inline friends. */ return 0; - if (dependent_type_p (type)) - /* For a dependent type, we do not yet know which functions are pure - virtuals. */ + pure = CLASSTYPE_PURE_VIRTUALS (type); + if (!pure) return 0; - u = CLASSTYPE_PURE_VIRTUALS (type); if (decl) { if (TREE_CODE (decl) == RESULT_DECL) return 0; if (TREE_CODE (decl) == VAR_DECL) - error ("cannot declare variable `%D' to be of type `%T'", - decl, type); + error ("cannot declare variable %q+D to be of abstract " + "type %qT", decl, type); else if (TREE_CODE (decl) == PARM_DECL) - error ("cannot declare parameter `%D' to be of type `%T'", - decl, type); + error ("cannot declare parameter %q+D to be of abstract type %qT", + decl, type); else if (TREE_CODE (decl) == FIELD_DECL) - error ("cannot declare field `%D' to be of type `%T'", - decl, type); + error ("cannot declare field %q+D to be of abstract type %qT", + decl, type); else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) - error ("invalid return type for member function `%#D'", decl); + error ("invalid abstract return type for member function %q+#D", decl); else if (TREE_CODE (decl) == FUNCTION_DECL) - error ("invalid return type for function `%#D'", decl); + error ("invalid abstract return type for function %q+#D", decl); + else if (TREE_CODE (decl) == IDENTIFIER_NODE) + /* Here we do not have location information. */ + error ("invalid abstract type %qT for %qE", type, decl); + else + error ("invalid abstract type for %q+D", decl); } else - error ("cannot allocate an object of type `%T'", type); + error ("cannot allocate an object of abstract type %qT", type); /* Only go through this once. */ - if (TREE_PURPOSE (u) == NULL_TREE) + if (VEC_length (tree, pure)) { - TREE_PURPOSE (u) = error_mark_node; - - error (" because the following virtual functions are abstract:"); - for (tu = u; tu; tu = TREE_CHAIN (tu)) - cp_error_at ("\t%#D", TREE_VALUE (tu)); + unsigned ix; + tree fn; + + inform ("%J because the following virtual functions are pure " + "within %qT:", TYPE_MAIN_DECL (type), type); + + for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++) + inform ("\t%+#D", fn); + /* Now truncate the vector. This leaves it non-null, so we know + there are pure virtuals, but empty so we don't list them out + again. */ + VEC_truncate (tree, pure, 0); } else - error (" since type `%T' has abstract virtual functions", type); + inform ("%J since type %qT has pure virtual functions", + TYPE_MAIN_DECL (type), type); return 1; } @@ -191,25 +348,15 @@ void cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type) { int decl = 0; - void (*p_msg) (const char *, ...); - void (*p_msg_at) (const char *, ...); + void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); if (diag_type == 1) - { - p_msg = warning; - p_msg_at = cp_warning_at; - } + p_msg = warning0; else if (diag_type == 2) - { - p_msg = pedwarn; - p_msg_at = cp_pedwarn_at; - } + p_msg = pedwarn; else - { - p_msg = error; - p_msg_at = cp_error_at; - } - + p_msg = error; + /* Avoid duplicate error message. */ if (TREE_CODE (type) == ERROR_MARK) return; @@ -218,10 +365,10 @@ cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type) || TREE_CODE (value) == PARM_DECL || TREE_CODE (value) == FIELD_DECL)) { - (*p_msg_at) ("`%D' has incomplete type", value); + p_msg ("%q+D has incomplete type", value); decl = 1; } -retry: + retry: /* We must print an error message. Be clever about what it says. */ switch (TREE_CODE (type)) @@ -230,48 +377,58 @@ retry: case UNION_TYPE: case ENUMERAL_TYPE: if (!decl) - (*p_msg) ("invalid use of undefined type `%#T'", type); + p_msg ("invalid use of incomplete type %q#T", type); if (!TYPE_TEMPLATE_INFO (type)) - (*p_msg_at) ("forward declaration of `%#T'", type); + p_msg ("forward declaration of %q+#T", type); else - (*p_msg_at) ("declaration of `%#T'", type); + p_msg ("declaration of %q+#T", type); break; case VOID_TYPE: - (*p_msg) ("invalid use of `%T'", type); + p_msg ("invalid use of %qT", type); break; case ARRAY_TYPE: if (TYPE_DOMAIN (type)) - { - type = TREE_TYPE (type); - goto retry; - } - (*p_msg) ("invalid use of array with unspecified bounds"); + { + type = TREE_TYPE (type); + goto retry; + } + p_msg ("invalid use of array with unspecified bounds"); break; case OFFSET_TYPE: bad_member: - (*p_msg) ("invalid use of member (did you forget the `&' ?)"); + p_msg ("invalid use of member (did you forget the %<&%> ?)"); break; case TEMPLATE_TYPE_PARM: - (*p_msg) ("invalid use of template type parameter"); + p_msg ("invalid use of template type parameter %qT", type); + break; + + case BOUND_TEMPLATE_TEMPLATE_PARM: + p_msg ("invalid use of template template parameter %qT", + TYPE_NAME (type)); + break; + + case TYPENAME_TYPE: + p_msg ("invalid use of dependent type %qT", type); break; case UNKNOWN_TYPE: if (value && TREE_CODE (value) == COMPONENT_REF) - goto bad_member; + goto bad_member; else if (value && TREE_CODE (value) == ADDR_EXPR) - (*p_msg) ("address of overloaded function with no contextual type information"); + p_msg ("address of overloaded function with no contextual " + "type information"); else if (value && TREE_CODE (value) == OVERLOAD) - (*p_msg) ("overloaded function with no contextual type information"); + p_msg ("overloaded function with no contextual type information"); else - (*p_msg) ("insufficient contextual information to determine type"); + p_msg ("insufficient contextual information to determine type"); break; - + default: - abort (); + gcc_unreachable (); } } @@ -286,19 +443,17 @@ cxx_incomplete_type_error (tree value, tree type) /* The recursive part of split_nonconstant_init. DEST is an lvalue - expression to which INIT should be assigned. INIT is a CONSTRUCTOR. - PCODE is a pointer to the tail of a chain of statements being emitted. - The return value is the new tail of that chain after new statements - are generated. */ + expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */ -static tree * -split_nonconstant_init_1 (tree dest, tree init, tree *pcode) +static void +split_nonconstant_init_1 (tree dest, tree init) { - tree *pelt, elt, type = TREE_TYPE (dest); - tree sub, code, inner_type = NULL; + unsigned HOST_WIDE_INT idx; + tree field_index, value; + tree type = TREE_TYPE (dest); + tree inner_type = NULL; bool array_type_p = false; - pelt = &CONSTRUCTOR_ELTS (init); switch (TREE_CODE (type)) { case ARRAY_TYPE: @@ -309,61 +464,82 @@ split_nonconstant_init_1 (tree dest, tree init, tree *pcode) case RECORD_TYPE: case UNION_TYPE: case QUAL_UNION_TYPE: - while ((elt = *pelt)) + FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, + field_index, value) { - tree field_index = TREE_PURPOSE (elt); - tree value = TREE_VALUE (elt); + /* The current implementation of this algorithm assumes that + the field was set for all the elements. This is usually done + by process_init_constructor. */ + gcc_assert (field_index); if (!array_type_p) inner_type = TREE_TYPE (field_index); if (TREE_CODE (value) == CONSTRUCTOR) { + tree sub; + if (array_type_p) - sub = build (ARRAY_REF, inner_type, dest, field_index); + sub = build4 (ARRAY_REF, inner_type, dest, field_index, + NULL_TREE, NULL_TREE); else - sub = build (COMPONENT_REF, inner_type, dest, field_index); + sub = build3 (COMPONENT_REF, inner_type, dest, field_index, + NULL_TREE); - pcode = split_nonconstant_init_1 (sub, value, pcode); + split_nonconstant_init_1 (sub, value); } else if (!initializer_constant_valid_p (value, inner_type)) { - *pelt = TREE_CHAIN (elt); + tree code; + tree sub; + + /* FIXME: Ordered removal is O(1) so the whole function is + worst-case quadratic. This could be fixed using an aside + bitmap to record which elements must be removed and remove + them all at the same time. Or by merging + split_non_constant_init into process_init_constructor_array, + that is separating constants from non-constants while building + the vector. */ + VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init), + idx); + --idx; if (array_type_p) - sub = build (ARRAY_REF, inner_type, dest, field_index); + sub = build4 (ARRAY_REF, inner_type, dest, field_index, + NULL_TREE, NULL_TREE); else - sub = build (COMPONENT_REF, inner_type, dest, field_index); + sub = build3 (COMPONENT_REF, inner_type, dest, field_index, + NULL_TREE); - code = build (MODIFY_EXPR, inner_type, sub, value); + code = build2 (INIT_EXPR, inner_type, sub, value); code = build_stmt (EXPR_STMT, code); - - *pcode = code; - pcode = &TREE_CHAIN (code); + add_stmt (code); continue; } - pelt = &TREE_CHAIN (elt); } break; case VECTOR_TYPE: if (!initializer_constant_valid_p (init, type)) { + tree code; + tree cons = copy_node (init); CONSTRUCTOR_ELTS (init) = NULL; - code = build (MODIFY_EXPR, type, dest, init); + code = build2 (MODIFY_EXPR, type, dest, cons); code = build_stmt (EXPR_STMT, code); - pcode = &TREE_CHAIN (code); + add_stmt (code); } break; default: - abort (); + gcc_unreachable (); } - return pcode; + /* The rest of the initializer is now a constant. */ + TREE_CONSTANT (init) = 1; } -/* A subroutine of store_init_value. Splits non-constant static +/* A subroutine of store_init_value. Splits non-constant static initializer INIT into a constant part and generates code to perform the non-constant part of the initialization to DEST. Returns the code for the runtime init. */ @@ -375,14 +551,14 @@ split_nonconstant_init (tree dest, tree init) if (TREE_CODE (init) == CONSTRUCTOR) { - code = build_stmt (COMPOUND_STMT, NULL_TREE); - split_nonconstant_init_1 (dest, init, &COMPOUND_BODY (code)); - code = build1 (STMT_EXPR, void_type_node, code); - TREE_SIDE_EFFECTS (code) = 1; + code = push_stmt_list (); + split_nonconstant_init_1 (dest, init); + code = pop_stmt_list (code); DECL_INITIAL (dest) = init; + TREE_READONLY (dest) = 0; } else - code = build (INIT_EXPR, TREE_TYPE (dest), dest, init); + code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init); return code; } @@ -418,14 +594,14 @@ store_init_value (tree decl, tree init) if (IS_AGGR_TYPE (type)) { - if (! TYPE_HAS_TRIVIAL_INIT_REF (type) - && TREE_CODE (init) != CONSTRUCTOR) - abort (); + gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type) + || TREE_CODE (init) == CONSTRUCTOR); if (TREE_CODE (init) == TREE_LIST) { - error ("constructor syntax used, but no constructor declared for type `%T'", type); - init = build_constructor (NULL_TREE, nreverse (init)); + error ("constructor syntax used, but no constructor declared " + "for type %qT", type); + init = build_constructor_from_list (NULL_TREE, nreverse (init)); } } else if (TREE_CODE (init) == TREE_LIST @@ -448,129 +624,77 @@ store_init_value (tree decl, tree init) /* End of special C++ code. */ /* Digest the specified initializer into an expression. */ - value = digest_init (type, init, (tree *) 0); - - /* Store the expression if valid; else report error. */ - - if (TREE_CODE (value) == ERROR_MARK) - ; - /* Other code expects that initializers for objects of types that need - constructing never make it into DECL_INITIAL, and passes 'init' to - build_aggr_init without checking DECL_INITIAL. So just return. */ - else if (TYPE_NEEDS_CONSTRUCTING (type)) - return build (INIT_EXPR, type, decl, value); - else if (TREE_STATIC (decl) - && (! TREE_CONSTANT (value) - || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) + value = digest_init (type, init); + /* If the initializer is not a constant, fill in DECL_INITIAL with + the bits that are constant, and then return an expression that + will perform the dynamic initialization. */ + if (value != error_mark_node + && (TREE_SIDE_EFFECTS (value) + || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) return split_nonconstant_init (decl, value); - - /* Store the VALUE in DECL_INITIAL. If we're building a - statement-tree we will actually expand the initialization later - when we output this function. */ + /* If the value is a constant, just put it in DECL_INITIAL. If DECL + is an automatic variable, the middle end will turn this into a + dynamic initialization later. */ DECL_INITIAL (decl) = value; return NULL_TREE; } -/* Digest the parser output INIT as an initializer for type TYPE. - Return a C expression of type TYPE to represent the initial value. +/* Process the initializer INIT for a variable of type TYPE, emitting + diagnostics for invalid initializers and converting the initializer as + appropriate. - If TAIL is nonzero, it points to a variable holding a list of elements - of which INIT is the first. We update the list stored there by - removing from the head all the elements that we use. - Normally this is only one; we use more than one element only if - TYPE is an aggregate and INIT is not a constructor. */ + For aggregate types, it assumes that reshape_init has already run, thus the + initializer will have the right shape (brace elision has been undone). */ tree -digest_init (tree type, tree init, tree* tail) +digest_init (tree type, tree init) { enum tree_code code = TREE_CODE (type); - tree element = NULL_TREE; - tree old_tail_contents = NULL_TREE; - /* Nonzero if INIT is a braced grouping. */ - int raw_constructor; - /* By default, assume we use one element from a list. - We correct this later in the sole case where it is not true. */ - - if (tail) - { - old_tail_contents = *tail; - *tail = TREE_CHAIN (*tail); - } - - if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST - && TREE_VALUE (init) == error_mark_node)) + if (init == error_mark_node) return error_mark_node; - if (TREE_CODE (init) == ERROR_MARK) - /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside - a template function. This gets substituted during instantiation. */ - return init; + gcc_assert (init); /* We must strip the outermost array type when completing the type, because the its bounds might be incomplete at the moment. */ if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE ? TREE_TYPE (type) : type, NULL_TREE)) return error_mark_node; - - /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ + + /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue + (g++.old-deja/g++.law/casts2.C). */ if (TREE_CODE (init) == NON_LVALUE_EXPR) init = TREE_OPERAND (init, 0); - raw_constructor = (TREE_CODE (init) == CONSTRUCTOR - && TREE_HAS_CONSTRUCTOR (init)); - - if (raw_constructor - && CONSTRUCTOR_ELTS (init) != 0 - && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0) - { - element = TREE_VALUE (CONSTRUCTOR_ELTS (init)); - /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ - if (element && TREE_CODE (element) == NON_LVALUE_EXPR) - element = TREE_OPERAND (element, 0); - if (element == error_mark_node) - return element; - } - - /* Initialization of an array of chars from a string constant - optionally enclosed in braces. */ - + /* Initialization of an array of chars from a string constant. The initializer + can be optionally enclosed in braces, but reshape_init has already removed + them if they were present. */ if (code == ARRAY_TYPE) { - tree typ1; - - if (TREE_CODE (init) == TREE_LIST) - { - error ("initializing array with parameter list"); - return error_mark_node; - } - - typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); + tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); if (char_type_p (typ1) - && ((init && TREE_CODE (init) == STRING_CST) - || (element && TREE_CODE (element) == STRING_CST))) + /*&& init */ + && TREE_CODE (init) == STRING_CST) { - tree string = element ? element : init; + tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init))); - if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) - != char_type_node) + if (char_type != char_type_node && TYPE_PRECISION (typ1) == BITS_PER_UNIT) { error ("char-array initialized from wide string"); return error_mark_node; } - if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) - == char_type_node) + if (char_type == char_type_node && TYPE_PRECISION (typ1) != BITS_PER_UNIT) { error ("int-array initialized from non-wide string"); return error_mark_node; } - TREE_TYPE (string) = type; - if (TYPE_DOMAIN (type) != 0 - && TREE_CONSTANT (TYPE_SIZE (type))) + TREE_TYPE (init) = type; + if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type))) { int size = TREE_INT_CST_LOW (TYPE_SIZE (type)); size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; @@ -578,431 +702,379 @@ digest_init (tree type, tree init, tree* tail) because it's ok to ignore the terminating null char that is counted in the length of the constant, but in C++ this would be invalid. */ - if (size < TREE_STRING_LENGTH (string)) + if (size < TREE_STRING_LENGTH (init)) pedwarn ("initializer-string for array of chars is too long"); } - return string; + return init; } } - /* Handle scalar types, including conversions, - and signature pointers and references. */ - - if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE - || code == ENUMERAL_TYPE || code == REFERENCE_TYPE - || code == BOOLEAN_TYPE || code == COMPLEX_TYPE - || TYPE_PTR_TO_MEMBER_P (type)) + /* Handle scalar types (including conversions) and references. */ + if (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE) + return convert_for_initialization (0, type, init, LOOKUP_NORMAL, + "initialization", NULL_TREE, 0); + + /* Come here only for aggregates: records, arrays, unions, complex numbers + and vectors. */ + gcc_assert (TREE_CODE (type) == ARRAY_TYPE + || TREE_CODE (type) == VECTOR_TYPE + || TREE_CODE (type) == RECORD_TYPE + || TREE_CODE (type) == UNION_TYPE + || TREE_CODE (type) == COMPLEX_TYPE); + + if (BRACE_ENCLOSED_INITIALIZER_P (init)) + return process_init_constructor (type, init); + else { - if (raw_constructor) + if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE) { - if (element == 0) - { - error ("initializer for scalar variable requires one element"); - return error_mark_node; - } - init = element; + error ("cannot initialize aggregate of type %qT with " + "a compound literal", type); + + return error_mark_node; } - while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init)) + + if (TREE_CODE (type) == ARRAY_TYPE + && TREE_CODE (init) != CONSTRUCTOR) { - pedwarn ("braces around scalar initializer for `%T'", type); - init = CONSTRUCTOR_ELTS (init); - if (TREE_CHAIN (init)) - pedwarn ("ignoring extra initializers for `%T'", type); - init = TREE_VALUE (init); + error ("array must be initialized with a brace-enclosed" + " initializer"); + return error_mark_node; } - return convert_for_initialization (0, type, init, LOOKUP_NORMAL, + return convert_for_initialization (NULL_TREE, type, init, + LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING, "initialization", NULL_TREE, 0); } +} + + +/* Set of flags used within process_init_constructor to describe the + initializers. */ +#define PICFLAG_ERRONEOUS 1 +#define PICFLAG_NOT_ALL_CONSTANT 2 +#define PICFLAG_NOT_ALL_SIMPLE 4 + +/* Given an initializer INIT, return the flag (PICFLAG_*) which better + describe it. */ + +static int +picflag_from_initializer (tree init) +{ + if (init == error_mark_node) + return PICFLAG_ERRONEOUS; + else if (!TREE_CONSTANT (init)) + return PICFLAG_NOT_ALL_CONSTANT; + else if (!initializer_constant_valid_p (init, TREE_TYPE (init))) + return PICFLAG_NOT_ALL_SIMPLE; + return 0; +} - /* Come here only for records and arrays (and unions with constructors). */ +/* Subroutine of process_init_constructor, which will process an initializer + INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which + describe the initializers. */ - if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type))) +static int +process_init_constructor_array (tree type, tree init) +{ + unsigned HOST_WIDE_INT i, len = 0; + int flags = 0; + bool unbounded = false; + constructor_elt *ce; + VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init); + + gcc_assert (TREE_CODE (type) == ARRAY_TYPE + || TREE_CODE (type) == VECTOR_TYPE); + + if (TREE_CODE (type) == ARRAY_TYPE) { - error ("variable-sized object of type `%T' may not be initialized", - type); - return error_mark_node; + tree domain = TYPE_DOMAIN (type); + if (domain) + len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) + - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) + + 1); + else + unbounded = true; /* Take as many as there are. */ } + else + /* Vectors are like simple fixed-size arrays. */ + len = TYPE_VECTOR_SUBPARTS (type); - if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code)) + /* There cannot be more initializers than needed as otherwise + reshape_init would have already rejected the initializer. */ + if (!unbounded) + gcc_assert (VEC_length (constructor_elt, v) <= len); + + for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i) { - if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type) - && TREE_HAS_CONSTRUCTOR (init)) + if (ce->index) { - error ("subobject of type `%T' must be initialized by constructor, not by `%E'", - type, init); - return error_mark_node; - } - else if (raw_constructor) - return process_init_constructor (type, init, (tree *)0); - else if (can_convert_arg (type, TREE_TYPE (init), init) - || TYPE_NON_AGGREGATE_CLASS (type)) - /* These are never initialized from multiple constructor elements. */; - else if (tail != 0) - { - *tail = old_tail_contents; - return process_init_constructor (type, 0, tail); + gcc_assert (TREE_CODE (ce->index) == INTEGER_CST); + if (compare_tree_int (ce->index, i) != 0) + { + ce->value = error_mark_node; + sorry ("non-trivial designated initializers not supported"); + } } + else + ce->index = size_int (i); + gcc_assert (ce->value); + ce->value = digest_init (TREE_TYPE (type), ce->value); - if (code != ARRAY_TYPE) - { - int flags = LOOKUP_NORMAL; - /* Initialization from { } is copy-initialization. */ - if (tail) - flags |= LOOKUP_ONLYCONVERTING; + if (ce->value != error_mark_node) + gcc_assert (same_type_ignoring_top_level_qualifiers_p + (TREE_TYPE (type), TREE_TYPE (ce->value))); - return convert_for_initialization (NULL_TREE, type, init, flags, - "initialization", NULL_TREE, 0); - } + flags |= picflag_from_initializer (ce->value); } - error ("invalid initializer"); - return error_mark_node; + /* No more initializers. If the array is unbounded, we are done. Otherwise, + we must add initializers ourselves. */ + if (!unbounded) + for (; i < len; ++i) + { + tree next; + + if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) + { + /* If this type needs constructors run for default-initialization, + we can't rely on the back end to do it for us, so build up + TARGET_EXPRs. If the type in question is a class, just build + one up; if it's an array, recurse. */ + if (IS_AGGR_TYPE (TREE_TYPE (type))) + next = build_functional_cast (TREE_TYPE (type), NULL_TREE); + else + next = build_constructor (NULL_TREE, NULL); + next = digest_init (TREE_TYPE (type), next); + } + else if (!zero_init_p (TREE_TYPE (type))) + next = build_zero_init (TREE_TYPE (type), + /*nelts=*/NULL_TREE, + /*static_storage_p=*/false); + else + /* The default zero-initialization is fine for us; don't + add anything to the CONSTRUCTOR. */ + break; + + flags |= picflag_from_initializer (next); + CONSTRUCTOR_APPEND_ELT (v, size_int (i), next); + } + + CONSTRUCTOR_ELTS (init) = v; + return flags; } - -/* Process a constructor for a variable of type TYPE. - The constructor elements may be specified either with INIT or with ELTS, - only one of which should be non-null. - - If INIT is specified, it is a CONSTRUCTOR node which is specifically - and solely for initializing this datum. - If ELTS is specified, it is the address of a variable containing - a list of expressions. We take as many elements as we need - from the head of the list and update the list. +/* Subroutine of process_init_constructor, which will process an initializer + INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe + the initializers. */ - In the resulting constructor, TREE_CONSTANT is set if all elts are - constant, and TREE_STATIC is set if, in addition, all elts are simple enough - constants that the assembler and linker can compute them. */ - -static tree -process_init_constructor (tree type, tree init, tree* elts) +static int +process_init_constructor_record (tree type, tree init) { - tree tail; - /* List of the elements of the result constructor, - in reverse order. */ - tree members = NULL; - tree next1; - tree result; - int allconstant = 1; - int allsimple = 1; - int erroneous = 0; - - /* Make TAIL be the list of elements to use for the initialization, - no matter how the data was given to us. */ - - if (elts) - { - if (warn_missing_braces) - warning ("aggregate has a partly bracketed initializer"); - tail = *elts; - } - else - tail = CONSTRUCTOR_ELTS (init); - - /* Gobble as many elements as needed, and make a constructor or initial value - for each element of this aggregate. Chain them together in result. - If there are too few, use 0 for each scalar ultimate component. */ - - if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) + VEC(constructor_elt,gc) *v = NULL; + int flags = 0; + tree field; + unsigned HOST_WIDE_INT idx = 0; + + gcc_assert (TREE_CODE (type) == RECORD_TYPE); + gcc_assert (!CLASSTYPE_VBASECLASSES (type)); + gcc_assert (!TYPE_BINFO (type) + || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type))); + gcc_assert (!TYPE_POLYMORPHIC_P (type)); + + /* Generally, we will always have an index for each initializer (which is + a FIELD_DECL, put by reshape_init), but compound literals don't go trough + reshape_init. So we need to handle both cases. */ + for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) { - long len; - int i; + tree next; - if (TREE_CODE (type) == ARRAY_TYPE) + if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field)) { - tree domain = TYPE_DOMAIN (type); - if (domain) - len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) - - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) - + 1); - else - len = -1; /* Take as many as there are. */ - } - else - { - /* Vectors are like simple fixed-size arrays. */ - len = TYPE_VECTOR_SUBPARTS (type); + flags |= picflag_from_initializer (integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node); + continue; } - for (i = 0; len < 0 || i < len; i++) + if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) + continue; + + if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init))) { - if (tail) + constructor_elt *ce = VEC_index (constructor_elt, + CONSTRUCTOR_ELTS (init), idx); + if (ce->index) { - if (TREE_PURPOSE (tail) - && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST - || compare_tree_int (TREE_PURPOSE (tail), i) != 0)) - sorry ("non-trivial labeled initializers"); - - if (TREE_VALUE (tail) != 0) + /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The + latter case can happen in templates where lookup has to be + deferred. */ + gcc_assert (TREE_CODE (ce->index) == FIELD_DECL + || TREE_CODE (ce->index) == IDENTIFIER_NODE); + if (ce->index != field + && ce->index != DECL_NAME (field)) { - tree tail1 = tail; - next1 = digest_init (TREE_TYPE (type), - TREE_VALUE (tail), &tail1); - if (next1 == error_mark_node) - return next1; - my_friendly_assert - (same_type_ignoring_top_level_qualifiers_p - (TREE_TYPE (type), TREE_TYPE (next1)), - 981123); - my_friendly_assert (tail1 == 0 - || TREE_CODE (tail1) == TREE_LIST, 319); - if (tail == tail1 && len < 0) - { - error ("non-empty initializer for array of empty elements"); - /* Just ignore what we were supposed to use. */ - tail1 = NULL_TREE; - } - tail = tail1; - } - else - { - next1 = error_mark_node; - tail = TREE_CHAIN (tail); + ce->value = error_mark_node; + sorry ("non-trivial designated initializers not supported"); } } - else if (len < 0) - /* We're done. */ - break; - else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) - { - /* If this type needs constructors run for - default-initialization, we can't rely on the backend to do it - for us, so build up TARGET_EXPRs. If the type in question is - a class, just build one up; if it's an array, recurse. */ - if (IS_AGGR_TYPE (TREE_TYPE (type))) - next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE); - else - next1 = build_constructor (NULL_TREE, NULL_TREE); - next1 = digest_init (TREE_TYPE (type), next1, 0); - } - else if (! zero_init_p (TREE_TYPE (type))) - next1 = build_zero_init (TREE_TYPE (type), - /*nelts=*/NULL_TREE, - /*static_storage_p=*/false); - else - /* The default zero-initialization is fine for us; don't - add anything to the CONSTRUCTOR. */ - break; - - if (next1 == error_mark_node) - erroneous = 1; - else if (!TREE_CONSTANT (next1)) - allconstant = 0; - else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) - allsimple = 0; - members = tree_cons (size_int (i), next1, members); + gcc_assert (ce->value); + next = digest_init (TREE_TYPE (field), ce->value); + ++idx; } - } - else if (TREE_CODE (type) == RECORD_TYPE) - { - tree field; - - if (tail) + else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) { - if (TYPE_USES_VIRTUAL_BASECLASSES (type)) - { - sorry ("initializer list for object of class with virtual base classes"); - return error_mark_node; - } + /* If this type needs constructors run for + default-initialization, we can't rely on the back end to do it + for us, so build up TARGET_EXPRs. If the type in question is + a class, just build one up; if it's an array, recurse. */ + if (IS_AGGR_TYPE (TREE_TYPE (field))) + next = build_functional_cast (TREE_TYPE (field), NULL_TREE); + else + next = build_constructor (NULL_TREE, NULL); - if (TYPE_BINFO_BASETYPES (type)) - { - sorry ("initializer list for object of class with base classes"); - return error_mark_node; - } + next = digest_init (TREE_TYPE (field), next); - if (TYPE_POLYMORPHIC_P (type)) - { - sorry ("initializer list for object using virtual functions"); - return error_mark_node; - } + /* Warn when some struct elements are implicitly initialized. */ + warning (OPT_Wmissing_field_initializers, + "missing initializer for member %qD", field); } - - for (field = TYPE_FIELDS (type); field; - field = TREE_CHAIN (field)) + else { - if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field)) - { - members = tree_cons (field, integer_zero_node, members); - continue; - } - - if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) + if (TREE_READONLY (field)) + error ("uninitialized const member %qD", field); + else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) + error ("member %qD with uninitialized const fields", field); + else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) + error ("member %qD is uninitialized reference", field); + + /* Warn when some struct elements are implicitly initialized + to zero. */ + warning (OPT_Wmissing_field_initializers, + "missing initializer for member %qD", field); + + if (!zero_init_p (TREE_TYPE (field))) + next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE, + /*static_storage_p=*/false); + else + /* The default zero-initialization is fine for us; don't + add anything to the CONSTRUCTOR. */ continue; + } - if (tail) - { - if (TREE_PURPOSE (tail) - && TREE_PURPOSE (tail) != field - && TREE_PURPOSE (tail) != DECL_NAME (field)) - sorry ("non-trivial labeled initializers"); + flags |= picflag_from_initializer (next); + CONSTRUCTOR_APPEND_ELT (v, field, next); + } - if (TREE_VALUE (tail) != 0) - { - tree tail1 = tail; + CONSTRUCTOR_ELTS (init) = v; + return flags; +} - next1 = digest_init (TREE_TYPE (field), - TREE_VALUE (tail), &tail1); - my_friendly_assert (tail1 == 0 - || TREE_CODE (tail1) == TREE_LIST, 320); - tail = tail1; - } - else - { - next1 = error_mark_node; - tail = TREE_CHAIN (tail); - } - } - else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) - { - /* If this type needs constructors run for - default-initialization, we can't rely on the backend to do it - for us, so build up TARGET_EXPRs. If the type in question is - a class, just build one up; if it's an array, recurse. */ - - if (IS_AGGR_TYPE (TREE_TYPE (field))) - next1 = build_functional_cast (TREE_TYPE (field), - NULL_TREE); - else - { - next1 = build_constructor (NULL_TREE, NULL_TREE); - if (init) - TREE_HAS_CONSTRUCTOR (next1) - = TREE_HAS_CONSTRUCTOR (init); - } - next1 = digest_init (TREE_TYPE (field), next1, 0); - - /* Warn when some struct elements are implicitly initialized. */ - if (extra_warnings - && (!init || TREE_HAS_CONSTRUCTOR (init))) - warning ("missing initializer for member `%D'", field); - } - else +/* Subroutine of process_init_constructor, which will process a single + initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*) + which describe the initializer. */ + +static int +process_init_constructor_union (tree type, tree init) +{ + constructor_elt *ce; + + /* If the initializer was empty, use default zero initialization. */ + if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))) + return 0; + + gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1); + ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0); + + /* If this element specifies a field, initialize via that field. */ + if (ce->index) + { + if (TREE_CODE (ce->index) == FIELD_DECL) + ; + else if (TREE_CODE (ce->index) == IDENTIFIER_NODE) + { + /* This can happen within a cast, see g++.dg/opt/cse2.C. */ + tree name = ce->index; + tree field; + for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + if (DECL_NAME (field) == name) + break; + if (!field) { - if (TREE_READONLY (field)) - error ("uninitialized const member `%D'", field); - else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) - error ("member `%D' with uninitialized const fields", - field); - else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) - error ("member `%D' is uninitialized reference", field); - - /* Warn when some struct elements are implicitly initialized - to zero. */ - if (extra_warnings - && (!init || TREE_HAS_CONSTRUCTOR (init))) - warning ("missing initializer for member `%D'", field); - - if (! zero_init_p (TREE_TYPE (field))) - next1 = build_zero_init (TREE_TYPE (field), - /*nelts=*/NULL_TREE, - /*static_storage_p=*/false); - else - /* The default zero-initialization is fine for us; don't - add anything to the CONSTRUCTOR. */ - continue; + error ("no field %qD found in union being initialized", field); + ce->value = error_mark_node; } - - if (next1 == error_mark_node) - erroneous = 1; - else if (!TREE_CONSTANT (next1)) - allconstant = 0; - else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) - allsimple = 0; - members = tree_cons (field, next1, members); + ce->index = field; + } + else + { + gcc_assert (TREE_CODE (ce->index) == INTEGER_CST + || TREE_CODE (ce->index) == RANGE_EXPR); + error ("index value instead of field name in union initializer"); + ce->value = error_mark_node; } } - else if (TREE_CODE (type) == UNION_TYPE - /* If the initializer was empty, use default zero initialization. */ - && tail) + else { - tree field = TYPE_FIELDS (type); - /* Find the first named field. ANSI decided in September 1990 that only named fields count here. */ + tree field = TYPE_FIELDS (type); while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL)) field = TREE_CHAIN (field); + gcc_assert (field); + ce->index = field; + } - /* If this element specifies a field, initialize via that field. */ - if (TREE_PURPOSE (tail) != NULL_TREE) - { - int win = 0; + if (ce->value && ce->value != error_mark_node) + ce->value = digest_init (TREE_TYPE (ce->index), ce->value); - if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL) - /* Handle the case of a call by build_c_cast. */ - field = TREE_PURPOSE (tail), win = 1; - else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE) - error ("index value instead of field name in union initializer"); - else - { - tree temp; - for (temp = TYPE_FIELDS (type); - temp; - temp = TREE_CHAIN (temp)) - if (DECL_NAME (temp) == TREE_PURPOSE (tail)) - break; - if (temp) - field = temp, win = 1; - else - error ("no field `%D' in union being initialized", - TREE_PURPOSE (tail)); - } - if (!win) - TREE_VALUE (tail) = error_mark_node; - } - else if (field == 0) - { - error ("union `%T' with no named members cannot be initialized", - type); - TREE_VALUE (tail) = error_mark_node; - } + return picflag_from_initializer (ce->value); +} - if (TREE_VALUE (tail) != 0) - { - tree tail1 = tail; +/* Process INIT, a constructor for a variable of aggregate type TYPE. The + constructor is a brace-enclosed initializer, and will be modified in-place. - next1 = digest_init (TREE_TYPE (field), - TREE_VALUE (tail), &tail1); - if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST) - abort (); - tail = tail1; - } - else - { - next1 = error_mark_node; - tail = TREE_CHAIN (tail); - } + Each element is converted to the right type through digest_init, and + missing initializers are added following the language rules (zero-padding, + etc.). - if (next1 == error_mark_node) - erroneous = 1; - else if (!TREE_CONSTANT (next1)) - allconstant = 0; - else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0) - allsimple = 0; - members = tree_cons (field, next1, members); - } + After the execution, the initializer will have TREE_CONSTANT if all elts are + constant, and TREE_STATIC set if, in addition, all elts are simple enough + constants that the assembler and linker can compute them. + + The function returns the initializer itself, or error_mark_node in case + of error. */ + +static tree +process_init_constructor (tree type, tree init) +{ + int flags; + + gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init)); - /* If arguments were specified as a list, just remove the ones we used. */ - if (elts) - *elts = tail; - /* If arguments were specified as a constructor, - complain unless we used all the elements of the constructor. */ - else if (tail) - pedwarn ("excess elements in aggregate initializer"); + if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) + flags = process_init_constructor_array (type, init); + else if (TREE_CODE (type) == RECORD_TYPE) + flags = process_init_constructor_record (type, init); + else if (TREE_CODE (type) == UNION_TYPE) + flags = process_init_constructor_union (type, init); + else + gcc_unreachable (); - if (erroneous) + if (flags & PICFLAG_ERRONEOUS) return error_mark_node; - result = build_constructor (type, nreverse (members)); + TREE_TYPE (init) = type; if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE) - complete_array_type (type, result, /*do_default=*/0); - if (init) - TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init); - if (allconstant) TREE_CONSTANT (result) = 1; - if (allconstant && allsimple) TREE_STATIC (result) = 1; - return result; + cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0); + if (!(flags & PICFLAG_NOT_ALL_CONSTANT)) + { + TREE_CONSTANT (init) = 1; + TREE_INVARIANT (init) = 1; + if (!(flags & PICFLAG_NOT_ALL_SIMPLE)) + TREE_STATIC (init) = 1; + } + return init; } /* Given a structure or union value DATUM, construct and return @@ -1082,16 +1154,11 @@ build_x_arrow (tree expr) expr = build_non_dependent_expr (expr); } - if (TREE_CODE (type) == REFERENCE_TYPE) - { - expr = convert_from_reference (expr); - type = TREE_TYPE (expr); - } - if (IS_AGGR_TYPE (type)) { while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr, - NULL_TREE, NULL_TREE))) + NULL_TREE, NULL_TREE, + /*overloaded_p=*/NULL))) { if (expr == error_mark_node) return error_mark_node; @@ -1107,11 +1174,11 @@ build_x_arrow (tree expr) types_memoized); } last_rval = expr; - } + } if (last_rval == NULL_TREE) { - error ("base operand of `->' has non-pointer type `%T'", type); + error ("base operand of %<->%> has non-pointer type %qT", type); return error_mark_node; } @@ -1135,9 +1202,9 @@ build_x_arrow (tree expr) } if (types_memoized) - error ("result of `operator->()' yields non-pointer result"); + error ("result of %()%> yields non-pointer result"); else - error ("base operand of `->' is not a pointer"); + error ("base operand of %<->%> is not a pointer"); return error_mark_node; } @@ -1151,39 +1218,53 @@ build_m_component_ref (tree datum, tree component) tree objtype; tree type; tree binfo; + tree ctype; - datum = decay_conversion (datum); - - if (datum == error_mark_node || component == error_mark_node) + if (error_operand_p (datum) || error_operand_p (component)) return error_mark_node; ptrmem_type = TREE_TYPE (component); if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type)) { - error ("`%E' cannot be used as a member pointer, since it is of type `%T'", + error ("%qE cannot be used as a member pointer, since it is of " + "type %qT", component, ptrmem_type); return error_mark_node; } - - objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); + + objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); if (! IS_AGGR_TYPE (objtype)) { - error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'", - component, datum, objtype); + error ("cannot apply member pointer %qE to %qE, which is of " + "non-class type %qT", + component, datum, objtype); return error_mark_node; } type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type); - binfo = lookup_base (objtype, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type), - ba_check, NULL); - if (!binfo) + ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type)); + + if (!COMPLETE_TYPE_P (ctype)) { - error ("member type `%T::' incompatible with object type `%T'", - type, objtype); - return error_mark_node; + if (!same_type_p (ctype, objtype)) + goto mismatch; + binfo = NULL; + } + else + { + binfo = lookup_base (objtype, ctype, ba_check, NULL); + + if (!binfo) + { + mismatch: + error ("pointer to member type %qT incompatible with object " + "type %qT", + type, objtype); + return error_mark_node; + } + else if (binfo == error_mark_node) + return error_mark_node; } - else if (binfo == error_mark_node) - return error_mark_node; if (TYPE_PTRMEM_P (ptrmem_type)) { @@ -1192,18 +1273,23 @@ build_m_component_ref (tree datum, tree component) things are not as complex as they are for references to non-static data members. */ type = cp_build_qualified_type (type, - (cp_type_quals (type) + (cp_type_quals (type) | cp_type_quals (TREE_TYPE (datum)))); + + datum = build_address (datum); + + /* Convert object to the correct base. */ + if (binfo) + datum = build_base_path (PLUS_EXPR, datum, binfo, 1); + /* Build an expression for "object + offset" where offset is the value stored in the pointer-to-data-member. */ - datum = build (PLUS_EXPR, build_pointer_type (type), - build_base_path (PLUS_EXPR, build_address (datum), - binfo, 1), - build_nop (ptrdiff_type_node, component)); + datum = build2 (PLUS_EXPR, build_pointer_type (type), + datum, build_nop (ptrdiff_type_node, component)); return build_indirect_ref (datum, 0); } else - return build (OFFSET_REF, type, datum, component); + return build2 (OFFSET_REF, type, datum, component); } /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ @@ -1233,20 +1319,19 @@ build_functional_cast (tree exp, tree parms) if (! IS_AGGR_TYPE (type)) { - /* This must build a C cast. */ if (parms == NULL_TREE) - parms = integer_zero_node; - else - parms = build_x_compound_expr_from_list (parms, "functional cast"); + return cp_convert (type, integer_zero_node); + /* This must build a C cast. */ + parms = build_x_compound_expr_from_list (parms, "functional cast"); return build_c_cast (type, parms); } /* Prepare to evaluate as a call to a constructor. If this expression is actually used, for example, - + return X (arg1, arg2, ...); - + then the slot being initialized will be filled in. */ if (!complete_type_or_else (type, NULL_TREE)) @@ -1257,17 +1342,17 @@ build_functional_cast (tree exp, tree parms) if (parms && TREE_CHAIN (parms) == NULL_TREE) return build_c_cast (type, TREE_VALUE (parms)); - /* We need to zero-initialize POD types. Let's do that for everything - that doesn't need a constructor. */ - if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type) + /* We need to zero-initialize POD types. */ + if (parms == NULL_TREE + && !CLASSTYPE_NON_POD_P (type) && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) { - exp = build_constructor (type, NULL_TREE); + exp = build_constructor (type, NULL); return get_target_expr (exp); } exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms, - TYPE_BINFO (type), LOOKUP_NORMAL); + type, LOOKUP_NORMAL); if (exp == error_mark_node) return error_mark_node; @@ -1288,12 +1373,12 @@ add_exception_specifier (tree list, tree spec, int complain) tree core = spec; bool is_ptr; int diag_type = -1; /* none */ - + if (spec == error_mark_node) return list; - - my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317); - + + gcc_assert (spec && (!list || TREE_VALUE (list))); + /* [except.spec] 1, type in an exception specifier shall not be incomplete, or pointer or ref to incomplete other than pointer to cv void. */ @@ -1312,9 +1397,9 @@ add_exception_specifier (tree list, tree spec, int complain) { ok = true; /* 15.4/1 says that types in an exception specifier must be complete, - but it seems more reasonable to only require this on definitions - and calls. So just give a pedwarn at this point; we will give an - error later if we hit one of those two cases. */ + but it seems more reasonable to only require this on definitions + and calls. So just give a pedwarn at this point; we will give an + error later if we hit one of those two cases. */ if (!COMPLETE_TYPE_P (complete_type (core))) diag_type = 2; /* pedwarn */ } @@ -1322,16 +1407,16 @@ add_exception_specifier (tree list, tree spec, int complain) if (ok) { tree probe; - + for (probe = list; probe; probe = TREE_CHAIN (probe)) - if (same_type_p (TREE_VALUE (probe), spec)) - break; + if (same_type_p (TREE_VALUE (probe), spec)) + break; if (!probe) list = tree_cons (NULL_TREE, spec, list); } else diag_type = 0; /* error */ - + if (diag_type >= 0 && complain) cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); @@ -1353,22 +1438,22 @@ merge_exception_specifiers (tree list, tree add) else { tree orig_list = list; - + for (; add; add = TREE_CHAIN (add)) - { - tree spec = TREE_VALUE (add); - tree probe; - - for (probe = orig_list; probe; probe = TREE_CHAIN (probe)) - if (same_type_p (TREE_VALUE (probe), spec)) - break; - if (!probe) - { - spec = build_tree_list (NULL_TREE, spec); - TREE_CHAIN (spec) = list; - list = spec; - } - } + { + tree spec = TREE_VALUE (add); + tree probe; + + for (probe = orig_list; probe; probe = TREE_CHAIN (probe)) + if (same_type_p (TREE_VALUE (probe), spec)) + break; + if (!probe) + { + spec = build_tree_list (NULL_TREE, spec); + TREE_CHAIN (spec) = list; + list = spec; + } + } } return list; } @@ -1394,11 +1479,14 @@ require_complete_eh_spec_types (tree fntype, tree decl) { if (decl) error - ("call to function `%D' which throws incomplete type `%#T'", + ("call to function %qD which throws incomplete type %q#T", decl, type); else - error ("call to function which throws incomplete type `%#T'", + error ("call to function which throws incomplete type %q#T", decl); } } } + + +#include "gt-cp-typeck2.h"