1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987-2014 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"
33 #include "stor-layout.h"
38 #include "diagnostic-core.h"
42 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
);
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
49 error_not_base_type (tree basetype
, tree type
)
51 if (TREE_CODE (basetype
) == FUNCTION_DECL
)
52 basetype
= DECL_CONTEXT (basetype
);
53 error ("type %qT is not a base type for type %qT", basetype
, type
);
54 return error_mark_node
;
58 binfo_or_else (tree base
, tree type
)
60 tree binfo
= lookup_base (type
, base
, ba_unique
,
61 NULL
, tf_warning_or_error
);
63 if (binfo
== error_mark_node
)
66 error_not_base_type (base
, type
);
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. */
74 cxx_readonly_error (tree arg
, enum lvalue_use errstring
)
77 /* This macro is used to emit diagnostics to ensure that all format
78 strings are complete sentences, visible to gettext and checked at
81 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
102 /* Handle C++-specific things first. */
105 && DECL_LANG_SPECIFIC (arg
)
106 && DECL_IN_AGGR_P (arg
)
107 && !TREE_STATIC (arg
))
108 ERROR_FOR_ASSIGNMENT (G_("assignment of "
109 "constant field %qD"),
110 G_("constant field %qD "
111 "used as %<asm%> output"),
113 "constant field %qD"),
115 "constant field %qD"),
117 else if (INDIRECT_REF_P (arg
)
118 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REFERENCE_TYPE
119 && (VAR_P (TREE_OPERAND (arg
, 0))
120 || TREE_CODE (TREE_OPERAND (arg
, 0)) == PARM_DECL
))
121 ERROR_FOR_ASSIGNMENT (G_("assignment of "
122 "read-only reference %qD"),
123 G_("read-only reference %qD "
124 "used as %<asm%> output"),
126 "read-only reference %qD"),
128 "read-only reference %qD"),
129 TREE_OPERAND (arg
, 0));
131 readonly_error (input_location
, arg
, errstring
);
135 /* Structure that holds information about declarations whose type was
136 incomplete and we could not check whether it was abstract or not. */
138 struct GTY((chain_next ("%h.next"))) pending_abstract_type
{
139 /* Declaration which we are checking for abstractness. It is either
140 a DECL node, or an IDENTIFIER_NODE if we do not have a full
141 declaration available. */
144 /* Type which will be checked for abstractness. */
147 /* Kind of use in an unnamed declarator. */
148 abstract_class_use use
;
150 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
151 because DECLs already carry locus information. */
154 /* Link to the next element in list. */
155 struct pending_abstract_type
* next
;
159 /* Compute the hash value of the node VAL. This function is used by the
160 hash table abstract_pending_vars. */
163 pat_calc_hash (const void* val
)
165 const struct pending_abstract_type
*pat
=
166 (const struct pending_abstract_type
*) val
;
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 pat_compare (const void* val1
, const void* val2
)
177 const struct pending_abstract_type
*const pat1
=
178 (const struct pending_abstract_type
*) val1
;
179 const_tree
const type2
= (const_tree
)val2
;
181 return (pat1
->type
== type2
);
184 /* Hash table that maintains pending_abstract_type nodes, for which we still
185 need to check for type abstractness. The key of the table is the type
186 of the declaration. */
187 static GTY ((param_is (struct pending_abstract_type
)))
188 htab_t abstract_pending_vars
= NULL
;
190 static int abstract_virtuals_error_sfinae (tree
, tree
, abstract_class_use
, tsubst_flags_t
);
192 /* This function is called after TYPE is completed, and will check if there
193 are pending declarations for which we still need to verify the abstractness
194 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
195 turned out to be incomplete. */
198 complete_type_check_abstract (tree type
)
201 struct pending_abstract_type
*pat
;
202 location_t cur_loc
= input_location
;
204 gcc_assert (COMPLETE_TYPE_P (type
));
206 if (!abstract_pending_vars
)
209 /* Retrieve the list of pending declarations for this type. */
210 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
211 (hashval_t
)TYPE_UID (type
), NO_INSERT
);
214 pat
= (struct pending_abstract_type
*)*slot
;
217 /* If the type is not abstract, do not do anything. */
218 if (CLASSTYPE_PURE_VIRTUALS (type
))
220 struct pending_abstract_type
*prev
= 0, *next
;
222 /* Reverse the list to emit the errors in top-down order. */
223 for (; pat
; pat
= next
)
231 /* Go through the list, and call abstract_virtuals_error for each
232 element: it will issue a diagnostic if the type is abstract. */
235 gcc_assert (type
== pat
->type
);
237 /* Tweak input_location so that the diagnostic appears at the correct
238 location. Notice that this is only needed if the decl is an
240 input_location
= pat
->locus
;
241 abstract_virtuals_error_sfinae (pat
->decl
, pat
->type
, pat
->use
,
242 tf_warning_or_error
);
247 htab_clear_slot (abstract_pending_vars
, slot
);
249 input_location
= cur_loc
;
253 /* If TYPE has abstract virtual functions, issue an error about trying
254 to create an object of that type. DECL is the object declared, or
255 NULL_TREE if the declaration is unavailable, in which case USE specifies
256 the kind of invalid use. Returns 1 if an error occurred; zero if
260 abstract_virtuals_error_sfinae (tree decl
, tree type
, abstract_class_use use
,
261 tsubst_flags_t complain
)
263 vec
<tree
, va_gc
> *pure
;
265 /* This function applies only to classes. Any other entity can never
267 if (!CLASS_TYPE_P (type
))
269 type
= TYPE_MAIN_VARIANT (type
);
272 /* Instantiation here seems to be required by the standard,
273 but breaks e.g. boost::bind. FIXME! */
274 /* In SFINAE, non-N3276 context, force instantiation. */
275 if (!(complain
& (tf_error
|tf_decltype
)))
276 complete_type (type
);
279 /* If the type is incomplete, we register it within a hash table,
280 so that we can check again once it is completed. This makes sense
281 only for objects for which we have a declaration or at least a
283 if (!COMPLETE_TYPE_P (type
) && (complain
& tf_error
))
286 struct pending_abstract_type
*pat
;
288 gcc_assert (!decl
|| DECL_P (decl
) || identifier_p (decl
));
290 if (!abstract_pending_vars
)
291 abstract_pending_vars
= htab_create_ggc (31, &pat_calc_hash
,
294 slot
= htab_find_slot_with_hash (abstract_pending_vars
, type
,
295 (hashval_t
)TYPE_UID (type
), INSERT
);
297 pat
= ggc_alloc_pending_abstract_type ();
301 pat
->locus
= ((decl
&& DECL_P (decl
))
302 ? DECL_SOURCE_LOCATION (decl
)
305 pat
->next
= (struct pending_abstract_type
*) *slot
;
311 if (!TYPE_SIZE (type
))
312 /* TYPE is being defined, and during that time
313 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
316 pure
= CLASSTYPE_PURE_VIRTUALS (type
);
320 if (!(complain
& tf_error
))
326 error ("cannot declare variable %q+D to be of abstract "
327 "type %qT", decl
, type
);
328 else if (TREE_CODE (decl
) == PARM_DECL
)
330 if (DECL_NAME (decl
))
331 error ("cannot declare parameter %q+D to be of abstract type %qT",
334 error ("cannot declare parameter to be of abstract type %qT",
337 else if (TREE_CODE (decl
) == FIELD_DECL
)
338 error ("cannot declare field %q+D to be of abstract type %qT",
340 else if (TREE_CODE (decl
) == FUNCTION_DECL
341 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
342 error ("invalid abstract return type for member function %q+#D", decl
);
343 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
344 error ("invalid abstract return type for function %q+#D", decl
);
345 else if (identifier_p (decl
))
346 /* Here we do not have location information. */
347 error ("invalid abstract type %qT for %qE", type
, decl
);
349 error ("invalid abstract type for %q+D", decl
);
354 error ("creating array of %qT, which is an abstract class type", type
);
357 error ("invalid cast to abstract class type %qT", type
);
360 error ("invalid new-expression of abstract class type %qT", type
);
363 error ("invalid abstract return type %qT", type
);
366 error ("invalid abstract parameter type %qT", type
);
369 error ("expression of abstract class type %qT cannot "
370 "be used in throw-expression", type
);
373 error ("cannot declare catch parameter to be of abstract "
374 "class type %qT", type
);
377 error ("cannot allocate an object of abstract type %qT", type
);
380 /* Only go through this once. */
386 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
387 " because the following virtual functions are pure within %qT:",
390 FOR_EACH_VEC_ELT (*pure
, ix
, fn
)
391 if (! DECL_CLONED_FUNCTION_P (fn
)
392 || DECL_COMPLETE_DESTRUCTOR_P (fn
))
393 inform (input_location
, "\t%+#D", fn
);
395 /* Now truncate the vector. This leaves it non-null, so we know
396 there are pure virtuals, but empty so we don't list them out
405 abstract_virtuals_error_sfinae (tree decl
, tree type
, tsubst_flags_t complain
)
407 return abstract_virtuals_error_sfinae (decl
, type
, ACU_UNKNOWN
, complain
);
411 abstract_virtuals_error_sfinae (abstract_class_use use
, tree type
,
412 tsubst_flags_t complain
)
414 return abstract_virtuals_error_sfinae (NULL_TREE
, type
, use
, complain
);
418 /* Wrapper for the above function in the common case of wanting errors. */
421 abstract_virtuals_error (tree decl
, tree type
)
423 return abstract_virtuals_error_sfinae (decl
, type
, tf_warning_or_error
);
427 abstract_virtuals_error (abstract_class_use use
, tree type
)
429 return abstract_virtuals_error_sfinae (use
, type
, tf_warning_or_error
);
432 /* Print an error message for invalid use of an incomplete type.
433 VALUE is the expression that was used (or 0 if that isn't known)
434 and TYPE is the type that was invalid. DIAG_KIND indicates the
435 type of diagnostic (see diagnostic.def). */
438 cxx_incomplete_type_diagnostic (const_tree value
, const_tree type
,
439 diagnostic_t diag_kind
)
443 gcc_assert (diag_kind
== DK_WARNING
444 || diag_kind
== DK_PEDWARN
445 || diag_kind
== DK_ERROR
);
447 /* Avoid duplicate error message. */
448 if (TREE_CODE (type
) == ERROR_MARK
)
451 if (value
!= 0 && (VAR_P (value
)
452 || TREE_CODE (value
) == PARM_DECL
453 || TREE_CODE (value
) == FIELD_DECL
))
455 emit_diagnostic (diag_kind
, input_location
, 0,
456 "%q+D has incomplete type", value
);
460 /* We must print an error message. Be clever about what it says. */
462 switch (TREE_CODE (type
))
468 emit_diagnostic (diag_kind
, input_location
, 0,
469 "invalid use of incomplete type %q#T", type
);
470 if (!TYPE_TEMPLATE_INFO (type
))
471 emit_diagnostic (diag_kind
, input_location
, 0,
472 "forward declaration of %q+#T", type
);
474 emit_diagnostic (diag_kind
, input_location
, 0,
475 "declaration of %q+#T", type
);
479 emit_diagnostic (diag_kind
, input_location
, 0,
480 "invalid use of %qT", type
);
484 if (TYPE_DOMAIN (type
))
486 type
= TREE_TYPE (type
);
489 emit_diagnostic (diag_kind
, input_location
, 0,
490 "invalid use of array with unspecified bounds");
496 tree member
= TREE_OPERAND (value
, 1);
497 if (is_overloaded_fn (member
))
498 member
= get_first_fn (member
);
499 if (DECL_FUNCTION_MEMBER_P (member
)
500 && ! flag_ms_extensions
)
501 emit_diagnostic (diag_kind
, input_location
, 0,
502 "invalid use of member function "
503 "(did you forget the %<()%> ?)");
505 emit_diagnostic (diag_kind
, input_location
, 0,
506 "invalid use of member "
507 "(did you forget the %<&%> ?)");
511 case TEMPLATE_TYPE_PARM
:
513 emit_diagnostic (diag_kind
, input_location
, 0,
514 "invalid use of %<auto%>");
516 emit_diagnostic (diag_kind
, input_location
, 0,
517 "invalid use of template type parameter %qT", type
);
520 case BOUND_TEMPLATE_TEMPLATE_PARM
:
521 emit_diagnostic (diag_kind
, input_location
, 0,
522 "invalid use of template template parameter %qT",
527 emit_diagnostic (diag_kind
, input_location
, 0,
528 "invalid use of dependent type %qT", type
);
532 if (type
== init_list_type_node
)
534 emit_diagnostic (diag_kind
, input_location
, 0,
535 "invalid use of brace-enclosed initializer list");
538 gcc_assert (type
== unknown_type_node
);
539 if (value
&& TREE_CODE (value
) == COMPONENT_REF
)
541 else if (value
&& TREE_CODE (value
) == ADDR_EXPR
)
542 emit_diagnostic (diag_kind
, input_location
, 0,
543 "address of overloaded function with no contextual "
545 else if (value
&& TREE_CODE (value
) == OVERLOAD
)
546 emit_diagnostic (diag_kind
, input_location
, 0,
547 "overloaded function with no contextual type information");
549 emit_diagnostic (diag_kind
, input_location
, 0,
550 "insufficient contextual information to determine type");
558 /* Backward-compatibility interface to incomplete_type_diagnostic;
559 required by ../tree.c. */
560 #undef cxx_incomplete_type_error
562 cxx_incomplete_type_error (const_tree value
, const_tree type
)
564 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
568 /* The recursive part of split_nonconstant_init. DEST is an lvalue
569 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
570 Return true if the whole of the value was initialized by the
571 generated statements. */
574 split_nonconstant_init_1 (tree dest
, tree init
)
576 unsigned HOST_WIDE_INT idx
;
577 tree field_index
, value
;
578 tree type
= TREE_TYPE (dest
);
579 tree inner_type
= NULL
;
580 bool array_type_p
= false;
581 bool complete_p
= true;
582 HOST_WIDE_INT num_split_elts
= 0;
584 switch (TREE_CODE (type
))
587 inner_type
= TREE_TYPE (type
);
593 case QUAL_UNION_TYPE
:
594 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init
), idx
,
597 /* The current implementation of this algorithm assumes that
598 the field was set for all the elements. This is usually done
599 by process_init_constructor. */
600 gcc_assert (field_index
);
603 inner_type
= TREE_TYPE (field_index
);
605 if (TREE_CODE (value
) == CONSTRUCTOR
)
610 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
611 NULL_TREE
, NULL_TREE
);
613 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
616 if (!split_nonconstant_init_1 (sub
, value
))
620 else if (!initializer_constant_valid_p (value
, inner_type
))
625 /* FIXME: Ordered removal is O(1) so the whole function is
626 worst-case quadratic. This could be fixed using an aside
627 bitmap to record which elements must be removed and remove
628 them all at the same time. Or by merging
629 split_non_constant_init into process_init_constructor_array,
630 that is separating constants from non-constants while building
632 CONSTRUCTOR_ELTS (init
)->ordered_remove (idx
);
635 if (TREE_CODE (field_index
) == RANGE_EXPR
)
637 /* Use build_vec_init to initialize a range. */
638 tree low
= TREE_OPERAND (field_index
, 0);
639 tree hi
= TREE_OPERAND (field_index
, 1);
640 sub
= build4 (ARRAY_REF
, inner_type
, dest
, low
,
641 NULL_TREE
, NULL_TREE
);
642 sub
= cp_build_addr_expr (sub
, tf_warning_or_error
);
643 tree max
= size_binop (MINUS_EXPR
, hi
, low
);
644 code
= build_vec_init (sub
, max
, value
, false, 0,
645 tf_warning_or_error
);
647 if (tree_fits_shwi_p (max
))
648 num_split_elts
+= tree_to_shwi (max
);
653 sub
= build4 (ARRAY_REF
, inner_type
, dest
, field_index
,
654 NULL_TREE
, NULL_TREE
);
656 sub
= build3 (COMPONENT_REF
, inner_type
, dest
, field_index
,
659 code
= build2 (INIT_EXPR
, inner_type
, sub
, value
);
660 code
= build_stmt (input_location
, EXPR_STMT
, code
);
661 code
= maybe_cleanup_point_expr_void (code
);
663 if (type_build_dtor_call (inner_type
))
665 code
= (build_special_member_call
666 (sub
, complete_dtor_identifier
, NULL
, inner_type
,
667 LOOKUP_NORMAL
, tf_warning_or_error
));
668 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type
))
669 finish_eh_cleanup (code
);
679 if (!initializer_constant_valid_p (init
, type
))
682 tree cons
= copy_node (init
);
683 CONSTRUCTOR_ELTS (init
) = NULL
;
684 code
= build2 (MODIFY_EXPR
, type
, dest
, cons
);
685 code
= build_stmt (input_location
, EXPR_STMT
, code
);
687 num_split_elts
+= CONSTRUCTOR_NELTS (init
);
695 /* The rest of the initializer is now a constant. */
696 TREE_CONSTANT (init
) = 1;
697 return complete_p
&& complete_ctor_at_level_p (TREE_TYPE (init
),
698 num_split_elts
, inner_type
);
701 /* A subroutine of store_init_value. Splits non-constant static
702 initializer INIT into a constant part and generates code to
703 perform the non-constant part of the initialization to DEST.
704 Returns the code for the runtime init. */
707 split_nonconstant_init (tree dest
, tree init
)
711 if (TREE_CODE (init
) == CONSTRUCTOR
)
713 code
= push_stmt_list ();
714 if (split_nonconstant_init_1 (dest
, init
))
716 code
= pop_stmt_list (code
);
717 DECL_INITIAL (dest
) = init
;
718 TREE_READONLY (dest
) = 0;
721 code
= build2 (INIT_EXPR
, TREE_TYPE (dest
), dest
, init
);
726 /* Perform appropriate conversions on the initial value of a variable,
727 store it in the declaration DECL,
728 and print any error messages that are appropriate.
729 If the init is invalid, store an ERROR_MARK.
731 C++: Note that INIT might be a TREE_LIST, which would mean that it is
732 a base class initializer for some aggregate type, hopefully compatible
733 with DECL. If INIT is a single element, and DECL is an aggregate
734 type, we silently convert INIT into a TREE_LIST, allowing a constructor
737 If INIT is a TREE_LIST and there is no constructor, turn INIT
738 into a CONSTRUCTOR and use standard initialization techniques.
739 Perhaps a warning should be generated?
741 Returns code to be executed if initialization could not be performed
742 for static variable. In that case, caller must emit the code. */
745 store_init_value (tree decl
, tree init
, vec
<tree
, va_gc
>** cleanups
, int flags
)
749 /* If variable's type was invalidly declared, just ignore it. */
751 type
= TREE_TYPE (decl
);
752 if (TREE_CODE (type
) == ERROR_MARK
)
755 if (MAYBE_CLASS_TYPE_P (type
))
757 if (TREE_CODE (init
) == TREE_LIST
)
759 error ("constructor syntax used, but no constructor declared "
760 "for type %qT", type
);
761 init
= build_constructor_from_list (init_list_type_node
, nreverse (init
));
764 else if (TREE_CODE (init
) == TREE_LIST
765 && TREE_TYPE (init
) != unknown_type_node
)
767 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
769 if (TREE_CODE (init
) == TREE_LIST
770 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
772 error ("cannot initialize arrays using this syntax");
776 /* We get here with code like `int a (2);' */
777 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
778 tf_warning_or_error
);
781 /* End of special C++ code. */
783 if (flags
& LOOKUP_ALREADY_DIGESTED
)
786 /* Digest the specified initializer into an expression. */
787 value
= digest_init_flags (type
, init
, flags
);
789 value
= extend_ref_init_temps (decl
, value
, cleanups
);
791 /* In C++0x constant expression is a semantic, not syntactic, property.
792 In C++98, make sure that what we thought was a constant expression at
793 template definition time is still constant and otherwise perform this
794 as optimization, e.g. to fold SIZEOF_EXPRs in the initializer. */
795 if (decl_maybe_constant_var_p (decl
) || TREE_STATIC (decl
))
798 value
= fold_non_dependent_expr (value
);
799 if (DECL_DECLARED_CONSTEXPR_P (decl
)
800 || DECL_IN_AGGR_P (decl
))
802 /* Diagnose a non-constant initializer for constexpr. */
803 if (processing_template_decl
804 && !require_potential_constant_expression (value
))
805 value
= error_mark_node
;
807 value
= cxx_constant_value (value
);
809 value
= maybe_constant_init (value
);
810 const_init
= (reduced_constant_expression_p (value
)
811 || error_operand_p (value
));
812 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = const_init
;
813 TREE_CONSTANT (decl
) = const_init
&& decl_maybe_constant_var_p (decl
);
816 /* If the initializer is not a constant, fill in DECL_INITIAL with
817 the bits that are constant, and then return an expression that
818 will perform the dynamic initialization. */
819 if (value
!= error_mark_node
820 && (TREE_SIDE_EFFECTS (value
)
821 || array_of_runtime_bound_p (type
)
822 || ! reduced_constant_expression_p (value
)))
824 if (TREE_CODE (type
) == ARRAY_TYPE
825 && (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type
))
826 || array_of_runtime_bound_p (type
)))
827 /* For an array, we only need/want a single cleanup region rather
828 than one per element. */
829 return build_vec_init (decl
, NULL_TREE
, value
, false, 1,
830 tf_warning_or_error
);
832 return split_nonconstant_init (decl
, value
);
834 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
835 is an automatic variable, the middle end will turn this into a
836 dynamic initialization later. */
837 DECL_INITIAL (decl
) = value
;
842 /* Give errors about narrowing conversions within { }. */
845 check_narrowing (tree type
, tree init
)
847 tree ftype
= unlowered_expr_type (init
);
851 if (!warn_narrowing
|| !ARITHMETIC_TYPE_P (type
))
854 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
855 && TREE_CODE (type
) == COMPLEX_TYPE
)
857 tree elttype
= TREE_TYPE (type
);
858 if (CONSTRUCTOR_NELTS (init
) > 0)
859 check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 0)->value
);
860 if (CONSTRUCTOR_NELTS (init
) > 1)
861 check_narrowing (elttype
, CONSTRUCTOR_ELT (init
, 1)->value
);
865 init
= maybe_constant_value (fold_non_dependent_expr_sfinae (init
, tf_none
));
867 if (TREE_CODE (type
) == INTEGER_TYPE
868 && TREE_CODE (ftype
) == REAL_TYPE
)
870 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
871 && CP_INTEGRAL_TYPE_P (type
))
873 if (TREE_CODE (ftype
) == ENUMERAL_TYPE
)
874 /* Check for narrowing based on the values of the enumeration. */
875 ftype
= ENUM_UNDERLYING_TYPE (ftype
);
876 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type
),
877 TYPE_MAX_VALUE (ftype
))
878 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype
),
879 TYPE_MIN_VALUE (type
)))
880 && (TREE_CODE (init
) != INTEGER_CST
881 || !int_fits_type_p (init
, type
)))
884 else if (TREE_CODE (ftype
) == REAL_TYPE
885 && TREE_CODE (type
) == REAL_TYPE
)
887 if (TYPE_PRECISION (type
) < TYPE_PRECISION (ftype
))
889 if (TREE_CODE (init
) == REAL_CST
)
891 /* Issue 703: Loss of precision is OK as long as the value is
892 within the representable range of the new type. */
894 d
= TREE_REAL_CST (init
);
895 real_convert (&r
, TYPE_MODE (type
), &d
);
903 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype
)
904 && TREE_CODE (type
) == REAL_TYPE
)
907 if (TREE_CODE (init
) == INTEGER_CST
)
909 d
= real_value_from_int_cst (0, init
);
910 if (exact_real_truncate (TYPE_MODE (type
), &d
))
917 if (cxx_dialect
>= cxx11
)
918 pedwarn (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
919 "narrowing conversion of %qE from %qT to %qT inside { }",
922 warning_at (EXPR_LOC_OR_LOC (init
, input_location
), OPT_Wnarrowing
,
923 "narrowing conversion of %qE from %qT to %qT inside { } "
924 "is ill-formed in C++11", init
, ftype
, type
);
928 /* Process the initializer INIT for a variable of type TYPE, emitting
929 diagnostics for invalid initializers and converting the initializer as
932 For aggregate types, it assumes that reshape_init has already run, thus the
933 initializer will have the right shape (brace elision has been undone).
935 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
938 digest_init_r (tree type
, tree init
, bool nested
, int flags
,
939 tsubst_flags_t complain
)
941 enum tree_code code
= TREE_CODE (type
);
943 if (error_operand_p (init
))
944 return error_mark_node
;
948 /* We must strip the outermost array type when completing the type,
949 because the its bounds might be incomplete at the moment. */
950 if (!complete_type_or_maybe_complain (TREE_CODE (type
) == ARRAY_TYPE
951 ? TREE_TYPE (type
) : type
, NULL_TREE
,
953 return error_mark_node
;
955 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
956 (g++.old-deja/g++.law/casts2.C). */
957 if (TREE_CODE (init
) == NON_LVALUE_EXPR
)
958 init
= TREE_OPERAND (init
, 0);
960 /* Initialization of an array of chars from a string constant. The initializer
961 can be optionally enclosed in braces, but reshape_init has already removed
962 them if they were present. */
963 if (code
== ARRAY_TYPE
)
965 tree typ1
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
966 if (char_type_p (typ1
)
968 && TREE_CODE (init
) == STRING_CST
)
970 tree char_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init
)));
972 if (TYPE_PRECISION (typ1
) == BITS_PER_UNIT
)
974 if (char_type
!= char_type_node
)
976 if (complain
& tf_error
)
977 error ("char-array initialized from wide string");
978 return error_mark_node
;
983 if (char_type
== char_type_node
)
985 if (complain
& tf_error
)
986 error ("int-array initialized from non-wide string");
987 return error_mark_node
;
989 else if (char_type
!= typ1
)
991 if (complain
& tf_error
)
992 error ("int-array initialized from incompatible "
994 return error_mark_node
;
998 if (type
!= TREE_TYPE (init
))
1000 init
= copy_node (init
);
1001 TREE_TYPE (init
) = type
;
1003 if (TYPE_DOMAIN (type
) != 0 && TREE_CONSTANT (TYPE_SIZE (type
)))
1005 int size
= TREE_INT_CST_LOW (TYPE_SIZE (type
));
1006 size
= (size
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
1007 /* In C it is ok to subtract 1 from the length of the string
1008 because it's ok to ignore the terminating null char that is
1009 counted in the length of the constant, but in C++ this would
1011 if (size
< TREE_STRING_LENGTH (init
))
1012 permerror (input_location
, "initializer-string for array "
1013 "of chars is too long");
1019 /* Handle scalar types (including conversions) and references. */
1020 if ((TREE_CODE (type
) != COMPLEX_TYPE
1021 || BRACE_ENCLOSED_INITIALIZER_P (init
))
1022 && (SCALAR_TYPE_P (type
) || code
== REFERENCE_TYPE
))
1027 check_narrowing (type
, init
);
1028 init
= convert_for_initialization (0, type
, init
, flags
,
1029 ICR_INIT
, NULL_TREE
, 0,
1033 /* Skip any conversions since we'll be outputting the underlying
1035 while (CONVERT_EXPR_P (*exp
)
1036 || TREE_CODE (*exp
) == NON_LVALUE_EXPR
)
1037 exp
= &TREE_OPERAND (*exp
, 0);
1039 *exp
= cplus_expand_constant (*exp
);
1044 /* Come here only for aggregates: records, arrays, unions, complex numbers
1046 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1047 || TREE_CODE (type
) == VECTOR_TYPE
1048 || TREE_CODE (type
) == RECORD_TYPE
1049 || TREE_CODE (type
) == UNION_TYPE
1050 || TREE_CODE (type
) == COMPLEX_TYPE
);
1052 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
1053 && !TYPE_NON_AGGREGATE_CLASS (type
))
1054 return process_init_constructor (type
, init
, complain
);
1057 if (COMPOUND_LITERAL_P (init
) && TREE_CODE (type
) == ARRAY_TYPE
)
1059 if (complain
& tf_error
)
1060 error ("cannot initialize aggregate of type %qT with "
1061 "a compound literal", type
);
1063 return error_mark_node
;
1066 if (TREE_CODE (type
) == ARRAY_TYPE
1067 && !BRACE_ENCLOSED_INITIALIZER_P (init
))
1069 /* Allow the result of build_array_copy and of
1070 build_value_init_noctor. */
1071 if ((TREE_CODE (init
) == VEC_INIT_EXPR
1072 || TREE_CODE (init
) == CONSTRUCTOR
)
1073 && (same_type_ignoring_top_level_qualifiers_p
1074 (type
, TREE_TYPE (init
))))
1077 if (complain
& tf_error
)
1078 error ("array must be initialized with a brace-enclosed"
1080 return error_mark_node
;
1083 return convert_for_initialization (NULL_TREE
, type
, init
,
1085 ICR_INIT
, NULL_TREE
, 0,
1091 digest_init (tree type
, tree init
, tsubst_flags_t complain
)
1093 return digest_init_r (type
, init
, false, LOOKUP_IMPLICIT
, complain
);
1097 digest_init_flags (tree type
, tree init
, int flags
)
1099 return digest_init_r (type
, init
, false, flags
, tf_warning_or_error
);
1102 /* Set of flags used within process_init_constructor to describe the
1104 #define PICFLAG_ERRONEOUS 1
1105 #define PICFLAG_NOT_ALL_CONSTANT 2
1106 #define PICFLAG_NOT_ALL_SIMPLE 4
1107 #define PICFLAG_SIDE_EFFECTS 8
1109 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1113 picflag_from_initializer (tree init
)
1115 if (init
== error_mark_node
)
1116 return PICFLAG_ERRONEOUS
;
1117 else if (!TREE_CONSTANT (init
))
1119 if (TREE_SIDE_EFFECTS (init
))
1120 return PICFLAG_SIDE_EFFECTS
;
1122 return PICFLAG_NOT_ALL_CONSTANT
;
1124 else if (!initializer_constant_valid_p (init
, TREE_TYPE (init
)))
1125 return PICFLAG_NOT_ALL_SIMPLE
;
1129 /* Adjust INIT for going into a CONSTRUCTOR. */
1132 massage_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
1134 init
= digest_init_r (type
, init
, true, LOOKUP_IMPLICIT
, complain
);
1135 /* Strip a simple TARGET_EXPR when we know this is an initializer. */
1136 if (TREE_CODE (init
) == TARGET_EXPR
1137 && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (init
))))
1138 init
= TARGET_EXPR_INITIAL (init
);
1139 /* When we defer constant folding within a statement, we may want to
1140 defer this folding as well. */
1141 tree t
= fold_non_dependent_expr_sfinae (init
, complain
);
1142 t
= maybe_constant_value (t
);
1143 if (TREE_CONSTANT (t
))
1148 /* Subroutine of process_init_constructor, which will process an initializer
1149 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1150 which describe the initializers. */
1153 process_init_constructor_array (tree type
, tree init
,
1154 tsubst_flags_t complain
)
1156 unsigned HOST_WIDE_INT i
, len
= 0;
1158 bool unbounded
= false;
1159 constructor_elt
*ce
;
1160 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (init
);
1162 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
1163 || TREE_CODE (type
) == VECTOR_TYPE
);
1165 if (TREE_CODE (type
) == ARRAY_TYPE
)
1167 tree domain
= TYPE_DOMAIN (type
);
1168 if (domain
&& TREE_CONSTANT (TYPE_MAX_VALUE (domain
)))
1169 len
= wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain
))
1170 - wi::to_offset (TYPE_MIN_VALUE (domain
)) + 1,
1171 TYPE_PRECISION (TREE_TYPE (domain
)),
1172 TYPE_SIGN (TREE_TYPE (domain
))).to_uhwi ();
1174 unbounded
= true; /* Take as many as there are. */
1177 /* Vectors are like simple fixed-size arrays. */
1178 len
= TYPE_VECTOR_SUBPARTS (type
);
1180 /* There must not be more initializers than needed. */
1181 if (!unbounded
&& vec_safe_length (v
) > len
)
1183 if (complain
& tf_error
)
1184 error ("too many initializers for %qT", type
);
1186 return PICFLAG_ERRONEOUS
;
1189 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
1193 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
);
1194 if (compare_tree_int (ce
->index
, i
) != 0)
1196 ce
->value
= error_mark_node
;
1197 sorry ("non-trivial designated initializers not supported");
1201 ce
->index
= size_int (i
);
1202 gcc_assert (ce
->value
);
1203 ce
->value
= massage_init_elt (TREE_TYPE (type
), ce
->value
, complain
);
1205 if (ce
->value
!= error_mark_node
)
1206 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1207 (TREE_TYPE (type
), TREE_TYPE (ce
->value
)));
1209 flags
|= picflag_from_initializer (ce
->value
);
1212 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1213 we must add initializers ourselves. */
1215 for (; i
< len
; ++i
)
1219 if (type_build_ctor_call (TREE_TYPE (type
)))
1221 /* If this type needs constructors run for default-initialization,
1222 we can't rely on the back end to do it for us, so make the
1223 initialization explicit by list-initializing from {}. */
1224 next
= build_constructor (init_list_type_node
, NULL
);
1225 next
= massage_init_elt (TREE_TYPE (type
), next
, complain
);
1226 if (initializer_zerop (next
))
1227 /* The default zero-initialization is fine for us; don't
1228 add anything to the CONSTRUCTOR. */
1231 else if (!zero_init_p (TREE_TYPE (type
)))
1232 next
= build_zero_init (TREE_TYPE (type
),
1233 /*nelts=*/NULL_TREE
,
1234 /*static_storage_p=*/false);
1236 /* The default zero-initialization is fine for us; don't
1237 add anything to the CONSTRUCTOR. */
1242 flags
|= picflag_from_initializer (next
);
1243 CONSTRUCTOR_APPEND_ELT (v
, size_int (i
), next
);
1247 CONSTRUCTOR_ELTS (init
) = v
;
1251 /* Subroutine of process_init_constructor, which will process an initializer
1252 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1253 the initializers. */
1256 process_init_constructor_record (tree type
, tree init
,
1257 tsubst_flags_t complain
)
1259 vec
<constructor_elt
, va_gc
> *v
= NULL
;
1262 unsigned HOST_WIDE_INT idx
= 0;
1264 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1265 gcc_assert (!CLASSTYPE_VBASECLASSES (type
));
1266 gcc_assert (!TYPE_BINFO (type
)
1267 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)));
1268 gcc_assert (!TYPE_POLYMORPHIC_P (type
));
1270 /* Generally, we will always have an index for each initializer (which is
1271 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1272 reshape_init. So we need to handle both cases. */
1273 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1278 if (!DECL_NAME (field
) && DECL_C_BIT_FIELD (field
))
1281 if (TREE_CODE (field
) != FIELD_DECL
|| DECL_ARTIFICIAL (field
))
1284 /* If this is a bitfield, first convert to the declared type. */
1285 type
= TREE_TYPE (field
);
1286 if (DECL_BIT_FIELD_TYPE (field
))
1287 type
= DECL_BIT_FIELD_TYPE (field
);
1288 if (type
== error_mark_node
)
1289 return PICFLAG_ERRONEOUS
;
1291 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1293 constructor_elt
*ce
= &(*CONSTRUCTOR_ELTS (init
))[idx
];
1296 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1297 latter case can happen in templates where lookup has to be
1299 gcc_assert (TREE_CODE (ce
->index
) == FIELD_DECL
1300 || identifier_p (ce
->index
));
1301 if (ce
->index
!= field
1302 && ce
->index
!= DECL_NAME (field
))
1304 ce
->value
= error_mark_node
;
1305 sorry ("non-trivial designated initializers not supported");
1309 gcc_assert (ce
->value
);
1310 next
= massage_init_elt (type
, ce
->value
, complain
);
1313 else if (type_build_ctor_call (TREE_TYPE (field
)))
1315 /* If this type needs constructors run for
1316 default-initialization, we can't rely on the back end to do it
1317 for us, so build up TARGET_EXPRs. If the type in question is
1318 a class, just build one up; if it's an array, recurse. */
1319 next
= build_constructor (init_list_type_node
, NULL
);
1320 /* Call this direct-initialization pending DR 1518 resolution so
1321 that explicit default ctors don't break valid C++03 code. */
1322 CONSTRUCTOR_IS_DIRECT_INIT (next
) = true;
1323 next
= massage_init_elt (TREE_TYPE (field
), next
, complain
);
1325 /* Warn when some struct elements are implicitly initialized. */
1326 warning (OPT_Wmissing_field_initializers
,
1327 "missing initializer for member %qD", field
);
1331 if (TREE_READONLY (field
))
1333 if (complain
& tf_error
)
1334 error ("uninitialized const member %qD", field
);
1336 return PICFLAG_ERRONEOUS
;
1338 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field
)))
1340 if (complain
& tf_error
)
1341 error ("member %qD with uninitialized const fields", field
);
1343 return PICFLAG_ERRONEOUS
;
1345 else if (TREE_CODE (TREE_TYPE (field
)) == REFERENCE_TYPE
)
1347 if (complain
& tf_error
)
1348 error ("member %qD is uninitialized reference", field
);
1350 return PICFLAG_ERRONEOUS
;
1353 /* Warn when some struct elements are implicitly initialized
1355 warning (OPT_Wmissing_field_initializers
,
1356 "missing initializer for member %qD", field
);
1358 if (!zero_init_p (TREE_TYPE (field
)))
1359 next
= build_zero_init (TREE_TYPE (field
), /*nelts=*/NULL_TREE
,
1360 /*static_storage_p=*/false);
1362 /* The default zero-initialization is fine for us; don't
1363 add anything to the CONSTRUCTOR. */
1367 /* If this is a bitfield, now convert to the lowered type. */
1368 if (type
!= TREE_TYPE (field
))
1369 next
= cp_convert_and_check (TREE_TYPE (field
), next
, complain
);
1370 flags
|= picflag_from_initializer (next
);
1371 CONSTRUCTOR_APPEND_ELT (v
, field
, next
);
1374 if (idx
< vec_safe_length (CONSTRUCTOR_ELTS (init
)))
1376 if (complain
& tf_error
)
1377 error ("too many initializers for %qT", type
);
1379 return PICFLAG_ERRONEOUS
;
1382 CONSTRUCTOR_ELTS (init
) = v
;
1386 /* Subroutine of process_init_constructor, which will process a single
1387 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1388 which describe the initializer. */
1391 process_init_constructor_union (tree type
, tree init
,
1392 tsubst_flags_t complain
)
1394 constructor_elt
*ce
;
1397 /* If the initializer was empty, use default zero initialization. */
1398 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
1401 len
= CONSTRUCTOR_ELTS (init
)->length ();
1404 if (!(complain
& tf_error
))
1405 return PICFLAG_ERRONEOUS
;
1406 error ("too many initializers for %qT", type
);
1407 CONSTRUCTOR_ELTS (init
)->block_remove (1, len
-1);
1410 ce
= &(*CONSTRUCTOR_ELTS (init
))[0];
1412 /* If this element specifies a field, initialize via that field. */
1415 if (TREE_CODE (ce
->index
) == FIELD_DECL
)
1417 else if (identifier_p (ce
->index
))
1419 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1420 tree name
= ce
->index
;
1422 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1423 if (DECL_NAME (field
) == name
)
1427 if (complain
& tf_error
)
1428 error ("no field %qD found in union being initialized",
1430 ce
->value
= error_mark_node
;
1436 gcc_assert (TREE_CODE (ce
->index
) == INTEGER_CST
1437 || TREE_CODE (ce
->index
) == RANGE_EXPR
);
1438 if (complain
& tf_error
)
1439 error ("index value instead of field name in union initializer");
1440 ce
->value
= error_mark_node
;
1445 /* Find the first named field. ANSI decided in September 1990
1446 that only named fields count here. */
1447 tree field
= TYPE_FIELDS (type
);
1448 while (field
&& (!DECL_NAME (field
) || TREE_CODE (field
) != FIELD_DECL
))
1449 field
= TREE_CHAIN (field
);
1450 if (field
== NULL_TREE
)
1452 if (complain
& tf_error
)
1453 error ("too many initializers for %qT", type
);
1454 ce
->value
= error_mark_node
;
1459 if (ce
->value
&& ce
->value
!= error_mark_node
)
1460 ce
->value
= massage_init_elt (TREE_TYPE (ce
->index
), ce
->value
, complain
);
1462 return picflag_from_initializer (ce
->value
);
1465 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1466 constructor is a brace-enclosed initializer, and will be modified in-place.
1468 Each element is converted to the right type through digest_init, and
1469 missing initializers are added following the language rules (zero-padding,
1472 After the execution, the initializer will have TREE_CONSTANT if all elts are
1473 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1474 constants that the assembler and linker can compute them.
1476 The function returns the initializer itself, or error_mark_node in case
1480 process_init_constructor (tree type
, tree init
, tsubst_flags_t complain
)
1484 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
1486 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
1487 flags
= process_init_constructor_array (type
, init
, complain
);
1488 else if (TREE_CODE (type
) == RECORD_TYPE
)
1489 flags
= process_init_constructor_record (type
, init
, complain
);
1490 else if (TREE_CODE (type
) == UNION_TYPE
)
1491 flags
= process_init_constructor_union (type
, init
, complain
);
1495 if (flags
& PICFLAG_ERRONEOUS
)
1496 return error_mark_node
;
1498 TREE_TYPE (init
) = type
;
1499 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
) == NULL_TREE
)
1500 cp_complete_array_type (&TREE_TYPE (init
), init
, /*do_default=*/0);
1501 if (flags
& PICFLAG_SIDE_EFFECTS
)
1503 TREE_CONSTANT (init
) = false;
1504 TREE_SIDE_EFFECTS (init
) = true;
1506 else if (flags
& PICFLAG_NOT_ALL_CONSTANT
)
1507 /* Make sure TREE_CONSTANT isn't set from build_constructor. */
1508 TREE_CONSTANT (init
) = false;
1511 TREE_CONSTANT (init
) = 1;
1512 if (!(flags
& PICFLAG_NOT_ALL_SIMPLE
))
1513 TREE_STATIC (init
) = 1;
1518 /* Given a structure or union value DATUM, construct and return
1519 the structure or union component which results from narrowing
1520 that value to the base specified in BASETYPE. For example, given the
1523 class L { int ii; };
1524 class A : L { ... };
1525 class B : L { ... };
1526 class C : A, B { ... };
1534 x.A::ii refers to the ii member of the L part of
1535 the A part of the C object named by X. In this case,
1536 DATUM would be x, and BASETYPE would be A.
1538 I used to think that this was nonconformant, that the standard specified
1539 that first we look up ii in A, then convert x to an L& and pull out the
1540 ii part. But in fact, it does say that we convert x to an A&; A here
1541 is known as the "naming class". (jason 2000-12-19)
1543 BINFO_P points to a variable initialized either to NULL_TREE or to the
1544 binfo for the specific base subobject we want to convert to. */
1547 build_scoped_ref (tree datum
, tree basetype
, tree
* binfo_p
)
1551 if (datum
== error_mark_node
)
1552 return error_mark_node
;
1556 binfo
= lookup_base (TREE_TYPE (datum
), basetype
, ba_check
,
1557 NULL
, tf_warning_or_error
);
1559 if (!binfo
|| binfo
== error_mark_node
)
1561 *binfo_p
= NULL_TREE
;
1563 error_not_base_type (basetype
, TREE_TYPE (datum
));
1564 return error_mark_node
;
1568 return build_base_path (PLUS_EXPR
, datum
, binfo
, 1,
1569 tf_warning_or_error
);
1572 /* Build a reference to an object specified by the C++ `->' operator.
1573 Usually this just involves dereferencing the object, but if the
1574 `->' operator is overloaded, then such overloads must be
1575 performed until an object which does not have the `->' operator
1576 overloaded is found. An error is reported when circular pointer
1577 delegation is detected. */
1580 build_x_arrow (location_t loc
, tree expr
, tsubst_flags_t complain
)
1582 tree orig_expr
= expr
;
1583 tree type
= TREE_TYPE (expr
);
1584 tree last_rval
= NULL_TREE
;
1585 vec
<tree
, va_gc
> *types_memoized
= NULL
;
1587 if (type
== error_mark_node
)
1588 return error_mark_node
;
1590 if (processing_template_decl
)
1592 if (type_dependent_expression_p (expr
))
1593 return build_min_nt_loc (loc
, ARROW_EXPR
, expr
);
1594 expr
= build_non_dependent_expr (expr
);
1597 if (MAYBE_CLASS_TYPE_P (type
))
1599 struct tinst_level
*actual_inst
= current_instantiation ();
1602 while ((expr
= build_new_op (loc
, COMPONENT_REF
,
1603 LOOKUP_NORMAL
, expr
, NULL_TREE
, NULL_TREE
,
1606 if (expr
== error_mark_node
)
1607 return error_mark_node
;
1609 if (fn
&& DECL_USE_TEMPLATE (fn
))
1610 push_tinst_level (fn
);
1613 if (vec_member (TREE_TYPE (expr
), types_memoized
))
1615 if (complain
& tf_error
)
1616 error ("circular pointer delegation detected");
1617 return error_mark_node
;
1620 vec_safe_push (types_memoized
, TREE_TYPE (expr
));
1624 while (current_instantiation () != actual_inst
)
1627 if (last_rval
== NULL_TREE
)
1629 if (complain
& tf_error
)
1630 error ("base operand of %<->%> has non-pointer type %qT", type
);
1631 return error_mark_node
;
1634 if (TREE_CODE (TREE_TYPE (last_rval
)) == REFERENCE_TYPE
)
1635 last_rval
= convert_from_reference (last_rval
);
1638 last_rval
= decay_conversion (expr
, complain
);
1640 if (TYPE_PTR_P (TREE_TYPE (last_rval
)))
1642 if (processing_template_decl
)
1644 expr
= build_min (ARROW_EXPR
, TREE_TYPE (TREE_TYPE (last_rval
)),
1646 TREE_SIDE_EFFECTS (expr
) = TREE_SIDE_EFFECTS (last_rval
);
1650 return cp_build_indirect_ref (last_rval
, RO_NULL
, complain
);
1653 if (complain
& tf_error
)
1656 error ("result of %<operator->()%> yields non-pointer result");
1658 error ("base operand of %<->%> is not a pointer");
1660 return error_mark_node
;
1663 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1664 already been checked out to be of aggregate type. */
1667 build_m_component_ref (tree datum
, tree component
, tsubst_flags_t complain
)
1675 if (error_operand_p (datum
) || error_operand_p (component
))
1676 return error_mark_node
;
1678 datum
= mark_lvalue_use (datum
);
1679 component
= mark_rvalue_use (component
);
1681 ptrmem_type
= TREE_TYPE (component
);
1682 if (!TYPE_PTRMEM_P (ptrmem_type
))
1684 if (complain
& tf_error
)
1685 error ("%qE cannot be used as a member pointer, since it is of "
1686 "type %qT", component
, ptrmem_type
);
1687 return error_mark_node
;
1690 objtype
= TYPE_MAIN_VARIANT (TREE_TYPE (datum
));
1691 if (! MAYBE_CLASS_TYPE_P (objtype
))
1693 if (complain
& tf_error
)
1694 error ("cannot apply member pointer %qE to %qE, which is of "
1695 "non-class type %qT", component
, datum
, objtype
);
1696 return error_mark_node
;
1699 type
= TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type
);
1700 ctype
= complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type
));
1702 if (!COMPLETE_TYPE_P (ctype
))
1704 if (!same_type_p (ctype
, objtype
))
1710 binfo
= lookup_base (objtype
, ctype
, ba_check
, NULL
, complain
);
1715 if (complain
& tf_error
)
1716 error ("pointer to member type %qT incompatible with object "
1717 "type %qT", type
, objtype
);
1718 return error_mark_node
;
1720 else if (binfo
== error_mark_node
)
1721 return error_mark_node
;
1724 if (TYPE_PTRDATAMEM_P (ptrmem_type
))
1726 cp_lvalue_kind kind
= lvalue_kind (datum
);
1729 /* Compute the type of the field, as described in [expr.ref].
1730 There's no such thing as a mutable pointer-to-member, so
1731 things are not as complex as they are for references to
1732 non-static data members. */
1733 type
= cp_build_qualified_type (type
,
1734 (cp_type_quals (type
)
1735 | cp_type_quals (TREE_TYPE (datum
))));
1737 datum
= build_address (datum
);
1739 /* Convert object to the correct base. */
1742 datum
= build_base_path (PLUS_EXPR
, datum
, binfo
, 1, complain
);
1743 if (datum
== error_mark_node
)
1744 return error_mark_node
;
1747 /* Build an expression for "object + offset" where offset is the
1748 value stored in the pointer-to-data-member. */
1749 ptype
= build_pointer_type (type
);
1750 datum
= fold_build_pointer_plus (fold_convert (ptype
, datum
), component
);
1751 datum
= cp_build_indirect_ref (datum
, RO_NULL
, complain
);
1752 if (datum
== error_mark_node
)
1753 return error_mark_node
;
1755 /* If the object expression was an rvalue, return an rvalue. */
1756 if (kind
& clk_class
)
1757 datum
= rvalue (datum
);
1758 else if (kind
& clk_rvalueref
)
1759 datum
= move (datum
);
1764 /* 5.5/6: In a .* expression whose object expression is an rvalue, the
1765 program is ill-formed if the second operand is a pointer to member
1766 function with ref-qualifier &. In a .* expression whose object
1767 expression is an lvalue, the program is ill-formed if the second
1768 operand is a pointer to member function with ref-qualifier &&. */
1769 if (FUNCTION_REF_QUALIFIED (type
))
1771 bool lval
= real_lvalue_p (datum
);
1772 if (lval
&& FUNCTION_RVALUE_QUALIFIED (type
))
1774 if (complain
& tf_error
)
1775 error ("pointer-to-member-function type %qT requires an rvalue",
1777 return error_mark_node
;
1779 else if (!lval
&& !FUNCTION_RVALUE_QUALIFIED (type
))
1781 if (complain
& tf_error
)
1782 error ("pointer-to-member-function type %qT requires an lvalue",
1784 return error_mark_node
;
1787 return build2 (OFFSET_REF
, type
, datum
, component
);
1791 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1794 build_functional_cast (tree exp
, tree parms
, tsubst_flags_t complain
)
1796 /* This is either a call to a constructor,
1797 or a C cast in C++'s `functional' notation. */
1799 /* The type to which we are casting. */
1801 vec
<tree
, va_gc
> *parmvec
;
1803 if (error_operand_p (exp
) || parms
== error_mark_node
)
1804 return error_mark_node
;
1806 if (TREE_CODE (exp
) == TYPE_DECL
)
1808 type
= TREE_TYPE (exp
);
1810 if (complain
& tf_warning
1811 && TREE_DEPRECATED (type
)
1812 && DECL_ARTIFICIAL (exp
))
1813 warn_deprecated_use (type
, NULL_TREE
);
1818 /* We need to check this explicitly, since value-initialization of
1819 arrays is allowed in other situations. */
1820 if (TREE_CODE (type
) == ARRAY_TYPE
)
1822 if (complain
& tf_error
)
1823 error ("functional cast to array type %qT", type
);
1824 return error_mark_node
;
1827 if (type_uses_auto (type
))
1829 if (complain
& tf_error
)
1830 error ("invalid use of %<auto%>");
1831 return error_mark_node
;
1834 if (processing_template_decl
)
1838 /* Diagnose this even in a template. We could also try harder
1839 to give all the usual errors when the type and args are
1841 if (TREE_CODE (type
) == REFERENCE_TYPE
&& !parms
)
1843 if (complain
& tf_error
)
1844 error ("invalid value-initialization of reference type");
1845 return error_mark_node
;
1848 t
= build_min (CAST_EXPR
, type
, parms
);
1849 /* We don't know if it will or will not have side effects. */
1850 TREE_SIDE_EFFECTS (t
) = 1;
1854 if (! MAYBE_CLASS_TYPE_P (type
))
1856 if (parms
== NULL_TREE
)
1858 if (VOID_TYPE_P (type
))
1859 return void_zero_node
;
1860 return build_value_init (cv_unqualified (type
), complain
);
1863 /* This must build a C cast. */
1864 parms
= build_x_compound_expr_from_list (parms
, ELK_FUNC_CAST
, complain
);
1865 return cp_build_c_cast (type
, parms
, complain
);
1868 /* Prepare to evaluate as a call to a constructor. If this expression
1869 is actually used, for example,
1871 return X (arg1, arg2, ...);
1873 then the slot being initialized will be filled in. */
1875 if (!complete_type_or_maybe_complain (type
, NULL_TREE
, complain
))
1876 return error_mark_node
;
1877 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
1878 return error_mark_node
;
1882 If the expression list is a single-expression, the type
1883 conversion is equivalent (in definedness, and if defined in
1884 meaning) to the corresponding cast expression. */
1885 if (parms
&& TREE_CHAIN (parms
) == NULL_TREE
)
1886 return cp_build_c_cast (type
, TREE_VALUE (parms
), complain
);
1890 The expression T(), where T is a simple-type-specifier for a
1891 non-array complete object type or the (possibly cv-qualified)
1892 void type, creates an rvalue of the specified type, which is
1893 value-initialized. */
1895 if (parms
== NULL_TREE
)
1897 exp
= build_value_init (type
, complain
);
1898 exp
= get_target_expr_sfinae (exp
, complain
);
1902 /* Call the constructor. */
1903 parmvec
= make_tree_vector ();
1904 for (; parms
!= NULL_TREE
; parms
= TREE_CHAIN (parms
))
1905 vec_safe_push (parmvec
, TREE_VALUE (parms
));
1906 exp
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
1907 &parmvec
, type
, LOOKUP_NORMAL
, complain
);
1908 release_tree_vector (parmvec
);
1910 if (exp
== error_mark_node
)
1911 return error_mark_node
;
1913 return build_cplus_new (type
, exp
, complain
);
1917 /* Add new exception specifier SPEC, to the LIST we currently have.
1918 If it's already in LIST then do nothing.
1919 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1920 know what we're doing. */
1923 add_exception_specifier (tree list
, tree spec
, int complain
)
1928 diagnostic_t diag_type
= DK_UNSPECIFIED
; /* none */
1930 if (spec
== error_mark_node
)
1933 gcc_assert (spec
&& (!list
|| TREE_VALUE (list
)));
1935 /* [except.spec] 1, type in an exception specifier shall not be
1936 incomplete, or pointer or ref to incomplete other than pointer
1938 is_ptr
= TYPE_PTR_P (core
);
1939 if (is_ptr
|| TREE_CODE (core
) == REFERENCE_TYPE
)
1940 core
= TREE_TYPE (core
);
1943 else if (VOID_TYPE_P (core
))
1945 else if (TREE_CODE (core
) == TEMPLATE_TYPE_PARM
)
1947 else if (processing_template_decl
)
1952 /* 15.4/1 says that types in an exception specifier must be complete,
1953 but it seems more reasonable to only require this on definitions
1954 and calls. So just give a pedwarn at this point; we will give an
1955 error later if we hit one of those two cases. */
1956 if (!COMPLETE_TYPE_P (complete_type (core
)))
1957 diag_type
= DK_PEDWARN
; /* pedwarn */
1964 for (probe
= list
; probe
; probe
= TREE_CHAIN (probe
))
1965 if (same_type_p (TREE_VALUE (probe
), spec
))
1968 list
= tree_cons (NULL_TREE
, spec
, list
);
1971 diag_type
= DK_ERROR
; /* error */
1973 if (diag_type
!= DK_UNSPECIFIED
1974 && (complain
& tf_warning_or_error
))
1975 cxx_incomplete_type_diagnostic (NULL_TREE
, core
, diag_type
);
1980 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
1983 nothrow_spec_p_uninst (const_tree spec
)
1985 if (DEFERRED_NOEXCEPT_SPEC_P (spec
))
1987 return nothrow_spec_p (spec
);
1990 /* Combine the two exceptions specifier lists LIST and ADD, and return
1991 their union. If FN is non-null, it's the source of ADD. */
1994 merge_exception_specifiers (tree list
, tree add
, tree fn
)
1996 tree noex
, orig_list
;
1998 /* No exception-specifier or noexcept(false) are less strict than
1999 anything else. Prefer the newer variant (LIST). */
2000 if (!list
|| list
== noexcept_false_spec
)
2002 else if (!add
|| add
== noexcept_false_spec
)
2005 /* noexcept(true) and throw() are stricter than anything else.
2006 As above, prefer the more recent one (LIST). */
2007 if (nothrow_spec_p_uninst (add
))
2010 noex
= TREE_PURPOSE (list
);
2011 if (DEFERRED_NOEXCEPT_SPEC_P (add
))
2013 /* If ADD is a deferred noexcept, we must have been called from
2014 process_subob_fn. For implicitly declared functions, we build up
2015 a list of functions to consider at instantiation time. */
2016 if (noex
&& operand_equal_p (noex
, boolean_true_node
, 0))
2018 gcc_assert (fn
&& (!noex
|| is_overloaded_fn (noex
)));
2019 noex
= build_overload (fn
, noex
);
2021 else if (nothrow_spec_p_uninst (list
))
2024 gcc_checking_assert (!TREE_PURPOSE (add
)
2025 || cp_tree_equal (noex
, TREE_PURPOSE (add
)));
2027 /* Combine the dynamic-exception-specifiers, if any. */
2029 for (; add
&& TREE_VALUE (add
); add
= TREE_CHAIN (add
))
2031 tree spec
= TREE_VALUE (add
);
2034 for (probe
= orig_list
; probe
&& TREE_VALUE (probe
);
2035 probe
= TREE_CHAIN (probe
))
2036 if (same_type_p (TREE_VALUE (probe
), spec
))
2040 spec
= build_tree_list (NULL_TREE
, spec
);
2041 TREE_CHAIN (spec
) = list
;
2046 /* Keep the noexcept-specifier at the beginning of the list. */
2047 if (noex
!= TREE_PURPOSE (list
))
2048 list
= tree_cons (noex
, TREE_VALUE (list
), TREE_CHAIN (list
));
2053 /* Subroutine of build_call. Ensure that each of the types in the
2054 exception specification is complete. Technically, 15.4/1 says that
2055 they need to be complete when we see a declaration of the function,
2056 but we should be able to get away with only requiring this when the
2057 function is defined or called. See also add_exception_specifier. */
2060 require_complete_eh_spec_types (tree fntype
, tree decl
)
2063 /* Don't complain about calls to op new. */
2064 if (decl
&& DECL_ARTIFICIAL (decl
))
2066 for (raises
= TYPE_RAISES_EXCEPTIONS (fntype
); raises
;
2067 raises
= TREE_CHAIN (raises
))
2069 tree type
= TREE_VALUE (raises
);
2070 if (type
&& !COMPLETE_TYPE_P (type
))
2074 ("call to function %qD which throws incomplete type %q#T",
2077 error ("call to function which throws incomplete type %q#T",
2084 #include "gt-cp-typeck2.h"