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");
431 emit_diagnostic (diag_kind, input_location, 0,
432 "invalid use of member (did you forget the %<&%> ?)");
435 case TEMPLATE_TYPE_PARM:
437 emit_diagnostic (diag_kind, input_location, 0,
438 "invalid use of %<auto%>");
440 emit_diagnostic (diag_kind, input_location, 0,
441 "invalid use of template type parameter %qT", type);
444 case BOUND_TEMPLATE_TEMPLATE_PARM:
445 emit_diagnostic (diag_kind, input_location, 0,
446 "invalid use of template template parameter %qT",
451 emit_diagnostic (diag_kind, input_location, 0,
452 "invalid use of dependent type %qT", type);
456 if (type == init_list_type_node)
458 emit_diagnostic (diag_kind, input_location, 0,
459 "invalid use of brace-enclosed initializer list");
462 gcc_assert (type == unknown_type_node);
463 if (value && TREE_CODE (value) == COMPONENT_REF)
465 else if (value && TREE_CODE (value) == ADDR_EXPR)
466 emit_diagnostic (diag_kind, input_location, 0,
467 "address of overloaded function with no contextual "
469 else if (value && TREE_CODE (value) == OVERLOAD)
470 emit_diagnostic (diag_kind, input_location, 0,
471 "overloaded function with no contextual type information");
473 emit_diagnostic (diag_kind, input_location, 0,
474 "insufficient contextual information to determine type");
482 /* Backward-compatibility interface to incomplete_type_diagnostic;
483 required by ../tree.c. */
484 #undef cxx_incomplete_type_error
486 cxx_incomplete_type_error (const_tree value, const_tree type)
488 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
492 /* The recursive part of split_nonconstant_init. DEST is an lvalue
493 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
494 Return true if the whole of the value was initialized by the
495 generated statements. */
498 split_nonconstant_init_1 (tree dest, tree init)
500 unsigned HOST_WIDE_INT idx;
501 tree field_index, value;
502 tree type = TREE_TYPE (dest);
503 tree inner_type = NULL;
504 bool array_type_p = false;
505 bool complete_p = true;
506 HOST_WIDE_INT num_split_elts = 0;
508 switch (TREE_CODE (type))
511 inner_type = TREE_TYPE (type);
517 case QUAL_UNION_TYPE:
518 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
521 /* The current implementation of this algorithm assumes that
522 the field was set for all the elements. This is usually done
523 by process_init_constructor. */
524 gcc_assert (field_index);
527 inner_type = TREE_TYPE (field_index);
529 if (TREE_CODE (value) == CONSTRUCTOR)
534 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
535 NULL_TREE, NULL_TREE);
537 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
540 if (!split_nonconstant_init_1 (sub, value))
544 else if (!initializer_constant_valid_p (value, inner_type))
549 /* FIXME: Ordered removal is O(1) so the whole function is
550 worst-case quadratic. This could be fixed using an aside
551 bitmap to record which elements must be removed and remove
552 them all at the same time. Or by merging
553 split_non_constant_init into process_init_constructor_array,
554 that is separating constants from non-constants while building
556 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
561 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
562 NULL_TREE, NULL_TREE);
564 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
567 code = build2 (INIT_EXPR, inner_type, sub, value);
568 code = build_stmt (input_location, EXPR_STMT, code);
577 if (!initializer_constant_valid_p (init, type))
580 tree cons = copy_node (init);
581 CONSTRUCTOR_ELTS (init) = NULL;
582 code = build2 (MODIFY_EXPR, type, dest, cons);
583 code = build_stmt (input_location, EXPR_STMT, code);
585 num_split_elts += CONSTRUCTOR_NELTS (init);
593 /* The rest of the initializer is now a constant. */
594 TREE_CONSTANT (init) = 1;
595 return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
596 num_split_elts, inner_type);
599 /* A subroutine of store_init_value. Splits non-constant static
600 initializer INIT into a constant part and generates code to
601 perform the non-constant part of the initialization to DEST.
602 Returns the code for the runtime init. */
605 split_nonconstant_init (tree dest, tree init)
609 if (TREE_CODE (init) == CONSTRUCTOR)
611 code = push_stmt_list ();
612 if (split_nonconstant_init_1 (dest, init))
614 code = pop_stmt_list (code);
615 DECL_INITIAL (dest) = init;
616 TREE_READONLY (dest) = 0;
619 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
624 /* Perform appropriate conversions on the initial value of a variable,
625 store it in the declaration DECL,
626 and print any error messages that are appropriate.
627 If the init is invalid, store an ERROR_MARK.
629 C++: Note that INIT might be a TREE_LIST, which would mean that it is
630 a base class initializer for some aggregate type, hopefully compatible
631 with DECL. If INIT is a single element, and DECL is an aggregate
632 type, we silently convert INIT into a TREE_LIST, allowing a constructor
635 If INIT is a TREE_LIST and there is no constructor, turn INIT
636 into a CONSTRUCTOR and use standard initialization techniques.
637 Perhaps a warning should be generated?
639 Returns code to be executed if initialization could not be performed
640 for static variable. In that case, caller must emit the code. */
643 store_init_value (tree decl, tree init, int flags)
647 /* If variable's type was invalidly declared, just ignore it. */
649 type = TREE_TYPE (decl);
650 if (TREE_CODE (type) == ERROR_MARK)
653 if (MAYBE_CLASS_TYPE_P (type))
655 if (TREE_CODE (init) == TREE_LIST)
657 error ("constructor syntax used, but no constructor declared "
658 "for type %qT", type);
659 init = build_constructor_from_list (init_list_type_node, nreverse (init));
662 else if (TREE_CODE (init) == TREE_LIST
663 && TREE_TYPE (init) != unknown_type_node)
665 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
667 if (TREE_CODE (init) == TREE_LIST
668 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
670 error ("cannot initialize arrays using this syntax");
674 /* We get here with code like `int a (2);' */
675 init = build_x_compound_expr_from_list (init, ELK_INIT,
676 tf_warning_or_error);
679 /* End of special C++ code. */
681 if (flags & LOOKUP_ALREADY_DIGESTED)
684 /* Digest the specified initializer into an expression. */
685 value = digest_init_flags (type, init, flags);
687 /* In C++0x constant expression is a semantic, not syntactic, property.
688 In C++98, make sure that what we thought was a constant expression at
689 template definition time is still constant. */
690 if ((cxx_dialect >= cxx0x
691 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
692 && (decl_maybe_constant_var_p (decl)
693 || TREE_STATIC (decl)))
696 value = fold_non_dependent_expr (value);
697 value = maybe_constant_init (value);
698 if (DECL_DECLARED_CONSTEXPR_P (decl))
699 /* Diagnose a non-constant initializer for constexpr. */
700 value = cxx_constant_value (value);
701 const_init = (reduced_constant_expression_p (value)
702 || error_operand_p (value));
703 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
704 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
707 /* If the initializer is not a constant, fill in DECL_INITIAL with
708 the bits that are constant, and then return an expression that
709 will perform the dynamic initialization. */
710 if (value != error_mark_node
711 && (TREE_SIDE_EFFECTS (value)
712 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
713 return split_nonconstant_init (decl, value);
714 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
715 is an automatic variable, the middle end will turn this into a
716 dynamic initialization later. */
717 DECL_INITIAL (decl) = value;
722 /* Give errors about narrowing conversions within { }. */
725 check_narrowing (tree type, tree init)
727 tree ftype = unlowered_expr_type (init);
731 if (!warn_narrowing || !ARITHMETIC_TYPE_P (type))
734 if (BRACE_ENCLOSED_INITIALIZER_P (init)
735 && TREE_CODE (type) == COMPLEX_TYPE)
737 tree elttype = TREE_TYPE (type);
738 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value);
739 if (CONSTRUCTOR_NELTS (init) > 1)
740 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value);
744 init = maybe_constant_value (init);
746 if (TREE_CODE (type) == INTEGER_TYPE
747 && TREE_CODE (ftype) == REAL_TYPE)
749 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
750 && CP_INTEGRAL_TYPE_P (type))
752 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
753 TYPE_MAX_VALUE (ftype))
754 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
755 TYPE_MIN_VALUE (type)))
756 && (TREE_CODE (init) != INTEGER_CST
757 || !int_fits_type_p (init, type)))
760 else if (TREE_CODE (ftype) == REAL_TYPE
761 && TREE_CODE (type) == REAL_TYPE)
763 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
765 if (TREE_CODE (init) == REAL_CST)
767 /* Issue 703: Loss of precision is OK as long as the value is
768 within the representable range of the new type. */
770 d = TREE_REAL_CST (init);
771 real_convert (&r, TYPE_MODE (type), &d);
779 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
780 && TREE_CODE (type) == REAL_TYPE)
783 if (TREE_CODE (init) == INTEGER_CST)
785 d = real_value_from_int_cst (0, init);
786 if (exact_real_truncate (TYPE_MODE (type), &d))
792 pedwarn (input_location, OPT_Wnarrowing, "narrowing conversion of %qE "
793 "from %qT to %qT inside { }", init, ftype, type);
796 /* Process the initializer INIT for a variable of type TYPE, emitting
797 diagnostics for invalid initializers and converting the initializer as
800 For aggregate types, it assumes that reshape_init has already run, thus the
801 initializer will have the right shape (brace elision has been undone).
803 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
806 digest_init_r (tree type, tree init, bool nested, int flags,
807 tsubst_flags_t complain)
809 enum tree_code code = TREE_CODE (type);
811 if (error_operand_p (init))
812 return error_mark_node;
816 /* We must strip the outermost array type when completing the type,
817 because the its bounds might be incomplete at the moment. */
818 if (!complete_type_or_maybe_complain (TREE_CODE (type) == ARRAY_TYPE
819 ? TREE_TYPE (type) : type, NULL_TREE,
821 return error_mark_node;
823 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
824 (g++.old-deja/g++.law/casts2.C). */
825 if (TREE_CODE (init) == NON_LVALUE_EXPR)
826 init = TREE_OPERAND (init, 0);
828 /* Initialization of an array of chars from a string constant. The initializer
829 can be optionally enclosed in braces, but reshape_init has already removed
830 them if they were present. */
831 if (code == ARRAY_TYPE)
833 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
834 if (char_type_p (typ1)
836 && TREE_CODE (init) == STRING_CST)
838 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
840 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
842 if (char_type != char_type_node)
844 if (complain & tf_error)
845 error ("char-array initialized from wide string");
846 return error_mark_node;
851 if (char_type == char_type_node)
853 if (complain & tf_error)
854 error ("int-array initialized from non-wide string");
855 return error_mark_node;
857 else if (char_type != typ1)
859 if (complain & tf_error)
860 error ("int-array initialized from incompatible "
862 return error_mark_node;
866 TREE_TYPE (init) = type;
867 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
869 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
870 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
871 /* In C it is ok to subtract 1 from the length of the string
872 because it's ok to ignore the terminating null char that is
873 counted in the length of the constant, but in C++ this would
875 if (size < TREE_STRING_LENGTH (init))
876 permerror (input_location, "initializer-string for array "
877 "of chars is too long");
883 /* Handle scalar types (including conversions) and references. */
884 if ((TREE_CODE (type) != COMPLEX_TYPE
885 || BRACE_ENCLOSED_INITIALIZER_P (init))
886 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
890 if (cxx_dialect != cxx98 && nested)
891 check_narrowing (type, init);
892 init = convert_for_initialization (0, type, init, flags,
893 ICR_INIT, NULL_TREE, 0,
897 /* Skip any conversions since we'll be outputting the underlying
899 while (CONVERT_EXPR_P (*exp)
900 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
901 exp = &TREE_OPERAND (*exp, 0);
903 *exp = cplus_expand_constant (*exp);
908 /* Come here only for aggregates: records, arrays, unions, complex numbers
910 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
911 || TREE_CODE (type) == VECTOR_TYPE
912 || TREE_CODE (type) == RECORD_TYPE
913 || TREE_CODE (type) == UNION_TYPE
914 || TREE_CODE (type) == COMPLEX_TYPE);
916 if (BRACE_ENCLOSED_INITIALIZER_P (init)
917 && !TYPE_NON_AGGREGATE_CLASS (type))
918 return process_init_constructor (type, init, complain);
921 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
923 if (complain & tf_error)
924 error ("cannot initialize aggregate of type %qT with "
925 "a compound literal", type);
927 return error_mark_node;
930 if (TREE_CODE (type) == ARRAY_TYPE
931 && !BRACE_ENCLOSED_INITIALIZER_P (init))
933 /* Allow the result of build_array_copy and of
934 build_value_init_noctor. */
935 if ((TREE_CODE (init) == VEC_INIT_EXPR
936 || TREE_CODE (init) == CONSTRUCTOR)
937 && (same_type_ignoring_top_level_qualifiers_p
938 (type, TREE_TYPE (init))))
941 if (complain & tf_error)
942 error ("array must be initialized with a brace-enclosed"
944 return error_mark_node;
947 return convert_for_initialization (NULL_TREE, type, init,
949 ICR_INIT, NULL_TREE, 0,
955 digest_init (tree type, tree init, tsubst_flags_t complain)
957 return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain);
961 digest_init_flags (tree type, tree init, int flags)
963 return digest_init_r (type, init, false, flags, tf_warning_or_error);
966 /* Set of flags used within process_init_constructor to describe the
968 #define PICFLAG_ERRONEOUS 1
969 #define PICFLAG_NOT_ALL_CONSTANT 2
970 #define PICFLAG_NOT_ALL_SIMPLE 4
972 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
976 picflag_from_initializer (tree init)
978 if (init == error_mark_node)
979 return PICFLAG_ERRONEOUS;
980 else if (!TREE_CONSTANT (init))
981 return PICFLAG_NOT_ALL_CONSTANT;
982 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
983 return PICFLAG_NOT_ALL_SIMPLE;
987 /* Subroutine of process_init_constructor, which will process an initializer
988 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
989 which describe the initializers. */
992 process_init_constructor_array (tree type, tree init,
993 tsubst_flags_t complain)
995 unsigned HOST_WIDE_INT i, len = 0;
997 bool unbounded = false;
999 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1001 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1002 || TREE_CODE (type) == VECTOR_TYPE);
1004 if (TREE_CODE (type) == ARRAY_TYPE)
1006 tree domain = TYPE_DOMAIN (type);
1008 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1009 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1012 unbounded = true; /* Take as many as there are. */
1015 /* Vectors are like simple fixed-size arrays. */
1016 len = TYPE_VECTOR_SUBPARTS (type);
1018 /* There must not be more initializers than needed. */
1019 if (!unbounded && VEC_length (constructor_elt, v) > len)
1021 if (complain & tf_error)
1022 error ("too many initializers for %qT", type);
1024 return PICFLAG_ERRONEOUS;
1027 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1031 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1032 if (compare_tree_int (ce->index, i) != 0)
1034 ce->value = error_mark_node;
1035 sorry ("non-trivial designated initializers not supported");
1039 ce->index = size_int (i);
1040 gcc_assert (ce->value);
1041 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true,
1042 LOOKUP_IMPLICIT, complain);
1044 if (ce->value != error_mark_node)
1045 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1046 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1048 flags |= picflag_from_initializer (ce->value);
1051 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1052 we must add initializers ourselves. */
1054 for (; i < len; ++i)
1058 if (type_build_ctor_call (TREE_TYPE (type)))
1060 /* If this type needs constructors run for default-initialization,
1061 we can't rely on the back end to do it for us, so make the
1062 initialization explicit by list-initializing from {}. */
1063 next = build_constructor (init_list_type_node, NULL);
1064 next = digest_init (TREE_TYPE (type), next, complain);
1066 else if (!zero_init_p (TREE_TYPE (type)))
1067 next = build_zero_init (TREE_TYPE (type),
1068 /*nelts=*/NULL_TREE,
1069 /*static_storage_p=*/false);
1071 /* The default zero-initialization is fine for us; don't
1072 add anything to the CONSTRUCTOR. */
1075 flags |= picflag_from_initializer (next);
1076 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1079 CONSTRUCTOR_ELTS (init) = v;
1083 /* Subroutine of process_init_constructor, which will process an initializer
1084 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1085 the initializers. */
1088 process_init_constructor_record (tree type, tree init,
1089 tsubst_flags_t complain)
1091 VEC(constructor_elt,gc) *v = NULL;
1094 unsigned HOST_WIDE_INT idx = 0;
1096 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1097 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1098 gcc_assert (!TYPE_BINFO (type)
1099 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1100 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1102 /* Generally, we will always have an index for each initializer (which is
1103 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1104 reshape_init. So we need to handle both cases. */
1105 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1110 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1112 flags |= picflag_from_initializer (integer_zero_node);
1113 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1117 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1120 /* If this is a bitfield, first convert to the declared type. */
1121 type = TREE_TYPE (field);
1122 if (DECL_BIT_FIELD_TYPE (field))
1123 type = DECL_BIT_FIELD_TYPE (field);
1125 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1127 constructor_elt *ce = VEC_index (constructor_elt,
1128 CONSTRUCTOR_ELTS (init), idx);
1131 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1132 latter case can happen in templates where lookup has to be
1134 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1135 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1136 if (ce->index != field
1137 && ce->index != DECL_NAME (field))
1139 ce->value = error_mark_node;
1140 sorry ("non-trivial designated initializers not supported");
1144 gcc_assert (ce->value);
1145 next = digest_init_r (type, ce->value, true,
1146 LOOKUP_IMPLICIT, complain);
1149 else if (type_build_ctor_call (TREE_TYPE (field)))
1151 /* If this type needs constructors run for
1152 default-initialization, we can't rely on the back end to do it
1153 for us, so build up TARGET_EXPRs. If the type in question is
1154 a class, just build one up; if it's an array, recurse. */
1155 next = build_constructor (init_list_type_node, NULL);
1156 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1158 next = finish_compound_literal (TREE_TYPE (field), next,
1160 /* direct-initialize the target. No temporary is going
1162 if (TREE_CODE (next) == TARGET_EXPR)
1163 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1166 next = digest_init_r (TREE_TYPE (field), next, true,
1167 LOOKUP_IMPLICIT, complain);
1169 /* Warn when some struct elements are implicitly initialized. */
1170 warning (OPT_Wmissing_field_initializers,
1171 "missing initializer for member %qD", field);
1175 if (TREE_READONLY (field))
1177 if (complain & tf_error)
1178 error ("uninitialized const member %qD", field);
1180 return PICFLAG_ERRONEOUS;
1182 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1184 if (complain & tf_error)
1185 error ("member %qD with uninitialized const fields", field);
1187 return PICFLAG_ERRONEOUS;
1189 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1191 if (complain & tf_error)
1192 error ("member %qD is uninitialized reference", field);
1194 return PICFLAG_ERRONEOUS;
1197 /* Warn when some struct elements are implicitly initialized
1199 warning (OPT_Wmissing_field_initializers,
1200 "missing initializer for member %qD", field);
1202 if (!zero_init_p (TREE_TYPE (field)))
1203 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1204 /*static_storage_p=*/false);
1206 /* The default zero-initialization is fine for us; don't
1207 add anything to the CONSTRUCTOR. */
1211 /* If this is a bitfield, now convert to the lowered type. */
1212 if (type != TREE_TYPE (field))
1213 next = cp_convert_and_check (TREE_TYPE (field), next);
1214 flags |= picflag_from_initializer (next);
1215 CONSTRUCTOR_APPEND_ELT (v, field, next);
1218 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1220 if (complain & tf_error)
1221 error ("too many initializers for %qT", type);
1223 return PICFLAG_ERRONEOUS;
1226 CONSTRUCTOR_ELTS (init) = v;
1230 /* Subroutine of process_init_constructor, which will process a single
1231 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1232 which describe the initializer. */
1235 process_init_constructor_union (tree type, tree init,
1236 tsubst_flags_t complain)
1238 constructor_elt *ce;
1241 /* If the initializer was empty, use default zero initialization. */
1242 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1245 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1248 if (!(complain & tf_error))
1249 return PICFLAG_ERRONEOUS;
1250 error ("too many initializers for %qT", type);
1251 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1254 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1256 /* If this element specifies a field, initialize via that field. */
1259 if (TREE_CODE (ce->index) == FIELD_DECL)
1261 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1263 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1264 tree name = ce->index;
1266 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1267 if (DECL_NAME (field) == name)
1271 if (complain & tf_error)
1272 error ("no field %qD found in union being initialized",
1274 ce->value = error_mark_node;
1280 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1281 || TREE_CODE (ce->index) == RANGE_EXPR);
1282 if (complain & tf_error)
1283 error ("index value instead of field name in union initializer");
1284 ce->value = error_mark_node;
1289 /* Find the first named field. ANSI decided in September 1990
1290 that only named fields count here. */
1291 tree field = TYPE_FIELDS (type);
1292 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1293 field = TREE_CHAIN (field);
1294 if (field == NULL_TREE)
1296 if (complain & tf_error)
1297 error ("too many initializers for %qT", type);
1298 ce->value = error_mark_node;
1303 if (ce->value && ce->value != error_mark_node)
1304 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value,
1305 true, LOOKUP_IMPLICIT, complain);
1307 return picflag_from_initializer (ce->value);
1310 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1311 constructor is a brace-enclosed initializer, and will be modified in-place.
1313 Each element is converted to the right type through digest_init, and
1314 missing initializers are added following the language rules (zero-padding,
1317 After the execution, the initializer will have TREE_CONSTANT if all elts are
1318 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1319 constants that the assembler and linker can compute them.
1321 The function returns the initializer itself, or error_mark_node in case
1325 process_init_constructor (tree type, tree init, tsubst_flags_t complain)
1329 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1331 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1332 flags = process_init_constructor_array (type, init, complain);
1333 else if (TREE_CODE (type) == RECORD_TYPE)
1334 flags = process_init_constructor_record (type, init, complain);
1335 else if (TREE_CODE (type) == UNION_TYPE)
1336 flags = process_init_constructor_union (type, init, complain);
1340 if (flags & PICFLAG_ERRONEOUS)
1341 return error_mark_node;
1343 TREE_TYPE (init) = type;
1344 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1345 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1346 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1348 TREE_CONSTANT (init) = 1;
1349 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1350 TREE_STATIC (init) = 1;
1355 /* Given a structure or union value DATUM, construct and return
1356 the structure or union component which results from narrowing
1357 that value to the base specified in BASETYPE. For example, given the
1360 class L { int ii; };
1361 class A : L { ... };
1362 class B : L { ... };
1363 class C : A, B { ... };
1371 x.A::ii refers to the ii member of the L part of
1372 the A part of the C object named by X. In this case,
1373 DATUM would be x, and BASETYPE would be A.
1375 I used to think that this was nonconformant, that the standard specified
1376 that first we look up ii in A, then convert x to an L& and pull out the
1377 ii part. But in fact, it does say that we convert x to an A&; A here
1378 is known as the "naming class". (jason 2000-12-19)
1380 BINFO_P points to a variable initialized either to NULL_TREE or to the
1381 binfo for the specific base subobject we want to convert to. */
1384 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1388 if (datum == error_mark_node)
1389 return error_mark_node;
1393 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1395 if (!binfo || binfo == error_mark_node)
1397 *binfo_p = NULL_TREE;
1399 error_not_base_type (basetype, TREE_TYPE (datum));
1400 return error_mark_node;
1404 return build_base_path (PLUS_EXPR, datum, binfo, 1,
1405 tf_warning_or_error);
1408 /* Build a reference to an object specified by the C++ `->' operator.
1409 Usually this just involves dereferencing the object, but if the
1410 `->' operator is overloaded, then such overloads must be
1411 performed until an object which does not have the `->' operator
1412 overloaded is found. An error is reported when circular pointer
1413 delegation is detected. */
1416 build_x_arrow (tree expr)
1418 tree orig_expr = expr;
1419 tree type = TREE_TYPE (expr);
1420 tree last_rval = NULL_TREE;
1421 VEC(tree,gc) *types_memoized = NULL;
1423 if (type == error_mark_node)
1424 return error_mark_node;
1426 if (processing_template_decl)
1428 if (type_dependent_expression_p (expr))
1429 return build_min_nt (ARROW_EXPR, expr);
1430 expr = build_non_dependent_expr (expr);
1433 if (MAYBE_CLASS_TYPE_P (type))
1435 struct tinst_level *actual_inst = current_instantiation ();
1438 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1439 NULL_TREE, NULL_TREE,
1440 &fn, tf_warning_or_error)))
1442 if (expr == error_mark_node)
1443 return error_mark_node;
1445 if (fn && DECL_USE_TEMPLATE (fn))
1446 push_tinst_level (fn);
1449 if (vec_member (TREE_TYPE (expr), types_memoized))
1451 error ("circular pointer delegation detected");
1452 return error_mark_node;
1455 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1459 while (current_instantiation () != actual_inst)
1462 if (last_rval == NULL_TREE)
1464 error ("base operand of %<->%> has non-pointer type %qT", type);
1465 return error_mark_node;
1468 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1469 last_rval = convert_from_reference (last_rval);
1472 last_rval = decay_conversion (expr);
1474 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1476 if (processing_template_decl)
1478 expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
1480 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
1484 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1488 error ("result of %<operator->()%> yields non-pointer result");
1490 error ("base operand of %<->%> is not a pointer");
1491 return error_mark_node;
1494 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1495 already been checked out to be of aggregate type. */
1498 build_m_component_ref (tree datum, tree component)
1506 if (error_operand_p (datum) || error_operand_p (component))
1507 return error_mark_node;
1509 datum = mark_lvalue_use (datum);
1510 component = mark_rvalue_use (component);
1512 ptrmem_type = TREE_TYPE (component);
1513 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1515 error ("%qE cannot be used as a member pointer, since it is of "
1517 component, ptrmem_type);
1518 return error_mark_node;
1521 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1522 if (! MAYBE_CLASS_TYPE_P (objtype))
1524 error ("cannot apply member pointer %qE to %qE, which is of "
1525 "non-class type %qT",
1526 component, datum, objtype);
1527 return error_mark_node;
1530 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1531 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1533 if (!COMPLETE_TYPE_P (ctype))
1535 if (!same_type_p (ctype, objtype))
1541 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1546 error ("pointer to member type %qT incompatible with object "
1549 return error_mark_node;
1551 else if (binfo == error_mark_node)
1552 return error_mark_node;
1555 if (TYPE_PTRMEM_P (ptrmem_type))
1557 bool is_lval = real_lvalue_p (datum);
1560 /* Compute the type of the field, as described in [expr.ref].
1561 There's no such thing as a mutable pointer-to-member, so
1562 things are not as complex as they are for references to
1563 non-static data members. */
1564 type = cp_build_qualified_type (type,
1565 (cp_type_quals (type)
1566 | cp_type_quals (TREE_TYPE (datum))));
1568 datum = build_address (datum);
1570 /* Convert object to the correct base. */
1572 datum = build_base_path (PLUS_EXPR, datum, binfo, 1,
1573 tf_warning_or_error);
1575 /* Build an expression for "object + offset" where offset is the
1576 value stored in the pointer-to-data-member. */
1577 ptype = build_pointer_type (type);
1578 datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
1579 datum = cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1580 /* If the object expression was an rvalue, return an rvalue. */
1582 datum = move (datum);
1586 return build2 (OFFSET_REF, type, datum, component);
1589 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1592 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1594 /* This is either a call to a constructor,
1595 or a C cast in C++'s `functional' notation. */
1597 /* The type to which we are casting. */
1599 VEC(tree,gc) *parmvec;
1601 if (exp == error_mark_node || parms == error_mark_node)
1602 return error_mark_node;
1604 if (TREE_CODE (exp) == TYPE_DECL)
1605 type = TREE_TYPE (exp);
1609 /* We need to check this explicitly, since value-initialization of
1610 arrays is allowed in other situations. */
1611 if (TREE_CODE (type) == ARRAY_TYPE)
1613 if (complain & tf_error)
1614 error ("functional cast to array type %qT", type);
1615 return error_mark_node;
1618 if (type_uses_auto (type))
1620 if (complain & tf_error)
1621 error ("invalid use of %<auto%>");
1622 type = error_mark_node;
1625 if (processing_template_decl)
1629 /* Diagnose this even in a template. We could also try harder
1630 to give all the usual errors when the type and args are
1632 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1634 if (complain & tf_error)
1635 error ("invalid value-initialization of reference type");
1636 return error_mark_node;
1639 t = build_min (CAST_EXPR, type, parms);
1640 /* We don't know if it will or will not have side effects. */
1641 TREE_SIDE_EFFECTS (t) = 1;
1645 if (! MAYBE_CLASS_TYPE_P (type))
1647 if (parms == NULL_TREE)
1649 if (VOID_TYPE_P (type))
1650 return void_zero_node;
1651 return build_value_init (cv_unqualified (type), complain);
1654 /* This must build a C cast. */
1655 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1656 return cp_build_c_cast (type, parms, complain);
1659 /* Prepare to evaluate as a call to a constructor. If this expression
1660 is actually used, for example,
1662 return X (arg1, arg2, ...);
1664 then the slot being initialized will be filled in. */
1666 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1667 return error_mark_node;
1668 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
1669 return error_mark_node;
1673 If the expression list is a single-expression, the type
1674 conversion is equivalent (in definedness, and if defined in
1675 meaning) to the corresponding cast expression. */
1676 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1677 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1681 The expression T(), where T is a simple-type-specifier for a
1682 non-array complete object type or the (possibly cv-qualified)
1683 void type, creates an rvalue of the specified type, which is
1684 value-initialized. */
1686 if (parms == NULL_TREE)
1688 exp = build_value_init (type, complain);
1689 exp = get_target_expr_sfinae (exp, complain);
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"