1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2017 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization. */
30 #include "coretypes.h"
32 #include "stor-layout.h"
37 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
);
40 /* Print an error message stemming from an attempt to use
41 BASETYPE as a base class for TYPE. */
44 error_not_base_type (tree basetype
, tree type
)
46 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
47 basetype
= DECL_CONTEXT (basetype
);
48 error ("type %qT is not a base type for type %qT", basetype
, type
);
49 return error_mark_node
;
53 binfo_or_else (tree base
, tree type
)
55 tree binfo
= lookup_base (type
, base
, ba_unique
,
56 NULL
, tf_warning_or_error
);
58 if (binfo
== error_mark_node
)
61 error_not_base_type (base
, type
);
65 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
66 value may not be changed thereafter. */
69 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
72 /* This macro is used to emit diagnostics to ensure that all format
73 strings are complete sentences, visible to gettext and checked at
76 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
97 /* Handle C++-specific things first. */
100 && DECL_LANG_SPECIFIC (arg
)
101 && DECL_IN_AGGR_P (arg
)
102 && !TREE_STATIC (arg
))
103 ERROR_FOR_ASSIGNMENT (G_("assignment of "
104 "constant field %qD"),
105 G_("constant field %qD "
106 "used as %<asm%> output"),
108 "constant field %qD"),
110 "constant field %qD"),
112 else if (INDIRECT_REF_P (arg
)
113 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
114 && (VAR_P (TREE_OPERAND (arg
, 0))
115 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
116 ERROR_FOR_ASSIGNMENT (G_("assignment of "
117 "read-only reference %qD"),
118 G_("read-only reference %qD "
119 "used as %<asm%> output"),
121 "read-only reference %qD"),
123 "read-only reference %qD"),
124 TREE_OPERAND (arg
, 0));
126 readonly_error (input_location
, arg
, errstring
);
130 /* Structure that holds information about declarations whose type was
131 incomplete and we could not check whether it was abstract or not. */
133 struct GTY((chain_next ("%h.next"), for_user
)) pending_abstract_type
{
134 /* Declaration which we are checking for abstractness. It is either
135 a DECL node, or an IDENTIFIER_NODE if we do not have a full
136 declaration available. */
139 /* Type which will be checked for abstractness. */
142 /* Kind of use in an unnamed declarator. */
143 enum abstract_class_use use
;
145 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
146 because DECLs already carry locus information. */
149 /* Link to the next element in list. */
150 struct pending_abstract_type
* next
;
153 struct abstract_type_hasher
: ggc_ptr_hash
<pending_abstract_type
>
155 typedef tree compare_type
;
156 static hashval_t
hash (pending_abstract_type
*);
157 static bool equal (pending_abstract_type
*, tree
);
160 /* Compute the hash value of the node VAL. This function is used by the
161 hash table abstract_pending_vars. */
164 abstract_type_hasher::hash (pending_abstract_type
*pat
)
166 return (hashval_t
) TYPE_UID (pat
->type
);
170 /* Compare node VAL1 with the type VAL2. This function is used by the
171 hash table abstract_pending_vars. */
174 abstract_type_hasher::equal (pending_abstract_type
*pat1
, tree type2
)
176 return (pat1
->type
== type2
);
179 /* Hash table that maintains pending_abstract_type nodes, for which we still
180 need to check for type abstractness. The key of the table is the type
181 of the declaration. */
182 static GTY (()) hash_table
<abstract_type_hasher
> *abstract_pending_vars
= NULL
;
184 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
186 /* This function is called after TYPE is completed, and will check if there
187 are pending declarations for which we still need to verify the abstractness
188 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
189 turned out to be incomplete. */
192 complete_type_check_abstract (tree type
)
194 struct pending_abstract_type
*pat
;
195 location_t cur_loc
= input_location
;
197 gcc_assert (COMPLETE_TYPE_P (type
));
199 if (!abstract_pending_vars
)
202 /* Retrieve the list of pending declarations for this type. */
203 pending_abstract_type
**slot
204 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
211 /* If the type is not abstract, do not do anything. */
212 if (CLASSTYPE_PURE_VIRTUALS (type
))
214 struct pending_abstract_type
*prev
= 0, *next
;
216 /* Reverse the list to emit the errors in top-down order. */
217 for (; pat
; pat
= next
)
225 /* Go through the list, and call abstract_virtuals_error for each
226 element: it will issue a diagnostic if the type is abstract. */
229 gcc_assert (type
== pat
->type
);
231 /* Tweak input_location so that the diagnostic appears at the correct
232 location. Notice that this is only needed if the decl is an
234 input_location
= pat
->locus
;
235 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
236 tf_warning_or_error
);
241 abstract_pending_vars
->clear_slot (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, in which case USE specifies
250 the kind of invalid use. Returns 1 if an error occurred; zero if
254 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
255 tsubst_flags_t complain
)
257 vec
<tree
, va_gc
> *pure
;
259 /* This function applies only to classes. Any other entity can never
261 if (!CLASS_TYPE_P (type
))
263 type
= TYPE_MAIN_VARIANT (type
);
266 /* Instantiation here seems to be required by the standard,
267 but breaks e.g. boost::bind. FIXME! */
268 /* In SFINAE, non-N3276 context, force instantiation. */
269 if (!(complain
& (tf_error
|tf_decltype
)))
270 complete_type (type
);
273 /* If the type is incomplete, we register it within a hash table,
274 so that we can check again once it is completed. This makes sense
275 only for objects for which we have a declaration or at least a
277 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
279 struct pending_abstract_type
*pat
;
281 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
283 if (!abstract_pending_vars
)
284 abstract_pending_vars
285 = hash_table
<abstract_type_hasher
>::create_ggc (31);
287 pending_abstract_type
**slot
288 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
291 pat
= ggc_alloc
<pending_abstract_type
> ();
295 pat
->locus
= ((decl
&& DECL_P (decl
))
296 ? DECL_SOURCE_LOCATION (decl
)
305 if (!TYPE_SIZE (type
))
306 /* TYPE is being defined, and during that time
307 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
310 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
314 if (!(complain
& tf_error
))
320 error ("cannot declare variable %q+D to be of abstract "
321 "type %qT", decl
, type
);
322 else if (TREE_CODE (decl
) == PARM_DECL
)
324 if (DECL_NAME (decl
))
325 error ("cannot declare parameter %q+D to be of abstract type %qT",
328 error ("cannot declare parameter to be of abstract type %qT",
331 else if (TREE_CODE (decl
) == FIELD_DECL
)
332 error ("cannot declare field %q+D to be of abstract type %qT",
334 else if (TREE_CODE (decl
) == FUNCTION_DECL
335 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
336 error ("invalid abstract return type for member function %q+#D", decl
);
337 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
338 error ("invalid abstract return type for function %q+#D", decl
);
339 else if (identifier_p (decl
))
340 /* Here we do not have location information. */
341 error ("invalid abstract type %qT for %qE", type
, decl
);
343 error ("invalid abstract type for %q+D", decl
);
348 error ("creating array of %qT, which is an abstract class type", type
);
351 error ("invalid cast to abstract class type %qT", type
);
354 error ("invalid new-expression of abstract class type %qT", type
);
357 error ("invalid abstract return type %qT", type
);
360 error ("invalid abstract parameter type %qT", type
);
363 error ("expression of abstract class type %qT cannot "
364 "be used in throw-expression", type
);
367 error ("cannot declare catch parameter to be of abstract "
368 "class type %qT", type
);
371 error ("cannot allocate an object of abstract type %qT", type
);
374 /* Only go through this once. */
380 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
381 " because the following virtual functions are pure within %qT:",
384 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
385 if (! DECL_CLONED_FUNCTION_P (fn
)
386 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
387 inform (DECL_SOURCE_LOCATION (fn
), "\t%#qD", fn
);
389 /* Now truncate the vector. This leaves it non-null, so we know
390 there are pure virtuals, but empty so we don't list them out
399 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
401 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
405 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
406 tsubst_flags_t complain
)
408 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
412 /* Wrapper for the above function in the common case of wanting errors. */
415 abstract_virtuals_error (tree decl
, tree type
)
417 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
421 abstract_virtuals_error (abstract_class_use use
, tree type
)
423 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
426 /* Print an inform about the declaration of the incomplete type TYPE. */
429 cxx_incomplete_type_inform (const_tree type
)
431 if (!TYPE_MAIN_DECL (type
))
434 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
435 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
437 if (current_class_type
438 && TYPE_BEING_DEFINED (current_class_type
)
439 && same_type_p (ptype
, current_class_type
))
440 inform (loc
, "definition of %q#T is not complete until "
441 "the closing brace", ptype
);
442 else if (!TYPE_TEMPLATE_INFO (ptype
))
443 inform (loc
, "forward declaration of %q#T", ptype
);
445 inform (loc
, "declaration of %q#T", ptype
);
448 /* Print an error message for invalid use of an incomplete type.
449 VALUE is the expression that was used (or 0 if that isn't known)
450 and TYPE is the type that was invalid. DIAG_KIND indicates the
451 type of diagnostic (see diagnostic.def). */
454 cxx_incomplete_type_diagnostic (location_t loc
, const_tree value
,
455 const_tree type
, diagnostic_t diag_kind
)
457 bool is_decl
= false, complained
= false;
459 gcc_assert (diag_kind
== DK_WARNING
460 || diag_kind
== DK_PEDWARN
461 || diag_kind
== DK_ERROR
);
463 /* Avoid duplicate error message. */
464 if (TREE_CODE (type
) == ERROR_MARK
)
467 if (value
!= 0 && (VAR_P (value
)
468 || TREE_CODE (value
) == PARM_DECL
469 || TREE_CODE (value
) == FIELD_DECL
))
471 complained
= emit_diagnostic (diag_kind
, DECL_SOURCE_LOCATION (value
), 0,
472 "%qD has incomplete type", value
);
476 /* We must print an error message. Be clever about what it says. */
478 switch (TREE_CODE (type
))
484 complained
= emit_diagnostic (diag_kind
, loc
, 0,
485 "invalid use of incomplete type %q#T",
488 cxx_incomplete_type_inform (type
);
492 emit_diagnostic (diag_kind
, loc
, 0,
493 "invalid use of %qT", type
);
497 if (TYPE_DOMAIN (type
))
499 type
= TREE_TYPE (type
);
502 emit_diagnostic (diag_kind
, loc
, 0,
503 "invalid use of array with unspecified bounds");
509 tree member
= TREE_OPERAND (value
, 1);
510 if (is_overloaded_fn (member
))
511 member
= get_first_fn (member
);
513 if (DECL_FUNCTION_MEMBER_P (member
)
514 && ! flag_ms_extensions
)
515 emit_diagnostic (diag_kind
, loc
, 0,
516 "invalid use of member function %qD "
517 "(did you forget the %<()%> ?)", member
);
519 emit_diagnostic (diag_kind
, loc
, 0,
520 "invalid use of member %qD "
521 "(did you forget the %<&%> ?)", member
);
525 case TEMPLATE_TYPE_PARM
:
528 if (CLASS_PLACEHOLDER_TEMPLATE (type
))
529 emit_diagnostic (diag_kind
, loc
, 0,
530 "invalid use of placeholder %qT", type
);
532 emit_diagnostic (diag_kind
, loc
, 0,
533 "invalid use of %qT", type
);
536 emit_diagnostic (diag_kind
, loc
, 0,
537 "invalid use of template type parameter %qT", type
);
540 case BOUND_TEMPLATE_TEMPLATE_PARM
:
541 emit_diagnostic (diag_kind
, loc
, 0,
542 "invalid use of template template parameter %qT",
548 emit_diagnostic (diag_kind
, loc
, 0,
549 "invalid use of dependent type %qT", type
);
553 if (type
== init_list_type_node
)
555 emit_diagnostic (diag_kind
, loc
, 0,
556 "invalid use of brace-enclosed initializer list");
559 gcc_assert (type
== unknown_type_node
);
560 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
562 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
563 emit_diagnostic (diag_kind
, loc
, 0,
564 "address of overloaded function with no contextual "
566 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
567 emit_diagnostic (diag_kind
, loc
, 0,
568 "overloaded function with no contextual type information");
570 emit_diagnostic (diag_kind
, loc
, 0,
571 "insufficient contextual information to determine type");
579 /* Print an error message for invalid use of an incomplete type.
580 VALUE is the expression that was used (or 0 if that isn't known)
581 and TYPE is the type that was invalid. */
584 cxx_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
586 cxx_incomplete_type_diagnostic (loc
, value
, type
, DK_ERROR
);
590 /* The recursive part of split_nonconstant_init. DEST is an lvalue
591 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
592 Return true if the whole of the value was initialized by the
593 generated statements. */
596 split_nonconstant_init_1 (tree dest
, tree init
)
598 unsigned HOST_WIDE_INT idx
;
599 tree field_index
, value
;
600 tree type
= TREE_TYPE (dest
);
601 tree inner_type
= NULL
;
602 bool array_type_p
= false;
603 bool complete_p
= true;
604 HOST_WIDE_INT num_split_elts
= 0;
606 switch (TREE_CODE (type
))
609 inner_type
= TREE_TYPE (type
);
611 if ((TREE_SIDE_EFFECTS (init
)
612 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
613 || array_of_runtime_bound_p (type
))
615 /* For an array, we only need/want a single cleanup region rather
616 than one per element. */
617 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
618 tf_warning_or_error
);
626 case QUAL_UNION_TYPE
:
627 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
630 /* The current implementation of this algorithm assumes that
631 the field was set for all the elements. This is usually done
632 by process_init_constructor. */
633 gcc_assert (field_index
);
636 inner_type
= TREE_TYPE (field_index
);
638 if (TREE_CODE (value
) == CONSTRUCTOR
)
643 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
644 NULL_TREE
, NULL_TREE
);
646 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
649 if (!split_nonconstant_init_1 (sub
, value
))
652 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
655 else if (!initializer_constant_valid_p (value
, inner_type
))
660 /* FIXME: Ordered removal is O(1) so the whole function is
661 worst-case quadratic. This could be fixed using an aside
662 bitmap to record which elements must be removed and remove
663 them all at the same time. Or by merging
664 split_non_constant_init into process_init_constructor_array,
665 that is separating constants from non-constants while building
667 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
670 if (TREE_CODE (field_index
) == RANGE_EXPR
)
672 /* Use build_vec_init to initialize a range. */
673 tree low
= TREE_OPERAND (field_index
, 0);
674 tree hi
= TREE_OPERAND (field_index
, 1);
675 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
676 NULL_TREE
, NULL_TREE
);
677 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
678 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
679 code
= build_vec_init (sub
, max
, value
, false, 0,
680 tf_warning_or_error
);
682 if (tree_fits_shwi_p (max
))
683 num_split_elts
+= tree_to_shwi (max
);
688 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
689 NULL_TREE
, NULL_TREE
);
691 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
694 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
695 code
= build_stmt (input_location
, EXPR_STMT
, code
);
696 code
= maybe_cleanup_point_expr_void (code
);
699 = cxx_maybe_build_cleanup (sub
, tf_warning_or_error
))
700 finish_eh_cleanup (cleanup
);
709 if (!initializer_constant_valid_p (init
, type
))
712 tree cons
= copy_node (init
);
713 CONSTRUCTOR_ELTS (init
) = NULL
;
714 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
715 code
= build_stmt (input_location
, EXPR_STMT
, code
);
717 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
725 /* The rest of the initializer is now a constant. */
726 TREE_CONSTANT (init
) = 1;
727 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
728 num_split_elts
, inner_type
);
731 /* A subroutine of store_init_value. Splits non-constant static
732 initializer INIT into a constant part and generates code to
733 perform the non-constant part of the initialization to DEST.
734 Returns the code for the runtime init. */
737 split_nonconstant_init (tree dest
, tree init
)
741 if (TREE_CODE (init
) == TARGET_EXPR
)
742 init
= TARGET_EXPR_INITIAL (init
);
743 if (TREE_CODE (init
) == CONSTRUCTOR
)
745 init
= cp_fully_fold (init
);
746 code
= push_stmt_list ();
747 if (split_nonconstant_init_1 (dest
, init
))
749 code
= pop_stmt_list (code
);
750 DECL_INITIAL (dest
) = init
;
751 TREE_READONLY (dest
) = 0;
753 else if (TREE_CODE (init
) == STRING_CST
754 && array_of_runtime_bound_p (TREE_TYPE (dest
)))
755 code
= build_vec_init (dest
, NULL_TREE
, init
, /*value-init*/false,
756 /*from array*/1, tf_warning_or_error
);
758 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
763 /* Perform appropriate conversions on the initial value of a variable,
764 store it in the declaration DECL,
765 and print any error messages that are appropriate.
766 If the init is invalid, store an ERROR_MARK.
768 C++: Note that INIT might be a TREE_LIST, which would mean that it is
769 a base class initializer for some aggregate type, hopefully compatible
770 with DECL. If INIT is a single element, and DECL is an aggregate
771 type, we silently convert INIT into a TREE_LIST, allowing a constructor
774 If INIT is a TREE_LIST and there is no constructor, turn INIT
775 into a CONSTRUCTOR and use standard initialization techniques.
776 Perhaps a warning should be generated?
778 Returns code to be executed if initialization could not be performed
779 for static variable. In that case, caller must emit the code. */
782 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
786 /* If variable's type was invalidly declared, just ignore it. */
788 type
= TREE_TYPE (decl
);
789 if (TREE_CODE (type
) == ERROR_MARK
)
792 if (MAYBE_CLASS_TYPE_P (type
))
794 if (TREE_CODE (init
) == TREE_LIST
)
796 error ("constructor syntax used, but no constructor declared "
797 "for type %qT", type
);
798 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
802 /* End of special C++ code. */
804 if (flags
& LOOKUP_ALREADY_DIGESTED
)
807 /* Digest the specified initializer into an expression. */
808 value
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
810 value
= extend_ref_init_temps (decl
, value
, cleanups
);
812 /* In C++11 constant expression is a semantic, not syntactic, property.
813 In C++98, make sure that what we thought was a constant expression at
814 template definition time is still constant and otherwise perform this
815 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
816 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
819 value
= instantiate_non_dependent_expr (value
);
820 if (DECL_DECLARED_CONSTEXPR_P (decl
)
821 || (DECL_IN_AGGR_P (decl
) && !DECL_VAR_DECLARED_INLINE_P (decl
)))
823 /* Diagnose a non-constant initializer for constexpr. */
824 if (!require_potential_constant_expression (value
))
825 value
= error_mark_node
;
827 value
= cxx_constant_value (value
, decl
);
829 value
= maybe_constant_init (value
, decl
);
830 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
831 /* Poison this CONSTRUCTOR so it can't be copied to another
832 constexpr variable. */
833 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
834 const_init
= (reduced_constant_expression_p (value
)
835 || error_operand_p (value
));
836 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
837 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
838 if (TREE_CODE (type
) != REFERENCE_TYPE
)
839 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
841 value
= cp_fully_fold (value
);
843 /* Handle aggregate NSDMI in non-constant initializers, too. */
844 value
= replace_placeholders (value
, decl
);
846 /* DECL may change value; purge caches. */
847 clear_cv_and_fold_caches ();
849 /* If the initializer is not a constant, fill in DECL_INITIAL with
850 the bits that are constant, and then return an expression that
851 will perform the dynamic initialization. */
852 if (value
!= error_mark_node
853 && (TREE_SIDE_EFFECTS (value
)
854 || array_of_runtime_bound_p (type
)
855 || ! reduced_constant_expression_p (value
)))
856 return split_nonconstant_init (decl
, value
);
857 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
858 is an automatic variable, the middle end will turn this into a
859 dynamic initialization later. */
860 DECL_INITIAL (decl
) = value
;
865 /* Give diagnostic about narrowing conversions within { }. */
868 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
870 tree ftype
= unlowered_expr_type (init
);
874 if (((!warn_narrowing
|| !(complain
& tf_warning
))
875 && cxx_dialect
== cxx98
)
876 || !ARITHMETIC_TYPE_P (type
))
879 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
880 && TREE_CODE (type
) == COMPLEX_TYPE
)
882 tree elttype
= TREE_TYPE (type
);
883 if (CONSTRUCTOR_NELTS (init
) > 0)
884 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
886 if (CONSTRUCTOR_NELTS (init
) > 1)
887 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
892 init
= fold_non_dependent_expr (init
);
894 if (TREE_CODE (type
) == INTEGER_TYPE
895 && TREE_CODE (ftype
) == REAL_TYPE
)
897 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
898 && CP_INTEGRAL_TYPE_P (type
))
900 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
901 /* Check for narrowing based on the values of the enumeration. */
902 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
903 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
904 TYPE_MAX_VALUE (ftype
))
905 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
906 TYPE_MIN_VALUE (type
)))
907 && (TREE_CODE (init
) != INTEGER_CST
908 || !int_fits_type_p (init
, type
)))
911 else if (TREE_CODE (ftype
) == REAL_TYPE
912 && TREE_CODE (type
) == REAL_TYPE
)
914 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
916 if (TREE_CODE (init
) == REAL_CST
)
918 /* Issue 703: Loss of precision is OK as long as the value is
919 within the representable range of the new type. */
921 d
= TREE_REAL_CST (init
);
922 real_convert (&r
, TYPE_MODE (type
), &d
);
930 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
931 && TREE_CODE (type
) == REAL_TYPE
)
934 if (TREE_CODE (init
) == INTEGER_CST
)
936 d
= real_value_from_int_cst (0, init
);
937 if (exact_real_truncate (TYPE_MODE (type
), &d
))
943 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
945 tree folded
= cp_fully_fold (init
);
946 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
952 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
953 if (cxx_dialect
== cxx98
)
955 if (complain
& tf_warning
)
956 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
957 "from %qH to %qI inside { } is ill-formed in C++11",
961 else if (!CONSTANT_CLASS_P (init
))
963 if (complain
& tf_warning_or_error
)
965 if ((!almost_ok
|| pedantic
)
966 && pedwarn (loc
, OPT_Wnarrowing
,
967 "narrowing conversion of %qE "
968 "from %qH to %qI inside { }",
971 inform (loc
, " the expression has a constant value but is not "
972 "a C++ constant-expression");
976 else if (complain
& tf_error
)
978 int savederrorcount
= errorcount
;
979 global_dc
->pedantic_errors
= 1;
980 pedwarn (loc
, OPT_Wnarrowing
,
981 "narrowing conversion of %qE from %qH to %qI "
982 "inside { }", init
, ftype
, type
);
983 if (errorcount
== savederrorcount
)
985 global_dc
->pedantic_errors
= flag_pedantic_errors
;
992 /* Process the initializer INIT for a variable of type TYPE, emitting
993 diagnostics for invalid initializers and converting the initializer as
996 For aggregate types, it assumes that reshape_init has already run, thus the
997 initializer will have the right shape (brace elision has been undone).
999 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
1002 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
1003 tsubst_flags_t complain
)
1005 enum tree_code code
= TREE_CODE (type
);
1007 if (error_operand_p (init
))
1008 return error_mark_node
;
1012 /* We must strip the outermost array type when completing the type,
1013 because the its bounds might be incomplete at the moment. */
1014 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
1015 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1017 return error_mark_node
;
1019 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1020 (g++.old-deja/g++.law/casts2.C). */
1021 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1022 init
= TREE_OPERAND (init
, 0);
1024 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
1026 /* Initialization of an array of chars from a string constant. The initializer
1027 can be optionally enclosed in braces, but reshape_init has already removed
1028 them if they were present. */
1029 if (code
== ARRAY_TYPE
)
1031 if (nested
&& !TYPE_DOMAIN (type
))
1033 /* C++ flexible array members have a null domain. */
1034 pedwarn (loc
, OPT_Wpedantic
,
1035 "initialization of a flexible array member");
1038 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1039 if (char_type_p (typ1
)
1041 && TREE_CODE (init
) == STRING_CST
)
1043 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1045 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1047 if (char_type
!= char_type_node
)
1049 if (complain
& tf_error
)
1050 error_at (loc
, "char-array initialized from wide string");
1051 return error_mark_node
;
1056 if (char_type
== char_type_node
)
1058 if (complain
& tf_error
)
1060 "int-array initialized from non-wide string");
1061 return error_mark_node
;
1063 else if (char_type
!= typ1
)
1065 if (complain
& tf_error
)
1066 error_at (loc
, "int-array initialized from incompatible "
1068 return error_mark_node
;
1072 if (type
!= TREE_TYPE (init
)
1073 && !variably_modified_type_p (type
, NULL_TREE
))
1075 init
= copy_node (init
);
1076 TREE_TYPE (init
) = type
;
1078 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1080 /* Not a flexible array member. */
1081 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1082 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1083 /* In C it is ok to subtract 1 from the length of the string
1084 because it's ok to ignore the terminating null char that is
1085 counted in the length of the constant, but in C++ this would
1087 if (size
< TREE_STRING_LENGTH (init
))
1088 permerror (loc
, "initializer-string for array "
1089 "of chars is too long");
1095 /* Handle scalar types (including conversions) and references. */
1096 if ((TREE_CODE (type
) != COMPLEX_TYPE
1097 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1098 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1101 flags
|= LOOKUP_NO_NARROWING
;
1102 init
= convert_for_initialization (0, type
, init
, flags
,
1103 ICR_INIT
, NULL_TREE
, 0,
1109 /* Come here only for aggregates: records, arrays, unions, complex numbers
1111 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1112 || VECTOR_TYPE_P (type
)
1113 || TREE_CODE (type
) == RECORD_TYPE
1114 || TREE_CODE (type
) == UNION_TYPE
1115 || TREE_CODE (type
) == COMPLEX_TYPE
);
1117 /* "If T is a class type and the initializer list has a single
1118 element of type cv U, where U is T or a class derived from T,
1119 the object is initialized from that element." */
1121 && cxx_dialect
>= cxx11
1122 && BRACE_ENCLOSED_INITIALIZER_P (init
)
1123 && CONSTRUCTOR_NELTS (init
) == 1
1124 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1125 || VECTOR_TYPE_P (type
)))
1127 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
1128 if (reference_related_p (type
, TREE_TYPE (elt
)))
1129 /* We should have fixed this in reshape_init. */
1133 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1134 && !TYPE_NON_AGGREGATE_CLASS (type
))
1135 return process_init_constructor (type
, init
, complain
);
1138 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1140 if (complain
& tf_error
)
1141 error_at (loc
, "cannot initialize aggregate of type %qT with "
1142 "a compound literal", type
);
1144 return error_mark_node
;
1147 if (TREE_CODE (type
) == ARRAY_TYPE
1148 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1150 /* Allow the result of build_array_copy and of
1151 build_value_init_noctor. */
1152 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1153 || TREE_CODE (init
) == CONSTRUCTOR
)
1154 && (same_type_ignoring_top_level_qualifiers_p
1155 (type
, TREE_TYPE (init
))))
1158 if (complain
& tf_error
)
1159 error_at (loc
, "array must be initialized with a brace-enclosed"
1161 return error_mark_node
;
1164 return convert_for_initialization (NULL_TREE
, type
, init
,
1166 ICR_INIT
, NULL_TREE
, 0,
1172 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1174 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1178 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1180 return digest_init_r (type
, init
, false, flags
, complain
);
1183 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1185 digest_nsdmi_init (tree decl
, tree init
)
1187 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1189 tree type
= TREE_TYPE (decl
);
1190 int flags
= LOOKUP_IMPLICIT
;
1191 if (DIRECT_LIST_INIT_P (init
))
1192 flags
= LOOKUP_NORMAL
;
1193 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1194 && CP_AGGREGATE_TYPE_P (type
))
1195 init
= reshape_init (type
, init
, tf_warning_or_error
);
1196 init
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
1197 if (TREE_CODE (init
) == TARGET_EXPR
)
1198 /* This represents the whole initialization. */
1199 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1203 /* Set of flags used within process_init_constructor to describe the
1205 #define PICFLAG_ERRONEOUS 1
1206 #define PICFLAG_NOT_ALL_CONSTANT 2
1207 #define PICFLAG_NOT_ALL_SIMPLE 4
1208 #define PICFLAG_SIDE_EFFECTS 8
1210 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1214 picflag_from_initializer (tree init
)
1216 if (init
== error_mark_node
)
1217 return PICFLAG_ERRONEOUS
;
1218 else if (!TREE_CONSTANT (init
))
1220 if (TREE_SIDE_EFFECTS (init
))
1221 return PICFLAG_SIDE_EFFECTS
;
1223 return PICFLAG_NOT_ALL_CONSTANT
;
1225 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1226 return PICFLAG_NOT_ALL_SIMPLE
;
1230 /* Adjust INIT for going into a CONSTRUCTOR. */
1233 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1235 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1236 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1237 if (SIMPLE_TARGET_EXPR_P (init
))
1238 init
= TARGET_EXPR_INITIAL (init
);
1239 /* When we defer constant folding within a statement, we may want to
1240 defer this folding as well. */
1241 tree t
= fold_non_dependent_expr (init
);
1242 t
= maybe_constant_init (t
);
1243 if (TREE_CONSTANT (t
))
1248 /* Subroutine of process_init_constructor, which will process an initializer
1249 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1250 which describe the initializers. */
1253 process_init_constructor_array (tree type
, tree init
,
1254 tsubst_flags_t complain
)
1256 unsigned HOST_WIDE_INT i
, len
= 0;
1258 bool unbounded
= false;
1259 constructor_elt
*ce
;
1260 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1262 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1263 || VECTOR_TYPE_P (type
));
1265 if (TREE_CODE (type
) == ARRAY_TYPE
)
1267 /* C++ flexible array members have a null domain. */
1268 tree domain
= TYPE_DOMAIN (type
);
1269 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1270 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1271 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1272 TYPE_PRECISION (TREE_TYPE (domain
)),
1273 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1275 unbounded
= true; /* Take as many as there are. */
1278 /* Vectors are like simple fixed-size arrays. */
1279 len
= TYPE_VECTOR_SUBPARTS (type
);
1281 /* There must not be more initializers than needed. */
1282 if (!unbounded
&& vec_safe_length (v
) > len
)
1284 if (complain
& tf_error
)
1285 error ("too many initializers for %qT", type
);
1287 return PICFLAG_ERRONEOUS
;
1290 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1294 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1295 if (compare_tree_int (ce
->index
, i
) != 0)
1297 ce
->value
= error_mark_node
;
1298 sorry ("non-trivial designated initializers not supported");
1302 ce
->index
= size_int (i
);
1303 gcc_assert (ce
->value
);
1304 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1306 if (ce
->value
!= error_mark_node
)
1307 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1308 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1310 flags
|= picflag_from_initializer (ce
->value
);
1313 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1314 we must add initializers ourselves. */
1316 for (; i
< len
; ++i
)
1320 if (type_build_ctor_call (TREE_TYPE (type
)))
1322 /* If this type needs constructors run for default-initialization,
1323 we can't rely on the back end to do it for us, so make the
1324 initialization explicit by list-initializing from T{}. */
1325 next
= build_constructor (init_list_type_node
, NULL
);
1326 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1327 if (initializer_zerop (next
))
1328 /* The default zero-initialization is fine for us; don't
1329 add anything to the CONSTRUCTOR. */
1332 else if (!zero_init_p (TREE_TYPE (type
)))
1333 next
= build_zero_init (TREE_TYPE (type
),
1334 /*nelts=*/NULL_TREE
,
1335 /*static_storage_p=*/false);
1337 /* The default zero-initialization is fine for us; don't
1338 add anything to the CONSTRUCTOR. */
1343 flags
|= picflag_from_initializer (next
);
1344 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1348 CONSTRUCTOR_ELTS (init
) = v
;
1352 /* Subroutine of process_init_constructor, which will process an initializer
1353 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1354 the initializers. */
1357 process_init_constructor_record (tree type
, tree init
,
1358 tsubst_flags_t complain
)
1360 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1364 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1365 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1366 gcc_assert (!TYPE_BINFO (type
)
1367 || cxx_dialect
>= cxx1z
1368 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1369 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1373 unsigned HOST_WIDE_INT idx
= 0;
1374 /* Generally, we will always have an index for each initializer (which is
1375 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1376 reshape_init. So we need to handle both cases. */
1377 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1382 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1385 if (TREE_CODE (field
) != FIELD_DECL
1386 || (DECL_ARTIFICIAL (field
)
1387 && !(cxx_dialect
>= cxx1z
&& DECL_FIELD_IS_BASE (field
))))
1390 /* If this is a bitfield, first convert to the declared type. */
1391 type
= TREE_TYPE (field
);
1392 if (DECL_BIT_FIELD_TYPE (field
))
1393 type
= DECL_BIT_FIELD_TYPE (field
);
1394 if (type
== error_mark_node
)
1395 return PICFLAG_ERRONEOUS
;
1397 if (idx
< CONSTRUCTOR_NELTS (init
))
1399 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1402 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1403 latter case can happen in templates where lookup has to be
1405 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1406 || identifier_p (ce
->index
));
1407 if (ce
->index
!= field
1408 && ce
->index
!= DECL_NAME (field
))
1410 ce
->value
= error_mark_node
;
1411 sorry ("non-trivial designated initializers not supported");
1415 gcc_assert (ce
->value
);
1416 next
= massage_init_elt (type
, ce
->value
, complain
);
1419 else if (DECL_INITIAL (field
))
1423 /* We're using an NSDMI past a field with implicit
1424 zero-init. Go back and make it explicit. */
1426 vec_safe_truncate (v
, 0);
1429 /* C++14 aggregate NSDMI. */
1430 next
= get_nsdmi (field
, /*ctor*/false);
1432 else if (type_build_ctor_call (TREE_TYPE (field
)))
1434 /* If this type needs constructors run for
1435 default-initialization, we can't rely on the back end to do it
1436 for us, so build up TARGET_EXPRs. If the type in question is
1437 a class, just build one up; if it's an array, recurse. */
1438 next
= build_constructor (init_list_type_node
, NULL
);
1439 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1441 /* Warn when some struct elements are implicitly initialized. */
1442 if ((complain
& tf_warning
)
1443 && !EMPTY_CONSTRUCTOR_P (init
))
1444 warning (OPT_Wmissing_field_initializers
,
1445 "missing initializer for member %qD", field
);
1449 const_tree fldtype
= TREE_TYPE (field
);
1450 if (TREE_CODE (fldtype
) == REFERENCE_TYPE
)
1452 if (complain
& tf_error
)
1453 error ("member %qD is uninitialized reference", field
);
1455 return PICFLAG_ERRONEOUS
;
1457 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1459 if (complain
& tf_error
)
1460 error ("member %qD with uninitialized reference fields", field
);
1462 return PICFLAG_ERRONEOUS
;
1465 /* Warn when some struct elements are implicitly initialized
1466 to zero. However, avoid issuing the warning for flexible
1467 array members since they need not have any elements. */
1468 if ((TREE_CODE (fldtype
) != ARRAY_TYPE
|| TYPE_DOMAIN (fldtype
))
1469 && (complain
& tf_warning
)
1470 && !EMPTY_CONSTRUCTOR_P (init
))
1471 warning (OPT_Wmissing_field_initializers
,
1472 "missing initializer for member %qD", field
);
1474 if (!zero_init_p (fldtype
)
1476 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1477 /*static_storage_p=*/false);
1480 /* The default zero-initialization is fine for us; don't
1481 add anything to the CONSTRUCTOR. */
1487 /* If this is a bitfield, now convert to the lowered type. */
1488 if (type
!= TREE_TYPE (field
))
1489 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1490 flags
|= picflag_from_initializer (next
);
1491 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1494 if (idx
< CONSTRUCTOR_NELTS (init
))
1496 if (complain
& tf_error
)
1497 error ("too many initializers for %qT", type
);
1499 return PICFLAG_ERRONEOUS
;
1502 CONSTRUCTOR_ELTS (init
) = v
;
1506 /* Subroutine of process_init_constructor, which will process a single
1507 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1508 which describe the initializer. */
1511 process_init_constructor_union (tree type
, tree init
,
1512 tsubst_flags_t complain
)
1514 constructor_elt
*ce
;
1517 /* If the initializer was empty, use the union's NSDMI if it has one.
1518 Otherwise use default zero initialization. */
1519 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1521 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1523 if (TREE_CODE (field
) == FIELD_DECL
1524 && DECL_INITIAL (field
) != NULL_TREE
)
1526 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
),
1528 get_nsdmi (field
, /*in_ctor=*/false));
1533 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1537 len
= CONSTRUCTOR_ELTS (init
)->length ();
1540 if (!(complain
& tf_error
))
1541 return PICFLAG_ERRONEOUS
;
1542 error ("too many initializers for %qT", type
);
1543 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1546 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1548 /* If this element specifies a field, initialize via that field. */
1551 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1553 else if (identifier_p (ce
->index
))
1555 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1556 tree name
= ce
->index
;
1558 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1559 if (DECL_NAME (field
) == name
)
1563 if (complain
& tf_error
)
1564 error ("no field %qD found in union being initialized",
1566 ce
->value
= error_mark_node
;
1572 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1573 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1574 if (complain
& tf_error
)
1575 error ("index value instead of field name in union initializer");
1576 ce
->value
= error_mark_node
;
1581 /* Find the first named field. ANSI decided in September 1990
1582 that only named fields count here. */
1583 tree field
= TYPE_FIELDS (type
);
1584 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1585 field
= TREE_CHAIN (field
);
1586 if (field
== NULL_TREE
)
1588 if (complain
& tf_error
)
1589 error ("too many initializers for %qT", type
);
1590 ce
->value
= error_mark_node
;
1595 if (ce
->value
&& ce
->value
!= error_mark_node
)
1596 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1598 return picflag_from_initializer (ce
->value
);
1601 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1602 constructor is a brace-enclosed initializer, and will be modified in-place.
1604 Each element is converted to the right type through digest_init, and
1605 missing initializers are added following the language rules (zero-padding,
1608 After the execution, the initializer will have TREE_CONSTANT if all elts are
1609 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1610 constants that the assembler and linker can compute them.
1612 The function returns the initializer itself, or error_mark_node in case
1616 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1620 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1622 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
1623 flags
= process_init_constructor_array (type
, init
, complain
);
1624 else if (TREE_CODE (type
) == RECORD_TYPE
)
1625 flags
= process_init_constructor_record (type
, init
, complain
);
1626 else if (TREE_CODE (type
) == UNION_TYPE
)
1627 flags
= process_init_constructor_union (type
, init
, complain
);
1631 if (flags
& PICFLAG_ERRONEOUS
)
1632 return error_mark_node
;
1634 TREE_TYPE (init
) = type
;
1635 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1636 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1637 if (flags
& PICFLAG_SIDE_EFFECTS
)
1639 TREE_CONSTANT (init
) = false;
1640 TREE_SIDE_EFFECTS (init
) = true;
1642 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1643 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1644 TREE_CONSTANT (init
) = false;
1647 TREE_CONSTANT (init
) = 1;
1648 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1649 TREE_STATIC (init
) = 1;
1654 /* Given a structure or union value DATUM, construct and return
1655 the structure or union component which results from narrowing
1656 that value to the base specified in BASETYPE. For example, given the
1659 class L { int ii; };
1660 class A : L { ... };
1661 class B : L { ... };
1662 class C : A, B { ... };
1670 x.A::ii refers to the ii member of the L part of
1671 the A part of the C object named by X. In this case,
1672 DATUM would be x, and BASETYPE would be A.
1674 I used to think that this was nonconformant, that the standard specified
1675 that first we look up ii in A, then convert x to an L& and pull out the
1676 ii part. But in fact, it does say that we convert x to an A&; A here
1677 is known as the "naming class". (jason 2000-12-19)
1679 BINFO_P points to a variable initialized either to NULL_TREE or to the
1680 binfo for the specific base subobject we want to convert to. */
1683 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1687 if (datum
== error_mark_node
)
1688 return error_mark_node
;
1692 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1693 NULL
, tf_warning_or_error
);
1695 if (!binfo
|| binfo
== error_mark_node
)
1697 *binfo_p
= NULL_TREE
;
1699 error_not_base_type (basetype
, TREE_TYPE (datum
));
1700 return error_mark_node
;
1704 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1705 tf_warning_or_error
);
1708 /* Build a reference to an object specified by the C++ `->' operator.
1709 Usually this just involves dereferencing the object, but if the
1710 `->' operator is overloaded, then such overloads must be
1711 performed until an object which does not have the `->' operator
1712 overloaded is found. An error is reported when circular pointer
1713 delegation is detected. */
1716 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1718 tree orig_expr
= expr
;
1719 tree type
= TREE_TYPE (expr
);
1720 tree last_rval
= NULL_TREE
;
1721 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1723 if (type
== error_mark_node
)
1724 return error_mark_node
;
1726 if (processing_template_decl
)
1728 if (type
&& TREE_CODE (type
) == POINTER_TYPE
1729 && !dependent_scope_p (TREE_TYPE (type
)))
1730 /* Pointer to current instantiation, don't treat as dependent. */;
1731 else if (type_dependent_expression_p (expr
))
1732 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1733 expr
= build_non_dependent_expr (expr
);
1736 if (MAYBE_CLASS_TYPE_P (type
))
1738 struct tinst_level
*actual_inst
= current_instantiation ();
1741 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1742 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1745 if (expr
== error_mark_node
)
1746 return error_mark_node
;
1748 /* This provides a better instantiation backtrace in case of
1750 if (fn
&& DECL_USE_TEMPLATE (fn
))
1751 push_tinst_level_loc (fn
,
1752 (current_instantiation () != actual_inst
)
1753 ? DECL_SOURCE_LOCATION (fn
)
1757 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1759 if (complain
& tf_error
)
1760 error ("circular pointer delegation detected");
1761 return error_mark_node
;
1764 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1768 while (current_instantiation () != actual_inst
)
1771 if (last_rval
== NULL_TREE
)
1773 if (complain
& tf_error
)
1774 error ("base operand of %<->%> has non-pointer type %qT", type
);
1775 return error_mark_node
;
1778 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1779 last_rval
= convert_from_reference (last_rval
);
1782 last_rval
= decay_conversion (expr
, complain
);
1784 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1786 if (processing_template_decl
)
1788 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1790 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1794 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1797 if (complain
& tf_error
)
1800 error ("result of %<operator->()%> yields non-pointer result");
1802 error ("base operand of %<->%> is not a pointer");
1804 return error_mark_node
;
1807 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1808 already been checked out to be of aggregate type. */
1811 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1819 if (error_operand_p (datum
) || error_operand_p (component
))
1820 return error_mark_node
;
1822 datum
= mark_lvalue_use (datum
);
1823 component
= mark_rvalue_use (component
);
1825 ptrmem_type
= TREE_TYPE (component
);
1826 if (!TYPE_PTRMEM_P (ptrmem_type
))
1828 if (complain
& tf_error
)
1829 error ("%qE cannot be used as a member pointer, since it is of "
1830 "type %qT", component
, ptrmem_type
);
1831 return error_mark_node
;
1834 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1835 if (! MAYBE_CLASS_TYPE_P (objtype
))
1837 if (complain
& tf_error
)
1838 error ("cannot apply member pointer %qE to %qE, which is of "
1839 "non-class type %qT", component
, datum
, objtype
);
1840 return error_mark_node
;
1843 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1844 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1846 if (!COMPLETE_TYPE_P (ctype
))
1848 if (!same_type_p (ctype
, objtype
))
1854 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1859 if (complain
& tf_error
)
1860 error ("pointer to member type %qT incompatible with object "
1861 "type %qT", type
, objtype
);
1862 return error_mark_node
;
1864 else if (binfo
== error_mark_node
)
1865 return error_mark_node
;
1868 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1870 cp_lvalue_kind kind
= lvalue_kind (datum
);
1873 /* Compute the type of the field, as described in [expr.ref].
1874 There's no such thing as a mutable pointer-to-member, so
1875 things are not as complex as they are for references to
1876 non-static data members. */
1877 type
= cp_build_qualified_type (type
,
1878 (cp_type_quals (type
)
1879 | cp_type_quals (TREE_TYPE (datum
))));
1881 datum
= build_address (datum
);
1883 /* Convert object to the correct base. */
1886 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1887 if (datum
== error_mark_node
)
1888 return error_mark_node
;
1891 /* Build an expression for "object + offset" where offset is the
1892 value stored in the pointer-to-data-member. */
1893 ptype
= build_pointer_type (type
);
1894 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1895 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1896 if (datum
== error_mark_node
)
1897 return error_mark_node
;
1899 /* If the object expression was an rvalue, return an rvalue. */
1900 if (kind
& clk_class
)
1901 datum
= rvalue (datum
);
1902 else if (kind
& clk_rvalueref
)
1903 datum
= move (datum
);
1908 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1909 program is ill-formed if the second operand is a pointer to member
1910 function with ref-qualifier &. In a .* expression whose object
1911 expression is an lvalue, the program is ill-formed if the second
1912 operand is a pointer to member function with ref-qualifier &&. */
1913 if (FUNCTION_REF_QUALIFIED (type
))
1915 bool lval
= lvalue_p (datum
);
1916 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1918 if (complain
& tf_error
)
1919 error ("pointer-to-member-function type %qT requires an rvalue",
1921 return error_mark_node
;
1923 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1925 if (complain
& tf_error
)
1926 error ("pointer-to-member-function type %qT requires an lvalue",
1928 return error_mark_node
;
1931 return build2 (OFFSET_REF
, type
, datum
, component
);
1935 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1938 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1940 /* This is either a call to a constructor,
1941 or a C cast in C++'s `functional' notation. */
1943 /* The type to which we are casting. */
1945 vec
<tree
, va_gc
> *parmvec
;
1947 if (error_operand_p (exp
) || parms
== error_mark_node
)
1948 return error_mark_node
;
1950 if (TREE_CODE (exp
) == TYPE_DECL
)
1952 type
= TREE_TYPE (exp
);
1954 if (complain
& tf_warning
1955 && TREE_DEPRECATED (type
)
1956 && DECL_ARTIFICIAL (exp
))
1957 warn_deprecated_use (type
, NULL_TREE
);
1962 /* We need to check this explicitly, since value-initialization of
1963 arrays is allowed in other situations. */
1964 if (TREE_CODE (type
) == ARRAY_TYPE
)
1966 if (complain
& tf_error
)
1967 error ("functional cast to array type %qT", type
);
1968 return error_mark_node
;
1971 if (tree anode
= type_uses_auto (type
))
1973 if (!CLASS_PLACEHOLDER_TEMPLATE (anode
))
1975 if (complain
& tf_error
)
1976 error ("invalid use of %qT", anode
);
1977 return error_mark_node
;
1981 if (complain
& tf_error
)
1982 error ("cannot deduce template arguments for %qT from ()", anode
);
1983 return error_mark_node
;
1986 type
= do_auto_deduction (type
, parms
, anode
, complain
,
1990 if (processing_template_decl
)
1994 /* Diagnose this even in a template. We could also try harder
1995 to give all the usual errors when the type and args are
1997 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1999 if (complain
& tf_error
)
2000 error ("invalid value-initialization of reference type");
2001 return error_mark_node
;
2004 t
= build_min (CAST_EXPR
, type
, parms
);
2005 /* We don't know if it will or will not have side effects. */
2006 TREE_SIDE_EFFECTS (t
) = 1;
2010 if (! MAYBE_CLASS_TYPE_P (type
))
2012 if (parms
== NULL_TREE
)
2014 if (VOID_TYPE_P (type
))
2016 return build_value_init (cv_unqualified (type
), complain
);
2019 /* This must build a C cast. */
2020 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2021 return cp_build_c_cast (type
, parms
, complain
);
2024 /* Prepare to evaluate as a call to a constructor. If this expression
2025 is actually used, for example,
2027 return X (arg1, arg2, ...);
2029 then the slot being initialized will be filled in. */
2031 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2032 return error_mark_node
;
2033 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
2034 return error_mark_node
;
2038 If the expression list is a single-expression, the type
2039 conversion is equivalent (in definedness, and if defined in
2040 meaning) to the corresponding cast expression. */
2041 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2042 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
2046 The expression T(), where T is a simple-type-specifier for a
2047 non-array complete object type or the (possibly cv-qualified)
2048 void type, creates an rvalue of the specified type, which is
2049 value-initialized. */
2051 if (parms
== NULL_TREE
)
2053 exp
= build_value_init (type
, complain
);
2054 exp
= get_target_expr_sfinae (exp
, complain
);
2058 /* Call the constructor. */
2059 parmvec
= make_tree_vector ();
2060 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2061 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2062 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2063 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2064 release_tree_vector (parmvec
);
2066 if (exp
== error_mark_node
)
2067 return error_mark_node
;
2069 return build_cplus_new (type
, exp
, complain
);
2073 /* Add new exception specifier SPEC, to the LIST we currently have.
2074 If it's already in LIST then do nothing.
2075 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2076 know what we're doing. */
2079 add_exception_specifier (tree list
, tree spec
, int complain
)
2084 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2086 if (spec
== error_mark_node
)
2089 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2091 /* [except.spec] 1, type in an exception specifier shall not be
2092 incomplete, or pointer or ref to incomplete other than pointer
2094 is_ptr
= TYPE_PTR_P (core
);
2095 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2096 core
= TREE_TYPE (core
);
2099 else if (VOID_TYPE_P (core
))
2101 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2103 else if (processing_template_decl
)
2108 /* 15.4/1 says that types in an exception specifier must be complete,
2109 but it seems more reasonable to only require this on definitions
2110 and calls. So just give a pedwarn at this point; we will give an
2111 error later if we hit one of those two cases. */
2112 if (!COMPLETE_TYPE_P (complete_type (core
)))
2113 diag_type
= DK_PEDWARN
; /* pedwarn */
2120 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2121 if (same_type_p (TREE_VALUE (probe
), spec
))
2124 list
= tree_cons (NULL_TREE
, spec
, list
);
2127 diag_type
= DK_ERROR
; /* error */
2129 if (diag_type
!= DK_UNSPECIFIED
2130 && (complain
& tf_warning_or_error
))
2131 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2136 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2139 nothrow_spec_p_uninst (const_tree spec
)
2141 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2143 return nothrow_spec_p (spec
);
2146 /* Combine the two exceptions specifier lists LIST and ADD, and return
2150 merge_exception_specifiers (tree list
, tree add
)
2152 tree noex
, orig_list
;
2154 /* No exception-specifier or noexcept(false) are less strict than
2155 anything else. Prefer the newer variant (LIST). */
2156 if (!list
|| list
== noexcept_false_spec
)
2158 else if (!add
|| add
== noexcept_false_spec
)
2161 /* noexcept(true) and throw() are stricter than anything else.
2162 As above, prefer the more recent one (LIST). */
2163 if (nothrow_spec_p_uninst (add
))
2166 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2167 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2168 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2170 /* We should have instantiated other deferred noexcept specs by now. */
2171 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2173 if (nothrow_spec_p_uninst (list
))
2175 noex
= TREE_PURPOSE (list
);
2176 gcc_checking_assert (!TREE_PURPOSE (add
)
2177 || errorcount
|| !flag_exceptions
2178 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2180 /* Combine the dynamic-exception-specifiers, if any. */
2182 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2184 tree spec
= TREE_VALUE (add
);
2187 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2188 probe
= TREE_CHAIN (probe
))
2189 if (same_type_p (TREE_VALUE (probe
), spec
))
2193 spec
= build_tree_list (NULL_TREE
, spec
);
2194 TREE_CHAIN (spec
) = list
;
2199 /* Keep the noexcept-specifier at the beginning of the list. */
2200 if (noex
!= TREE_PURPOSE (list
))
2201 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2206 /* Subroutine of build_call. Ensure that each of the types in the
2207 exception specification is complete. Technically, 15.4/1 says that
2208 they need to be complete when we see a declaration of the function,
2209 but we should be able to get away with only requiring this when the
2210 function is defined or called. See also add_exception_specifier. */
2213 require_complete_eh_spec_types (tree fntype
, tree decl
)
2216 /* Don't complain about calls to op new. */
2217 if (decl
&& DECL_ARTIFICIAL (decl
))
2219 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2220 raises
= TREE_CHAIN (raises
))
2222 tree type
= TREE_VALUE (raises
);
2223 if (type
&& !COMPLETE_TYPE_P (type
))
2227 ("call to function %qD which throws incomplete type %q#T",
2230 error ("call to function which throws incomplete type %q#T",
2237 #include "gt-cp-typeck2.h"