1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2015 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"
35 #include "stor-layout.h"
40 #include "diagnostic-core.h"
43 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
);
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
50 error_not_base_type (tree basetype
, tree type
)
52 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
53 basetype
= DECL_CONTEXT (basetype
);
54 error ("type %qT is not a base type for type %qT", basetype
, type
);
55 return error_mark_node
;
59 binfo_or_else (tree base
, tree type
)
61 tree binfo
= lookup_base (type
, base
, ba_unique
,
62 NULL
, tf_warning_or_error
);
64 if (binfo
== error_mark_node
)
67 error_not_base_type (base
, type
);
71 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
72 value may not be changed thereafter. */
75 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
78 /* This macro is used to emit diagnostics to ensure that all format
79 strings are complete sentences, visible to gettext and checked at
82 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
103 /* Handle C++-specific things first. */
106 && DECL_LANG_SPECIFIC (arg
)
107 && DECL_IN_AGGR_P (arg
)
108 && !TREE_STATIC (arg
))
109 ERROR_FOR_ASSIGNMENT (G_("assignment of "
110 "constant field %qD"),
111 G_("constant field %qD "
112 "used as %<asm%> output"),
114 "constant field %qD"),
116 "constant field %qD"),
118 else if (INDIRECT_REF_P (arg
)
119 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
120 && (VAR_P (TREE_OPERAND (arg
, 0))
121 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
122 ERROR_FOR_ASSIGNMENT (G_("assignment of "
123 "read-only reference %qD"),
124 G_("read-only reference %qD "
125 "used as %<asm%> output"),
127 "read-only reference %qD"),
129 "read-only reference %qD"),
130 TREE_OPERAND (arg
, 0));
132 readonly_error (input_location
, arg
, errstring
);
136 /* Structure that holds information about declarations whose type was
137 incomplete and we could not check whether it was abstract or not. */
139 struct GTY((chain_next ("%h.next"), for_user
)) pending_abstract_type
{
140 /* Declaration which we are checking for abstractness. It is either
141 a DECL node, or an IDENTIFIER_NODE if we do not have a full
142 declaration available. */
145 /* Type which will be checked for abstractness. */
148 /* Kind of use in an unnamed declarator. */
149 abstract_class_use use
;
151 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
152 because DECLs already carry locus information. */
155 /* Link to the next element in list. */
156 struct pending_abstract_type
* next
;
159 struct abstract_type_hasher
: ggc_hasher
<pending_abstract_type
*>
161 typedef tree compare_type
;
162 static hashval_t
hash (pending_abstract_type
*);
163 static bool equal (pending_abstract_type
*, tree
);
166 /* Compute the hash value of the node VAL. This function is used by the
167 hash table abstract_pending_vars. */
170 abstract_type_hasher::hash (pending_abstract_type
*pat
)
172 return (hashval_t
) TYPE_UID (pat
->type
);
176 /* Compare node VAL1 with the type VAL2. This function is used by the
177 hash table abstract_pending_vars. */
180 abstract_type_hasher::equal (pending_abstract_type
*pat1
, tree type2
)
182 return (pat1
->type
== type2
);
185 /* Hash table that maintains pending_abstract_type nodes, for which we still
186 need to check for type abstractness. The key of the table is the type
187 of the declaration. */
188 static GTY (()) hash_table
<abstract_type_hasher
> *abstract_pending_vars
= NULL
;
190 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
192 /* This function is called after TYPE is completed, and will check if there
193 are pending declarations for which we still need to verify the abstractness
194 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
195 turned out to be incomplete. */
198 complete_type_check_abstract (tree type
)
200 struct pending_abstract_type
*pat
;
201 location_t cur_loc
= input_location
;
203 gcc_assert (COMPLETE_TYPE_P (type
));
205 if (!abstract_pending_vars
)
208 /* Retrieve the list of pending declarations for this type. */
209 pending_abstract_type
**slot
210 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
217 /* If the type is not abstract, do not do anything. */
218 if (CLASSTYPE_PURE_VIRTUALS (type
))
220 struct pending_abstract_type
*prev
= 0, *next
;
222 /* Reverse the list to emit the errors in top-down order. */
223 for (; pat
; pat
= next
)
231 /* Go through the list, and call abstract_virtuals_error for each
232 element: it will issue a diagnostic if the type is abstract. */
235 gcc_assert (type
== pat
->type
);
237 /* Tweak input_location so that the diagnostic appears at the correct
238 location. Notice that this is only needed if the decl is an
240 input_location
= pat
->locus
;
241 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
242 tf_warning_or_error
);
247 abstract_pending_vars
->clear_slot (slot
);
249 input_location
= cur_loc
;
253 /* If TYPE has abstract virtual functions, issue an error about trying
254 to create an object of that type. DECL is the object declared, or
255 NULL_TREE if the declaration is unavailable, in which case USE specifies
256 the kind of invalid use. Returns 1 if an error occurred; zero if
260 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
261 tsubst_flags_t complain
)
263 vec
<tree
, va_gc
> *pure
;
265 /* This function applies only to classes. Any other entity can never
267 if (!CLASS_TYPE_P (type
))
269 type
= TYPE_MAIN_VARIANT (type
);
272 /* Instantiation here seems to be required by the standard,
273 but breaks e.g. boost::bind. FIXME! */
274 /* In SFINAE, non-N3276 context, force instantiation. */
275 if (!(complain
& (tf_error
|tf_decltype
)))
276 complete_type (type
);
279 /* If the type is incomplete, we register it within a hash table,
280 so that we can check again once it is completed. This makes sense
281 only for objects for which we have a declaration or at least a
283 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
285 struct pending_abstract_type
*pat
;
287 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
289 if (!abstract_pending_vars
)
290 abstract_pending_vars
291 = hash_table
<abstract_type_hasher
>::create_ggc (31);
293 pending_abstract_type
**slot
294 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
297 pat
= ggc_alloc
<pending_abstract_type
> ();
301 pat
->locus
= ((decl
&& DECL_P (decl
))
302 ? DECL_SOURCE_LOCATION (decl
)
311 if (!TYPE_SIZE (type
))
312 /* TYPE is being defined, and during that time
313 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
316 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
320 if (!(complain
& tf_error
))
326 error ("cannot declare variable %q+D to be of abstract "
327 "type %qT", decl
, type
);
328 else if (TREE_CODE (decl
) == PARM_DECL
)
330 if (DECL_NAME (decl
))
331 error ("cannot declare parameter %q+D to be of abstract type %qT",
334 error ("cannot declare parameter to be of abstract type %qT",
337 else if (TREE_CODE (decl
) == FIELD_DECL
)
338 error ("cannot declare field %q+D to be of abstract type %qT",
340 else if (TREE_CODE (decl
) == FUNCTION_DECL
341 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
342 error ("invalid abstract return type for member function %q+#D", decl
);
343 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
344 error ("invalid abstract return type for function %q+#D", decl
);
345 else if (identifier_p (decl
))
346 /* Here we do not have location information. */
347 error ("invalid abstract type %qT for %qE", type
, decl
);
349 error ("invalid abstract type for %q+D", decl
);
354 error ("creating array of %qT, which is an abstract class type", type
);
357 error ("invalid cast to abstract class type %qT", type
);
360 error ("invalid new-expression of abstract class type %qT", type
);
363 error ("invalid abstract return type %qT", type
);
366 error ("invalid abstract parameter type %qT", type
);
369 error ("expression of abstract class type %qT cannot "
370 "be used in throw-expression", type
);
373 error ("cannot declare catch parameter to be of abstract "
374 "class type %qT", type
);
377 error ("cannot allocate an object of abstract type %qT", type
);
380 /* Only go through this once. */
386 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
387 " because the following virtual functions are pure within %qT:",
390 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
391 if (! DECL_CLONED_FUNCTION_P (fn
)
392 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
393 inform (input_location
, "\t%+#D", fn
);
395 /* Now truncate the vector. This leaves it non-null, so we know
396 there are pure virtuals, but empty so we don't list them out
405 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
407 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
411 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
412 tsubst_flags_t complain
)
414 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
418 /* Wrapper for the above function in the common case of wanting errors. */
421 abstract_virtuals_error (tree decl
, tree type
)
423 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
427 abstract_virtuals_error (abstract_class_use use
, tree type
)
429 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
432 /* Print an inform about the declaration of the incomplete type TYPE. */
435 cxx_incomplete_type_inform (const_tree type
)
437 if (!TYPE_MAIN_DECL (type
))
440 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
441 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
443 if (current_class_type
444 && TYPE_BEING_DEFINED (current_class_type
)
445 && same_type_p (ptype
, current_class_type
))
446 inform (loc
, "definition of %q#T is not complete until "
447 "the closing brace", ptype
);
448 else if (!TYPE_TEMPLATE_INFO (ptype
))
449 inform (loc
, "forward declaration of %q#T", ptype
);
451 inform (loc
, "declaration of %q#T", ptype
);
454 /* Print an error message for invalid use of an incomplete type.
455 VALUE is the expression that was used (or 0 if that isn't known)
456 and TYPE is the type that was invalid. DIAG_KIND indicates the
457 type of diagnostic (see diagnostic.def). */
460 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
,
461 diagnostic_t diag_kind
)
463 bool is_decl
= false, complained
= false;
465 gcc_assert (diag_kind
== DK_WARNING
466 || diag_kind
== DK_PEDWARN
467 || diag_kind
== DK_ERROR
);
469 /* Avoid duplicate error message. */
470 if (TREE_CODE (type
) == ERROR_MARK
)
473 if (value
!= 0 && (VAR_P (value
)
474 || TREE_CODE (value
) == PARM_DECL
475 || TREE_CODE (value
) == FIELD_DECL
))
477 complained
= emit_diagnostic (diag_kind
, input_location
, 0,
478 "%q+D has incomplete type", value
);
482 /* We must print an error message. Be clever about what it says. */
484 switch (TREE_CODE (type
))
490 complained
= emit_diagnostic (diag_kind
, input_location
, 0,
491 "invalid use of incomplete type %q#T",
494 cxx_incomplete_type_inform (type
);
498 emit_diagnostic (diag_kind
, input_location
, 0,
499 "invalid use of %qT", type
);
503 if (TYPE_DOMAIN (type
))
505 type
= TREE_TYPE (type
);
508 emit_diagnostic (diag_kind
, input_location
, 0,
509 "invalid use of array with unspecified bounds");
515 tree member
= TREE_OPERAND (value
, 1);
516 if (is_overloaded_fn (member
))
517 member
= get_first_fn (member
);
518 if (DECL_FUNCTION_MEMBER_P (member
)
519 && ! flag_ms_extensions
)
520 emit_diagnostic (diag_kind
, input_location
, 0,
521 "invalid use of member function "
522 "(did you forget the %<()%> ?)");
524 emit_diagnostic (diag_kind
, input_location
, 0,
525 "invalid use of member "
526 "(did you forget the %<&%> ?)");
530 case TEMPLATE_TYPE_PARM
:
532 emit_diagnostic (diag_kind
, input_location
, 0,
533 "invalid use of %<auto%>");
535 emit_diagnostic (diag_kind
, input_location
, 0,
536 "invalid use of template type parameter %qT", type
);
539 case BOUND_TEMPLATE_TEMPLATE_PARM
:
540 emit_diagnostic (diag_kind
, input_location
, 0,
541 "invalid use of template template parameter %qT",
546 emit_diagnostic (diag_kind
, input_location
, 0,
547 "invalid use of dependent type %qT", type
);
551 if (type
== init_list_type_node
)
553 emit_diagnostic (diag_kind
, input_location
, 0,
554 "invalid use of brace-enclosed initializer list");
557 gcc_assert (type
== unknown_type_node
);
558 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
560 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
561 emit_diagnostic (diag_kind
, input_location
, 0,
562 "address of overloaded function with no contextual "
564 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
565 emit_diagnostic (diag_kind
, input_location
, 0,
566 "overloaded function with no contextual type information");
568 emit_diagnostic (diag_kind
, input_location
, 0,
569 "insufficient contextual information to determine type");
577 /* Backward-compatibility interface to incomplete_type_diagnostic;
578 required by ../tree.c. */
579 #undef cxx_incomplete_type_error
581 cxx_incomplete_type_error (const_tree value
, const_tree type
)
583 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
587 /* The recursive part of split_nonconstant_init. DEST is an lvalue
588 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
589 Return true if the whole of the value was initialized by the
590 generated statements. */
593 split_nonconstant_init_1 (tree dest
, tree init
)
595 unsigned HOST_WIDE_INT idx
;
596 tree field_index
, value
;
597 tree type
= TREE_TYPE (dest
);
598 tree inner_type
= NULL
;
599 bool array_type_p
= false;
600 bool complete_p
= true;
601 HOST_WIDE_INT num_split_elts
= 0;
603 switch (TREE_CODE (type
))
606 inner_type
= TREE_TYPE (type
);
608 if ((TREE_SIDE_EFFECTS (init
)
609 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
610 || array_of_runtime_bound_p (type
))
612 /* For an array, we only need/want a single cleanup region rather
613 than one per element. */
614 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
615 tf_warning_or_error
);
623 case QUAL_UNION_TYPE
:
624 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
627 /* The current implementation of this algorithm assumes that
628 the field was set for all the elements. This is usually done
629 by process_init_constructor. */
630 gcc_assert (field_index
);
633 inner_type
= TREE_TYPE (field_index
);
635 if (TREE_CODE (value
) == CONSTRUCTOR
)
640 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
641 NULL_TREE
, NULL_TREE
);
643 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
646 if (!split_nonconstant_init_1 (sub
, value
))
649 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
652 else if (!initializer_constant_valid_p (value
, inner_type
))
657 /* FIXME: Ordered removal is O(1) so the whole function is
658 worst-case quadratic. This could be fixed using an aside
659 bitmap to record which elements must be removed and remove
660 them all at the same time. Or by merging
661 split_non_constant_init into process_init_constructor_array,
662 that is separating constants from non-constants while building
664 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
667 if (TREE_CODE (field_index
) == RANGE_EXPR
)
669 /* Use build_vec_init to initialize a range. */
670 tree low
= TREE_OPERAND (field_index
, 0);
671 tree hi
= TREE_OPERAND (field_index
, 1);
672 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
673 NULL_TREE
, NULL_TREE
);
674 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
675 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
676 code
= build_vec_init (sub
, max
, value
, false, 0,
677 tf_warning_or_error
);
679 if (tree_fits_shwi_p (max
))
680 num_split_elts
+= tree_to_shwi (max
);
685 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
686 NULL_TREE
, NULL_TREE
);
688 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
691 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
692 code
= build_stmt (input_location
, EXPR_STMT
, code
);
693 code
= maybe_cleanup_point_expr_void (code
);
695 if (type_build_dtor_call (inner_type
))
697 code
= (build_special_member_call
698 (sub
, complete_dtor_identifier
, NULL
, inner_type
,
699 LOOKUP_NORMAL
, tf_warning_or_error
));
700 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type
))
701 finish_eh_cleanup (code
);
711 if (!initializer_constant_valid_p (init
, type
))
714 tree cons
= copy_node (init
);
715 CONSTRUCTOR_ELTS (init
) = NULL
;
716 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
717 code
= build_stmt (input_location
, EXPR_STMT
, code
);
719 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
727 /* The rest of the initializer is now a constant. */
728 TREE_CONSTANT (init
) = 1;
729 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
730 num_split_elts
, inner_type
);
733 /* A subroutine of store_init_value. Splits non-constant static
734 initializer INIT into a constant part and generates code to
735 perform the non-constant part of the initialization to DEST.
736 Returns the code for the runtime init. */
739 split_nonconstant_init (tree dest
, tree init
)
743 if (TREE_CODE (init
) == TARGET_EXPR
)
744 init
= TARGET_EXPR_INITIAL (init
);
745 if (TREE_CODE (init
) == CONSTRUCTOR
)
747 code
= push_stmt_list ();
748 if (split_nonconstant_init_1 (dest
, init
))
750 code
= pop_stmt_list (code
);
751 DECL_INITIAL (dest
) = init
;
752 TREE_READONLY (dest
) = 0;
755 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
760 /* Perform appropriate conversions on the initial value of a variable,
761 store it in the declaration DECL,
762 and print any error messages that are appropriate.
763 If the init is invalid, store an ERROR_MARK.
765 C++: Note that INIT might be a TREE_LIST, which would mean that it is
766 a base class initializer for some aggregate type, hopefully compatible
767 with DECL. If INIT is a single element, and DECL is an aggregate
768 type, we silently convert INIT into a TREE_LIST, allowing a constructor
771 If INIT is a TREE_LIST and there is no constructor, turn INIT
772 into a CONSTRUCTOR and use standard initialization techniques.
773 Perhaps a warning should be generated?
775 Returns code to be executed if initialization could not be performed
776 for static variable. In that case, caller must emit the code. */
779 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
783 /* If variable's type was invalidly declared, just ignore it. */
785 type
= TREE_TYPE (decl
);
786 if (TREE_CODE (type
) == ERROR_MARK
)
789 if (MAYBE_CLASS_TYPE_P (type
))
791 if (TREE_CODE (init
) == TREE_LIST
)
793 error ("constructor syntax used, but no constructor declared "
794 "for type %qT", type
);
795 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
799 /* End of special C++ code. */
801 if (flags
& LOOKUP_ALREADY_DIGESTED
)
804 /* Digest the specified initializer into an expression. */
805 value
= digest_init_flags (type
, init
, flags
);
807 value
= extend_ref_init_temps (decl
, value
, cleanups
);
809 /* In C++11 constant expression is a semantic, not syntactic, property.
810 In C++98, make sure that what we thought was a constant expression at
811 template definition time is still constant and otherwise perform this
812 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
813 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
816 value
= instantiate_non_dependent_expr (value
);
817 if (DECL_DECLARED_CONSTEXPR_P (decl
)
818 || DECL_IN_AGGR_P (decl
))
820 /* Diagnose a non-constant initializer for constexpr. */
821 if (processing_template_decl
822 && !require_potential_constant_expression (value
))
823 value
= error_mark_node
;
825 value
= cxx_constant_value (value
, decl
);
827 value
= maybe_constant_init (value
, decl
);
828 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
829 /* Poison this CONSTRUCTOR so it can't be copied to another
830 constexpr variable. */
831 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
832 const_init
= (reduced_constant_expression_p (value
)
833 || error_operand_p (value
));
834 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
835 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
838 if (cxx_dialect
>= cxx14
&& CLASS_TYPE_P (strip_array_types (type
)))
839 /* Handle aggregate NSDMI in non-constant initializers, too. */
840 value
= replace_placeholders (value
, decl
);
842 /* If the initializer is not a constant, fill in DECL_INITIAL with
843 the bits that are constant, and then return an expression that
844 will perform the dynamic initialization. */
845 if (value
!= error_mark_node
846 && (TREE_SIDE_EFFECTS (value
)
847 || array_of_runtime_bound_p (type
)
848 || ! reduced_constant_expression_p (value
)))
849 return split_nonconstant_init (decl
, value
);
850 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
851 is an automatic variable, the middle end will turn this into a
852 dynamic initialization later. */
853 DECL_INITIAL (decl
) = value
;
858 /* Give diagnostic about narrowing conversions within { }. */
861 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
863 tree ftype
= unlowered_expr_type (init
);
867 if (((!warn_narrowing
|| !(complain
& tf_warning
))
868 && cxx_dialect
== cxx98
)
869 || !ARITHMETIC_TYPE_P (type
))
872 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
873 && TREE_CODE (type
) == COMPLEX_TYPE
)
875 tree elttype
= TREE_TYPE (type
);
876 if (CONSTRUCTOR_NELTS (init
) > 0)
877 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
879 if (CONSTRUCTOR_NELTS (init
) > 1)
880 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
885 init
= fold_non_dependent_expr (init
);
887 if (TREE_CODE (type
) == INTEGER_TYPE
888 && TREE_CODE (ftype
) == REAL_TYPE
)
890 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
891 && CP_INTEGRAL_TYPE_P (type
))
893 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
894 /* Check for narrowing based on the values of the enumeration. */
895 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
896 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
897 TYPE_MAX_VALUE (ftype
))
898 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
899 TYPE_MIN_VALUE (type
)))
900 && (TREE_CODE (init
) != INTEGER_CST
901 || !int_fits_type_p (init
, type
)))
904 else if (TREE_CODE (ftype
) == REAL_TYPE
905 && TREE_CODE (type
) == REAL_TYPE
)
907 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
909 if (TREE_CODE (init
) == REAL_CST
)
911 /* Issue 703: Loss of precision is OK as long as the value is
912 within the representable range of the new type. */
914 d
= TREE_REAL_CST (init
);
915 real_convert (&r
, TYPE_MODE (type
), &d
);
923 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
924 && TREE_CODE (type
) == REAL_TYPE
)
927 if (TREE_CODE (init
) == INTEGER_CST
)
929 d
= real_value_from_int_cst (0, init
);
930 if (exact_real_truncate (TYPE_MODE (type
), &d
))
937 if (cxx_dialect
== cxx98
)
938 warning_at (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
939 "narrowing conversion of %qE from %qT to %qT inside { } "
940 "is ill-formed in C++11", init
, ftype
, type
);
941 else if (!TREE_CONSTANT (init
))
943 if (complain
& tf_warning_or_error
)
945 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
946 "narrowing conversion of %qE from %qT to %qT inside { }",
951 else if (complain
& tf_error
)
953 int savederrorcount
= errorcount
;
954 global_dc
->pedantic_errors
= 1;
955 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
956 "narrowing conversion of %qE from %qT to %qT "
957 "inside { }", init
, ftype
, type
);
958 if (errorcount
== savederrorcount
)
960 global_dc
->pedantic_errors
= flag_pedantic_errors
;
964 return cxx_dialect
== cxx98
|| ok
;
967 /* Process the initializer INIT for a variable of type TYPE, emitting
968 diagnostics for invalid initializers and converting the initializer as
971 For aggregate types, it assumes that reshape_init has already run, thus the
972 initializer will have the right shape (brace elision has been undone).
974 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
977 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
978 tsubst_flags_t complain
)
980 enum tree_code code
= TREE_CODE (type
);
982 if (error_operand_p (init
))
983 return error_mark_node
;
987 /* We must strip the outermost array type when completing the type,
988 because the its bounds might be incomplete at the moment. */
989 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
990 ? TREE_TYPE (type
) : type
, NULL_TREE
,
992 return error_mark_node
;
994 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
995 (g++.old-deja/g++.law/casts2.C). */
996 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
997 init
= TREE_OPERAND (init
, 0);
999 /* Initialization of an array of chars from a string constant. The initializer
1000 can be optionally enclosed in braces, but reshape_init has already removed
1001 them if they were present. */
1002 if (code
== ARRAY_TYPE
)
1004 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1005 if (char_type_p (typ1
)
1007 && TREE_CODE (init
) == STRING_CST
)
1009 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1011 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1013 if (char_type
!= char_type_node
)
1015 if (complain
& tf_error
)
1016 error ("char-array initialized from wide string");
1017 return error_mark_node
;
1022 if (char_type
== char_type_node
)
1024 if (complain
& tf_error
)
1025 error ("int-array initialized from non-wide string");
1026 return error_mark_node
;
1028 else if (char_type
!= typ1
)
1030 if (complain
& tf_error
)
1031 error ("int-array initialized from incompatible "
1033 return error_mark_node
;
1037 if (type
!= TREE_TYPE (init
))
1039 init
= copy_node (init
);
1040 TREE_TYPE (init
) = type
;
1042 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
1044 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1045 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1046 /* In C it is ok to subtract 1 from the length of the string
1047 because it's ok to ignore the terminating null char that is
1048 counted in the length of the constant, but in C++ this would
1050 if (size
< TREE_STRING_LENGTH (init
))
1051 permerror (input_location
, "initializer-string for array "
1052 "of chars is too long");
1058 /* Handle scalar types (including conversions) and references. */
1059 if ((TREE_CODE (type
) != COMPLEX_TYPE
1060 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1061 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1066 flags
|= LOOKUP_NO_NARROWING
;
1067 init
= convert_for_initialization (0, type
, init
, flags
,
1068 ICR_INIT
, NULL_TREE
, 0,
1072 /* Skip any conversions since we'll be outputting the underlying
1074 while (CONVERT_EXPR_P (*exp
)
1075 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
1076 exp
= &TREE_OPERAND (*exp
, 0);
1078 *exp
= cplus_expand_constant (*exp
);
1083 /* Come here only for aggregates: records, arrays, unions, complex numbers
1085 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1086 || TREE_CODE (type
) == VECTOR_TYPE
1087 || TREE_CODE (type
) == RECORD_TYPE
1088 || TREE_CODE (type
) == UNION_TYPE
1089 || TREE_CODE (type
) == COMPLEX_TYPE
);
1091 #ifdef ENABLE_CHECKING
1092 /* "If T is a class type and the initializer list has a single
1093 element of type cv U, where U is T or a class derived from T,
1094 the object is initialized from that element." */
1095 if (cxx_dialect
>= cxx11
1096 && BRACE_ENCLOSED_INITIALIZER_P (init
)
1097 && CONSTRUCTOR_NELTS (init
) == 1
1098 && (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
)))
1100 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
1101 if (reference_related_p (type
, TREE_TYPE (elt
)))
1102 /* We should have fixed this in reshape_init. */
1107 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1108 && !TYPE_NON_AGGREGATE_CLASS (type
))
1109 return process_init_constructor (type
, init
, complain
);
1112 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1114 if (complain
& tf_error
)
1115 error ("cannot initialize aggregate of type %qT with "
1116 "a compound literal", type
);
1118 return error_mark_node
;
1121 if (TREE_CODE (type
) == ARRAY_TYPE
1122 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1124 /* Allow the result of build_array_copy and of
1125 build_value_init_noctor. */
1126 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1127 || TREE_CODE (init
) == CONSTRUCTOR
)
1128 && (same_type_ignoring_top_level_qualifiers_p
1129 (type
, TREE_TYPE (init
))))
1132 if (complain
& tf_error
)
1133 error ("array must be initialized with a brace-enclosed"
1135 return error_mark_node
;
1138 return convert_for_initialization (NULL_TREE
, type
, init
,
1140 ICR_INIT
, NULL_TREE
, 0,
1146 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1148 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1152 digest_init_flags (tree type
, tree init
, int flags
)
1154 return digest_init_r (type
, init
, false, flags
, tf_warning_or_error
);
1157 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1159 digest_nsdmi_init (tree decl
, tree init
)
1161 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1163 tree type
= TREE_TYPE (decl
);
1164 int flags
= LOOKUP_IMPLICIT
;
1165 if (DIRECT_LIST_INIT_P (init
))
1166 flags
= LOOKUP_NORMAL
;
1167 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1168 && CP_AGGREGATE_TYPE_P (type
))
1169 init
= reshape_init (type
, init
, tf_warning_or_error
);
1170 init
= digest_init_flags (type
, init
, flags
);
1171 if (TREE_CODE (init
) == TARGET_EXPR
)
1172 /* This represents the whole initialization. */
1173 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1177 /* Set of flags used within process_init_constructor to describe the
1179 #define PICFLAG_ERRONEOUS 1
1180 #define PICFLAG_NOT_ALL_CONSTANT 2
1181 #define PICFLAG_NOT_ALL_SIMPLE 4
1182 #define PICFLAG_SIDE_EFFECTS 8
1184 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1188 picflag_from_initializer (tree init
)
1190 if (init
== error_mark_node
)
1191 return PICFLAG_ERRONEOUS
;
1192 else if (!TREE_CONSTANT (init
))
1194 if (TREE_SIDE_EFFECTS (init
))
1195 return PICFLAG_SIDE_EFFECTS
;
1197 return PICFLAG_NOT_ALL_CONSTANT
;
1199 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1200 return PICFLAG_NOT_ALL_SIMPLE
;
1204 /* Adjust INIT for going into a CONSTRUCTOR. */
1207 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1209 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1210 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1211 if (TREE_CODE (init
) == TARGET_EXPR
1212 && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (init
))))
1213 init
= TARGET_EXPR_INITIAL (init
);
1214 /* When we defer constant folding within a statement, we may want to
1215 defer this folding as well. */
1216 tree t
= fold_non_dependent_expr (init
);
1217 t
= maybe_constant_init (t
);
1218 if (TREE_CONSTANT (t
))
1223 /* Subroutine of process_init_constructor, which will process an initializer
1224 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1225 which describe the initializers. */
1228 process_init_constructor_array (tree type
, tree init
,
1229 tsubst_flags_t complain
)
1231 unsigned HOST_WIDE_INT i
, len
= 0;
1233 bool unbounded
= false;
1234 constructor_elt
*ce
;
1235 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1237 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1238 || TREE_CODE (type
) == VECTOR_TYPE
);
1240 if (TREE_CODE (type
) == ARRAY_TYPE
)
1242 tree domain
= TYPE_DOMAIN (type
);
1243 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1244 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1245 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1246 TYPE_PRECISION (TREE_TYPE (domain
)),
1247 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1249 unbounded
= true; /* Take as many as there are. */
1252 /* Vectors are like simple fixed-size arrays. */
1253 len
= TYPE_VECTOR_SUBPARTS (type
);
1255 /* There must not be more initializers than needed. */
1256 if (!unbounded
&& vec_safe_length (v
) > len
)
1258 if (complain
& tf_error
)
1259 error ("too many initializers for %qT", type
);
1261 return PICFLAG_ERRONEOUS
;
1264 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1268 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1269 if (compare_tree_int (ce
->index
, i
) != 0)
1271 ce
->value
= error_mark_node
;
1272 sorry ("non-trivial designated initializers not supported");
1276 ce
->index
= size_int (i
);
1277 gcc_assert (ce
->value
);
1278 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1280 if (ce
->value
!= error_mark_node
)
1281 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1282 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1284 flags
|= picflag_from_initializer (ce
->value
);
1287 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1288 we must add initializers ourselves. */
1290 for (; i
< len
; ++i
)
1294 if (type_build_ctor_call (TREE_TYPE (type
)))
1296 /* If this type needs constructors run for default-initialization,
1297 we can't rely on the back end to do it for us, so make the
1298 initialization explicit by list-initializing from T{}. */
1299 next
= build_constructor (init_list_type_node
, NULL
);
1300 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1301 if (initializer_zerop (next
))
1302 /* The default zero-initialization is fine for us; don't
1303 add anything to the CONSTRUCTOR. */
1306 else if (!zero_init_p (TREE_TYPE (type
)))
1307 next
= build_zero_init (TREE_TYPE (type
),
1308 /*nelts=*/NULL_TREE
,
1309 /*static_storage_p=*/false);
1311 /* The default zero-initialization is fine for us; don't
1312 add anything to the CONSTRUCTOR. */
1317 flags
|= picflag_from_initializer (next
);
1318 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1322 CONSTRUCTOR_ELTS (init
) = v
;
1326 /* Subroutine of process_init_constructor, which will process an initializer
1327 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1328 the initializers. */
1331 process_init_constructor_record (tree type
, tree init
,
1332 tsubst_flags_t complain
)
1334 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1338 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1339 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1340 gcc_assert (!TYPE_BINFO (type
)
1341 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1342 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1346 unsigned HOST_WIDE_INT idx
= 0;
1347 /* Generally, we will always have an index for each initializer (which is
1348 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1349 reshape_init. So we need to handle both cases. */
1350 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1355 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1358 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1361 /* If this is a bitfield, first convert to the declared type. */
1362 type
= TREE_TYPE (field
);
1363 if (DECL_BIT_FIELD_TYPE (field
))
1364 type
= DECL_BIT_FIELD_TYPE (field
);
1365 if (type
== error_mark_node
)
1366 return PICFLAG_ERRONEOUS
;
1368 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1370 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1373 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1374 latter case can happen in templates where lookup has to be
1376 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1377 || identifier_p (ce
->index
));
1378 if (ce
->index
!= field
1379 && ce
->index
!= DECL_NAME (field
))
1381 ce
->value
= error_mark_node
;
1382 sorry ("non-trivial designated initializers not supported");
1386 gcc_assert (ce
->value
);
1387 next
= massage_init_elt (type
, ce
->value
, complain
);
1390 else if (DECL_INITIAL (field
))
1394 /* We're using an NSDMI past a field with implicit
1395 zero-init. Go back and make it explicit. */
1397 vec_safe_truncate (v
, 0);
1400 /* C++14 aggregate NSDMI. */
1401 next
= get_nsdmi (field
, /*ctor*/false);
1403 else if (type_build_ctor_call (TREE_TYPE (field
)))
1405 /* If this type needs constructors run for
1406 default-initialization, we can't rely on the back end to do it
1407 for us, so build up TARGET_EXPRs. If the type in question is
1408 a class, just build one up; if it's an array, recurse. */
1409 next
= build_constructor (init_list_type_node
, NULL
);
1410 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1412 /* Warn when some struct elements are implicitly initialized. */
1413 if ((complain
& tf_warning
)
1414 && !EMPTY_CONSTRUCTOR_P (init
))
1415 warning (OPT_Wmissing_field_initializers
,
1416 "missing initializer for member %qD", field
);
1420 if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1422 if (complain
& tf_error
)
1423 error ("member %qD is uninitialized reference", field
);
1425 return PICFLAG_ERRONEOUS
;
1427 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1429 if (complain
& tf_error
)
1430 error ("member %qD with uninitialized reference fields", field
);
1432 return PICFLAG_ERRONEOUS
;
1435 /* Warn when some struct elements are implicitly initialized
1437 if ((complain
& tf_warning
)
1438 && !EMPTY_CONSTRUCTOR_P (init
))
1439 warning (OPT_Wmissing_field_initializers
,
1440 "missing initializer for member %qD", field
);
1442 if (!zero_init_p (TREE_TYPE (field
))
1444 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1445 /*static_storage_p=*/false);
1448 /* The default zero-initialization is fine for us; don't
1449 add anything to the CONSTRUCTOR. */
1455 /* If this is a bitfield, now convert to the lowered type. */
1456 if (type
!= TREE_TYPE (field
))
1457 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1458 flags
|= picflag_from_initializer (next
);
1459 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1462 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1464 if (complain
& tf_error
)
1465 error ("too many initializers for %qT", type
);
1467 return PICFLAG_ERRONEOUS
;
1470 CONSTRUCTOR_ELTS (init
) = v
;
1474 /* Subroutine of process_init_constructor, which will process a single
1475 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1476 which describe the initializer. */
1479 process_init_constructor_union (tree type
, tree init
,
1480 tsubst_flags_t complain
)
1482 constructor_elt
*ce
;
1485 /* If the initializer was empty, use default zero initialization. */
1486 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1489 len
= CONSTRUCTOR_ELTS (init
)->length ();
1492 if (!(complain
& tf_error
))
1493 return PICFLAG_ERRONEOUS
;
1494 error ("too many initializers for %qT", type
);
1495 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1498 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1500 /* If this element specifies a field, initialize via that field. */
1503 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1505 else if (identifier_p (ce
->index
))
1507 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1508 tree name
= ce
->index
;
1510 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1511 if (DECL_NAME (field
) == name
)
1515 if (complain
& tf_error
)
1516 error ("no field %qD found in union being initialized",
1518 ce
->value
= error_mark_node
;
1524 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1525 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1526 if (complain
& tf_error
)
1527 error ("index value instead of field name in union initializer");
1528 ce
->value
= error_mark_node
;
1533 /* Find the first named field. ANSI decided in September 1990
1534 that only named fields count here. */
1535 tree field
= TYPE_FIELDS (type
);
1536 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1537 field
= TREE_CHAIN (field
);
1538 if (field
== NULL_TREE
)
1540 if (complain
& tf_error
)
1541 error ("too many initializers for %qT", type
);
1542 ce
->value
= error_mark_node
;
1547 if (ce
->value
&& ce
->value
!= error_mark_node
)
1548 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1550 return picflag_from_initializer (ce
->value
);
1553 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1554 constructor is a brace-enclosed initializer, and will be modified in-place.
1556 Each element is converted to the right type through digest_init, and
1557 missing initializers are added following the language rules (zero-padding,
1560 After the execution, the initializer will have TREE_CONSTANT if all elts are
1561 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1562 constants that the assembler and linker can compute them.
1564 The function returns the initializer itself, or error_mark_node in case
1568 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1572 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1574 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1575 flags
= process_init_constructor_array (type
, init
, complain
);
1576 else if (TREE_CODE (type
) == RECORD_TYPE
)
1577 flags
= process_init_constructor_record (type
, init
, complain
);
1578 else if (TREE_CODE (type
) == UNION_TYPE
)
1579 flags
= process_init_constructor_union (type
, init
, complain
);
1583 if (flags
& PICFLAG_ERRONEOUS
)
1584 return error_mark_node
;
1586 TREE_TYPE (init
) = type
;
1587 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1588 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1589 if (flags
& PICFLAG_SIDE_EFFECTS
)
1591 TREE_CONSTANT (init
) = false;
1592 TREE_SIDE_EFFECTS (init
) = true;
1594 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1595 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1596 TREE_CONSTANT (init
) = false;
1599 TREE_CONSTANT (init
) = 1;
1600 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1601 TREE_STATIC (init
) = 1;
1606 /* Given a structure or union value DATUM, construct and return
1607 the structure or union component which results from narrowing
1608 that value to the base specified in BASETYPE. For example, given the
1611 class L { int ii; };
1612 class A : L { ... };
1613 class B : L { ... };
1614 class C : A, B { ... };
1622 x.A::ii refers to the ii member of the L part of
1623 the A part of the C object named by X. In this case,
1624 DATUM would be x, and BASETYPE would be A.
1626 I used to think that this was nonconformant, that the standard specified
1627 that first we look up ii in A, then convert x to an L& and pull out the
1628 ii part. But in fact, it does say that we convert x to an A&; A here
1629 is known as the "naming class". (jason 2000-12-19)
1631 BINFO_P points to a variable initialized either to NULL_TREE or to the
1632 binfo for the specific base subobject we want to convert to. */
1635 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1639 if (datum
== error_mark_node
)
1640 return error_mark_node
;
1644 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1645 NULL
, tf_warning_or_error
);
1647 if (!binfo
|| binfo
== error_mark_node
)
1649 *binfo_p
= NULL_TREE
;
1651 error_not_base_type (basetype
, TREE_TYPE (datum
));
1652 return error_mark_node
;
1656 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1657 tf_warning_or_error
);
1660 /* Build a reference to an object specified by the C++ `->' operator.
1661 Usually this just involves dereferencing the object, but if the
1662 `->' operator is overloaded, then such overloads must be
1663 performed until an object which does not have the `->' operator
1664 overloaded is found. An error is reported when circular pointer
1665 delegation is detected. */
1668 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1670 tree orig_expr
= expr
;
1671 tree type
= TREE_TYPE (expr
);
1672 tree last_rval
= NULL_TREE
;
1673 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1675 if (type
== error_mark_node
)
1676 return error_mark_node
;
1678 if (processing_template_decl
)
1680 if (type_dependent_expression_p (expr
))
1681 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1682 expr
= build_non_dependent_expr (expr
);
1685 if (MAYBE_CLASS_TYPE_P (type
))
1687 struct tinst_level
*actual_inst
= current_instantiation ();
1690 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1691 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1694 if (expr
== error_mark_node
)
1695 return error_mark_node
;
1697 /* This provides a better instantiation backtrace in case of
1699 if (fn
&& DECL_USE_TEMPLATE (fn
))
1700 push_tinst_level_loc (fn
,
1701 (current_instantiation () != actual_inst
)
1702 ? DECL_SOURCE_LOCATION (fn
)
1706 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1708 if (complain
& tf_error
)
1709 error ("circular pointer delegation detected");
1710 return error_mark_node
;
1713 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1717 while (current_instantiation () != actual_inst
)
1720 if (last_rval
== NULL_TREE
)
1722 if (complain
& tf_error
)
1723 error ("base operand of %<->%> has non-pointer type %qT", type
);
1724 return error_mark_node
;
1727 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1728 last_rval
= convert_from_reference (last_rval
);
1731 last_rval
= decay_conversion (expr
, complain
);
1733 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1735 if (processing_template_decl
)
1737 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1739 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1743 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1746 if (complain
& tf_error
)
1749 error ("result of %<operator->()%> yields non-pointer result");
1751 error ("base operand of %<->%> is not a pointer");
1753 return error_mark_node
;
1756 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1757 already been checked out to be of aggregate type. */
1760 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1768 if (error_operand_p (datum
) || error_operand_p (component
))
1769 return error_mark_node
;
1771 datum
= mark_lvalue_use (datum
);
1772 component
= mark_rvalue_use (component
);
1774 ptrmem_type
= TREE_TYPE (component
);
1775 if (!TYPE_PTRMEM_P (ptrmem_type
))
1777 if (complain
& tf_error
)
1778 error ("%qE cannot be used as a member pointer, since it is of "
1779 "type %qT", component
, ptrmem_type
);
1780 return error_mark_node
;
1783 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1784 if (! MAYBE_CLASS_TYPE_P (objtype
))
1786 if (complain
& tf_error
)
1787 error ("cannot apply member pointer %qE to %qE, which is of "
1788 "non-class type %qT", component
, datum
, objtype
);
1789 return error_mark_node
;
1792 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1793 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1795 if (!COMPLETE_TYPE_P (ctype
))
1797 if (!same_type_p (ctype
, objtype
))
1803 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1808 if (complain
& tf_error
)
1809 error ("pointer to member type %qT incompatible with object "
1810 "type %qT", type
, objtype
);
1811 return error_mark_node
;
1813 else if (binfo
== error_mark_node
)
1814 return error_mark_node
;
1817 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1819 cp_lvalue_kind kind
= lvalue_kind (datum
);
1822 /* Compute the type of the field, as described in [expr.ref].
1823 There's no such thing as a mutable pointer-to-member, so
1824 things are not as complex as they are for references to
1825 non-static data members. */
1826 type
= cp_build_qualified_type (type
,
1827 (cp_type_quals (type
)
1828 | cp_type_quals (TREE_TYPE (datum
))));
1830 datum
= build_address (datum
);
1832 /* Convert object to the correct base. */
1835 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1836 if (datum
== error_mark_node
)
1837 return error_mark_node
;
1840 /* Build an expression for "object + offset" where offset is the
1841 value stored in the pointer-to-data-member. */
1842 ptype
= build_pointer_type (type
);
1843 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1844 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1845 if (datum
== error_mark_node
)
1846 return error_mark_node
;
1848 /* If the object expression was an rvalue, return an rvalue. */
1849 if (kind
& clk_class
)
1850 datum
= rvalue (datum
);
1851 else if (kind
& clk_rvalueref
)
1852 datum
= move (datum
);
1857 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1858 program is ill-formed if the second operand is a pointer to member
1859 function with ref-qualifier &. In a .* expression whose object
1860 expression is an lvalue, the program is ill-formed if the second
1861 operand is a pointer to member function with ref-qualifier &&. */
1862 if (FUNCTION_REF_QUALIFIED (type
))
1864 bool lval
= real_lvalue_p (datum
);
1865 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1867 if (complain
& tf_error
)
1868 error ("pointer-to-member-function type %qT requires an rvalue",
1870 return error_mark_node
;
1872 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1874 if (complain
& tf_error
)
1875 error ("pointer-to-member-function type %qT requires an lvalue",
1877 return error_mark_node
;
1880 return build2 (OFFSET_REF
, type
, datum
, component
);
1884 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1887 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1889 /* This is either a call to a constructor,
1890 or a C cast in C++'s `functional' notation. */
1892 /* The type to which we are casting. */
1894 vec
<tree
, va_gc
> *parmvec
;
1896 if (error_operand_p (exp
) || parms
== error_mark_node
)
1897 return error_mark_node
;
1899 if (TREE_CODE (exp
) == TYPE_DECL
)
1901 type
= TREE_TYPE (exp
);
1903 if (complain
& tf_warning
1904 && TREE_DEPRECATED (type
)
1905 && DECL_ARTIFICIAL (exp
))
1906 warn_deprecated_use (type
, NULL_TREE
);
1911 /* We need to check this explicitly, since value-initialization of
1912 arrays is allowed in other situations. */
1913 if (TREE_CODE (type
) == ARRAY_TYPE
)
1915 if (complain
& tf_error
)
1916 error ("functional cast to array type %qT", type
);
1917 return error_mark_node
;
1920 if (type_uses_auto (type
))
1922 if (complain
& tf_error
)
1923 error ("invalid use of %<auto%>");
1924 return error_mark_node
;
1927 if (processing_template_decl
)
1931 /* Diagnose this even in a template. We could also try harder
1932 to give all the usual errors when the type and args are
1934 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1936 if (complain
& tf_error
)
1937 error ("invalid value-initialization of reference type");
1938 return error_mark_node
;
1941 t
= build_min (CAST_EXPR
, type
, parms
);
1942 /* We don't know if it will or will not have side effects. */
1943 TREE_SIDE_EFFECTS (t
) = 1;
1947 if (! MAYBE_CLASS_TYPE_P (type
))
1949 if (parms
== NULL_TREE
)
1951 if (VOID_TYPE_P (type
))
1953 return build_value_init (cv_unqualified (type
), complain
);
1956 /* This must build a C cast. */
1957 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
1958 return cp_build_c_cast (type
, parms
, complain
);
1961 /* Prepare to evaluate as a call to a constructor. If this expression
1962 is actually used, for example,
1964 return X (arg1, arg2, ...);
1966 then the slot being initialized will be filled in. */
1968 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
1969 return error_mark_node
;
1970 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
1971 return error_mark_node
;
1975 If the expression list is a single-expression, the type
1976 conversion is equivalent (in definedness, and if defined in
1977 meaning) to the corresponding cast expression. */
1978 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1979 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1983 The expression T(), where T is a simple-type-specifier for a
1984 non-array complete object type or the (possibly cv-qualified)
1985 void type, creates an rvalue of the specified type, which is
1986 value-initialized. */
1988 if (parms
== NULL_TREE
)
1990 exp
= build_value_init (type
, complain
);
1991 exp
= get_target_expr_sfinae (exp
, complain
);
1995 /* Call the constructor. */
1996 parmvec
= make_tree_vector ();
1997 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
1998 vec_safe_push (parmvec
, TREE_VALUE (parms
));
1999 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2000 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2001 release_tree_vector (parmvec
);
2003 if (exp
== error_mark_node
)
2004 return error_mark_node
;
2006 return build_cplus_new (type
, exp
, complain
);
2010 /* Add new exception specifier SPEC, to the LIST we currently have.
2011 If it's already in LIST then do nothing.
2012 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2013 know what we're doing. */
2016 add_exception_specifier (tree list
, tree spec
, int complain
)
2021 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2023 if (spec
== error_mark_node
)
2026 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2028 /* [except.spec] 1, type in an exception specifier shall not be
2029 incomplete, or pointer or ref to incomplete other than pointer
2031 is_ptr
= TYPE_PTR_P (core
);
2032 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2033 core
= TREE_TYPE (core
);
2036 else if (VOID_TYPE_P (core
))
2038 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2040 else if (processing_template_decl
)
2045 /* 15.4/1 says that types in an exception specifier must be complete,
2046 but it seems more reasonable to only require this on definitions
2047 and calls. So just give a pedwarn at this point; we will give an
2048 error later if we hit one of those two cases. */
2049 if (!COMPLETE_TYPE_P (complete_type (core
)))
2050 diag_type
= DK_PEDWARN
; /* pedwarn */
2057 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2058 if (same_type_p (TREE_VALUE (probe
), spec
))
2061 list
= tree_cons (NULL_TREE
, spec
, list
);
2064 diag_type
= DK_ERROR
; /* error */
2066 if (diag_type
!= DK_UNSPECIFIED
2067 && (complain
& tf_warning_or_error
))
2068 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2073 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2076 nothrow_spec_p_uninst (const_tree spec
)
2078 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2080 return nothrow_spec_p (spec
);
2083 /* Combine the two exceptions specifier lists LIST and ADD, and return
2087 merge_exception_specifiers (tree list
, tree add
)
2089 tree noex
, orig_list
;
2091 /* No exception-specifier or noexcept(false) are less strict than
2092 anything else. Prefer the newer variant (LIST). */
2093 if (!list
|| list
== noexcept_false_spec
)
2095 else if (!add
|| add
== noexcept_false_spec
)
2098 /* noexcept(true) and throw() are stricter than anything else.
2099 As above, prefer the more recent one (LIST). */
2100 if (nothrow_spec_p_uninst (add
))
2103 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2104 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2105 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2107 /* We should have instantiated other deferred noexcept specs by now. */
2108 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2110 if (nothrow_spec_p_uninst (list
))
2112 noex
= TREE_PURPOSE (list
);
2113 gcc_checking_assert (!TREE_PURPOSE (add
)
2114 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2116 /* Combine the dynamic-exception-specifiers, if any. */
2118 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2120 tree spec
= TREE_VALUE (add
);
2123 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2124 probe
= TREE_CHAIN (probe
))
2125 if (same_type_p (TREE_VALUE (probe
), spec
))
2129 spec
= build_tree_list (NULL_TREE
, spec
);
2130 TREE_CHAIN (spec
) = list
;
2135 /* Keep the noexcept-specifier at the beginning of the list. */
2136 if (noex
!= TREE_PURPOSE (list
))
2137 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2142 /* Subroutine of build_call. Ensure that each of the types in the
2143 exception specification is complete. Technically, 15.4/1 says that
2144 they need to be complete when we see a declaration of the function,
2145 but we should be able to get away with only requiring this when the
2146 function is defined or called. See also add_exception_specifier. */
2149 require_complete_eh_spec_types (tree fntype
, tree decl
)
2152 /* Don't complain about calls to op new. */
2153 if (decl
&& DECL_ARTIFICIAL (decl
))
2155 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2156 raises
= TREE_CHAIN (raises
))
2158 tree type
= TREE_VALUE (raises
);
2159 if (type
&& !COMPLETE_TYPE_P (type
))
2163 ("call to function %qD which throws incomplete type %q#T",
2166 error ("call to function which throws incomplete type %q#T",
2173 #include "gt-cp-typeck2.h"