1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2016 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 (const_tree value
, const_tree type
,
455 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 location_t loc
= EXPR_LOC_OR_LOC (value
, input_location
);
480 switch (TREE_CODE (type
))
486 complained
= emit_diagnostic (diag_kind
, loc
, 0,
487 "invalid use of incomplete type %q#T",
490 cxx_incomplete_type_inform (type
);
494 emit_diagnostic (diag_kind
, loc
, 0,
495 "invalid use of %qT", type
);
499 if (TYPE_DOMAIN (type
))
501 type
= TREE_TYPE (type
);
504 emit_diagnostic (diag_kind
, loc
, 0,
505 "invalid use of array with unspecified bounds");
511 tree member
= TREE_OPERAND (value
, 1);
512 if (is_overloaded_fn (member
))
513 member
= get_first_fn (member
);
514 if (DECL_FUNCTION_MEMBER_P (member
)
515 && ! flag_ms_extensions
)
516 emit_diagnostic (diag_kind
, loc
, 0,
517 "invalid use of member function %qD "
518 "(did you forget the %<()%> ?)", member
);
520 emit_diagnostic (diag_kind
, loc
, 0,
521 "invalid use of member %qD "
522 "(did you forget the %<&%> ?)", member
);
526 case TEMPLATE_TYPE_PARM
:
528 emit_diagnostic (diag_kind
, loc
, 0,
529 "invalid use of %<auto%>");
531 emit_diagnostic (diag_kind
, loc
, 0,
532 "invalid use of template type parameter %qT", type
);
535 case BOUND_TEMPLATE_TEMPLATE_PARM
:
536 emit_diagnostic (diag_kind
, loc
, 0,
537 "invalid use of template template parameter %qT",
542 emit_diagnostic (diag_kind
, loc
, 0,
543 "invalid use of dependent type %qT", type
);
547 if (type
== init_list_type_node
)
549 emit_diagnostic (diag_kind
, loc
, 0,
550 "invalid use of brace-enclosed initializer list");
553 gcc_assert (type
== unknown_type_node
);
554 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
556 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
557 emit_diagnostic (diag_kind
, loc
, 0,
558 "address of overloaded function with no contextual "
560 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
561 emit_diagnostic (diag_kind
, loc
, 0,
562 "overloaded function with no contextual type information");
564 emit_diagnostic (diag_kind
, loc
, 0,
565 "insufficient contextual information to determine type");
573 /* Backward-compatibility interface to incomplete_type_diagnostic;
574 required by ../tree.c. */
575 #undef cxx_incomplete_type_error
577 cxx_incomplete_type_error (const_tree value
, const_tree type
)
579 cxx_incomplete_type_diagnostic (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
);
691 if (type_build_dtor_call (inner_type
))
693 code
= (build_special_member_call
694 (sub
, complete_dtor_identifier
, NULL
, inner_type
,
695 LOOKUP_NORMAL
, tf_warning_or_error
));
696 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type
))
697 finish_eh_cleanup (code
);
707 if (!initializer_constant_valid_p (init
, type
))
710 tree cons
= copy_node (init
);
711 CONSTRUCTOR_ELTS (init
) = NULL
;
712 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
713 code
= build_stmt (input_location
, EXPR_STMT
, code
);
715 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
723 /* The rest of the initializer is now a constant. */
724 TREE_CONSTANT (init
) = 1;
725 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
726 num_split_elts
, inner_type
);
729 /* A subroutine of store_init_value. Splits non-constant static
730 initializer INIT into a constant part and generates code to
731 perform the non-constant part of the initialization to DEST.
732 Returns the code for the runtime init. */
735 split_nonconstant_init (tree dest
, tree init
)
739 if (TREE_CODE (init
) == TARGET_EXPR
)
740 init
= TARGET_EXPR_INITIAL (init
);
741 if (TREE_CODE (init
) == CONSTRUCTOR
)
743 init
= cp_fully_fold (init
);
744 code
= push_stmt_list ();
745 if (split_nonconstant_init_1 (dest
, init
))
747 code
= pop_stmt_list (code
);
748 DECL_INITIAL (dest
) = init
;
749 TREE_READONLY (dest
) = 0;
752 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
757 /* Perform appropriate conversions on the initial value of a variable,
758 store it in the declaration DECL,
759 and print any error messages that are appropriate.
760 If the init is invalid, store an ERROR_MARK.
762 C++: Note that INIT might be a TREE_LIST, which would mean that it is
763 a base class initializer for some aggregate type, hopefully compatible
764 with DECL. If INIT is a single element, and DECL is an aggregate
765 type, we silently convert INIT into a TREE_LIST, allowing a constructor
768 If INIT is a TREE_LIST and there is no constructor, turn INIT
769 into a CONSTRUCTOR and use standard initialization techniques.
770 Perhaps a warning should be generated?
772 Returns code to be executed if initialization could not be performed
773 for static variable. In that case, caller must emit the code. */
776 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
780 /* If variable's type was invalidly declared, just ignore it. */
782 type
= TREE_TYPE (decl
);
783 if (TREE_CODE (type
) == ERROR_MARK
)
786 if (MAYBE_CLASS_TYPE_P (type
))
788 if (TREE_CODE (init
) == TREE_LIST
)
790 error ("constructor syntax used, but no constructor declared "
791 "for type %qT", type
);
792 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
796 /* End of special C++ code. */
798 if (flags
& LOOKUP_ALREADY_DIGESTED
)
801 /* Digest the specified initializer into an expression. */
802 value
= digest_init_flags (type
, init
, flags
);
804 value
= extend_ref_init_temps (decl
, value
, cleanups
);
806 /* In C++11 constant expression is a semantic, not syntactic, property.
807 In C++98, make sure that what we thought was a constant expression at
808 template definition time is still constant and otherwise perform this
809 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
810 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
813 value
= instantiate_non_dependent_expr (value
);
814 if (DECL_DECLARED_CONSTEXPR_P (decl
)
815 || DECL_IN_AGGR_P (decl
))
817 /* Diagnose a non-constant initializer for constexpr. */
818 if (processing_template_decl
819 && !require_potential_constant_expression (value
))
820 value
= error_mark_node
;
822 value
= cxx_constant_value (value
, decl
);
824 value
= maybe_constant_init (value
, decl
);
825 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
826 /* Poison this CONSTRUCTOR so it can't be copied to another
827 constexpr variable. */
828 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
829 const_init
= (reduced_constant_expression_p (value
)
830 || error_operand_p (value
));
831 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
832 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
834 value
= cp_fully_fold (value
);
836 if (cxx_dialect
>= cxx14
&& CLASS_TYPE_P (strip_array_types (type
)))
837 /* Handle aggregate NSDMI in non-constant initializers, too. */
838 value
= replace_placeholders (value
, decl
);
840 /* DECL may change value; purge caches. */
841 clear_cv_and_fold_caches ();
843 /* If the initializer is not a constant, fill in DECL_INITIAL with
844 the bits that are constant, and then return an expression that
845 will perform the dynamic initialization. */
846 if (value
!= error_mark_node
847 && (TREE_SIDE_EFFECTS (value
)
848 || array_of_runtime_bound_p (type
)
849 || ! reduced_constant_expression_p (value
)))
850 return split_nonconstant_init (decl
, value
);
851 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
852 is an automatic variable, the middle end will turn this into a
853 dynamic initialization later. */
854 DECL_INITIAL (decl
) = value
;
859 /* Give diagnostic about narrowing conversions within { }. */
862 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
864 tree ftype
= unlowered_expr_type (init
);
868 if (((!warn_narrowing
|| !(complain
& tf_warning
))
869 && cxx_dialect
== cxx98
)
870 || !ARITHMETIC_TYPE_P (type
))
873 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
874 && TREE_CODE (type
) == COMPLEX_TYPE
)
876 tree elttype
= TREE_TYPE (type
);
877 if (CONSTRUCTOR_NELTS (init
) > 0)
878 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
880 if (CONSTRUCTOR_NELTS (init
) > 1)
881 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
886 init
= fold_non_dependent_expr (init
);
888 if (TREE_CODE (type
) == INTEGER_TYPE
889 && TREE_CODE (ftype
) == REAL_TYPE
)
891 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
892 && CP_INTEGRAL_TYPE_P (type
))
894 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
895 /* Check for narrowing based on the values of the enumeration. */
896 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
897 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
898 TYPE_MAX_VALUE (ftype
))
899 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
900 TYPE_MIN_VALUE (type
)))
901 && (TREE_CODE (init
) != INTEGER_CST
902 || !int_fits_type_p (init
, type
)))
905 else if (TREE_CODE (ftype
) == REAL_TYPE
906 && TREE_CODE (type
) == REAL_TYPE
)
908 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
910 if (TREE_CODE (init
) == REAL_CST
)
912 /* Issue 703: Loss of precision is OK as long as the value is
913 within the representable range of the new type. */
915 d
= TREE_REAL_CST (init
);
916 real_convert (&r
, TYPE_MODE (type
), &d
);
924 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
925 && TREE_CODE (type
) == REAL_TYPE
)
928 if (TREE_CODE (init
) == INTEGER_CST
)
930 d
= real_value_from_int_cst (0, init
);
931 if (exact_real_truncate (TYPE_MODE (type
), &d
))
937 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
939 tree folded
= cp_fully_fold (init
);
940 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
946 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
947 if (cxx_dialect
== cxx98
)
949 if (complain
& tf_warning
)
950 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
951 "from %qT to %qT inside { } is ill-formed in C++11",
955 else if (!CONSTANT_CLASS_P (init
))
957 if (complain
& tf_warning_or_error
)
959 if (!almost_ok
|| pedantic
)
960 pedwarn (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
961 "from %qT to %qT inside { }", init
, ftype
, type
);
962 if (pedantic
&& almost_ok
)
963 inform (loc
, " the expression has a constant value but is not "
964 "a C++ constant-expression");
968 else if (complain
& tf_error
)
970 int savederrorcount
= errorcount
;
971 global_dc
->pedantic_errors
= 1;
972 pedwarn (loc
, OPT_Wnarrowing
,
973 "narrowing conversion of %qE from %qT to %qT "
974 "inside { }", init
, ftype
, type
);
975 if (errorcount
== savederrorcount
)
977 global_dc
->pedantic_errors
= flag_pedantic_errors
;
984 /* Process the initializer INIT for a variable of type TYPE, emitting
985 diagnostics for invalid initializers and converting the initializer as
988 For aggregate types, it assumes that reshape_init has already run, thus the
989 initializer will have the right shape (brace elision has been undone).
991 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
994 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
995 tsubst_flags_t complain
)
997 enum tree_code code
= TREE_CODE (type
);
999 if (error_operand_p (init
))
1000 return error_mark_node
;
1004 /* We must strip the outermost array type when completing the type,
1005 because the its bounds might be incomplete at the moment. */
1006 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
1007 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1009 return error_mark_node
;
1011 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1012 (g++.old-deja/g++.law/casts2.C). */
1013 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1014 init
= TREE_OPERAND (init
, 0);
1016 /* Initialization of an array of chars from a string constant. The initializer
1017 can be optionally enclosed in braces, but reshape_init has already removed
1018 them if they were present. */
1019 if (code
== ARRAY_TYPE
)
1021 if (nested
&& !TYPE_DOMAIN (type
))
1023 /* C++ flexible array members have a null domain. */
1024 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wpedantic
,
1025 "initialization of a flexible array member");
1028 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1029 if (char_type_p (typ1
)
1031 && TREE_CODE (init
) == STRING_CST
)
1033 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1035 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1037 if (char_type
!= char_type_node
)
1039 if (complain
& tf_error
)
1040 error ("char-array initialized from wide string");
1041 return error_mark_node
;
1046 if (char_type
== char_type_node
)
1048 if (complain
& tf_error
)
1049 error ("int-array initialized from non-wide string");
1050 return error_mark_node
;
1052 else if (char_type
!= typ1
)
1054 if (complain
& tf_error
)
1055 error ("int-array initialized from incompatible "
1057 return error_mark_node
;
1061 if (type
!= TREE_TYPE (init
))
1063 init
= copy_node (init
);
1064 TREE_TYPE (init
) = type
;
1066 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1068 /* Not a flexible array member. */
1069 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1070 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1071 /* In C it is ok to subtract 1 from the length of the string
1072 because it's ok to ignore the terminating null char that is
1073 counted in the length of the constant, but in C++ this would
1075 if (size
< TREE_STRING_LENGTH (init
))
1076 permerror (input_location
, "initializer-string for array "
1077 "of chars is too long");
1083 /* Handle scalar types (including conversions) and references. */
1084 if ((TREE_CODE (type
) != COMPLEX_TYPE
1085 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1086 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1089 flags
|= LOOKUP_NO_NARROWING
;
1090 init
= convert_for_initialization (0, type
, init
, flags
,
1091 ICR_INIT
, NULL_TREE
, 0,
1097 /* Come here only for aggregates: records, arrays, unions, complex numbers
1099 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1100 || VECTOR_TYPE_P (type
)
1101 || TREE_CODE (type
) == RECORD_TYPE
1102 || TREE_CODE (type
) == UNION_TYPE
1103 || TREE_CODE (type
) == COMPLEX_TYPE
);
1105 /* "If T is a class type and the initializer list has a single
1106 element of type cv U, where U is T or a class derived from T,
1107 the object is initialized from that element." */
1109 && cxx_dialect
>= cxx11
1110 && BRACE_ENCLOSED_INITIALIZER_P (init
)
1111 && CONSTRUCTOR_NELTS (init
) == 1
1112 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1113 || VECTOR_TYPE_P (type
)))
1115 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
1116 if (reference_related_p (type
, TREE_TYPE (elt
)))
1117 /* We should have fixed this in reshape_init. */
1121 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1122 && !TYPE_NON_AGGREGATE_CLASS (type
))
1123 return process_init_constructor (type
, init
, complain
);
1126 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1128 if (complain
& tf_error
)
1129 error ("cannot initialize aggregate of type %qT with "
1130 "a compound literal", type
);
1132 return error_mark_node
;
1135 if (TREE_CODE (type
) == ARRAY_TYPE
1136 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1138 /* Allow the result of build_array_copy and of
1139 build_value_init_noctor. */
1140 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1141 || TREE_CODE (init
) == CONSTRUCTOR
)
1142 && (same_type_ignoring_top_level_qualifiers_p
1143 (type
, TREE_TYPE (init
))))
1146 if (complain
& tf_error
)
1147 error ("array must be initialized with a brace-enclosed"
1149 return error_mark_node
;
1152 return convert_for_initialization (NULL_TREE
, type
, init
,
1154 ICR_INIT
, NULL_TREE
, 0,
1160 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1162 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1166 digest_init_flags (tree type
, tree init
, int flags
)
1168 return digest_init_r (type
, init
, false, flags
, tf_warning_or_error
);
1171 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1173 digest_nsdmi_init (tree decl
, tree init
)
1175 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1177 tree type
= TREE_TYPE (decl
);
1178 int flags
= LOOKUP_IMPLICIT
;
1179 if (DIRECT_LIST_INIT_P (init
))
1180 flags
= LOOKUP_NORMAL
;
1181 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1182 && CP_AGGREGATE_TYPE_P (type
))
1183 init
= reshape_init (type
, init
, tf_warning_or_error
);
1184 init
= digest_init_flags (type
, init
, flags
);
1185 if (TREE_CODE (init
) == TARGET_EXPR
)
1186 /* This represents the whole initialization. */
1187 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1191 /* Set of flags used within process_init_constructor to describe the
1193 #define PICFLAG_ERRONEOUS 1
1194 #define PICFLAG_NOT_ALL_CONSTANT 2
1195 #define PICFLAG_NOT_ALL_SIMPLE 4
1196 #define PICFLAG_SIDE_EFFECTS 8
1198 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1202 picflag_from_initializer (tree init
)
1204 if (init
== error_mark_node
)
1205 return PICFLAG_ERRONEOUS
;
1206 else if (!TREE_CONSTANT (init
))
1208 if (TREE_SIDE_EFFECTS (init
))
1209 return PICFLAG_SIDE_EFFECTS
;
1211 return PICFLAG_NOT_ALL_CONSTANT
;
1213 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1214 return PICFLAG_NOT_ALL_SIMPLE
;
1218 /* Adjust INIT for going into a CONSTRUCTOR. */
1221 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1223 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1224 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1225 if (SIMPLE_TARGET_EXPR_P (init
))
1226 init
= TARGET_EXPR_INITIAL (init
);
1227 /* When we defer constant folding within a statement, we may want to
1228 defer this folding as well. */
1229 tree t
= fold_non_dependent_expr (init
);
1230 t
= maybe_constant_init (t
);
1231 if (TREE_CONSTANT (t
))
1236 /* Subroutine of process_init_constructor, which will process an initializer
1237 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1238 which describe the initializers. */
1241 process_init_constructor_array (tree type
, tree init
,
1242 tsubst_flags_t complain
)
1244 unsigned HOST_WIDE_INT i
, len
= 0;
1246 bool unbounded
= false;
1247 constructor_elt
*ce
;
1248 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1250 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1251 || VECTOR_TYPE_P (type
));
1253 if (TREE_CODE (type
) == ARRAY_TYPE
)
1255 /* C++ flexible array members have a null domain. */
1256 tree domain
= TYPE_DOMAIN (type
);
1257 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1258 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1259 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1260 TYPE_PRECISION (TREE_TYPE (domain
)),
1261 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1263 unbounded
= true; /* Take as many as there are. */
1266 /* Vectors are like simple fixed-size arrays. */
1267 len
= TYPE_VECTOR_SUBPARTS (type
);
1269 /* There must not be more initializers than needed. */
1270 if (!unbounded
&& vec_safe_length (v
) > len
)
1272 if (complain
& tf_error
)
1273 error ("too many initializers for %qT", type
);
1275 return PICFLAG_ERRONEOUS
;
1278 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1282 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1283 if (compare_tree_int (ce
->index
, i
) != 0)
1285 ce
->value
= error_mark_node
;
1286 sorry ("non-trivial designated initializers not supported");
1290 ce
->index
= size_int (i
);
1291 gcc_assert (ce
->value
);
1292 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1294 if (ce
->value
!= error_mark_node
)
1295 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1296 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1298 flags
|= picflag_from_initializer (ce
->value
);
1301 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1302 we must add initializers ourselves. */
1304 for (; i
< len
; ++i
)
1308 if (type_build_ctor_call (TREE_TYPE (type
)))
1310 /* If this type needs constructors run for default-initialization,
1311 we can't rely on the back end to do it for us, so make the
1312 initialization explicit by list-initializing from T{}. */
1313 next
= build_constructor (init_list_type_node
, NULL
);
1314 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1315 if (initializer_zerop (next
))
1316 /* The default zero-initialization is fine for us; don't
1317 add anything to the CONSTRUCTOR. */
1320 else if (!zero_init_p (TREE_TYPE (type
)))
1321 next
= build_zero_init (TREE_TYPE (type
),
1322 /*nelts=*/NULL_TREE
,
1323 /*static_storage_p=*/false);
1325 /* The default zero-initialization is fine for us; don't
1326 add anything to the CONSTRUCTOR. */
1331 flags
|= picflag_from_initializer (next
);
1332 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1336 CONSTRUCTOR_ELTS (init
) = v
;
1340 /* Subroutine of process_init_constructor, which will process an initializer
1341 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1342 the initializers. */
1345 process_init_constructor_record (tree type
, tree init
,
1346 tsubst_flags_t complain
)
1348 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1352 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1353 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1354 gcc_assert (!TYPE_BINFO (type
)
1355 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1356 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1360 unsigned HOST_WIDE_INT idx
= 0;
1361 /* Generally, we will always have an index for each initializer (which is
1362 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1363 reshape_init. So we need to handle both cases. */
1364 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1369 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1372 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1375 /* If this is a bitfield, first convert to the declared type. */
1376 type
= TREE_TYPE (field
);
1377 if (DECL_BIT_FIELD_TYPE (field
))
1378 type
= DECL_BIT_FIELD_TYPE (field
);
1379 if (type
== error_mark_node
)
1380 return PICFLAG_ERRONEOUS
;
1382 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1384 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1387 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1388 latter case can happen in templates where lookup has to be
1390 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1391 || identifier_p (ce
->index
));
1392 if (ce
->index
!= field
1393 && ce
->index
!= DECL_NAME (field
))
1395 ce
->value
= error_mark_node
;
1396 sorry ("non-trivial designated initializers not supported");
1400 gcc_assert (ce
->value
);
1401 next
= massage_init_elt (type
, ce
->value
, complain
);
1404 else if (DECL_INITIAL (field
))
1408 /* We're using an NSDMI past a field with implicit
1409 zero-init. Go back and make it explicit. */
1411 vec_safe_truncate (v
, 0);
1414 /* C++14 aggregate NSDMI. */
1415 next
= get_nsdmi (field
, /*ctor*/false);
1417 else if (type_build_ctor_call (TREE_TYPE (field
)))
1419 /* If this type needs constructors run for
1420 default-initialization, we can't rely on the back end to do it
1421 for us, so build up TARGET_EXPRs. If the type in question is
1422 a class, just build one up; if it's an array, recurse. */
1423 next
= build_constructor (init_list_type_node
, NULL
);
1424 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1426 /* Warn when some struct elements are implicitly initialized. */
1427 if ((complain
& tf_warning
)
1428 && !EMPTY_CONSTRUCTOR_P (init
))
1429 warning (OPT_Wmissing_field_initializers
,
1430 "missing initializer for member %qD", field
);
1434 const_tree fldtype
= TREE_TYPE (field
);
1435 if (TREE_CODE (fldtype
) == REFERENCE_TYPE
)
1437 if (complain
& tf_error
)
1438 error ("member %qD is uninitialized reference", field
);
1440 return PICFLAG_ERRONEOUS
;
1442 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1444 if (complain
& tf_error
)
1445 error ("member %qD with uninitialized reference fields", field
);
1447 return PICFLAG_ERRONEOUS
;
1450 /* Warn when some struct elements are implicitly initialized
1451 to zero. However, avoid issuing the warning for flexible
1452 array members since they need not have any elements. */
1453 if ((TREE_CODE (fldtype
) != ARRAY_TYPE
|| TYPE_DOMAIN (fldtype
))
1454 && (complain
& tf_warning
)
1455 && !EMPTY_CONSTRUCTOR_P (init
))
1456 warning (OPT_Wmissing_field_initializers
,
1457 "missing initializer for member %qD", field
);
1459 if (!zero_init_p (fldtype
)
1461 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1462 /*static_storage_p=*/false);
1465 /* The default zero-initialization is fine for us; don't
1466 add anything to the CONSTRUCTOR. */
1472 /* If this is a bitfield, now convert to the lowered type. */
1473 if (type
!= TREE_TYPE (field
))
1474 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1475 flags
|= picflag_from_initializer (next
);
1476 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1479 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1481 if (complain
& tf_error
)
1482 error ("too many initializers for %qT", type
);
1484 return PICFLAG_ERRONEOUS
;
1487 CONSTRUCTOR_ELTS (init
) = v
;
1491 /* Subroutine of process_init_constructor, which will process a single
1492 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1493 which describe the initializer. */
1496 process_init_constructor_union (tree type
, tree init
,
1497 tsubst_flags_t complain
)
1499 constructor_elt
*ce
;
1502 /* If the initializer was empty, use the union's NSDMI if it has one.
1503 Otherwise use default zero initialization. */
1504 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1506 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1508 if (DECL_INITIAL (field
))
1510 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
),
1512 get_nsdmi (field
, /*in_ctor=*/false));
1517 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1521 len
= CONSTRUCTOR_ELTS (init
)->length ();
1524 if (!(complain
& tf_error
))
1525 return PICFLAG_ERRONEOUS
;
1526 error ("too many initializers for %qT", type
);
1527 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1530 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1532 /* If this element specifies a field, initialize via that field. */
1535 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1537 else if (identifier_p (ce
->index
))
1539 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1540 tree name
= ce
->index
;
1542 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1543 if (DECL_NAME (field
) == name
)
1547 if (complain
& tf_error
)
1548 error ("no field %qD found in union being initialized",
1550 ce
->value
= error_mark_node
;
1556 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1557 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1558 if (complain
& tf_error
)
1559 error ("index value instead of field name in union initializer");
1560 ce
->value
= error_mark_node
;
1565 /* Find the first named field. ANSI decided in September 1990
1566 that only named fields count here. */
1567 tree field
= TYPE_FIELDS (type
);
1568 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1569 field
= TREE_CHAIN (field
);
1570 if (field
== NULL_TREE
)
1572 if (complain
& tf_error
)
1573 error ("too many initializers for %qT", type
);
1574 ce
->value
= error_mark_node
;
1579 if (ce
->value
&& ce
->value
!= error_mark_node
)
1580 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1582 return picflag_from_initializer (ce
->value
);
1585 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1586 constructor is a brace-enclosed initializer, and will be modified in-place.
1588 Each element is converted to the right type through digest_init, and
1589 missing initializers are added following the language rules (zero-padding,
1592 After the execution, the initializer will have TREE_CONSTANT if all elts are
1593 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1594 constants that the assembler and linker can compute them.
1596 The function returns the initializer itself, or error_mark_node in case
1600 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1604 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1606 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
1607 flags
= process_init_constructor_array (type
, init
, complain
);
1608 else if (TREE_CODE (type
) == RECORD_TYPE
)
1609 flags
= process_init_constructor_record (type
, init
, complain
);
1610 else if (TREE_CODE (type
) == UNION_TYPE
)
1611 flags
= process_init_constructor_union (type
, init
, complain
);
1615 if (flags
& PICFLAG_ERRONEOUS
)
1616 return error_mark_node
;
1618 TREE_TYPE (init
) = type
;
1619 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1620 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1621 if (flags
& PICFLAG_SIDE_EFFECTS
)
1623 TREE_CONSTANT (init
) = false;
1624 TREE_SIDE_EFFECTS (init
) = true;
1626 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1627 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1628 TREE_CONSTANT (init
) = false;
1631 TREE_CONSTANT (init
) = 1;
1632 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1633 TREE_STATIC (init
) = 1;
1638 /* Given a structure or union value DATUM, construct and return
1639 the structure or union component which results from narrowing
1640 that value to the base specified in BASETYPE. For example, given the
1643 class L { int ii; };
1644 class A : L { ... };
1645 class B : L { ... };
1646 class C : A, B { ... };
1654 x.A::ii refers to the ii member of the L part of
1655 the A part of the C object named by X. In this case,
1656 DATUM would be x, and BASETYPE would be A.
1658 I used to think that this was nonconformant, that the standard specified
1659 that first we look up ii in A, then convert x to an L& and pull out the
1660 ii part. But in fact, it does say that we convert x to an A&; A here
1661 is known as the "naming class". (jason 2000-12-19)
1663 BINFO_P points to a variable initialized either to NULL_TREE or to the
1664 binfo for the specific base subobject we want to convert to. */
1667 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1671 if (datum
== error_mark_node
)
1672 return error_mark_node
;
1676 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1677 NULL
, tf_warning_or_error
);
1679 if (!binfo
|| binfo
== error_mark_node
)
1681 *binfo_p
= NULL_TREE
;
1683 error_not_base_type (basetype
, TREE_TYPE (datum
));
1684 return error_mark_node
;
1688 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1689 tf_warning_or_error
);
1692 /* Build a reference to an object specified by the C++ `->' operator.
1693 Usually this just involves dereferencing the object, but if the
1694 `->' operator is overloaded, then such overloads must be
1695 performed until an object which does not have the `->' operator
1696 overloaded is found. An error is reported when circular pointer
1697 delegation is detected. */
1700 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1702 tree orig_expr
= expr
;
1703 tree type
= TREE_TYPE (expr
);
1704 tree last_rval
= NULL_TREE
;
1705 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1707 if (type
== error_mark_node
)
1708 return error_mark_node
;
1710 if (processing_template_decl
)
1712 if (type_dependent_expression_p (expr
))
1713 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1714 expr
= build_non_dependent_expr (expr
);
1717 if (MAYBE_CLASS_TYPE_P (type
))
1719 struct tinst_level
*actual_inst
= current_instantiation ();
1722 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1723 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1726 if (expr
== error_mark_node
)
1727 return error_mark_node
;
1729 /* This provides a better instantiation backtrace in case of
1731 if (fn
&& DECL_USE_TEMPLATE (fn
))
1732 push_tinst_level_loc (fn
,
1733 (current_instantiation () != actual_inst
)
1734 ? DECL_SOURCE_LOCATION (fn
)
1738 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1740 if (complain
& tf_error
)
1741 error ("circular pointer delegation detected");
1742 return error_mark_node
;
1745 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1749 while (current_instantiation () != actual_inst
)
1752 if (last_rval
== NULL_TREE
)
1754 if (complain
& tf_error
)
1755 error ("base operand of %<->%> has non-pointer type %qT", type
);
1756 return error_mark_node
;
1759 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1760 last_rval
= convert_from_reference (last_rval
);
1763 last_rval
= decay_conversion (expr
, complain
);
1765 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1767 if (processing_template_decl
)
1769 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1771 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1775 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1778 if (complain
& tf_error
)
1781 error ("result of %<operator->()%> yields non-pointer result");
1783 error ("base operand of %<->%> is not a pointer");
1785 return error_mark_node
;
1788 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1789 already been checked out to be of aggregate type. */
1792 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1800 if (error_operand_p (datum
) || error_operand_p (component
))
1801 return error_mark_node
;
1803 datum
= mark_lvalue_use (datum
);
1804 component
= mark_rvalue_use (component
);
1806 ptrmem_type
= TREE_TYPE (component
);
1807 if (!TYPE_PTRMEM_P (ptrmem_type
))
1809 if (complain
& tf_error
)
1810 error ("%qE cannot be used as a member pointer, since it is of "
1811 "type %qT", component
, ptrmem_type
);
1812 return error_mark_node
;
1815 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1816 if (! MAYBE_CLASS_TYPE_P (objtype
))
1818 if (complain
& tf_error
)
1819 error ("cannot apply member pointer %qE to %qE, which is of "
1820 "non-class type %qT", component
, datum
, objtype
);
1821 return error_mark_node
;
1824 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1825 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1827 if (!COMPLETE_TYPE_P (ctype
))
1829 if (!same_type_p (ctype
, objtype
))
1835 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1840 if (complain
& tf_error
)
1841 error ("pointer to member type %qT incompatible with object "
1842 "type %qT", type
, objtype
);
1843 return error_mark_node
;
1845 else if (binfo
== error_mark_node
)
1846 return error_mark_node
;
1849 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1851 cp_lvalue_kind kind
= lvalue_kind (datum
);
1854 /* Compute the type of the field, as described in [expr.ref].
1855 There's no such thing as a mutable pointer-to-member, so
1856 things are not as complex as they are for references to
1857 non-static data members. */
1858 type
= cp_build_qualified_type (type
,
1859 (cp_type_quals (type
)
1860 | cp_type_quals (TREE_TYPE (datum
))));
1862 datum
= build_address (datum
);
1864 /* Convert object to the correct base. */
1867 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1868 if (datum
== error_mark_node
)
1869 return error_mark_node
;
1872 /* Build an expression for "object + offset" where offset is the
1873 value stored in the pointer-to-data-member. */
1874 ptype
= build_pointer_type (type
);
1875 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1876 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1877 if (datum
== error_mark_node
)
1878 return error_mark_node
;
1880 /* If the object expression was an rvalue, return an rvalue. */
1881 if (kind
& clk_class
)
1882 datum
= rvalue (datum
);
1883 else if (kind
& clk_rvalueref
)
1884 datum
= move (datum
);
1889 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1890 program is ill-formed if the second operand is a pointer to member
1891 function with ref-qualifier &. In a .* expression whose object
1892 expression is an lvalue, the program is ill-formed if the second
1893 operand is a pointer to member function with ref-qualifier &&. */
1894 if (FUNCTION_REF_QUALIFIED (type
))
1896 bool lval
= real_lvalue_p (datum
);
1897 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1899 if (complain
& tf_error
)
1900 error ("pointer-to-member-function type %qT requires an rvalue",
1902 return error_mark_node
;
1904 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1906 if (complain
& tf_error
)
1907 error ("pointer-to-member-function type %qT requires an lvalue",
1909 return error_mark_node
;
1912 return build2 (OFFSET_REF
, type
, datum
, component
);
1916 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1919 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1921 /* This is either a call to a constructor,
1922 or a C cast in C++'s `functional' notation. */
1924 /* The type to which we are casting. */
1926 vec
<tree
, va_gc
> *parmvec
;
1928 if (error_operand_p (exp
) || parms
== error_mark_node
)
1929 return error_mark_node
;
1931 if (TREE_CODE (exp
) == TYPE_DECL
)
1933 type
= TREE_TYPE (exp
);
1935 if (complain
& tf_warning
1936 && TREE_DEPRECATED (type
)
1937 && DECL_ARTIFICIAL (exp
))
1938 warn_deprecated_use (type
, NULL_TREE
);
1943 /* We need to check this explicitly, since value-initialization of
1944 arrays is allowed in other situations. */
1945 if (TREE_CODE (type
) == ARRAY_TYPE
)
1947 if (complain
& tf_error
)
1948 error ("functional cast to array type %qT", type
);
1949 return error_mark_node
;
1952 if (type_uses_auto (type
))
1954 if (complain
& tf_error
)
1955 error ("invalid use of %<auto%>");
1956 return error_mark_node
;
1959 if (processing_template_decl
)
1963 /* Diagnose this even in a template. We could also try harder
1964 to give all the usual errors when the type and args are
1966 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1968 if (complain
& tf_error
)
1969 error ("invalid value-initialization of reference type");
1970 return error_mark_node
;
1973 t
= build_min (CAST_EXPR
, type
, parms
);
1974 /* We don't know if it will or will not have side effects. */
1975 TREE_SIDE_EFFECTS (t
) = 1;
1979 if (! MAYBE_CLASS_TYPE_P (type
))
1981 if (parms
== NULL_TREE
)
1983 if (VOID_TYPE_P (type
))
1985 return build_value_init (cv_unqualified (type
), complain
);
1988 /* This must build a C cast. */
1989 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
1990 return cp_build_c_cast (type
, parms
, complain
);
1993 /* Prepare to evaluate as a call to a constructor. If this expression
1994 is actually used, for example,
1996 return X (arg1, arg2, ...);
1998 then the slot being initialized will be filled in. */
2000 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2001 return error_mark_node
;
2002 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
2003 return error_mark_node
;
2007 If the expression list is a single-expression, the type
2008 conversion is equivalent (in definedness, and if defined in
2009 meaning) to the corresponding cast expression. */
2010 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2011 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
2015 The expression T(), where T is a simple-type-specifier for a
2016 non-array complete object type or the (possibly cv-qualified)
2017 void type, creates an rvalue of the specified type, which is
2018 value-initialized. */
2020 if (parms
== NULL_TREE
)
2022 exp
= build_value_init (type
, complain
);
2023 exp
= get_target_expr_sfinae (exp
, complain
);
2027 /* Call the constructor. */
2028 parmvec
= make_tree_vector ();
2029 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2030 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2031 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2032 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2033 release_tree_vector (parmvec
);
2035 if (exp
== error_mark_node
)
2036 return error_mark_node
;
2038 return build_cplus_new (type
, exp
, complain
);
2042 /* Add new exception specifier SPEC, to the LIST we currently have.
2043 If it's already in LIST then do nothing.
2044 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2045 know what we're doing. */
2048 add_exception_specifier (tree list
, tree spec
, int complain
)
2053 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2055 if (spec
== error_mark_node
)
2058 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2060 /* [except.spec] 1, type in an exception specifier shall not be
2061 incomplete, or pointer or ref to incomplete other than pointer
2063 is_ptr
= TYPE_PTR_P (core
);
2064 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2065 core
= TREE_TYPE (core
);
2068 else if (VOID_TYPE_P (core
))
2070 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2072 else if (processing_template_decl
)
2077 /* 15.4/1 says that types in an exception specifier must be complete,
2078 but it seems more reasonable to only require this on definitions
2079 and calls. So just give a pedwarn at this point; we will give an
2080 error later if we hit one of those two cases. */
2081 if (!COMPLETE_TYPE_P (complete_type (core
)))
2082 diag_type
= DK_PEDWARN
; /* pedwarn */
2089 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2090 if (same_type_p (TREE_VALUE (probe
), spec
))
2093 list
= tree_cons (NULL_TREE
, spec
, list
);
2096 diag_type
= DK_ERROR
; /* error */
2098 if (diag_type
!= DK_UNSPECIFIED
2099 && (complain
& tf_warning_or_error
))
2100 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2105 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2108 nothrow_spec_p_uninst (const_tree spec
)
2110 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2112 return nothrow_spec_p (spec
);
2115 /* Combine the two exceptions specifier lists LIST and ADD, and return
2119 merge_exception_specifiers (tree list
, tree add
)
2121 tree noex
, orig_list
;
2123 /* No exception-specifier or noexcept(false) are less strict than
2124 anything else. Prefer the newer variant (LIST). */
2125 if (!list
|| list
== noexcept_false_spec
)
2127 else if (!add
|| add
== noexcept_false_spec
)
2130 /* noexcept(true) and throw() are stricter than anything else.
2131 As above, prefer the more recent one (LIST). */
2132 if (nothrow_spec_p_uninst (add
))
2135 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2136 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2137 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2139 /* We should have instantiated other deferred noexcept specs by now. */
2140 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2142 if (nothrow_spec_p_uninst (list
))
2144 noex
= TREE_PURPOSE (list
);
2145 gcc_checking_assert (!TREE_PURPOSE (add
)
2146 || errorcount
|| !flag_exceptions
2147 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2149 /* Combine the dynamic-exception-specifiers, if any. */
2151 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2153 tree spec
= TREE_VALUE (add
);
2156 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2157 probe
= TREE_CHAIN (probe
))
2158 if (same_type_p (TREE_VALUE (probe
), spec
))
2162 spec
= build_tree_list (NULL_TREE
, spec
);
2163 TREE_CHAIN (spec
) = list
;
2168 /* Keep the noexcept-specifier at the beginning of the list. */
2169 if (noex
!= TREE_PURPOSE (list
))
2170 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2175 /* Subroutine of build_call. Ensure that each of the types in the
2176 exception specification is complete. Technically, 15.4/1 says that
2177 they need to be complete when we see a declaration of the function,
2178 but we should be able to get away with only requiring this when the
2179 function is defined or called. See also add_exception_specifier. */
2182 require_complete_eh_spec_types (tree fntype
, tree decl
)
2185 /* Don't complain about calls to op new. */
2186 if (decl
&& DECL_ARTIFICIAL (decl
))
2188 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2189 raises
= TREE_CHAIN (raises
))
2191 tree type
= TREE_VALUE (raises
);
2192 if (type
&& !COMPLETE_TYPE_P (type
))
2196 ("call to function %qD which throws incomplete type %q#T",
2199 error ("call to function which throws incomplete type %q#T",
2206 #include "gt-cp-typeck2.h"