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%#D", 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
);
512 if (DECL_FUNCTION_MEMBER_P (member
)
513 && ! flag_ms_extensions
)
514 emit_diagnostic (diag_kind
, loc
, 0,
515 "invalid use of member function %qD "
516 "(did you forget the %<()%> ?)", member
);
518 emit_diagnostic (diag_kind
, loc
, 0,
519 "invalid use of member %qD "
520 "(did you forget the %<&%> ?)", member
);
524 case TEMPLATE_TYPE_PARM
:
526 emit_diagnostic (diag_kind
, loc
, 0,
527 "invalid use of %<auto%>");
529 emit_diagnostic (diag_kind
, loc
, 0,
530 "invalid use of template type parameter %qT", type
);
533 case BOUND_TEMPLATE_TEMPLATE_PARM
:
534 emit_diagnostic (diag_kind
, loc
, 0,
535 "invalid use of template template parameter %qT",
541 emit_diagnostic (diag_kind
, loc
, 0,
542 "invalid use of dependent type %qT", type
);
546 if (type
== init_list_type_node
)
548 emit_diagnostic (diag_kind
, loc
, 0,
549 "invalid use of brace-enclosed initializer list");
552 gcc_assert (type
== unknown_type_node
);
553 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
555 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
556 emit_diagnostic (diag_kind
, loc
, 0,
557 "address of overloaded function with no contextual "
559 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
560 emit_diagnostic (diag_kind
, loc
, 0,
561 "overloaded function with no contextual type information");
563 emit_diagnostic (diag_kind
, loc
, 0,
564 "insufficient contextual information to determine type");
572 /* Print an error message for invalid use of an incomplete type.
573 VALUE is the expression that was used (or 0 if that isn't known)
574 and TYPE is the type that was invalid. */
577 cxx_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
579 cxx_incomplete_type_diagnostic (loc
, value
, type
, DK_ERROR
);
583 /* The recursive part of split_nonconstant_init. DEST is an lvalue
584 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
585 Return true if the whole of the value was initialized by the
586 generated statements. */
589 split_nonconstant_init_1 (tree dest
, tree init
)
591 unsigned HOST_WIDE_INT idx
;
592 tree field_index
, value
;
593 tree type
= TREE_TYPE (dest
);
594 tree inner_type
= NULL
;
595 bool array_type_p
= false;
596 bool complete_p
= true;
597 HOST_WIDE_INT num_split_elts
= 0;
599 switch (TREE_CODE (type
))
602 inner_type
= TREE_TYPE (type
);
604 if ((TREE_SIDE_EFFECTS (init
)
605 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
606 || array_of_runtime_bound_p (type
))
608 /* For an array, we only need/want a single cleanup region rather
609 than one per element. */
610 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
611 tf_warning_or_error
);
619 case QUAL_UNION_TYPE
:
620 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
623 /* The current implementation of this algorithm assumes that
624 the field was set for all the elements. This is usually done
625 by process_init_constructor. */
626 gcc_assert (field_index
);
629 inner_type
= TREE_TYPE (field_index
);
631 if (TREE_CODE (value
) == CONSTRUCTOR
)
636 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
637 NULL_TREE
, NULL_TREE
);
639 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
642 if (!split_nonconstant_init_1 (sub
, value
))
645 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
648 else if (!initializer_constant_valid_p (value
, inner_type
))
653 /* FIXME: Ordered removal is O(1) so the whole function is
654 worst-case quadratic. This could be fixed using an aside
655 bitmap to record which elements must be removed and remove
656 them all at the same time. Or by merging
657 split_non_constant_init into process_init_constructor_array,
658 that is separating constants from non-constants while building
660 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
663 if (TREE_CODE (field_index
) == RANGE_EXPR
)
665 /* Use build_vec_init to initialize a range. */
666 tree low
= TREE_OPERAND (field_index
, 0);
667 tree hi
= TREE_OPERAND (field_index
, 1);
668 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
669 NULL_TREE
, NULL_TREE
);
670 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
671 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
672 code
= build_vec_init (sub
, max
, value
, false, 0,
673 tf_warning_or_error
);
675 if (tree_fits_shwi_p (max
))
676 num_split_elts
+= tree_to_shwi (max
);
681 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
682 NULL_TREE
, NULL_TREE
);
684 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
687 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
688 code
= build_stmt (input_location
, EXPR_STMT
, code
);
689 code
= maybe_cleanup_point_expr_void (code
);
692 = cxx_maybe_build_cleanup (sub
, tf_warning_or_error
))
693 finish_eh_cleanup (cleanup
);
702 if (!initializer_constant_valid_p (init
, type
))
705 tree cons
= copy_node (init
);
706 CONSTRUCTOR_ELTS (init
) = NULL
;
707 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
708 code
= build_stmt (input_location
, EXPR_STMT
, code
);
710 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
718 /* The rest of the initializer is now a constant. */
719 TREE_CONSTANT (init
) = 1;
720 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
721 num_split_elts
, inner_type
);
724 /* A subroutine of store_init_value. Splits non-constant static
725 initializer INIT into a constant part and generates code to
726 perform the non-constant part of the initialization to DEST.
727 Returns the code for the runtime init. */
730 split_nonconstant_init (tree dest
, tree init
)
734 if (TREE_CODE (init
) == TARGET_EXPR
)
735 init
= TARGET_EXPR_INITIAL (init
);
736 if (TREE_CODE (init
) == CONSTRUCTOR
)
738 init
= cp_fully_fold (init
);
739 code
= push_stmt_list ();
740 if (split_nonconstant_init_1 (dest
, init
))
742 code
= pop_stmt_list (code
);
743 DECL_INITIAL (dest
) = init
;
744 TREE_READONLY (dest
) = 0;
747 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
752 /* Perform appropriate conversions on the initial value of a variable,
753 store it in the declaration DECL,
754 and print any error messages that are appropriate.
755 If the init is invalid, store an ERROR_MARK.
757 C++: Note that INIT might be a TREE_LIST, which would mean that it is
758 a base class initializer for some aggregate type, hopefully compatible
759 with DECL. If INIT is a single element, and DECL is an aggregate
760 type, we silently convert INIT into a TREE_LIST, allowing a constructor
763 If INIT is a TREE_LIST and there is no constructor, turn INIT
764 into a CONSTRUCTOR and use standard initialization techniques.
765 Perhaps a warning should be generated?
767 Returns code to be executed if initialization could not be performed
768 for static variable. In that case, caller must emit the code. */
771 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
775 /* If variable's type was invalidly declared, just ignore it. */
777 type
= TREE_TYPE (decl
);
778 if (TREE_CODE (type
) == ERROR_MARK
)
781 if (MAYBE_CLASS_TYPE_P (type
))
783 if (TREE_CODE (init
) == TREE_LIST
)
785 error ("constructor syntax used, but no constructor declared "
786 "for type %qT", type
);
787 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
791 /* End of special C++ code. */
793 if (flags
& LOOKUP_ALREADY_DIGESTED
)
796 /* Digest the specified initializer into an expression. */
797 value
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
799 value
= extend_ref_init_temps (decl
, value
, cleanups
);
801 /* In C++11 constant expression is a semantic, not syntactic, property.
802 In C++98, make sure that what we thought was a constant expression at
803 template definition time is still constant and otherwise perform this
804 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
805 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
808 value
= instantiate_non_dependent_expr (value
);
809 if (DECL_DECLARED_CONSTEXPR_P (decl
)
810 || (DECL_IN_AGGR_P (decl
) && !DECL_VAR_DECLARED_INLINE_P (decl
)))
812 /* Diagnose a non-constant initializer for constexpr. */
813 if (processing_template_decl
814 && !require_potential_constant_expression (value
))
815 value
= error_mark_node
;
817 value
= cxx_constant_value (value
, decl
);
819 value
= maybe_constant_init (value
, decl
);
820 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
821 /* Poison this CONSTRUCTOR so it can't be copied to another
822 constexpr variable. */
823 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
824 const_init
= (reduced_constant_expression_p (value
)
825 || error_operand_p (value
));
826 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
827 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
828 if (TREE_CODE (type
) != REFERENCE_TYPE
)
829 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
831 value
= cp_fully_fold (value
);
833 if (cxx_dialect
>= cxx14
&& CLASS_TYPE_P (strip_array_types (type
)))
834 /* Handle aggregate NSDMI in non-constant initializers, too. */
835 value
= replace_placeholders (value
, decl
);
837 /* DECL may change value; purge caches. */
838 clear_cv_and_fold_caches ();
840 /* If the initializer is not a constant, fill in DECL_INITIAL with
841 the bits that are constant, and then return an expression that
842 will perform the dynamic initialization. */
843 if (value
!= error_mark_node
844 && (TREE_SIDE_EFFECTS (value
)
845 || array_of_runtime_bound_p (type
)
846 || ! reduced_constant_expression_p (value
)))
847 return split_nonconstant_init (decl
, value
);
848 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
849 is an automatic variable, the middle end will turn this into a
850 dynamic initialization later. */
851 DECL_INITIAL (decl
) = value
;
856 /* Give diagnostic about narrowing conversions within { }. */
859 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
861 tree ftype
= unlowered_expr_type (init
);
865 if (((!warn_narrowing
|| !(complain
& tf_warning
))
866 && cxx_dialect
== cxx98
)
867 || !ARITHMETIC_TYPE_P (type
))
870 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
871 && TREE_CODE (type
) == COMPLEX_TYPE
)
873 tree elttype
= TREE_TYPE (type
);
874 if (CONSTRUCTOR_NELTS (init
) > 0)
875 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
877 if (CONSTRUCTOR_NELTS (init
) > 1)
878 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
883 init
= fold_non_dependent_expr (init
);
885 if (TREE_CODE (type
) == INTEGER_TYPE
886 && TREE_CODE (ftype
) == REAL_TYPE
)
888 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
889 && CP_INTEGRAL_TYPE_P (type
))
891 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
892 /* Check for narrowing based on the values of the enumeration. */
893 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
894 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
895 TYPE_MAX_VALUE (ftype
))
896 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
897 TYPE_MIN_VALUE (type
)))
898 && (TREE_CODE (init
) != INTEGER_CST
899 || !int_fits_type_p (init
, type
)))
902 else if (TREE_CODE (ftype
) == REAL_TYPE
903 && TREE_CODE (type
) == REAL_TYPE
)
905 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
907 if (TREE_CODE (init
) == REAL_CST
)
909 /* Issue 703: Loss of precision is OK as long as the value is
910 within the representable range of the new type. */
912 d
= TREE_REAL_CST (init
);
913 real_convert (&r
, TYPE_MODE (type
), &d
);
921 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
922 && TREE_CODE (type
) == REAL_TYPE
)
925 if (TREE_CODE (init
) == INTEGER_CST
)
927 d
= real_value_from_int_cst (0, init
);
928 if (exact_real_truncate (TYPE_MODE (type
), &d
))
934 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
936 tree folded
= cp_fully_fold (init
);
937 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
943 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
944 if (cxx_dialect
== cxx98
)
946 if (complain
& tf_warning
)
947 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
948 "from %qT to %qT inside { } is ill-formed in C++11",
952 else if (!CONSTANT_CLASS_P (init
))
954 if (complain
& tf_warning_or_error
)
956 if ((!almost_ok
|| pedantic
)
957 && pedwarn (loc
, OPT_Wnarrowing
,
958 "narrowing conversion of %qE "
959 "from %qT to %qT inside { }",
962 inform (loc
, " the expression has a constant value but is not "
963 "a C++ constant-expression");
967 else if (complain
& tf_error
)
969 int savederrorcount
= errorcount
;
970 global_dc
->pedantic_errors
= 1;
971 pedwarn (loc
, OPT_Wnarrowing
,
972 "narrowing conversion of %qE from %qT to %qT "
973 "inside { }", init
, ftype
, type
);
974 if (errorcount
== savederrorcount
)
976 global_dc
->pedantic_errors
= flag_pedantic_errors
;
983 /* Process the initializer INIT for a variable of type TYPE, emitting
984 diagnostics for invalid initializers and converting the initializer as
987 For aggregate types, it assumes that reshape_init has already run, thus the
988 initializer will have the right shape (brace elision has been undone).
990 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
993 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
994 tsubst_flags_t complain
)
996 enum tree_code code
= TREE_CODE (type
);
998 if (error_operand_p (init
))
999 return error_mark_node
;
1003 /* We must strip the outermost array type when completing the type,
1004 because the its bounds might be incomplete at the moment. */
1005 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
1006 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1008 return error_mark_node
;
1010 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1011 (g++.old-deja/g++.law/casts2.C). */
1012 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1013 init
= TREE_OPERAND (init
, 0);
1015 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
1017 /* Initialization of an array of chars from a string constant. The initializer
1018 can be optionally enclosed in braces, but reshape_init has already removed
1019 them if they were present. */
1020 if (code
== ARRAY_TYPE
)
1022 if (nested
&& !TYPE_DOMAIN (type
))
1024 /* C++ flexible array members have a null domain. */
1025 pedwarn (loc
, OPT_Wpedantic
,
1026 "initialization of a flexible array member");
1029 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1030 if (char_type_p (typ1
)
1032 && TREE_CODE (init
) == STRING_CST
)
1034 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1036 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1038 if (char_type
!= char_type_node
)
1040 if (complain
& tf_error
)
1041 error_at (loc
, "char-array initialized from wide string");
1042 return error_mark_node
;
1047 if (char_type
== char_type_node
)
1049 if (complain
& tf_error
)
1051 "int-array initialized from non-wide string");
1052 return error_mark_node
;
1054 else if (char_type
!= typ1
)
1056 if (complain
& tf_error
)
1057 error_at (loc
, "int-array initialized from incompatible "
1059 return error_mark_node
;
1063 if (type
!= TREE_TYPE (init
))
1065 init
= copy_node (init
);
1066 TREE_TYPE (init
) = type
;
1068 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1070 /* Not a flexible array member. */
1071 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1072 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1073 /* In C it is ok to subtract 1 from the length of the string
1074 because it's ok to ignore the terminating null char that is
1075 counted in the length of the constant, but in C++ this would
1077 if (size
< TREE_STRING_LENGTH (init
))
1078 permerror (loc
, "initializer-string for array "
1079 "of chars is too long");
1085 /* Handle scalar types (including conversions) and references. */
1086 if ((TREE_CODE (type
) != COMPLEX_TYPE
1087 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1088 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1091 flags
|= LOOKUP_NO_NARROWING
;
1092 init
= convert_for_initialization (0, type
, init
, flags
,
1093 ICR_INIT
, NULL_TREE
, 0,
1099 /* Come here only for aggregates: records, arrays, unions, complex numbers
1101 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1102 || VECTOR_TYPE_P (type
)
1103 || TREE_CODE (type
) == RECORD_TYPE
1104 || TREE_CODE (type
) == UNION_TYPE
1105 || TREE_CODE (type
) == COMPLEX_TYPE
);
1107 /* "If T is a class type and the initializer list has a single
1108 element of type cv U, where U is T or a class derived from T,
1109 the object is initialized from that element." */
1111 && cxx_dialect
>= cxx11
1112 && BRACE_ENCLOSED_INITIALIZER_P (init
)
1113 && CONSTRUCTOR_NELTS (init
) == 1
1114 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1115 || VECTOR_TYPE_P (type
)))
1117 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
1118 if (reference_related_p (type
, TREE_TYPE (elt
)))
1119 /* We should have fixed this in reshape_init. */
1123 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1124 && !TYPE_NON_AGGREGATE_CLASS (type
))
1125 return process_init_constructor (type
, init
, complain
);
1128 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1130 if (complain
& tf_error
)
1131 error_at (loc
, "cannot initialize aggregate of type %qT with "
1132 "a compound literal", type
);
1134 return error_mark_node
;
1137 if (TREE_CODE (type
) == ARRAY_TYPE
1138 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1140 /* Allow the result of build_array_copy and of
1141 build_value_init_noctor. */
1142 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1143 || TREE_CODE (init
) == CONSTRUCTOR
)
1144 && (same_type_ignoring_top_level_qualifiers_p
1145 (type
, TREE_TYPE (init
))))
1148 if (complain
& tf_error
)
1149 error_at (loc
, "array must be initialized with a brace-enclosed"
1151 return error_mark_node
;
1154 return convert_for_initialization (NULL_TREE
, type
, init
,
1156 ICR_INIT
, NULL_TREE
, 0,
1162 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1164 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1168 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1170 return digest_init_r (type
, init
, false, flags
, complain
);
1173 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1175 digest_nsdmi_init (tree decl
, tree init
)
1177 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1179 tree type
= TREE_TYPE (decl
);
1180 int flags
= LOOKUP_IMPLICIT
;
1181 if (DIRECT_LIST_INIT_P (init
))
1182 flags
= LOOKUP_NORMAL
;
1183 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1184 && CP_AGGREGATE_TYPE_P (type
))
1185 init
= reshape_init (type
, init
, tf_warning_or_error
);
1186 init
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
1187 if (TREE_CODE (init
) == TARGET_EXPR
)
1188 /* This represents the whole initialization. */
1189 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1193 /* Set of flags used within process_init_constructor to describe the
1195 #define PICFLAG_ERRONEOUS 1
1196 #define PICFLAG_NOT_ALL_CONSTANT 2
1197 #define PICFLAG_NOT_ALL_SIMPLE 4
1198 #define PICFLAG_SIDE_EFFECTS 8
1200 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1204 picflag_from_initializer (tree init
)
1206 if (init
== error_mark_node
)
1207 return PICFLAG_ERRONEOUS
;
1208 else if (!TREE_CONSTANT (init
))
1210 if (TREE_SIDE_EFFECTS (init
))
1211 return PICFLAG_SIDE_EFFECTS
;
1213 return PICFLAG_NOT_ALL_CONSTANT
;
1215 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1216 return PICFLAG_NOT_ALL_SIMPLE
;
1220 /* Adjust INIT for going into a CONSTRUCTOR. */
1223 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1225 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1226 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1227 if (SIMPLE_TARGET_EXPR_P (init
))
1228 init
= TARGET_EXPR_INITIAL (init
);
1229 /* When we defer constant folding within a statement, we may want to
1230 defer this folding as well. */
1231 tree t
= fold_non_dependent_expr (init
);
1232 t
= maybe_constant_init (t
);
1233 if (TREE_CONSTANT (t
))
1238 /* Subroutine of process_init_constructor, which will process an initializer
1239 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1240 which describe the initializers. */
1243 process_init_constructor_array (tree type
, tree init
,
1244 tsubst_flags_t complain
)
1246 unsigned HOST_WIDE_INT i
, len
= 0;
1248 bool unbounded
= false;
1249 constructor_elt
*ce
;
1250 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1252 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1253 || VECTOR_TYPE_P (type
));
1255 if (TREE_CODE (type
) == ARRAY_TYPE
)
1257 /* C++ flexible array members have a null domain. */
1258 tree domain
= TYPE_DOMAIN (type
);
1259 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1260 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1261 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1262 TYPE_PRECISION (TREE_TYPE (domain
)),
1263 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1265 unbounded
= true; /* Take as many as there are. */
1268 /* Vectors are like simple fixed-size arrays. */
1269 len
= TYPE_VECTOR_SUBPARTS (type
);
1271 /* There must not be more initializers than needed. */
1272 if (!unbounded
&& vec_safe_length (v
) > len
)
1274 if (complain
& tf_error
)
1275 error ("too many initializers for %qT", type
);
1277 return PICFLAG_ERRONEOUS
;
1280 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1284 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1285 if (compare_tree_int (ce
->index
, i
) != 0)
1287 ce
->value
= error_mark_node
;
1288 sorry ("non-trivial designated initializers not supported");
1292 ce
->index
= size_int (i
);
1293 gcc_assert (ce
->value
);
1294 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1296 if (ce
->value
!= error_mark_node
)
1297 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1298 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1300 flags
|= picflag_from_initializer (ce
->value
);
1303 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1304 we must add initializers ourselves. */
1306 for (; i
< len
; ++i
)
1310 if (type_build_ctor_call (TREE_TYPE (type
)))
1312 /* If this type needs constructors run for default-initialization,
1313 we can't rely on the back end to do it for us, so make the
1314 initialization explicit by list-initializing from T{}. */
1315 next
= build_constructor (init_list_type_node
, NULL
);
1316 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1317 if (initializer_zerop (next
))
1318 /* The default zero-initialization is fine for us; don't
1319 add anything to the CONSTRUCTOR. */
1322 else if (!zero_init_p (TREE_TYPE (type
)))
1323 next
= build_zero_init (TREE_TYPE (type
),
1324 /*nelts=*/NULL_TREE
,
1325 /*static_storage_p=*/false);
1327 /* The default zero-initialization is fine for us; don't
1328 add anything to the CONSTRUCTOR. */
1333 flags
|= picflag_from_initializer (next
);
1334 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1338 CONSTRUCTOR_ELTS (init
) = v
;
1342 /* Subroutine of process_init_constructor, which will process an initializer
1343 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1344 the initializers. */
1347 process_init_constructor_record (tree type
, tree init
,
1348 tsubst_flags_t complain
)
1350 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1354 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1355 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1356 gcc_assert (!TYPE_BINFO (type
)
1357 || cxx_dialect
>= cxx1z
1358 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1359 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1363 unsigned HOST_WIDE_INT idx
= 0;
1364 /* Generally, we will always have an index for each initializer (which is
1365 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1366 reshape_init. So we need to handle both cases. */
1367 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1372 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1375 if (TREE_CODE (field
) != FIELD_DECL
1376 || (DECL_ARTIFICIAL (field
)
1377 && !(cxx_dialect
>= cxx1z
&& DECL_FIELD_IS_BASE (field
))))
1380 /* If this is a bitfield, first convert to the declared type. */
1381 type
= TREE_TYPE (field
);
1382 if (DECL_BIT_FIELD_TYPE (field
))
1383 type
= DECL_BIT_FIELD_TYPE (field
);
1384 if (type
== error_mark_node
)
1385 return PICFLAG_ERRONEOUS
;
1387 if (idx
< CONSTRUCTOR_NELTS (init
))
1389 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1392 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1393 latter case can happen in templates where lookup has to be
1395 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1396 || identifier_p (ce
->index
));
1397 if (ce
->index
!= field
1398 && ce
->index
!= DECL_NAME (field
))
1400 ce
->value
= error_mark_node
;
1401 sorry ("non-trivial designated initializers not supported");
1405 gcc_assert (ce
->value
);
1406 next
= massage_init_elt (type
, ce
->value
, complain
);
1409 else if (DECL_INITIAL (field
))
1413 /* We're using an NSDMI past a field with implicit
1414 zero-init. Go back and make it explicit. */
1416 vec_safe_truncate (v
, 0);
1419 /* C++14 aggregate NSDMI. */
1420 next
= get_nsdmi (field
, /*ctor*/false);
1422 else if (type_build_ctor_call (TREE_TYPE (field
)))
1424 /* If this type needs constructors run for
1425 default-initialization, we can't rely on the back end to do it
1426 for us, so build up TARGET_EXPRs. If the type in question is
1427 a class, just build one up; if it's an array, recurse. */
1428 next
= build_constructor (init_list_type_node
, NULL
);
1429 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1431 /* Warn when some struct elements are implicitly initialized. */
1432 if ((complain
& tf_warning
)
1433 && !EMPTY_CONSTRUCTOR_P (init
))
1434 warning (OPT_Wmissing_field_initializers
,
1435 "missing initializer for member %qD", field
);
1439 const_tree fldtype
= TREE_TYPE (field
);
1440 if (TREE_CODE (fldtype
) == REFERENCE_TYPE
)
1442 if (complain
& tf_error
)
1443 error ("member %qD is uninitialized reference", field
);
1445 return PICFLAG_ERRONEOUS
;
1447 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1449 if (complain
& tf_error
)
1450 error ("member %qD with uninitialized reference fields", field
);
1452 return PICFLAG_ERRONEOUS
;
1455 /* Warn when some struct elements are implicitly initialized
1456 to zero. However, avoid issuing the warning for flexible
1457 array members since they need not have any elements. */
1458 if ((TREE_CODE (fldtype
) != ARRAY_TYPE
|| TYPE_DOMAIN (fldtype
))
1459 && (complain
& tf_warning
)
1460 && !EMPTY_CONSTRUCTOR_P (init
))
1461 warning (OPT_Wmissing_field_initializers
,
1462 "missing initializer for member %qD", field
);
1464 if (!zero_init_p (fldtype
)
1466 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1467 /*static_storage_p=*/false);
1470 /* The default zero-initialization is fine for us; don't
1471 add anything to the CONSTRUCTOR. */
1477 /* If this is a bitfield, now convert to the lowered type. */
1478 if (type
!= TREE_TYPE (field
))
1479 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1480 flags
|= picflag_from_initializer (next
);
1481 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1484 if (idx
< CONSTRUCTOR_NELTS (init
))
1486 if (complain
& tf_error
)
1487 error ("too many initializers for %qT", type
);
1489 return PICFLAG_ERRONEOUS
;
1492 CONSTRUCTOR_ELTS (init
) = v
;
1496 /* Subroutine of process_init_constructor, which will process a single
1497 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1498 which describe the initializer. */
1501 process_init_constructor_union (tree type
, tree init
,
1502 tsubst_flags_t complain
)
1504 constructor_elt
*ce
;
1507 /* If the initializer was empty, use the union's NSDMI if it has one.
1508 Otherwise use default zero initialization. */
1509 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1511 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1513 if (TREE_CODE (field
) == FIELD_DECL
1514 && DECL_INITIAL (field
) != NULL_TREE
)
1516 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
),
1518 get_nsdmi (field
, /*in_ctor=*/false));
1523 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1527 len
= CONSTRUCTOR_ELTS (init
)->length ();
1530 if (!(complain
& tf_error
))
1531 return PICFLAG_ERRONEOUS
;
1532 error ("too many initializers for %qT", type
);
1533 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1536 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1538 /* If this element specifies a field, initialize via that field. */
1541 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1543 else if (identifier_p (ce
->index
))
1545 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1546 tree name
= ce
->index
;
1548 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1549 if (DECL_NAME (field
) == name
)
1553 if (complain
& tf_error
)
1554 error ("no field %qD found in union being initialized",
1556 ce
->value
= error_mark_node
;
1562 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1563 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1564 if (complain
& tf_error
)
1565 error ("index value instead of field name in union initializer");
1566 ce
->value
= error_mark_node
;
1571 /* Find the first named field. ANSI decided in September 1990
1572 that only named fields count here. */
1573 tree field
= TYPE_FIELDS (type
);
1574 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1575 field
= TREE_CHAIN (field
);
1576 if (field
== NULL_TREE
)
1578 if (complain
& tf_error
)
1579 error ("too many initializers for %qT", type
);
1580 ce
->value
= error_mark_node
;
1585 if (ce
->value
&& ce
->value
!= error_mark_node
)
1586 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1588 return picflag_from_initializer (ce
->value
);
1591 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1592 constructor is a brace-enclosed initializer, and will be modified in-place.
1594 Each element is converted to the right type through digest_init, and
1595 missing initializers are added following the language rules (zero-padding,
1598 After the execution, the initializer will have TREE_CONSTANT if all elts are
1599 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1600 constants that the assembler and linker can compute them.
1602 The function returns the initializer itself, or error_mark_node in case
1606 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1610 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1612 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
1613 flags
= process_init_constructor_array (type
, init
, complain
);
1614 else if (TREE_CODE (type
) == RECORD_TYPE
)
1615 flags
= process_init_constructor_record (type
, init
, complain
);
1616 else if (TREE_CODE (type
) == UNION_TYPE
)
1617 flags
= process_init_constructor_union (type
, init
, complain
);
1621 if (flags
& PICFLAG_ERRONEOUS
)
1622 return error_mark_node
;
1624 TREE_TYPE (init
) = type
;
1625 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1626 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1627 if (flags
& PICFLAG_SIDE_EFFECTS
)
1629 TREE_CONSTANT (init
) = false;
1630 TREE_SIDE_EFFECTS (init
) = true;
1632 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1633 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1634 TREE_CONSTANT (init
) = false;
1637 TREE_CONSTANT (init
) = 1;
1638 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1639 TREE_STATIC (init
) = 1;
1644 /* Given a structure or union value DATUM, construct and return
1645 the structure or union component which results from narrowing
1646 that value to the base specified in BASETYPE. For example, given the
1649 class L { int ii; };
1650 class A : L { ... };
1651 class B : L { ... };
1652 class C : A, B { ... };
1660 x.A::ii refers to the ii member of the L part of
1661 the A part of the C object named by X. In this case,
1662 DATUM would be x, and BASETYPE would be A.
1664 I used to think that this was nonconformant, that the standard specified
1665 that first we look up ii in A, then convert x to an L& and pull out the
1666 ii part. But in fact, it does say that we convert x to an A&; A here
1667 is known as the "naming class". (jason 2000-12-19)
1669 BINFO_P points to a variable initialized either to NULL_TREE or to the
1670 binfo for the specific base subobject we want to convert to. */
1673 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1677 if (datum
== error_mark_node
)
1678 return error_mark_node
;
1682 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1683 NULL
, tf_warning_or_error
);
1685 if (!binfo
|| binfo
== error_mark_node
)
1687 *binfo_p
= NULL_TREE
;
1689 error_not_base_type (basetype
, TREE_TYPE (datum
));
1690 return error_mark_node
;
1694 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1695 tf_warning_or_error
);
1698 /* Build a reference to an object specified by the C++ `->' operator.
1699 Usually this just involves dereferencing the object, but if the
1700 `->' operator is overloaded, then such overloads must be
1701 performed until an object which does not have the `->' operator
1702 overloaded is found. An error is reported when circular pointer
1703 delegation is detected. */
1706 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1708 tree orig_expr
= expr
;
1709 tree type
= TREE_TYPE (expr
);
1710 tree last_rval
= NULL_TREE
;
1711 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1713 if (type
== error_mark_node
)
1714 return error_mark_node
;
1716 if (processing_template_decl
)
1718 if (type
&& TREE_CODE (type
) == POINTER_TYPE
1719 && !dependent_scope_p (TREE_TYPE (type
)))
1720 /* Pointer to current instantiation, don't treat as dependent. */;
1721 else if (type_dependent_expression_p (expr
))
1722 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1723 expr
= build_non_dependent_expr (expr
);
1726 if (MAYBE_CLASS_TYPE_P (type
))
1728 struct tinst_level
*actual_inst
= current_instantiation ();
1731 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1732 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1735 if (expr
== error_mark_node
)
1736 return error_mark_node
;
1738 /* This provides a better instantiation backtrace in case of
1740 if (fn
&& DECL_USE_TEMPLATE (fn
))
1741 push_tinst_level_loc (fn
,
1742 (current_instantiation () != actual_inst
)
1743 ? DECL_SOURCE_LOCATION (fn
)
1747 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1749 if (complain
& tf_error
)
1750 error ("circular pointer delegation detected");
1751 return error_mark_node
;
1754 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1758 while (current_instantiation () != actual_inst
)
1761 if (last_rval
== NULL_TREE
)
1763 if (complain
& tf_error
)
1764 error ("base operand of %<->%> has non-pointer type %qT", type
);
1765 return error_mark_node
;
1768 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1769 last_rval
= convert_from_reference (last_rval
);
1772 last_rval
= decay_conversion (expr
, complain
);
1774 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1776 if (processing_template_decl
)
1778 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1780 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1784 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1787 if (complain
& tf_error
)
1790 error ("result of %<operator->()%> yields non-pointer result");
1792 error ("base operand of %<->%> is not a pointer");
1794 return error_mark_node
;
1797 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1798 already been checked out to be of aggregate type. */
1801 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1809 if (error_operand_p (datum
) || error_operand_p (component
))
1810 return error_mark_node
;
1812 datum
= mark_lvalue_use (datum
);
1813 component
= mark_rvalue_use (component
);
1815 ptrmem_type
= TREE_TYPE (component
);
1816 if (!TYPE_PTRMEM_P (ptrmem_type
))
1818 if (complain
& tf_error
)
1819 error ("%qE cannot be used as a member pointer, since it is of "
1820 "type %qT", component
, ptrmem_type
);
1821 return error_mark_node
;
1824 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1825 if (! MAYBE_CLASS_TYPE_P (objtype
))
1827 if (complain
& tf_error
)
1828 error ("cannot apply member pointer %qE to %qE, which is of "
1829 "non-class type %qT", component
, datum
, objtype
);
1830 return error_mark_node
;
1833 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1834 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1836 if (!COMPLETE_TYPE_P (ctype
))
1838 if (!same_type_p (ctype
, objtype
))
1844 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1849 if (complain
& tf_error
)
1850 error ("pointer to member type %qT incompatible with object "
1851 "type %qT", type
, objtype
);
1852 return error_mark_node
;
1854 else if (binfo
== error_mark_node
)
1855 return error_mark_node
;
1858 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1860 cp_lvalue_kind kind
= lvalue_kind (datum
);
1863 /* Compute the type of the field, as described in [expr.ref].
1864 There's no such thing as a mutable pointer-to-member, so
1865 things are not as complex as they are for references to
1866 non-static data members. */
1867 type
= cp_build_qualified_type (type
,
1868 (cp_type_quals (type
)
1869 | cp_type_quals (TREE_TYPE (datum
))));
1871 datum
= build_address (datum
);
1873 /* Convert object to the correct base. */
1876 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1877 if (datum
== error_mark_node
)
1878 return error_mark_node
;
1881 /* Build an expression for "object + offset" where offset is the
1882 value stored in the pointer-to-data-member. */
1883 ptype
= build_pointer_type (type
);
1884 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1885 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1886 if (datum
== error_mark_node
)
1887 return error_mark_node
;
1889 /* If the object expression was an rvalue, return an rvalue. */
1890 if (kind
& clk_class
)
1891 datum
= rvalue (datum
);
1892 else if (kind
& clk_rvalueref
)
1893 datum
= move (datum
);
1898 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1899 program is ill-formed if the second operand is a pointer to member
1900 function with ref-qualifier &. In a .* expression whose object
1901 expression is an lvalue, the program is ill-formed if the second
1902 operand is a pointer to member function with ref-qualifier &&. */
1903 if (FUNCTION_REF_QUALIFIED (type
))
1905 bool lval
= lvalue_p (datum
);
1906 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1908 if (complain
& tf_error
)
1909 error ("pointer-to-member-function type %qT requires an rvalue",
1911 return error_mark_node
;
1913 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1915 if (complain
& tf_error
)
1916 error ("pointer-to-member-function type %qT requires an lvalue",
1918 return error_mark_node
;
1921 return build2 (OFFSET_REF
, type
, datum
, component
);
1925 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1928 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1930 /* This is either a call to a constructor,
1931 or a C cast in C++'s `functional' notation. */
1933 /* The type to which we are casting. */
1935 vec
<tree
, va_gc
> *parmvec
;
1937 if (error_operand_p (exp
) || parms
== error_mark_node
)
1938 return error_mark_node
;
1940 if (TREE_CODE (exp
) == TYPE_DECL
)
1942 type
= TREE_TYPE (exp
);
1944 if (complain
& tf_warning
1945 && TREE_DEPRECATED (type
)
1946 && DECL_ARTIFICIAL (exp
))
1947 warn_deprecated_use (type
, NULL_TREE
);
1952 /* We need to check this explicitly, since value-initialization of
1953 arrays is allowed in other situations. */
1954 if (TREE_CODE (type
) == ARRAY_TYPE
)
1956 if (complain
& tf_error
)
1957 error ("functional cast to array type %qT", type
);
1958 return error_mark_node
;
1961 if (tree anode
= type_uses_auto (type
))
1963 if (!CLASS_PLACEHOLDER_TEMPLATE (anode
))
1965 if (complain
& tf_error
)
1966 error ("invalid use of %qT", anode
);
1967 return error_mark_node
;
1971 if (complain
& tf_error
)
1972 error ("cannot deduce template arguments for %qT from ()", anode
);
1973 return error_mark_node
;
1976 type
= do_auto_deduction (type
, parms
, anode
, complain
,
1980 if (processing_template_decl
)
1984 /* Diagnose this even in a template. We could also try harder
1985 to give all the usual errors when the type and args are
1987 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1989 if (complain
& tf_error
)
1990 error ("invalid value-initialization of reference type");
1991 return error_mark_node
;
1994 t
= build_min (CAST_EXPR
, type
, parms
);
1995 /* We don't know if it will or will not have side effects. */
1996 TREE_SIDE_EFFECTS (t
) = 1;
2000 if (! MAYBE_CLASS_TYPE_P (type
))
2002 if (parms
== NULL_TREE
)
2004 if (VOID_TYPE_P (type
))
2006 return build_value_init (cv_unqualified (type
), complain
);
2009 /* This must build a C cast. */
2010 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2011 return cp_build_c_cast (type
, parms
, complain
);
2014 /* Prepare to evaluate as a call to a constructor. If this expression
2015 is actually used, for example,
2017 return X (arg1, arg2, ...);
2019 then the slot being initialized will be filled in. */
2021 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2022 return error_mark_node
;
2023 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
2024 return error_mark_node
;
2028 If the expression list is a single-expression, the type
2029 conversion is equivalent (in definedness, and if defined in
2030 meaning) to the corresponding cast expression. */
2031 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2032 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
2036 The expression T(), where T is a simple-type-specifier for a
2037 non-array complete object type or the (possibly cv-qualified)
2038 void type, creates an rvalue of the specified type, which is
2039 value-initialized. */
2041 if (parms
== NULL_TREE
)
2043 exp
= build_value_init (type
, complain
);
2044 exp
= get_target_expr_sfinae (exp
, complain
);
2048 /* Call the constructor. */
2049 parmvec
= make_tree_vector ();
2050 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2051 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2052 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2053 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2054 release_tree_vector (parmvec
);
2056 if (exp
== error_mark_node
)
2057 return error_mark_node
;
2059 return build_cplus_new (type
, exp
, complain
);
2063 /* Add new exception specifier SPEC, to the LIST we currently have.
2064 If it's already in LIST then do nothing.
2065 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2066 know what we're doing. */
2069 add_exception_specifier (tree list
, tree spec
, int complain
)
2074 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2076 if (spec
== error_mark_node
)
2079 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2081 /* [except.spec] 1, type in an exception specifier shall not be
2082 incomplete, or pointer or ref to incomplete other than pointer
2084 is_ptr
= TYPE_PTR_P (core
);
2085 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2086 core
= TREE_TYPE (core
);
2089 else if (VOID_TYPE_P (core
))
2091 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2093 else if (processing_template_decl
)
2098 /* 15.4/1 says that types in an exception specifier must be complete,
2099 but it seems more reasonable to only require this on definitions
2100 and calls. So just give a pedwarn at this point; we will give an
2101 error later if we hit one of those two cases. */
2102 if (!COMPLETE_TYPE_P (complete_type (core
)))
2103 diag_type
= DK_PEDWARN
; /* pedwarn */
2110 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2111 if (same_type_p (TREE_VALUE (probe
), spec
))
2114 list
= tree_cons (NULL_TREE
, spec
, list
);
2117 diag_type
= DK_ERROR
; /* error */
2119 if (diag_type
!= DK_UNSPECIFIED
2120 && (complain
& tf_warning_or_error
))
2121 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2126 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2129 nothrow_spec_p_uninst (const_tree spec
)
2131 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2133 return nothrow_spec_p (spec
);
2136 /* Combine the two exceptions specifier lists LIST and ADD, and return
2140 merge_exception_specifiers (tree list
, tree add
)
2142 tree noex
, orig_list
;
2144 /* No exception-specifier or noexcept(false) are less strict than
2145 anything else. Prefer the newer variant (LIST). */
2146 if (!list
|| list
== noexcept_false_spec
)
2148 else if (!add
|| add
== noexcept_false_spec
)
2151 /* noexcept(true) and throw() are stricter than anything else.
2152 As above, prefer the more recent one (LIST). */
2153 if (nothrow_spec_p_uninst (add
))
2156 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2157 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2158 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2160 /* We should have instantiated other deferred noexcept specs by now. */
2161 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2163 if (nothrow_spec_p_uninst (list
))
2165 noex
= TREE_PURPOSE (list
);
2166 gcc_checking_assert (!TREE_PURPOSE (add
)
2167 || errorcount
|| !flag_exceptions
2168 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2170 /* Combine the dynamic-exception-specifiers, if any. */
2172 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2174 tree spec
= TREE_VALUE (add
);
2177 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2178 probe
= TREE_CHAIN (probe
))
2179 if (same_type_p (TREE_VALUE (probe
), spec
))
2183 spec
= build_tree_list (NULL_TREE
, spec
);
2184 TREE_CHAIN (spec
) = list
;
2189 /* Keep the noexcept-specifier at the beginning of the list. */
2190 if (noex
!= TREE_PURPOSE (list
))
2191 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2196 /* Subroutine of build_call. Ensure that each of the types in the
2197 exception specification is complete. Technically, 15.4/1 says that
2198 they need to be complete when we see a declaration of the function,
2199 but we should be able to get away with only requiring this when the
2200 function is defined or called. See also add_exception_specifier. */
2203 require_complete_eh_spec_types (tree fntype
, tree decl
)
2206 /* Don't complain about calls to op new. */
2207 if (decl
&& DECL_ARTIFICIAL (decl
))
2209 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2210 raises
= TREE_CHAIN (raises
))
2212 tree type
= TREE_VALUE (raises
);
2213 if (type
&& !COMPLETE_TYPE_P (type
))
2217 ("call to function %qD which throws incomplete type %q#T",
2220 error ("call to function which throws incomplete type %q#T",
2227 #include "gt-cp-typeck2.h"