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 "double-int.h"
42 #include "stor-layout.h"
47 #include "diagnostic-core.h"
51 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
);
54 /* Print an error message stemming from an attempt to use
55 BASETYPE as a base class for TYPE. */
58 error_not_base_type (tree basetype
, tree type
)
60 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
61 basetype
= DECL_CONTEXT (basetype
);
62 error ("type %qT is not a base type for type %qT", basetype
, type
);
63 return error_mark_node
;
67 binfo_or_else (tree base
, tree type
)
69 tree binfo
= lookup_base (type
, base
, ba_unique
,
70 NULL
, tf_warning_or_error
);
72 if (binfo
== error_mark_node
)
75 error_not_base_type (base
, type
);
79 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
80 value may not be changed thereafter. */
83 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
86 /* This macro is used to emit diagnostics to ensure that all format
87 strings are complete sentences, visible to gettext and checked at
90 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
107 gcc_unreachable (); \
111 /* Handle C++-specific things first. */
114 && DECL_LANG_SPECIFIC (arg
)
115 && DECL_IN_AGGR_P (arg
)
116 && !TREE_STATIC (arg
))
117 ERROR_FOR_ASSIGNMENT (G_("assignment of "
118 "constant field %qD"),
119 G_("constant field %qD "
120 "used as %<asm%> output"),
122 "constant field %qD"),
124 "constant field %qD"),
126 else if (INDIRECT_REF_P (arg
)
127 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
128 && (VAR_P (TREE_OPERAND (arg
, 0))
129 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
130 ERROR_FOR_ASSIGNMENT (G_("assignment of "
131 "read-only reference %qD"),
132 G_("read-only reference %qD "
133 "used as %<asm%> output"),
135 "read-only reference %qD"),
137 "read-only reference %qD"),
138 TREE_OPERAND (arg
, 0));
140 readonly_error (input_location
, arg
, errstring
);
144 /* Structure that holds information about declarations whose type was
145 incomplete and we could not check whether it was abstract or not. */
147 struct GTY((chain_next ("%h.next"), for_user
)) pending_abstract_type
{
148 /* Declaration which we are checking for abstractness. It is either
149 a DECL node, or an IDENTIFIER_NODE if we do not have a full
150 declaration available. */
153 /* Type which will be checked for abstractness. */
156 /* Kind of use in an unnamed declarator. */
157 abstract_class_use use
;
159 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
160 because DECLs already carry locus information. */
163 /* Link to the next element in list. */
164 struct pending_abstract_type
* next
;
167 struct abstract_type_hasher
: ggc_hasher
<pending_abstract_type
*>
169 typedef tree compare_type
;
170 static hashval_t
hash (pending_abstract_type
*);
171 static bool equal (pending_abstract_type
*, tree
);
174 /* Compute the hash value of the node VAL. This function is used by the
175 hash table abstract_pending_vars. */
178 abstract_type_hasher::hash (pending_abstract_type
*pat
)
180 return (hashval_t
) TYPE_UID (pat
->type
);
184 /* Compare node VAL1 with the type VAL2. This function is used by the
185 hash table abstract_pending_vars. */
188 abstract_type_hasher::equal (pending_abstract_type
*pat1
, tree type2
)
190 return (pat1
->type
== type2
);
193 /* Hash table that maintains pending_abstract_type nodes, for which we still
194 need to check for type abstractness. The key of the table is the type
195 of the declaration. */
196 static GTY (()) hash_table
<abstract_type_hasher
> *abstract_pending_vars
= NULL
;
198 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
200 /* This function is called after TYPE is completed, and will check if there
201 are pending declarations for which we still need to verify the abstractness
202 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
203 turned out to be incomplete. */
206 complete_type_check_abstract (tree type
)
208 struct pending_abstract_type
*pat
;
209 location_t cur_loc
= input_location
;
211 gcc_assert (COMPLETE_TYPE_P (type
));
213 if (!abstract_pending_vars
)
216 /* Retrieve the list of pending declarations for this type. */
217 pending_abstract_type
**slot
218 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
225 /* If the type is not abstract, do not do anything. */
226 if (CLASSTYPE_PURE_VIRTUALS (type
))
228 struct pending_abstract_type
*prev
= 0, *next
;
230 /* Reverse the list to emit the errors in top-down order. */
231 for (; pat
; pat
= next
)
239 /* Go through the list, and call abstract_virtuals_error for each
240 element: it will issue a diagnostic if the type is abstract. */
243 gcc_assert (type
== pat
->type
);
245 /* Tweak input_location so that the diagnostic appears at the correct
246 location. Notice that this is only needed if the decl is an
248 input_location
= pat
->locus
;
249 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
250 tf_warning_or_error
);
255 abstract_pending_vars
->clear_slot (slot
);
257 input_location
= cur_loc
;
261 /* If TYPE has abstract virtual functions, issue an error about trying
262 to create an object of that type. DECL is the object declared, or
263 NULL_TREE if the declaration is unavailable, in which case USE specifies
264 the kind of invalid use. Returns 1 if an error occurred; zero if
268 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
269 tsubst_flags_t complain
)
271 vec
<tree
, va_gc
> *pure
;
273 /* This function applies only to classes. Any other entity can never
275 if (!CLASS_TYPE_P (type
))
277 type
= TYPE_MAIN_VARIANT (type
);
280 /* Instantiation here seems to be required by the standard,
281 but breaks e.g. boost::bind. FIXME! */
282 /* In SFINAE, non-N3276 context, force instantiation. */
283 if (!(complain
& (tf_error
|tf_decltype
)))
284 complete_type (type
);
287 /* If the type is incomplete, we register it within a hash table,
288 so that we can check again once it is completed. This makes sense
289 only for objects for which we have a declaration or at least a
291 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
293 struct pending_abstract_type
*pat
;
295 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
297 if (!abstract_pending_vars
)
298 abstract_pending_vars
299 = hash_table
<abstract_type_hasher
>::create_ggc (31);
301 pending_abstract_type
**slot
302 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
305 pat
= ggc_alloc
<pending_abstract_type
> ();
309 pat
->locus
= ((decl
&& DECL_P (decl
))
310 ? DECL_SOURCE_LOCATION (decl
)
319 if (!TYPE_SIZE (type
))
320 /* TYPE is being defined, and during that time
321 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
324 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
328 if (!(complain
& tf_error
))
334 error ("cannot declare variable %q+D to be of abstract "
335 "type %qT", decl
, type
);
336 else if (TREE_CODE (decl
) == PARM_DECL
)
338 if (DECL_NAME (decl
))
339 error ("cannot declare parameter %q+D to be of abstract type %qT",
342 error ("cannot declare parameter to be of abstract type %qT",
345 else if (TREE_CODE (decl
) == FIELD_DECL
)
346 error ("cannot declare field %q+D to be of abstract type %qT",
348 else if (TREE_CODE (decl
) == FUNCTION_DECL
349 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
350 error ("invalid abstract return type for member function %q+#D", decl
);
351 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
352 error ("invalid abstract return type for function %q+#D", decl
);
353 else if (identifier_p (decl
))
354 /* Here we do not have location information. */
355 error ("invalid abstract type %qT for %qE", type
, decl
);
357 error ("invalid abstract type for %q+D", decl
);
362 error ("creating array of %qT, which is an abstract class type", type
);
365 error ("invalid cast to abstract class type %qT", type
);
368 error ("invalid new-expression of abstract class type %qT", type
);
371 error ("invalid abstract return type %qT", type
);
374 error ("invalid abstract parameter type %qT", type
);
377 error ("expression of abstract class type %qT cannot "
378 "be used in throw-expression", type
);
381 error ("cannot declare catch parameter to be of abstract "
382 "class type %qT", type
);
385 error ("cannot allocate an object of abstract type %qT", type
);
388 /* Only go through this once. */
394 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
395 " because the following virtual functions are pure within %qT:",
398 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
399 if (! DECL_CLONED_FUNCTION_P (fn
)
400 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
401 inform (input_location
, "\t%+#D", fn
);
403 /* Now truncate the vector. This leaves it non-null, so we know
404 there are pure virtuals, but empty so we don't list them out
413 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
415 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
419 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
420 tsubst_flags_t complain
)
422 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
426 /* Wrapper for the above function in the common case of wanting errors. */
429 abstract_virtuals_error (tree decl
, tree type
)
431 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
435 abstract_virtuals_error (abstract_class_use use
, tree type
)
437 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
440 /* Print an inform about the declaration of the incomplete type TYPE. */
443 cxx_incomplete_type_inform (const_tree type
)
445 if (!TYPE_MAIN_DECL (type
))
448 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
449 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
451 if (current_class_type
452 && TYPE_BEING_DEFINED (current_class_type
)
453 && same_type_p (ptype
, current_class_type
))
454 inform (loc
, "definition of %q#T is not complete until "
455 "the closing brace", ptype
);
456 else if (!TYPE_TEMPLATE_INFO (ptype
))
457 inform (loc
, "forward declaration of %q#T", ptype
);
459 inform (loc
, "declaration of %q#T", ptype
);
462 /* Print an error message for invalid use of an incomplete type.
463 VALUE is the expression that was used (or 0 if that isn't known)
464 and TYPE is the type that was invalid. DIAG_KIND indicates the
465 type of diagnostic (see diagnostic.def). */
468 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
,
469 diagnostic_t diag_kind
)
471 bool is_decl
= false, complained
= false;
473 gcc_assert (diag_kind
== DK_WARNING
474 || diag_kind
== DK_PEDWARN
475 || diag_kind
== DK_ERROR
);
477 /* Avoid duplicate error message. */
478 if (TREE_CODE (type
) == ERROR_MARK
)
481 if (value
!= 0 && (VAR_P (value
)
482 || TREE_CODE (value
) == PARM_DECL
483 || TREE_CODE (value
) == FIELD_DECL
))
485 complained
= emit_diagnostic (diag_kind
, input_location
, 0,
486 "%q+D has incomplete type", value
);
490 /* We must print an error message. Be clever about what it says. */
492 switch (TREE_CODE (type
))
498 complained
= emit_diagnostic (diag_kind
, input_location
, 0,
499 "invalid use of incomplete type %q#T",
502 cxx_incomplete_type_inform (type
);
506 emit_diagnostic (diag_kind
, input_location
, 0,
507 "invalid use of %qT", type
);
511 if (TYPE_DOMAIN (type
))
513 type
= TREE_TYPE (type
);
516 emit_diagnostic (diag_kind
, input_location
, 0,
517 "invalid use of array with unspecified bounds");
523 tree member
= TREE_OPERAND (value
, 1);
524 if (is_overloaded_fn (member
))
525 member
= get_first_fn (member
);
526 if (DECL_FUNCTION_MEMBER_P (member
)
527 && ! flag_ms_extensions
)
528 emit_diagnostic (diag_kind
, input_location
, 0,
529 "invalid use of member function "
530 "(did you forget the %<()%> ?)");
532 emit_diagnostic (diag_kind
, input_location
, 0,
533 "invalid use of member "
534 "(did you forget the %<&%> ?)");
538 case TEMPLATE_TYPE_PARM
:
540 emit_diagnostic (diag_kind
, input_location
, 0,
541 "invalid use of %<auto%>");
543 emit_diagnostic (diag_kind
, input_location
, 0,
544 "invalid use of template type parameter %qT", type
);
547 case BOUND_TEMPLATE_TEMPLATE_PARM
:
548 emit_diagnostic (diag_kind
, input_location
, 0,
549 "invalid use of template template parameter %qT",
554 emit_diagnostic (diag_kind
, input_location
, 0,
555 "invalid use of dependent type %qT", type
);
559 if (type
== init_list_type_node
)
561 emit_diagnostic (diag_kind
, input_location
, 0,
562 "invalid use of brace-enclosed initializer list");
565 gcc_assert (type
== unknown_type_node
);
566 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
568 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
569 emit_diagnostic (diag_kind
, input_location
, 0,
570 "address of overloaded function with no contextual "
572 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
573 emit_diagnostic (diag_kind
, input_location
, 0,
574 "overloaded function with no contextual type information");
576 emit_diagnostic (diag_kind
, input_location
, 0,
577 "insufficient contextual information to determine type");
585 /* Backward-compatibility interface to incomplete_type_diagnostic;
586 required by ../tree.c. */
587 #undef cxx_incomplete_type_error
589 cxx_incomplete_type_error (const_tree value
, const_tree type
)
591 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
595 /* The recursive part of split_nonconstant_init. DEST is an lvalue
596 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
597 Return true if the whole of the value was initialized by the
598 generated statements. */
601 split_nonconstant_init_1 (tree dest
, tree init
)
603 unsigned HOST_WIDE_INT idx
;
604 tree field_index
, value
, reloc
;
605 tree type
= TREE_TYPE (dest
);
606 tree inner_type
= NULL
;
607 bool array_type_p
= false;
608 bool complete_p
= true;
609 HOST_WIDE_INT num_split_elts
= 0;
611 switch (TREE_CODE (type
))
614 inner_type
= TREE_TYPE (type
);
616 if ((TREE_SIDE_EFFECTS (init
)
617 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
618 || array_of_runtime_bound_p (type
))
620 /* For an array, we only need/want a single cleanup region rather
621 than one per element. */
622 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
623 tf_warning_or_error
);
631 case QUAL_UNION_TYPE
:
632 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
635 /* The current implementation of this algorithm assumes that
636 the field was set for all the elements. This is usually done
637 by process_init_constructor. */
638 gcc_assert (field_index
);
641 inner_type
= TREE_TYPE (field_index
);
643 if (TREE_CODE (value
) == CONSTRUCTOR
)
648 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
649 NULL_TREE
, NULL_TREE
);
651 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
654 if (!split_nonconstant_init_1 (sub
, value
))
657 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
660 else if (!(reloc
= initializer_constant_valid_p (value
, inner_type
))
661 /* An absolute value is required with reverse SSO. */
662 || (reloc
!= null_pointer_node
663 && TYPE_REVERSE_STORAGE_ORDER (type
)
664 && !AGGREGATE_TYPE_P (inner_type
)))
669 /* FIXME: Ordered removal is O(1) so the whole function is
670 worst-case quadratic. This could be fixed using an aside
671 bitmap to record which elements must be removed and remove
672 them all at the same time. Or by merging
673 split_non_constant_init into process_init_constructor_array,
674 that is separating constants from non-constants while building
676 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
679 if (TREE_CODE (field_index
) == RANGE_EXPR
)
681 /* Use build_vec_init to initialize a range. */
682 tree low
= TREE_OPERAND (field_index
, 0);
683 tree hi
= TREE_OPERAND (field_index
, 1);
684 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
685 NULL_TREE
, NULL_TREE
);
686 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
687 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
688 code
= build_vec_init (sub
, max
, value
, false, 0,
689 tf_warning_or_error
);
691 if (tree_fits_shwi_p (max
))
692 num_split_elts
+= tree_to_shwi (max
);
697 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
698 NULL_TREE
, NULL_TREE
);
700 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
703 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
704 code
= build_stmt (input_location
, EXPR_STMT
, code
);
705 code
= maybe_cleanup_point_expr_void (code
);
707 if (type_build_dtor_call (inner_type
))
709 code
= (build_special_member_call
710 (sub
, complete_dtor_identifier
, NULL
, inner_type
,
711 LOOKUP_NORMAL
, tf_warning_or_error
));
712 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type
))
713 finish_eh_cleanup (code
);
723 if (!initializer_constant_valid_p (init
, type
))
726 tree cons
= copy_node (init
);
727 CONSTRUCTOR_ELTS (init
) = NULL
;
728 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
729 code
= build_stmt (input_location
, EXPR_STMT
, code
);
731 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
739 /* The rest of the initializer is now a constant. */
740 TREE_CONSTANT (init
) = 1;
741 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
742 num_split_elts
, inner_type
);
745 /* A subroutine of store_init_value. Splits non-constant static
746 initializer INIT into a constant part and generates code to
747 perform the non-constant part of the initialization to DEST.
748 Returns the code for the runtime init. */
751 split_nonconstant_init (tree dest
, tree init
)
755 if (TREE_CODE (init
) == TARGET_EXPR
)
756 init
= TARGET_EXPR_INITIAL (init
);
757 if (TREE_CODE (init
) == CONSTRUCTOR
)
759 code
= push_stmt_list ();
760 if (split_nonconstant_init_1 (dest
, init
))
762 code
= pop_stmt_list (code
);
763 DECL_INITIAL (dest
) = init
;
764 TREE_READONLY (dest
) = 0;
767 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
772 /* Perform appropriate conversions on the initial value of a variable,
773 store it in the declaration DECL,
774 and print any error messages that are appropriate.
775 If the init is invalid, store an ERROR_MARK.
777 C++: Note that INIT might be a TREE_LIST, which would mean that it is
778 a base class initializer for some aggregate type, hopefully compatible
779 with DECL. If INIT is a single element, and DECL is an aggregate
780 type, we silently convert INIT into a TREE_LIST, allowing a constructor
783 If INIT is a TREE_LIST and there is no constructor, turn INIT
784 into a CONSTRUCTOR and use standard initialization techniques.
785 Perhaps a warning should be generated?
787 Returns code to be executed if initialization could not be performed
788 for static variable. In that case, caller must emit the code. */
791 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
795 /* If variable's type was invalidly declared, just ignore it. */
797 type
= TREE_TYPE (decl
);
798 if (TREE_CODE (type
) == ERROR_MARK
)
801 if (MAYBE_CLASS_TYPE_P (type
))
803 if (TREE_CODE (init
) == TREE_LIST
)
805 error ("constructor syntax used, but no constructor declared "
806 "for type %qT", type
);
807 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
811 /* End of special C++ code. */
813 if (flags
& LOOKUP_ALREADY_DIGESTED
)
816 /* Digest the specified initializer into an expression. */
817 value
= digest_init_flags (type
, init
, flags
);
819 value
= extend_ref_init_temps (decl
, value
, cleanups
);
821 /* In C++11 constant expression is a semantic, not syntactic, property.
822 In C++98, make sure that what we thought was a constant expression at
823 template definition time is still constant and otherwise perform this
824 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
825 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
828 value
= instantiate_non_dependent_expr (value
);
829 if (DECL_DECLARED_CONSTEXPR_P (decl
)
830 || DECL_IN_AGGR_P (decl
))
832 /* Diagnose a non-constant initializer for constexpr. */
833 if (processing_template_decl
834 && !require_potential_constant_expression (value
))
835 value
= error_mark_node
;
837 value
= cxx_constant_value (value
, decl
);
839 value
= maybe_constant_init (value
, decl
);
840 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
841 /* Poison this CONSTRUCTOR so it can't be copied to another
842 constexpr variable. */
843 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
844 const_init
= (reduced_constant_expression_p (value
)
845 || error_operand_p (value
));
846 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
847 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
850 if (cxx_dialect
>= cxx14
)
851 /* Handle aggregate NSDMI in non-constant initializers, too. */
852 value
= replace_placeholders (value
, decl
);
854 /* If the initializer is not a constant, fill in DECL_INITIAL with
855 the bits that are constant, and then return an expression that
856 will perform the dynamic initialization. */
857 if (value
!= error_mark_node
858 && (TREE_SIDE_EFFECTS (value
)
859 || array_of_runtime_bound_p (type
)
860 || ! reduced_constant_expression_p (value
)))
861 return split_nonconstant_init (decl
, value
);
862 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
863 is an automatic variable, the middle end will turn this into a
864 dynamic initialization later. */
865 DECL_INITIAL (decl
) = value
;
870 /* Give diagnostic about narrowing conversions within { }. */
873 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
875 tree ftype
= unlowered_expr_type (init
);
879 if (((!warn_narrowing
|| !(complain
& tf_warning
))
880 && cxx_dialect
== cxx98
)
881 || !ARITHMETIC_TYPE_P (type
))
884 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
885 && TREE_CODE (type
) == COMPLEX_TYPE
)
887 tree elttype
= TREE_TYPE (type
);
888 if (CONSTRUCTOR_NELTS (init
) > 0)
889 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
891 if (CONSTRUCTOR_NELTS (init
) > 1)
892 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
897 init
= fold_non_dependent_expr (init
);
899 if (TREE_CODE (type
) == INTEGER_TYPE
900 && TREE_CODE (ftype
) == REAL_TYPE
)
902 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
903 && CP_INTEGRAL_TYPE_P (type
))
905 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
906 /* Check for narrowing based on the values of the enumeration. */
907 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
908 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
909 TYPE_MAX_VALUE (ftype
))
910 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
911 TYPE_MIN_VALUE (type
)))
912 && (TREE_CODE (init
) != INTEGER_CST
913 || !int_fits_type_p (init
, type
)))
916 else if (TREE_CODE (ftype
) == REAL_TYPE
917 && TREE_CODE (type
) == REAL_TYPE
)
919 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
921 if (TREE_CODE (init
) == REAL_CST
)
923 /* Issue 703: Loss of precision is OK as long as the value is
924 within the representable range of the new type. */
926 d
= TREE_REAL_CST (init
);
927 real_convert (&r
, TYPE_MODE (type
), &d
);
935 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
936 && TREE_CODE (type
) == REAL_TYPE
)
939 if (TREE_CODE (init
) == INTEGER_CST
)
941 d
= real_value_from_int_cst (0, init
);
942 if (exact_real_truncate (TYPE_MODE (type
), &d
))
949 if (cxx_dialect
== cxx98
)
950 warning_at (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
951 "narrowing conversion of %qE from %qT to %qT inside { } "
952 "is ill-formed in C++11", init
, ftype
, type
);
953 else if (!TREE_CONSTANT (init
))
955 if (complain
& tf_warning_or_error
)
957 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
958 "narrowing conversion of %qE from %qT to %qT inside { }",
963 else if (complain
& tf_error
)
965 global_dc
->pedantic_errors
= 1;
966 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
967 "narrowing conversion of %qE from %qT to %qT inside { }",
969 global_dc
->pedantic_errors
= flag_pedantic_errors
;
973 return cxx_dialect
== cxx98
|| ok
;
976 /* Process the initializer INIT for a variable of type TYPE, emitting
977 diagnostics for invalid initializers and converting the initializer as
980 For aggregate types, it assumes that reshape_init has already run, thus the
981 initializer will have the right shape (brace elision has been undone).
983 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
986 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
987 tsubst_flags_t complain
)
989 enum tree_code code
= TREE_CODE (type
);
991 if (error_operand_p (init
))
992 return error_mark_node
;
996 /* We must strip the outermost array type when completing the type,
997 because the its bounds might be incomplete at the moment. */
998 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
999 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1001 return error_mark_node
;
1003 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1004 (g++.old-deja/g++.law/casts2.C). */
1005 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1006 init
= TREE_OPERAND (init
, 0);
1008 /* Initialization of an array of chars from a string constant. The initializer
1009 can be optionally enclosed in braces, but reshape_init has already removed
1010 them if they were present. */
1011 if (code
== ARRAY_TYPE
)
1013 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1014 if (char_type_p (typ1
)
1016 && TREE_CODE (init
) == STRING_CST
)
1018 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1020 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1022 if (char_type
!= char_type_node
)
1024 if (complain
& tf_error
)
1025 error ("char-array initialized from wide string");
1026 return error_mark_node
;
1031 if (char_type
== char_type_node
)
1033 if (complain
& tf_error
)
1034 error ("int-array initialized from non-wide string");
1035 return error_mark_node
;
1037 else if (char_type
!= typ1
)
1039 if (complain
& tf_error
)
1040 error ("int-array initialized from incompatible "
1042 return error_mark_node
;
1046 if (type
!= TREE_TYPE (init
))
1048 init
= copy_node (init
);
1049 TREE_TYPE (init
) = type
;
1051 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
1053 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1054 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1055 /* In C it is ok to subtract 1 from the length of the string
1056 because it's ok to ignore the terminating null char that is
1057 counted in the length of the constant, but in C++ this would
1059 if (size
< TREE_STRING_LENGTH (init
))
1060 permerror (input_location
, "initializer-string for array "
1061 "of chars is too long");
1067 /* Handle scalar types (including conversions) and references. */
1068 if ((TREE_CODE (type
) != COMPLEX_TYPE
1069 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1070 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1075 flags
|= LOOKUP_NO_NARROWING
;
1076 init
= convert_for_initialization (0, type
, init
, flags
,
1077 ICR_INIT
, NULL_TREE
, 0,
1081 /* Skip any conversions since we'll be outputting the underlying
1083 while (CONVERT_EXPR_P (*exp
)
1084 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
1085 exp
= &TREE_OPERAND (*exp
, 0);
1087 *exp
= cplus_expand_constant (*exp
);
1092 /* Come here only for aggregates: records, arrays, unions, complex numbers
1094 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1095 || TREE_CODE (type
) == VECTOR_TYPE
1096 || TREE_CODE (type
) == RECORD_TYPE
1097 || TREE_CODE (type
) == UNION_TYPE
1098 || TREE_CODE (type
) == COMPLEX_TYPE
);
1100 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1101 && !TYPE_NON_AGGREGATE_CLASS (type
))
1102 return process_init_constructor (type
, init
, complain
);
1105 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1107 if (complain
& tf_error
)
1108 error ("cannot initialize aggregate of type %qT with "
1109 "a compound literal", type
);
1111 return error_mark_node
;
1114 if (TREE_CODE (type
) == ARRAY_TYPE
1115 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1117 /* Allow the result of build_array_copy and of
1118 build_value_init_noctor. */
1119 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1120 || TREE_CODE (init
) == CONSTRUCTOR
)
1121 && (same_type_ignoring_top_level_qualifiers_p
1122 (type
, TREE_TYPE (init
))))
1125 if (complain
& tf_error
)
1126 error ("array must be initialized with a brace-enclosed"
1128 return error_mark_node
;
1131 return convert_for_initialization (NULL_TREE
, type
, init
,
1133 ICR_INIT
, NULL_TREE
, 0,
1139 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1141 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1145 digest_init_flags (tree type
, tree init
, int flags
)
1147 return digest_init_r (type
, init
, false, flags
, tf_warning_or_error
);
1150 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1152 digest_nsdmi_init (tree decl
, tree init
)
1154 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1156 int flags
= LOOKUP_IMPLICIT
;
1157 if (DIRECT_LIST_INIT_P (init
))
1158 flags
= LOOKUP_NORMAL
;
1159 init
= digest_init_flags (TREE_TYPE (decl
), init
, flags
);
1160 if (TREE_CODE (init
) == TARGET_EXPR
)
1161 /* This represents the whole initialization. */
1162 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1166 /* Set of flags used within process_init_constructor to describe the
1168 #define PICFLAG_ERRONEOUS 1
1169 #define PICFLAG_NOT_ALL_CONSTANT 2
1170 #define PICFLAG_NOT_ALL_SIMPLE 4
1171 #define PICFLAG_SIDE_EFFECTS 8
1173 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1177 picflag_from_initializer (tree init
)
1179 if (init
== error_mark_node
)
1180 return PICFLAG_ERRONEOUS
;
1181 else if (!TREE_CONSTANT (init
))
1183 if (TREE_SIDE_EFFECTS (init
))
1184 return PICFLAG_SIDE_EFFECTS
;
1186 return PICFLAG_NOT_ALL_CONSTANT
;
1188 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1189 return PICFLAG_NOT_ALL_SIMPLE
;
1193 /* Adjust INIT for going into a CONSTRUCTOR. */
1196 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1198 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1199 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1200 if (TREE_CODE (init
) == TARGET_EXPR
1201 && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (init
))))
1202 init
= TARGET_EXPR_INITIAL (init
);
1203 /* When we defer constant folding within a statement, we may want to
1204 defer this folding as well. */
1205 tree t
= fold_non_dependent_expr (init
);
1206 t
= maybe_constant_init (t
);
1207 if (TREE_CONSTANT (t
))
1212 /* Subroutine of process_init_constructor, which will process an initializer
1213 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1214 which describe the initializers. */
1217 process_init_constructor_array (tree type
, tree init
,
1218 tsubst_flags_t complain
)
1220 unsigned HOST_WIDE_INT i
, len
= 0;
1222 bool unbounded
= false;
1223 constructor_elt
*ce
;
1224 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1226 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1227 || TREE_CODE (type
) == VECTOR_TYPE
);
1229 if (TREE_CODE (type
) == ARRAY_TYPE
)
1231 tree domain
= TYPE_DOMAIN (type
);
1232 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1233 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1234 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1235 TYPE_PRECISION (TREE_TYPE (domain
)),
1236 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1238 unbounded
= true; /* Take as many as there are. */
1241 /* Vectors are like simple fixed-size arrays. */
1242 len
= TYPE_VECTOR_SUBPARTS (type
);
1244 /* There must not be more initializers than needed. */
1245 if (!unbounded
&& vec_safe_length (v
) > len
)
1247 if (complain
& tf_error
)
1248 error ("too many initializers for %qT", type
);
1250 return PICFLAG_ERRONEOUS
;
1253 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1257 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1258 if (compare_tree_int (ce
->index
, i
) != 0)
1260 ce
->value
= error_mark_node
;
1261 sorry ("non-trivial designated initializers not supported");
1265 ce
->index
= size_int (i
);
1266 gcc_assert (ce
->value
);
1267 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1269 if (ce
->value
!= error_mark_node
)
1270 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1271 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1273 flags
|= picflag_from_initializer (ce
->value
);
1276 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1277 we must add initializers ourselves. */
1279 for (; i
< len
; ++i
)
1283 if (type_build_ctor_call (TREE_TYPE (type
)))
1285 /* If this type needs constructors run for default-initialization,
1286 we can't rely on the back end to do it for us, so make the
1287 initialization explicit by list-initializing from T{}. */
1288 next
= build_constructor (init_list_type_node
, NULL
);
1289 CONSTRUCTOR_IS_DIRECT_INIT (next
) = true;
1290 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1291 if (initializer_zerop (next
))
1292 /* The default zero-initialization is fine for us; don't
1293 add anything to the CONSTRUCTOR. */
1296 else if (!zero_init_p (TREE_TYPE (type
)))
1297 next
= build_zero_init (TREE_TYPE (type
),
1298 /*nelts=*/NULL_TREE
,
1299 /*static_storage_p=*/false);
1301 /* The default zero-initialization is fine for us; don't
1302 add anything to the CONSTRUCTOR. */
1307 flags
|= picflag_from_initializer (next
);
1308 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1312 CONSTRUCTOR_ELTS (init
) = v
;
1316 /* Subroutine of process_init_constructor, which will process an initializer
1317 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1318 the initializers. */
1321 process_init_constructor_record (tree type
, tree init
,
1322 tsubst_flags_t complain
)
1324 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1328 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1329 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1330 gcc_assert (!TYPE_BINFO (type
)
1331 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1332 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1336 unsigned HOST_WIDE_INT idx
= 0;
1337 /* Generally, we will always have an index for each initializer (which is
1338 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1339 reshape_init. So we need to handle both cases. */
1340 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1345 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1348 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1351 /* If this is a bitfield, first convert to the declared type. */
1352 type
= TREE_TYPE (field
);
1353 if (DECL_BIT_FIELD_TYPE (field
))
1354 type
= DECL_BIT_FIELD_TYPE (field
);
1355 if (type
== error_mark_node
)
1356 return PICFLAG_ERRONEOUS
;
1358 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1360 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1363 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1364 latter case can happen in templates where lookup has to be
1366 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1367 || identifier_p (ce
->index
));
1368 if (ce
->index
!= field
1369 && ce
->index
!= DECL_NAME (field
))
1371 ce
->value
= error_mark_node
;
1372 sorry ("non-trivial designated initializers not supported");
1376 gcc_assert (ce
->value
);
1377 next
= massage_init_elt (type
, ce
->value
, complain
);
1380 else if (DECL_INITIAL (field
))
1384 /* We're using an NSDMI past a field with implicit
1385 zero-init. Go back and make it explicit. */
1387 vec_safe_truncate (v
, 0);
1390 /* C++14 aggregate NSDMI. */
1391 next
= get_nsdmi (field
, /*ctor*/false);
1393 else if (type_build_ctor_call (TREE_TYPE (field
)))
1395 /* If this type needs constructors run for
1396 default-initialization, we can't rely on the back end to do it
1397 for us, so build up TARGET_EXPRs. If the type in question is
1398 a class, just build one up; if it's an array, recurse. */
1399 next
= build_constructor (init_list_type_node
, NULL
);
1400 /* Call this direct-initialization pending DR 1518 resolution so
1401 that explicit default ctors don't break valid C++03 code. */
1402 CONSTRUCTOR_IS_DIRECT_INIT (next
) = true;
1403 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1405 /* Warn when some struct elements are implicitly initialized. */
1406 if ((complain
& tf_warning
)
1407 && !EMPTY_CONSTRUCTOR_P (init
))
1408 warning (OPT_Wmissing_field_initializers
,
1409 "missing initializer for member %qD", field
);
1413 if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1415 if (complain
& tf_error
)
1416 error ("member %qD is uninitialized reference", field
);
1418 return PICFLAG_ERRONEOUS
;
1420 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1422 if (complain
& tf_error
)
1423 error ("member %qD with uninitialized reference fields", field
);
1425 return PICFLAG_ERRONEOUS
;
1428 /* Warn when some struct elements are implicitly initialized
1430 if ((complain
& tf_warning
)
1431 && !EMPTY_CONSTRUCTOR_P (init
))
1432 warning (OPT_Wmissing_field_initializers
,
1433 "missing initializer for member %qD", field
);
1435 if (!zero_init_p (TREE_TYPE (field
))
1437 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1438 /*static_storage_p=*/false);
1441 /* The default zero-initialization is fine for us; don't
1442 add anything to the CONSTRUCTOR. */
1448 /* If this is a bitfield, now convert to the lowered type. */
1449 if (type
!= TREE_TYPE (field
))
1450 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1451 flags
|= picflag_from_initializer (next
);
1452 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1455 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1457 if (complain
& tf_error
)
1458 error ("too many initializers for %qT", type
);
1460 return PICFLAG_ERRONEOUS
;
1463 CONSTRUCTOR_ELTS (init
) = v
;
1467 /* Subroutine of process_init_constructor, which will process a single
1468 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1469 which describe the initializer. */
1472 process_init_constructor_union (tree type
, tree init
,
1473 tsubst_flags_t complain
)
1475 constructor_elt
*ce
;
1478 /* If the initializer was empty, use default zero initialization. */
1479 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1482 len
= CONSTRUCTOR_ELTS (init
)->length ();
1485 if (!(complain
& tf_error
))
1486 return PICFLAG_ERRONEOUS
;
1487 error ("too many initializers for %qT", type
);
1488 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1491 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1493 /* If this element specifies a field, initialize via that field. */
1496 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1498 else if (identifier_p (ce
->index
))
1500 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1501 tree name
= ce
->index
;
1503 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1504 if (DECL_NAME (field
) == name
)
1508 if (complain
& tf_error
)
1509 error ("no field %qD found in union being initialized",
1511 ce
->value
= error_mark_node
;
1517 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1518 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1519 if (complain
& tf_error
)
1520 error ("index value instead of field name in union initializer");
1521 ce
->value
= error_mark_node
;
1526 /* Find the first named field. ANSI decided in September 1990
1527 that only named fields count here. */
1528 tree field
= TYPE_FIELDS (type
);
1529 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1530 field
= TREE_CHAIN (field
);
1531 if (field
== NULL_TREE
)
1533 if (complain
& tf_error
)
1534 error ("too many initializers for %qT", type
);
1535 ce
->value
= error_mark_node
;
1540 if (ce
->value
&& ce
->value
!= error_mark_node
)
1541 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1543 return picflag_from_initializer (ce
->value
);
1546 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1547 constructor is a brace-enclosed initializer, and will be modified in-place.
1549 Each element is converted to the right type through digest_init, and
1550 missing initializers are added following the language rules (zero-padding,
1553 After the execution, the initializer will have TREE_CONSTANT if all elts are
1554 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1555 constants that the assembler and linker can compute them.
1557 The function returns the initializer itself, or error_mark_node in case
1561 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1565 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1567 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1568 flags
= process_init_constructor_array (type
, init
, complain
);
1569 else if (TREE_CODE (type
) == RECORD_TYPE
)
1570 flags
= process_init_constructor_record (type
, init
, complain
);
1571 else if (TREE_CODE (type
) == UNION_TYPE
)
1572 flags
= process_init_constructor_union (type
, init
, complain
);
1576 if (flags
& PICFLAG_ERRONEOUS
)
1577 return error_mark_node
;
1579 TREE_TYPE (init
) = type
;
1580 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1581 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1582 if (flags
& PICFLAG_SIDE_EFFECTS
)
1584 TREE_CONSTANT (init
) = false;
1585 TREE_SIDE_EFFECTS (init
) = true;
1587 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1588 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1589 TREE_CONSTANT (init
) = false;
1592 TREE_CONSTANT (init
) = 1;
1593 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1594 TREE_STATIC (init
) = 1;
1599 /* Given a structure or union value DATUM, construct and return
1600 the structure or union component which results from narrowing
1601 that value to the base specified in BASETYPE. For example, given the
1604 class L { int ii; };
1605 class A : L { ... };
1606 class B : L { ... };
1607 class C : A, B { ... };
1615 x.A::ii refers to the ii member of the L part of
1616 the A part of the C object named by X. In this case,
1617 DATUM would be x, and BASETYPE would be A.
1619 I used to think that this was nonconformant, that the standard specified
1620 that first we look up ii in A, then convert x to an L& and pull out the
1621 ii part. But in fact, it does say that we convert x to an A&; A here
1622 is known as the "naming class". (jason 2000-12-19)
1624 BINFO_P points to a variable initialized either to NULL_TREE or to the
1625 binfo for the specific base subobject we want to convert to. */
1628 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1632 if (datum
== error_mark_node
)
1633 return error_mark_node
;
1637 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1638 NULL
, tf_warning_or_error
);
1640 if (!binfo
|| binfo
== error_mark_node
)
1642 *binfo_p
= NULL_TREE
;
1644 error_not_base_type (basetype
, TREE_TYPE (datum
));
1645 return error_mark_node
;
1649 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1650 tf_warning_or_error
);
1653 /* Build a reference to an object specified by the C++ `->' operator.
1654 Usually this just involves dereferencing the object, but if the
1655 `->' operator is overloaded, then such overloads must be
1656 performed until an object which does not have the `->' operator
1657 overloaded is found. An error is reported when circular pointer
1658 delegation is detected. */
1661 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1663 tree orig_expr
= expr
;
1664 tree type
= TREE_TYPE (expr
);
1665 tree last_rval
= NULL_TREE
;
1666 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1668 if (type
== error_mark_node
)
1669 return error_mark_node
;
1671 if (processing_template_decl
)
1673 if (type_dependent_expression_p (expr
))
1674 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1675 expr
= build_non_dependent_expr (expr
);
1678 if (MAYBE_CLASS_TYPE_P (type
))
1680 struct tinst_level
*actual_inst
= current_instantiation ();
1683 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1684 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1687 if (expr
== error_mark_node
)
1688 return error_mark_node
;
1690 /* This provides a better instantiation backtrace in case of
1692 if (fn
&& DECL_USE_TEMPLATE (fn
))
1693 push_tinst_level_loc (fn
,
1694 (current_instantiation () != actual_inst
)
1695 ? DECL_SOURCE_LOCATION (fn
)
1699 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1701 if (complain
& tf_error
)
1702 error ("circular pointer delegation detected");
1703 return error_mark_node
;
1706 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1710 while (current_instantiation () != actual_inst
)
1713 if (last_rval
== NULL_TREE
)
1715 if (complain
& tf_error
)
1716 error ("base operand of %<->%> has non-pointer type %qT", type
);
1717 return error_mark_node
;
1720 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1721 last_rval
= convert_from_reference (last_rval
);
1724 last_rval
= decay_conversion (expr
, complain
);
1726 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1728 if (processing_template_decl
)
1730 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1732 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1736 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1739 if (complain
& tf_error
)
1742 error ("result of %<operator->()%> yields non-pointer result");
1744 error ("base operand of %<->%> is not a pointer");
1746 return error_mark_node
;
1749 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1750 already been checked out to be of aggregate type. */
1753 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1761 if (error_operand_p (datum
) || error_operand_p (component
))
1762 return error_mark_node
;
1764 datum
= mark_lvalue_use (datum
);
1765 component
= mark_rvalue_use (component
);
1767 ptrmem_type
= TREE_TYPE (component
);
1768 if (!TYPE_PTRMEM_P (ptrmem_type
))
1770 if (complain
& tf_error
)
1771 error ("%qE cannot be used as a member pointer, since it is of "
1772 "type %qT", component
, ptrmem_type
);
1773 return error_mark_node
;
1776 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1777 if (! MAYBE_CLASS_TYPE_P (objtype
))
1779 if (complain
& tf_error
)
1780 error ("cannot apply member pointer %qE to %qE, which is of "
1781 "non-class type %qT", component
, datum
, objtype
);
1782 return error_mark_node
;
1785 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1786 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1788 if (!COMPLETE_TYPE_P (ctype
))
1790 if (!same_type_p (ctype
, objtype
))
1796 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1801 if (complain
& tf_error
)
1802 error ("pointer to member type %qT incompatible with object "
1803 "type %qT", type
, objtype
);
1804 return error_mark_node
;
1806 else if (binfo
== error_mark_node
)
1807 return error_mark_node
;
1810 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1812 cp_lvalue_kind kind
= lvalue_kind (datum
);
1815 /* Compute the type of the field, as described in [expr.ref].
1816 There's no such thing as a mutable pointer-to-member, so
1817 things are not as complex as they are for references to
1818 non-static data members. */
1819 type
= cp_build_qualified_type (type
,
1820 (cp_type_quals (type
)
1821 | cp_type_quals (TREE_TYPE (datum
))));
1823 datum
= build_address (datum
);
1825 /* Convert object to the correct base. */
1828 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1829 if (datum
== error_mark_node
)
1830 return error_mark_node
;
1833 /* Build an expression for "object + offset" where offset is the
1834 value stored in the pointer-to-data-member. */
1835 ptype
= build_pointer_type (type
);
1836 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1837 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1838 if (datum
== error_mark_node
)
1839 return error_mark_node
;
1841 /* If the object expression was an rvalue, return an rvalue. */
1842 if (kind
& clk_class
)
1843 datum
= rvalue (datum
);
1844 else if (kind
& clk_rvalueref
)
1845 datum
= move (datum
);
1850 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1851 program is ill-formed if the second operand is a pointer to member
1852 function with ref-qualifier &. In a .* expression whose object
1853 expression is an lvalue, the program is ill-formed if the second
1854 operand is a pointer to member function with ref-qualifier &&. */
1855 if (FUNCTION_REF_QUALIFIED (type
))
1857 bool lval
= real_lvalue_p (datum
);
1858 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1860 if (complain
& tf_error
)
1861 error ("pointer-to-member-function type %qT requires an rvalue",
1863 return error_mark_node
;
1865 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1867 if (complain
& tf_error
)
1868 error ("pointer-to-member-function type %qT requires an lvalue",
1870 return error_mark_node
;
1873 return build2 (OFFSET_REF
, type
, datum
, component
);
1877 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1880 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1882 /* This is either a call to a constructor,
1883 or a C cast in C++'s `functional' notation. */
1885 /* The type to which we are casting. */
1887 vec
<tree
, va_gc
> *parmvec
;
1889 if (error_operand_p (exp
) || parms
== error_mark_node
)
1890 return error_mark_node
;
1892 if (TREE_CODE (exp
) == TYPE_DECL
)
1894 type
= TREE_TYPE (exp
);
1896 if (complain
& tf_warning
1897 && TREE_DEPRECATED (type
)
1898 && DECL_ARTIFICIAL (exp
))
1899 warn_deprecated_use (type
, NULL_TREE
);
1904 /* We need to check this explicitly, since value-initialization of
1905 arrays is allowed in other situations. */
1906 if (TREE_CODE (type
) == ARRAY_TYPE
)
1908 if (complain
& tf_error
)
1909 error ("functional cast to array type %qT", type
);
1910 return error_mark_node
;
1913 if (type_uses_auto (type
))
1915 if (complain
& tf_error
)
1916 error ("invalid use of %<auto%>");
1917 return error_mark_node
;
1920 if (processing_template_decl
)
1924 /* Diagnose this even in a template. We could also try harder
1925 to give all the usual errors when the type and args are
1927 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1929 if (complain
& tf_error
)
1930 error ("invalid value-initialization of reference type");
1931 return error_mark_node
;
1934 t
= build_min (CAST_EXPR
, type
, parms
);
1935 /* We don't know if it will or will not have side effects. */
1936 TREE_SIDE_EFFECTS (t
) = 1;
1940 if (! MAYBE_CLASS_TYPE_P (type
))
1942 if (parms
== NULL_TREE
)
1944 if (VOID_TYPE_P (type
))
1946 return build_value_init (cv_unqualified (type
), complain
);
1949 /* This must build a C cast. */
1950 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
1951 return cp_build_c_cast (type
, parms
, complain
);
1954 /* Prepare to evaluate as a call to a constructor. If this expression
1955 is actually used, for example,
1957 return X (arg1, arg2, ...);
1959 then the slot being initialized will be filled in. */
1961 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
1962 return error_mark_node
;
1963 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
1964 return error_mark_node
;
1968 If the expression list is a single-expression, the type
1969 conversion is equivalent (in definedness, and if defined in
1970 meaning) to the corresponding cast expression. */
1971 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1972 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1976 The expression T(), where T is a simple-type-specifier for a
1977 non-array complete object type or the (possibly cv-qualified)
1978 void type, creates an rvalue of the specified type, which is
1979 value-initialized. */
1981 if (parms
== NULL_TREE
)
1983 exp
= build_value_init (type
, complain
);
1984 exp
= get_target_expr_sfinae (exp
, complain
);
1988 /* Call the constructor. */
1989 parmvec
= make_tree_vector ();
1990 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
1991 vec_safe_push (parmvec
, TREE_VALUE (parms
));
1992 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
1993 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
1994 release_tree_vector (parmvec
);
1996 if (exp
== error_mark_node
)
1997 return error_mark_node
;
1999 return build_cplus_new (type
, exp
, complain
);
2003 /* Add new exception specifier SPEC, to the LIST we currently have.
2004 If it's already in LIST then do nothing.
2005 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2006 know what we're doing. */
2009 add_exception_specifier (tree list
, tree spec
, int complain
)
2014 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2016 if (spec
== error_mark_node
)
2019 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2021 /* [except.spec] 1, type in an exception specifier shall not be
2022 incomplete, or pointer or ref to incomplete other than pointer
2024 is_ptr
= TYPE_PTR_P (core
);
2025 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2026 core
= TREE_TYPE (core
);
2029 else if (VOID_TYPE_P (core
))
2031 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2033 else if (processing_template_decl
)
2038 /* 15.4/1 says that types in an exception specifier must be complete,
2039 but it seems more reasonable to only require this on definitions
2040 and calls. So just give a pedwarn at this point; we will give an
2041 error later if we hit one of those two cases. */
2042 if (!COMPLETE_TYPE_P (complete_type (core
)))
2043 diag_type
= DK_PEDWARN
; /* pedwarn */
2050 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2051 if (same_type_p (TREE_VALUE (probe
), spec
))
2054 list
= tree_cons (NULL_TREE
, spec
, list
);
2057 diag_type
= DK_ERROR
; /* error */
2059 if (diag_type
!= DK_UNSPECIFIED
2060 && (complain
& tf_warning_or_error
))
2061 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2066 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2069 nothrow_spec_p_uninst (const_tree spec
)
2071 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2073 return nothrow_spec_p (spec
);
2076 /* Combine the two exceptions specifier lists LIST and ADD, and return
2080 merge_exception_specifiers (tree list
, tree add
)
2082 tree noex
, orig_list
;
2084 /* No exception-specifier or noexcept(false) are less strict than
2085 anything else. Prefer the newer variant (LIST). */
2086 if (!list
|| list
== noexcept_false_spec
)
2088 else if (!add
|| add
== noexcept_false_spec
)
2091 /* noexcept(true) and throw() are stricter than anything else.
2092 As above, prefer the more recent one (LIST). */
2093 if (nothrow_spec_p_uninst (add
))
2096 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2097 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2098 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2100 /* We should have instantiated other deferred noexcept specs by now. */
2101 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2103 if (nothrow_spec_p_uninst (list
))
2105 noex
= TREE_PURPOSE (list
);
2106 gcc_checking_assert (!TREE_PURPOSE (add
)
2107 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2109 /* Combine the dynamic-exception-specifiers, if any. */
2111 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2113 tree spec
= TREE_VALUE (add
);
2116 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2117 probe
= TREE_CHAIN (probe
))
2118 if (same_type_p (TREE_VALUE (probe
), spec
))
2122 spec
= build_tree_list (NULL_TREE
, spec
);
2123 TREE_CHAIN (spec
) = list
;
2128 /* Keep the noexcept-specifier at the beginning of the list. */
2129 if (noex
!= TREE_PURPOSE (list
))
2130 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2135 /* Subroutine of build_call. Ensure that each of the types in the
2136 exception specification is complete. Technically, 15.4/1 says that
2137 they need to be complete when we see a declaration of the function,
2138 but we should be able to get away with only requiring this when the
2139 function is defined or called. See also add_exception_specifier. */
2142 require_complete_eh_spec_types (tree fntype
, tree decl
)
2145 /* Don't complain about calls to op new. */
2146 if (decl
&& DECL_ARTIFICIAL (decl
))
2148 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2149 raises
= TREE_CHAIN (raises
))
2151 tree type
= TREE_VALUE (raises
);
2152 if (type
&& !COMPLETE_TYPE_P (type
))
2156 ("call to function %qD which throws incomplete type %q#T",
2159 error ("call to function which throws incomplete type %q#T",
2166 #include "gt-cp-typeck2.h"