1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2019 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"
35 #include "gcc-rich-location.h"
38 process_init_constructor (tree type
, tree init
, int nested
, int flags
,
39 tsubst_flags_t complain
);
42 /* Print an error message stemming from an attempt to use
43 BASETYPE as a base class for TYPE. */
46 error_not_base_type (tree basetype
, tree type
)
48 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
49 basetype
= DECL_CONTEXT (basetype
);
50 error ("type %qT is not a base type for type %qT", basetype
, type
);
51 return error_mark_node
;
55 binfo_or_else (tree base
, tree type
)
57 tree binfo
= lookup_base (type
, base
, ba_unique
,
58 NULL
, tf_warning_or_error
);
60 if (binfo
== error_mark_node
)
63 error_not_base_type (base
, type
);
67 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
68 value may not be changed thereafter. */
71 cxx_readonly_error (location_t loc
, tree arg
, enum lvalue_use errstring
)
74 /* This macro is used to emit diagnostics to ensure that all format
75 strings are complete sentences, visible to gettext and checked at
78 #define ERROR_FOR_ASSIGNMENT(LOC, AS, ASM, IN, DE, ARG) \
83 error_at (LOC, AS, ARG); \
86 error_at (LOC, ASM, ARG); \
89 error_at (LOC, IN, ARG); \
92 error_at (LOC, DE, ARG); \
99 /* Handle C++-specific things first. */
102 && DECL_LANG_SPECIFIC (arg
)
103 && DECL_IN_AGGR_P (arg
)
104 && !TREE_STATIC (arg
))
105 ERROR_FOR_ASSIGNMENT (loc
,
106 G_("assignment of constant field %qD"),
107 G_("constant field %qD used as %<asm%> output"),
108 G_("increment of constant field %qD"),
109 G_("decrement of constant field %qD"),
111 else if (INDIRECT_REF_P (arg
)
112 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (arg
, 0)))
113 && (VAR_P (TREE_OPERAND (arg
, 0))
114 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
115 ERROR_FOR_ASSIGNMENT (loc
,
116 G_("assignment of read-only reference %qD"),
117 G_("read-only reference %qD used as %<asm%> output"),
118 G_("increment of read-only reference %qD"),
119 G_("decrement of read-only reference %qD"),
120 TREE_OPERAND (arg
, 0));
122 readonly_error (loc
, arg
, errstring
);
125 /* Structure that holds information about declarations whose type was
126 incomplete and we could not check whether it was abstract or not. */
128 struct GTY((chain_next ("%h.next"), for_user
)) pending_abstract_type
{
129 /* Declaration which we are checking for abstractness. It is either
130 a DECL node, or an IDENTIFIER_NODE if we do not have a full
131 declaration available. */
134 /* Type which will be checked for abstractness. */
137 /* Kind of use in an unnamed declarator. */
138 enum abstract_class_use use
;
140 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
141 because DECLs already carry locus information. */
144 /* Link to the next element in list. */
145 struct pending_abstract_type
* next
;
148 struct abstract_type_hasher
: ggc_ptr_hash
<pending_abstract_type
>
150 typedef tree compare_type
;
151 static hashval_t
hash (pending_abstract_type
*);
152 static bool equal (pending_abstract_type
*, tree
);
155 /* Compute the hash value of the node VAL. This function is used by the
156 hash table abstract_pending_vars. */
159 abstract_type_hasher::hash (pending_abstract_type
*pat
)
161 return (hashval_t
) TYPE_UID (pat
->type
);
165 /* Compare node VAL1 with the type VAL2. This function is used by the
166 hash table abstract_pending_vars. */
169 abstract_type_hasher::equal (pending_abstract_type
*pat1
, tree type2
)
171 return (pat1
->type
== type2
);
174 /* Hash table that maintains pending_abstract_type nodes, for which we still
175 need to check for type abstractness. The key of the table is the type
176 of the declaration. */
177 static GTY (()) hash_table
<abstract_type_hasher
> *abstract_pending_vars
= NULL
;
179 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
181 /* This function is called after TYPE is completed, and will check if there
182 are pending declarations for which we still need to verify the abstractness
183 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
184 turned out to be incomplete. */
187 complete_type_check_abstract (tree type
)
189 struct pending_abstract_type
*pat
;
190 location_t cur_loc
= input_location
;
192 gcc_assert (COMPLETE_TYPE_P (type
));
194 if (!abstract_pending_vars
)
197 /* Retrieve the list of pending declarations for this type. */
198 pending_abstract_type
**slot
199 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
206 /* If the type is not abstract, do not do anything. */
207 if (CLASSTYPE_PURE_VIRTUALS (type
))
209 struct pending_abstract_type
*prev
= 0, *next
;
211 /* Reverse the list to emit the errors in top-down order. */
212 for (; pat
; pat
= next
)
220 /* Go through the list, and call abstract_virtuals_error for each
221 element: it will issue a diagnostic if the type is abstract. */
224 gcc_assert (type
== pat
->type
);
226 /* Tweak input_location so that the diagnostic appears at the correct
227 location. Notice that this is only needed if the decl is an
229 input_location
= pat
->locus
;
230 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
231 tf_warning_or_error
);
236 abstract_pending_vars
->clear_slot (slot
);
238 input_location
= cur_loc
;
242 /* If TYPE has abstract virtual functions, issue an error about trying
243 to create an object of that type. DECL is the object declared, or
244 NULL_TREE if the declaration is unavailable, in which case USE specifies
245 the kind of invalid use. Returns 1 if an error occurred; zero if
249 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
250 tsubst_flags_t complain
)
252 vec
<tree
, va_gc
> *pure
;
254 /* This function applies only to classes. Any other entity can never
256 if (!CLASS_TYPE_P (type
))
258 type
= TYPE_MAIN_VARIANT (type
);
261 /* Instantiation here seems to be required by the standard,
262 but breaks e.g. boost::bind. FIXME! */
263 /* In SFINAE, non-N3276 context, force instantiation. */
264 if (!(complain
& (tf_error
|tf_decltype
)))
265 complete_type (type
);
268 /* If the type is incomplete, we register it within a hash table,
269 so that we can check again once it is completed. This makes sense
270 only for objects for which we have a declaration or at least a
272 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
274 struct pending_abstract_type
*pat
;
276 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
278 if (!abstract_pending_vars
)
279 abstract_pending_vars
280 = hash_table
<abstract_type_hasher
>::create_ggc (31);
282 pending_abstract_type
**slot
283 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
286 pat
= ggc_alloc
<pending_abstract_type
> ();
290 pat
->locus
= ((decl
&& DECL_P (decl
))
291 ? DECL_SOURCE_LOCATION (decl
)
300 if (!TYPE_SIZE (type
))
301 /* TYPE is being defined, and during that time
302 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
305 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
309 if (!(complain
& tf_error
))
312 auto_diagnostic_group d
;
316 error ("cannot declare variable %q+D to be of abstract "
317 "type %qT", decl
, type
);
318 else if (TREE_CODE (decl
) == PARM_DECL
)
320 if (DECL_NAME (decl
))
321 error ("cannot declare parameter %q+D to be of abstract type %qT",
324 error ("cannot declare parameter to be of abstract type %qT",
327 else if (TREE_CODE (decl
) == FIELD_DECL
)
328 error ("cannot declare field %q+D to be of abstract type %qT",
330 else if (TREE_CODE (decl
) == FUNCTION_DECL
331 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
332 error ("invalid abstract return type for member function %q+#D", decl
);
333 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
334 error ("invalid abstract return type for function %q+#D", decl
);
335 else if (identifier_p (decl
))
336 /* Here we do not have location information. */
337 error ("invalid abstract type %qT for %qE", type
, decl
);
339 error ("invalid abstract type for %q+D", decl
);
344 error ("creating array of %qT, which is an abstract class type", type
);
347 error ("invalid cast to abstract class type %qT", type
);
350 error ("invalid new-expression of abstract class type %qT", type
);
353 error ("invalid abstract return type %qT", type
);
356 error ("invalid abstract parameter type %qT", type
);
359 error ("expression of abstract class type %qT cannot "
360 "be used in throw-expression", type
);
363 error ("cannot declare %<catch%> parameter to be of abstract "
364 "class type %qT", type
);
367 error ("cannot allocate an object of abstract type %qT", type
);
370 /* Only go through this once. */
376 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
377 " because the following virtual functions are pure within %qT:",
380 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
381 if (! DECL_CLONED_FUNCTION_P (fn
)
382 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
383 inform (DECL_SOURCE_LOCATION (fn
), " %#qD", fn
);
385 /* Now truncate the vector. This leaves it non-null, so we know
386 there are pure virtuals, but empty so we don't list them out
395 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
397 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
401 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
402 tsubst_flags_t complain
)
404 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
408 /* Wrapper for the above function in the common case of wanting errors. */
411 abstract_virtuals_error (tree decl
, tree type
)
413 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
417 abstract_virtuals_error (abstract_class_use use
, tree type
)
419 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
422 /* Print an inform about the declaration of the incomplete type TYPE. */
425 cxx_incomplete_type_inform (const_tree type
)
427 if (!TYPE_MAIN_DECL (type
))
430 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
431 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
433 if (current_class_type
434 && TYPE_BEING_DEFINED (current_class_type
)
435 && same_type_p (ptype
, current_class_type
))
436 inform (loc
, "definition of %q#T is not complete until "
437 "the closing brace", ptype
);
438 else if (!TYPE_TEMPLATE_INFO (ptype
))
439 inform (loc
, "forward declaration of %q#T", ptype
);
441 inform (loc
, "declaration of %q#T", ptype
);
444 /* Print an error message for invalid use of an incomplete type.
445 VALUE is the expression that was used (or 0 if that isn't known)
446 and TYPE is the type that was invalid. DIAG_KIND indicates the
447 type of diagnostic (see diagnostic.def). */
450 cxx_incomplete_type_diagnostic (location_t loc
, const_tree value
,
451 const_tree type
, diagnostic_t diag_kind
)
453 bool is_decl
= false, complained
= false;
455 gcc_assert (diag_kind
== DK_WARNING
456 || diag_kind
== DK_PEDWARN
457 || diag_kind
== DK_ERROR
);
459 /* Avoid duplicate error message. */
460 if (TREE_CODE (type
) == ERROR_MARK
)
465 STRIP_ANY_LOCATION_WRAPPER (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
);
477 /* We must print an error message. Be clever about what it says. */
479 switch (TREE_CODE (type
))
485 complained
= emit_diagnostic (diag_kind
, loc
, 0,
486 "invalid use of incomplete type %q#T",
489 cxx_incomplete_type_inform (type
);
493 emit_diagnostic (diag_kind
, loc
, 0,
494 "invalid use of %qT", type
);
498 if (TYPE_DOMAIN (type
))
500 type
= TREE_TYPE (type
);
503 emit_diagnostic (diag_kind
, loc
, 0,
504 "invalid use of array with unspecified bounds");
510 tree member
= TREE_OPERAND (value
, 1);
511 if (is_overloaded_fn (member
))
512 member
= get_first_fn (member
);
514 if (DECL_FUNCTION_MEMBER_P (member
)
515 && ! flag_ms_extensions
)
517 gcc_rich_location
richloc (loc
);
518 /* If "member" has no arguments (other than "this"), then
519 add a fix-it hint. */
520 if (type_num_arguments (TREE_TYPE (member
)) == 1)
521 richloc
.add_fixit_insert_after ("()");
522 emit_diagnostic (diag_kind
, &richloc
, 0,
523 "invalid use of member function %qD "
524 "(did you forget the %<()%> ?)", member
);
527 emit_diagnostic (diag_kind
, loc
, 0,
528 "invalid use of member %qD "
529 "(did you forget the %<&%> ?)", member
);
533 case TEMPLATE_TYPE_PARM
:
536 if (CLASS_PLACEHOLDER_TEMPLATE (type
))
537 emit_diagnostic (diag_kind
, loc
, 0,
538 "invalid use of placeholder %qT", type
);
540 emit_diagnostic (diag_kind
, loc
, 0,
541 "invalid use of %qT", type
);
544 emit_diagnostic (diag_kind
, loc
, 0,
545 "invalid use of template type parameter %qT", type
);
548 case BOUND_TEMPLATE_TEMPLATE_PARM
:
549 emit_diagnostic (diag_kind
, loc
, 0,
550 "invalid use of template template parameter %qT",
556 emit_diagnostic (diag_kind
, loc
, 0,
557 "invalid use of dependent type %qT", type
);
561 if (type
== init_list_type_node
)
563 emit_diagnostic (diag_kind
, loc
, 0,
564 "invalid use of brace-enclosed initializer list");
567 gcc_assert (type
== unknown_type_node
);
568 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
570 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
571 emit_diagnostic (diag_kind
, loc
, 0,
572 "address of overloaded function with no contextual "
574 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
575 emit_diagnostic (diag_kind
, loc
, 0,
576 "overloaded function with no contextual type information");
578 emit_diagnostic (diag_kind
, loc
, 0,
579 "insufficient contextual information to determine type");
587 /* Print an error message for invalid use of an incomplete type.
588 VALUE is the expression that was used (or 0 if that isn't known)
589 and TYPE is the type that was invalid. */
592 cxx_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
594 cxx_incomplete_type_diagnostic (loc
, value
, type
, DK_ERROR
);
598 /* The recursive part of split_nonconstant_init. DEST is an lvalue
599 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
600 Return true if the whole of the value was initialized by the
601 generated statements. */
604 split_nonconstant_init_1 (tree dest
, tree init
)
606 unsigned HOST_WIDE_INT idx
;
607 tree field_index
, value
;
608 tree type
= TREE_TYPE (dest
);
609 tree inner_type
= NULL
;
610 bool array_type_p
= false;
611 bool complete_p
= true;
612 HOST_WIDE_INT num_split_elts
= 0;
614 switch (TREE_CODE (type
))
617 inner_type
= TREE_TYPE (type
);
619 if ((TREE_SIDE_EFFECTS (init
)
620 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
621 || vla_type_p (type
))
623 /* For an array, we only need/want a single cleanup region rather
624 than one per element. */
625 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
626 tf_warning_or_error
);
634 case QUAL_UNION_TYPE
:
635 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
638 /* The current implementation of this algorithm assumes that
639 the field was set for all the elements. This is usually done
640 by process_init_constructor. */
641 gcc_assert (field_index
);
644 inner_type
= TREE_TYPE (field_index
);
646 if (TREE_CODE (value
) == CONSTRUCTOR
)
651 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
652 NULL_TREE
, NULL_TREE
);
654 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
657 if (!split_nonconstant_init_1 (sub
, value
))
660 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
663 else if (!initializer_constant_valid_p (value
, inner_type
))
668 /* FIXME: Ordered removal is O(1) so the whole function is
669 worst-case quadratic. This could be fixed using an aside
670 bitmap to record which elements must be removed and remove
671 them all at the same time. Or by merging
672 split_non_constant_init into process_init_constructor_array,
673 that is separating constants from non-constants while building
675 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
678 if (TREE_CODE (field_index
) == RANGE_EXPR
)
680 /* Use build_vec_init to initialize a range. */
681 tree low
= TREE_OPERAND (field_index
, 0);
682 tree hi
= TREE_OPERAND (field_index
, 1);
683 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
684 NULL_TREE
, NULL_TREE
);
685 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
686 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
687 code
= build_vec_init (sub
, max
, value
, false, 0,
688 tf_warning_or_error
);
690 if (tree_fits_shwi_p (max
))
691 num_split_elts
+= tree_to_shwi (max
);
696 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
697 NULL_TREE
, NULL_TREE
);
699 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
702 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
703 code
= build_stmt (input_location
, EXPR_STMT
, code
);
704 code
= maybe_cleanup_point_expr_void (code
);
707 = cxx_maybe_build_cleanup (sub
, tf_warning_or_error
))
708 finish_eh_cleanup (cleanup
);
717 if (!initializer_constant_valid_p (init
, type
))
720 tree cons
= copy_node (init
);
721 CONSTRUCTOR_ELTS (init
) = NULL
;
722 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
723 code
= build_stmt (input_location
, EXPR_STMT
, code
);
725 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
733 /* The rest of the initializer is now a constant. */
734 TREE_CONSTANT (init
) = 1;
736 /* We didn't split out anything. */
737 if (num_split_elts
== 0)
740 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
741 num_split_elts
, inner_type
);
744 /* A subroutine of store_init_value. Splits non-constant static
745 initializer INIT into a constant part and generates code to
746 perform the non-constant part of the initialization to DEST.
747 Returns the code for the runtime init. */
750 split_nonconstant_init (tree dest
, tree init
)
754 if (TREE_CODE (init
) == TARGET_EXPR
)
755 init
= TARGET_EXPR_INITIAL (init
);
756 if (TREE_CODE (init
) == CONSTRUCTOR
)
758 init
= cp_fully_fold_init (init
);
759 code
= push_stmt_list ();
760 if (split_nonconstant_init_1 (dest
, init
))
762 code
= pop_stmt_list (code
);
763 DECL_INITIAL (dest
) = init
;
764 TREE_READONLY (dest
) = 0;
766 else if (TREE_CODE (init
) == STRING_CST
767 && array_of_runtime_bound_p (TREE_TYPE (dest
)))
768 code
= build_vec_init (dest
, NULL_TREE
, init
, /*value-init*/false,
769 /*from array*/1, tf_warning_or_error
);
771 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
776 /* Perform appropriate conversions on the initial value of a variable,
777 store it in the declaration DECL,
778 and print any error messages that are appropriate.
779 If the init is invalid, store an ERROR_MARK.
781 C++: Note that INIT might be a TREE_LIST, which would mean that it is
782 a base class initializer for some aggregate type, hopefully compatible
783 with DECL. If INIT is a single element, and DECL is an aggregate
784 type, we silently convert INIT into a TREE_LIST, allowing a constructor
787 If INIT is a TREE_LIST and there is no constructor, turn INIT
788 into a CONSTRUCTOR and use standard initialization techniques.
789 Perhaps a warning should be generated?
791 Returns code to be executed if initialization could not be performed
792 for static variable. In that case, caller must emit the code. */
795 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
799 /* If variable's type was invalidly declared, just ignore it. */
801 type
= TREE_TYPE (decl
);
802 if (TREE_CODE (type
) == ERROR_MARK
)
805 if (MAYBE_CLASS_TYPE_P (type
))
807 if (TREE_CODE (init
) == TREE_LIST
)
809 error ("constructor syntax used, but no constructor declared "
810 "for type %qT", type
);
811 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
815 /* End of special C++ code. */
817 if (flags
& LOOKUP_ALREADY_DIGESTED
)
821 if (TREE_STATIC (decl
))
822 flags
|= LOOKUP_ALLOW_FLEXARRAY_INIT
;
823 /* Digest the specified initializer into an expression. */
824 value
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
827 /* Look for braced array initializers for character arrays and
828 recursively convert them into STRING_CSTs. */
829 value
= braced_lists_to_strings (type
, value
);
831 current_ref_temp_count
= 0;
832 value
= extend_ref_init_temps (decl
, value
, cleanups
);
834 /* In C++11 constant expression is a semantic, not syntactic, property.
835 In C++98, make sure that what we thought was a constant expression at
836 template definition time is still constant and otherwise perform this
837 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
838 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
842 value
= fold_non_dependent_expr (value
);
843 if (DECL_DECLARED_CONSTEXPR_P (decl
)
844 || (DECL_IN_AGGR_P (decl
)
845 && DECL_INITIALIZED_IN_CLASS_P (decl
)))
847 /* Diagnose a non-constant initializer for constexpr variable or
848 non-inline in-class-initialized static data member. */
849 if (!require_constant_expression (value
))
850 value
= error_mark_node
;
851 else if (processing_template_decl
)
852 /* In a template we might not have done the necessary
853 transformations to make value actually constant,
854 e.g. extend_ref_init_temps. */
855 value
= maybe_constant_init (value
, decl
, true);
857 value
= cxx_constant_init (value
, decl
);
860 value
= maybe_constant_init (value
, decl
, true);
861 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
862 /* Poison this CONSTRUCTOR so it can't be copied to another
863 constexpr variable. */
864 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
865 const_init
= (reduced_constant_expression_p (value
)
866 || error_operand_p (value
));
867 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
868 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
869 if (!TYPE_REF_P (type
))
870 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
874 value
= cp_fully_fold_init (value
);
876 /* Handle aggregate NSDMI in non-constant initializers, too. */
877 value
= replace_placeholders (value
, decl
);
879 /* DECL may change value; purge caches. */
880 clear_cv_and_fold_caches ();
882 /* If the initializer is not a constant, fill in DECL_INITIAL with
883 the bits that are constant, and then return an expression that
884 will perform the dynamic initialization. */
885 if (value
!= error_mark_node
886 && (TREE_SIDE_EFFECTS (value
)
888 || ! reduced_constant_expression_p (value
)))
889 return split_nonconstant_init (decl
, value
);
890 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
891 is an automatic variable, the middle end will turn this into a
892 dynamic initialization later. */
893 DECL_INITIAL (decl
) = value
;
898 /* Give diagnostic about narrowing conversions within { }, or as part of
899 a converted constant expression. If CONST_ONLY, only check
903 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
, bool const_only
)
905 tree ftype
= unlowered_expr_type (init
);
909 if (((!warn_narrowing
|| !(complain
& tf_warning
))
910 && cxx_dialect
== cxx98
)
911 || !ARITHMETIC_TYPE_P (type
)
912 /* Don't emit bogus warnings with e.g. value-dependent trees. */
913 || instantiation_dependent_expression_p (init
))
916 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
917 && TREE_CODE (type
) == COMPLEX_TYPE
)
919 tree elttype
= TREE_TYPE (type
);
920 if (CONSTRUCTOR_NELTS (init
) > 0)
921 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
923 if (CONSTRUCTOR_NELTS (init
) > 1)
924 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
929 init
= maybe_constant_value (init
);
931 /* If we were asked to only check constants, return early. */
932 if (const_only
&& !TREE_CONSTANT (init
))
935 if (CP_INTEGRAL_TYPE_P (type
)
936 && TREE_CODE (ftype
) == REAL_TYPE
)
938 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
939 && CP_INTEGRAL_TYPE_P (type
))
941 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
942 /* Check for narrowing based on the values of the enumeration. */
943 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
944 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
945 TYPE_MAX_VALUE (ftype
))
946 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
947 TYPE_MIN_VALUE (type
)))
948 && (TREE_CODE (init
) != INTEGER_CST
949 || !int_fits_type_p (init
, type
)))
952 else if (TREE_CODE (ftype
) == REAL_TYPE
953 && TREE_CODE (type
) == REAL_TYPE
)
955 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
957 if (TREE_CODE (init
) == REAL_CST
)
959 /* Issue 703: Loss of precision is OK as long as the value is
960 within the representable range of the new type. */
962 d
= TREE_REAL_CST (init
);
963 real_convert (&r
, TYPE_MODE (type
), &d
);
971 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
972 && TREE_CODE (type
) == REAL_TYPE
)
975 if (TREE_CODE (init
) == INTEGER_CST
)
977 d
= real_value_from_int_cst (0, init
);
978 if (exact_real_truncate (TYPE_MODE (type
), &d
))
984 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
986 tree folded
= cp_fully_fold (init
);
987 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
993 location_t loc
= cp_expr_loc_or_loc (init
, input_location
);
994 if (cxx_dialect
== cxx98
)
996 if (complain
& tf_warning
)
997 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
998 "from %qH to %qI is ill-formed in C++11",
1002 else if (!CONSTANT_CLASS_P (init
))
1004 if (complain
& tf_warning_or_error
)
1006 auto_diagnostic_group d
;
1007 if ((!almost_ok
|| pedantic
)
1008 && pedwarn (loc
, OPT_Wnarrowing
,
1009 "narrowing conversion of %qE from %qH to %qI",
1012 inform (loc
, " the expression has a constant value but is not "
1013 "a C++ constant-expression");
1017 else if (complain
& tf_error
)
1019 int savederrorcount
= errorcount
;
1020 global_dc
->pedantic_errors
= 1;
1021 pedwarn (loc
, OPT_Wnarrowing
,
1022 "narrowing conversion of %qE from %qH to %qI",
1024 if (errorcount
== savederrorcount
)
1026 global_dc
->pedantic_errors
= flag_pedantic_errors
;
1033 /* True iff TYPE is a C++2a "ordinary" character type. */
1036 ordinary_char_type_p (tree type
)
1038 type
= TYPE_MAIN_VARIANT (type
);
1039 return (type
== char_type_node
1040 || type
== signed_char_type_node
1041 || type
== unsigned_char_type_node
);
1044 /* Process the initializer INIT for a variable of type TYPE, emitting
1045 diagnostics for invalid initializers and converting the initializer as
1048 For aggregate types, it assumes that reshape_init has already run, thus the
1049 initializer will have the right shape (brace elision has been undone).
1051 NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
1052 2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR. */
1055 digest_init_r (tree type
, tree init
, int nested
, int flags
,
1056 tsubst_flags_t complain
)
1058 enum tree_code code
= TREE_CODE (type
);
1060 if (error_operand_p (init
))
1061 return error_mark_node
;
1065 /* We must strip the outermost array type when completing the type,
1066 because the its bounds might be incomplete at the moment. */
1067 if (!complete_type_or_maybe_complain (code
== ARRAY_TYPE
1068 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1070 return error_mark_node
;
1072 location_t loc
= cp_expr_loc_or_loc (init
, input_location
);
1074 tree stripped_init
= init
;
1076 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1077 (g++.old-deja/g++.law/casts2.C). */
1078 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1079 stripped_init
= TREE_OPERAND (init
, 0);
1081 stripped_init
= tree_strip_any_location_wrapper (stripped_init
);
1083 /* Initialization of an array of chars from a string constant. The initializer
1084 can be optionally enclosed in braces, but reshape_init has already removed
1085 them if they were present. */
1086 if (code
== ARRAY_TYPE
)
1088 if (nested
&& !TYPE_DOMAIN (type
))
1089 /* C++ flexible array members have a null domain. */
1091 if (flags
& LOOKUP_ALLOW_FLEXARRAY_INIT
)
1092 pedwarn (loc
, OPT_Wpedantic
,
1093 "initialization of a flexible array member");
1096 if (complain
& tf_error
)
1097 error_at (loc
, "non-static initialization of"
1098 " a flexible array member");
1099 return error_mark_node
;
1103 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1104 if (char_type_p (typ1
)
1105 && TREE_CODE (stripped_init
) == STRING_CST
)
1107 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1108 bool incompat_string_cst
= false;
1110 if (typ1
!= char_type
)
1112 /* The array element type does not match the initializing string
1113 literal element type; this is only allowed when both types are
1114 ordinary character type. There are no string literals of
1115 signed or unsigned char type in the language, but we can get
1116 them internally from converting braced-init-lists to
1118 if (ordinary_char_type_p (typ1
)
1119 && ordinary_char_type_p (char_type
))
1122 incompat_string_cst
= true;
1125 if (incompat_string_cst
)
1127 if (complain
& tf_error
)
1128 error_at (loc
, "cannot initialize array of %qT from "
1129 "a string literal with type array of %qT",
1131 return error_mark_node
;
1134 if (nested
== 2 && !TYPE_DOMAIN (type
))
1136 if (complain
& tf_error
)
1137 error_at (loc
, "initialization of flexible array member "
1138 "in a nested context");
1139 return error_mark_node
;
1142 if (type
!= TREE_TYPE (init
)
1143 && !variably_modified_type_p (type
, NULL_TREE
))
1145 init
= copy_node (init
);
1146 TREE_TYPE (init
) = type
;
1147 /* If we have a location wrapper, then also copy the wrapped
1148 node, and update the copy's type. */
1149 if (location_wrapper_p (init
))
1151 stripped_init
= copy_node (stripped_init
);
1152 TREE_OPERAND (init
, 0) = stripped_init
;
1153 TREE_TYPE (stripped_init
) = type
;
1156 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1158 /* Not a flexible array member. */
1159 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1160 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1161 /* In C it is ok to subtract 1 from the length of the string
1162 because it's ok to ignore the terminating null char that is
1163 counted in the length of the constant, but in C++ this would
1165 if (size
< TREE_STRING_LENGTH (stripped_init
))
1167 permerror (loc
, "initializer-string for %qT is too long",
1170 init
= build_string (size
,
1171 TREE_STRING_POINTER (stripped_init
));
1172 TREE_TYPE (init
) = type
;
1179 /* Handle scalar types (including conversions) and references. */
1180 if ((code
!= COMPLEX_TYPE
|| BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1181 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1184 flags
|= LOOKUP_NO_NARROWING
;
1185 init
= convert_for_initialization (0, type
, init
, flags
,
1186 ICR_INIT
, NULL_TREE
, 0,
1192 /* Come here only for aggregates: records, arrays, unions, complex numbers
1194 gcc_assert (code
== ARRAY_TYPE
1195 || VECTOR_TYPE_P (type
)
1196 || code
== RECORD_TYPE
1197 || code
== UNION_TYPE
1198 || code
== COMPLEX_TYPE
);
1200 /* "If T is a class type and the initializer list has a single
1201 element of type cv U, where U is T or a class derived from T,
1202 the object is initialized from that element." */
1203 if (cxx_dialect
>= cxx11
1204 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1205 && CONSTRUCTOR_NELTS (stripped_init
) == 1
1206 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1207 || VECTOR_TYPE_P (type
)))
1209 tree elt
= CONSTRUCTOR_ELT (stripped_init
, 0)->value
;
1210 if (reference_related_p (type
, TREE_TYPE (elt
)))
1212 /* In C++17, aggregates can have bases, thus participate in
1213 aggregate initialization. In the following case:
1215 struct B { int c; };
1219 there's an extra set of braces, so the D temporary initializes
1220 the first element of d, which is the B base subobject. The base
1221 of type B is copy-initialized from the D temporary, causing
1223 tree field
= next_initializable_field (TYPE_FIELDS (type
));
1224 if (field
&& DECL_FIELD_IS_BASE (field
))
1226 if (warning_at (loc
, 0, "initializing a base class of type %qT "
1227 "results in object slicing", TREE_TYPE (field
)))
1228 inform (loc
, "remove %<{ }%> around initializer");
1230 else if (flag_checking
)
1231 /* We should have fixed this in reshape_init. */
1236 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init
)
1237 && !TYPE_NON_AGGREGATE_CLASS (type
))
1238 return process_init_constructor (type
, stripped_init
, nested
, flags
,
1242 if (COMPOUND_LITERAL_P (stripped_init
) && code
== ARRAY_TYPE
)
1244 if (complain
& tf_error
)
1245 error_at (loc
, "cannot initialize aggregate of type %qT with "
1246 "a compound literal", type
);
1248 return error_mark_node
;
1251 if (code
== ARRAY_TYPE
1252 && !BRACE_ENCLOSED_INITIALIZER_P (stripped_init
))
1254 /* Allow the result of build_array_copy and of
1255 build_value_init_noctor. */
1256 if ((TREE_CODE (stripped_init
) == VEC_INIT_EXPR
1257 || TREE_CODE (stripped_init
) == CONSTRUCTOR
)
1258 && (same_type_ignoring_top_level_qualifiers_p
1259 (type
, TREE_TYPE (init
))))
1262 if (complain
& tf_error
)
1263 error_at (loc
, "array must be initialized with a brace-enclosed"
1265 return error_mark_node
;
1268 return convert_for_initialization (NULL_TREE
, type
, init
,
1270 ICR_INIT
, NULL_TREE
, 0,
1276 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1278 return digest_init_r (type
, init
, 0, LOOKUP_IMPLICIT
, complain
);
1282 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1284 return digest_init_r (type
, init
, 0, flags
, complain
);
1287 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1289 digest_nsdmi_init (tree decl
, tree init
, tsubst_flags_t complain
)
1291 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1293 tree type
= TREE_TYPE (decl
);
1294 int flags
= LOOKUP_IMPLICIT
;
1295 if (DIRECT_LIST_INIT_P (init
))
1296 flags
= LOOKUP_NORMAL
;
1297 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1298 && CP_AGGREGATE_TYPE_P (type
))
1299 init
= reshape_init (type
, init
, complain
);
1300 init
= digest_init_flags (type
, init
, flags
, complain
);
1301 if (TREE_CODE (init
) == TARGET_EXPR
)
1302 /* This represents the whole initialization. */
1303 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1307 /* Set of flags used within process_init_constructor to describe the
1309 #define PICFLAG_ERRONEOUS 1
1310 #define PICFLAG_NOT_ALL_CONSTANT 2
1311 #define PICFLAG_NOT_ALL_SIMPLE 4
1312 #define PICFLAG_SIDE_EFFECTS 8
1314 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1318 picflag_from_initializer (tree init
)
1320 if (init
== error_mark_node
)
1321 return PICFLAG_ERRONEOUS
;
1322 else if (!TREE_CONSTANT (init
))
1324 if (TREE_SIDE_EFFECTS (init
))
1325 return PICFLAG_SIDE_EFFECTS
;
1327 return PICFLAG_NOT_ALL_CONSTANT
;
1329 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1330 return PICFLAG_NOT_ALL_SIMPLE
;
1334 /* Adjust INIT for going into a CONSTRUCTOR. */
1337 massage_init_elt (tree type
, tree init
, int nested
, int flags
,
1338 tsubst_flags_t complain
)
1340 flags
&= LOOKUP_ALLOW_FLEXARRAY_INIT
;
1341 flags
|= LOOKUP_IMPLICIT
;
1342 init
= digest_init_r (type
, init
, nested
? 2 : 1, flags
, complain
);
1343 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1344 if (SIMPLE_TARGET_EXPR_P (init
))
1345 init
= TARGET_EXPR_INITIAL (init
);
1346 /* When we defer constant folding within a statement, we may want to
1347 defer this folding as well. */
1348 tree t
= fold_non_dependent_init (init
, complain
);
1349 if (TREE_CONSTANT (t
))
1354 /* Subroutine of process_init_constructor, which will process an initializer
1355 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1356 which describe the initializers. */
1359 process_init_constructor_array (tree type
, tree init
, int nested
, int flags
,
1360 tsubst_flags_t complain
)
1362 unsigned HOST_WIDE_INT i
, len
= 0;
1364 bool unbounded
= false;
1365 constructor_elt
*ce
;
1366 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1368 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1369 || VECTOR_TYPE_P (type
));
1371 if (TREE_CODE (type
) == ARRAY_TYPE
)
1373 /* C++ flexible array members have a null domain. */
1374 tree domain
= TYPE_DOMAIN (type
);
1375 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1376 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1377 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1378 TYPE_PRECISION (TREE_TYPE (domain
)),
1379 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1381 unbounded
= true; /* Take as many as there are. */
1383 if (nested
== 2 && !domain
&& !vec_safe_is_empty (v
))
1385 if (complain
& tf_error
)
1386 error_at (cp_expr_loc_or_loc (init
, input_location
),
1387 "initialization of flexible array member "
1388 "in a nested context");
1389 return PICFLAG_ERRONEOUS
;
1393 /* Vectors are like simple fixed-size arrays. */
1394 unbounded
= !TYPE_VECTOR_SUBPARTS (type
).is_constant (&len
);
1396 /* There must not be more initializers than needed. */
1397 if (!unbounded
&& vec_safe_length (v
) > len
)
1399 if (complain
& tf_error
)
1400 error ("too many initializers for %qT", type
);
1402 return PICFLAG_ERRONEOUS
;
1405 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1408 ce
->index
= size_int (i
);
1409 else if (!check_array_designated_initializer (ce
, i
))
1410 ce
->index
= error_mark_node
;
1411 gcc_assert (ce
->value
);
1413 = massage_init_elt (TREE_TYPE (type
), ce
->value
, nested
, flags
,
1417 (ce
->value
== error_mark_node
1418 || (same_type_ignoring_top_level_qualifiers_p
1419 (strip_array_types (TREE_TYPE (type
)),
1420 strip_array_types (TREE_TYPE (ce
->value
)))));
1422 picflags
|= picflag_from_initializer (ce
->value
);
1425 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1426 we must add initializers ourselves. */
1428 for (; i
< len
; ++i
)
1432 if (type_build_ctor_call (TREE_TYPE (type
)))
1434 /* If this type needs constructors run for default-initialization,
1435 we can't rely on the back end to do it for us, so make the
1436 initialization explicit by list-initializing from T{}. */
1437 next
= build_constructor (init_list_type_node
, NULL
);
1438 next
= massage_init_elt (TREE_TYPE (type
), next
, nested
, flags
,
1440 if (initializer_zerop (next
))
1441 /* The default zero-initialization is fine for us; don't
1442 add anything to the CONSTRUCTOR. */
1445 else if (!zero_init_p (TREE_TYPE (type
)))
1446 next
= build_zero_init (TREE_TYPE (type
),
1447 /*nelts=*/NULL_TREE
,
1448 /*static_storage_p=*/false);
1450 /* The default zero-initialization is fine for us; don't
1451 add anything to the CONSTRUCTOR. */
1456 picflags
|= picflag_from_initializer (next
);
1458 && (initializer_constant_valid_p (next
, TREE_TYPE (next
))
1459 == null_pointer_node
))
1461 tree range
= build2 (RANGE_EXPR
, size_type_node
,
1462 build_int_cst (size_type_node
, i
),
1463 build_int_cst (size_type_node
, len
- 1));
1464 CONSTRUCTOR_APPEND_ELT (v
, range
, next
);
1468 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1471 /* Don't bother checking all the other elements. */
1475 CONSTRUCTOR_ELTS (init
) = v
;
1479 /* Subroutine of process_init_constructor, which will process an initializer
1480 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1481 the initializers. */
1484 process_init_constructor_record (tree type
, tree init
, int nested
, int flags
,
1485 tsubst_flags_t complain
)
1487 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1491 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1492 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1493 gcc_assert (!TYPE_BINFO (type
)
1494 || cxx_dialect
>= cxx17
1495 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1496 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1500 unsigned HOST_WIDE_INT idx
= 0;
1501 int designator_skip
= -1;
1502 /* Generally, we will always have an index for each initializer (which is
1503 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1504 reshape_init. So we need to handle both cases. */
1505 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1510 if (TREE_CODE (field
) != FIELD_DECL
1511 || (DECL_ARTIFICIAL (field
)
1512 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
))))
1515 if (DECL_UNNAMED_BIT_FIELD (field
))
1518 /* If this is a bitfield, first convert to the declared type. */
1519 type
= TREE_TYPE (field
);
1520 if (DECL_BIT_FIELD_TYPE (field
))
1521 type
= DECL_BIT_FIELD_TYPE (field
);
1522 if (type
== error_mark_node
)
1523 return PICFLAG_ERRONEOUS
;
1526 if (idx
< CONSTRUCTOR_NELTS (init
))
1528 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1531 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1532 latter case can happen in templates where lookup has to be
1534 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1535 || identifier_p (ce
->index
));
1536 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1538 else if (ANON_AGGR_TYPE_P (type
)
1539 && search_anon_aggr (type
,
1540 TREE_CODE (ce
->index
) == FIELD_DECL
1541 ? DECL_NAME (ce
->index
)
1543 /* If the element is an anonymous union object and the
1544 initializer list is a designated-initializer-list, the
1545 anonymous union object is initialized by the
1546 designated-initializer-list { D }, where D is the
1547 designated-initializer-clause naming a member of the
1548 anonymous union object. */
1549 next
= build_constructor_single (init_list_type_node
,
1550 ce
->index
, ce
->value
);
1554 if (designator_skip
== -1)
1555 designator_skip
= 1;
1560 designator_skip
= 0;
1566 gcc_assert (ce
->value
);
1567 next
= massage_init_elt (type
, next
, nested
, flags
, complain
);
1572 /* Already handled above. */;
1573 else if (DECL_INITIAL (field
))
1577 /* We're using an NSDMI past a field with implicit
1578 zero-init. Go back and make it explicit. */
1580 vec_safe_truncate (v
, 0);
1583 /* C++14 aggregate NSDMI. */
1584 next
= get_nsdmi (field
, /*ctor*/false, complain
);
1585 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1586 && find_placeholders (next
))
1587 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1589 else if (type_build_ctor_call (TREE_TYPE (field
)))
1591 /* If this type needs constructors run for
1592 default-initialization, we can't rely on the back end to do it
1593 for us, so build up TARGET_EXPRs. If the type in question is
1594 a class, just build one up; if it's an array, recurse. */
1595 next
= build_constructor (init_list_type_node
, NULL
);
1596 next
= massage_init_elt (TREE_TYPE (field
), next
, nested
, flags
,
1599 /* Warn when some struct elements are implicitly initialized. */
1600 if ((complain
& tf_warning
)
1601 && !EMPTY_CONSTRUCTOR_P (init
))
1602 warning (OPT_Wmissing_field_initializers
,
1603 "missing initializer for member %qD", field
);
1607 const_tree fldtype
= TREE_TYPE (field
);
1608 if (TYPE_REF_P (fldtype
))
1610 if (complain
& tf_error
)
1611 error ("member %qD is uninitialized reference", field
);
1613 return PICFLAG_ERRONEOUS
;
1615 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1617 if (complain
& tf_error
)
1618 error ("member %qD with uninitialized reference fields", field
);
1620 return PICFLAG_ERRONEOUS
;
1622 /* Do nothing for flexible array members since they need not have any
1623 elements. Don't worry about 'skipped' because a flexarray has to
1624 be the last field. */
1625 else if (TREE_CODE (fldtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (fldtype
))
1628 /* Warn when some struct elements are implicitly initialized
1630 if ((complain
& tf_warning
)
1631 && !EMPTY_CONSTRUCTOR_P (init
))
1632 warning (OPT_Wmissing_field_initializers
,
1633 "missing initializer for member %qD", field
);
1635 if (!zero_init_p (fldtype
)
1637 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1638 /*static_storage_p=*/false);
1641 /* The default zero-initialization is fine for us; don't
1642 add anything to the CONSTRUCTOR. */
1648 if (DECL_SIZE (field
) && integer_zerop (DECL_SIZE (field
))
1649 && !TREE_SIDE_EFFECTS (next
))
1650 /* Don't add trivial initialization of an empty base/field to the
1651 constructor, as they might not be ordered the way the back-end
1655 /* If this is a bitfield, now convert to the lowered type. */
1656 if (type
!= TREE_TYPE (field
))
1657 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1658 picflags
|= picflag_from_initializer (next
);
1659 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1662 if (idx
< CONSTRUCTOR_NELTS (init
))
1664 if (complain
& tf_error
)
1666 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1667 /* For better diagnostics, try to find out if it is really
1668 the case of too many initializers or if designators are
1669 in incorrect order. */
1670 if (designator_skip
== 1 && ce
->index
)
1672 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1673 || identifier_p (ce
->index
));
1674 for (field
= TYPE_FIELDS (type
);
1675 field
; field
= DECL_CHAIN (field
))
1677 if (TREE_CODE (field
) != FIELD_DECL
1678 || (DECL_ARTIFICIAL (field
)
1679 && !(cxx_dialect
>= cxx17
1680 && DECL_FIELD_IS_BASE (field
))))
1683 if (DECL_UNNAMED_BIT_FIELD (field
))
1686 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1688 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1691 = search_anon_aggr (TREE_TYPE (field
),
1692 TREE_CODE (ce
->index
) == FIELD_DECL
1693 ? DECL_NAME (ce
->index
)
1704 error ("designator order for field %qD does not match declaration "
1705 "order in %qT", field
, type
);
1707 error ("too many initializers for %qT", type
);
1710 return PICFLAG_ERRONEOUS
;
1713 CONSTRUCTOR_ELTS (init
) = v
;
1717 /* Subroutine of process_init_constructor, which will process a single
1718 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1719 which describe the initializer. */
1722 process_init_constructor_union (tree type
, tree init
, int nested
, int flags
,
1723 tsubst_flags_t complain
)
1725 constructor_elt
*ce
;
1728 /* If the initializer was empty, use the union's NSDMI if it has one.
1729 Otherwise use default zero initialization. */
1730 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1732 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1734 if (TREE_CODE (field
) == FIELD_DECL
1735 && DECL_INITIAL (field
) != NULL_TREE
)
1737 tree val
= get_nsdmi (field
, /*in_ctor=*/false, complain
);
1738 if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
)
1739 && find_placeholders (val
))
1740 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init
) = 1;
1741 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
), field
, val
);
1746 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1750 len
= CONSTRUCTOR_ELTS (init
)->length ();
1753 if (!(complain
& tf_error
))
1754 return PICFLAG_ERRONEOUS
;
1755 error ("too many initializers for %qT", type
);
1756 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1759 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1761 /* If this element specifies a field, initialize via that field. */
1764 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1766 else if (identifier_p (ce
->index
))
1768 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1769 tree name
= ce
->index
;
1771 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1772 if (DECL_NAME (field
) == name
)
1776 if (complain
& tf_error
)
1777 error ("no field %qD found in union being initialized",
1779 ce
->value
= error_mark_node
;
1785 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1786 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1787 if (complain
& tf_error
)
1788 error ("index value instead of field name in union initializer");
1789 ce
->value
= error_mark_node
;
1794 /* Find the first named field. ANSI decided in September 1990
1795 that only named fields count here. */
1796 tree field
= TYPE_FIELDS (type
);
1797 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1798 field
= TREE_CHAIN (field
);
1799 if (field
== NULL_TREE
)
1801 if (complain
& tf_error
)
1802 error ("too many initializers for %qT", type
);
1803 ce
->value
= error_mark_node
;
1808 if (ce
->value
&& ce
->value
!= error_mark_node
)
1809 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, nested
,
1812 return picflag_from_initializer (ce
->value
);
1815 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1816 constructor is a brace-enclosed initializer, and will be modified in-place.
1818 Each element is converted to the right type through digest_init, and
1819 missing initializers are added following the language rules (zero-padding,
1822 After the execution, the initializer will have TREE_CONSTANT if all elts are
1823 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1824 constants that the assembler and linker can compute them.
1826 The function returns the initializer itself, or error_mark_node in case
1830 process_init_constructor (tree type
, tree init
, int nested
, int flags
,
1831 tsubst_flags_t complain
)
1835 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1837 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
1838 picflags
= process_init_constructor_array (type
, init
, nested
, flags
,
1840 else if (TREE_CODE (type
) == RECORD_TYPE
)
1841 picflags
= process_init_constructor_record (type
, init
, nested
, flags
,
1843 else if (TREE_CODE (type
) == UNION_TYPE
)
1844 picflags
= process_init_constructor_union (type
, init
, nested
, flags
,
1849 if (picflags
& PICFLAG_ERRONEOUS
)
1850 return error_mark_node
;
1852 TREE_TYPE (init
) = type
;
1853 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1854 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1855 if (picflags
& PICFLAG_SIDE_EFFECTS
)
1857 TREE_CONSTANT (init
) = false;
1858 TREE_SIDE_EFFECTS (init
) = true;
1860 else if (picflags
& PICFLAG_NOT_ALL_CONSTANT
)
1861 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1862 TREE_CONSTANT (init
) = false;
1865 TREE_CONSTANT (init
) = 1;
1866 if (!(picflags
& PICFLAG_NOT_ALL_SIMPLE
))
1867 TREE_STATIC (init
) = 1;
1872 /* Given a structure or union value DATUM, construct and return
1873 the structure or union component which results from narrowing
1874 that value to the base specified in BASETYPE. For example, given the
1877 class L { int ii; };
1878 class A : L { ... };
1879 class B : L { ... };
1880 class C : A, B { ... };
1888 x.A::ii refers to the ii member of the L part of
1889 the A part of the C object named by X. In this case,
1890 DATUM would be x, and BASETYPE would be A.
1892 I used to think that this was nonconformant, that the standard specified
1893 that first we look up ii in A, then convert x to an L& and pull out the
1894 ii part. But in fact, it does say that we convert x to an A&; A here
1895 is known as the "naming class". (jason 2000-12-19)
1897 BINFO_P points to a variable initialized either to NULL_TREE or to the
1898 binfo for the specific base subobject we want to convert to. */
1901 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1905 if (datum
== error_mark_node
)
1906 return error_mark_node
;
1910 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1911 NULL
, tf_warning_or_error
);
1913 if (!binfo
|| binfo
== error_mark_node
)
1915 *binfo_p
= NULL_TREE
;
1917 error_not_base_type (basetype
, TREE_TYPE (datum
));
1918 return error_mark_node
;
1922 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1923 tf_warning_or_error
);
1926 /* Build a reference to an object specified by the C++ `->' operator.
1927 Usually this just involves dereferencing the object, but if the
1928 `->' operator is overloaded, then such overloads must be
1929 performed until an object which does not have the `->' operator
1930 overloaded is found. An error is reported when circular pointer
1931 delegation is detected. */
1934 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1936 tree orig_expr
= expr
;
1937 tree type
= TREE_TYPE (expr
);
1938 tree last_rval
= NULL_TREE
;
1939 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1941 if (type
== error_mark_node
)
1942 return error_mark_node
;
1944 if (processing_template_decl
)
1946 if (type
&& TYPE_PTR_P (type
)
1947 && !dependent_scope_p (TREE_TYPE (type
)))
1948 /* Pointer to current instantiation, don't treat as dependent. */;
1949 else if (type_dependent_expression_p (expr
))
1950 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1951 expr
= build_non_dependent_expr (expr
);
1954 if (MAYBE_CLASS_TYPE_P (type
))
1956 struct tinst_level
*actual_inst
= current_instantiation ();
1959 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1960 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1963 if (expr
== error_mark_node
)
1964 return error_mark_node
;
1966 /* This provides a better instantiation backtrace in case of
1968 if (fn
&& DECL_USE_TEMPLATE (fn
))
1969 push_tinst_level_loc (fn
,
1970 (current_instantiation () != actual_inst
)
1971 ? DECL_SOURCE_LOCATION (fn
)
1975 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1977 if (complain
& tf_error
)
1978 error ("circular pointer delegation detected");
1979 return error_mark_node
;
1982 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1986 while (current_instantiation () != actual_inst
)
1989 if (last_rval
== NULL_TREE
)
1991 if (complain
& tf_error
)
1992 error ("base operand of %<->%> has non-pointer type %qT", type
);
1993 return error_mark_node
;
1996 if (TYPE_REF_P (TREE_TYPE (last_rval
)))
1997 last_rval
= convert_from_reference (last_rval
);
2000 last_rval
= decay_conversion (expr
, complain
);
2002 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
2004 if (processing_template_decl
)
2006 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
2008 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
2012 return cp_build_indirect_ref (last_rval
, RO_ARROW
, complain
);
2015 if (complain
& tf_error
)
2018 error ("result of %<operator->()%> yields non-pointer result");
2020 error ("base operand of %<->%> is not a pointer");
2022 return error_mark_node
;
2025 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
2026 already been checked out to be of aggregate type. */
2029 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
2037 if (error_operand_p (datum
) || error_operand_p (component
))
2038 return error_mark_node
;
2040 datum
= mark_lvalue_use (datum
);
2041 component
= mark_rvalue_use (component
);
2043 ptrmem_type
= TREE_TYPE (component
);
2044 if (!TYPE_PTRMEM_P (ptrmem_type
))
2046 if (complain
& tf_error
)
2047 error ("%qE cannot be used as a member pointer, since it is of "
2048 "type %qT", component
, ptrmem_type
);
2049 return error_mark_node
;
2052 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
2053 if (! MAYBE_CLASS_TYPE_P (objtype
))
2055 if (complain
& tf_error
)
2056 error ("cannot apply member pointer %qE to %qE, which is of "
2057 "non-class type %qT", component
, datum
, objtype
);
2058 return error_mark_node
;
2061 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
2062 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
2064 if (!COMPLETE_TYPE_P (ctype
))
2066 if (!same_type_p (ctype
, objtype
))
2072 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
2077 if (complain
& tf_error
)
2078 error ("pointer to member type %qT incompatible with object "
2079 "type %qT", type
, objtype
);
2080 return error_mark_node
;
2082 else if (binfo
== error_mark_node
)
2083 return error_mark_node
;
2086 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
2088 bool is_lval
= real_lvalue_p (datum
);
2091 /* Compute the type of the field, as described in [expr.ref].
2092 There's no such thing as a mutable pointer-to-member, so
2093 things are not as complex as they are for references to
2094 non-static data members. */
2095 type
= cp_build_qualified_type (type
,
2096 (cp_type_quals (type
)
2097 | cp_type_quals (TREE_TYPE (datum
))));
2099 datum
= build_address (datum
);
2101 /* Convert object to the correct base. */
2104 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
2105 if (datum
== error_mark_node
)
2106 return error_mark_node
;
2109 /* Build an expression for "object + offset" where offset is the
2110 value stored in the pointer-to-data-member. */
2111 ptype
= build_pointer_type (type
);
2112 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
2113 datum
= cp_build_fold_indirect_ref (datum
);
2114 if (datum
== error_mark_node
)
2115 return error_mark_node
;
2117 /* If the object expression was an rvalue, return an rvalue. */
2119 datum
= move (datum
);
2124 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
2125 program is ill-formed if the second operand is a pointer to member
2126 function with ref-qualifier & (for C++2A: unless its cv-qualifier-seq
2127 is const). In a .* expression whose object expression is an lvalue,
2128 the program is ill-formed if the second operand is a pointer to member
2129 function with ref-qualifier &&. */
2130 if (FUNCTION_REF_QUALIFIED (type
))
2132 bool lval
= lvalue_p (datum
);
2133 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
2135 if (complain
& tf_error
)
2136 error ("pointer-to-member-function type %qT requires an rvalue",
2138 return error_mark_node
;
2140 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
2142 if ((type_memfn_quals (type
)
2143 & (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
))
2146 if (complain
& tf_error
)
2147 error ("pointer-to-member-function type %qT requires "
2148 "an lvalue", ptrmem_type
);
2149 return error_mark_node
;
2151 else if (cxx_dialect
< cxx2a
)
2153 if (complain
& tf_warning_or_error
)
2154 pedwarn (input_location
, OPT_Wpedantic
,
2155 "pointer-to-member-function type %qT requires "
2156 "an lvalue before C++2a", ptrmem_type
);
2158 return error_mark_node
;
2162 return build2 (OFFSET_REF
, type
, datum
, component
);
2166 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
2169 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
2171 /* This is either a call to a constructor,
2172 or a C cast in C++'s `functional' notation. */
2174 /* The type to which we are casting. */
2177 if (error_operand_p (exp
) || parms
== error_mark_node
)
2178 return error_mark_node
;
2180 if (TREE_CODE (exp
) == TYPE_DECL
)
2182 type
= TREE_TYPE (exp
);
2184 if (DECL_ARTIFICIAL (exp
))
2185 cp_warn_deprecated_use (type
);
2190 /* We need to check this explicitly, since value-initialization of
2191 arrays is allowed in other situations. */
2192 if (TREE_CODE (type
) == ARRAY_TYPE
)
2194 if (complain
& tf_error
)
2195 error ("functional cast to array type %qT", type
);
2196 return error_mark_node
;
2199 if (tree anode
= type_uses_auto (type
))
2201 if (!CLASS_PLACEHOLDER_TEMPLATE (anode
))
2203 if (complain
& tf_error
)
2204 error_at (DECL_SOURCE_LOCATION (TEMPLATE_TYPE_DECL (anode
)),
2205 "invalid use of %qT", anode
);
2206 return error_mark_node
;
2210 /* Even if there are no parameters, we might be able to deduce from
2211 default template arguments. Pass TF_NONE so that we don't
2212 generate redundant diagnostics. */
2213 type
= do_auto_deduction (type
, parms
, anode
, tf_none
,
2215 if (type
== error_mark_node
)
2217 if (complain
& tf_error
)
2218 error ("cannot deduce template arguments for %qT from %<()%>",
2220 return error_mark_node
;
2224 type
= do_auto_deduction (type
, parms
, anode
, complain
,
2228 if (processing_template_decl
)
2232 /* Diagnose this even in a template. We could also try harder
2233 to give all the usual errors when the type and args are
2235 if (TYPE_REF_P (type
) && !parms
)
2237 if (complain
& tf_error
)
2238 error ("invalid value-initialization of reference type");
2239 return error_mark_node
;
2242 t
= build_min (CAST_EXPR
, type
, parms
);
2243 /* We don't know if it will or will not have side effects. */
2244 TREE_SIDE_EFFECTS (t
) = 1;
2248 if (! MAYBE_CLASS_TYPE_P (type
))
2250 if (parms
== NULL_TREE
)
2252 if (VOID_TYPE_P (type
))
2254 return build_value_init (cv_unqualified (type
), complain
);
2257 /* This must build a C cast. */
2258 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2259 return cp_build_c_cast (type
, parms
, complain
);
2262 /* Prepare to evaluate as a call to a constructor. If this expression
2263 is actually used, for example,
2265 return X (arg1, arg2, ...);
2267 then the slot being initialized will be filled in. */
2269 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2270 return error_mark_node
;
2271 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
2272 return error_mark_node
;
2276 If the expression list is a single-expression, the type
2277 conversion is equivalent (in definedness, and if defined in
2278 meaning) to the corresponding cast expression. */
2279 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2280 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
2284 The expression T(), where T is a simple-type-specifier for a
2285 non-array complete object type or the (possibly cv-qualified)
2286 void type, creates an rvalue of the specified type, which is
2287 value-initialized. */
2289 if (parms
== NULL_TREE
)
2291 exp
= build_value_init (type
, complain
);
2292 exp
= get_target_expr_sfinae (exp
, complain
);
2296 /* Call the constructor. */
2297 releasing_vec parmvec
;
2298 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2299 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2300 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2301 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2303 if (exp
== error_mark_node
)
2304 return error_mark_node
;
2306 return build_cplus_new (type
, exp
, complain
);
2310 /* Add new exception specifier SPEC, to the LIST we currently have.
2311 If it's already in LIST then do nothing.
2312 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2313 know what we're doing. */
2316 add_exception_specifier (tree list
, tree spec
, tsubst_flags_t complain
)
2321 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2323 if (spec
== error_mark_node
)
2326 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2328 /* [except.spec] 1, type in an exception specifier shall not be
2329 incomplete, or pointer or ref to incomplete other than pointer
2331 is_ptr
= TYPE_PTR_P (core
);
2332 if (is_ptr
|| TYPE_REF_P (core
))
2333 core
= TREE_TYPE (core
);
2336 else if (VOID_TYPE_P (core
))
2338 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2340 else if (processing_template_decl
)
2345 /* 15.4/1 says that types in an exception specifier must be complete,
2346 but it seems more reasonable to only require this on definitions
2347 and calls. So just give a pedwarn at this point; we will give an
2348 error later if we hit one of those two cases. */
2349 if (!COMPLETE_TYPE_P (complete_type (core
)))
2350 diag_type
= DK_PEDWARN
; /* pedwarn */
2357 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2358 if (same_type_p (TREE_VALUE (probe
), spec
))
2361 list
= tree_cons (NULL_TREE
, spec
, list
);
2364 diag_type
= DK_ERROR
; /* error */
2366 if (diag_type
!= DK_UNSPECIFIED
2367 && (complain
& tf_warning_or_error
))
2368 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2373 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2376 nothrow_spec_p_uninst (const_tree spec
)
2378 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2380 return nothrow_spec_p (spec
);
2383 /* Combine the two exceptions specifier lists LIST and ADD, and return
2387 merge_exception_specifiers (tree list
, tree add
)
2389 tree noex
, orig_list
;
2391 if (list
== error_mark_node
|| add
== error_mark_node
)
2392 return error_mark_node
;
2394 /* No exception-specifier or noexcept(false) are less strict than
2395 anything else. Prefer the newer variant (LIST). */
2396 if (!list
|| list
== noexcept_false_spec
)
2398 else if (!add
|| add
== noexcept_false_spec
)
2401 /* noexcept(true) and throw() are stricter than anything else.
2402 As above, prefer the more recent one (LIST). */
2403 if (nothrow_spec_p_uninst (add
))
2406 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2407 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2408 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2410 /* We should have instantiated other deferred noexcept specs by now. */
2411 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2413 if (nothrow_spec_p_uninst (list
))
2415 noex
= TREE_PURPOSE (list
);
2416 gcc_checking_assert (!TREE_PURPOSE (add
)
2417 || errorcount
|| !flag_exceptions
2418 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2420 /* Combine the dynamic-exception-specifiers, if any. */
2422 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2424 tree spec
= TREE_VALUE (add
);
2427 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2428 probe
= TREE_CHAIN (probe
))
2429 if (same_type_p (TREE_VALUE (probe
), spec
))
2433 spec
= build_tree_list (NULL_TREE
, spec
);
2434 TREE_CHAIN (spec
) = list
;
2439 /* Keep the noexcept-specifier at the beginning of the list. */
2440 if (noex
!= TREE_PURPOSE (list
))
2441 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2446 /* Subroutine of build_call. Ensure that each of the types in the
2447 exception specification is complete. Technically, 15.4/1 says that
2448 they need to be complete when we see a declaration of the function,
2449 but we should be able to get away with only requiring this when the
2450 function is defined or called. See also add_exception_specifier. */
2453 require_complete_eh_spec_types (tree fntype
, tree decl
)
2456 /* Don't complain about calls to op new. */
2457 if (decl
&& DECL_ARTIFICIAL (decl
))
2459 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2460 raises
= TREE_CHAIN (raises
))
2462 tree type
= TREE_VALUE (raises
);
2463 if (type
&& !COMPLETE_TYPE_P (type
))
2467 ("call to function %qD which throws incomplete type %q#T",
2470 error ("call to function which throws incomplete type %q#T",
2477 #include "gt-cp-typeck2.h"