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, 2010, 2011
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-core.h"
42 process_init_constructor (tree type, tree init, tsubst_flags_t complain);
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
49 error_not_base_type (tree basetype, tree type)
51 if (TREE_CODE (basetype) == FUNCTION_DECL)
52 basetype = DECL_CONTEXT (basetype);
53 error ("type %qT is not a base type for type %qT", basetype, type);
54 return error_mark_node;
58 binfo_or_else (tree base, tree type)
60 tree binfo = lookup_base (type, base, ba_unique, NULL);
62 if (binfo == error_mark_node)
65 error_not_base_type (base, type);
69 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
70 value may not be changed thereafter. */
73 cxx_readonly_error (tree arg, enum lvalue_use errstring)
76 /* This macro is used to emit diagnostics to ensure that all format
77 strings are complete sentences, visible to gettext and checked at
80 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
101 /* Handle C++-specific things first. */
103 if (TREE_CODE (arg) == VAR_DECL
104 && DECL_LANG_SPECIFIC (arg)
105 && DECL_IN_AGGR_P (arg)
106 && !TREE_STATIC (arg))
107 ERROR_FOR_ASSIGNMENT (G_("assignment of "
108 "constant field %qD"),
109 G_("constant field %qD "
110 "used as %<asm%> output"),
112 "constant field %qD"),
114 "constant field %qD"),
116 else if (TREE_CODE (arg) == INDIRECT_REF
117 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
118 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
119 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
120 ERROR_FOR_ASSIGNMENT (G_("assignment of "
121 "read-only reference %qD"),
122 G_("read-only reference %qD "
123 "used as %<asm%> output"),
125 "read-only reference %qD"),
127 "read-only reference %qD"),
128 TREE_OPERAND (arg, 0));
130 readonly_error (arg, errstring);
134 /* Structure that holds information about declarations whose type was
135 incomplete and we could not check whether it was abstract or not. */
137 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
138 /* Declaration which we are checking for abstractness. It is either
139 a DECL node, or an IDENTIFIER_NODE if we do not have a full
140 declaration available. */
143 /* Type which will be checked for abstractness. */
146 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
147 because DECLs already carry locus information. */
150 /* Link to the next element in list. */
151 struct pending_abstract_type* next;
155 /* Compute the hash value of the node VAL. This function is used by the
156 hash table abstract_pending_vars. */
159 pat_calc_hash (const void* val)
161 const struct pending_abstract_type *pat =
162 (const struct pending_abstract_type *) val;
163 return (hashval_t) TYPE_UID (pat->type);
167 /* Compare node VAL1 with the type VAL2. This function is used by the
168 hash table abstract_pending_vars. */
171 pat_compare (const void* val1, const void* val2)
173 const struct pending_abstract_type *const pat1 =
174 (const struct pending_abstract_type *) val1;
175 const_tree const type2 = (const_tree)val2;
177 return (pat1->type == type2);
180 /* Hash table that maintains pending_abstract_type nodes, for which we still
181 need to check for type abstractness. The key of the table is the type
182 of the declaration. */
183 static GTY ((param_is (struct pending_abstract_type)))
184 htab_t abstract_pending_vars = NULL;
187 /* This function is called after TYPE is completed, and will check if there
188 are pending declarations for which we still need to verify the abstractness
189 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
190 turned out to be incomplete. */
193 complete_type_check_abstract (tree type)
196 struct pending_abstract_type *pat;
197 location_t cur_loc = input_location;
199 gcc_assert (COMPLETE_TYPE_P (type));
201 if (!abstract_pending_vars)
204 /* Retrieve the list of pending declarations for this type. */
205 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
206 (hashval_t)TYPE_UID (type), NO_INSERT);
209 pat = (struct pending_abstract_type*)*slot;
212 /* If the type is not abstract, do not do anything. */
213 if (CLASSTYPE_PURE_VIRTUALS (type))
215 struct pending_abstract_type *prev = 0, *next;
217 /* Reverse the list to emit the errors in top-down order. */
218 for (; pat; pat = next)
226 /* Go through the list, and call abstract_virtuals_error for each
227 element: it will issue a diagnostic if the type is abstract. */
230 gcc_assert (type == pat->type);
232 /* Tweak input_location so that the diagnostic appears at the correct
233 location. Notice that this is only needed if the decl is an
235 input_location = pat->locus;
236 abstract_virtuals_error (pat->decl, pat->type);
241 htab_clear_slot (abstract_pending_vars, slot);
243 input_location = cur_loc;
247 /* If TYPE has abstract virtual functions, issue an error about trying
248 to create an object of that type. DECL is the object declared, or
249 NULL_TREE if the declaration is unavailable. Returns 1 if an error
250 occurred; zero if all was well. */
253 abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain)
257 /* This function applies only to classes. Any other entity can never
259 if (!CLASS_TYPE_P (type))
261 type = TYPE_MAIN_VARIANT (type);
263 /* If the type is incomplete, we register it within a hash table,
264 so that we can check again once it is completed. This makes sense
265 only for objects for which we have a declaration or at least a
267 if (!COMPLETE_TYPE_P (type))
270 struct pending_abstract_type *pat;
272 gcc_assert (!decl || DECL_P (decl)
273 || TREE_CODE (decl) == IDENTIFIER_NODE);
275 if (!abstract_pending_vars)
276 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
279 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
280 (hashval_t)TYPE_UID (type), INSERT);
282 pat = ggc_alloc_pending_abstract_type ();
285 pat->locus = ((decl && DECL_P (decl))
286 ? DECL_SOURCE_LOCATION (decl)
289 pat->next = (struct pending_abstract_type *) *slot;
295 if (!TYPE_SIZE (type))
296 /* TYPE is being defined, and during that time
297 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
300 pure = CLASSTYPE_PURE_VIRTUALS (type);
304 if (!(complain & tf_error))
309 if (TREE_CODE (decl) == VAR_DECL)
310 error ("cannot declare variable %q+D to be of abstract "
311 "type %qT", decl, type);
312 else if (TREE_CODE (decl) == PARM_DECL)
313 error ("cannot declare parameter %q+D to be of abstract type %qT",
315 else if (TREE_CODE (decl) == FIELD_DECL)
316 error ("cannot declare field %q+D to be of abstract type %qT",
318 else if (TREE_CODE (decl) == FUNCTION_DECL
319 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
320 error ("invalid abstract return type for member function %q+#D", decl);
321 else if (TREE_CODE (decl) == FUNCTION_DECL)
322 error ("invalid abstract return type for function %q+#D", decl);
323 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
324 /* Here we do not have location information. */
325 error ("invalid abstract type %qT for %qE", type, decl);
327 error ("invalid abstract type for %q+D", decl);
330 error ("cannot allocate an object of abstract type %qT", type);
332 /* Only go through this once. */
333 if (VEC_length (tree, pure))
338 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
339 " because the following virtual functions are pure within %qT:",
342 FOR_EACH_VEC_ELT (tree, pure, ix, fn)
343 if (! DECL_CLONED_FUNCTION_P (fn)
344 || DECL_COMPLETE_DESTRUCTOR_P (fn))
345 inform (input_location, "\t%+#D", fn);
347 /* Now truncate the vector. This leaves it non-null, so we know
348 there are pure virtuals, but empty so we don't list them out
350 VEC_truncate (tree, pure, 0);
353 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
354 " since type %qT has pure virtual functions",
360 /* Wrapper for the above function in the common case of wanting errors. */
363 abstract_virtuals_error (tree decl, tree type)
365 return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
368 /* Print an error message for invalid use of an incomplete type.
369 VALUE is the expression that was used (or 0 if that isn't known)
370 and TYPE is the type that was invalid. DIAG_KIND indicates the
371 type of diagnostic (see diagnostic.def). */
374 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
375 diagnostic_t diag_kind)
379 gcc_assert (diag_kind == DK_WARNING
380 || diag_kind == DK_PEDWARN
381 || diag_kind == DK_ERROR);
383 /* Avoid duplicate error message. */
384 if (TREE_CODE (type) == ERROR_MARK)
387 if (value != 0 && (TREE_CODE (value) == VAR_DECL
388 || TREE_CODE (value) == PARM_DECL
389 || TREE_CODE (value) == FIELD_DECL))
391 emit_diagnostic (diag_kind, input_location, 0,
392 "%q+D has incomplete type", value);
396 /* We must print an error message. Be clever about what it says. */
398 switch (TREE_CODE (type))
404 emit_diagnostic (diag_kind, input_location, 0,
405 "invalid use of incomplete type %q#T", type);
406 if (!TYPE_TEMPLATE_INFO (type))
407 emit_diagnostic (diag_kind, input_location, 0,
408 "forward declaration of %q+#T", type);
410 emit_diagnostic (diag_kind, input_location, 0,
411 "declaration of %q+#T", type);
415 emit_diagnostic (diag_kind, input_location, 0,
416 "invalid use of %qT", type);
420 if (TYPE_DOMAIN (type))
422 type = TREE_TYPE (type);
425 emit_diagnostic (diag_kind, input_location, 0,
426 "invalid use of array with unspecified bounds");
432 tree member = TREE_OPERAND (value, 1);
433 if (is_overloaded_fn (member))
434 member = get_first_fn (member);
435 if (DECL_FUNCTION_MEMBER_P (member)
436 && ! flag_ms_extensions)
437 emit_diagnostic (diag_kind, input_location, 0,
438 "invalid use of member function "
439 "(did you forget the %<()%> ?)");
441 emit_diagnostic (diag_kind, input_location, 0,
442 "invalid use of member "
443 "(did you forget the %<&%> ?)");
447 case TEMPLATE_TYPE_PARM:
449 emit_diagnostic (diag_kind, input_location, 0,
450 "invalid use of %<auto%>");
452 emit_diagnostic (diag_kind, input_location, 0,
453 "invalid use of template type parameter %qT", type);
456 case BOUND_TEMPLATE_TEMPLATE_PARM:
457 emit_diagnostic (diag_kind, input_location, 0,
458 "invalid use of template template parameter %qT",
463 emit_diagnostic (diag_kind, input_location, 0,
464 "invalid use of dependent type %qT", type);
468 if (type == init_list_type_node)
470 emit_diagnostic (diag_kind, input_location, 0,
471 "invalid use of brace-enclosed initializer list");
474 gcc_assert (type == unknown_type_node);
475 if (value && TREE_CODE (value) == COMPONENT_REF)
477 else if (value && TREE_CODE (value) == ADDR_EXPR)
478 emit_diagnostic (diag_kind, input_location, 0,
479 "address of overloaded function with no contextual "
481 else if (value && TREE_CODE (value) == OVERLOAD)
482 emit_diagnostic (diag_kind, input_location, 0,
483 "overloaded function with no contextual type information");
485 emit_diagnostic (diag_kind, input_location, 0,
486 "insufficient contextual information to determine type");
494 /* Backward-compatibility interface to incomplete_type_diagnostic;
495 required by ../tree.c. */
496 #undef cxx_incomplete_type_error
498 cxx_incomplete_type_error (const_tree value, const_tree type)
500 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
504 /* The recursive part of split_nonconstant_init. DEST is an lvalue
505 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
506 Return true if the whole of the value was initialized by the
507 generated statements. */
510 split_nonconstant_init_1 (tree dest, tree init)
512 unsigned HOST_WIDE_INT idx;
513 tree field_index, value;
514 tree type = TREE_TYPE (dest);
515 tree inner_type = NULL;
516 bool array_type_p = false;
517 bool complete_p = true;
518 HOST_WIDE_INT num_split_elts = 0;
520 switch (TREE_CODE (type))
523 inner_type = TREE_TYPE (type);
529 case QUAL_UNION_TYPE:
530 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
533 /* The current implementation of this algorithm assumes that
534 the field was set for all the elements. This is usually done
535 by process_init_constructor. */
536 gcc_assert (field_index);
539 inner_type = TREE_TYPE (field_index);
541 if (TREE_CODE (value) == CONSTRUCTOR)
546 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
547 NULL_TREE, NULL_TREE);
549 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
552 if (!split_nonconstant_init_1 (sub, value))
556 else if (!initializer_constant_valid_p (value, inner_type))
561 /* FIXME: Ordered removal is O(1) so the whole function is
562 worst-case quadratic. This could be fixed using an aside
563 bitmap to record which elements must be removed and remove
564 them all at the same time. Or by merging
565 split_non_constant_init into process_init_constructor_array,
566 that is separating constants from non-constants while building
568 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
573 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
574 NULL_TREE, NULL_TREE);
576 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
579 code = build2 (INIT_EXPR, inner_type, sub, value);
580 code = build_stmt (input_location, EXPR_STMT, code);
581 code = maybe_cleanup_point_expr_void (code);
583 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type))
585 code = (build_special_member_call
586 (sub, complete_dtor_identifier, NULL, inner_type,
587 LOOKUP_NORMAL, tf_warning_or_error));
588 finish_eh_cleanup (code);
597 if (!initializer_constant_valid_p (init, type))
600 tree cons = copy_node (init);
601 CONSTRUCTOR_ELTS (init) = NULL;
602 code = build2 (MODIFY_EXPR, type, dest, cons);
603 code = build_stmt (input_location, EXPR_STMT, code);
605 num_split_elts += CONSTRUCTOR_NELTS (init);
613 /* The rest of the initializer is now a constant. */
614 TREE_CONSTANT (init) = 1;
615 return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
616 num_split_elts, inner_type);
619 /* A subroutine of store_init_value. Splits non-constant static
620 initializer INIT into a constant part and generates code to
621 perform the non-constant part of the initialization to DEST.
622 Returns the code for the runtime init. */
625 split_nonconstant_init (tree dest, tree init)
629 if (TREE_CODE (init) == CONSTRUCTOR)
631 code = push_stmt_list ();
632 if (split_nonconstant_init_1 (dest, init))
634 code = pop_stmt_list (code);
635 DECL_INITIAL (dest) = init;
636 TREE_READONLY (dest) = 0;
639 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
644 /* Perform appropriate conversions on the initial value of a variable,
645 store it in the declaration DECL,
646 and print any error messages that are appropriate.
647 If the init is invalid, store an ERROR_MARK.
649 C++: Note that INIT might be a TREE_LIST, which would mean that it is
650 a base class initializer for some aggregate type, hopefully compatible
651 with DECL. If INIT is a single element, and DECL is an aggregate
652 type, we silently convert INIT into a TREE_LIST, allowing a constructor
655 If INIT is a TREE_LIST and there is no constructor, turn INIT
656 into a CONSTRUCTOR and use standard initialization techniques.
657 Perhaps a warning should be generated?
659 Returns code to be executed if initialization could not be performed
660 for static variable. In that case, caller must emit the code. */
663 store_init_value (tree decl, tree init, VEC(tree,gc)** cleanups, int flags)
667 /* If variable's type was invalidly declared, just ignore it. */
669 type = TREE_TYPE (decl);
670 if (TREE_CODE (type) == ERROR_MARK)
673 if (MAYBE_CLASS_TYPE_P (type))
675 if (TREE_CODE (init) == TREE_LIST)
677 error ("constructor syntax used, but no constructor declared "
678 "for type %qT", type);
679 init = build_constructor_from_list (init_list_type_node, nreverse (init));
682 else if (TREE_CODE (init) == TREE_LIST
683 && TREE_TYPE (init) != unknown_type_node)
685 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
687 if (TREE_CODE (init) == TREE_LIST
688 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
690 error ("cannot initialize arrays using this syntax");
694 /* We get here with code like `int a (2);' */
695 init = build_x_compound_expr_from_list (init, ELK_INIT,
696 tf_warning_or_error);
699 /* End of special C++ code. */
701 if (flags & LOOKUP_ALREADY_DIGESTED)
704 /* Digest the specified initializer into an expression. */
705 value = digest_init_flags (type, init, flags);
707 value = extend_ref_init_temps (decl, value, cleanups);
709 /* In C++0x constant expression is a semantic, not syntactic, property.
710 In C++98, make sure that what we thought was a constant expression at
711 template definition time is still constant. */
712 if ((cxx_dialect >= cxx0x
713 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
714 && (decl_maybe_constant_var_p (decl)
715 || TREE_STATIC (decl)))
718 value = fold_non_dependent_expr (value);
719 value = maybe_constant_init (value);
720 if (DECL_DECLARED_CONSTEXPR_P (decl))
721 /* Diagnose a non-constant initializer for constexpr. */
722 value = cxx_constant_value (value);
723 const_init = (reduced_constant_expression_p (value)
724 || error_operand_p (value));
725 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
726 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
729 /* If the initializer is not a constant, fill in DECL_INITIAL with
730 the bits that are constant, and then return an expression that
731 will perform the dynamic initialization. */
732 if (value != error_mark_node
733 && (TREE_SIDE_EFFECTS (value)
734 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
736 if (TREE_CODE (type) == ARRAY_TYPE
737 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type)))
738 /* For an array, we only need/want a single cleanup region rather
739 than one per element. */
740 return build_vec_init (decl, NULL_TREE, value, false, 1,
741 tf_warning_or_error);
743 return split_nonconstant_init (decl, value);
745 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
746 is an automatic variable, the middle end will turn this into a
747 dynamic initialization later. */
748 DECL_INITIAL (decl) = value;
753 /* Give errors about narrowing conversions within { }. */
756 check_narrowing (tree type, tree init)
758 tree ftype = unlowered_expr_type (init);
762 if (!warn_narrowing || !ARITHMETIC_TYPE_P (type))
765 if (BRACE_ENCLOSED_INITIALIZER_P (init)
766 && TREE_CODE (type) == COMPLEX_TYPE)
768 tree elttype = TREE_TYPE (type);
769 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value);
770 if (CONSTRUCTOR_NELTS (init) > 1)
771 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value);
775 init = maybe_constant_value (init);
777 if (TREE_CODE (type) == INTEGER_TYPE
778 && TREE_CODE (ftype) == REAL_TYPE)
780 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
781 && CP_INTEGRAL_TYPE_P (type))
783 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
784 TYPE_MAX_VALUE (ftype))
785 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
786 TYPE_MIN_VALUE (type)))
787 && (TREE_CODE (init) != INTEGER_CST
788 || !int_fits_type_p (init, type)))
791 else if (TREE_CODE (ftype) == REAL_TYPE
792 && TREE_CODE (type) == REAL_TYPE)
794 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
796 if (TREE_CODE (init) == REAL_CST)
798 /* Issue 703: Loss of precision is OK as long as the value is
799 within the representable range of the new type. */
801 d = TREE_REAL_CST (init);
802 real_convert (&r, TYPE_MODE (type), &d);
810 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
811 && TREE_CODE (type) == REAL_TYPE)
814 if (TREE_CODE (init) == INTEGER_CST)
816 d = real_value_from_int_cst (0, init);
817 if (exact_real_truncate (TYPE_MODE (type), &d))
824 if (cxx_dialect >= cxx0x)
825 pedwarn (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
826 "narrowing conversion of %qE from %qT to %qT inside { }",
829 warning_at (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
830 "narrowing conversion of %qE from %qT to %qT inside { } "
831 "is ill-formed in C++11", init, ftype, type);
835 /* Process the initializer INIT for a variable of type TYPE, emitting
836 diagnostics for invalid initializers and converting the initializer as
839 For aggregate types, it assumes that reshape_init has already run, thus the
840 initializer will have the right shape (brace elision has been undone).
842 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
845 digest_init_r (tree type, tree init, bool nested, int flags,
846 tsubst_flags_t complain)
848 enum tree_code code = TREE_CODE (type);
850 if (error_operand_p (init))
851 return error_mark_node;
855 /* We must strip the outermost array type when completing the type,
856 because the its bounds might be incomplete at the moment. */
857 if (!complete_type_or_maybe_complain (TREE_CODE (type) == ARRAY_TYPE
858 ? TREE_TYPE (type) : type, NULL_TREE,
860 return error_mark_node;
862 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
863 (g++.old-deja/g++.law/casts2.C). */
864 if (TREE_CODE (init) == NON_LVALUE_EXPR)
865 init = TREE_OPERAND (init, 0);
867 /* Initialization of an array of chars from a string constant. The initializer
868 can be optionally enclosed in braces, but reshape_init has already removed
869 them if they were present. */
870 if (code == ARRAY_TYPE)
872 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
873 if (char_type_p (typ1)
875 && TREE_CODE (init) == STRING_CST)
877 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
879 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
881 if (char_type != char_type_node)
883 if (complain & tf_error)
884 error ("char-array initialized from wide string");
885 return error_mark_node;
890 if (char_type == char_type_node)
892 if (complain & tf_error)
893 error ("int-array initialized from non-wide string");
894 return error_mark_node;
896 else if (char_type != typ1)
898 if (complain & tf_error)
899 error ("int-array initialized from incompatible "
901 return error_mark_node;
905 if (type != TREE_TYPE (init))
907 init = copy_node (init);
908 TREE_TYPE (init) = type;
910 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
912 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
913 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
914 /* In C it is ok to subtract 1 from the length of the string
915 because it's ok to ignore the terminating null char that is
916 counted in the length of the constant, but in C++ this would
918 if (size < TREE_STRING_LENGTH (init))
919 permerror (input_location, "initializer-string for array "
920 "of chars is too long");
926 /* Handle scalar types (including conversions) and references. */
927 if ((TREE_CODE (type) != COMPLEX_TYPE
928 || BRACE_ENCLOSED_INITIALIZER_P (init))
929 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
934 check_narrowing (type, init);
935 init = convert_for_initialization (0, type, init, flags,
936 ICR_INIT, NULL_TREE, 0,
940 /* Skip any conversions since we'll be outputting the underlying
942 while (CONVERT_EXPR_P (*exp)
943 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
944 exp = &TREE_OPERAND (*exp, 0);
946 *exp = cplus_expand_constant (*exp);
951 /* Come here only for aggregates: records, arrays, unions, complex numbers
953 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
954 || TREE_CODE (type) == VECTOR_TYPE
955 || TREE_CODE (type) == RECORD_TYPE
956 || TREE_CODE (type) == UNION_TYPE
957 || TREE_CODE (type) == COMPLEX_TYPE);
959 if (BRACE_ENCLOSED_INITIALIZER_P (init)
960 && !TYPE_NON_AGGREGATE_CLASS (type))
961 return process_init_constructor (type, init, complain);
964 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
966 if (complain & tf_error)
967 error ("cannot initialize aggregate of type %qT with "
968 "a compound literal", type);
970 return error_mark_node;
973 if (TREE_CODE (type) == ARRAY_TYPE
974 && !BRACE_ENCLOSED_INITIALIZER_P (init))
976 /* Allow the result of build_array_copy and of
977 build_value_init_noctor. */
978 if ((TREE_CODE (init) == VEC_INIT_EXPR
979 || TREE_CODE (init) == CONSTRUCTOR)
980 && (same_type_ignoring_top_level_qualifiers_p
981 (type, TREE_TYPE (init))))
984 if (complain & tf_error)
985 error ("array must be initialized with a brace-enclosed"
987 return error_mark_node;
990 return convert_for_initialization (NULL_TREE, type, init,
992 ICR_INIT, NULL_TREE, 0,
998 digest_init (tree type, tree init, tsubst_flags_t complain)
1000 return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain);
1004 digest_init_flags (tree type, tree init, int flags)
1006 return digest_init_r (type, init, false, flags, tf_warning_or_error);
1009 /* Set of flags used within process_init_constructor to describe the
1011 #define PICFLAG_ERRONEOUS 1
1012 #define PICFLAG_NOT_ALL_CONSTANT 2
1013 #define PICFLAG_NOT_ALL_SIMPLE 4
1015 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1019 picflag_from_initializer (tree init)
1021 if (init == error_mark_node)
1022 return PICFLAG_ERRONEOUS;
1023 else if (!TREE_CONSTANT (init))
1024 return PICFLAG_NOT_ALL_CONSTANT;
1025 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
1026 return PICFLAG_NOT_ALL_SIMPLE;
1030 /* Subroutine of process_init_constructor, which will process an initializer
1031 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1032 which describe the initializers. */
1035 process_init_constructor_array (tree type, tree init,
1036 tsubst_flags_t complain)
1038 unsigned HOST_WIDE_INT i, len = 0;
1040 bool unbounded = false;
1041 constructor_elt *ce;
1042 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1044 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1045 || TREE_CODE (type) == VECTOR_TYPE);
1047 if (TREE_CODE (type) == ARRAY_TYPE)
1049 tree domain = TYPE_DOMAIN (type);
1051 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1052 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1055 unbounded = true; /* Take as many as there are. */
1058 /* Vectors are like simple fixed-size arrays. */
1059 len = TYPE_VECTOR_SUBPARTS (type);
1061 /* There must not be more initializers than needed. */
1062 if (!unbounded && VEC_length (constructor_elt, v) > len)
1064 if (complain & tf_error)
1065 error ("too many initializers for %qT", type);
1067 return PICFLAG_ERRONEOUS;
1070 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1074 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1075 if (compare_tree_int (ce->index, i) != 0)
1077 ce->value = error_mark_node;
1078 sorry ("non-trivial designated initializers not supported");
1082 ce->index = size_int (i);
1083 gcc_assert (ce->value);
1084 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true,
1085 LOOKUP_IMPLICIT, complain);
1087 if (ce->value != error_mark_node)
1088 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1089 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1091 flags |= picflag_from_initializer (ce->value);
1094 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1095 we must add initializers ourselves. */
1097 for (; i < len; ++i)
1101 if (type_build_ctor_call (TREE_TYPE (type)))
1103 /* If this type needs constructors run for default-initialization,
1104 we can't rely on the back end to do it for us, so make the
1105 initialization explicit by list-initializing from {}. */
1106 next = build_constructor (init_list_type_node, NULL);
1107 next = digest_init (TREE_TYPE (type), next, complain);
1109 else if (!zero_init_p (TREE_TYPE (type)))
1110 next = build_zero_init (TREE_TYPE (type),
1111 /*nelts=*/NULL_TREE,
1112 /*static_storage_p=*/false);
1114 /* The default zero-initialization is fine for us; don't
1115 add anything to the CONSTRUCTOR. */
1118 flags |= picflag_from_initializer (next);
1119 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1122 CONSTRUCTOR_ELTS (init) = v;
1126 /* Subroutine of process_init_constructor, which will process an initializer
1127 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1128 the initializers. */
1131 process_init_constructor_record (tree type, tree init,
1132 tsubst_flags_t complain)
1134 VEC(constructor_elt,gc) *v = NULL;
1137 unsigned HOST_WIDE_INT idx = 0;
1139 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1140 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1141 gcc_assert (!TYPE_BINFO (type)
1142 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1143 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1145 /* Generally, we will always have an index for each initializer (which is
1146 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1147 reshape_init. So we need to handle both cases. */
1148 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1153 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1155 flags |= picflag_from_initializer (integer_zero_node);
1156 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1160 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1163 /* If this is a bitfield, first convert to the declared type. */
1164 type = TREE_TYPE (field);
1165 if (DECL_BIT_FIELD_TYPE (field))
1166 type = DECL_BIT_FIELD_TYPE (field);
1168 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1170 constructor_elt *ce = VEC_index (constructor_elt,
1171 CONSTRUCTOR_ELTS (init), idx);
1174 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1175 latter case can happen in templates where lookup has to be
1177 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1178 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1179 if (ce->index != field
1180 && ce->index != DECL_NAME (field))
1182 ce->value = error_mark_node;
1183 sorry ("non-trivial designated initializers not supported");
1187 gcc_assert (ce->value);
1188 next = digest_init_r (type, ce->value, true,
1189 LOOKUP_IMPLICIT, complain);
1192 else if (type_build_ctor_call (TREE_TYPE (field)))
1194 /* If this type needs constructors run for
1195 default-initialization, we can't rely on the back end to do it
1196 for us, so build up TARGET_EXPRs. If the type in question is
1197 a class, just build one up; if it's an array, recurse. */
1198 next = build_constructor (init_list_type_node, NULL);
1199 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1201 next = finish_compound_literal (TREE_TYPE (field), next,
1203 /* direct-initialize the target. No temporary is going
1205 if (TREE_CODE (next) == TARGET_EXPR)
1206 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1209 next = digest_init_r (TREE_TYPE (field), next, true,
1210 LOOKUP_IMPLICIT, complain);
1212 /* Warn when some struct elements are implicitly initialized. */
1213 warning (OPT_Wmissing_field_initializers,
1214 "missing initializer for member %qD", field);
1218 if (TREE_READONLY (field))
1220 if (complain & tf_error)
1221 error ("uninitialized const member %qD", field);
1223 return PICFLAG_ERRONEOUS;
1225 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1227 if (complain & tf_error)
1228 error ("member %qD with uninitialized const fields", field);
1230 return PICFLAG_ERRONEOUS;
1232 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1234 if (complain & tf_error)
1235 error ("member %qD is uninitialized reference", field);
1237 return PICFLAG_ERRONEOUS;
1240 /* Warn when some struct elements are implicitly initialized
1242 warning (OPT_Wmissing_field_initializers,
1243 "missing initializer for member %qD", field);
1245 if (!zero_init_p (TREE_TYPE (field)))
1246 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1247 /*static_storage_p=*/false);
1249 /* The default zero-initialization is fine for us; don't
1250 add anything to the CONSTRUCTOR. */
1254 /* If this is a bitfield, now convert to the lowered type. */
1255 if (type != TREE_TYPE (field))
1256 next = cp_convert_and_check (TREE_TYPE (field), next);
1257 flags |= picflag_from_initializer (next);
1258 CONSTRUCTOR_APPEND_ELT (v, field, next);
1261 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1263 if (complain & tf_error)
1264 error ("too many initializers for %qT", type);
1266 return PICFLAG_ERRONEOUS;
1269 CONSTRUCTOR_ELTS (init) = v;
1273 /* Subroutine of process_init_constructor, which will process a single
1274 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1275 which describe the initializer. */
1278 process_init_constructor_union (tree type, tree init,
1279 tsubst_flags_t complain)
1281 constructor_elt *ce;
1284 /* If the initializer was empty, use default zero initialization. */
1285 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1288 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1291 if (!(complain & tf_error))
1292 return PICFLAG_ERRONEOUS;
1293 error ("too many initializers for %qT", type);
1294 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1297 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1299 /* If this element specifies a field, initialize via that field. */
1302 if (TREE_CODE (ce->index) == FIELD_DECL)
1304 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1306 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1307 tree name = ce->index;
1309 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1310 if (DECL_NAME (field) == name)
1314 if (complain & tf_error)
1315 error ("no field %qD found in union being initialized",
1317 ce->value = error_mark_node;
1323 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1324 || TREE_CODE (ce->index) == RANGE_EXPR);
1325 if (complain & tf_error)
1326 error ("index value instead of field name in union initializer");
1327 ce->value = error_mark_node;
1332 /* Find the first named field. ANSI decided in September 1990
1333 that only named fields count here. */
1334 tree field = TYPE_FIELDS (type);
1335 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1336 field = TREE_CHAIN (field);
1337 if (field == NULL_TREE)
1339 if (complain & tf_error)
1340 error ("too many initializers for %qT", type);
1341 ce->value = error_mark_node;
1346 if (ce->value && ce->value != error_mark_node)
1347 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value,
1348 true, LOOKUP_IMPLICIT, complain);
1350 return picflag_from_initializer (ce->value);
1353 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1354 constructor is a brace-enclosed initializer, and will be modified in-place.
1356 Each element is converted to the right type through digest_init, and
1357 missing initializers are added following the language rules (zero-padding,
1360 After the execution, the initializer will have TREE_CONSTANT if all elts are
1361 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1362 constants that the assembler and linker can compute them.
1364 The function returns the initializer itself, or error_mark_node in case
1368 process_init_constructor (tree type, tree init, tsubst_flags_t complain)
1372 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1374 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1375 flags = process_init_constructor_array (type, init, complain);
1376 else if (TREE_CODE (type) == RECORD_TYPE)
1377 flags = process_init_constructor_record (type, init, complain);
1378 else if (TREE_CODE (type) == UNION_TYPE)
1379 flags = process_init_constructor_union (type, init, complain);
1383 if (flags & PICFLAG_ERRONEOUS)
1384 return error_mark_node;
1386 TREE_TYPE (init) = type;
1387 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1388 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1389 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1391 TREE_CONSTANT (init) = 1;
1392 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1393 TREE_STATIC (init) = 1;
1398 /* Given a structure or union value DATUM, construct and return
1399 the structure or union component which results from narrowing
1400 that value to the base specified in BASETYPE. For example, given the
1403 class L { int ii; };
1404 class A : L { ... };
1405 class B : L { ... };
1406 class C : A, B { ... };
1414 x.A::ii refers to the ii member of the L part of
1415 the A part of the C object named by X. In this case,
1416 DATUM would be x, and BASETYPE would be A.
1418 I used to think that this was nonconformant, that the standard specified
1419 that first we look up ii in A, then convert x to an L& and pull out the
1420 ii part. But in fact, it does say that we convert x to an A&; A here
1421 is known as the "naming class". (jason 2000-12-19)
1423 BINFO_P points to a variable initialized either to NULL_TREE or to the
1424 binfo for the specific base subobject we want to convert to. */
1427 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1431 if (datum == error_mark_node)
1432 return error_mark_node;
1436 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1438 if (!binfo || binfo == error_mark_node)
1440 *binfo_p = NULL_TREE;
1442 error_not_base_type (basetype, TREE_TYPE (datum));
1443 return error_mark_node;
1447 return build_base_path (PLUS_EXPR, datum, binfo, 1,
1448 tf_warning_or_error);
1451 /* Build a reference to an object specified by the C++ `->' operator.
1452 Usually this just involves dereferencing the object, but if the
1453 `->' operator is overloaded, then such overloads must be
1454 performed until an object which does not have the `->' operator
1455 overloaded is found. An error is reported when circular pointer
1456 delegation is detected. */
1459 build_x_arrow (tree expr)
1461 tree orig_expr = expr;
1462 tree type = TREE_TYPE (expr);
1463 tree last_rval = NULL_TREE;
1464 VEC(tree,gc) *types_memoized = NULL;
1466 if (type == error_mark_node)
1467 return error_mark_node;
1469 if (processing_template_decl)
1471 if (type_dependent_expression_p (expr))
1472 return build_min_nt (ARROW_EXPR, expr);
1473 expr = build_non_dependent_expr (expr);
1476 if (MAYBE_CLASS_TYPE_P (type))
1478 struct tinst_level *actual_inst = current_instantiation ();
1481 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1482 NULL_TREE, NULL_TREE,
1483 &fn, tf_warning_or_error)))
1485 if (expr == error_mark_node)
1486 return error_mark_node;
1488 if (fn && DECL_USE_TEMPLATE (fn))
1489 push_tinst_level (fn);
1492 if (vec_member (TREE_TYPE (expr), types_memoized))
1494 error ("circular pointer delegation detected");
1495 return error_mark_node;
1498 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1502 while (current_instantiation () != actual_inst)
1505 if (last_rval == NULL_TREE)
1507 error ("base operand of %<->%> has non-pointer type %qT", type);
1508 return error_mark_node;
1511 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1512 last_rval = convert_from_reference (last_rval);
1515 last_rval = decay_conversion (expr);
1517 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1519 if (processing_template_decl)
1521 expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
1523 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
1527 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1531 error ("result of %<operator->()%> yields non-pointer result");
1533 error ("base operand of %<->%> is not a pointer");
1534 return error_mark_node;
1537 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1538 already been checked out to be of aggregate type. */
1541 build_m_component_ref (tree datum, tree component)
1549 if (error_operand_p (datum) || error_operand_p (component))
1550 return error_mark_node;
1552 datum = mark_lvalue_use (datum);
1553 component = mark_rvalue_use (component);
1555 ptrmem_type = TREE_TYPE (component);
1556 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1558 error ("%qE cannot be used as a member pointer, since it is of "
1560 component, ptrmem_type);
1561 return error_mark_node;
1564 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1565 if (! MAYBE_CLASS_TYPE_P (objtype))
1567 error ("cannot apply member pointer %qE to %qE, which is of "
1568 "non-class type %qT",
1569 component, datum, objtype);
1570 return error_mark_node;
1573 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1574 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1576 if (!COMPLETE_TYPE_P (ctype))
1578 if (!same_type_p (ctype, objtype))
1584 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1589 error ("pointer to member type %qT incompatible with object "
1592 return error_mark_node;
1594 else if (binfo == error_mark_node)
1595 return error_mark_node;
1598 if (TYPE_PTRMEM_P (ptrmem_type))
1600 bool is_lval = real_lvalue_p (datum);
1603 /* Compute the type of the field, as described in [expr.ref].
1604 There's no such thing as a mutable pointer-to-member, so
1605 things are not as complex as they are for references to
1606 non-static data members. */
1607 type = cp_build_qualified_type (type,
1608 (cp_type_quals (type)
1609 | cp_type_quals (TREE_TYPE (datum))));
1611 datum = build_address (datum);
1613 /* Convert object to the correct base. */
1615 datum = build_base_path (PLUS_EXPR, datum, binfo, 1,
1616 tf_warning_or_error);
1618 /* Build an expression for "object + offset" where offset is the
1619 value stored in the pointer-to-data-member. */
1620 ptype = build_pointer_type (type);
1621 datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
1622 datum = cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1623 /* If the object expression was an rvalue, return an rvalue. */
1625 datum = move (datum);
1629 return build2 (OFFSET_REF, type, datum, component);
1632 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1635 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1637 /* This is either a call to a constructor,
1638 or a C cast in C++'s `functional' notation. */
1640 /* The type to which we are casting. */
1642 VEC(tree,gc) *parmvec;
1644 if (exp == error_mark_node || parms == error_mark_node)
1645 return error_mark_node;
1647 if (TREE_CODE (exp) == TYPE_DECL)
1648 type = TREE_TYPE (exp);
1652 /* We need to check this explicitly, since value-initialization of
1653 arrays is allowed in other situations. */
1654 if (TREE_CODE (type) == ARRAY_TYPE)
1656 if (complain & tf_error)
1657 error ("functional cast to array type %qT", type);
1658 return error_mark_node;
1661 if (type_uses_auto (type))
1663 if (complain & tf_error)
1664 error ("invalid use of %<auto%>");
1665 return error_mark_node;
1668 if (processing_template_decl)
1672 /* Diagnose this even in a template. We could also try harder
1673 to give all the usual errors when the type and args are
1675 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1677 if (complain & tf_error)
1678 error ("invalid value-initialization of reference type");
1679 return error_mark_node;
1682 t = build_min (CAST_EXPR, type, parms);
1683 /* We don't know if it will or will not have side effects. */
1684 TREE_SIDE_EFFECTS (t) = 1;
1688 if (! MAYBE_CLASS_TYPE_P (type))
1690 if (parms == NULL_TREE)
1692 if (VOID_TYPE_P (type))
1693 return void_zero_node;
1694 return build_value_init (cv_unqualified (type), complain);
1697 /* This must build a C cast. */
1698 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1699 return cp_build_c_cast (type, parms, complain);
1702 /* Prepare to evaluate as a call to a constructor. If this expression
1703 is actually used, for example,
1705 return X (arg1, arg2, ...);
1707 then the slot being initialized will be filled in. */
1709 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1710 return error_mark_node;
1711 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
1712 return error_mark_node;
1716 If the expression list is a single-expression, the type
1717 conversion is equivalent (in definedness, and if defined in
1718 meaning) to the corresponding cast expression. */
1719 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1720 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1724 The expression T(), where T is a simple-type-specifier for a
1725 non-array complete object type or the (possibly cv-qualified)
1726 void type, creates an rvalue of the specified type, which is
1727 value-initialized. */
1729 if (parms == NULL_TREE)
1731 exp = build_value_init (type, complain);
1732 exp = get_target_expr_sfinae (exp, complain);
1736 /* Call the constructor. */
1737 parmvec = make_tree_vector ();
1738 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1739 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1740 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1741 &parmvec, type, LOOKUP_NORMAL, complain);
1742 release_tree_vector (parmvec);
1744 if (exp == error_mark_node)
1745 return error_mark_node;
1747 return build_cplus_new (type, exp, complain);
1751 /* Add new exception specifier SPEC, to the LIST we currently have.
1752 If it's already in LIST then do nothing.
1753 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1754 know what we're doing. */
1757 add_exception_specifier (tree list, tree spec, int complain)
1762 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1764 if (spec == error_mark_node)
1767 gcc_assert (spec && (!list || TREE_VALUE (list)));
1769 /* [except.spec] 1, type in an exception specifier shall not be
1770 incomplete, or pointer or ref to incomplete other than pointer
1772 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1773 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1774 core = TREE_TYPE (core);
1777 else if (VOID_TYPE_P (core))
1779 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1781 else if (processing_template_decl)
1786 /* 15.4/1 says that types in an exception specifier must be complete,
1787 but it seems more reasonable to only require this on definitions
1788 and calls. So just give a pedwarn at this point; we will give an
1789 error later if we hit one of those two cases. */
1790 if (!COMPLETE_TYPE_P (complete_type (core)))
1791 diag_type = DK_PEDWARN; /* pedwarn */
1798 for (probe = list; probe; probe = TREE_CHAIN (probe))
1799 if (same_type_p (TREE_VALUE (probe), spec))
1802 list = tree_cons (NULL_TREE, spec, list);
1805 diag_type = DK_ERROR; /* error */
1807 if (diag_type != DK_UNSPECIFIED && complain)
1808 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1813 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
1816 nothrow_spec_p_uninst (const_tree spec)
1818 if (DEFERRED_NOEXCEPT_SPEC_P (spec))
1820 return nothrow_spec_p (spec);
1823 /* Combine the two exceptions specifier lists LIST and ADD, and return
1824 their union. If FN is non-null, it's the source of ADD. */
1827 merge_exception_specifiers (tree list, tree add, tree fn)
1829 tree noex, orig_list;
1831 /* No exception-specifier or noexcept(false) are less strict than
1832 anything else. Prefer the newer variant (LIST). */
1833 if (!list || list == noexcept_false_spec)
1835 else if (!add || add == noexcept_false_spec)
1838 /* noexcept(true) and throw() are stricter than anything else.
1839 As above, prefer the more recent one (LIST). */
1840 if (nothrow_spec_p_uninst (add))
1843 noex = TREE_PURPOSE (list);
1844 if (DEFERRED_NOEXCEPT_SPEC_P (add))
1846 /* If ADD is a deferred noexcept, we must have been called from
1847 process_subob_fn. For implicitly declared functions, we build up
1848 a list of functions to consider at instantiation time. */
1849 if (noex == boolean_true_node)
1851 gcc_assert (fn && (!noex || is_overloaded_fn (noex)));
1852 noex = build_overload (fn, noex);
1854 else if (nothrow_spec_p_uninst (list))
1857 gcc_checking_assert (!TREE_PURPOSE (add)
1858 || cp_tree_equal (noex, TREE_PURPOSE (add)));
1860 /* Combine the dynamic-exception-specifiers, if any. */
1862 for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
1864 tree spec = TREE_VALUE (add);
1867 for (probe = orig_list; probe && TREE_VALUE (probe);
1868 probe = TREE_CHAIN (probe))
1869 if (same_type_p (TREE_VALUE (probe), spec))
1873 spec = build_tree_list (NULL_TREE, spec);
1874 TREE_CHAIN (spec) = list;
1879 /* Keep the noexcept-specifier at the beginning of the list. */
1880 if (noex != TREE_PURPOSE (list))
1881 list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
1886 /* Subroutine of build_call. Ensure that each of the types in the
1887 exception specification is complete. Technically, 15.4/1 says that
1888 they need to be complete when we see a declaration of the function,
1889 but we should be able to get away with only requiring this when the
1890 function is defined or called. See also add_exception_specifier. */
1893 require_complete_eh_spec_types (tree fntype, tree decl)
1896 /* Don't complain about calls to op new. */
1897 if (decl && DECL_ARTIFICIAL (decl))
1899 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1900 raises = TREE_CHAIN (raises))
1902 tree type = TREE_VALUE (raises);
1903 if (type && !COMPLETE_TYPE_P (type))
1907 ("call to function %qD which throws incomplete type %q#T",
1910 error ("call to function which throws incomplete type %q#T",
1917 #include "gt-cp-typeck2.h"