1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This file is part of the C++ front end.
24 It contains routines to build C++ expressions given their operands,
25 including computing the types of the result, C and C++ specific error
26 checks, and some optimization. */
30 #include "coretypes.h"
32 #include "stor-layout.h"
37 process_init_constructor (tree type
, tree init
, int nested
,
38 tsubst_flags_t complain
);
41 /* Print an error message stemming from an attempt to use
42 BASETYPE as a base class for TYPE. */
45 error_not_base_type (tree basetype
, tree type
)
47 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
48 basetype
= DECL_CONTEXT (basetype
);
49 error ("type %qT is not a base type for type %qT", basetype
, type
);
50 return error_mark_node
;
54 binfo_or_else (tree base
, tree type
)
56 tree binfo
= lookup_base (type
, base
, ba_unique
,
57 NULL
, tf_warning_or_error
);
59 if (binfo
== error_mark_node
)
62 error_not_base_type (base
, type
);
66 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
67 value may not be changed thereafter. */
70 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
73 /* This macro is used to emit diagnostics to ensure that all format
74 strings are complete sentences, visible to gettext and checked at
77 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
98 /* Handle C++-specific things first. */
101 && DECL_LANG_SPECIFIC (arg
)
102 && DECL_IN_AGGR_P (arg
)
103 && !TREE_STATIC (arg
))
104 ERROR_FOR_ASSIGNMENT (G_("assignment of "
105 "constant field %qD"),
106 G_("constant field %qD "
107 "used as %<asm%> output"),
109 "constant field %qD"),
111 "constant field %qD"),
113 else if (INDIRECT_REF_P (arg
)
114 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
115 && (VAR_P (TREE_OPERAND (arg
, 0))
116 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
117 ERROR_FOR_ASSIGNMENT (G_("assignment of "
118 "read-only reference %qD"),
119 G_("read-only reference %qD "
120 "used as %<asm%> output"),
122 "read-only reference %qD"),
124 "read-only reference %qD"),
125 TREE_OPERAND (arg
, 0));
127 readonly_error (input_location
, arg
, errstring
);
131 /* Structure that holds information about declarations whose type was
132 incomplete and we could not check whether it was abstract or not. */
134 struct GTY((chain_next ("%h.next"), for_user
)) pending_abstract_type
{
135 /* Declaration which we are checking for abstractness. It is either
136 a DECL node, or an IDENTIFIER_NODE if we do not have a full
137 declaration available. */
140 /* Type which will be checked for abstractness. */
143 /* Kind of use in an unnamed declarator. */
144 enum abstract_class_use use
;
146 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
147 because DECLs already carry locus information. */
150 /* Link to the next element in list. */
151 struct pending_abstract_type
* next
;
154 struct abstract_type_hasher
: ggc_ptr_hash
<pending_abstract_type
>
156 typedef tree compare_type
;
157 static hashval_t
hash (pending_abstract_type
*);
158 static bool equal (pending_abstract_type
*, tree
);
161 /* Compute the hash value of the node VAL. This function is used by the
162 hash table abstract_pending_vars. */
165 abstract_type_hasher::hash (pending_abstract_type
*pat
)
167 return (hashval_t
) TYPE_UID (pat
->type
);
171 /* Compare node VAL1 with the type VAL2. This function is used by the
172 hash table abstract_pending_vars. */
175 abstract_type_hasher::equal (pending_abstract_type
*pat1
, tree type2
)
177 return (pat1
->type
== type2
);
180 /* Hash table that maintains pending_abstract_type nodes, for which we still
181 need to check for type abstractness. The key of the table is the type
182 of the declaration. */
183 static GTY (()) hash_table
<abstract_type_hasher
> *abstract_pending_vars
= NULL
;
185 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
187 /* This function is called after TYPE is completed, and will check if there
188 are pending declarations for which we still need to verify the abstractness
189 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
190 turned out to be incomplete. */
193 complete_type_check_abstract (tree type
)
195 struct pending_abstract_type
*pat
;
196 location_t cur_loc
= input_location
;
198 gcc_assert (COMPLETE_TYPE_P (type
));
200 if (!abstract_pending_vars
)
203 /* Retrieve the list of pending declarations for this type. */
204 pending_abstract_type
**slot
205 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
212 /* If the type is not abstract, do not do anything. */
213 if (CLASSTYPE_PURE_VIRTUALS (type
))
215 struct pending_abstract_type
*prev
= 0, *next
;
217 /* Reverse the list to emit the errors in top-down order. */
218 for (; pat
; pat
= next
)
226 /* Go through the list, and call abstract_virtuals_error for each
227 element: it will issue a diagnostic if the type is abstract. */
230 gcc_assert (type
== pat
->type
);
232 /* Tweak input_location so that the diagnostic appears at the correct
233 location. Notice that this is only needed if the decl is an
235 input_location
= pat
->locus
;
236 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
237 tf_warning_or_error
);
242 abstract_pending_vars
->clear_slot (slot
);
244 input_location
= cur_loc
;
248 /* If TYPE has abstract virtual functions, issue an error about trying
249 to create an object of that type. DECL is the object declared, or
250 NULL_TREE if the declaration is unavailable, in which case USE specifies
251 the kind of invalid use. Returns 1 if an error occurred; zero if
255 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
256 tsubst_flags_t complain
)
258 vec
<tree
, va_gc
> *pure
;
260 /* This function applies only to classes. Any other entity can never
262 if (!CLASS_TYPE_P (type
))
264 type
= TYPE_MAIN_VARIANT (type
);
267 /* Instantiation here seems to be required by the standard,
268 but breaks e.g. boost::bind. FIXME! */
269 /* In SFINAE, non-N3276 context, force instantiation. */
270 if (!(complain
& (tf_error
|tf_decltype
)))
271 complete_type (type
);
274 /* If the type is incomplete, we register it within a hash table,
275 so that we can check again once it is completed. This makes sense
276 only for objects for which we have a declaration or at least a
278 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
280 struct pending_abstract_type
*pat
;
282 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
284 if (!abstract_pending_vars
)
285 abstract_pending_vars
286 = hash_table
<abstract_type_hasher
>::create_ggc (31);
288 pending_abstract_type
**slot
289 = abstract_pending_vars
->find_slot_with_hash (type
, TYPE_UID (type
),
292 pat
= ggc_alloc
<pending_abstract_type
> ();
296 pat
->locus
= ((decl
&& DECL_P (decl
))
297 ? DECL_SOURCE_LOCATION (decl
)
306 if (!TYPE_SIZE (type
))
307 /* TYPE is being defined, and during that time
308 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
311 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
315 if (!(complain
& tf_error
))
321 error ("cannot declare variable %q+D to be of abstract "
322 "type %qT", decl
, type
);
323 else if (TREE_CODE (decl
) == PARM_DECL
)
325 if (DECL_NAME (decl
))
326 error ("cannot declare parameter %q+D to be of abstract type %qT",
329 error ("cannot declare parameter to be of abstract type %qT",
332 else if (TREE_CODE (decl
) == FIELD_DECL
)
333 error ("cannot declare field %q+D to be of abstract type %qT",
335 else if (TREE_CODE (decl
) == FUNCTION_DECL
336 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
337 error ("invalid abstract return type for member function %q+#D", decl
);
338 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
339 error ("invalid abstract return type for function %q+#D", decl
);
340 else if (identifier_p (decl
))
341 /* Here we do not have location information. */
342 error ("invalid abstract type %qT for %qE", type
, decl
);
344 error ("invalid abstract type for %q+D", decl
);
349 error ("creating array of %qT, which is an abstract class type", type
);
352 error ("invalid cast to abstract class type %qT", type
);
355 error ("invalid new-expression of abstract class type %qT", type
);
358 error ("invalid abstract return type %qT", type
);
361 error ("invalid abstract parameter type %qT", type
);
364 error ("expression of abstract class type %qT cannot "
365 "be used in throw-expression", type
);
368 error ("cannot declare catch parameter to be of abstract "
369 "class type %qT", type
);
372 error ("cannot allocate an object of abstract type %qT", type
);
375 /* Only go through this once. */
381 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
382 " because the following virtual functions are pure within %qT:",
385 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
386 if (! DECL_CLONED_FUNCTION_P (fn
)
387 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
388 inform (DECL_SOURCE_LOCATION (fn
), "\t%#qD", fn
);
390 /* Now truncate the vector. This leaves it non-null, so we know
391 there are pure virtuals, but empty so we don't list them out
400 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
402 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
406 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
407 tsubst_flags_t complain
)
409 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
413 /* Wrapper for the above function in the common case of wanting errors. */
416 abstract_virtuals_error (tree decl
, tree type
)
418 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
422 abstract_virtuals_error (abstract_class_use use
, tree type
)
424 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
427 /* Print an inform about the declaration of the incomplete type TYPE. */
430 cxx_incomplete_type_inform (const_tree type
)
432 if (!TYPE_MAIN_DECL (type
))
435 location_t loc
= DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
));
436 tree ptype
= strip_top_quals (CONST_CAST_TREE (type
));
438 if (current_class_type
439 && TYPE_BEING_DEFINED (current_class_type
)
440 && same_type_p (ptype
, current_class_type
))
441 inform (loc
, "definition of %q#T is not complete until "
442 "the closing brace", ptype
);
443 else if (!TYPE_TEMPLATE_INFO (ptype
))
444 inform (loc
, "forward declaration of %q#T", ptype
);
446 inform (loc
, "declaration of %q#T", ptype
);
449 /* Print an error message for invalid use of an incomplete type.
450 VALUE is the expression that was used (or 0 if that isn't known)
451 and TYPE is the type that was invalid. DIAG_KIND indicates the
452 type of diagnostic (see diagnostic.def). */
455 cxx_incomplete_type_diagnostic (location_t loc
, const_tree value
,
456 const_tree type
, diagnostic_t diag_kind
)
458 bool is_decl
= false, complained
= false;
460 gcc_assert (diag_kind
== DK_WARNING
461 || diag_kind
== DK_PEDWARN
462 || diag_kind
== DK_ERROR
);
464 /* Avoid duplicate error message. */
465 if (TREE_CODE (type
) == ERROR_MARK
)
468 if (value
!= 0 && (VAR_P (value
)
469 || TREE_CODE (value
) == PARM_DECL
470 || TREE_CODE (value
) == FIELD_DECL
))
472 complained
= emit_diagnostic (diag_kind
, DECL_SOURCE_LOCATION (value
), 0,
473 "%qD has incomplete type", value
);
477 /* We must print an error message. Be clever about what it says. */
479 switch (TREE_CODE (type
))
485 complained
= emit_diagnostic (diag_kind
, loc
, 0,
486 "invalid use of incomplete type %q#T",
489 cxx_incomplete_type_inform (type
);
493 emit_diagnostic (diag_kind
, loc
, 0,
494 "invalid use of %qT", type
);
498 if (TYPE_DOMAIN (type
))
500 type
= TREE_TYPE (type
);
503 emit_diagnostic (diag_kind
, loc
, 0,
504 "invalid use of array with unspecified bounds");
510 tree member
= TREE_OPERAND (value
, 1);
511 if (is_overloaded_fn (member
))
512 member
= get_first_fn (member
);
514 if (DECL_FUNCTION_MEMBER_P (member
)
515 && ! flag_ms_extensions
)
516 emit_diagnostic (diag_kind
, loc
, 0,
517 "invalid use of member function %qD "
518 "(did you forget the %<()%> ?)", member
);
520 emit_diagnostic (diag_kind
, loc
, 0,
521 "invalid use of member %qD "
522 "(did you forget the %<&%> ?)", member
);
526 case TEMPLATE_TYPE_PARM
:
529 if (CLASS_PLACEHOLDER_TEMPLATE (type
))
530 emit_diagnostic (diag_kind
, loc
, 0,
531 "invalid use of placeholder %qT", type
);
533 emit_diagnostic (diag_kind
, loc
, 0,
534 "invalid use of %qT", type
);
537 emit_diagnostic (diag_kind
, loc
, 0,
538 "invalid use of template type parameter %qT", type
);
541 case BOUND_TEMPLATE_TEMPLATE_PARM
:
542 emit_diagnostic (diag_kind
, loc
, 0,
543 "invalid use of template template parameter %qT",
549 emit_diagnostic (diag_kind
, loc
, 0,
550 "invalid use of dependent type %qT", type
);
554 if (type
== init_list_type_node
)
556 emit_diagnostic (diag_kind
, loc
, 0,
557 "invalid use of brace-enclosed initializer list");
560 gcc_assert (type
== unknown_type_node
);
561 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
563 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
564 emit_diagnostic (diag_kind
, loc
, 0,
565 "address of overloaded function with no contextual "
567 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
568 emit_diagnostic (diag_kind
, loc
, 0,
569 "overloaded function with no contextual type information");
571 emit_diagnostic (diag_kind
, loc
, 0,
572 "insufficient contextual information to determine type");
580 /* Print an error message for invalid use of an incomplete type.
581 VALUE is the expression that was used (or 0 if that isn't known)
582 and TYPE is the type that was invalid. */
585 cxx_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
587 cxx_incomplete_type_diagnostic (loc
, value
, type
, DK_ERROR
);
591 /* The recursive part of split_nonconstant_init. DEST is an lvalue
592 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
593 Return true if the whole of the value was initialized by the
594 generated statements. */
597 split_nonconstant_init_1 (tree dest
, tree init
)
599 unsigned HOST_WIDE_INT idx
;
600 tree field_index
, value
;
601 tree type
= TREE_TYPE (dest
);
602 tree inner_type
= NULL
;
603 bool array_type_p
= false;
604 bool complete_p
= true;
605 HOST_WIDE_INT num_split_elts
= 0;
607 switch (TREE_CODE (type
))
610 inner_type
= TREE_TYPE (type
);
612 if ((TREE_SIDE_EFFECTS (init
)
613 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
614 || array_of_runtime_bound_p (type
))
616 /* For an array, we only need/want a single cleanup region rather
617 than one per element. */
618 tree code
= build_vec_init (dest
, NULL_TREE
, init
, false, 1,
619 tf_warning_or_error
);
627 case QUAL_UNION_TYPE
:
628 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
631 /* The current implementation of this algorithm assumes that
632 the field was set for all the elements. This is usually done
633 by process_init_constructor. */
634 gcc_assert (field_index
);
637 inner_type
= TREE_TYPE (field_index
);
639 if (TREE_CODE (value
) == CONSTRUCTOR
)
644 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
645 NULL_TREE
, NULL_TREE
);
647 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
650 if (!split_nonconstant_init_1 (sub
, value
))
653 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
--);
656 else if (!initializer_constant_valid_p (value
, inner_type
))
661 /* FIXME: Ordered removal is O(1) so the whole function is
662 worst-case quadratic. This could be fixed using an aside
663 bitmap to record which elements must be removed and remove
664 them all at the same time. Or by merging
665 split_non_constant_init into process_init_constructor_array,
666 that is separating constants from non-constants while building
668 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
671 if (TREE_CODE (field_index
) == RANGE_EXPR
)
673 /* Use build_vec_init to initialize a range. */
674 tree low
= TREE_OPERAND (field_index
, 0);
675 tree hi
= TREE_OPERAND (field_index
, 1);
676 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
677 NULL_TREE
, NULL_TREE
);
678 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
679 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
680 code
= build_vec_init (sub
, max
, value
, false, 0,
681 tf_warning_or_error
);
683 if (tree_fits_shwi_p (max
))
684 num_split_elts
+= tree_to_shwi (max
);
689 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
690 NULL_TREE
, NULL_TREE
);
692 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
695 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
696 code
= build_stmt (input_location
, EXPR_STMT
, code
);
697 code
= maybe_cleanup_point_expr_void (code
);
700 = cxx_maybe_build_cleanup (sub
, tf_warning_or_error
))
701 finish_eh_cleanup (cleanup
);
710 if (!initializer_constant_valid_p (init
, type
))
713 tree cons
= copy_node (init
);
714 CONSTRUCTOR_ELTS (init
) = NULL
;
715 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
716 code
= build_stmt (input_location
, EXPR_STMT
, code
);
718 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
726 /* The rest of the initializer is now a constant. */
727 TREE_CONSTANT (init
) = 1;
729 /* We didn't split out anything. */
730 if (num_split_elts
== 0)
733 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
734 num_split_elts
, inner_type
);
737 /* A subroutine of store_init_value. Splits non-constant static
738 initializer INIT into a constant part and generates code to
739 perform the non-constant part of the initialization to DEST.
740 Returns the code for the runtime init. */
743 split_nonconstant_init (tree dest
, tree init
)
747 if (TREE_CODE (init
) == TARGET_EXPR
)
748 init
= TARGET_EXPR_INITIAL (init
);
749 if (TREE_CODE (init
) == CONSTRUCTOR
)
751 init
= cp_fully_fold (init
);
752 code
= push_stmt_list ();
753 if (split_nonconstant_init_1 (dest
, init
))
755 code
= pop_stmt_list (code
);
756 DECL_INITIAL (dest
) = init
;
757 TREE_READONLY (dest
) = 0;
759 else if (TREE_CODE (init
) == STRING_CST
760 && array_of_runtime_bound_p (TREE_TYPE (dest
)))
761 code
= build_vec_init (dest
, NULL_TREE
, init
, /*value-init*/false,
762 /*from array*/1, tf_warning_or_error
);
764 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
769 /* Perform appropriate conversions on the initial value of a variable,
770 store it in the declaration DECL,
771 and print any error messages that are appropriate.
772 If the init is invalid, store an ERROR_MARK.
774 C++: Note that INIT might be a TREE_LIST, which would mean that it is
775 a base class initializer for some aggregate type, hopefully compatible
776 with DECL. If INIT is a single element, and DECL is an aggregate
777 type, we silently convert INIT into a TREE_LIST, allowing a constructor
780 If INIT is a TREE_LIST and there is no constructor, turn INIT
781 into a CONSTRUCTOR and use standard initialization techniques.
782 Perhaps a warning should be generated?
784 Returns code to be executed if initialization could not be performed
785 for static variable. In that case, caller must emit the code. */
788 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
792 /* If variable's type was invalidly declared, just ignore it. */
794 type
= TREE_TYPE (decl
);
795 if (TREE_CODE (type
) == ERROR_MARK
)
798 if (MAYBE_CLASS_TYPE_P (type
))
800 if (TREE_CODE (init
) == TREE_LIST
)
802 error ("constructor syntax used, but no constructor declared "
803 "for type %qT", type
);
804 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
808 /* End of special C++ code. */
810 if (flags
& LOOKUP_ALREADY_DIGESTED
)
813 /* Digest the specified initializer into an expression. */
814 value
= digest_init_flags (type
, init
, flags
, tf_warning_or_error
);
816 value
= extend_ref_init_temps (decl
, value
, cleanups
);
818 /* In C++11 constant expression is a semantic, not syntactic, property.
819 In C++98, make sure that what we thought was a constant expression at
820 template definition time is still constant and otherwise perform this
821 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
822 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
825 value
= instantiate_non_dependent_expr (value
);
826 if (DECL_DECLARED_CONSTEXPR_P (decl
)
827 || (DECL_IN_AGGR_P (decl
) && !DECL_VAR_DECLARED_INLINE_P (decl
)))
829 /* Diagnose a non-constant initializer for constexpr. */
830 if (!require_constant_expression (value
))
831 value
= error_mark_node
;
833 value
= cxx_constant_init (value
, decl
);
836 value
= maybe_constant_init (value
, decl
);
837 if (TREE_CODE (value
) == CONSTRUCTOR
&& cp_has_mutable_p (type
))
838 /* Poison this CONSTRUCTOR so it can't be copied to another
839 constexpr variable. */
840 CONSTRUCTOR_MUTABLE_POISON (value
) = true;
841 const_init
= (reduced_constant_expression_p (value
)
842 || error_operand_p (value
));
843 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
844 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
845 if (TREE_CODE (type
) != REFERENCE_TYPE
)
846 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
848 value
= cp_fully_fold (value
);
850 /* Handle aggregate NSDMI in non-constant initializers, too. */
851 value
= replace_placeholders (value
, decl
);
853 /* DECL may change value; purge caches. */
854 clear_cv_and_fold_caches ();
856 /* If the initializer is not a constant, fill in DECL_INITIAL with
857 the bits that are constant, and then return an expression that
858 will perform the dynamic initialization. */
859 if (value
!= error_mark_node
860 && (TREE_SIDE_EFFECTS (value
)
861 || array_of_runtime_bound_p (type
)
862 || ! reduced_constant_expression_p (value
)))
863 return split_nonconstant_init (decl
, value
);
864 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
865 is an automatic variable, the middle end will turn this into a
866 dynamic initialization later. */
867 DECL_INITIAL (decl
) = value
;
872 /* Give diagnostic about narrowing conversions within { }. */
875 check_narrowing (tree type
, tree init
, tsubst_flags_t complain
)
877 tree ftype
= unlowered_expr_type (init
);
881 if (((!warn_narrowing
|| !(complain
& tf_warning
))
882 && cxx_dialect
== cxx98
)
883 || !ARITHMETIC_TYPE_P (type
))
886 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
887 && TREE_CODE (type
) == COMPLEX_TYPE
)
889 tree elttype
= TREE_TYPE (type
);
890 if (CONSTRUCTOR_NELTS (init
) > 0)
891 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
,
893 if (CONSTRUCTOR_NELTS (init
) > 1)
894 ok
&= check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
,
899 init
= fold_non_dependent_expr (init
);
901 if (TREE_CODE (type
) == INTEGER_TYPE
902 && TREE_CODE (ftype
) == REAL_TYPE
)
904 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
905 && CP_INTEGRAL_TYPE_P (type
))
907 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
908 /* Check for narrowing based on the values of the enumeration. */
909 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
910 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
911 TYPE_MAX_VALUE (ftype
))
912 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
913 TYPE_MIN_VALUE (type
)))
914 && (TREE_CODE (init
) != INTEGER_CST
915 || !int_fits_type_p (init
, type
)))
918 else if (TREE_CODE (ftype
) == REAL_TYPE
919 && TREE_CODE (type
) == REAL_TYPE
)
921 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
923 if (TREE_CODE (init
) == REAL_CST
)
925 /* Issue 703: Loss of precision is OK as long as the value is
926 within the representable range of the new type. */
928 d
= TREE_REAL_CST (init
);
929 real_convert (&r
, TYPE_MODE (type
), &d
);
937 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
938 && TREE_CODE (type
) == REAL_TYPE
)
941 if (TREE_CODE (init
) == INTEGER_CST
)
943 d
= real_value_from_int_cst (0, init
);
944 if (exact_real_truncate (TYPE_MODE (type
), &d
))
950 if (!ok
&& !CONSTANT_CLASS_P (init
) && (complain
& tf_warning_or_error
))
952 tree folded
= cp_fully_fold (init
);
953 if (TREE_CONSTANT (folded
) && check_narrowing (type
, folded
, tf_none
))
959 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
960 if (cxx_dialect
== cxx98
)
962 if (complain
& tf_warning
)
963 warning_at (loc
, OPT_Wnarrowing
, "narrowing conversion of %qE "
964 "from %qH to %qI inside { } is ill-formed in C++11",
968 else if (!CONSTANT_CLASS_P (init
))
970 if (complain
& tf_warning_or_error
)
972 if ((!almost_ok
|| pedantic
)
973 && pedwarn (loc
, OPT_Wnarrowing
,
974 "narrowing conversion of %qE "
975 "from %qH to %qI inside { }",
978 inform (loc
, " the expression has a constant value but is not "
979 "a C++ constant-expression");
983 else if (complain
& tf_error
)
985 int savederrorcount
= errorcount
;
986 global_dc
->pedantic_errors
= 1;
987 pedwarn (loc
, OPT_Wnarrowing
,
988 "narrowing conversion of %qE from %qH to %qI "
989 "inside { }", init
, ftype
, type
);
990 if (errorcount
== savederrorcount
)
992 global_dc
->pedantic_errors
= flag_pedantic_errors
;
999 /* Process the initializer INIT for a variable of type TYPE, emitting
1000 diagnostics for invalid initializers and converting the initializer as
1003 For aggregate types, it assumes that reshape_init has already run, thus the
1004 initializer will have the right shape (brace elision has been undone).
1006 NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
1007 2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR. */
1010 digest_init_r (tree type
, tree init
, int nested
, int flags
,
1011 tsubst_flags_t complain
)
1013 enum tree_code code
= TREE_CODE (type
);
1015 if (error_operand_p (init
))
1016 return error_mark_node
;
1020 /* We must strip the outermost array type when completing the type,
1021 because the its bounds might be incomplete at the moment. */
1022 if (!complete_type_or_maybe_complain (code
== ARRAY_TYPE
1023 ? TREE_TYPE (type
) : type
, NULL_TREE
,
1025 return error_mark_node
;
1027 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
1028 (g++.old-deja/g++.law/casts2.C). */
1029 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
1030 init
= TREE_OPERAND (init
, 0);
1032 location_t loc
= EXPR_LOC_OR_LOC (init
, input_location
);
1034 /* Initialization of an array of chars from a string constant. The initializer
1035 can be optionally enclosed in braces, but reshape_init has already removed
1036 them if they were present. */
1037 if (code
== ARRAY_TYPE
)
1039 if (nested
&& !TYPE_DOMAIN (type
))
1040 /* C++ flexible array members have a null domain. */
1041 pedwarn (loc
, OPT_Wpedantic
,
1042 "initialization of a flexible array member");
1044 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1045 if (char_type_p (typ1
)
1047 && TREE_CODE (init
) == STRING_CST
)
1049 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
1051 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
1053 if (char_type
!= char_type_node
)
1055 if (complain
& tf_error
)
1056 error_at (loc
, "char-array initialized from wide string");
1057 return error_mark_node
;
1062 if (char_type
== char_type_node
)
1064 if (complain
& tf_error
)
1066 "int-array initialized from non-wide string");
1067 return error_mark_node
;
1069 else if (char_type
!= typ1
)
1071 if (complain
& tf_error
)
1072 error_at (loc
, "int-array initialized from incompatible "
1074 return error_mark_node
;
1078 if (nested
== 2 && !TYPE_DOMAIN (type
))
1080 if (complain
& tf_error
)
1081 error_at (loc
, "initialization of flexible array member "
1082 "in a nested context");
1083 return error_mark_node
;
1086 if (type
!= TREE_TYPE (init
)
1087 && !variably_modified_type_p (type
, NULL_TREE
))
1089 init
= copy_node (init
);
1090 TREE_TYPE (init
) = type
;
1092 if (TYPE_DOMAIN (type
) && TREE_CONSTANT (TYPE_SIZE (type
)))
1094 /* Not a flexible array member. */
1095 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1096 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1097 /* In C it is ok to subtract 1 from the length of the string
1098 because it's ok to ignore the terminating null char that is
1099 counted in the length of the constant, but in C++ this would
1101 if (size
< TREE_STRING_LENGTH (init
))
1102 permerror (loc
, "initializer-string for array "
1103 "of chars is too long");
1109 /* Handle scalar types (including conversions) and references. */
1110 if ((code
!= COMPLEX_TYPE
|| BRACE_ENCLOSED_INITIALIZER_P (init
))
1111 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1114 flags
|= LOOKUP_NO_NARROWING
;
1115 init
= convert_for_initialization (0, type
, init
, flags
,
1116 ICR_INIT
, NULL_TREE
, 0,
1122 /* Come here only for aggregates: records, arrays, unions, complex numbers
1124 gcc_assert (code
== ARRAY_TYPE
1125 || VECTOR_TYPE_P (type
)
1126 || code
== RECORD_TYPE
1127 || code
== UNION_TYPE
1128 || code
== COMPLEX_TYPE
);
1130 /* "If T is a class type and the initializer list has a single
1131 element of type cv U, where U is T or a class derived from T,
1132 the object is initialized from that element." */
1134 && cxx_dialect
>= cxx11
1135 && BRACE_ENCLOSED_INITIALIZER_P (init
)
1136 && CONSTRUCTOR_NELTS (init
) == 1
1137 && ((CLASS_TYPE_P (type
) && !CLASSTYPE_NON_AGGREGATE (type
))
1138 || VECTOR_TYPE_P (type
)))
1140 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
1141 if (reference_related_p (type
, TREE_TYPE (elt
)))
1142 /* We should have fixed this in reshape_init. */
1146 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1147 && !TYPE_NON_AGGREGATE_CLASS (type
))
1148 return process_init_constructor (type
, init
, nested
, complain
);
1151 if (COMPOUND_LITERAL_P (init
) && code
== ARRAY_TYPE
)
1153 if (complain
& tf_error
)
1154 error_at (loc
, "cannot initialize aggregate of type %qT with "
1155 "a compound literal", type
);
1157 return error_mark_node
;
1160 if (code
== ARRAY_TYPE
1161 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1163 /* Allow the result of build_array_copy and of
1164 build_value_init_noctor. */
1165 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1166 || TREE_CODE (init
) == CONSTRUCTOR
)
1167 && (same_type_ignoring_top_level_qualifiers_p
1168 (type
, TREE_TYPE (init
))))
1171 if (complain
& tf_error
)
1172 error_at (loc
, "array must be initialized with a brace-enclosed"
1174 return error_mark_node
;
1177 return convert_for_initialization (NULL_TREE
, type
, init
,
1179 ICR_INIT
, NULL_TREE
, 0,
1185 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1187 return digest_init_r (type
, init
, 0, LOOKUP_IMPLICIT
, complain
);
1191 digest_init_flags (tree type
, tree init
, int flags
, tsubst_flags_t complain
)
1193 return digest_init_r (type
, init
, 0, flags
, complain
);
1196 /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL). */
1198 digest_nsdmi_init (tree decl
, tree init
, tsubst_flags_t complain
)
1200 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
1202 tree type
= TREE_TYPE (decl
);
1203 int flags
= LOOKUP_IMPLICIT
;
1204 if (DIRECT_LIST_INIT_P (init
))
1205 flags
= LOOKUP_NORMAL
;
1206 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1207 && CP_AGGREGATE_TYPE_P (type
))
1208 init
= reshape_init (type
, init
, complain
);
1209 init
= digest_init_flags (type
, init
, flags
, complain
);
1210 if (TREE_CODE (init
) == TARGET_EXPR
)
1211 /* This represents the whole initialization. */
1212 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
1216 /* Set of flags used within process_init_constructor to describe the
1218 #define PICFLAG_ERRONEOUS 1
1219 #define PICFLAG_NOT_ALL_CONSTANT 2
1220 #define PICFLAG_NOT_ALL_SIMPLE 4
1221 #define PICFLAG_SIDE_EFFECTS 8
1223 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1227 picflag_from_initializer (tree init
)
1229 if (init
== error_mark_node
)
1230 return PICFLAG_ERRONEOUS
;
1231 else if (!TREE_CONSTANT (init
))
1233 if (TREE_SIDE_EFFECTS (init
))
1234 return PICFLAG_SIDE_EFFECTS
;
1236 return PICFLAG_NOT_ALL_CONSTANT
;
1238 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1239 return PICFLAG_NOT_ALL_SIMPLE
;
1243 /* Adjust INIT for going into a CONSTRUCTOR. */
1246 massage_init_elt (tree type
, tree init
, int nested
, tsubst_flags_t complain
)
1248 init
= digest_init_r (type
, init
, nested
? 2 : 1, LOOKUP_IMPLICIT
, complain
);
1249 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1250 if (SIMPLE_TARGET_EXPR_P (init
))
1251 init
= TARGET_EXPR_INITIAL (init
);
1252 /* When we defer constant folding within a statement, we may want to
1253 defer this folding as well. */
1254 tree t
= fold_non_dependent_expr (init
);
1255 t
= maybe_constant_init (t
);
1256 if (TREE_CONSTANT (t
))
1261 /* Subroutine of process_init_constructor, which will process an initializer
1262 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1263 which describe the initializers. */
1266 process_init_constructor_array (tree type
, tree init
, int nested
,
1267 tsubst_flags_t complain
)
1269 unsigned HOST_WIDE_INT i
, len
= 0;
1271 bool unbounded
= false;
1272 constructor_elt
*ce
;
1273 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1275 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1276 || VECTOR_TYPE_P (type
));
1278 if (TREE_CODE (type
) == ARRAY_TYPE
)
1280 /* C++ flexible array members have a null domain. */
1281 tree domain
= TYPE_DOMAIN (type
);
1282 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1283 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1284 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1285 TYPE_PRECISION (TREE_TYPE (domain
)),
1286 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1288 unbounded
= true; /* Take as many as there are. */
1290 if (nested
== 2 && !domain
&& !vec_safe_is_empty (v
))
1292 if (complain
& tf_error
)
1293 error_at (EXPR_LOC_OR_LOC (init
, input_location
),
1294 "initialization of flexible array member "
1295 "in a nested context");
1296 return PICFLAG_ERRONEOUS
;
1300 /* Vectors are like simple fixed-size arrays. */
1301 unbounded
= !TYPE_VECTOR_SUBPARTS (type
).is_constant (&len
);
1303 /* There must not be more initializers than needed. */
1304 if (!unbounded
&& vec_safe_length (v
) > len
)
1306 if (complain
& tf_error
)
1307 error ("too many initializers for %qT", type
);
1309 return PICFLAG_ERRONEOUS
;
1312 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1315 ce
->index
= size_int (i
);
1316 else if (!check_array_designated_initializer (ce
, i
))
1317 ce
->index
= error_mark_node
;
1318 gcc_assert (ce
->value
);
1320 = massage_init_elt (TREE_TYPE (type
), ce
->value
, nested
, complain
);
1322 if (ce
->value
!= error_mark_node
)
1323 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1324 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1326 flags
|= picflag_from_initializer (ce
->value
);
1329 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1330 we must add initializers ourselves. */
1332 for (; i
< len
; ++i
)
1336 if (type_build_ctor_call (TREE_TYPE (type
)))
1338 /* If this type needs constructors run for default-initialization,
1339 we can't rely on the back end to do it for us, so make the
1340 initialization explicit by list-initializing from T{}. */
1341 next
= build_constructor (init_list_type_node
, NULL
);
1342 next
= massage_init_elt (TREE_TYPE (type
), next
, nested
, complain
);
1343 if (initializer_zerop (next
))
1344 /* The default zero-initialization is fine for us; don't
1345 add anything to the CONSTRUCTOR. */
1348 else if (!zero_init_p (TREE_TYPE (type
)))
1349 next
= build_zero_init (TREE_TYPE (type
),
1350 /*nelts=*/NULL_TREE
,
1351 /*static_storage_p=*/false);
1353 /* The default zero-initialization is fine for us; don't
1354 add anything to the CONSTRUCTOR. */
1359 flags
|= picflag_from_initializer (next
);
1360 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1364 CONSTRUCTOR_ELTS (init
) = v
;
1368 /* Subroutine of process_init_constructor, which will process an initializer
1369 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1370 the initializers. */
1373 process_init_constructor_record (tree type
, tree init
, int nested
,
1374 tsubst_flags_t complain
)
1376 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1380 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1381 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1382 gcc_assert (!TYPE_BINFO (type
)
1383 || cxx_dialect
>= cxx17
1384 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1385 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1389 unsigned HOST_WIDE_INT idx
= 0;
1390 int designator_skip
= -1;
1391 /* Generally, we will always have an index for each initializer (which is
1392 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1393 reshape_init. So we need to handle both cases. */
1394 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1399 if (TREE_CODE (field
) != FIELD_DECL
1400 || (DECL_ARTIFICIAL (field
)
1401 && !(cxx_dialect
>= cxx17
&& DECL_FIELD_IS_BASE (field
))))
1404 if (DECL_UNNAMED_BIT_FIELD (field
))
1407 /* If this is a bitfield, first convert to the declared type. */
1408 type
= TREE_TYPE (field
);
1409 if (DECL_BIT_FIELD_TYPE (field
))
1410 type
= DECL_BIT_FIELD_TYPE (field
);
1411 if (type
== error_mark_node
)
1412 return PICFLAG_ERRONEOUS
;
1415 if (idx
< CONSTRUCTOR_NELTS (init
))
1417 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1420 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1421 latter case can happen in templates where lookup has to be
1423 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1424 || identifier_p (ce
->index
));
1425 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1427 else if (ANON_AGGR_TYPE_P (type
)
1428 && search_anon_aggr (type
,
1429 TREE_CODE (ce
->index
) == FIELD_DECL
1430 ? DECL_NAME (ce
->index
)
1432 /* If the element is an anonymous union object and the
1433 initializer list is a designated-initializer-list, the
1434 anonymous union object is initialized by the
1435 designated-initializer-list { D }, where D is the
1436 designated-initializer-clause naming a member of the
1437 anonymous union object. */
1438 next
= build_constructor_single (type
, ce
->index
, ce
->value
);
1442 if (designator_skip
== -1)
1443 designator_skip
= 1;
1448 designator_skip
= 0;
1454 gcc_assert (ce
->value
);
1455 next
= massage_init_elt (type
, next
, nested
, complain
);
1460 /* Already handled above. */;
1461 else if (DECL_INITIAL (field
))
1465 /* We're using an NSDMI past a field with implicit
1466 zero-init. Go back and make it explicit. */
1468 vec_safe_truncate (v
, 0);
1471 /* C++14 aggregate NSDMI. */
1472 next
= get_nsdmi (field
, /*ctor*/false, complain
);
1474 else if (type_build_ctor_call (TREE_TYPE (field
)))
1476 /* If this type needs constructors run for
1477 default-initialization, we can't rely on the back end to do it
1478 for us, so build up TARGET_EXPRs. If the type in question is
1479 a class, just build one up; if it's an array, recurse. */
1480 next
= build_constructor (init_list_type_node
, NULL
);
1481 next
= massage_init_elt (TREE_TYPE (field
), next
, nested
, complain
);
1483 /* Warn when some struct elements are implicitly initialized. */
1484 if ((complain
& tf_warning
)
1485 && !EMPTY_CONSTRUCTOR_P (init
))
1486 warning (OPT_Wmissing_field_initializers
,
1487 "missing initializer for member %qD", field
);
1491 const_tree fldtype
= TREE_TYPE (field
);
1492 if (TREE_CODE (fldtype
) == REFERENCE_TYPE
)
1494 if (complain
& tf_error
)
1495 error ("member %qD is uninitialized reference", field
);
1497 return PICFLAG_ERRONEOUS
;
1499 else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype
))
1501 if (complain
& tf_error
)
1502 error ("member %qD with uninitialized reference fields", field
);
1504 return PICFLAG_ERRONEOUS
;
1507 /* Warn when some struct elements are implicitly initialized
1508 to zero. However, avoid issuing the warning for flexible
1509 array members since they need not have any elements. */
1510 if ((TREE_CODE (fldtype
) != ARRAY_TYPE
|| TYPE_DOMAIN (fldtype
))
1511 && (complain
& tf_warning
)
1512 && !EMPTY_CONSTRUCTOR_P (init
))
1513 warning (OPT_Wmissing_field_initializers
,
1514 "missing initializer for member %qD", field
);
1516 if (!zero_init_p (fldtype
)
1518 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1519 /*static_storage_p=*/false);
1522 /* The default zero-initialization is fine for us; don't
1523 add anything to the CONSTRUCTOR. */
1529 /* If this is a bitfield, now convert to the lowered type. */
1530 if (type
!= TREE_TYPE (field
))
1531 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1532 flags
|= picflag_from_initializer (next
);
1533 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1536 if (idx
< CONSTRUCTOR_NELTS (init
))
1538 if (complain
& tf_error
)
1540 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1541 /* For better diagnostics, try to find out if it is really
1542 the case of too many initializers or if designators are
1543 in incorrect order. */
1544 if (designator_skip
== 1 && ce
->index
)
1546 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1547 || identifier_p (ce
->index
));
1548 for (field
= TYPE_FIELDS (type
);
1549 field
; field
= DECL_CHAIN (field
))
1551 if (TREE_CODE (field
) != FIELD_DECL
1552 || (DECL_ARTIFICIAL (field
)
1553 && !(cxx_dialect
>= cxx17
1554 && DECL_FIELD_IS_BASE (field
))))
1557 if (DECL_UNNAMED_BIT_FIELD (field
))
1560 if (ce
->index
== field
|| ce
->index
== DECL_NAME (field
))
1562 if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1565 = search_anon_aggr (TREE_TYPE (field
),
1566 TREE_CODE (ce
->index
) == FIELD_DECL
1567 ? DECL_NAME (ce
->index
)
1578 error ("designator order for field %qD does not match declaration "
1579 "order in %qT", field
, type
);
1581 error ("too many initializers for %qT", type
);
1584 return PICFLAG_ERRONEOUS
;
1587 CONSTRUCTOR_ELTS (init
) = v
;
1591 /* Subroutine of process_init_constructor, which will process a single
1592 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1593 which describe the initializer. */
1596 process_init_constructor_union (tree type
, tree init
, int nested
,
1597 tsubst_flags_t complain
)
1599 constructor_elt
*ce
;
1602 /* If the initializer was empty, use the union's NSDMI if it has one.
1603 Otherwise use default zero initialization. */
1604 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1606 for (tree field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1608 if (TREE_CODE (field
) == FIELD_DECL
1609 && DECL_INITIAL (field
) != NULL_TREE
)
1611 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init
),
1613 get_nsdmi (field
, /*in_ctor=*/false,
1619 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1623 len
= CONSTRUCTOR_ELTS (init
)->length ();
1626 if (!(complain
& tf_error
))
1627 return PICFLAG_ERRONEOUS
;
1628 error ("too many initializers for %qT", type
);
1629 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1632 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1634 /* If this element specifies a field, initialize via that field. */
1637 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1639 else if (identifier_p (ce
->index
))
1641 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1642 tree name
= ce
->index
;
1644 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1645 if (DECL_NAME (field
) == name
)
1649 if (complain
& tf_error
)
1650 error ("no field %qD found in union being initialized",
1652 ce
->value
= error_mark_node
;
1658 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1659 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1660 if (complain
& tf_error
)
1661 error ("index value instead of field name in union initializer");
1662 ce
->value
= error_mark_node
;
1667 /* Find the first named field. ANSI decided in September 1990
1668 that only named fields count here. */
1669 tree field
= TYPE_FIELDS (type
);
1670 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1671 field
= TREE_CHAIN (field
);
1672 if (field
== NULL_TREE
)
1674 if (complain
& tf_error
)
1675 error ("too many initializers for %qT", type
);
1676 ce
->value
= error_mark_node
;
1681 if (ce
->value
&& ce
->value
!= error_mark_node
)
1682 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, nested
,
1685 return picflag_from_initializer (ce
->value
);
1688 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1689 constructor is a brace-enclosed initializer, and will be modified in-place.
1691 Each element is converted to the right type through digest_init, and
1692 missing initializers are added following the language rules (zero-padding,
1695 After the execution, the initializer will have TREE_CONSTANT if all elts are
1696 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1697 constants that the assembler and linker can compute them.
1699 The function returns the initializer itself, or error_mark_node in case
1703 process_init_constructor (tree type
, tree init
, int nested
,
1704 tsubst_flags_t complain
)
1708 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1710 if (TREE_CODE (type
) == ARRAY_TYPE
|| VECTOR_TYPE_P (type
))
1711 flags
= process_init_constructor_array (type
, init
, nested
, complain
);
1712 else if (TREE_CODE (type
) == RECORD_TYPE
)
1713 flags
= process_init_constructor_record (type
, init
, nested
, complain
);
1714 else if (TREE_CODE (type
) == UNION_TYPE
)
1715 flags
= process_init_constructor_union (type
, init
, nested
, complain
);
1719 if (flags
& PICFLAG_ERRONEOUS
)
1720 return error_mark_node
;
1722 TREE_TYPE (init
) = type
;
1723 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1724 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1725 if (flags
& PICFLAG_SIDE_EFFECTS
)
1727 TREE_CONSTANT (init
) = false;
1728 TREE_SIDE_EFFECTS (init
) = true;
1730 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1731 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1732 TREE_CONSTANT (init
) = false;
1735 TREE_CONSTANT (init
) = 1;
1736 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1737 TREE_STATIC (init
) = 1;
1742 /* Given a structure or union value DATUM, construct and return
1743 the structure or union component which results from narrowing
1744 that value to the base specified in BASETYPE. For example, given the
1747 class L { int ii; };
1748 class A : L { ... };
1749 class B : L { ... };
1750 class C : A, B { ... };
1758 x.A::ii refers to the ii member of the L part of
1759 the A part of the C object named by X. In this case,
1760 DATUM would be x, and BASETYPE would be A.
1762 I used to think that this was nonconformant, that the standard specified
1763 that first we look up ii in A, then convert x to an L& and pull out the
1764 ii part. But in fact, it does say that we convert x to an A&; A here
1765 is known as the "naming class". (jason 2000-12-19)
1767 BINFO_P points to a variable initialized either to NULL_TREE or to the
1768 binfo for the specific base subobject we want to convert to. */
1771 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1775 if (datum
== error_mark_node
)
1776 return error_mark_node
;
1780 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1781 NULL
, tf_warning_or_error
);
1783 if (!binfo
|| binfo
== error_mark_node
)
1785 *binfo_p
= NULL_TREE
;
1787 error_not_base_type (basetype
, TREE_TYPE (datum
));
1788 return error_mark_node
;
1792 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1793 tf_warning_or_error
);
1796 /* Build a reference to an object specified by the C++ `->' operator.
1797 Usually this just involves dereferencing the object, but if the
1798 `->' operator is overloaded, then such overloads must be
1799 performed until an object which does not have the `->' operator
1800 overloaded is found. An error is reported when circular pointer
1801 delegation is detected. */
1804 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1806 tree orig_expr
= expr
;
1807 tree type
= TREE_TYPE (expr
);
1808 tree last_rval
= NULL_TREE
;
1809 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1811 if (type
== error_mark_node
)
1812 return error_mark_node
;
1814 if (processing_template_decl
)
1816 if (type
&& TREE_CODE (type
) == POINTER_TYPE
1817 && !dependent_scope_p (TREE_TYPE (type
)))
1818 /* Pointer to current instantiation, don't treat as dependent. */;
1819 else if (type_dependent_expression_p (expr
))
1820 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1821 expr
= build_non_dependent_expr (expr
);
1824 if (MAYBE_CLASS_TYPE_P (type
))
1826 struct tinst_level
*actual_inst
= current_instantiation ();
1829 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1830 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1833 if (expr
== error_mark_node
)
1834 return error_mark_node
;
1836 /* This provides a better instantiation backtrace in case of
1838 if (fn
&& DECL_USE_TEMPLATE (fn
))
1839 push_tinst_level_loc (fn
,
1840 (current_instantiation () != actual_inst
)
1841 ? DECL_SOURCE_LOCATION (fn
)
1845 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1847 if (complain
& tf_error
)
1848 error ("circular pointer delegation detected");
1849 return error_mark_node
;
1852 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1856 while (current_instantiation () != actual_inst
)
1859 if (last_rval
== NULL_TREE
)
1861 if (complain
& tf_error
)
1862 error ("base operand of %<->%> has non-pointer type %qT", type
);
1863 return error_mark_node
;
1866 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1867 last_rval
= convert_from_reference (last_rval
);
1870 last_rval
= decay_conversion (expr
, complain
);
1872 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1874 if (processing_template_decl
)
1876 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1878 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1882 return cp_build_indirect_ref (last_rval
, RO_ARROW
, complain
);
1885 if (complain
& tf_error
)
1888 error ("result of %<operator->()%> yields non-pointer result");
1890 error ("base operand of %<->%> is not a pointer");
1892 return error_mark_node
;
1895 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1896 already been checked out to be of aggregate type. */
1899 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1907 if (error_operand_p (datum
) || error_operand_p (component
))
1908 return error_mark_node
;
1910 datum
= mark_lvalue_use (datum
);
1911 component
= mark_rvalue_use (component
);
1913 ptrmem_type
= TREE_TYPE (component
);
1914 if (!TYPE_PTRMEM_P (ptrmem_type
))
1916 if (complain
& tf_error
)
1917 error ("%qE cannot be used as a member pointer, since it is of "
1918 "type %qT", component
, ptrmem_type
);
1919 return error_mark_node
;
1922 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1923 if (! MAYBE_CLASS_TYPE_P (objtype
))
1925 if (complain
& tf_error
)
1926 error ("cannot apply member pointer %qE to %qE, which is of "
1927 "non-class type %qT", component
, datum
, objtype
);
1928 return error_mark_node
;
1931 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1932 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1934 if (!COMPLETE_TYPE_P (ctype
))
1936 if (!same_type_p (ctype
, objtype
))
1942 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1947 if (complain
& tf_error
)
1948 error ("pointer to member type %qT incompatible with object "
1949 "type %qT", type
, objtype
);
1950 return error_mark_node
;
1952 else if (binfo
== error_mark_node
)
1953 return error_mark_node
;
1956 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1958 cp_lvalue_kind kind
= lvalue_kind (datum
);
1961 /* Compute the type of the field, as described in [expr.ref].
1962 There's no such thing as a mutable pointer-to-member, so
1963 things are not as complex as they are for references to
1964 non-static data members. */
1965 type
= cp_build_qualified_type (type
,
1966 (cp_type_quals (type
)
1967 | cp_type_quals (TREE_TYPE (datum
))));
1969 datum
= build_address (datum
);
1971 /* Convert object to the correct base. */
1974 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1975 if (datum
== error_mark_node
)
1976 return error_mark_node
;
1979 /* Build an expression for "object + offset" where offset is the
1980 value stored in the pointer-to-data-member. */
1981 ptype
= build_pointer_type (type
);
1982 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1983 datum
= cp_build_fold_indirect_ref (datum
);
1984 if (datum
== error_mark_node
)
1985 return error_mark_node
;
1987 /* If the object expression was an rvalue, return an rvalue. */
1988 if (kind
& clk_class
)
1989 datum
= rvalue (datum
);
1990 else if (kind
& clk_rvalueref
)
1991 datum
= move (datum
);
1996 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1997 program is ill-formed if the second operand is a pointer to member
1998 function with ref-qualifier & (for C++2A: unless its cv-qualifier-seq
1999 is const). In a .* expression whose object expression is an lvalue,
2000 the program is ill-formed if the second operand is a pointer to member
2001 function with ref-qualifier &&. */
2002 if (FUNCTION_REF_QUALIFIED (type
))
2004 bool lval
= lvalue_p (datum
);
2005 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
2007 if (complain
& tf_error
)
2008 error ("pointer-to-member-function type %qT requires an rvalue",
2010 return error_mark_node
;
2012 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
2014 if ((type_memfn_quals (type
)
2015 & (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
))
2018 if (complain
& tf_error
)
2019 error ("pointer-to-member-function type %qT requires "
2020 "an lvalue", ptrmem_type
);
2021 return error_mark_node
;
2023 else if (cxx_dialect
< cxx2a
)
2025 if (complain
& tf_warning_or_error
)
2026 pedwarn (input_location
, OPT_Wpedantic
,
2027 "pointer-to-member-function type %qT requires "
2028 "an lvalue before C++2a", ptrmem_type
);
2030 return error_mark_node
;
2034 return build2 (OFFSET_REF
, type
, datum
, component
);
2038 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
2041 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
2043 /* This is either a call to a constructor,
2044 or a C cast in C++'s `functional' notation. */
2046 /* The type to which we are casting. */
2048 vec
<tree
, va_gc
> *parmvec
;
2050 if (error_operand_p (exp
) || parms
== error_mark_node
)
2051 return error_mark_node
;
2053 if (TREE_CODE (exp
) == TYPE_DECL
)
2055 type
= TREE_TYPE (exp
);
2057 if (complain
& tf_warning
2058 && TREE_DEPRECATED (type
)
2059 && DECL_ARTIFICIAL (exp
))
2060 warn_deprecated_use (type
, NULL_TREE
);
2065 /* We need to check this explicitly, since value-initialization of
2066 arrays is allowed in other situations. */
2067 if (TREE_CODE (type
) == ARRAY_TYPE
)
2069 if (complain
& tf_error
)
2070 error ("functional cast to array type %qT", type
);
2071 return error_mark_node
;
2074 if (tree anode
= type_uses_auto (type
))
2076 if (!CLASS_PLACEHOLDER_TEMPLATE (anode
))
2078 if (complain
& tf_error
)
2079 error ("invalid use of %qT", anode
);
2080 return error_mark_node
;
2084 if (complain
& tf_error
)
2085 error ("cannot deduce template arguments for %qT from ()", anode
);
2086 return error_mark_node
;
2089 type
= do_auto_deduction (type
, parms
, anode
, complain
,
2093 if (processing_template_decl
)
2097 /* Diagnose this even in a template. We could also try harder
2098 to give all the usual errors when the type and args are
2100 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
2102 if (complain
& tf_error
)
2103 error ("invalid value-initialization of reference type");
2104 return error_mark_node
;
2107 t
= build_min (CAST_EXPR
, type
, parms
);
2108 /* We don't know if it will or will not have side effects. */
2109 TREE_SIDE_EFFECTS (t
) = 1;
2113 if (! MAYBE_CLASS_TYPE_P (type
))
2115 if (parms
== NULL_TREE
)
2117 if (VOID_TYPE_P (type
))
2119 return build_value_init (cv_unqualified (type
), complain
);
2122 /* This must build a C cast. */
2123 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
2124 return cp_build_c_cast (type
, parms
, complain
);
2127 /* Prepare to evaluate as a call to a constructor. If this expression
2128 is actually used, for example,
2130 return X (arg1, arg2, ...);
2132 then the slot being initialized will be filled in. */
2134 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
2135 return error_mark_node
;
2136 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
2137 return error_mark_node
;
2141 If the expression list is a single-expression, the type
2142 conversion is equivalent (in definedness, and if defined in
2143 meaning) to the corresponding cast expression. */
2144 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
2145 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
2149 The expression T(), where T is a simple-type-specifier for a
2150 non-array complete object type or the (possibly cv-qualified)
2151 void type, creates an rvalue of the specified type, which is
2152 value-initialized. */
2154 if (parms
== NULL_TREE
)
2156 exp
= build_value_init (type
, complain
);
2157 exp
= get_target_expr_sfinae (exp
, complain
);
2161 /* Call the constructor. */
2162 parmvec
= make_tree_vector ();
2163 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
2164 vec_safe_push (parmvec
, TREE_VALUE (parms
));
2165 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
2166 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
2167 release_tree_vector (parmvec
);
2169 if (exp
== error_mark_node
)
2170 return error_mark_node
;
2172 return build_cplus_new (type
, exp
, complain
);
2176 /* Add new exception specifier SPEC, to the LIST we currently have.
2177 If it's already in LIST then do nothing.
2178 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
2179 know what we're doing. */
2182 add_exception_specifier (tree list
, tree spec
, int complain
)
2187 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
2189 if (spec
== error_mark_node
)
2192 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
2194 /* [except.spec] 1, type in an exception specifier shall not be
2195 incomplete, or pointer or ref to incomplete other than pointer
2197 is_ptr
= TYPE_PTR_P (core
);
2198 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
2199 core
= TREE_TYPE (core
);
2202 else if (VOID_TYPE_P (core
))
2204 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
2206 else if (processing_template_decl
)
2211 /* 15.4/1 says that types in an exception specifier must be complete,
2212 but it seems more reasonable to only require this on definitions
2213 and calls. So just give a pedwarn at this point; we will give an
2214 error later if we hit one of those two cases. */
2215 if (!COMPLETE_TYPE_P (complete_type (core
)))
2216 diag_type
= DK_PEDWARN
; /* pedwarn */
2223 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
2224 if (same_type_p (TREE_VALUE (probe
), spec
))
2227 list
= tree_cons (NULL_TREE
, spec
, list
);
2230 diag_type
= DK_ERROR
; /* error */
2232 if (diag_type
!= DK_UNSPECIFIED
2233 && (complain
& tf_warning_or_error
))
2234 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
2239 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
2242 nothrow_spec_p_uninst (const_tree spec
)
2244 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
2246 return nothrow_spec_p (spec
);
2249 /* Combine the two exceptions specifier lists LIST and ADD, and return
2253 merge_exception_specifiers (tree list
, tree add
)
2255 tree noex
, orig_list
;
2257 /* No exception-specifier or noexcept(false) are less strict than
2258 anything else. Prefer the newer variant (LIST). */
2259 if (!list
|| list
== noexcept_false_spec
)
2261 else if (!add
|| add
== noexcept_false_spec
)
2264 /* noexcept(true) and throw() are stricter than anything else.
2265 As above, prefer the more recent one (LIST). */
2266 if (nothrow_spec_p_uninst (add
))
2269 /* Two implicit noexcept specs (e.g. on a destructor) are equivalent. */
2270 if (UNEVALUATED_NOEXCEPT_SPEC_P (add
)
2271 && UNEVALUATED_NOEXCEPT_SPEC_P (list
))
2273 /* We should have instantiated other deferred noexcept specs by now. */
2274 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add
));
2276 if (nothrow_spec_p_uninst (list
))
2278 noex
= TREE_PURPOSE (list
);
2279 gcc_checking_assert (!TREE_PURPOSE (add
)
2280 || errorcount
|| !flag_exceptions
2281 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2283 /* Combine the dynamic-exception-specifiers, if any. */
2285 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2287 tree spec
= TREE_VALUE (add
);
2290 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2291 probe
= TREE_CHAIN (probe
))
2292 if (same_type_p (TREE_VALUE (probe
), spec
))
2296 spec
= build_tree_list (NULL_TREE
, spec
);
2297 TREE_CHAIN (spec
) = list
;
2302 /* Keep the noexcept-specifier at the beginning of the list. */
2303 if (noex
!= TREE_PURPOSE (list
))
2304 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2309 /* Subroutine of build_call. Ensure that each of the types in the
2310 exception specification is complete. Technically, 15.4/1 says that
2311 they need to be complete when we see a declaration of the function,
2312 but we should be able to get away with only requiring this when the
2313 function is defined or called. See also add_exception_specifier. */
2316 require_complete_eh_spec_types (tree fntype
, tree decl
)
2319 /* Don't complain about calls to op new. */
2320 if (decl
&& DECL_ARTIFICIAL (decl
))
2322 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2323 raises
= TREE_CHAIN (raises
))
2325 tree type
= TREE_VALUE (raises
);
2326 if (type
&& !COMPLETE_TYPE_P (type
))
2330 ("call to function %qD which throws incomplete type %q#T",
2333 error ("call to function which throws incomplete type %q#T",
2340 #include "gt-cp-typeck2.h"