1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009
5 Free Software Foundation, Inc.
6 Hacked by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* This file is part of the C++ front end.
26 It contains routines to build C++ expressions given their operands,
27 including computing the types of the result, C and C++ specific error
28 checks, and some optimization. */
32 #include "coretypes.h"
39 #include "diagnostic.h"
43 process_init_constructor (tree type, tree init);
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
50 error_not_base_type (tree basetype, tree type)
52 if (TREE_CODE (basetype) == FUNCTION_DECL)
53 basetype = DECL_CONTEXT (basetype);
54 error ("type %qT is not a base type for type %qT", basetype, type);
55 return error_mark_node;
59 binfo_or_else (tree base, tree type)
61 tree binfo = lookup_base (type, base, ba_unique, NULL);
63 if (binfo == error_mark_node)
66 error_not_base_type (base, type);
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. */
74 readonly_error (tree arg, const char* string)
78 if (TREE_CODE (arg) == COMPONENT_REF)
80 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
81 fmt = "%s of data-member %qD in read-only structure";
83 fmt = "%s of read-only data-member %qD";
84 error (fmt, string, TREE_OPERAND (arg, 1));
86 else if (TREE_CODE (arg) == VAR_DECL)
88 if (DECL_LANG_SPECIFIC (arg)
89 && DECL_IN_AGGR_P (arg)
90 && !TREE_STATIC (arg))
91 fmt = "%s of constant field %qD";
93 fmt = "%s of read-only variable %qD";
94 error (fmt, string, arg);
96 else if (TREE_CODE (arg) == PARM_DECL)
97 error ("%s of read-only parameter %qD", string, arg);
98 else if (TREE_CODE (arg) == INDIRECT_REF
99 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
100 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
101 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
102 error ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
103 else if (TREE_CODE (arg) == RESULT_DECL)
104 error ("%s of read-only named return value %qD", string, arg);
105 else if (TREE_CODE (arg) == FUNCTION_DECL)
106 error ("%s of function %qD", string, arg);
108 error ("%s of read-only location %qE", string, arg);
112 /* Structure that holds information about declarations whose type was
113 incomplete and we could not check whether it was abstract or not. */
115 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
116 /* Declaration which we are checking for abstractness. It is either
117 a DECL node, or an IDENTIFIER_NODE if we do not have a full
118 declaration available. */
121 /* Type which will be checked for abstractness. */
124 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
125 because DECLs already carry locus information. */
128 /* Link to the next element in list. */
129 struct pending_abstract_type* next;
133 /* Compute the hash value of the node VAL. This function is used by the
134 hash table abstract_pending_vars. */
137 pat_calc_hash (const void* val)
139 const struct pending_abstract_type *pat =
140 (const struct pending_abstract_type *) val;
141 return (hashval_t) TYPE_UID (pat->type);
145 /* Compare node VAL1 with the type VAL2. This function is used by the
146 hash table abstract_pending_vars. */
149 pat_compare (const void* val1, const void* val2)
151 const struct pending_abstract_type *const pat1 =
152 (const struct pending_abstract_type *) val1;
153 const_tree const type2 = (const_tree)val2;
155 return (pat1->type == type2);
158 /* Hash table that maintains pending_abstract_type nodes, for which we still
159 need to check for type abstractness. The key of the table is the type
160 of the declaration. */
161 static GTY ((param_is (struct pending_abstract_type)))
162 htab_t abstract_pending_vars = NULL;
165 /* This function is called after TYPE is completed, and will check if there
166 are pending declarations for which we still need to verify the abstractness
167 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
168 turned out to be incomplete. */
171 complete_type_check_abstract (tree type)
174 struct pending_abstract_type *pat;
175 location_t cur_loc = input_location;
177 gcc_assert (COMPLETE_TYPE_P (type));
179 if (!abstract_pending_vars)
182 /* Retrieve the list of pending declarations for this type. */
183 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
184 (hashval_t)TYPE_UID (type), NO_INSERT);
187 pat = (struct pending_abstract_type*)*slot;
190 /* If the type is not abstract, do not do anything. */
191 if (CLASSTYPE_PURE_VIRTUALS (type))
193 struct pending_abstract_type *prev = 0, *next;
195 /* Reverse the list to emit the errors in top-down order. */
196 for (; pat; pat = next)
204 /* Go through the list, and call abstract_virtuals_error for each
205 element: it will issue a diagnostic if the type is abstract. */
208 gcc_assert (type == pat->type);
210 /* Tweak input_location so that the diagnostic appears at the correct
211 location. Notice that this is only needed if the decl is an
213 input_location = pat->locus;
214 abstract_virtuals_error (pat->decl, pat->type);
219 htab_clear_slot (abstract_pending_vars, slot);
221 input_location = cur_loc;
225 /* If TYPE has abstract virtual functions, issue an error about trying
226 to create an object of that type. DECL is the object declared, or
227 NULL_TREE if the declaration is unavailable. Returns 1 if an error
228 occurred; zero if all was well. */
231 abstract_virtuals_error (tree decl, tree type)
235 /* This function applies only to classes. Any other entity can never
237 if (!CLASS_TYPE_P (type))
239 type = TYPE_MAIN_VARIANT (type);
241 /* If the type is incomplete, we register it within a hash table,
242 so that we can check again once it is completed. This makes sense
243 only for objects for which we have a declaration or at least a
245 if (!COMPLETE_TYPE_P (type))
248 struct pending_abstract_type *pat;
250 gcc_assert (!decl || DECL_P (decl)
251 || TREE_CODE (decl) == IDENTIFIER_NODE);
253 if (!abstract_pending_vars)
254 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
257 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
258 (hashval_t)TYPE_UID (type), INSERT);
260 pat = GGC_NEW (struct pending_abstract_type);
263 pat->locus = ((decl && DECL_P (decl))
264 ? DECL_SOURCE_LOCATION (decl)
267 pat->next = (struct pending_abstract_type *) *slot;
273 if (!TYPE_SIZE (type))
274 /* TYPE is being defined, and during that time
275 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
278 pure = CLASSTYPE_PURE_VIRTUALS (type);
284 if (TREE_CODE (decl) == RESULT_DECL)
287 if (TREE_CODE (decl) == VAR_DECL)
288 error ("cannot declare variable %q+D to be of abstract "
289 "type %qT", decl, type);
290 else if (TREE_CODE (decl) == PARM_DECL)
291 error ("cannot declare parameter %q+D to be of abstract type %qT",
293 else if (TREE_CODE (decl) == FIELD_DECL)
294 error ("cannot declare field %q+D to be of abstract type %qT",
296 else if (TREE_CODE (decl) == FUNCTION_DECL
297 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
298 error ("invalid abstract return type for member function %q+#D", decl);
299 else if (TREE_CODE (decl) == FUNCTION_DECL)
300 error ("invalid abstract return type for function %q+#D", decl);
301 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
302 /* Here we do not have location information. */
303 error ("invalid abstract type %qT for %qE", type, decl);
305 error ("invalid abstract type for %q+D", decl);
308 error ("cannot allocate an object of abstract type %qT", type);
310 /* Only go through this once. */
311 if (VEC_length (tree, pure))
316 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
317 " because the following virtual functions are pure within %qT:",
320 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
321 inform (input_location, "\t%+#D", fn);
322 /* Now truncate the vector. This leaves it non-null, so we know
323 there are pure virtuals, but empty so we don't list them out
325 VEC_truncate (tree, pure, 0);
328 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
329 " since type %qT has pure virtual functions",
335 /* Print an error message for invalid use of an incomplete type.
336 VALUE is the expression that was used (or 0 if that isn't known)
337 and TYPE is the type that was invalid. DIAG_KIND indicates the
338 type of diagnostic (see diagnostic.def). */
341 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
342 diagnostic_t diag_kind)
346 gcc_assert (diag_kind == DK_WARNING
347 || diag_kind == DK_PEDWARN
348 || diag_kind == DK_ERROR);
350 /* Avoid duplicate error message. */
351 if (TREE_CODE (type) == ERROR_MARK)
354 if (value != 0 && (TREE_CODE (value) == VAR_DECL
355 || TREE_CODE (value) == PARM_DECL
356 || TREE_CODE (value) == FIELD_DECL))
358 emit_diagnostic (diag_kind, input_location, 0,
359 "%q+D has incomplete type", value);
363 /* We must print an error message. Be clever about what it says. */
365 switch (TREE_CODE (type))
371 emit_diagnostic (diag_kind, input_location, 0,
372 "invalid use of incomplete type %q#T", type);
373 if (!TYPE_TEMPLATE_INFO (type))
374 emit_diagnostic (diag_kind, input_location, 0,
375 "forward declaration of %q+#T", type);
377 emit_diagnostic (diag_kind, input_location, 0,
378 "declaration of %q+#T", type);
382 emit_diagnostic (diag_kind, input_location, 0,
383 "invalid use of %qT", type);
387 if (TYPE_DOMAIN (type))
389 type = TREE_TYPE (type);
392 emit_diagnostic (diag_kind, input_location, 0,
393 "invalid use of array with unspecified bounds");
398 emit_diagnostic (diag_kind, input_location, 0,
399 "invalid use of member (did you forget the %<&%> ?)");
402 case TEMPLATE_TYPE_PARM:
404 emit_diagnostic (diag_kind, input_location, 0,
405 "invalid use of %<auto%>");
407 emit_diagnostic (diag_kind, input_location, 0,
408 "invalid use of template type parameter %qT", type);
411 case BOUND_TEMPLATE_TEMPLATE_PARM:
412 emit_diagnostic (diag_kind, input_location, 0,
413 "invalid use of template template parameter %qT",
418 emit_diagnostic (diag_kind, input_location, 0,
419 "invalid use of dependent type %qT", type);
423 if (value && TREE_CODE (value) == COMPONENT_REF)
425 else if (value && TREE_CODE (value) == ADDR_EXPR)
426 emit_diagnostic (diag_kind, input_location, 0,
427 "address of overloaded function with no contextual "
429 else if (value && TREE_CODE (value) == OVERLOAD)
430 emit_diagnostic (diag_kind, input_location, 0,
431 "overloaded function with no contextual type information");
433 emit_diagnostic (diag_kind, input_location, 0,
434 "insufficient contextual information to determine type");
442 /* Backward-compatibility interface to incomplete_type_diagnostic;
443 required by ../tree.c. */
444 #undef cxx_incomplete_type_error
446 cxx_incomplete_type_error (const_tree value, const_tree type)
448 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
452 /* The recursive part of split_nonconstant_init. DEST is an lvalue
453 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
456 split_nonconstant_init_1 (tree dest, tree init)
458 unsigned HOST_WIDE_INT idx;
459 tree field_index, value;
460 tree type = TREE_TYPE (dest);
461 tree inner_type = NULL;
462 bool array_type_p = false;
464 switch (TREE_CODE (type))
467 inner_type = TREE_TYPE (type);
473 case QUAL_UNION_TYPE:
474 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
477 /* The current implementation of this algorithm assumes that
478 the field was set for all the elements. This is usually done
479 by process_init_constructor. */
480 gcc_assert (field_index);
483 inner_type = TREE_TYPE (field_index);
485 if (TREE_CODE (value) == CONSTRUCTOR)
490 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
491 NULL_TREE, NULL_TREE);
493 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
496 split_nonconstant_init_1 (sub, value);
498 else if (!initializer_constant_valid_p (value, inner_type))
503 /* FIXME: Ordered removal is O(1) so the whole function is
504 worst-case quadratic. This could be fixed using an aside
505 bitmap to record which elements must be removed and remove
506 them all at the same time. Or by merging
507 split_non_constant_init into process_init_constructor_array,
508 that is separating constants from non-constants while building
510 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
515 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
516 NULL_TREE, NULL_TREE);
518 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
521 code = build2 (INIT_EXPR, inner_type, sub, value);
522 code = build_stmt (input_location, EXPR_STMT, code);
530 if (!initializer_constant_valid_p (init, type))
533 tree cons = copy_node (init);
534 CONSTRUCTOR_ELTS (init) = NULL;
535 code = build2 (MODIFY_EXPR, type, dest, cons);
536 code = build_stmt (input_location, EXPR_STMT, code);
545 /* The rest of the initializer is now a constant. */
546 TREE_CONSTANT (init) = 1;
549 /* A subroutine of store_init_value. Splits non-constant static
550 initializer INIT into a constant part and generates code to
551 perform the non-constant part of the initialization to DEST.
552 Returns the code for the runtime init. */
555 split_nonconstant_init (tree dest, tree init)
559 if (TREE_CODE (init) == CONSTRUCTOR)
561 code = push_stmt_list ();
562 split_nonconstant_init_1 (dest, init);
563 code = pop_stmt_list (code);
564 DECL_INITIAL (dest) = init;
565 TREE_READONLY (dest) = 0;
568 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
573 /* Perform appropriate conversions on the initial value of a variable,
574 store it in the declaration DECL,
575 and print any error messages that are appropriate.
576 If the init is invalid, store an ERROR_MARK.
578 C++: Note that INIT might be a TREE_LIST, which would mean that it is
579 a base class initializer for some aggregate type, hopefully compatible
580 with DECL. If INIT is a single element, and DECL is an aggregate
581 type, we silently convert INIT into a TREE_LIST, allowing a constructor
584 If INIT is a TREE_LIST and there is no constructor, turn INIT
585 into a CONSTRUCTOR and use standard initialization techniques.
586 Perhaps a warning should be generated?
588 Returns code to be executed if initialization could not be performed
589 for static variable. In that case, caller must emit the code. */
592 store_init_value (tree decl, tree init, int flags)
596 /* If variable's type was invalidly declared, just ignore it. */
598 type = TREE_TYPE (decl);
599 if (TREE_CODE (type) == ERROR_MARK)
602 if (MAYBE_CLASS_TYPE_P (type))
604 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
605 || TREE_CODE (init) == CONSTRUCTOR);
607 if (TREE_CODE (init) == TREE_LIST)
609 error ("constructor syntax used, but no constructor declared "
610 "for type %qT", type);
611 init = build_constructor_from_list (init_list_type_node, nreverse (init));
614 else if (TREE_CODE (init) == TREE_LIST
615 && TREE_TYPE (init) != unknown_type_node)
617 if (TREE_CODE (decl) == RESULT_DECL)
618 init = build_x_compound_expr_from_list (init,
619 "return value initializer");
620 else if (TREE_CODE (init) == TREE_LIST
621 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
623 error ("cannot initialize arrays using this syntax");
627 /* We get here with code like `int a (2);' */
628 init = build_x_compound_expr_from_list (init, "initializer");
631 /* End of special C++ code. */
633 /* Digest the specified initializer into an expression. */
634 value = digest_init_flags (type, init, flags);
635 /* If the initializer is not a constant, fill in DECL_INITIAL with
636 the bits that are constant, and then return an expression that
637 will perform the dynamic initialization. */
638 if (value != error_mark_node
639 && (TREE_SIDE_EFFECTS (value)
640 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
641 return split_nonconstant_init (decl, value);
642 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
643 is an automatic variable, the middle end will turn this into a
644 dynamic initialization later. */
645 DECL_INITIAL (decl) = value;
650 /* Give errors about narrowing conversions within { }. */
653 check_narrowing (tree type, tree init)
655 tree ftype = unlowered_expr_type (init);
658 bool was_decl = false;
663 init = decl_constant_value (init);
666 if (TREE_CODE (type) == INTEGER_TYPE
667 && TREE_CODE (ftype) == REAL_TYPE)
669 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
670 && CP_INTEGRAL_TYPE_P (type))
672 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
673 && (TREE_CODE (init) != INTEGER_CST
674 || !int_fits_type_p (init, type)))
677 else if (TREE_CODE (ftype) == REAL_TYPE
678 && TREE_CODE (type) == REAL_TYPE)
680 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
682 if (TREE_CODE (init) == REAL_CST)
684 /* Issue 703: Loss of precision is OK as long as the value is
685 within the representable range of the new type. */
687 d = TREE_REAL_CST (init);
688 real_convert (&r, TYPE_MODE (type), &d);
696 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
697 && TREE_CODE (type) == REAL_TYPE)
700 if (TREE_CODE (init) == INTEGER_CST)
702 d = real_value_from_int_cst (0, init);
703 if (exact_real_truncate (TYPE_MODE (type), &d))
709 permerror (input_location, "narrowing conversion of %qE from %qT to %qT inside { }",
713 /* Process the initializer INIT for a variable of type TYPE, emitting
714 diagnostics for invalid initializers and converting the initializer as
717 For aggregate types, it assumes that reshape_init has already run, thus the
718 initializer will have the right shape (brace elision has been undone).
720 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
723 digest_init_r (tree type, tree init, bool nested, int flags)
725 enum tree_code code = TREE_CODE (type);
727 if (error_operand_p (init))
728 return error_mark_node;
732 /* We must strip the outermost array type when completing the type,
733 because the its bounds might be incomplete at the moment. */
734 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
735 ? TREE_TYPE (type) : type, NULL_TREE))
736 return error_mark_node;
738 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
739 (g++.old-deja/g++.law/casts2.C). */
740 if (TREE_CODE (init) == NON_LVALUE_EXPR)
741 init = TREE_OPERAND (init, 0);
743 /* Initialization of an array of chars from a string constant. The initializer
744 can be optionally enclosed in braces, but reshape_init has already removed
745 them if they were present. */
746 if (code == ARRAY_TYPE)
748 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
749 if (char_type_p (typ1)
751 && TREE_CODE (init) == STRING_CST)
753 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
755 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
757 if (char_type != char_type_node)
759 error ("char-array initialized from wide string");
760 return error_mark_node;
765 if (char_type == char_type_node)
767 error ("int-array initialized from non-wide string");
768 return error_mark_node;
770 else if (char_type != typ1)
772 error ("int-array initialized from incompatible wide string");
773 return error_mark_node;
777 TREE_TYPE (init) = type;
778 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
780 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
781 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
782 /* In C it is ok to subtract 1 from the length of the string
783 because it's ok to ignore the terminating null char that is
784 counted in the length of the constant, but in C++ this would
786 if (size < TREE_STRING_LENGTH (init))
787 permerror (input_location, "initializer-string for array of chars is too long");
793 /* Handle scalar types (including conversions) and references. */
794 if ((TREE_CODE (type) != COMPLEX_TYPE
795 || BRACE_ENCLOSED_INITIALIZER_P (init))
796 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
800 if (cxx_dialect != cxx98 && nested)
801 check_narrowing (type, init);
802 init = convert_for_initialization (0, type, init, flags,
803 "initialization", NULL_TREE, 0,
804 tf_warning_or_error);
807 /* Skip any conversions since we'll be outputting the underlying
809 while (CONVERT_EXPR_P (*exp)
810 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
811 exp = &TREE_OPERAND (*exp, 0);
813 *exp = cplus_expand_constant (*exp);
818 /* Come here only for aggregates: records, arrays, unions, complex numbers
820 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
821 || TREE_CODE (type) == VECTOR_TYPE
822 || TREE_CODE (type) == RECORD_TYPE
823 || TREE_CODE (type) == UNION_TYPE
824 || TREE_CODE (type) == COMPLEX_TYPE);
826 if (BRACE_ENCLOSED_INITIALIZER_P (init)
827 && !TYPE_NON_AGGREGATE_CLASS (type))
828 return process_init_constructor (type, init);
831 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
833 error ("cannot initialize aggregate of type %qT with "
834 "a compound literal", type);
836 return error_mark_node;
839 if (TREE_CODE (type) == ARRAY_TYPE
840 && TREE_CODE (init) != CONSTRUCTOR)
842 /* Allow the result of build_array_copy. */
843 if (TREE_CODE (init) == TARGET_EXPR
844 && (same_type_ignoring_top_level_qualifiers_p
845 (type, TREE_TYPE (init))))
848 error ("array must be initialized with a brace-enclosed"
850 return error_mark_node;
853 return convert_for_initialization (NULL_TREE, type, init,
855 "initialization", NULL_TREE, 0,
856 tf_warning_or_error);
861 digest_init (tree type, tree init)
863 return digest_init_r (type, init, false, LOOKUP_IMPLICIT);
867 digest_init_flags (tree type, tree init, int flags)
869 return digest_init_r (type, init, false, flags);
872 /* Set of flags used within process_init_constructor to describe the
874 #define PICFLAG_ERRONEOUS 1
875 #define PICFLAG_NOT_ALL_CONSTANT 2
876 #define PICFLAG_NOT_ALL_SIMPLE 4
878 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
882 picflag_from_initializer (tree init)
884 if (init == error_mark_node)
885 return PICFLAG_ERRONEOUS;
886 else if (!TREE_CONSTANT (init))
887 return PICFLAG_NOT_ALL_CONSTANT;
888 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
889 return PICFLAG_NOT_ALL_SIMPLE;
893 /* Subroutine of process_init_constructor, which will process an initializer
894 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
895 which describe the initializers. */
898 process_init_constructor_array (tree type, tree init)
900 unsigned HOST_WIDE_INT i, len = 0;
902 bool unbounded = false;
904 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
906 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
907 || TREE_CODE (type) == VECTOR_TYPE);
909 if (TREE_CODE (type) == ARRAY_TYPE)
911 tree domain = TYPE_DOMAIN (type);
913 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
914 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
917 unbounded = true; /* Take as many as there are. */
920 /* Vectors are like simple fixed-size arrays. */
921 len = TYPE_VECTOR_SUBPARTS (type);
923 /* There must not be more initializers than needed. */
924 if (!unbounded && VEC_length (constructor_elt, v) > len)
925 error ("too many initializers for %qT", type);
927 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
931 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
932 if (compare_tree_int (ce->index, i) != 0)
934 ce->value = error_mark_node;
935 sorry ("non-trivial designated initializers not supported");
939 ce->index = size_int (i);
940 gcc_assert (ce->value);
941 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true, LOOKUP_IMPLICIT);
943 if (ce->value != error_mark_node)
944 gcc_assert (same_type_ignoring_top_level_qualifiers_p
945 (TREE_TYPE (type), TREE_TYPE (ce->value)));
947 flags |= picflag_from_initializer (ce->value);
950 /* No more initializers. If the array is unbounded, we are done. Otherwise,
951 we must add initializers ourselves. */
957 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
959 /* If this type needs constructors run for default-initialization,
960 we can't rely on the back end to do it for us, so build up
961 TARGET_EXPRs. If the type in question is a class, just build
962 one up; if it's an array, recurse. */
963 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
964 next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
965 tf_warning_or_error);
967 next = build_constructor (init_list_type_node, NULL);
968 next = digest_init (TREE_TYPE (type), next);
970 else if (!zero_init_p (TREE_TYPE (type)))
971 next = build_zero_init (TREE_TYPE (type),
973 /*static_storage_p=*/false);
975 /* The default zero-initialization is fine for us; don't
976 add anything to the CONSTRUCTOR. */
979 flags |= picflag_from_initializer (next);
980 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
983 CONSTRUCTOR_ELTS (init) = v;
987 /* Subroutine of process_init_constructor, which will process an initializer
988 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
992 process_init_constructor_record (tree type, tree init)
994 VEC(constructor_elt,gc) *v = NULL;
997 unsigned HOST_WIDE_INT idx = 0;
999 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1000 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1001 gcc_assert (!TYPE_BINFO (type)
1002 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1003 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1005 /* Generally, we will always have an index for each initializer (which is
1006 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1007 reshape_init. So we need to handle both cases. */
1008 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1013 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1015 flags |= picflag_from_initializer (integer_zero_node);
1016 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1020 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1023 /* If this is a bitfield, first convert to the declared type. */
1024 type = TREE_TYPE (field);
1025 if (DECL_BIT_FIELD_TYPE (field))
1026 type = DECL_BIT_FIELD_TYPE (field);
1028 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1030 constructor_elt *ce = VEC_index (constructor_elt,
1031 CONSTRUCTOR_ELTS (init), idx);
1034 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1035 latter case can happen in templates where lookup has to be
1037 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1038 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1039 if (ce->index != field
1040 && ce->index != DECL_NAME (field))
1042 ce->value = error_mark_node;
1043 sorry ("non-trivial designated initializers not supported");
1047 gcc_assert (ce->value);
1048 next = digest_init_r (type, ce->value, true, LOOKUP_IMPLICIT);
1051 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
1053 /* If this type needs constructors run for
1054 default-initialization, we can't rely on the back end to do it
1055 for us, so build up TARGET_EXPRs. If the type in question is
1056 a class, just build one up; if it's an array, recurse. */
1057 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1058 next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1059 tf_warning_or_error);
1061 next = build_constructor (init_list_type_node, NULL);
1063 next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1065 /* Warn when some struct elements are implicitly initialized. */
1066 warning (OPT_Wmissing_field_initializers,
1067 "missing initializer for member %qD", field);
1071 if (TREE_READONLY (field))
1072 error ("uninitialized const member %qD", field);
1073 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1074 error ("member %qD with uninitialized const fields", field);
1075 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1076 error ("member %qD is uninitialized reference", field);
1078 /* Warn when some struct elements are implicitly initialized
1080 warning (OPT_Wmissing_field_initializers,
1081 "missing initializer for member %qD", field);
1083 if (!zero_init_p (TREE_TYPE (field)))
1084 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1085 /*static_storage_p=*/false);
1087 /* The default zero-initialization is fine for us; don't
1088 add anything to the CONSTRUCTOR. */
1092 /* If this is a bitfield, now convert to the lowered type. */
1093 if (type != TREE_TYPE (field))
1094 next = cp_convert_and_check (TREE_TYPE (field), next);
1095 flags |= picflag_from_initializer (next);
1096 CONSTRUCTOR_APPEND_ELT (v, field, next);
1099 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1100 error ("too many initializers for %qT", type);
1102 CONSTRUCTOR_ELTS (init) = v;
1106 /* Subroutine of process_init_constructor, which will process a single
1107 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1108 which describe the initializer. */
1111 process_init_constructor_union (tree type, tree init)
1113 constructor_elt *ce;
1116 /* If the initializer was empty, use default zero initialization. */
1117 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1120 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1123 error ("too many initializers for %qT", type);
1124 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1127 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1129 /* If this element specifies a field, initialize via that field. */
1132 if (TREE_CODE (ce->index) == FIELD_DECL)
1134 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1136 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1137 tree name = ce->index;
1139 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1140 if (DECL_NAME (field) == name)
1144 error ("no field %qD found in union being initialized", field);
1145 ce->value = error_mark_node;
1151 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1152 || TREE_CODE (ce->index) == RANGE_EXPR);
1153 error ("index value instead of field name in union initializer");
1154 ce->value = error_mark_node;
1159 /* Find the first named field. ANSI decided in September 1990
1160 that only named fields count here. */
1161 tree field = TYPE_FIELDS (type);
1162 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1163 field = TREE_CHAIN (field);
1164 if (field == NULL_TREE)
1166 error ("too many initializers for %qT", type);
1167 ce->value = error_mark_node;
1172 if (ce->value && ce->value != error_mark_node)
1173 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1175 return picflag_from_initializer (ce->value);
1178 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1179 constructor is a brace-enclosed initializer, and will be modified in-place.
1181 Each element is converted to the right type through digest_init, and
1182 missing initializers are added following the language rules (zero-padding,
1185 After the execution, the initializer will have TREE_CONSTANT if all elts are
1186 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1187 constants that the assembler and linker can compute them.
1189 The function returns the initializer itself, or error_mark_node in case
1193 process_init_constructor (tree type, tree init)
1197 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1199 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1200 flags = process_init_constructor_array (type, init);
1201 else if (TREE_CODE (type) == RECORD_TYPE)
1202 flags = process_init_constructor_record (type, init);
1203 else if (TREE_CODE (type) == UNION_TYPE)
1204 flags = process_init_constructor_union (type, init);
1208 if (flags & PICFLAG_ERRONEOUS)
1209 return error_mark_node;
1211 TREE_TYPE (init) = type;
1212 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1213 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1214 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1216 TREE_CONSTANT (init) = 1;
1217 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1218 TREE_STATIC (init) = 1;
1223 /* Given a structure or union value DATUM, construct and return
1224 the structure or union component which results from narrowing
1225 that value to the base specified in BASETYPE. For example, given the
1228 class L { int ii; };
1229 class A : L { ... };
1230 class B : L { ... };
1231 class C : A, B { ... };
1239 x.A::ii refers to the ii member of the L part of
1240 the A part of the C object named by X. In this case,
1241 DATUM would be x, and BASETYPE would be A.
1243 I used to think that this was nonconformant, that the standard specified
1244 that first we look up ii in A, then convert x to an L& and pull out the
1245 ii part. But in fact, it does say that we convert x to an A&; A here
1246 is known as the "naming class". (jason 2000-12-19)
1248 BINFO_P points to a variable initialized either to NULL_TREE or to the
1249 binfo for the specific base subobject we want to convert to. */
1252 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1256 if (datum == error_mark_node)
1257 return error_mark_node;
1261 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1263 if (!binfo || binfo == error_mark_node)
1265 *binfo_p = NULL_TREE;
1267 error_not_base_type (basetype, TREE_TYPE (datum));
1268 return error_mark_node;
1272 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1275 /* Build a reference to an object specified by the C++ `->' operator.
1276 Usually this just involves dereferencing the object, but if the
1277 `->' operator is overloaded, then such overloads must be
1278 performed until an object which does not have the `->' operator
1279 overloaded is found. An error is reported when circular pointer
1280 delegation is detected. */
1283 build_x_arrow (tree expr)
1285 tree orig_expr = expr;
1286 tree types_memoized = NULL_TREE;
1287 tree type = TREE_TYPE (expr);
1288 tree last_rval = NULL_TREE;
1290 if (type == error_mark_node)
1291 return error_mark_node;
1293 if (processing_template_decl)
1295 if (type_dependent_expression_p (expr))
1296 return build_min_nt (ARROW_EXPR, expr);
1297 expr = build_non_dependent_expr (expr);
1300 if (MAYBE_CLASS_TYPE_P (type))
1302 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1303 NULL_TREE, NULL_TREE,
1304 /*overloaded_p=*/NULL,
1305 tf_warning_or_error)))
1307 if (expr == error_mark_node)
1308 return error_mark_node;
1310 if (value_member (TREE_TYPE (expr), types_memoized))
1312 error ("circular pointer delegation detected");
1313 return error_mark_node;
1317 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1323 if (last_rval == NULL_TREE)
1325 error ("base operand of %<->%> has non-pointer type %qT", type);
1326 return error_mark_node;
1329 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1330 last_rval = convert_from_reference (last_rval);
1333 last_rval = decay_conversion (expr);
1335 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1337 if (processing_template_decl)
1339 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1340 /* It will be dereferenced. */
1341 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1345 return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error);
1349 error ("result of %<operator->()%> yields non-pointer result");
1351 error ("base operand of %<->%> is not a pointer");
1352 return error_mark_node;
1355 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1356 already been checked out to be of aggregate type. */
1359 build_m_component_ref (tree datum, tree component)
1367 if (error_operand_p (datum) || error_operand_p (component))
1368 return error_mark_node;
1370 ptrmem_type = TREE_TYPE (component);
1371 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1373 error ("%qE cannot be used as a member pointer, since it is of "
1375 component, ptrmem_type);
1376 return error_mark_node;
1379 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1380 if (! MAYBE_CLASS_TYPE_P (objtype))
1382 error ("cannot apply member pointer %qE to %qE, which is of "
1383 "non-class type %qT",
1384 component, datum, objtype);
1385 return error_mark_node;
1388 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1389 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1391 if (!COMPLETE_TYPE_P (ctype))
1393 if (!same_type_p (ctype, objtype))
1399 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1404 error ("pointer to member type %qT incompatible with object "
1407 return error_mark_node;
1409 else if (binfo == error_mark_node)
1410 return error_mark_node;
1413 if (TYPE_PTRMEM_P (ptrmem_type))
1417 /* Compute the type of the field, as described in [expr.ref].
1418 There's no such thing as a mutable pointer-to-member, so
1419 things are not as complex as they are for references to
1420 non-static data members. */
1421 type = cp_build_qualified_type (type,
1422 (cp_type_quals (type)
1423 | cp_type_quals (TREE_TYPE (datum))));
1425 datum = build_address (datum);
1427 /* Convert object to the correct base. */
1429 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1431 /* Build an expression for "object + offset" where offset is the
1432 value stored in the pointer-to-data-member. */
1433 ptype = build_pointer_type (type);
1434 datum = build2 (POINTER_PLUS_EXPR, ptype,
1435 fold_convert (ptype, datum),
1436 build_nop (sizetype, component));
1437 return cp_build_indirect_ref (datum, 0, tf_warning_or_error);
1440 return build2 (OFFSET_REF, type, datum, component);
1443 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1446 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1448 /* This is either a call to a constructor,
1449 or a C cast in C++'s `functional' notation. */
1451 /* The type to which we are casting. */
1453 VEC(tree,gc) *parmvec;
1455 if (exp == error_mark_node || parms == error_mark_node)
1456 return error_mark_node;
1458 if (TREE_CODE (exp) == TYPE_DECL)
1459 type = TREE_TYPE (exp);
1463 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1465 error ("invalid value-initialization of reference types");
1466 return error_mark_node;
1469 if (processing_template_decl)
1471 tree t = build_min (CAST_EXPR, type, parms);
1472 /* We don't know if it will or will not have side effects. */
1473 TREE_SIDE_EFFECTS (t) = 1;
1477 if (! MAYBE_CLASS_TYPE_P (type))
1479 if (parms == NULL_TREE)
1480 return cp_convert (type, integer_zero_node);
1482 /* This must build a C cast. */
1483 parms = build_x_compound_expr_from_list (parms, "functional cast");
1484 return cp_build_c_cast (type, parms, complain);
1487 /* Prepare to evaluate as a call to a constructor. If this expression
1488 is actually used, for example,
1490 return X (arg1, arg2, ...);
1492 then the slot being initialized will be filled in. */
1494 if (!complete_type_or_else (type, NULL_TREE))
1495 return error_mark_node;
1496 if (abstract_virtuals_error (NULL_TREE, type))
1497 return error_mark_node;
1501 If the expression list is a single-expression, the type
1502 conversion is equivalent (in definedness, and if defined in
1503 meaning) to the corresponding cast expression. */
1504 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1505 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1509 The expression T(), where T is a simple-type-specifier for a
1510 non-array complete object type or the (possibly cv-qualified)
1511 void type, creates an rvalue of the specified type, which is
1512 value-initialized. */
1514 if (parms == NULL_TREE
1515 /* If there's a user-defined constructor, value-initialization is
1516 just calling the constructor, so fall through. */
1517 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1519 exp = build_value_init (type);
1520 return get_target_expr (exp);
1523 /* Call the constructor. */
1524 parmvec = make_tree_vector ();
1525 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1526 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1527 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1528 &parmvec, type, LOOKUP_NORMAL, complain);
1529 release_tree_vector (parmvec);
1531 if (exp == error_mark_node)
1532 return error_mark_node;
1534 return build_cplus_new (type, exp);
1538 /* Add new exception specifier SPEC, to the LIST we currently have.
1539 If it's already in LIST then do nothing.
1540 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1541 know what we're doing. */
1544 add_exception_specifier (tree list, tree spec, int complain)
1549 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1551 if (spec == error_mark_node)
1554 gcc_assert (spec && (!list || TREE_VALUE (list)));
1556 /* [except.spec] 1, type in an exception specifier shall not be
1557 incomplete, or pointer or ref to incomplete other than pointer
1559 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1560 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1561 core = TREE_TYPE (core);
1564 else if (VOID_TYPE_P (core))
1566 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1568 else if (processing_template_decl)
1573 /* 15.4/1 says that types in an exception specifier must be complete,
1574 but it seems more reasonable to only require this on definitions
1575 and calls. So just give a pedwarn at this point; we will give an
1576 error later if we hit one of those two cases. */
1577 if (!COMPLETE_TYPE_P (complete_type (core)))
1578 diag_type = DK_PEDWARN; /* pedwarn */
1585 for (probe = list; probe; probe = TREE_CHAIN (probe))
1586 if (same_type_p (TREE_VALUE (probe), spec))
1589 list = tree_cons (NULL_TREE, spec, list);
1592 diag_type = DK_ERROR; /* error */
1594 if (diag_type != DK_UNSPECIFIED && complain)
1595 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1600 /* Combine the two exceptions specifier lists LIST and ADD, and return
1604 merge_exception_specifiers (tree list, tree add)
1608 else if (!TREE_VALUE (list))
1610 else if (!TREE_VALUE (add))
1614 tree orig_list = list;
1616 for (; add; add = TREE_CHAIN (add))
1618 tree spec = TREE_VALUE (add);
1621 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1622 if (same_type_p (TREE_VALUE (probe), spec))
1626 spec = build_tree_list (NULL_TREE, spec);
1627 TREE_CHAIN (spec) = list;
1635 /* Subroutine of build_call. Ensure that each of the types in the
1636 exception specification is complete. Technically, 15.4/1 says that
1637 they need to be complete when we see a declaration of the function,
1638 but we should be able to get away with only requiring this when the
1639 function is defined or called. See also add_exception_specifier. */
1642 require_complete_eh_spec_types (tree fntype, tree decl)
1645 /* Don't complain about calls to op new. */
1646 if (decl && DECL_ARTIFICIAL (decl))
1648 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1649 raises = TREE_CHAIN (raises))
1651 tree type = TREE_VALUE (raises);
1652 if (type && !COMPLETE_TYPE_P (type))
1656 ("call to function %qD which throws incomplete type %q#T",
1659 error ("call to function which throws incomplete type %q#T",
1666 #include "gt-cp-typeck2.h"