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
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 inform (input_location, "\t%+#D", fn);
344 /* Now truncate the vector. This leaves it non-null, so we know
345 there are pure virtuals, but empty so we don't list them out
347 VEC_truncate (tree, pure, 0);
350 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
351 " since type %qT has pure virtual functions",
357 /* Wrapper for the above function in the common case of wanting errors. */
360 abstract_virtuals_error (tree decl, tree type)
362 return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
365 /* Print an error message for invalid use of an incomplete type.
366 VALUE is the expression that was used (or 0 if that isn't known)
367 and TYPE is the type that was invalid. DIAG_KIND indicates the
368 type of diagnostic (see diagnostic.def). */
371 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
372 diagnostic_t diag_kind)
376 gcc_assert (diag_kind == DK_WARNING
377 || diag_kind == DK_PEDWARN
378 || diag_kind == DK_ERROR);
380 /* Avoid duplicate error message. */
381 if (TREE_CODE (type) == ERROR_MARK)
384 if (value != 0 && (TREE_CODE (value) == VAR_DECL
385 || TREE_CODE (value) == PARM_DECL
386 || TREE_CODE (value) == FIELD_DECL))
388 emit_diagnostic (diag_kind, input_location, 0,
389 "%q+D has incomplete type", value);
393 /* We must print an error message. Be clever about what it says. */
395 switch (TREE_CODE (type))
401 emit_diagnostic (diag_kind, input_location, 0,
402 "invalid use of incomplete type %q#T", type);
403 if (!TYPE_TEMPLATE_INFO (type))
404 emit_diagnostic (diag_kind, input_location, 0,
405 "forward declaration of %q+#T", type);
407 emit_diagnostic (diag_kind, input_location, 0,
408 "declaration of %q+#T", type);
412 emit_diagnostic (diag_kind, input_location, 0,
413 "invalid use of %qT", type);
417 if (TYPE_DOMAIN (type))
419 type = TREE_TYPE (type);
422 emit_diagnostic (diag_kind, input_location, 0,
423 "invalid use of array with unspecified bounds");
428 emit_diagnostic (diag_kind, input_location, 0,
429 "invalid use of member (did you forget the %<&%> ?)");
432 case TEMPLATE_TYPE_PARM:
434 emit_diagnostic (diag_kind, input_location, 0,
435 "invalid use of %<auto%>");
437 emit_diagnostic (diag_kind, input_location, 0,
438 "invalid use of template type parameter %qT", type);
441 case BOUND_TEMPLATE_TEMPLATE_PARM:
442 emit_diagnostic (diag_kind, input_location, 0,
443 "invalid use of template template parameter %qT",
448 emit_diagnostic (diag_kind, input_location, 0,
449 "invalid use of dependent type %qT", type);
453 if (type == init_list_type_node)
455 emit_diagnostic (diag_kind, input_location, 0,
456 "invalid use of brace-enclosed initializer list");
459 gcc_assert (type == unknown_type_node);
460 if (value && TREE_CODE (value) == COMPONENT_REF)
462 else if (value && TREE_CODE (value) == ADDR_EXPR)
463 emit_diagnostic (diag_kind, input_location, 0,
464 "address of overloaded function with no contextual "
466 else if (value && TREE_CODE (value) == OVERLOAD)
467 emit_diagnostic (diag_kind, input_location, 0,
468 "overloaded function with no contextual type information");
470 emit_diagnostic (diag_kind, input_location, 0,
471 "insufficient contextual information to determine type");
479 /* Backward-compatibility interface to incomplete_type_diagnostic;
480 required by ../tree.c. */
481 #undef cxx_incomplete_type_error
483 cxx_incomplete_type_error (const_tree value, const_tree type)
485 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
489 /* The recursive part of split_nonconstant_init. DEST is an lvalue
490 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
491 Return true if the whole of the value was initialized by the
492 generated statements. */
495 split_nonconstant_init_1 (tree dest, tree init)
497 unsigned HOST_WIDE_INT idx;
498 tree field_index, value;
499 tree type = TREE_TYPE (dest);
500 tree inner_type = NULL;
501 bool array_type_p = false;
502 bool complete_p = true;
503 HOST_WIDE_INT num_split_elts = 0;
505 switch (TREE_CODE (type))
508 inner_type = TREE_TYPE (type);
514 case QUAL_UNION_TYPE:
515 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
518 /* The current implementation of this algorithm assumes that
519 the field was set for all the elements. This is usually done
520 by process_init_constructor. */
521 gcc_assert (field_index);
524 inner_type = TREE_TYPE (field_index);
526 if (TREE_CODE (value) == CONSTRUCTOR)
531 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
532 NULL_TREE, NULL_TREE);
534 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
537 if (!split_nonconstant_init_1 (sub, value))
541 else if (!initializer_constant_valid_p (value, inner_type))
546 /* FIXME: Ordered removal is O(1) so the whole function is
547 worst-case quadratic. This could be fixed using an aside
548 bitmap to record which elements must be removed and remove
549 them all at the same time. Or by merging
550 split_non_constant_init into process_init_constructor_array,
551 that is separating constants from non-constants while building
553 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
558 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
559 NULL_TREE, NULL_TREE);
561 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
564 code = build2 (INIT_EXPR, inner_type, sub, value);
565 code = build_stmt (input_location, EXPR_STMT, code);
574 if (!initializer_constant_valid_p (init, type))
577 tree cons = copy_node (init);
578 CONSTRUCTOR_ELTS (init) = NULL;
579 code = build2 (MODIFY_EXPR, type, dest, cons);
580 code = build_stmt (input_location, EXPR_STMT, code);
582 num_split_elts += CONSTRUCTOR_NELTS (init);
590 /* The rest of the initializer is now a constant. */
591 TREE_CONSTANT (init) = 1;
592 return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
593 num_split_elts, inner_type);
596 /* A subroutine of store_init_value. Splits non-constant static
597 initializer INIT into a constant part and generates code to
598 perform the non-constant part of the initialization to DEST.
599 Returns the code for the runtime init. */
602 split_nonconstant_init (tree dest, tree init)
606 if (TREE_CODE (init) == CONSTRUCTOR)
608 code = push_stmt_list ();
609 if (split_nonconstant_init_1 (dest, init))
611 code = pop_stmt_list (code);
612 DECL_INITIAL (dest) = init;
613 TREE_READONLY (dest) = 0;
616 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
621 /* Perform appropriate conversions on the initial value of a variable,
622 store it in the declaration DECL,
623 and print any error messages that are appropriate.
624 If the init is invalid, store an ERROR_MARK.
626 C++: Note that INIT might be a TREE_LIST, which would mean that it is
627 a base class initializer for some aggregate type, hopefully compatible
628 with DECL. If INIT is a single element, and DECL is an aggregate
629 type, we silently convert INIT into a TREE_LIST, allowing a constructor
632 If INIT is a TREE_LIST and there is no constructor, turn INIT
633 into a CONSTRUCTOR and use standard initialization techniques.
634 Perhaps a warning should be generated?
636 Returns code to be executed if initialization could not be performed
637 for static variable. In that case, caller must emit the code. */
640 store_init_value (tree decl, tree init, int flags)
644 /* If variable's type was invalidly declared, just ignore it. */
646 type = TREE_TYPE (decl);
647 if (TREE_CODE (type) == ERROR_MARK)
650 if (MAYBE_CLASS_TYPE_P (type))
652 if (TREE_CODE (init) == TREE_LIST)
654 error ("constructor syntax used, but no constructor declared "
655 "for type %qT", type);
656 init = build_constructor_from_list (init_list_type_node, nreverse (init));
659 else if (TREE_CODE (init) == TREE_LIST
660 && TREE_TYPE (init) != unknown_type_node)
662 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
664 if (TREE_CODE (init) == TREE_LIST
665 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
667 error ("cannot initialize arrays using this syntax");
671 /* We get here with code like `int a (2);' */
672 init = build_x_compound_expr_from_list (init, ELK_INIT,
673 tf_warning_or_error);
676 /* End of special C++ code. */
678 if (flags & LOOKUP_ALREADY_DIGESTED)
681 /* Digest the specified initializer into an expression. */
682 value = digest_init_flags (type, init, flags);
684 /* In C++0x constant expression is a semantic, not syntactic, property.
685 In C++98, make sure that what we thought was a constant expression at
686 template definition time is still constant. */
687 if ((cxx_dialect >= cxx0x
688 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
689 && (decl_maybe_constant_var_p (decl)
690 || TREE_STATIC (decl)))
693 value = fold_non_dependent_expr (value);
694 value = maybe_constant_init (value);
695 if (DECL_DECLARED_CONSTEXPR_P (decl))
696 /* Diagnose a non-constant initializer for constexpr. */
697 value = cxx_constant_value (value);
698 const_init = (reduced_constant_expression_p (value)
699 || error_operand_p (value));
700 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
701 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
704 /* If the initializer is not a constant, fill in DECL_INITIAL with
705 the bits that are constant, and then return an expression that
706 will perform the dynamic initialization. */
707 if (value != error_mark_node
708 && (TREE_SIDE_EFFECTS (value)
709 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
710 return split_nonconstant_init (decl, value);
711 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
712 is an automatic variable, the middle end will turn this into a
713 dynamic initialization later. */
714 DECL_INITIAL (decl) = value;
719 /* Give errors about narrowing conversions within { }. */
722 check_narrowing (tree type, tree init)
724 tree ftype = unlowered_expr_type (init);
728 if (!warn_narrowing || !ARITHMETIC_TYPE_P (type))
731 if (BRACE_ENCLOSED_INITIALIZER_P (init)
732 && TREE_CODE (type) == COMPLEX_TYPE)
734 tree elttype = TREE_TYPE (type);
735 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value);
736 if (CONSTRUCTOR_NELTS (init) > 1)
737 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value);
741 init = maybe_constant_value (init);
743 if (TREE_CODE (type) == INTEGER_TYPE
744 && TREE_CODE (ftype) == REAL_TYPE)
746 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
747 && CP_INTEGRAL_TYPE_P (type))
749 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
750 TYPE_MAX_VALUE (ftype))
751 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
752 TYPE_MIN_VALUE (type)))
753 && (TREE_CODE (init) != INTEGER_CST
754 || !int_fits_type_p (init, type)))
757 else if (TREE_CODE (ftype) == REAL_TYPE
758 && TREE_CODE (type) == REAL_TYPE)
760 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
762 if (TREE_CODE (init) == REAL_CST)
764 /* Issue 703: Loss of precision is OK as long as the value is
765 within the representable range of the new type. */
767 d = TREE_REAL_CST (init);
768 real_convert (&r, TYPE_MODE (type), &d);
776 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
777 && TREE_CODE (type) == REAL_TYPE)
780 if (TREE_CODE (init) == INTEGER_CST)
782 d = real_value_from_int_cst (0, init);
783 if (exact_real_truncate (TYPE_MODE (type), &d))
789 pedwarn (input_location, OPT_Wnarrowing, "narrowing conversion of %qE "
790 "from %qT to %qT inside { }", init, ftype, type);
793 /* Process the initializer INIT for a variable of type TYPE, emitting
794 diagnostics for invalid initializers and converting the initializer as
797 For aggregate types, it assumes that reshape_init has already run, thus the
798 initializer will have the right shape (brace elision has been undone).
800 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
803 digest_init_r (tree type, tree init, bool nested, int flags,
804 tsubst_flags_t complain)
806 enum tree_code code = TREE_CODE (type);
808 if (error_operand_p (init))
809 return error_mark_node;
813 /* We must strip the outermost array type when completing the type,
814 because the its bounds might be incomplete at the moment. */
815 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
816 ? TREE_TYPE (type) : type, NULL_TREE))
817 return error_mark_node;
819 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
820 (g++.old-deja/g++.law/casts2.C). */
821 if (TREE_CODE (init) == NON_LVALUE_EXPR)
822 init = TREE_OPERAND (init, 0);
824 /* Initialization of an array of chars from a string constant. The initializer
825 can be optionally enclosed in braces, but reshape_init has already removed
826 them if they were present. */
827 if (code == ARRAY_TYPE)
829 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
830 if (char_type_p (typ1)
832 && TREE_CODE (init) == STRING_CST)
834 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
836 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
838 if (char_type != char_type_node)
840 if (complain & tf_error)
841 error ("char-array initialized from wide string");
842 return error_mark_node;
847 if (char_type == char_type_node)
849 if (complain & tf_error)
850 error ("int-array initialized from non-wide string");
851 return error_mark_node;
853 else if (char_type != typ1)
855 if (complain & tf_error)
856 error ("int-array initialized from incompatible "
858 return error_mark_node;
862 TREE_TYPE (init) = type;
863 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
865 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
866 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
867 /* In C it is ok to subtract 1 from the length of the string
868 because it's ok to ignore the terminating null char that is
869 counted in the length of the constant, but in C++ this would
871 if (size < TREE_STRING_LENGTH (init))
872 permerror (input_location, "initializer-string for array "
873 "of chars is too long");
879 /* Handle scalar types (including conversions) and references. */
880 if ((TREE_CODE (type) != COMPLEX_TYPE
881 || BRACE_ENCLOSED_INITIALIZER_P (init))
882 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
886 if (cxx_dialect != cxx98 && nested)
887 check_narrowing (type, init);
888 init = convert_for_initialization (0, type, init, flags,
889 ICR_INIT, NULL_TREE, 0,
893 /* Skip any conversions since we'll be outputting the underlying
895 while (CONVERT_EXPR_P (*exp)
896 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
897 exp = &TREE_OPERAND (*exp, 0);
899 *exp = cplus_expand_constant (*exp);
904 /* Come here only for aggregates: records, arrays, unions, complex numbers
906 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
907 || TREE_CODE (type) == VECTOR_TYPE
908 || TREE_CODE (type) == RECORD_TYPE
909 || TREE_CODE (type) == UNION_TYPE
910 || TREE_CODE (type) == COMPLEX_TYPE);
912 if (BRACE_ENCLOSED_INITIALIZER_P (init)
913 && !TYPE_NON_AGGREGATE_CLASS (type))
914 return process_init_constructor (type, init, complain);
917 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
919 if (complain & tf_error)
920 error ("cannot initialize aggregate of type %qT with "
921 "a compound literal", type);
923 return error_mark_node;
926 if (TREE_CODE (type) == ARRAY_TYPE
927 && !BRACE_ENCLOSED_INITIALIZER_P (init))
929 /* Allow the result of build_array_copy and of
930 build_value_init_noctor. */
931 if ((TREE_CODE (init) == VEC_INIT_EXPR
932 || TREE_CODE (init) == CONSTRUCTOR)
933 && (same_type_ignoring_top_level_qualifiers_p
934 (type, TREE_TYPE (init))))
937 if (complain & tf_error)
938 error ("array must be initialized with a brace-enclosed"
940 return error_mark_node;
943 return convert_for_initialization (NULL_TREE, type, init,
945 ICR_INIT, NULL_TREE, 0,
951 digest_init (tree type, tree init, tsubst_flags_t complain)
953 return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain);
957 digest_init_flags (tree type, tree init, int flags)
959 return digest_init_r (type, init, false, flags, tf_warning_or_error);
962 /* Set of flags used within process_init_constructor to describe the
964 #define PICFLAG_ERRONEOUS 1
965 #define PICFLAG_NOT_ALL_CONSTANT 2
966 #define PICFLAG_NOT_ALL_SIMPLE 4
968 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
972 picflag_from_initializer (tree init)
974 if (init == error_mark_node)
975 return PICFLAG_ERRONEOUS;
976 else if (!TREE_CONSTANT (init))
977 return PICFLAG_NOT_ALL_CONSTANT;
978 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
979 return PICFLAG_NOT_ALL_SIMPLE;
983 /* Subroutine of process_init_constructor, which will process an initializer
984 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
985 which describe the initializers. */
988 process_init_constructor_array (tree type, tree init,
989 tsubst_flags_t complain)
991 unsigned HOST_WIDE_INT i, len = 0;
993 bool unbounded = false;
995 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
997 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
998 || TREE_CODE (type) == VECTOR_TYPE);
1000 if (TREE_CODE (type) == ARRAY_TYPE)
1002 tree domain = TYPE_DOMAIN (type);
1004 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1005 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1008 unbounded = true; /* Take as many as there are. */
1011 /* Vectors are like simple fixed-size arrays. */
1012 len = TYPE_VECTOR_SUBPARTS (type);
1014 /* There must not be more initializers than needed. */
1015 if (!unbounded && VEC_length (constructor_elt, v) > len)
1017 if (complain & tf_error)
1018 error ("too many initializers for %qT", type);
1020 return PICFLAG_ERRONEOUS;
1023 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1027 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1028 if (compare_tree_int (ce->index, i) != 0)
1030 ce->value = error_mark_node;
1031 sorry ("non-trivial designated initializers not supported");
1035 ce->index = size_int (i);
1036 gcc_assert (ce->value);
1037 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true,
1038 LOOKUP_IMPLICIT, complain);
1040 if (ce->value != error_mark_node)
1041 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1042 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1044 flags |= picflag_from_initializer (ce->value);
1047 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1048 we must add initializers ourselves. */
1050 for (; i < len; ++i)
1054 if (type_build_ctor_call (TREE_TYPE (type)))
1056 /* If this type needs constructors run for default-initialization,
1057 we can't rely on the back end to do it for us, so make the
1058 initialization explicit by list-initializing from {}. */
1059 next = build_constructor (init_list_type_node, NULL);
1060 next = digest_init (TREE_TYPE (type), next, complain);
1062 else if (!zero_init_p (TREE_TYPE (type)))
1063 next = build_zero_init (TREE_TYPE (type),
1064 /*nelts=*/NULL_TREE,
1065 /*static_storage_p=*/false);
1067 /* The default zero-initialization is fine for us; don't
1068 add anything to the CONSTRUCTOR. */
1071 flags |= picflag_from_initializer (next);
1072 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1075 CONSTRUCTOR_ELTS (init) = v;
1079 /* Subroutine of process_init_constructor, which will process an initializer
1080 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1081 the initializers. */
1084 process_init_constructor_record (tree type, tree init,
1085 tsubst_flags_t complain)
1087 VEC(constructor_elt,gc) *v = NULL;
1090 unsigned HOST_WIDE_INT idx = 0;
1092 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1093 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1094 gcc_assert (!TYPE_BINFO (type)
1095 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1096 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1098 /* Generally, we will always have an index for each initializer (which is
1099 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1100 reshape_init. So we need to handle both cases. */
1101 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1106 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1108 flags |= picflag_from_initializer (integer_zero_node);
1109 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1113 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1116 /* If this is a bitfield, first convert to the declared type. */
1117 type = TREE_TYPE (field);
1118 if (DECL_BIT_FIELD_TYPE (field))
1119 type = DECL_BIT_FIELD_TYPE (field);
1121 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1123 constructor_elt *ce = VEC_index (constructor_elt,
1124 CONSTRUCTOR_ELTS (init), idx);
1127 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1128 latter case can happen in templates where lookup has to be
1130 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1131 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1132 if (ce->index != field
1133 && ce->index != DECL_NAME (field))
1135 ce->value = error_mark_node;
1136 sorry ("non-trivial designated initializers not supported");
1140 gcc_assert (ce->value);
1141 next = digest_init_r (type, ce->value, true,
1142 LOOKUP_IMPLICIT, complain);
1145 else if (type_build_ctor_call (TREE_TYPE (field)))
1147 /* If this type needs constructors run for
1148 default-initialization, we can't rely on the back end to do it
1149 for us, so build up TARGET_EXPRs. If the type in question is
1150 a class, just build one up; if it's an array, recurse. */
1151 next = build_constructor (init_list_type_node, NULL);
1152 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1154 next = finish_compound_literal (TREE_TYPE (field), next,
1156 /* direct-initialize the target. No temporary is going
1158 if (TREE_CODE (next) == TARGET_EXPR)
1159 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1162 next = digest_init_r (TREE_TYPE (field), next, true,
1163 LOOKUP_IMPLICIT, complain);
1165 /* Warn when some struct elements are implicitly initialized. */
1166 warning (OPT_Wmissing_field_initializers,
1167 "missing initializer for member %qD", field);
1171 if (TREE_READONLY (field))
1173 if (complain & tf_error)
1174 error ("uninitialized const member %qD", field);
1176 return PICFLAG_ERRONEOUS;
1178 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1180 if (complain & tf_error)
1181 error ("member %qD with uninitialized const fields", field);
1183 return PICFLAG_ERRONEOUS;
1185 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1187 if (complain & tf_error)
1188 error ("member %qD is uninitialized reference", field);
1190 return PICFLAG_ERRONEOUS;
1193 /* Warn when some struct elements are implicitly initialized
1195 warning (OPT_Wmissing_field_initializers,
1196 "missing initializer for member %qD", field);
1198 if (!zero_init_p (TREE_TYPE (field)))
1199 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1200 /*static_storage_p=*/false);
1202 /* The default zero-initialization is fine for us; don't
1203 add anything to the CONSTRUCTOR. */
1207 /* If this is a bitfield, now convert to the lowered type. */
1208 if (type != TREE_TYPE (field))
1209 next = cp_convert_and_check (TREE_TYPE (field), next);
1210 flags |= picflag_from_initializer (next);
1211 CONSTRUCTOR_APPEND_ELT (v, field, next);
1214 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1216 if (complain & tf_error)
1217 error ("too many initializers for %qT", type);
1219 return PICFLAG_ERRONEOUS;
1222 CONSTRUCTOR_ELTS (init) = v;
1226 /* Subroutine of process_init_constructor, which will process a single
1227 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1228 which describe the initializer. */
1231 process_init_constructor_union (tree type, tree init,
1232 tsubst_flags_t complain)
1234 constructor_elt *ce;
1237 /* If the initializer was empty, use default zero initialization. */
1238 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1241 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1244 if (!(complain & tf_error))
1245 return PICFLAG_ERRONEOUS;
1246 error ("too many initializers for %qT", type);
1247 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1250 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1252 /* If this element specifies a field, initialize via that field. */
1255 if (TREE_CODE (ce->index) == FIELD_DECL)
1257 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1259 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1260 tree name = ce->index;
1262 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1263 if (DECL_NAME (field) == name)
1267 if (complain & tf_error)
1268 error ("no field %qD found in union being initialized",
1270 ce->value = error_mark_node;
1276 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1277 || TREE_CODE (ce->index) == RANGE_EXPR);
1278 if (complain & tf_error)
1279 error ("index value instead of field name in union initializer");
1280 ce->value = error_mark_node;
1285 /* Find the first named field. ANSI decided in September 1990
1286 that only named fields count here. */
1287 tree field = TYPE_FIELDS (type);
1288 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1289 field = TREE_CHAIN (field);
1290 if (field == NULL_TREE)
1292 if (complain & tf_error)
1293 error ("too many initializers for %qT", type);
1294 ce->value = error_mark_node;
1299 if (ce->value && ce->value != error_mark_node)
1300 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value,
1301 true, LOOKUP_IMPLICIT, complain);
1303 return picflag_from_initializer (ce->value);
1306 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1307 constructor is a brace-enclosed initializer, and will be modified in-place.
1309 Each element is converted to the right type through digest_init, and
1310 missing initializers are added following the language rules (zero-padding,
1313 After the execution, the initializer will have TREE_CONSTANT if all elts are
1314 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1315 constants that the assembler and linker can compute them.
1317 The function returns the initializer itself, or error_mark_node in case
1321 process_init_constructor (tree type, tree init, tsubst_flags_t complain)
1325 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1327 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1328 flags = process_init_constructor_array (type, init, complain);
1329 else if (TREE_CODE (type) == RECORD_TYPE)
1330 flags = process_init_constructor_record (type, init, complain);
1331 else if (TREE_CODE (type) == UNION_TYPE)
1332 flags = process_init_constructor_union (type, init, complain);
1336 if (flags & PICFLAG_ERRONEOUS)
1337 return error_mark_node;
1339 TREE_TYPE (init) = type;
1340 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1341 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1342 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1344 TREE_CONSTANT (init) = 1;
1345 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1346 TREE_STATIC (init) = 1;
1351 /* Given a structure or union value DATUM, construct and return
1352 the structure or union component which results from narrowing
1353 that value to the base specified in BASETYPE. For example, given the
1356 class L { int ii; };
1357 class A : L { ... };
1358 class B : L { ... };
1359 class C : A, B { ... };
1367 x.A::ii refers to the ii member of the L part of
1368 the A part of the C object named by X. In this case,
1369 DATUM would be x, and BASETYPE would be A.
1371 I used to think that this was nonconformant, that the standard specified
1372 that first we look up ii in A, then convert x to an L& and pull out the
1373 ii part. But in fact, it does say that we convert x to an A&; A here
1374 is known as the "naming class". (jason 2000-12-19)
1376 BINFO_P points to a variable initialized either to NULL_TREE or to the
1377 binfo for the specific base subobject we want to convert to. */
1380 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1384 if (datum == error_mark_node)
1385 return error_mark_node;
1389 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1391 if (!binfo || binfo == error_mark_node)
1393 *binfo_p = NULL_TREE;
1395 error_not_base_type (basetype, TREE_TYPE (datum));
1396 return error_mark_node;
1400 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1403 /* Build a reference to an object specified by the C++ `->' operator.
1404 Usually this just involves dereferencing the object, but if the
1405 `->' operator is overloaded, then such overloads must be
1406 performed until an object which does not have the `->' operator
1407 overloaded is found. An error is reported when circular pointer
1408 delegation is detected. */
1411 build_x_arrow (tree expr)
1413 tree orig_expr = expr;
1414 tree type = TREE_TYPE (expr);
1415 tree last_rval = NULL_TREE;
1416 VEC(tree,gc) *types_memoized = NULL;
1418 if (type == error_mark_node)
1419 return error_mark_node;
1421 if (processing_template_decl)
1423 if (type_dependent_expression_p (expr))
1424 return build_min_nt (ARROW_EXPR, expr);
1425 expr = build_non_dependent_expr (expr);
1428 if (MAYBE_CLASS_TYPE_P (type))
1430 struct tinst_level *actual_inst = current_instantiation ();
1433 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1434 NULL_TREE, NULL_TREE,
1435 &fn, tf_warning_or_error)))
1437 if (expr == error_mark_node)
1438 return error_mark_node;
1440 if (fn && DECL_USE_TEMPLATE (fn))
1441 push_tinst_level (fn);
1444 if (vec_member (TREE_TYPE (expr), types_memoized))
1446 error ("circular pointer delegation detected");
1447 return error_mark_node;
1450 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1454 while (current_instantiation () != actual_inst)
1457 if (last_rval == NULL_TREE)
1459 error ("base operand of %<->%> has non-pointer type %qT", type);
1460 return error_mark_node;
1463 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1464 last_rval = convert_from_reference (last_rval);
1467 last_rval = decay_conversion (expr);
1469 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1471 if (processing_template_decl)
1473 expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
1475 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
1479 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1483 error ("result of %<operator->()%> yields non-pointer result");
1485 error ("base operand of %<->%> is not a pointer");
1486 return error_mark_node;
1489 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1490 already been checked out to be of aggregate type. */
1493 build_m_component_ref (tree datum, tree component)
1501 if (error_operand_p (datum) || error_operand_p (component))
1502 return error_mark_node;
1504 datum = mark_lvalue_use (datum);
1505 component = mark_rvalue_use (component);
1507 ptrmem_type = TREE_TYPE (component);
1508 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1510 error ("%qE cannot be used as a member pointer, since it is of "
1512 component, ptrmem_type);
1513 return error_mark_node;
1516 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1517 if (! MAYBE_CLASS_TYPE_P (objtype))
1519 error ("cannot apply member pointer %qE to %qE, which is of "
1520 "non-class type %qT",
1521 component, datum, objtype);
1522 return error_mark_node;
1525 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1526 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1528 if (!COMPLETE_TYPE_P (ctype))
1530 if (!same_type_p (ctype, objtype))
1536 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1541 error ("pointer to member type %qT incompatible with object "
1544 return error_mark_node;
1546 else if (binfo == error_mark_node)
1547 return error_mark_node;
1550 if (TYPE_PTRMEM_P (ptrmem_type))
1552 bool is_lval = real_lvalue_p (datum);
1555 /* Compute the type of the field, as described in [expr.ref].
1556 There's no such thing as a mutable pointer-to-member, so
1557 things are not as complex as they are for references to
1558 non-static data members. */
1559 type = cp_build_qualified_type (type,
1560 (cp_type_quals (type)
1561 | cp_type_quals (TREE_TYPE (datum))));
1563 datum = build_address (datum);
1565 /* Convert object to the correct base. */
1567 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1569 /* Build an expression for "object + offset" where offset is the
1570 value stored in the pointer-to-data-member. */
1571 ptype = build_pointer_type (type);
1572 datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
1573 datum = cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1574 /* If the object expression was an rvalue, return an rvalue. */
1576 datum = move (datum);
1580 return build2 (OFFSET_REF, type, datum, component);
1583 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1586 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1588 /* This is either a call to a constructor,
1589 or a C cast in C++'s `functional' notation. */
1591 /* The type to which we are casting. */
1593 VEC(tree,gc) *parmvec;
1595 if (exp == error_mark_node || parms == error_mark_node)
1596 return error_mark_node;
1598 if (TREE_CODE (exp) == TYPE_DECL)
1599 type = TREE_TYPE (exp);
1603 /* We need to check this explicitly, since value-initialization of
1604 arrays is allowed in other situations. */
1605 if (TREE_CODE (type) == ARRAY_TYPE)
1607 if (complain & tf_error)
1608 error ("functional cast to array type %qT", type);
1609 return error_mark_node;
1612 if (type_uses_auto (type))
1614 if (complain & tf_error)
1615 error ("invalid use of %<auto%>");
1616 type = error_mark_node;
1619 if (processing_template_decl)
1623 /* Diagnose this even in a template. We could also try harder
1624 to give all the usual errors when the type and args are
1626 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1628 if (complain & tf_error)
1629 error ("invalid value-initialization of reference type");
1630 return error_mark_node;
1633 t = build_min (CAST_EXPR, type, parms);
1634 /* We don't know if it will or will not have side effects. */
1635 TREE_SIDE_EFFECTS (t) = 1;
1639 if (! MAYBE_CLASS_TYPE_P (type))
1641 if (parms == NULL_TREE)
1643 if (VOID_TYPE_P (type))
1644 return void_zero_node;
1645 return build_value_init (cv_unqualified (type), complain);
1648 /* This must build a C cast. */
1649 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1650 return cp_build_c_cast (type, parms, complain);
1653 /* Prepare to evaluate as a call to a constructor. If this expression
1654 is actually used, for example,
1656 return X (arg1, arg2, ...);
1658 then the slot being initialized will be filled in. */
1660 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1661 return error_mark_node;
1662 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
1663 return error_mark_node;
1667 If the expression list is a single-expression, the type
1668 conversion is equivalent (in definedness, and if defined in
1669 meaning) to the corresponding cast expression. */
1670 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1671 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1675 The expression T(), where T is a simple-type-specifier for a
1676 non-array complete object type or the (possibly cv-qualified)
1677 void type, creates an rvalue of the specified type, which is
1678 value-initialized. */
1680 if (parms == NULL_TREE
1681 /* If there's a user-defined constructor, value-initialization is
1682 just calling the constructor, so fall through. */
1683 && !TYPE_HAS_USER_CONSTRUCTOR (type))
1685 exp = build_value_init (type, complain);
1686 exp = get_target_expr_sfinae (exp, complain);
1687 /* FIXME this is wrong */
1688 if (literal_type_p (type))
1689 TREE_CONSTANT (exp) = true;
1693 /* Call the constructor. */
1694 parmvec = make_tree_vector ();
1695 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1696 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1697 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1698 &parmvec, type, LOOKUP_NORMAL, complain);
1699 release_tree_vector (parmvec);
1701 if (exp == error_mark_node)
1702 return error_mark_node;
1704 return build_cplus_new (type, exp, complain);
1708 /* Add new exception specifier SPEC, to the LIST we currently have.
1709 If it's already in LIST then do nothing.
1710 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1711 know what we're doing. */
1714 add_exception_specifier (tree list, tree spec, int complain)
1719 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1721 if (spec == error_mark_node)
1724 gcc_assert (spec && (!list || TREE_VALUE (list)));
1726 /* [except.spec] 1, type in an exception specifier shall not be
1727 incomplete, or pointer or ref to incomplete other than pointer
1729 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1730 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1731 core = TREE_TYPE (core);
1734 else if (VOID_TYPE_P (core))
1736 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1738 else if (processing_template_decl)
1743 /* 15.4/1 says that types in an exception specifier must be complete,
1744 but it seems more reasonable to only require this on definitions
1745 and calls. So just give a pedwarn at this point; we will give an
1746 error later if we hit one of those two cases. */
1747 if (!COMPLETE_TYPE_P (complete_type (core)))
1748 diag_type = DK_PEDWARN; /* pedwarn */
1755 for (probe = list; probe; probe = TREE_CHAIN (probe))
1756 if (same_type_p (TREE_VALUE (probe), spec))
1759 list = tree_cons (NULL_TREE, spec, list);
1762 diag_type = DK_ERROR; /* error */
1764 if (diag_type != DK_UNSPECIFIED && complain)
1765 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1770 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
1773 nothrow_spec_p_uninst (const_tree spec)
1775 if (DEFERRED_NOEXCEPT_SPEC_P (spec))
1777 return nothrow_spec_p (spec);
1780 /* Combine the two exceptions specifier lists LIST and ADD, and return
1781 their union. If FN is non-null, it's the source of ADD. */
1784 merge_exception_specifiers (tree list, tree add, tree fn)
1786 tree noex, orig_list;
1788 /* No exception-specifier or noexcept(false) are less strict than
1789 anything else. Prefer the newer variant (LIST). */
1790 if (!list || list == noexcept_false_spec)
1792 else if (!add || add == noexcept_false_spec)
1795 /* noexcept(true) and throw() are stricter than anything else.
1796 As above, prefer the more recent one (LIST). */
1797 if (nothrow_spec_p_uninst (add))
1800 noex = TREE_PURPOSE (list);
1801 if (DEFERRED_NOEXCEPT_SPEC_P (add))
1803 /* If ADD is a deferred noexcept, we must have been called from
1804 process_subob_fn. For implicitly declared functions, we build up
1805 a list of functions to consider at instantiation time. */
1806 if (noex == boolean_true_node)
1808 gcc_assert (fn && (!noex || is_overloaded_fn (noex)));
1809 noex = build_overload (fn, noex);
1811 else if (nothrow_spec_p_uninst (list))
1814 gcc_checking_assert (!TREE_PURPOSE (add)
1815 || cp_tree_equal (noex, TREE_PURPOSE (add)));
1817 /* Combine the dynamic-exception-specifiers, if any. */
1819 for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
1821 tree spec = TREE_VALUE (add);
1824 for (probe = orig_list; probe && TREE_VALUE (probe);
1825 probe = TREE_CHAIN (probe))
1826 if (same_type_p (TREE_VALUE (probe), spec))
1830 spec = build_tree_list (NULL_TREE, spec);
1831 TREE_CHAIN (spec) = list;
1836 /* Keep the noexcept-specifier at the beginning of the list. */
1837 if (noex != TREE_PURPOSE (list))
1838 list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
1843 /* Subroutine of build_call. Ensure that each of the types in the
1844 exception specification is complete. Technically, 15.4/1 says that
1845 they need to be complete when we see a declaration of the function,
1846 but we should be able to get away with only requiring this when the
1847 function is defined or called. See also add_exception_specifier. */
1850 require_complete_eh_spec_types (tree fntype, tree decl)
1853 /* Don't complain about calls to op new. */
1854 if (decl && DECL_ARTIFICIAL (decl))
1856 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1857 raises = TREE_CHAIN (raises))
1859 tree type = TREE_VALUE (raises);
1860 if (type && !COMPLETE_TYPE_P (type))
1864 ("call to function %qD which throws incomplete type %q#T",
1867 error ("call to function which throws incomplete type %q#T",
1874 #include "gt-cp-typeck2.h"