1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987-2022 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file is part of the C++ front end.
23 It contains routines to build C++ expressions given their operands,
24 including computing the types of the result, C and C++ specific error
25 checks, and some optimization. */
29 #include "coretypes.h"
32 #include "stor-layout.h"
36 #include "c-family/c-objc.h"
37 #include "c-family/c-ubsan.h"
38 #include "gcc-rich-location.h"
39 #include "stringpool.h"
44 static tree
cp_build_addr_expr_strict (tree
, tsubst_flags_t
);
45 static tree
cp_build_function_call (tree
, tree
, tsubst_flags_t
);
46 static tree
pfn_from_ptrmemfunc (tree
);
47 static tree
delta_from_ptrmemfunc (tree
);
48 static tree
convert_for_assignment (tree
, tree
, impl_conv_rhs
, tree
, int,
50 static tree
cp_pointer_int_sum (location_t
, enum tree_code
, tree
, tree
,
52 static tree
rationalize_conditional_expr (enum tree_code
, tree
,
54 static bool comp_ptr_ttypes_real (tree
, tree
, int);
55 static bool comp_except_types (tree
, tree
, bool);
56 static bool comp_array_types (const_tree
, const_tree
, compare_bounds_t
, bool);
57 static tree
pointer_diff (location_t
, tree
, tree
, tree
, tsubst_flags_t
, tree
*);
58 static tree
get_delta_difference (tree
, tree
, bool, bool, tsubst_flags_t
);
59 static void casts_away_constness_r (tree
*, tree
*, tsubst_flags_t
);
60 static bool casts_away_constness (tree
, tree
, tsubst_flags_t
);
61 static bool maybe_warn_about_returning_address_of_local (tree
, location_t
= UNKNOWN_LOCATION
);
62 static void error_args_num (location_t
, tree
, bool);
63 static int convert_arguments (tree
, vec
<tree
, va_gc
> **, tree
, int,
65 static bool is_std_move_p (tree
);
66 static bool is_std_forward_p (tree
);
68 /* Do `exp = require_complete_type (exp);' to make sure exp
69 does not have an incomplete type. (That includes void types.)
70 Returns error_mark_node if the VALUE does not have
71 complete type when this function returns. */
74 require_complete_type_sfinae (tree value
, tsubst_flags_t complain
)
78 if (processing_template_decl
|| value
== error_mark_node
)
81 if (TREE_CODE (value
) == OVERLOAD
)
82 type
= unknown_type_node
;
84 type
= TREE_TYPE (value
);
86 if (type
== error_mark_node
)
87 return error_mark_node
;
89 /* First, detect a valid value with a complete type. */
90 if (COMPLETE_TYPE_P (type
))
93 if (complete_type_or_maybe_complain (type
, value
, complain
))
96 return error_mark_node
;
100 require_complete_type (tree value
)
102 return require_complete_type_sfinae (value
, tf_warning_or_error
);
105 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
106 a template instantiation, do the instantiation. Returns TYPE,
107 whether or not it could be completed, unless something goes
108 horribly wrong, in which case the error_mark_node is returned. */
111 complete_type (tree type
)
113 if (type
== NULL_TREE
)
114 /* Rather than crash, we return something sure to cause an error
116 return error_mark_node
;
118 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
120 else if (TREE_CODE (type
) == ARRAY_TYPE
)
122 tree t
= complete_type (TREE_TYPE (type
));
123 unsigned int needs_constructing
, has_nontrivial_dtor
;
124 if (COMPLETE_TYPE_P (t
) && !dependent_type_p (type
))
127 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
129 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
130 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
132 TYPE_NEEDS_CONSTRUCTING (t
) = needs_constructing
;
133 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = has_nontrivial_dtor
;
136 else if (CLASS_TYPE_P (type
))
139 /* TYPE could be a class member we've not loaded the definition of. */
140 lazy_load_pendings (TYPE_NAME (TYPE_MAIN_VARIANT (type
)));
142 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
143 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
149 /* Like complete_type, but issue an error if the TYPE cannot be completed.
150 VALUE is used for informative diagnostics.
151 Returns NULL_TREE if the type cannot be made complete. */
154 complete_type_or_maybe_complain (tree type
, tree value
, tsubst_flags_t complain
)
156 type
= complete_type (type
);
157 if (type
== error_mark_node
)
158 /* We already issued an error. */
160 else if (!COMPLETE_TYPE_P (type
))
162 if (complain
& tf_error
)
163 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
164 note_failed_type_completion_for_satisfaction (type
);
172 complete_type_or_else (tree type
, tree value
)
174 return complete_type_or_maybe_complain (type
, value
, tf_warning_or_error
);
178 /* Return the common type of two parameter lists.
179 We assume that comptypes has already been done and returned 1;
180 if that isn't so, this may crash.
182 As an optimization, free the space we allocate if the parameter
183 lists are already common. */
186 commonparms (tree p1
, tree p2
)
188 tree oldargs
= p1
, newargs
, n
;
192 len
= list_length (p1
);
193 newargs
= tree_last (p1
);
195 if (newargs
== void_list_node
)
204 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
209 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
211 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
213 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
216 else if (! TREE_PURPOSE (p1
))
218 if (TREE_PURPOSE (p2
))
220 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
226 if (simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)) != 1)
228 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
230 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
233 TREE_VALUE (n
) = merge_types (TREE_VALUE (p1
), TREE_VALUE (p2
));
236 TREE_VALUE (n
) = TREE_VALUE (p1
);
244 /* Given a type, perhaps copied for a typedef,
245 find the "original" version of it. */
247 original_type (tree t
)
249 int quals
= cp_type_quals (t
);
250 while (t
!= error_mark_node
251 && TYPE_NAME (t
) != NULL_TREE
)
253 tree x
= TYPE_NAME (t
);
254 if (TREE_CODE (x
) != TYPE_DECL
)
256 x
= DECL_ORIGINAL_TYPE (x
);
261 return cp_build_qualified_type (t
, quals
);
264 /* Merge the attributes of type OTHER_TYPE into the attributes of type TYPE
265 and return a variant of TYPE with the merged attributes. */
268 merge_type_attributes_from (tree type
, tree other_type
)
270 tree attrs
= targetm
.merge_type_attributes (type
, other_type
);
271 attrs
= restrict_type_identity_attributes_to (attrs
, TYPE_ATTRIBUTES (type
));
272 return cp_build_type_attribute_variant (type
, attrs
);
275 /* Return the common type for two arithmetic types T1 and T2 under the
276 usual arithmetic conversions. The default conversions have already
277 been applied, and enumerated types converted to their compatible
281 cp_common_type (tree t1
, tree t2
)
283 enum tree_code code1
= TREE_CODE (t1
);
284 enum tree_code code2
= TREE_CODE (t2
);
289 /* In what follows, we slightly generalize the rules given in [expr] so
290 as to deal with `long long' and `complex'. First, merge the
292 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
294 if (SCOPED_ENUM_P (t1
) || SCOPED_ENUM_P (t2
))
296 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
297 return build_type_attribute_variant (t1
, attributes
);
302 /* FIXME: Attributes. */
303 gcc_assert (ARITHMETIC_TYPE_P (t1
)
304 || VECTOR_TYPE_P (t1
)
305 || UNSCOPED_ENUM_P (t1
));
306 gcc_assert (ARITHMETIC_TYPE_P (t2
)
307 || VECTOR_TYPE_P (t2
)
308 || UNSCOPED_ENUM_P (t2
));
310 /* If one type is complex, form the common type of the non-complex
311 components, then make that complex. Use T1 or T2 if it is the
313 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
315 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
316 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
318 = type_after_usual_arithmetic_conversions (subtype1
, subtype2
);
320 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
321 return build_type_attribute_variant (t1
, attributes
);
322 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
323 return build_type_attribute_variant (t2
, attributes
);
325 return build_type_attribute_variant (build_complex_type (subtype
),
329 if (code1
== VECTOR_TYPE
)
331 /* When we get here we should have two vectors of the same size.
332 Just prefer the unsigned one if present. */
333 if (TYPE_UNSIGNED (t1
))
334 return merge_type_attributes_from (t1
, t2
);
336 return merge_type_attributes_from (t2
, t1
);
339 /* If only one is real, use it as the result. */
340 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
341 return build_type_attribute_variant (t1
, attributes
);
342 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
343 return build_type_attribute_variant (t2
, attributes
);
345 /* Both real or both integers; use the one with greater precision. */
346 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
347 return build_type_attribute_variant (t1
, attributes
);
348 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
349 return build_type_attribute_variant (t2
, attributes
);
351 /* The types are the same; no need to do anything fancy. */
352 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
353 return build_type_attribute_variant (t1
, attributes
);
355 if (code1
!= REAL_TYPE
)
357 /* If one is unsigned long long, then convert the other to unsigned
359 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
360 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
361 return build_type_attribute_variant (long_long_unsigned_type_node
,
363 /* If one is a long long, and the other is an unsigned long, and
364 long long can represent all the values of an unsigned long, then
365 convert to a long long. Otherwise, convert to an unsigned long
366 long. Otherwise, if either operand is long long, convert the
369 Since we're here, we know the TYPE_PRECISION is the same;
370 therefore converting to long long cannot represent all the values
371 of an unsigned long, so we choose unsigned long long in that
373 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
374 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
376 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
377 ? long_long_unsigned_type_node
378 : long_long_integer_type_node
);
379 return build_type_attribute_variant (t
, attributes
);
382 /* Go through the same procedure, but for longs. */
383 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
384 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
385 return build_type_attribute_variant (long_unsigned_type_node
,
387 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
388 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
390 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
391 ? long_unsigned_type_node
: long_integer_type_node
);
392 return build_type_attribute_variant (t
, attributes
);
395 /* For __intN types, either the type is __int128 (and is lower
396 priority than the types checked above, but higher than other
397 128-bit types) or it's known to not be the same size as other
398 types (enforced in toplev.cc). Prefer the unsigned type. */
399 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
401 if (int_n_enabled_p
[i
]
402 && (same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].signed_type
)
403 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].signed_type
)
404 || same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].unsigned_type
)
405 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].unsigned_type
)))
407 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
408 ? int_n_trees
[i
].unsigned_type
409 : int_n_trees
[i
].signed_type
);
410 return build_type_attribute_variant (t
, attributes
);
414 /* Otherwise prefer the unsigned one. */
415 if (TYPE_UNSIGNED (t1
))
416 return build_type_attribute_variant (t1
, attributes
);
418 return build_type_attribute_variant (t2
, attributes
);
422 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
423 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
424 return build_type_attribute_variant (long_double_type_node
,
426 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
427 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
428 return build_type_attribute_variant (double_type_node
,
430 if (same_type_p (TYPE_MAIN_VARIANT (t1
), float_type_node
)
431 || same_type_p (TYPE_MAIN_VARIANT (t2
), float_type_node
))
432 return build_type_attribute_variant (float_type_node
,
435 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
436 the standard C++ floating-point types. Logic earlier in this
437 function has already eliminated the possibility that
438 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
439 compelling reason to choose one or the other. */
440 return build_type_attribute_variant (t1
, attributes
);
444 /* T1 and T2 are arithmetic or enumeration types. Return the type
445 that will result from the "usual arithmetic conversions" on T1 and
446 T2 as described in [expr]. */
449 type_after_usual_arithmetic_conversions (tree t1
, tree t2
)
451 gcc_assert (ARITHMETIC_TYPE_P (t1
)
452 || VECTOR_TYPE_P (t1
)
453 || UNSCOPED_ENUM_P (t1
));
454 gcc_assert (ARITHMETIC_TYPE_P (t2
)
455 || VECTOR_TYPE_P (t2
)
456 || UNSCOPED_ENUM_P (t2
));
458 /* Perform the integral promotions. We do not promote real types here. */
459 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t1
)
460 && INTEGRAL_OR_ENUMERATION_TYPE_P (t2
))
462 t1
= type_promotes_to (t1
);
463 t2
= type_promotes_to (t2
);
466 return cp_common_type (t1
, t2
);
470 composite_pointer_error (const op_location_t
&location
,
471 diagnostic_t kind
, tree t1
, tree t2
,
472 composite_pointer_operation operation
)
477 emit_diagnostic (kind
, location
, 0,
478 "comparison between "
479 "distinct pointer types %qT and %qT lacks a cast",
483 emit_diagnostic (kind
, location
, 0,
484 "conversion between "
485 "distinct pointer types %qT and %qT lacks a cast",
488 case CPO_CONDITIONAL_EXPR
:
489 emit_diagnostic (kind
, location
, 0,
490 "conditional expression between "
491 "distinct pointer types %qT and %qT lacks a cast",
499 /* Subroutine of composite_pointer_type to implement the recursive
500 case. See that function for documentation of the parameters. And ADD_CONST
501 is used to track adding "const" where needed. */
504 composite_pointer_type_r (const op_location_t
&location
,
505 tree t1
, tree t2
, bool *add_const
,
506 composite_pointer_operation operation
,
507 tsubst_flags_t complain
)
514 /* Determine the types pointed to by T1 and T2. */
517 pointee1
= TREE_TYPE (t1
);
518 pointee2
= TREE_TYPE (t2
);
522 pointee1
= TYPE_PTRMEM_POINTED_TO_TYPE (t1
);
523 pointee2
= TYPE_PTRMEM_POINTED_TO_TYPE (t2
);
528 If T1 and T2 are similar types, the result is the cv-combined type of
530 if (same_type_ignoring_top_level_qualifiers_p (pointee1
, pointee2
))
531 result_type
= pointee1
;
532 else if ((TYPE_PTR_P (pointee1
) && TYPE_PTR_P (pointee2
))
533 || (TYPE_PTRMEM_P (pointee1
) && TYPE_PTRMEM_P (pointee2
)))
535 result_type
= composite_pointer_type_r (location
, pointee1
, pointee2
,
536 add_const
, operation
, complain
);
537 if (result_type
== error_mark_node
)
538 return error_mark_node
;
542 if (complain
& tf_error
)
543 composite_pointer_error (location
, DK_PERMERROR
,
546 return error_mark_node
;
547 result_type
= void_type_node
;
549 const int q1
= cp_type_quals (pointee1
);
550 const int q2
= cp_type_quals (pointee2
);
551 const int quals
= q1
| q2
;
552 result_type
= cp_build_qualified_type (result_type
,
555 : TYPE_UNQUALIFIED
)));
556 /* The cv-combined type can add "const" as per [conv.qual]/3.3 (except for
557 the TLQ). The reason is that both T1 and T2 can then be converted to the
558 cv-combined type of T1 and T2. */
559 if (quals
!= q1
|| quals
!= q2
)
561 /* If the original types were pointers to members, so is the
563 if (TYPE_PTRMEM_P (t1
))
565 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
566 TYPE_PTRMEM_CLASS_TYPE (t2
)))
568 if (complain
& tf_error
)
569 composite_pointer_error (location
, DK_PERMERROR
,
572 return error_mark_node
;
574 result_type
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
578 result_type
= build_pointer_type (result_type
);
580 /* Merge the attributes. */
581 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
582 return build_type_attribute_variant (result_type
, attributes
);
585 /* Return the composite pointer type (see [expr.type]) for T1 and T2.
586 ARG1 and ARG2 are the values with those types. The OPERATION is to
587 describe the operation between the pointer types,
588 in case an error occurs.
590 This routine also implements the computation of a common type for
591 pointers-to-members as per [expr.eq]. */
594 composite_pointer_type (const op_location_t
&location
,
595 tree t1
, tree t2
, tree arg1
, tree arg2
,
596 composite_pointer_operation operation
,
597 tsubst_flags_t complain
)
604 If one operand is a null pointer constant, the composite pointer
605 type is the type of the other operand. */
606 if (null_ptr_cst_p (arg1
))
608 if (null_ptr_cst_p (arg2
))
615 If one of the operands has type "pointer to cv1 void", then
616 the other has type "pointer to cv2 T", and the composite pointer
617 type is "pointer to cv12 void", where cv12 is the union of cv1
620 If either type is a pointer to void, make sure it is T1. */
621 if (TYPE_PTR_P (t2
) && VOID_TYPE_P (TREE_TYPE (t2
)))
624 /* Now, if T1 is a pointer to void, merge the qualifiers. */
625 if (TYPE_PTR_P (t1
) && VOID_TYPE_P (TREE_TYPE (t1
)))
630 if (TYPE_PTRFN_P (t2
))
632 if (complain
& tf_error
)
637 pedwarn (location
, OPT_Wpedantic
,
638 "ISO C++ forbids comparison between pointer "
639 "of type %<void *%> and pointer-to-function");
642 pedwarn (location
, OPT_Wpedantic
,
643 "ISO C++ forbids conversion between pointer "
644 "of type %<void *%> and pointer-to-function");
646 case CPO_CONDITIONAL_EXPR
:
647 pedwarn (location
, OPT_Wpedantic
,
648 "ISO C++ forbids conditional expression between "
649 "pointer of type %<void *%> and "
650 "pointer-to-function");
657 return error_mark_node
;
660 = cp_build_qualified_type (void_type_node
,
661 (cp_type_quals (TREE_TYPE (t1
))
662 | cp_type_quals (TREE_TYPE (t2
))));
663 result_type
= build_pointer_type (result_type
);
664 /* Merge the attributes. */
665 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
666 return build_type_attribute_variant (result_type
, attributes
);
669 if (c_dialect_objc () && TYPE_PTR_P (t1
)
672 if (objc_have_common_type (t1
, t2
, -3, NULL_TREE
))
673 return objc_common_type (t1
, t2
);
676 /* if T1 or T2 is "pointer to noexcept function" and the other type is
677 "pointer to function", where the function types are otherwise the same,
678 "pointer to function" */
679 if (fnptr_conv_p (t1
, t2
))
681 if (fnptr_conv_p (t2
, t1
))
684 /* [expr.eq] permits the application of a pointer conversion to
685 bring the pointers to a common type. */
686 if (TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
)
687 && CLASS_TYPE_P (TREE_TYPE (t1
))
688 && CLASS_TYPE_P (TREE_TYPE (t2
))
689 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1
),
692 class1
= TREE_TYPE (t1
);
693 class2
= TREE_TYPE (t2
);
695 if (DERIVED_FROM_P (class1
, class2
))
696 t2
= (build_pointer_type
697 (cp_build_qualified_type (class1
, cp_type_quals (class2
))));
698 else if (DERIVED_FROM_P (class2
, class1
))
699 t1
= (build_pointer_type
700 (cp_build_qualified_type (class2
, cp_type_quals (class1
))));
703 if (complain
& tf_error
)
704 composite_pointer_error (location
, DK_ERROR
, t1
, t2
, operation
);
705 return error_mark_node
;
708 /* [expr.eq] permits the application of a pointer-to-member
709 conversion to change the class type of one of the types. */
710 else if (TYPE_PTRMEM_P (t1
)
711 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
712 TYPE_PTRMEM_CLASS_TYPE (t2
)))
714 class1
= TYPE_PTRMEM_CLASS_TYPE (t1
);
715 class2
= TYPE_PTRMEM_CLASS_TYPE (t2
);
717 if (DERIVED_FROM_P (class1
, class2
))
718 t1
= build_ptrmem_type (class2
, TYPE_PTRMEM_POINTED_TO_TYPE (t1
));
719 else if (DERIVED_FROM_P (class2
, class1
))
720 t2
= build_ptrmem_type (class1
, TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
723 if (complain
& tf_error
)
727 error_at (location
, "comparison between distinct "
728 "pointer-to-member types %qT and %qT lacks a cast",
732 error_at (location
, "conversion between distinct "
733 "pointer-to-member types %qT and %qT lacks a cast",
736 case CPO_CONDITIONAL_EXPR
:
737 error_at (location
, "conditional expression between distinct "
738 "pointer-to-member types %qT and %qT lacks a cast",
744 return error_mark_node
;
748 bool add_const
= false;
749 return composite_pointer_type_r (location
, t1
, t2
, &add_const
, operation
,
753 /* Return the merged type of two types.
754 We assume that comptypes has already been done and returned 1;
755 if that isn't so, this may crash.
757 This just combines attributes and default arguments; any other
758 differences would cause the two types to compare unalike. */
761 merge_types (tree t1
, tree t2
)
763 enum tree_code code1
;
764 enum tree_code code2
;
767 /* Save time if the two types are the same. */
770 if (original_type (t1
) == original_type (t2
))
773 /* If one type is nonsense, use the other. */
774 if (t1
== error_mark_node
)
776 if (t2
== error_mark_node
)
779 /* Handle merging an auto redeclaration with a previous deduced
784 /* Merge the attributes. */
785 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
787 if (TYPE_PTRMEMFUNC_P (t1
))
788 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
789 if (TYPE_PTRMEMFUNC_P (t2
))
790 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
792 code1
= TREE_CODE (t1
);
793 code2
= TREE_CODE (t2
);
796 gcc_assert (code1
== TYPENAME_TYPE
|| code2
== TYPENAME_TYPE
);
797 if (code1
== TYPENAME_TYPE
)
799 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
800 code1
= TREE_CODE (t1
);
804 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
805 code2
= TREE_CODE (t2
);
813 /* For two pointers, do this recursively on the target type. */
815 tree target
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
816 int quals
= cp_type_quals (t1
);
818 if (code1
== POINTER_TYPE
)
820 t1
= build_pointer_type (target
);
821 if (TREE_CODE (target
) == METHOD_TYPE
)
822 t1
= build_ptrmemfunc_type (t1
);
825 t1
= cp_build_reference_type (target
, TYPE_REF_IS_RVALUE (t1
));
826 t1
= build_type_attribute_variant (t1
, attributes
);
827 t1
= cp_build_qualified_type (t1
, quals
);
836 quals
= cp_type_quals (t1
);
837 pointee
= merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1
),
838 TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
839 t1
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
841 t1
= cp_build_qualified_type (t1
, quals
);
847 tree elt
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
848 /* Save space: see if the result is identical to one of the args. */
849 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
850 return build_type_attribute_variant (t1
, attributes
);
851 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
852 return build_type_attribute_variant (t2
, attributes
);
853 /* Merge the element types, and have a size if either arg has one. */
854 t1
= build_cplus_array_type
855 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
860 /* Function types: prefer the one that specified arg types.
861 If both do, merge the arg types. Also merge the return types. */
863 tree valtype
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
864 tree p1
= TYPE_ARG_TYPES (t1
);
865 tree p2
= TYPE_ARG_TYPES (t2
);
868 /* Save space: see if the result is identical to one of the args. */
869 if (valtype
== TREE_TYPE (t1
) && ! p2
)
870 return cp_build_type_attribute_variant (t1
, attributes
);
871 if (valtype
== TREE_TYPE (t2
) && ! p1
)
872 return cp_build_type_attribute_variant (t2
, attributes
);
874 /* Simple way if one arg fails to specify argument types. */
875 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
877 else if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
880 parms
= commonparms (p1
, p2
);
882 cp_cv_quals quals
= type_memfn_quals (t1
);
883 cp_ref_qualifier rqual
= type_memfn_rqual (t1
);
884 gcc_assert (quals
== type_memfn_quals (t2
));
885 gcc_assert (rqual
== type_memfn_rqual (t2
));
887 tree rval
= build_function_type (valtype
, parms
);
888 rval
= apply_memfn_quals (rval
, quals
);
889 tree raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
890 TYPE_RAISES_EXCEPTIONS (t2
));
891 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
892 t1
= build_cp_fntype_variant (rval
, rqual
, raises
, late_return_type_p
);
898 /* Get this value the long way, since TYPE_METHOD_BASETYPE
899 is just the main variant of this. */
900 tree basetype
= class_of_this_parm (t2
);
901 tree raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
902 TYPE_RAISES_EXCEPTIONS (t2
));
903 cp_ref_qualifier rqual
= type_memfn_rqual (t1
);
905 bool late_return_type_1_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
907 /* If this was a member function type, get back to the
908 original type of type member function (i.e., without
909 the class instance variable up front. */
910 t1
= build_function_type (TREE_TYPE (t1
),
911 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
912 t2
= build_function_type (TREE_TYPE (t2
),
913 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
914 t3
= merge_types (t1
, t2
);
915 t3
= build_method_type_directly (basetype
, TREE_TYPE (t3
),
916 TYPE_ARG_TYPES (t3
));
917 t1
= build_cp_fntype_variant (t3
, rqual
, raises
, late_return_type_1_p
);
922 /* There is no need to merge attributes into a TYPENAME_TYPE.
923 When the type is instantiated it will have whatever
924 attributes result from the instantiation. */
928 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
930 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
935 return cp_build_type_attribute_variant (t1
, attributes
);
938 /* Return the ARRAY_TYPE type without its domain. */
941 strip_array_domain (tree type
)
944 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
945 if (TYPE_DOMAIN (type
) == NULL_TREE
)
947 t2
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
948 return cp_build_type_attribute_variant (t2
, TYPE_ATTRIBUTES (type
));
951 /* Wrapper around cp_common_type that is used by c-common.cc and other
952 front end optimizations that remove promotions.
954 Return the common type for two arithmetic types T1 and T2 under the
955 usual arithmetic conversions. The default conversions have already
956 been applied, and enumerated types converted to their compatible
960 common_type (tree t1
, tree t2
)
962 /* If one type is nonsense, use the other */
963 if (t1
== error_mark_node
)
965 if (t2
== error_mark_node
)
968 return cp_common_type (t1
, t2
);
971 /* Return the common type of two pointer types T1 and T2. This is the
972 type for the result of most arithmetic operations if the operands
973 have the given two types.
975 We assume that comp_target_types has already been done and returned
976 nonzero; if that isn't so, this may crash. */
979 common_pointer_type (tree t1
, tree t2
)
981 gcc_assert ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
982 || (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
983 || (TYPE_PTRMEMFUNC_P (t1
) && TYPE_PTRMEMFUNC_P (t2
)));
985 return composite_pointer_type (input_location
, t1
, t2
,
986 error_mark_node
, error_mark_node
,
987 CPO_CONVERSION
, tf_warning_or_error
);
990 /* Compare two exception specifier types for exactness or subsetness, if
991 allowed. Returns false for mismatch, true for match (same, or
994 [except.spec] "If a class X ... objects of class X or any class publicly
995 and unambiguously derived from X. Similarly, if a pointer type Y * ...
996 exceptions of type Y * or that are pointers to any type publicly and
997 unambiguously derived from Y. Otherwise a function only allows exceptions
998 that have the same type ..."
999 This does not mention cv qualifiers and is different to what throw
1000 [except.throw] and catch [except.catch] will do. They will ignore the
1001 top level cv qualifiers, and allow qualifiers in the pointer to class
1004 We implement the letter of the standard. */
1007 comp_except_types (tree a
, tree b
, bool exact
)
1009 if (same_type_p (a
, b
))
1013 if (cp_type_quals (a
) || cp_type_quals (b
))
1016 if (TYPE_PTR_P (a
) && TYPE_PTR_P (b
))
1020 if (cp_type_quals (a
) || cp_type_quals (b
))
1024 if (TREE_CODE (a
) != RECORD_TYPE
1025 || TREE_CODE (b
) != RECORD_TYPE
)
1028 if (publicly_uniquely_derived_p (a
, b
))
1034 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
1035 If EXACT is ce_derived, T2 can be stricter than T1 (according to 15.4/5).
1036 If EXACT is ce_type, the C++17 type compatibility rules apply.
1037 If EXACT is ce_normal, the compatibility rules in 15.4/3 apply.
1038 If EXACT is ce_exact, the specs must be exactly the same. Exception lists
1039 are unordered, but we've already filtered out duplicates. Most lists will
1040 be in order, we should try to make use of that. */
1043 comp_except_specs (const_tree t1
, const_tree t2
, int exact
)
1052 /* First handle noexcept. */
1053 if (exact
< ce_exact
)
1055 if (exact
== ce_type
1056 && (canonical_eh_spec (CONST_CAST_TREE (t1
))
1057 == canonical_eh_spec (CONST_CAST_TREE (t2
))))
1060 /* noexcept(false) is compatible with no exception-specification,
1061 and less strict than any spec. */
1062 if (t1
== noexcept_false_spec
)
1063 return t2
== NULL_TREE
|| exact
== ce_derived
;
1064 /* Even a derived noexcept(false) is compatible with no
1065 exception-specification. */
1066 if (t2
== noexcept_false_spec
)
1067 return t1
== NULL_TREE
;
1069 /* Otherwise, if we aren't looking for an exact match, noexcept is
1070 equivalent to throw(). */
1071 if (t1
== noexcept_true_spec
)
1072 t1
= empty_except_spec
;
1073 if (t2
== noexcept_true_spec
)
1074 t2
= empty_except_spec
;
1077 /* If any noexcept is left, it is only comparable to itself;
1078 either we're looking for an exact match or we're redeclaring a
1079 template with dependent noexcept. */
1080 if ((t1
&& TREE_PURPOSE (t1
))
1081 || (t2
&& TREE_PURPOSE (t2
)))
1083 && cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)));
1085 if (t1
== NULL_TREE
) /* T1 is ... */
1086 return t2
== NULL_TREE
|| exact
== ce_derived
;
1087 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
1088 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
1089 if (t2
== NULL_TREE
) /* T2 is ... */
1091 if (TREE_VALUE (t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
1092 return exact
== ce_derived
;
1094 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
1095 Count how many we find, to determine exactness. For exact matching and
1096 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
1098 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
1100 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
1102 tree a
= TREE_VALUE (probe
);
1103 tree b
= TREE_VALUE (t2
);
1105 if (comp_except_types (a
, b
, exact
))
1107 if (probe
== base
&& exact
> ce_derived
)
1108 base
= TREE_CHAIN (probe
);
1113 if (probe
== NULL_TREE
)
1116 return exact
== ce_derived
|| base
== NULL_TREE
|| length
== list_length (t1
);
1119 /* Compare the array types T1 and T2. CB says how we should behave when
1120 comparing array bounds: bounds_none doesn't allow dimensionless arrays,
1121 bounds_either says than any array can be [], bounds_first means that
1122 onlt T1 can be an array with unknown bounds. STRICT is true if
1123 qualifiers must match when comparing the types of the array elements. */
1126 comp_array_types (const_tree t1
, const_tree t2
, compare_bounds_t cb
,
1136 /* The type of the array elements must be the same. */
1138 ? !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1139 : !similar_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1142 d1
= TYPE_DOMAIN (t1
);
1143 d2
= TYPE_DOMAIN (t2
);
1148 /* If one of the arrays is dimensionless, and the other has a
1149 dimension, they are of different types. However, it is valid to
1157 declarations for an array object can specify
1158 array types that differ by the presence or absence of a major
1159 array bound (_dcl.array_). */
1161 return cb
>= bounds_either
;
1163 return cb
== bounds_either
;
1165 /* Check that the dimensions are the same. */
1167 if (!cp_tree_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
)))
1169 max1
= TYPE_MAX_VALUE (d1
);
1170 max2
= TYPE_MAX_VALUE (d2
);
1172 if (!cp_tree_equal (max1
, max2
))
1178 /* Compare the relative position of T1 and T2 into their respective
1179 template parameter list.
1180 T1 and T2 must be template parameter types.
1181 Return TRUE if T1 and T2 have the same position, FALSE otherwise. */
1184 comp_template_parms_position (tree t1
, tree t2
)
1186 tree index1
, index2
;
1187 gcc_assert (t1
&& t2
1188 && TREE_CODE (t1
) == TREE_CODE (t2
)
1189 && (TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
1190 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
1191 || TREE_CODE (t1
) == TEMPLATE_TYPE_PARM
));
1193 index1
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t1
));
1194 index2
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t2
));
1196 /* Then compare their relative position. */
1197 if (TEMPLATE_PARM_IDX (index1
) != TEMPLATE_PARM_IDX (index2
)
1198 || TEMPLATE_PARM_LEVEL (index1
) != TEMPLATE_PARM_LEVEL (index2
)
1199 || (TEMPLATE_PARM_PARAMETER_PACK (index1
)
1200 != TEMPLATE_PARM_PARAMETER_PACK (index2
)))
1203 /* In C++14 we can end up comparing 'auto' to a normal template
1204 parameter. Don't confuse them. */
1205 if (cxx_dialect
>= cxx14
&& (is_auto (t1
) || is_auto (t2
)))
1206 return TYPE_IDENTIFIER (t1
) == TYPE_IDENTIFIER (t2
);
1211 /* Heuristic check if two parameter types can be considered ABI-equivalent. */
1214 cxx_safe_arg_type_equiv_p (tree t1
, tree t2
)
1216 t1
= TYPE_MAIN_VARIANT (t1
);
1217 t2
= TYPE_MAIN_VARIANT (t2
);
1223 /* The signedness of the parameter matters only when an integral
1224 type smaller than int is promoted to int, otherwise only the
1225 precision of the parameter matters.
1226 This check should make sure that the callee does not see
1227 undefined values in argument registers. */
1228 if (INTEGRAL_TYPE_P (t1
)
1229 && INTEGRAL_TYPE_P (t2
)
1230 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
)
1231 && (TYPE_UNSIGNED (t1
) == TYPE_UNSIGNED (t2
)
1232 || !targetm
.calls
.promote_prototypes (NULL_TREE
)
1233 || TYPE_PRECISION (t1
) >= TYPE_PRECISION (integer_type_node
)))
1236 return same_type_p (t1
, t2
);
1239 /* Check if a type cast between two function types can be considered safe. */
1242 cxx_safe_function_type_cast_p (tree t1
, tree t2
)
1244 if (TREE_TYPE (t1
) == void_type_node
&&
1245 TYPE_ARG_TYPES (t1
) == void_list_node
)
1248 if (TREE_TYPE (t2
) == void_type_node
&&
1249 TYPE_ARG_TYPES (t2
) == void_list_node
)
1252 if (!cxx_safe_arg_type_equiv_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1255 for (t1
= TYPE_ARG_TYPES (t1
), t2
= TYPE_ARG_TYPES (t2
);
1257 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1258 if (!cxx_safe_arg_type_equiv_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1264 /* Subroutine in comptypes. */
1267 structural_comptypes (tree t1
, tree t2
, int strict
)
1269 /* Both should be types that are not obviously the same. */
1270 gcc_checking_assert (t1
!= t2
&& TYPE_P (t1
) && TYPE_P (t2
));
1272 /* Suppress typename resolution under spec_hasher::equal in place of calling
1273 push_to_top_level there. */
1274 if (!comparing_specializations
)
1276 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1277 current instantiation. */
1278 if (TREE_CODE (t1
) == TYPENAME_TYPE
)
1279 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
1281 if (TREE_CODE (t2
) == TYPENAME_TYPE
)
1282 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
1285 if (TYPE_PTRMEMFUNC_P (t1
))
1286 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
1287 if (TYPE_PTRMEMFUNC_P (t2
))
1288 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
1290 /* Different classes of types can't be compatible. */
1291 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1294 /* Qualifiers must match. For array types, we will check when we
1295 recur on the array element types. */
1296 if (TREE_CODE (t1
) != ARRAY_TYPE
1297 && cp_type_quals (t1
) != cp_type_quals (t2
))
1299 if (TREE_CODE (t1
) == FUNCTION_TYPE
1300 && type_memfn_quals (t1
) != type_memfn_quals (t2
))
1302 /* Need to check this before TYPE_MAIN_VARIANT.
1303 FIXME function qualifiers should really change the main variant. */
1304 if (FUNC_OR_METHOD_TYPE_P (t1
))
1306 if (type_memfn_rqual (t1
) != type_memfn_rqual (t2
))
1308 if (flag_noexcept_type
1309 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (t1
),
1310 TYPE_RAISES_EXCEPTIONS (t2
),
1315 /* Allow for two different type nodes which have essentially the same
1316 definition. Note that we already checked for equality of the type
1317 qualifiers (just above). */
1318 if (TREE_CODE (t1
) != ARRAY_TYPE
1319 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1322 /* Compare the types. Return false on known not-same. Break on not
1323 known. Never return true from this switch -- you'll break
1324 specialization comparison. */
1325 switch (TREE_CODE (t1
))
1329 /* All void and bool types are the same. */
1334 case FIXED_POINT_TYPE
:
1336 /* With these nodes, we can't determine type equivalence by
1337 looking at what is stored in the nodes themselves, because
1338 two nodes might have different TYPE_MAIN_VARIANTs but still
1339 represent the same type. For example, wchar_t and int could
1340 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1341 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1342 and are distinct types. On the other hand, int and the
1345 typedef int INT __attribute((may_alias));
1347 have identical properties, different TYPE_MAIN_VARIANTs, but
1348 represent the same type. The canonical type system keeps
1349 track of equivalence in this case, so we fall back on it. */
1350 if (TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1353 /* We don't need or want the attribute comparison. */
1356 case TEMPLATE_TEMPLATE_PARM
:
1357 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1358 if (!comp_template_parms_position (t1
, t2
))
1360 if (!comp_template_parms
1361 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1362 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1364 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1366 /* Don't check inheritance. */
1367 strict
= COMPARE_STRICT
;
1372 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1373 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1374 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
1375 && comp_template_args (TYPE_TI_ARGS (t1
), TYPE_TI_ARGS (t2
)))
1378 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1380 else if ((strict
& COMPARE_DERIVED
) && DERIVED_FROM_P (t2
, t1
))
1386 if (!comptypes (TYPE_OFFSET_BASETYPE (t1
), TYPE_OFFSET_BASETYPE (t2
),
1387 strict
& ~COMPARE_REDECLARATION
))
1389 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1393 case REFERENCE_TYPE
:
1394 if (TYPE_REF_IS_RVALUE (t1
) != TYPE_REF_IS_RVALUE (t2
))
1396 /* fall through to checks for pointer types */
1400 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1401 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1407 /* Exception specs and memfn_rquals were checked above. */
1408 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1410 if (!compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)))
1415 /* Target types must match incl. qualifiers. */
1416 if (!comp_array_types (t1
, t2
, ((strict
& COMPARE_REDECLARATION
)
1417 ? bounds_either
: bounds_none
),
1422 case TEMPLATE_TYPE_PARM
:
1423 /* If T1 and T2 don't have the same relative position in their
1424 template parameters set, they can't be equal. */
1425 if (!comp_template_parms_position (t1
, t2
))
1427 /* If T1 and T2 don't represent the same class template deduction,
1428 they aren't equal. */
1429 if (CLASS_PLACEHOLDER_TEMPLATE (t1
)
1430 != CLASS_PLACEHOLDER_TEMPLATE (t2
))
1432 /* Constrained 'auto's are distinct from parms that don't have the same
1434 if (!equivalent_placeholder_constraints (t1
, t2
))
1439 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1440 TYPENAME_TYPE_FULLNAME (t2
)))
1442 /* Qualifiers don't matter on scopes. */
1443 if (!same_type_ignoring_top_level_qualifiers_p (TYPE_CONTEXT (t1
),
1448 case UNBOUND_CLASS_TEMPLATE
:
1449 if (!cp_tree_equal (TYPE_IDENTIFIER (t1
), TYPE_IDENTIFIER (t2
)))
1451 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1456 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1461 if (gnu_vector_type_p (t1
) != gnu_vector_type_p (t2
)
1462 || maybe_ne (TYPE_VECTOR_SUBPARTS (t1
), TYPE_VECTOR_SUBPARTS (t2
))
1463 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1467 case TYPE_PACK_EXPANSION
:
1468 return (same_type_p (PACK_EXPANSION_PATTERN (t1
),
1469 PACK_EXPANSION_PATTERN (t2
))
1470 && comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
1471 PACK_EXPANSION_EXTRA_ARGS (t2
)));
1474 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1
)
1475 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2
))
1477 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t1
) != DECLTYPE_FOR_LAMBDA_CAPTURE (t2
))
1479 if (DECLTYPE_FOR_LAMBDA_PROXY (t1
) != DECLTYPE_FOR_LAMBDA_PROXY (t2
))
1481 if (!cp_tree_equal (DECLTYPE_TYPE_EXPR (t1
), DECLTYPE_TYPE_EXPR (t2
)))
1485 case UNDERLYING_TYPE
:
1486 if (!same_type_p (UNDERLYING_TYPE_TYPE (t1
), UNDERLYING_TYPE_TYPE (t2
)))
1491 if (!cp_tree_equal (TYPEOF_TYPE_EXPR (t1
), TYPEOF_TYPE_EXPR (t2
)))
1499 /* If we get here, we know that from a target independent POV the
1500 types are the same. Make sure the target attributes are also
1502 if (!comp_type_attributes (t1
, t2
))
1506 if (comparing_dependent_aliases
)
1508 /* Don't treat an alias template specialization with dependent
1509 arguments as equivalent to its underlying type when used as a
1510 template argument; we need them to be distinct so that we
1511 substitute into the specialization arguments at instantiation
1512 time. And aliases can't be equivalent without being ==, so
1513 we don't need to look any deeper. */
1514 tree dep1
= dependent_alias_template_spec_p (t1
, nt_transparent
);
1515 tree dep2
= dependent_alias_template_spec_p (t2
, nt_transparent
);
1516 if ((dep1
|| dep2
) && dep1
!= dep2
)
1523 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1524 is a bitwise-or of the COMPARE_* flags. */
1527 comptypes (tree t1
, tree t2
, int strict
)
1529 gcc_checking_assert (t1
&& t2
);
1531 /* TYPE_ARGUMENT_PACKS are not really types. */
1532 gcc_checking_assert (TREE_CODE (t1
) != TYPE_ARGUMENT_PACK
1533 && TREE_CODE (t2
) != TYPE_ARGUMENT_PACK
);
1538 /* Suppress errors caused by previously reported errors. */
1539 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1542 if (strict
== COMPARE_STRICT
)
1544 if (TYPE_STRUCTURAL_EQUALITY_P (t1
) || TYPE_STRUCTURAL_EQUALITY_P (t2
))
1545 /* At least one of the types requires structural equality, so
1546 perform a deep check. */
1547 return structural_comptypes (t1
, t2
, strict
);
1549 if (flag_checking
&& param_use_canonical_types
)
1551 bool result
= structural_comptypes (t1
, t2
, strict
);
1553 if (result
&& TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1554 /* The two types are structurally equivalent, but their
1555 canonical types were different. This is a failure of the
1556 canonical type propagation code.*/
1558 ("canonical types differ for identical types %qT and %qT",
1560 else if (!result
&& TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
1561 /* Two types are structurally different, but the canonical
1562 types are the same. This means we were over-eager in
1563 assigning canonical types. */
1565 ("same canonical type node for different types %qT and %qT",
1570 if (!flag_checking
&& param_use_canonical_types
)
1571 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1573 return structural_comptypes (t1
, t2
, strict
);
1575 else if (strict
== COMPARE_STRUCTURAL
)
1576 return structural_comptypes (t1
, t2
, COMPARE_STRICT
);
1578 return structural_comptypes (t1
, t2
, strict
);
1581 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
1582 top-level qualifiers. */
1585 same_type_ignoring_top_level_qualifiers_p (tree type1
, tree type2
)
1587 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1592 type1
= cp_build_qualified_type (type1
, TYPE_UNQUALIFIED
);
1593 type2
= cp_build_qualified_type (type2
, TYPE_UNQUALIFIED
);
1594 return same_type_p (type1
, type2
);
1597 /* Returns nonzero iff TYPE1 and TYPE2 are similar, as per [conv.qual]. */
1600 similar_type_p (tree type1
, tree type2
)
1602 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1605 /* Informally, two types are similar if, ignoring top-level cv-qualification:
1606 * they are the same type; or
1607 * they are both pointers, and the pointed-to types are similar; or
1608 * they are both pointers to member of the same class, and the types of
1609 the pointed-to members are similar; or
1610 * they are both arrays of the same size or both arrays of unknown bound,
1611 and the array element types are similar. */
1613 if (same_type_ignoring_top_level_qualifiers_p (type1
, type2
))
1616 if ((TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1617 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
1618 || (TREE_CODE (type1
) == ARRAY_TYPE
&& TREE_CODE (type2
) == ARRAY_TYPE
))
1619 return comp_ptr_ttypes_const (type1
, type2
, bounds_either
);
1624 /* Helper function for layout_compatible_type_p and
1625 is_corresponding_member_aggr. Advance to next members (NULL if
1626 no further ones) and return true if those members are still part of
1627 the common initial sequence. */
1630 next_common_initial_seqence (tree
&memb1
, tree
&memb2
)
1634 if (TREE_CODE (memb1
) != FIELD_DECL
1635 || (DECL_FIELD_IS_BASE (memb1
) && is_empty_field (memb1
)))
1637 memb1
= DECL_CHAIN (memb1
);
1640 if (DECL_FIELD_IS_BASE (memb1
))
1642 memb1
= TYPE_FIELDS (TREE_TYPE (memb1
));
1649 if (TREE_CODE (memb2
) != FIELD_DECL
1650 || (DECL_FIELD_IS_BASE (memb2
) && is_empty_field (memb2
)))
1652 memb2
= DECL_CHAIN (memb2
);
1655 if (DECL_FIELD_IS_BASE (memb2
))
1657 memb2
= TYPE_FIELDS (TREE_TYPE (memb2
));
1662 if (memb1
== NULL_TREE
&& memb2
== NULL_TREE
)
1664 if (memb1
== NULL_TREE
|| memb2
== NULL_TREE
)
1666 if (DECL_BIT_FIELD_TYPE (memb1
))
1668 if (!DECL_BIT_FIELD_TYPE (memb2
))
1670 if (!layout_compatible_type_p (DECL_BIT_FIELD_TYPE (memb1
),
1671 DECL_BIT_FIELD_TYPE (memb2
)))
1673 if (TYPE_PRECISION (TREE_TYPE (memb1
))
1674 != TYPE_PRECISION (TREE_TYPE (memb2
)))
1677 else if (DECL_BIT_FIELD_TYPE (memb2
))
1679 else if (!layout_compatible_type_p (TREE_TYPE (memb1
), TREE_TYPE (memb2
)))
1681 if ((!lookup_attribute ("no_unique_address", DECL_ATTRIBUTES (memb1
)))
1682 != !lookup_attribute ("no_unique_address", DECL_ATTRIBUTES (memb2
)))
1684 if (!tree_int_cst_equal (bit_position (memb1
), bit_position (memb2
)))
1689 /* Return true if TYPE1 and TYPE2 are layout-compatible types. */
1692 layout_compatible_type_p (tree type1
, tree type2
)
1694 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1698 if (TREE_CODE (type1
) != TREE_CODE (type2
))
1701 type1
= cp_build_qualified_type (type1
, TYPE_UNQUALIFIED
);
1702 type2
= cp_build_qualified_type (type2
, TYPE_UNQUALIFIED
);
1704 if (TREE_CODE (type1
) == ENUMERAL_TYPE
)
1705 return (TYPE_ALIGN (type1
) == TYPE_ALIGN (type2
)
1706 && tree_int_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
))
1707 && same_type_p (finish_underlying_type (type1
),
1708 finish_underlying_type (type2
)));
1710 if (CLASS_TYPE_P (type1
)
1711 && std_layout_type_p (type1
)
1712 && std_layout_type_p (type2
)
1713 && TYPE_ALIGN (type1
) == TYPE_ALIGN (type2
)
1714 && tree_int_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
)))
1716 tree field1
= TYPE_FIELDS (type1
);
1717 tree field2
= TYPE_FIELDS (type2
);
1718 if (TREE_CODE (type1
) == RECORD_TYPE
)
1722 if (!next_common_initial_seqence (field1
, field2
))
1724 if (field1
== NULL_TREE
)
1726 field1
= DECL_CHAIN (field1
);
1727 field2
= DECL_CHAIN (field2
);
1730 /* Otherwise both types must be union types.
1732 "Two standard-layout unions are layout-compatible if they have
1733 the same number of non-static data members and corresponding
1734 non-static data members (in any order) have layout-compatible
1736 but the code anticipates that bitfield vs. non-bitfield,
1737 different bitfield widths or presence/absence of
1738 [[no_unique_address]] should be checked as well. */
1739 auto_vec
<tree
, 16> vec
;
1740 unsigned int count
= 0;
1741 for (; field1
; field1
= DECL_CHAIN (field1
))
1742 if (TREE_CODE (field1
) == FIELD_DECL
)
1744 for (; field2
; field2
= DECL_CHAIN (field2
))
1745 if (TREE_CODE (field2
) == FIELD_DECL
)
1746 vec
.safe_push (field2
);
1747 /* Discussions on core lean towards treating multiple union fields
1748 of the same type as the same field, so this might need changing
1750 if (count
!= vec
.length ())
1752 for (field1
= TYPE_FIELDS (type1
); field1
; field1
= DECL_CHAIN (field1
))
1754 if (TREE_CODE (field1
) != FIELD_DECL
)
1757 tree t1
= DECL_BIT_FIELD_TYPE (field1
);
1758 if (t1
== NULL_TREE
)
1759 t1
= TREE_TYPE (field1
);
1760 FOR_EACH_VEC_ELT (vec
, j
, field2
)
1762 tree t2
= DECL_BIT_FIELD_TYPE (field2
);
1763 if (t2
== NULL_TREE
)
1764 t2
= TREE_TYPE (field2
);
1765 if (DECL_BIT_FIELD_TYPE (field1
))
1767 if (!DECL_BIT_FIELD_TYPE (field2
))
1769 if (TYPE_PRECISION (TREE_TYPE (field1
))
1770 != TYPE_PRECISION (TREE_TYPE (field2
)))
1773 else if (DECL_BIT_FIELD_TYPE (field2
))
1775 if (!layout_compatible_type_p (t1
, t2
))
1777 if ((!lookup_attribute ("no_unique_address",
1778 DECL_ATTRIBUTES (field1
)))
1779 != !lookup_attribute ("no_unique_address",
1780 DECL_ATTRIBUTES (field2
)))
1784 if (j
== vec
.length ())
1786 vec
.unordered_remove (j
);
1791 return same_type_p (type1
, type2
);
1794 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1797 at_least_as_qualified_p (const_tree type1
, const_tree type2
)
1799 int q1
= cp_type_quals (type1
);
1800 int q2
= cp_type_quals (type2
);
1802 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1803 return (q1
& q2
) == q2
;
1806 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1807 more cv-qualified that TYPE1, and 0 otherwise. */
1810 comp_cv_qualification (int q1
, int q2
)
1815 if ((q1
& q2
) == q2
)
1817 else if ((q1
& q2
) == q1
)
1824 comp_cv_qualification (const_tree type1
, const_tree type2
)
1826 int q1
= cp_type_quals (type1
);
1827 int q2
= cp_type_quals (type2
);
1828 return comp_cv_qualification (q1
, q2
);
1831 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1832 subset of the cv-qualification signature of TYPE2, and the types
1833 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1836 comp_cv_qual_signature (tree type1
, tree type2
)
1838 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1840 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1846 /* Subroutines of `comptypes'. */
1848 /* Return true if two parameter type lists PARMS1 and PARMS2 are
1849 equivalent in the sense that functions with those parameter types
1850 can have equivalent types. The two lists must be equivalent,
1851 element by element. */
1854 compparms (const_tree parms1
, const_tree parms2
)
1858 /* An unspecified parmlist matches any specified parmlist
1859 whose argument types don't need default promotions. */
1861 for (t1
= parms1
, t2
= parms2
;
1863 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1865 /* If one parmlist is shorter than the other,
1866 they fail to match. */
1869 if (!same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1876 /* Process a sizeof or alignof expression where the operand is a type.
1877 STD_ALIGNOF indicates whether an alignof has C++11 (minimum alignment)
1878 or GNU (preferred alignment) semantics; it is ignored if OP is
1882 cxx_sizeof_or_alignof_type (location_t loc
, tree type
, enum tree_code op
,
1883 bool std_alignof
, bool complain
)
1885 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
1886 if (type
== error_mark_node
)
1887 return error_mark_node
;
1889 type
= non_reference (type
);
1890 if (TREE_CODE (type
) == METHOD_TYPE
)
1894 pedwarn (loc
, OPT_Wpointer_arith
,
1895 "invalid application of %qs to a member function",
1896 OVL_OP_INFO (false, op
)->name
);
1897 return size_one_node
;
1900 return error_mark_node
;
1902 else if (VOID_TYPE_P (type
) && std_alignof
)
1905 error_at (loc
, "invalid application of %qs to a void type",
1906 OVL_OP_INFO (false, op
)->name
);
1907 return error_mark_node
;
1910 bool dependent_p
= dependent_type_p (type
);
1912 complete_type (type
);
1914 /* VLA types will have a non-constant size. In the body of an
1915 uninstantiated template, we don't need to try to compute the
1916 value, because the sizeof expression is not an integral
1917 constant expression in that case. And, if we do try to
1918 compute the value, we'll likely end up with SAVE_EXPRs, which
1919 the template substitution machinery does not expect to see. */
1920 || (processing_template_decl
1921 && COMPLETE_TYPE_P (type
)
1922 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
1924 tree value
= build_min (op
, size_type_node
, type
);
1925 TREE_READONLY (value
) = 1;
1926 if (op
== ALIGNOF_EXPR
&& std_alignof
)
1927 ALIGNOF_EXPR_STD_P (value
) = true;
1928 SET_EXPR_LOCATION (value
, loc
);
1932 return c_sizeof_or_alignof_type (loc
, complete_type (type
),
1933 op
== SIZEOF_EXPR
, std_alignof
,
1937 /* Return the size of the type, without producing any warnings for
1938 types whose size cannot be taken. This routine should be used only
1939 in some other routine that has already produced a diagnostic about
1940 using the size of such a type. */
1942 cxx_sizeof_nowarn (tree type
)
1944 if (TREE_CODE (type
) == FUNCTION_TYPE
1945 || VOID_TYPE_P (type
)
1946 || TREE_CODE (type
) == ERROR_MARK
)
1947 return size_one_node
;
1948 else if (!COMPLETE_TYPE_P (type
))
1949 return size_zero_node
;
1951 return cxx_sizeof_or_alignof_type (input_location
, type
,
1952 SIZEOF_EXPR
, false, false);
1955 /* Process a sizeof expression where the operand is an expression. */
1958 cxx_sizeof_expr (location_t loc
, tree e
, tsubst_flags_t complain
)
1960 if (e
== error_mark_node
)
1961 return error_mark_node
;
1963 if (instantiation_dependent_uneval_expression_p (e
))
1965 e
= build_min (SIZEOF_EXPR
, size_type_node
, e
);
1966 TREE_SIDE_EFFECTS (e
) = 0;
1967 TREE_READONLY (e
) = 1;
1968 SET_EXPR_LOCATION (e
, loc
);
1973 location_t e_loc
= cp_expr_loc_or_loc (e
, loc
);
1974 STRIP_ANY_LOCATION_WRAPPER (e
);
1976 /* To get the size of a static data member declared as an array of
1977 unknown bound, we need to instantiate it. */
1979 && VAR_HAD_UNKNOWN_BOUND (e
)
1980 && DECL_TEMPLATE_INSTANTIATION (e
))
1981 instantiate_decl (e
, /*defer_ok*/true, /*expl_inst_mem*/false);
1983 if (TREE_CODE (e
) == PARM_DECL
1984 && DECL_ARRAY_PARAMETER_P (e
)
1985 && (complain
& tf_warning
))
1987 auto_diagnostic_group d
;
1988 if (warning_at (e_loc
, OPT_Wsizeof_array_argument
,
1989 "%<sizeof%> on array function parameter %qE "
1990 "will return size of %qT", e
, TREE_TYPE (e
)))
1991 inform (DECL_SOURCE_LOCATION (e
), "declared here");
1994 e
= mark_type_use (e
);
1998 if (complain
& tf_error
)
2000 "invalid application of %<sizeof%> to a bit-field");
2002 return error_mark_node
;
2005 else if (is_overloaded_fn (e
))
2007 if (complain
& tf_error
)
2008 permerror (e_loc
, "ISO C++ forbids applying %<sizeof%> to "
2009 "an expression of function type");
2011 return error_mark_node
;
2014 else if (type_unknown_p (e
))
2016 if (complain
& tf_error
)
2017 cxx_incomplete_type_error (e_loc
, e
, TREE_TYPE (e
));
2019 return error_mark_node
;
2025 return cxx_sizeof_or_alignof_type (loc
, e
, SIZEOF_EXPR
, false,
2026 complain
& tf_error
);
2029 /* Implement the __alignof keyword: Return the minimum required
2030 alignment of E, measured in bytes. For VAR_DECL's and
2031 FIELD_DECL's return DECL_ALIGN (which can be set from an
2032 "aligned" __attribute__ specification). STD_ALIGNOF acts
2033 like in cxx_sizeof_or_alignof_type. */
2036 cxx_alignof_expr (location_t loc
, tree e
, bool std_alignof
,
2037 tsubst_flags_t complain
)
2041 if (e
== error_mark_node
)
2042 return error_mark_node
;
2044 if (processing_template_decl
)
2046 e
= build_min (ALIGNOF_EXPR
, size_type_node
, e
);
2047 TREE_SIDE_EFFECTS (e
) = 0;
2048 TREE_READONLY (e
) = 1;
2049 SET_EXPR_LOCATION (e
, loc
);
2050 ALIGNOF_EXPR_STD_P (e
) = std_alignof
;
2055 location_t e_loc
= cp_expr_loc_or_loc (e
, loc
);
2056 STRIP_ANY_LOCATION_WRAPPER (e
);
2058 e
= mark_type_use (e
);
2060 if (!verify_type_context (loc
, TCTX_ALIGNOF
, TREE_TYPE (e
),
2061 !(complain
& tf_error
)))
2063 if (!(complain
& tf_error
))
2064 return error_mark_node
;
2068 t
= size_int (DECL_ALIGN_UNIT (e
));
2069 else if (bitfield_p (e
))
2071 if (complain
& tf_error
)
2073 "invalid application of %<__alignof%> to a bit-field");
2075 return error_mark_node
;
2078 else if (TREE_CODE (e
) == COMPONENT_REF
2079 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
)
2080 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e
, 1)));
2081 else if (is_overloaded_fn (e
))
2083 if (complain
& tf_error
)
2084 permerror (e_loc
, "ISO C++ forbids applying %<__alignof%> to "
2085 "an expression of function type");
2087 return error_mark_node
;
2088 if (TREE_CODE (e
) == FUNCTION_DECL
)
2089 t
= size_int (DECL_ALIGN_UNIT (e
));
2093 else if (type_unknown_p (e
))
2095 if (complain
& tf_error
)
2096 cxx_incomplete_type_error (e_loc
, e
, TREE_TYPE (e
));
2098 return error_mark_node
;
2102 return cxx_sizeof_or_alignof_type (loc
, TREE_TYPE (e
),
2103 ALIGNOF_EXPR
, std_alignof
,
2104 complain
& tf_error
);
2106 return fold_convert_loc (loc
, size_type_node
, t
);
2109 /* Process a sizeof or alignof expression E with code OP where the operand
2110 is an expression. STD_ALIGNOF acts like in cxx_sizeof_or_alignof_type. */
2113 cxx_sizeof_or_alignof_expr (location_t loc
, tree e
, enum tree_code op
,
2114 bool std_alignof
, bool complain
)
2116 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
2117 if (op
== SIZEOF_EXPR
)
2118 return cxx_sizeof_expr (loc
, e
, complain
? tf_warning_or_error
: tf_none
);
2120 return cxx_alignof_expr (loc
, e
, std_alignof
,
2121 complain
? tf_warning_or_error
: tf_none
);
2124 /* Build a representation of an expression 'alignas(E).' Return the
2125 folded integer value of E if it is an integral constant expression
2126 that resolves to a valid alignment. If E depends on a template
2127 parameter, return a syntactic representation tree of kind
2128 ALIGNOF_EXPR. Otherwise, return an error_mark_node if the
2129 expression is ill formed, or NULL_TREE if E is NULL_TREE. */
2132 cxx_alignas_expr (tree e
)
2134 if (e
== NULL_TREE
|| e
== error_mark_node
2135 || (!TYPE_P (e
) && !require_potential_rvalue_constant_expression (e
)))
2141 When the alignment-specifier is of the form
2142 alignas(type-id), it shall have the same effect as
2143 alignas(alignof(type-id)). */
2145 return cxx_sizeof_or_alignof_type (input_location
,
2147 /*std_alignof=*/true,
2150 /* If we reach this point, it means the alignas expression if of
2151 the form "alignas(assignment-expression)", so we should follow
2152 what is stated by [dcl.align]/2. */
2154 if (value_dependent_expression_p (e
))
2155 /* Leave value-dependent expression alone for now. */
2158 e
= instantiate_non_dependent_expr (e
);
2159 e
= mark_rvalue_use (e
);
2161 /* [dcl.align]/2 says:
2163 the assignment-expression shall be an integral constant
2166 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (e
)))
2168 error ("%<alignas%> argument has non-integral type %qT", TREE_TYPE (e
));
2169 return error_mark_node
;
2172 return cxx_constant_value (e
);
2176 /* EXPR is being used in a context that is not a function call.
2181 The expression can be used only as the left-hand operand of a
2182 member function call.
2184 [expr.mptr.operator]
2186 If the result of .* or ->* is a function, then that result can be
2187 used only as the operand for the function call operator ().
2189 by issuing an error message if appropriate. Returns true iff EXPR
2190 violates these rules. */
2193 invalid_nonstatic_memfn_p (location_t loc
, tree expr
, tsubst_flags_t complain
)
2195 if (expr
== NULL_TREE
)
2197 /* Don't enforce this in MS mode. */
2198 if (flag_ms_extensions
)
2200 if (is_overloaded_fn (expr
) && !really_overloaded_fn (expr
))
2201 expr
= get_first_fn (expr
);
2202 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (expr
))
2204 if (complain
& tf_error
)
2208 error_at (loc
, "invalid use of non-static member function %qD",
2210 inform (DECL_SOURCE_LOCATION (expr
), "declared here");
2213 error_at (loc
, "invalid use of non-static member function of "
2214 "type %qT", TREE_TYPE (expr
));
2221 /* If EXP is a reference to a bit-field, and the type of EXP does not
2222 match the declared type of the bit-field, return the declared type
2223 of the bit-field. Otherwise, return NULL_TREE. */
2226 is_bitfield_expr_with_lowered_type (const_tree exp
)
2228 switch (TREE_CODE (exp
))
2231 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1)
2232 ? TREE_OPERAND (exp
, 1)
2233 : TREE_OPERAND (exp
, 0)))
2235 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 2));
2238 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1));
2242 case UNARY_PLUS_EXPR
:
2243 case PREDECREMENT_EXPR
:
2244 case PREINCREMENT_EXPR
:
2245 case POSTDECREMENT_EXPR
:
2246 case POSTINCREMENT_EXPR
:
2248 case NON_LVALUE_EXPR
:
2250 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
2256 field
= TREE_OPERAND (exp
, 1);
2257 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_BIT_FIELD_TYPE (field
))
2259 if (same_type_ignoring_top_level_qualifiers_p
2260 (TREE_TYPE (exp
), DECL_BIT_FIELD_TYPE (field
)))
2262 return DECL_BIT_FIELD_TYPE (field
);
2266 if (DECL_HAS_VALUE_EXPR_P (exp
))
2267 return is_bitfield_expr_with_lowered_type (DECL_VALUE_EXPR
2268 (CONST_CAST_TREE (exp
)));
2271 case VIEW_CONVERT_EXPR
:
2272 if (location_wrapper_p (exp
))
2273 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
2282 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
2283 bitfield with a lowered type, the type of EXP is returned, rather
2287 unlowered_expr_type (const_tree exp
)
2290 tree etype
= TREE_TYPE (exp
);
2292 type
= is_bitfield_expr_with_lowered_type (exp
);
2294 type
= cp_build_qualified_type (type
, cp_type_quals (etype
));
2301 /* Perform the conversions in [expr] that apply when an lvalue appears
2302 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
2303 function-to-pointer conversions. In addition, bitfield references are
2304 converted to their declared types. Note that this function does not perform
2305 the lvalue-to-rvalue conversion for class types. If you need that conversion
2306 for class types, then you probably need to use force_rvalue.
2308 Although the returned value is being used as an rvalue, this
2309 function does not wrap the returned expression in a
2310 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
2311 that the return value is no longer an lvalue. */
2314 decay_conversion (tree exp
,
2315 tsubst_flags_t complain
,
2316 bool reject_builtin
/* = true */)
2319 enum tree_code code
;
2320 location_t loc
= cp_expr_loc_or_input_loc (exp
);
2322 type
= TREE_TYPE (exp
);
2323 if (type
== error_mark_node
)
2324 return error_mark_node
;
2326 exp
= resolve_nondeduced_context_or_error (exp
, complain
);
2328 code
= TREE_CODE (type
);
2330 if (error_operand_p (exp
))
2331 return error_mark_node
;
2333 if (NULLPTR_TYPE_P (type
) && !TREE_SIDE_EFFECTS (exp
))
2335 mark_rvalue_use (exp
, loc
, reject_builtin
);
2336 return nullptr_node
;
2339 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2340 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
2341 if (code
== VOID_TYPE
)
2343 if (complain
& tf_error
)
2344 error_at (loc
, "void value not ignored as it ought to be");
2345 return error_mark_node
;
2347 if (invalid_nonstatic_memfn_p (loc
, exp
, complain
))
2348 return error_mark_node
;
2349 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
2351 exp
= mark_lvalue_use (exp
);
2352 if (reject_builtin
&& reject_gcc_builtin (exp
, loc
))
2353 return error_mark_node
;
2354 return cp_build_addr_expr (exp
, complain
);
2356 if (code
== ARRAY_TYPE
)
2361 exp
= mark_lvalue_use (exp
);
2363 if (INDIRECT_REF_P (exp
))
2364 return build_nop (build_pointer_type (TREE_TYPE (type
)),
2365 TREE_OPERAND (exp
, 0));
2367 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
2369 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1), complain
);
2370 if (op1
== error_mark_node
)
2371 return error_mark_node
;
2372 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
2373 TREE_OPERAND (exp
, 0), op1
);
2376 if (!obvalue_p (exp
)
2377 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
2379 if (complain
& tf_error
)
2380 error_at (loc
, "invalid use of non-lvalue array");
2381 return error_mark_node
;
2384 /* Don't let an array compound literal decay to a pointer. It can
2385 still be used to initialize an array or bind to a reference. */
2386 if (TREE_CODE (exp
) == TARGET_EXPR
)
2388 if (complain
& tf_error
)
2389 error_at (loc
, "taking address of temporary array");
2390 return error_mark_node
;
2393 ptrtype
= build_pointer_type (TREE_TYPE (type
));
2397 if (!cxx_mark_addressable (exp
))
2398 return error_mark_node
;
2399 adr
= build_nop (ptrtype
, build_address (exp
));
2402 /* This way is better for a COMPONENT_REF since it can
2403 simplify the offset for a component. */
2404 adr
= cp_build_addr_expr (exp
, complain
);
2405 return cp_convert (ptrtype
, adr
, complain
);
2408 /* Otherwise, it's the lvalue-to-rvalue conversion. */
2409 exp
= mark_rvalue_use (exp
, loc
, reject_builtin
);
2411 /* If a bitfield is used in a context where integral promotion
2412 applies, then the caller is expected to have used
2413 default_conversion. That function promotes bitfields correctly
2414 before calling this function. At this point, if we have a
2415 bitfield referenced, we may assume that is not subject to
2416 promotion, and that, therefore, the type of the resulting rvalue
2417 is the declared type of the bitfield. */
2418 exp
= convert_bitfield_to_declared_type (exp
);
2420 /* We do not call rvalue() here because we do not want to wrap EXP
2421 in a NON_LVALUE_EXPR. */
2425 Non-class rvalues always have cv-unqualified types. */
2426 type
= TREE_TYPE (exp
);
2427 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
2428 exp
= build_nop (cv_unqualified (type
), exp
);
2430 if (!complete_type_or_maybe_complain (type
, exp
, complain
))
2431 return error_mark_node
;
2436 /* Perform preparatory conversions, as part of the "usual arithmetic
2437 conversions". In particular, as per [expr]:
2439 Whenever an lvalue expression appears as an operand of an
2440 operator that expects the rvalue for that operand, the
2441 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
2442 standard conversions are applied to convert the expression to an
2445 In addition, we perform integral promotions here, as those are
2446 applied to both operands to a binary operator before determining
2447 what additional conversions should apply. */
2450 cp_default_conversion (tree exp
, tsubst_flags_t complain
)
2452 /* Check for target-specific promotions. */
2453 tree promoted_type
= targetm
.promoted_type (TREE_TYPE (exp
));
2455 exp
= cp_convert (promoted_type
, exp
, complain
);
2456 /* Perform the integral promotions first so that bitfield
2457 expressions (which may promote to "int", even if the bitfield is
2458 declared "unsigned") are promoted correctly. */
2459 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp
)))
2460 exp
= cp_perform_integral_promotions (exp
, complain
);
2461 /* Perform the other conversions. */
2462 exp
= decay_conversion (exp
, complain
);
2470 default_conversion (tree exp
)
2472 return cp_default_conversion (exp
, tf_warning_or_error
);
2475 /* EXPR is an expression with an integral or enumeration type.
2476 Perform the integral promotions in [conv.prom], and return the
2480 cp_perform_integral_promotions (tree expr
, tsubst_flags_t complain
)
2485 expr
= mark_rvalue_use (expr
);
2486 if (error_operand_p (expr
))
2487 return error_mark_node
;
2489 type
= TREE_TYPE (expr
);
2493 A prvalue for an integral bit-field (11.3.9) can be converted to a prvalue
2494 of type int if int can represent all the values of the bit-field;
2495 otherwise, it can be converted to unsigned int if unsigned int can
2496 represent all the values of the bit-field. If the bit-field is larger yet,
2497 no integral promotion applies to it. If the bit-field has an enumerated
2498 type, it is treated as any other value of that type for promotion
2500 tree bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
2502 && (TREE_CODE (bitfield_type
) == ENUMERAL_TYPE
2503 || TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)))
2504 type
= bitfield_type
;
2506 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
2507 /* Scoped enums don't promote. */
2508 if (SCOPED_ENUM_P (type
))
2510 promoted_type
= type_promotes_to (type
);
2511 if (type
!= promoted_type
)
2512 expr
= cp_convert (promoted_type
, expr
, complain
);
2513 else if (bitfield_type
&& bitfield_type
!= type
)
2514 /* Prevent decay_conversion from converting to bitfield_type. */
2515 expr
= build_nop (type
, expr
);
2522 perform_integral_promotions (tree expr
)
2524 return cp_perform_integral_promotions (expr
, tf_warning_or_error
);
2527 /* Returns nonzero iff exp is a STRING_CST or the result of applying
2528 decay_conversion to one. */
2531 string_conv_p (const_tree totype
, const_tree exp
, int warn
)
2535 if (!TYPE_PTR_P (totype
))
2538 t
= TREE_TYPE (totype
);
2539 if (!same_type_p (t
, char_type_node
)
2540 && !same_type_p (t
, char8_type_node
)
2541 && !same_type_p (t
, char16_type_node
)
2542 && !same_type_p (t
, char32_type_node
)
2543 && !same_type_p (t
, wchar_type_node
))
2546 location_t loc
= EXPR_LOC_OR_LOC (exp
, input_location
);
2548 STRIP_ANY_LOCATION_WRAPPER (exp
);
2550 if (TREE_CODE (exp
) == STRING_CST
)
2552 /* Make sure that we don't try to convert between char and wide chars. */
2553 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
2558 /* Is this a string constant which has decayed to 'const char *'? */
2559 t
= build_pointer_type (cp_build_qualified_type (t
, TYPE_QUAL_CONST
));
2560 if (!same_type_p (TREE_TYPE (exp
), t
))
2563 if (TREE_CODE (exp
) != ADDR_EXPR
2564 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
2569 if (cxx_dialect
>= cxx11
)
2570 pedwarn (loc
, OPT_Wwrite_strings
,
2571 "ISO C++ forbids converting a string constant to %qT",
2574 warning_at (loc
, OPT_Wwrite_strings
,
2575 "deprecated conversion from string constant to %qT",
2582 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
2583 can, for example, use as an lvalue. This code used to be in
2584 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
2585 expressions, where we're dealing with aggregates. But now it's again only
2586 called from unary_complex_lvalue. The case (in particular) that led to
2587 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
2591 rationalize_conditional_expr (enum tree_code code
, tree t
,
2592 tsubst_flags_t complain
)
2594 location_t loc
= cp_expr_loc_or_input_loc (t
);
2596 /* For MIN_EXPR or MAX_EXPR, fold-const.cc has arranged things so that
2597 the first operand is always the one to be used if both operands
2598 are equal, so we know what conditional expression this used to be. */
2599 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
2601 tree op0
= TREE_OPERAND (t
, 0);
2602 tree op1
= TREE_OPERAND (t
, 1);
2604 /* The following code is incorrect if either operand side-effects. */
2605 gcc_assert (!TREE_SIDE_EFFECTS (op0
)
2606 && !TREE_SIDE_EFFECTS (op1
));
2608 build_conditional_expr (loc
,
2609 build_x_binary_op (loc
,
2610 (TREE_CODE (t
) == MIN_EXPR
2611 ? LE_EXPR
: GE_EXPR
),
2612 op0
, TREE_CODE (op0
),
2613 op1
, TREE_CODE (op1
),
2617 cp_build_unary_op (code
, op0
, false, complain
),
2618 cp_build_unary_op (code
, op1
, false, complain
),
2622 tree op1
= TREE_OPERAND (t
, 1);
2623 if (TREE_CODE (op1
) != THROW_EXPR
)
2624 op1
= cp_build_unary_op (code
, op1
, false, complain
);
2625 tree op2
= TREE_OPERAND (t
, 2);
2626 if (TREE_CODE (op2
) != THROW_EXPR
)
2627 op2
= cp_build_unary_op (code
, op2
, false, complain
);
2630 build_conditional_expr (loc
, TREE_OPERAND (t
, 0), op1
, op2
, complain
);
2633 /* Given the TYPE of an anonymous union field inside T, return the
2634 FIELD_DECL for the field. If not found return NULL_TREE. Because
2635 anonymous unions can nest, we must also search all anonymous unions
2636 that are directly reachable. */
2639 lookup_anon_field (tree
, tree type
)
2643 type
= TYPE_MAIN_VARIANT (type
);
2644 field
= ANON_AGGR_TYPE_FIELD (type
);
2649 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
2650 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
2651 non-NULL, it indicates the path to the base used to name MEMBER.
2652 If PRESERVE_REFERENCE is true, the expression returned will have
2653 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
2654 returned will have the type referred to by the reference.
2656 This function does not perform access control; that is either done
2657 earlier by the parser when the name of MEMBER is resolved to MEMBER
2658 itself, or later when overload resolution selects one of the
2659 functions indicated by MEMBER. */
2662 build_class_member_access_expr (cp_expr object
, tree member
,
2663 tree access_path
, bool preserve_reference
,
2664 tsubst_flags_t complain
)
2668 tree result
= NULL_TREE
;
2669 tree using_decl
= NULL_TREE
;
2671 if (error_operand_p (object
) || error_operand_p (member
))
2672 return error_mark_node
;
2674 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2678 The type of the first expression shall be "class object" (of a
2680 object_type
= TREE_TYPE (object
);
2681 if (!currently_open_class (object_type
)
2682 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
2683 return error_mark_node
;
2684 if (!CLASS_TYPE_P (object_type
))
2686 if (complain
& tf_error
)
2688 if (INDIRECT_TYPE_P (object_type
)
2689 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
2690 error ("request for member %qD in %qE, which is of pointer "
2691 "type %qT (maybe you meant to use %<->%> ?)",
2692 member
, object
.get_value (), object_type
);
2694 error ("request for member %qD in %qE, which is of non-class "
2695 "type %qT", member
, object
.get_value (), object_type
);
2697 return error_mark_node
;
2700 /* The standard does not seem to actually say that MEMBER must be a
2701 member of OBJECT_TYPE. However, that is clearly what is
2703 if (DECL_P (member
))
2705 member_scope
= DECL_CLASS_CONTEXT (member
);
2706 if (!mark_used (member
, complain
) && !(complain
& tf_error
))
2707 return error_mark_node
;
2709 if (TREE_UNAVAILABLE (member
))
2710 error_unavailable_use (member
, NULL_TREE
);
2711 else if (TREE_DEPRECATED (member
))
2712 warn_deprecated_use (member
, NULL_TREE
);
2715 member_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (member
));
2716 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2717 presently be the anonymous union. Go outwards until we find a
2718 type related to OBJECT_TYPE. */
2719 while ((ANON_AGGR_TYPE_P (member_scope
) || UNSCOPED_ENUM_P (member_scope
))
2720 && !same_type_ignoring_top_level_qualifiers_p (member_scope
,
2722 member_scope
= TYPE_CONTEXT (member_scope
);
2723 if (!member_scope
|| !DERIVED_FROM_P (member_scope
, object_type
))
2725 if (complain
& tf_error
)
2727 if (TREE_CODE (member
) == FIELD_DECL
)
2728 error ("invalid use of non-static data member %qE", member
);
2730 error ("%qD is not a member of %qT", member
, object_type
);
2732 return error_mark_node
;
2735 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2736 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
2737 in the front end; only _DECLs and _REFs are lvalues in the back end. */
2738 if (tree temp
= unary_complex_lvalue (ADDR_EXPR
, object
))
2740 temp
= cp_build_fold_indirect_ref (temp
);
2741 if (!lvalue_p (object
) && lvalue_p (temp
))
2742 /* Preserve rvalueness. */
2747 /* In [expr.ref], there is an explicit list of the valid choices for
2748 MEMBER. We check for each of those cases here. */
2751 /* A static data member. */
2753 mark_exp_read (object
);
2755 if (tree wrap
= maybe_get_tls_wrapper_call (result
))
2756 /* Replace an evaluated use of the thread_local variable with
2757 a call to its wrapper. */
2760 /* If OBJECT has side-effects, they are supposed to occur. */
2761 if (TREE_SIDE_EFFECTS (object
))
2762 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), object
, result
);
2764 else if (TREE_CODE (member
) == FIELD_DECL
)
2766 /* A non-static data member. */
2771 if (INDIRECT_REF_P (object
))
2773 integer_zerop (tree_strip_nop_conversions (TREE_OPERAND (object
, 0)));
2775 null_object_p
= false;
2777 /* Convert OBJECT to the type of MEMBER. */
2778 if (!same_type_p (TYPE_MAIN_VARIANT (object_type
),
2779 TYPE_MAIN_VARIANT (member_scope
)))
2784 /* We didn't complain above about a currently open class, but now we
2785 must: we don't know how to refer to a base member before layout is
2786 complete. But still don't complain in a template. */
2787 if (!cp_unevaluated_operand
2788 && !dependent_type_p (object_type
)
2789 && !complete_type_or_maybe_complain (object_type
, object
,
2791 return error_mark_node
;
2793 binfo
= lookup_base (access_path
? access_path
: object_type
,
2794 member_scope
, ba_unique
, &kind
, complain
);
2795 if (binfo
== error_mark_node
)
2796 return error_mark_node
;
2798 /* It is invalid to try to get to a virtual base of a
2799 NULL object. The most common cause is invalid use of
2801 if (null_object_p
&& kind
== bk_via_virtual
)
2803 if (complain
& tf_error
)
2805 error ("invalid access to non-static data member %qD in "
2806 "virtual base of NULL object", member
);
2808 return error_mark_node
;
2811 /* Convert to the base. */
2812 object
= build_base_path (PLUS_EXPR
, object
, binfo
,
2813 /*nonnull=*/1, complain
);
2814 /* If we found the base successfully then we should be able
2815 to convert to it successfully. */
2816 gcc_assert (object
!= error_mark_node
);
2819 /* If MEMBER is from an anonymous aggregate, we have converted
2820 OBJECT so that it refers to the class containing the
2821 anonymous union. Generate a reference to the anonymous union
2822 itself, and recur to find MEMBER. */
2823 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member
))
2824 /* When this code is called from build_field_call, the
2825 object already has the type of the anonymous union.
2826 That is because the COMPONENT_REF was already
2827 constructed, and was then disassembled before calling
2828 build_field_call. After the function-call code is
2829 cleaned up, this waste can be eliminated. */
2830 && (!same_type_ignoring_top_level_qualifiers_p
2831 (TREE_TYPE (object
), DECL_CONTEXT (member
))))
2833 tree anonymous_union
;
2835 anonymous_union
= lookup_anon_field (TREE_TYPE (object
),
2836 DECL_CONTEXT (member
));
2837 object
= build_class_member_access_expr (object
,
2839 /*access_path=*/NULL_TREE
,
2844 /* Compute the type of the field, as described in [expr.ref]. */
2845 type_quals
= TYPE_UNQUALIFIED
;
2846 member_type
= TREE_TYPE (member
);
2847 if (!TYPE_REF_P (member_type
))
2849 type_quals
= (cp_type_quals (member_type
)
2850 | cp_type_quals (object_type
));
2852 /* A field is const (volatile) if the enclosing object, or the
2853 field itself, is const (volatile). But, a mutable field is
2854 not const, even within a const object. */
2855 if (DECL_MUTABLE_P (member
))
2856 type_quals
&= ~TYPE_QUAL_CONST
;
2857 member_type
= cp_build_qualified_type (member_type
, type_quals
);
2860 result
= build3_loc (input_location
, COMPONENT_REF
, member_type
,
2861 object
, member
, NULL_TREE
);
2863 /* Mark the expression const or volatile, as appropriate. Even
2864 though we've dealt with the type above, we still have to mark the
2865 expression itself. */
2866 if (type_quals
& TYPE_QUAL_CONST
)
2867 TREE_READONLY (result
) = 1;
2868 if (type_quals
& TYPE_QUAL_VOLATILE
)
2869 TREE_THIS_VOLATILE (result
) = 1;
2871 else if (BASELINK_P (member
))
2873 /* The member is a (possibly overloaded) member function. */
2877 /* If the MEMBER is exactly one static member function, then we
2878 know the type of the expression. Otherwise, we must wait
2879 until overload resolution has been performed. */
2880 functions
= BASELINK_FUNCTIONS (member
);
2881 if (TREE_CODE (functions
) == FUNCTION_DECL
2882 && DECL_STATIC_FUNCTION_P (functions
))
2883 type
= TREE_TYPE (functions
);
2885 type
= unknown_type_node
;
2886 /* Note that we do not convert OBJECT to the BASELINK_BINFO
2887 base. That will happen when the function is called. */
2888 result
= build3_loc (input_location
, COMPONENT_REF
, type
, object
, member
,
2891 else if (TREE_CODE (member
) == CONST_DECL
)
2893 /* The member is an enumerator. */
2895 /* If OBJECT has side-effects, they are supposed to occur. */
2896 if (TREE_SIDE_EFFECTS (object
))
2897 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
2900 else if ((using_decl
= strip_using_decl (member
)) != member
)
2901 result
= build_class_member_access_expr (object
,
2903 access_path
, preserve_reference
,
2907 if (complain
& tf_error
)
2908 error ("invalid use of %qD", member
);
2909 return error_mark_node
;
2912 if (!preserve_reference
)
2915 If E2 is declared to have type "reference to T", then ... the
2916 type of E1.E2 is T. */
2917 result
= convert_from_reference (result
);
2922 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
2923 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
2926 lookup_destructor (tree object
, tree scope
, tree dtor_name
,
2927 tsubst_flags_t complain
)
2929 tree object_type
= TREE_TYPE (object
);
2930 tree dtor_type
= TREE_OPERAND (dtor_name
, 0);
2933 /* We've already complained about this destructor. */
2934 if (dtor_type
== error_mark_node
)
2935 return error_mark_node
;
2937 if (scope
&& !check_dtor_name (scope
, dtor_type
))
2939 if (complain
& tf_error
)
2940 error ("qualified type %qT does not match destructor name ~%qT",
2942 return error_mark_node
;
2944 if (is_auto (dtor_type
))
2945 dtor_type
= object_type
;
2946 else if (identifier_p (dtor_type
))
2948 /* In a template, names we can't find a match for are still accepted
2949 destructor names, and we check them here. */
2950 if (check_dtor_name (object_type
, dtor_type
))
2951 dtor_type
= object_type
;
2954 if (complain
& tf_error
)
2955 error ("object type %qT does not match destructor name ~%qT",
2956 object_type
, dtor_type
);
2957 return error_mark_node
;
2961 else if (!DERIVED_FROM_P (dtor_type
, TYPE_MAIN_VARIANT (object_type
)))
2963 if (complain
& tf_error
)
2964 error ("the type being destroyed is %qT, but the destructor "
2965 "refers to %qT", TYPE_MAIN_VARIANT (object_type
), dtor_type
);
2966 return error_mark_node
;
2968 expr
= lookup_member (dtor_type
, complete_dtor_identifier
,
2969 /*protect=*/1, /*want_type=*/false,
2970 tf_warning_or_error
);
2973 if (complain
& tf_error
)
2974 cxx_incomplete_type_error (dtor_name
, dtor_type
);
2975 return error_mark_node
;
2977 expr
= (adjust_result_of_qualified_name_lookup
2978 (expr
, dtor_type
, object_type
));
2979 if (scope
== NULL_TREE
)
2980 /* We need to call adjust_result_of_qualified_name_lookup in case the
2981 destructor names a base class, but we unset BASELINK_QUALIFIED_P so
2982 that we still get virtual function binding. */
2983 BASELINK_QUALIFIED_P (expr
) = false;
2987 /* An expression of the form "A::template B" has been resolved to
2988 DECL. Issue a diagnostic if B is not a template or template
2992 check_template_keyword (tree decl
)
2994 /* The standard says:
2998 If a name prefixed by the keyword template is not a member
2999 template, the program is ill-formed.
3001 DR 228 removed the restriction that the template be a member
3004 DR 96, if accepted would add the further restriction that explicit
3005 template arguments must be provided if the template keyword is
3006 used, but, as of 2005-10-16, that DR is still in "drafting". If
3007 this DR is accepted, then the semantic checks here can be
3008 simplified, as the entity named must in fact be a template
3009 specialization, rather than, as at present, a set of overloaded
3010 functions containing at least one template function. */
3011 if (TREE_CODE (decl
) != TEMPLATE_DECL
3012 && TREE_CODE (decl
) != TEMPLATE_ID_EXPR
)
3016 if (DECL_USE_TEMPLATE (decl
)
3017 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
3020 permerror (input_location
, "%qD is not a template", decl
);
3022 else if (!is_overloaded_fn (decl
))
3023 permerror (input_location
, "%qD is not a template", decl
);
3028 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (decl
));
3029 !found
&& iter
; ++iter
)
3032 if (TREE_CODE (fn
) == TEMPLATE_DECL
3033 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
3034 || (TREE_CODE (fn
) == FUNCTION_DECL
3035 && DECL_USE_TEMPLATE (fn
)
3036 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn
))))
3040 permerror (input_location
, "%qD is not a template", decl
);
3045 /* Record that an access failure occurred on BASETYPE_PATH attempting
3046 to access DECL, where DIAG_DECL should be used for diagnostics. */
3049 access_failure_info::record_access_failure (tree basetype_path
,
3050 tree decl
, tree diag_decl
)
3052 m_was_inaccessible
= true;
3053 m_basetype_path
= basetype_path
;
3055 m_diag_decl
= diag_decl
;
3058 /* If an access failure was recorded, then attempt to locate an
3059 accessor function for the pertinent field.
3060 Otherwise, return NULL_TREE. */
3063 access_failure_info::get_any_accessor (bool const_p
) const
3065 if (!was_inaccessible_p ())
3069 = locate_field_accessor (m_basetype_path
, m_diag_decl
, const_p
);
3073 /* The accessor must itself be accessible for it to be a reasonable
3075 if (!accessible_p (m_basetype_path
, accessor
, true))
3081 /* Add a fix-it hint to RICHLOC suggesting the use of ACCESSOR_DECL, by
3082 replacing the primary location in RICHLOC with "accessor()". */
3085 access_failure_info::add_fixit_hint (rich_location
*richloc
,
3089 pp_string (&pp
, IDENTIFIER_POINTER (DECL_NAME (accessor_decl
)));
3090 pp_string (&pp
, "()");
3091 richloc
->add_fixit_replace (pp_formatted_text (&pp
));
3094 /* If an access failure was recorded, then attempt to locate an
3095 accessor function for the pertinent field, and if one is
3096 available, add a note and fix-it hint suggesting using it. */
3099 access_failure_info::maybe_suggest_accessor (bool const_p
) const
3101 tree accessor
= get_any_accessor (const_p
);
3102 if (accessor
== NULL_TREE
)
3104 rich_location
richloc (line_table
, input_location
);
3105 add_fixit_hint (&richloc
, accessor
);
3106 inform (&richloc
, "field %q#D can be accessed via %q#D",
3107 m_diag_decl
, accessor
);
3110 /* Subroutine of finish_class_member_access_expr.
3111 Issue an error about NAME not being a member of ACCESS_PATH (or
3112 OBJECT_TYPE), potentially providing a fix-it hint for misspelled
3116 complain_about_unrecognized_member (tree access_path
, tree name
,
3119 /* Attempt to provide a hint about misspelled names. */
3120 tree guessed_id
= lookup_member_fuzzy (access_path
, name
,
3121 /*want_type=*/false);
3122 if (guessed_id
== NULL_TREE
)
3125 error ("%q#T has no member named %qE",
3126 TREE_CODE (access_path
) == TREE_BINFO
3127 ? TREE_TYPE (access_path
) : object_type
, name
);
3131 location_t bogus_component_loc
= input_location
;
3132 gcc_rich_location
rich_loc (bogus_component_loc
);
3134 /* Check that the guessed name is accessible along access_path. */
3135 access_failure_info afi
;
3136 lookup_member (access_path
, guessed_id
, /*protect=*/1,
3137 /*want_type=*/false, /*complain=*/false,
3139 if (afi
.was_inaccessible_p ())
3141 tree accessor
= afi
.get_any_accessor (TYPE_READONLY (object_type
));
3144 /* The guessed name isn't directly accessible, but can be accessed
3145 via an accessor member function. */
3146 afi
.add_fixit_hint (&rich_loc
, accessor
);
3147 error_at (&rich_loc
,
3148 "%q#T has no member named %qE;"
3149 " did you mean %q#D? (accessible via %q#D)",
3150 TREE_CODE (access_path
) == TREE_BINFO
3151 ? TREE_TYPE (access_path
) : object_type
,
3152 name
, afi
.get_diag_decl (), accessor
);
3156 /* The guessed name isn't directly accessible, and no accessor
3157 member function could be found. */
3158 error_at (&rich_loc
,
3159 "%q#T has no member named %qE;"
3160 " did you mean %q#D? (not accessible from this context)",
3161 TREE_CODE (access_path
) == TREE_BINFO
3162 ? TREE_TYPE (access_path
) : object_type
,
3163 name
, afi
.get_diag_decl ());
3164 complain_about_access (afi
.get_decl (), afi
.get_diag_decl (),
3165 afi
.get_diag_decl (), false, ak_none
);
3170 /* The guessed name is directly accessible; suggest it. */
3171 rich_loc
.add_fixit_misspelled_id (bogus_component_loc
,
3173 error_at (&rich_loc
,
3174 "%q#T has no member named %qE;"
3175 " did you mean %qE?",
3176 TREE_CODE (access_path
) == TREE_BINFO
3177 ? TREE_TYPE (access_path
) : object_type
,
3182 /* This function is called by the parser to process a class member
3183 access expression of the form OBJECT.NAME. NAME is a node used by
3184 the parser to represent a name; it is not yet a DECL. It may,
3185 however, be a BASELINK where the BASELINK_FUNCTIONS is a
3186 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
3187 there is no reason to do the lookup twice, so the parser keeps the
3188 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
3189 be a template via the use of the "A::template B" syntax. */
3192 finish_class_member_access_expr (cp_expr object
, tree name
, bool template_p
,
3193 tsubst_flags_t complain
)
3198 tree access_path
= NULL_TREE
;
3199 tree orig_object
= object
;
3200 tree orig_name
= name
;
3202 if (object
== error_mark_node
|| name
== error_mark_node
)
3203 return error_mark_node
;
3205 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
3206 if (!objc_is_public (object
, name
))
3207 return error_mark_node
;
3209 object_type
= TREE_TYPE (object
);
3211 if (processing_template_decl
)
3213 if (/* If OBJECT is dependent, so is OBJECT.NAME. */
3214 type_dependent_object_expression_p (object
)
3215 /* If NAME is "f<args>", where either 'f' or 'args' is
3216 dependent, then the expression is dependent. */
3217 || (TREE_CODE (name
) == TEMPLATE_ID_EXPR
3218 && dependent_template_id_p (TREE_OPERAND (name
, 0),
3219 TREE_OPERAND (name
, 1)))
3220 /* If NAME is "T::X" where "T" is dependent, then the
3221 expression is dependent. */
3222 || (TREE_CODE (name
) == SCOPE_REF
3223 && TYPE_P (TREE_OPERAND (name
, 0))
3224 && dependent_scope_p (TREE_OPERAND (name
, 0)))
3225 /* If NAME is operator T where "T" is dependent, we can't
3226 lookup until we instantiate the T. */
3227 || (TREE_CODE (name
) == IDENTIFIER_NODE
3228 && IDENTIFIER_CONV_OP_P (name
)
3229 && dependent_type_p (TREE_TYPE (name
))))
3232 return build_min_nt_loc (UNKNOWN_LOCATION
, COMPONENT_REF
,
3233 orig_object
, orig_name
, NULL_TREE
);
3235 object
= build_non_dependent_expr (object
);
3237 else if (c_dialect_objc ()
3238 && identifier_p (name
)
3239 && (expr
= objc_maybe_build_component_ref (object
, name
)))
3244 The type of the first expression shall be "class object" (of a
3246 if (!currently_open_class (object_type
)
3247 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
3248 return error_mark_node
;
3249 if (!CLASS_TYPE_P (object_type
))
3251 if (complain
& tf_error
)
3253 if (INDIRECT_TYPE_P (object_type
)
3254 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
3255 error ("request for member %qD in %qE, which is of pointer "
3256 "type %qT (maybe you meant to use %<->%> ?)",
3257 name
, object
.get_value (), object_type
);
3259 error ("request for member %qD in %qE, which is of non-class "
3260 "type %qT", name
, object
.get_value (), object_type
);
3262 return error_mark_node
;
3265 if (BASELINK_P (name
))
3266 /* A member function that has already been looked up. */
3270 bool is_template_id
= false;
3271 tree template_args
= NULL_TREE
;
3272 tree scope
= NULL_TREE
;
3274 access_path
= object_type
;
3276 if (TREE_CODE (name
) == SCOPE_REF
)
3278 /* A qualified name. The qualifying class or namespace `S'
3279 has already been looked up; it is either a TYPE or a
3281 scope
= TREE_OPERAND (name
, 0);
3282 name
= TREE_OPERAND (name
, 1);
3284 /* If SCOPE is a namespace, then the qualified name does not
3285 name a member of OBJECT_TYPE. */
3286 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3288 if (complain
& tf_error
)
3289 error ("%<%D::%D%> is not a member of %qT",
3290 scope
, name
, object_type
);
3291 return error_mark_node
;
3295 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3297 is_template_id
= true;
3298 template_args
= TREE_OPERAND (name
, 1);
3299 name
= TREE_OPERAND (name
, 0);
3301 if (!identifier_p (name
))
3302 name
= OVL_NAME (name
);
3307 if (TREE_CODE (scope
) == ENUMERAL_TYPE
)
3309 gcc_assert (!is_template_id
);
3310 /* Looking up a member enumerator (c++/56793). */
3311 if (!TYPE_CLASS_SCOPE_P (scope
)
3312 || !DERIVED_FROM_P (TYPE_CONTEXT (scope
), object_type
))
3314 if (complain
& tf_error
)
3315 error ("%<%D::%D%> is not a member of %qT",
3316 scope
, name
, object_type
);
3317 return error_mark_node
;
3319 tree val
= lookup_enumerator (scope
, name
);
3322 if (complain
& tf_error
)
3323 error ("%qD is not a member of %qD",
3325 return error_mark_node
;
3328 if (TREE_SIDE_EFFECTS (object
))
3329 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
), object
, val
);
3333 gcc_assert (CLASS_TYPE_P (scope
));
3334 gcc_assert (identifier_p (name
) || TREE_CODE (name
) == BIT_NOT_EXPR
);
3336 if (constructor_name_p (name
, scope
))
3338 if (complain
& tf_error
)
3339 error ("cannot call constructor %<%T::%D%> directly",
3341 return error_mark_node
;
3344 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
3345 access_path
= lookup_base (object_type
, scope
, ba_check
,
3347 if (access_path
== error_mark_node
)
3348 return error_mark_node
;
3351 if (any_dependent_bases_p (object_type
))
3353 if (complain
& tf_error
)
3354 error ("%qT is not a base of %qT", scope
, object_type
);
3355 return error_mark_node
;
3359 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3361 if (dependent_type_p (object_type
))
3362 /* The destructor isn't declared yet. */
3364 member
= lookup_destructor (object
, scope
, name
, complain
);
3368 /* Look up the member. */
3369 access_failure_info afi
;
3370 if (processing_template_decl
)
3371 /* Even though this class member access expression is at this
3372 point not dependent, the member itself may be dependent, and
3373 we must not potentially push a access check for a dependent
3374 member onto TI_DEFERRED_ACCESS_CHECKS. So don't check access
3375 ahead of time here; we're going to redo this member lookup at
3376 instantiation time anyway. */
3377 push_deferring_access_checks (dk_no_check
);
3378 member
= lookup_member (access_path
, name
, /*protect=*/1,
3379 /*want_type=*/false, complain
,
3381 if (processing_template_decl
)
3382 pop_deferring_access_checks ();
3383 afi
.maybe_suggest_accessor (TYPE_READONLY (object_type
));
3384 if (member
== NULL_TREE
)
3386 if (dependent_type_p (object_type
))
3387 /* Try again at instantiation time. */
3389 if (complain
& tf_error
)
3390 complain_about_unrecognized_member (access_path
, name
,
3392 return error_mark_node
;
3394 if (member
== error_mark_node
)
3395 return error_mark_node
;
3397 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (member
)))
3398 /* Dependent type attributes on the decl mean that the TREE_TYPE is
3399 wrong, so don't use it. */
3401 if (TREE_CODE (member
) == USING_DECL
&& DECL_DEPENDENT_P (member
))
3407 tree templ
= member
;
3409 if (BASELINK_P (templ
))
3410 member
= lookup_template_function (templ
, template_args
);
3411 else if (variable_template_p (templ
))
3412 member
= (lookup_and_finish_template_variable
3413 (templ
, template_args
, complain
));
3416 if (complain
& tf_error
)
3417 error ("%qD is not a member template function", name
);
3418 return error_mark_node
;
3423 if (TREE_UNAVAILABLE (member
))
3424 error_unavailable_use (member
, NULL_TREE
);
3425 else if (TREE_DEPRECATED (member
))
3426 warn_deprecated_use (member
, NULL_TREE
);
3429 check_template_keyword (member
);
3431 expr
= build_class_member_access_expr (object
, member
, access_path
,
3432 /*preserve_reference=*/false,
3434 if (processing_template_decl
&& expr
!= error_mark_node
)
3436 if (BASELINK_P (member
))
3438 if (TREE_CODE (orig_name
) == SCOPE_REF
)
3439 BASELINK_QUALIFIED_P (member
) = 1;
3442 return build_min_non_dep (COMPONENT_REF
, expr
,
3443 orig_object
, orig_name
,
3450 /* Build a COMPONENT_REF of OBJECT and MEMBER with the appropriate
3454 build_simple_component_ref (tree object
, tree member
)
3456 tree type
= cp_build_qualified_type (TREE_TYPE (member
),
3457 cp_type_quals (TREE_TYPE (object
)));
3458 return build3_loc (input_location
,
3459 COMPONENT_REF
, type
,
3460 object
, member
, NULL_TREE
);
3463 /* Return an expression for the MEMBER_NAME field in the internal
3464 representation of PTRMEM, a pointer-to-member function. (Each
3465 pointer-to-member function type gets its own RECORD_TYPE so it is
3466 more convenient to access the fields by name than by FIELD_DECL.)
3467 This routine converts the NAME to a FIELD_DECL and then creates the
3468 node for the complete expression. */
3471 build_ptrmemfunc_access_expr (tree ptrmem
, tree member_name
)
3476 if (TREE_CODE (ptrmem
) == CONSTRUCTOR
)
3478 for (auto &e
: CONSTRUCTOR_ELTS (ptrmem
))
3479 if (e
.index
&& DECL_P (e
.index
) && DECL_NAME (e
.index
) == member_name
)
3484 /* This code is a stripped down version of
3485 build_class_member_access_expr. It does not work to use that
3486 routine directly because it expects the object to be of class
3488 ptrmem_type
= TREE_TYPE (ptrmem
);
3489 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type
));
3490 for (member
= TYPE_FIELDS (ptrmem_type
); member
;
3491 member
= DECL_CHAIN (member
))
3492 if (DECL_NAME (member
) == member_name
)
3494 return build_simple_component_ref (ptrmem
, member
);
3497 /* Return a TREE_LIST of namespace-scope overloads for the given operator,
3498 and for any other relevant operator. */
3501 op_unqualified_lookup (tree_code code
, bool is_assign
)
3503 tree lookups
= NULL_TREE
;
3505 if (cxx_dialect
>= cxx20
&& !is_assign
)
3507 if (code
== NE_EXPR
)
3509 /* != can get rewritten in terms of ==. */
3510 tree fnname
= ovl_op_identifier (false, EQ_EXPR
);
3511 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3512 lookups
= tree_cons (fnname
, fns
, lookups
);
3514 else if (code
== GT_EXPR
|| code
== LE_EXPR
3515 || code
== LT_EXPR
|| code
== GE_EXPR
)
3517 /* These can get rewritten in terms of <=>. */
3518 tree fnname
= ovl_op_identifier (false, SPACESHIP_EXPR
);
3519 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3520 lookups
= tree_cons (fnname
, fns
, lookups
);
3524 tree fnname
= ovl_op_identifier (is_assign
, code
);
3525 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3526 lookups
= tree_cons (fnname
, fns
, lookups
);
3531 return build_tree_list (NULL_TREE
, NULL_TREE
);
3534 /* Create a DEPENDENT_OPERATOR_TYPE for a dependent operator expression of
3535 the given operator. LOOKUPS, if non-NULL, is the result of phase 1
3536 name lookup for the given operator. */
3539 build_dependent_operator_type (tree lookups
, tree_code code
, bool is_assign
)
3542 /* We're partially instantiating a dependent operator expression, and
3543 LOOKUPS is the result of phase 1 name lookup that we performed
3544 earlier at template definition time, so just reuse the corresponding
3545 DEPENDENT_OPERATOR_TYPE. */
3546 return TREE_TYPE (lookups
);
3548 /* Otherwise we're processing a dependent operator expression at template
3549 definition time, so perform phase 1 name lookup now. */
3550 lookups
= op_unqualified_lookup (code
, is_assign
);
3552 tree type
= cxx_make_type (DEPENDENT_OPERATOR_TYPE
);
3553 DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (type
) = lookups
;
3554 TREE_TYPE (lookups
) = type
;
3558 /* Given an expression PTR for a pointer, return an expression
3559 for the value pointed to.
3560 ERRORSTRING is the name of the operator to appear in error messages.
3562 This function may need to overload OPERATOR_FNNAME.
3563 Must also handle REFERENCE_TYPEs for C++. */
3566 build_x_indirect_ref (location_t loc
, tree expr
, ref_operator errorstring
,
3567 tree lookups
, tsubst_flags_t complain
)
3569 tree orig_expr
= expr
;
3571 tree overload
= NULL_TREE
;
3573 if (processing_template_decl
)
3575 /* Retain the type if we know the operand is a pointer. */
3576 if (TREE_TYPE (expr
) && INDIRECT_TYPE_P (TREE_TYPE (expr
)))
3578 if (expr
== current_class_ptr
3579 || (TREE_CODE (expr
) == NOP_EXPR
3580 && TREE_OPERAND (expr
, 0) == current_class_ptr
3581 && (same_type_ignoring_top_level_qualifiers_p
3582 (TREE_TYPE (expr
), TREE_TYPE (current_class_ptr
)))))
3583 return current_class_ref
;
3584 return build_min (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (expr
)), expr
);
3586 if (type_dependent_expression_p (expr
))
3588 expr
= build_min_nt_loc (loc
, INDIRECT_REF
, expr
);
3590 = build_dependent_operator_type (lookups
, INDIRECT_REF
, false);
3593 expr
= build_non_dependent_expr (expr
);
3596 rval
= build_new_op (loc
, INDIRECT_REF
, LOOKUP_NORMAL
, expr
,
3597 NULL_TREE
, NULL_TREE
, lookups
,
3598 &overload
, complain
);
3600 rval
= cp_build_indirect_ref (loc
, expr
, errorstring
, complain
);
3602 if (processing_template_decl
&& rval
!= error_mark_node
)
3604 if (overload
!= NULL_TREE
)
3605 return (build_min_non_dep_op_overload
3606 (INDIRECT_REF
, rval
, overload
, orig_expr
));
3608 return build_min_non_dep (INDIRECT_REF
, rval
, orig_expr
);
3614 /* Like c-family strict_aliasing_warning, but don't warn for dependent
3615 types or expressions. */
3618 cp_strict_aliasing_warning (location_t loc
, tree type
, tree expr
)
3620 if (processing_template_decl
)
3624 if (dependent_type_p (type
) || type_dependent_expression_p (e
))
3627 return strict_aliasing_warning (loc
, type
, expr
);
3630 /* The implementation of the above, and of indirection implied by other
3631 constructs. If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR. */
3634 cp_build_indirect_ref_1 (location_t loc
, tree ptr
, ref_operator errorstring
,
3635 tsubst_flags_t complain
, bool do_fold
)
3639 /* RO_NULL should only be used with the folding entry points below, not
3640 cp_build_indirect_ref. */
3641 gcc_checking_assert (errorstring
!= RO_NULL
|| do_fold
);
3643 if (ptr
== current_class_ptr
3644 || (TREE_CODE (ptr
) == NOP_EXPR
3645 && TREE_OPERAND (ptr
, 0) == current_class_ptr
3646 && (same_type_ignoring_top_level_qualifiers_p
3647 (TREE_TYPE (ptr
), TREE_TYPE (current_class_ptr
)))))
3648 return current_class_ref
;
3650 pointer
= (TYPE_REF_P (TREE_TYPE (ptr
))
3651 ? ptr
: decay_conversion (ptr
, complain
));
3652 if (pointer
== error_mark_node
)
3653 return error_mark_node
;
3655 type
= TREE_TYPE (pointer
);
3657 if (INDIRECT_TYPE_P (type
))
3661 If the type of the expression is "pointer to T," the type
3662 of the result is "T." */
3663 tree t
= TREE_TYPE (type
);
3665 if ((CONVERT_EXPR_P (ptr
)
3666 || TREE_CODE (ptr
) == VIEW_CONVERT_EXPR
)
3667 && (!CLASS_TYPE_P (t
) || !CLASSTYPE_EMPTY_P (t
)))
3669 /* If a warning is issued, mark it to avoid duplicates from
3670 the backend. This only needs to be done at
3671 warn_strict_aliasing > 2. */
3672 if (warn_strict_aliasing
> 2
3673 && cp_strict_aliasing_warning (EXPR_LOCATION (ptr
),
3674 type
, TREE_OPERAND (ptr
, 0)))
3675 suppress_warning (ptr
, OPT_Wstrict_aliasing
);
3678 if (VOID_TYPE_P (t
))
3680 /* A pointer to incomplete type (other than cv void) can be
3681 dereferenced [expr.unary.op]/1 */
3682 if (complain
& tf_error
)
3683 error_at (loc
, "%qT is not a pointer-to-object type", type
);
3684 return error_mark_node
;
3686 else if (do_fold
&& TREE_CODE (pointer
) == ADDR_EXPR
3687 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
3688 /* The POINTER was something like `&x'. We simplify `*&x' to
3690 return TREE_OPERAND (pointer
, 0);
3693 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
3695 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
3696 so that we get the proper error message if the result is used
3697 to assign to. Also, &* is supposed to be a no-op. */
3698 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
3699 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
3700 TREE_SIDE_EFFECTS (ref
)
3701 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
));
3705 else if (!(complain
& tf_error
))
3706 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
3708 /* `pointer' won't be an error_mark_node if we were given a
3709 pointer to member, so it's cool to check for this here. */
3710 else if (TYPE_PTRMEM_P (type
))
3711 switch (errorstring
)
3713 case RO_ARRAY_INDEXING
:
3715 "invalid use of array indexing on pointer to member");
3718 error_at (loc
, "invalid use of unary %<*%> on pointer to member");
3720 case RO_IMPLICIT_CONVERSION
:
3721 error_at (loc
, "invalid use of implicit conversion on pointer "
3725 error_at (loc
, "left hand operand of %<->*%> must be a pointer to "
3726 "class, but is a pointer to member of type %qT", type
);
3731 else if (pointer
!= error_mark_node
)
3732 invalid_indirection_error (loc
, type
, errorstring
);
3734 return error_mark_node
;
3737 /* Entry point used by c-common, which expects folding. */
3740 build_indirect_ref (location_t loc
, tree ptr
, ref_operator errorstring
)
3742 return cp_build_indirect_ref_1 (loc
, ptr
, errorstring
,
3743 tf_warning_or_error
, true);
3746 /* Entry point used by internal indirection needs that don't correspond to any
3747 syntactic construct. */
3750 cp_build_fold_indirect_ref (tree pointer
)
3752 return cp_build_indirect_ref_1 (input_location
, pointer
, RO_NULL
,
3753 tf_warning_or_error
, true);
3756 /* Entry point used by indirection needs that correspond to some syntactic
3760 cp_build_indirect_ref (location_t loc
, tree ptr
, ref_operator errorstring
,
3761 tsubst_flags_t complain
)
3763 return cp_build_indirect_ref_1 (loc
, ptr
, errorstring
, complain
, false);
3766 /* This handles expressions of the form "a[i]", which denotes
3769 This is logically equivalent in C to *(a+i), but we may do it differently.
3770 If A is a variable or a member, we generate a primitive ARRAY_REF.
3771 This avoids forcing the array out of registers, and can work on
3772 arrays that are not lvalues (for example, members of structures returned
3775 If INDEX is of some user-defined type, it must be converted to
3776 integer type. Otherwise, to make a compatible PLUS_EXPR, it
3777 will inherit the type of the array, which will be some pointer type.
3779 LOC is the location to use in building the array reference. */
3782 cp_build_array_ref (location_t loc
, tree array
, tree idx
,
3783 tsubst_flags_t complain
)
3789 if (complain
& tf_error
)
3790 error_at (loc
, "subscript missing in array reference");
3791 return error_mark_node
;
3794 if (TREE_TYPE (array
) == error_mark_node
3795 || TREE_TYPE (idx
) == error_mark_node
)
3796 return error_mark_node
;
3798 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
3800 switch (TREE_CODE (array
))
3804 tree value
= cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3806 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3807 TREE_OPERAND (array
, 0), value
);
3808 SET_EXPR_LOCATION (ret
, loc
);
3813 ret
= build_conditional_expr
3814 (loc
, TREE_OPERAND (array
, 0),
3815 cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3817 cp_build_array_ref (loc
, TREE_OPERAND (array
, 2), idx
,
3820 protected_set_expr_location (ret
, loc
);
3827 bool non_lvalue
= convert_vector_to_array_for_subscript (loc
, &array
, idx
);
3829 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
3833 warn_array_subscript_with_type_char (loc
, idx
);
3835 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx
)))
3837 if (complain
& tf_error
)
3838 error_at (loc
, "array subscript is not an integer");
3839 return error_mark_node
;
3842 /* Apply integral promotions *after* noticing character types.
3843 (It is unclear why we do these promotions -- the standard
3844 does not say that we should. In fact, the natural thing would
3845 seem to be to convert IDX to ptrdiff_t; we're performing
3846 pointer arithmetic.) */
3847 idx
= cp_perform_integral_promotions (idx
, complain
);
3849 idx
= maybe_fold_non_dependent_expr (idx
, complain
);
3851 /* An array that is indexed by a non-constant
3852 cannot be stored in a register; we must be able to do
3853 address arithmetic on its address.
3854 Likewise an array of elements of variable size. */
3855 if (TREE_CODE (idx
) != INTEGER_CST
3856 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
3857 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
3860 if (!cxx_mark_addressable (array
, true))
3861 return error_mark_node
;
3864 /* An array that is indexed by a constant value which is not within
3865 the array bounds cannot be stored in a register either; because we
3866 would get a crash in store_bit_field/extract_bit_field when trying
3867 to access a non-existent part of the register. */
3868 if (TREE_CODE (idx
) == INTEGER_CST
3869 && TYPE_DOMAIN (TREE_TYPE (array
))
3870 && ! int_fits_type_p (idx
, TYPE_DOMAIN (TREE_TYPE (array
))))
3872 if (!cxx_mark_addressable (array
))
3873 return error_mark_node
;
3876 /* Note in C++ it is valid to subscript a `register' array, since
3877 it is valid to take the address of something with that
3878 storage specification. */
3882 while (TREE_CODE (foo
) == COMPONENT_REF
)
3883 foo
= TREE_OPERAND (foo
, 0);
3884 if (VAR_P (foo
) && DECL_REGISTER (foo
)
3885 && (complain
& tf_warning
))
3886 warning_at (loc
, OPT_Wextra
,
3887 "subscripting array declared %<register%>");
3890 type
= TREE_TYPE (TREE_TYPE (array
));
3891 rval
= build4 (ARRAY_REF
, type
, array
, idx
, NULL_TREE
, NULL_TREE
);
3892 /* Array ref is const/volatile if the array elements are
3893 or if the array is.. */
3894 TREE_READONLY (rval
)
3895 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
3896 TREE_SIDE_EFFECTS (rval
)
3897 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
3898 TREE_THIS_VOLATILE (rval
)
3899 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
3900 ret
= require_complete_type_sfinae (rval
, complain
);
3901 protected_set_expr_location (ret
, loc
);
3903 ret
= non_lvalue_loc (loc
, ret
);
3908 tree ar
= cp_default_conversion (array
, complain
);
3909 tree ind
= cp_default_conversion (idx
, complain
);
3910 tree first
= NULL_TREE
;
3912 if (flag_strong_eval_order
== 2 && TREE_SIDE_EFFECTS (ind
))
3913 ar
= first
= save_expr (ar
);
3915 /* Put the integer in IND to simplify error checking. */
3916 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
3917 std::swap (ar
, ind
);
3919 if (ar
== error_mark_node
|| ind
== error_mark_node
)
3920 return error_mark_node
;
3922 if (!TYPE_PTR_P (TREE_TYPE (ar
)))
3924 if (complain
& tf_error
)
3925 error_at (loc
, "subscripted value is neither array nor pointer");
3926 return error_mark_node
;
3928 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
3930 if (complain
& tf_error
)
3931 error_at (loc
, "array subscript is not an integer");
3932 return error_mark_node
;
3935 warn_array_subscript_with_type_char (loc
, idx
);
3937 ret
= cp_build_binary_op (input_location
, PLUS_EXPR
, ar
, ind
, complain
);
3939 ret
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (ret
), first
, ret
);
3940 ret
= cp_build_indirect_ref (loc
, ret
, RO_ARRAY_INDEXING
, complain
);
3941 protected_set_expr_location (ret
, loc
);
3943 ret
= non_lvalue_loc (loc
, ret
);
3948 /* Entry point for Obj-C++. */
3951 build_array_ref (location_t loc
, tree array
, tree idx
)
3953 return cp_build_array_ref (loc
, array
, idx
, tf_warning_or_error
);
3956 /* Resolve a pointer to member function. INSTANCE is the object
3957 instance to use, if the member points to a virtual member.
3959 This used to avoid checking for virtual functions if basetype
3960 has no virtual functions, according to an earlier ANSI draft.
3961 With the final ISO C++ rules, such an optimization is
3962 incorrect: A pointer to a derived member can be static_cast
3963 to pointer-to-base-member, as long as the dynamic object
3964 later has the right member. So now we only do this optimization
3965 when we know the dynamic type of the object. */
3968 get_member_function_from_ptrfunc (tree
*instance_ptrptr
, tree function
,
3969 tsubst_flags_t complain
)
3971 if (TREE_CODE (function
) == OFFSET_REF
)
3972 function
= TREE_OPERAND (function
, 1);
3974 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
3976 tree idx
, delta
, e1
, e2
, e3
, vtbl
;
3978 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
3979 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
3981 tree instance_ptr
= *instance_ptrptr
;
3982 tree instance_save_expr
= 0;
3983 if (instance_ptr
== error_mark_node
)
3985 if (TREE_CODE (function
) == PTRMEM_CST
)
3987 /* Extracting the function address from a pmf is only
3988 allowed with -Wno-pmf-conversions. It only works for
3990 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
), complain
);
3991 e1
= convert (fntype
, e1
);
3996 if (complain
& tf_error
)
3997 error ("object missing in use of %qE", function
);
3998 return error_mark_node
;
4002 /* True if we know that the dynamic type of the object doesn't have
4003 virtual functions, so we can assume the PFN field is a pointer. */
4004 nonvirtual
= (COMPLETE_TYPE_P (basetype
)
4005 && !TYPE_POLYMORPHIC_P (basetype
)
4006 && resolves_to_fixed_type_p (instance_ptr
, 0));
4008 /* If we don't really have an object (i.e. in an ill-formed
4009 conversion from PMF to pointer), we can't resolve virtual
4010 functions anyway. */
4011 if (!nonvirtual
&& is_dummy_object (instance_ptr
))
4014 if (TREE_SIDE_EFFECTS (instance_ptr
))
4015 instance_ptr
= instance_save_expr
= save_expr (instance_ptr
);
4017 if (TREE_SIDE_EFFECTS (function
))
4018 function
= save_expr (function
);
4020 /* Start by extracting all the information from the PMF itself. */
4021 e3
= pfn_from_ptrmemfunc (function
);
4022 delta
= delta_from_ptrmemfunc (function
);
4023 idx
= build1 (NOP_EXPR
, vtable_index_type
, e3
);
4024 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
4026 int flag_sanitize_save
;
4027 case ptrmemfunc_vbit_in_pfn
:
4028 e1
= cp_build_binary_op (input_location
,
4029 BIT_AND_EXPR
, idx
, integer_one_node
,
4031 idx
= cp_build_binary_op (input_location
,
4032 MINUS_EXPR
, idx
, integer_one_node
,
4034 if (idx
== error_mark_node
)
4035 return error_mark_node
;
4038 case ptrmemfunc_vbit_in_delta
:
4039 e1
= cp_build_binary_op (input_location
,
4040 BIT_AND_EXPR
, delta
, integer_one_node
,
4042 /* Don't instrument the RSHIFT_EXPR we're about to create because
4043 we're going to use DELTA number of times, and that wouldn't play
4044 well with SAVE_EXPRs therein. */
4045 flag_sanitize_save
= flag_sanitize
;
4047 delta
= cp_build_binary_op (input_location
,
4048 RSHIFT_EXPR
, delta
, integer_one_node
,
4050 flag_sanitize
= flag_sanitize_save
;
4051 if (delta
== error_mark_node
)
4052 return error_mark_node
;
4059 if (e1
== error_mark_node
)
4060 return error_mark_node
;
4062 /* Convert down to the right base before using the instance. A
4063 special case is that in a pointer to member of class C, C may
4064 be incomplete. In that case, the function will of course be
4065 a member of C, and no conversion is required. In fact,
4066 lookup_base will fail in that case, because incomplete
4067 classes do not have BINFOs. */
4068 if (!same_type_ignoring_top_level_qualifiers_p
4069 (basetype
, TREE_TYPE (TREE_TYPE (instance_ptr
))))
4071 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr
)),
4072 basetype
, ba_check
, NULL
, complain
);
4073 instance_ptr
= build_base_path (PLUS_EXPR
, instance_ptr
, basetype
,
4075 if (instance_ptr
== error_mark_node
)
4076 return error_mark_node
;
4078 /* ...and then the delta in the PMF. */
4079 instance_ptr
= fold_build_pointer_plus (instance_ptr
, delta
);
4081 /* Hand back the adjusted 'this' argument to our caller. */
4082 *instance_ptrptr
= instance_ptr
;
4085 /* Now just return the pointer. */
4088 /* Next extract the vtable pointer from the object. */
4089 vtbl
= build1 (NOP_EXPR
, build_pointer_type (vtbl_ptr_type_node
),
4091 vtbl
= cp_build_fold_indirect_ref (vtbl
);
4092 if (vtbl
== error_mark_node
)
4093 return error_mark_node
;
4095 /* Finally, extract the function pointer from the vtable. */
4096 e2
= fold_build_pointer_plus_loc (input_location
, vtbl
, idx
);
4097 e2
= cp_build_fold_indirect_ref (e2
);
4098 if (e2
== error_mark_node
)
4099 return error_mark_node
;
4100 TREE_CONSTANT (e2
) = 1;
4102 /* When using function descriptors, the address of the
4103 vtable entry is treated as a function pointer. */
4104 if (TARGET_VTABLE_USES_DESCRIPTORS
)
4105 e2
= build1 (NOP_EXPR
, TREE_TYPE (e2
),
4106 cp_build_addr_expr (e2
, complain
));
4108 e2
= fold_convert (TREE_TYPE (e3
), e2
);
4109 e1
= build_conditional_expr (input_location
, e1
, e2
, e3
, complain
);
4110 if (e1
== error_mark_node
)
4111 return error_mark_node
;
4113 /* Make sure this doesn't get evaluated first inside one of the
4114 branches of the COND_EXPR. */
4115 if (instance_save_expr
)
4116 e1
= build2 (COMPOUND_EXPR
, TREE_TYPE (e1
),
4117 instance_save_expr
, e1
);
4124 /* Used by the C-common bits. */
4126 build_function_call (location_t
/*loc*/,
4127 tree function
, tree params
)
4129 return cp_build_function_call (function
, params
, tf_warning_or_error
);
4132 /* Used by the C-common bits. */
4134 build_function_call_vec (location_t
/*loc*/, vec
<location_t
> /*arg_loc*/,
4135 tree function
, vec
<tree
, va_gc
> *params
,
4136 vec
<tree
, va_gc
> * /*origtypes*/, tree orig_function
)
4138 vec
<tree
, va_gc
> *orig_params
= params
;
4139 tree ret
= cp_build_function_call_vec (function
, ¶ms
,
4140 tf_warning_or_error
, orig_function
);
4142 /* cp_build_function_call_vec can reallocate PARAMS by adding
4143 default arguments. That should never happen here. Verify
4145 gcc_assert (params
== orig_params
);
4150 /* Build a function call using a tree list of arguments. */
4153 cp_build_function_call (tree function
, tree params
, tsubst_flags_t complain
)
4158 for (; params
!= NULL_TREE
; params
= TREE_CHAIN (params
))
4159 vec_safe_push (vec
, TREE_VALUE (params
));
4160 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
4164 /* Build a function call using varargs. */
4167 cp_build_function_call_nary (tree function
, tsubst_flags_t complain
, ...)
4173 va_start (args
, complain
);
4174 for (t
= va_arg (args
, tree
); t
!= NULL_TREE
; t
= va_arg (args
, tree
))
4175 vec_safe_push (vec
, t
);
4177 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
4181 /* Build a function call using a vector of arguments.
4182 If FUNCTION is the result of resolving an overloaded target built-in,
4183 ORIG_FNDECL is the original function decl, otherwise it is null.
4184 PARAMS may be NULL if there are no parameters. This changes the
4185 contents of PARAMS. */
4188 cp_build_function_call_vec (tree function
, vec
<tree
, va_gc
> **params
,
4189 tsubst_flags_t complain
, tree orig_fndecl
)
4191 tree fntype
, fndecl
;
4193 tree original
= function
;
4197 vec
<tree
, va_gc
> *allocated
= NULL
;
4200 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
4201 expressions, like those used for ObjC messenger dispatches. */
4202 if (params
!= NULL
&& !vec_safe_is_empty (*params
))
4203 function
= objc_rewrite_function_call (function
, (**params
)[0]);
4205 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4206 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
4207 if (TREE_CODE (function
) == NOP_EXPR
4208 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
4209 function
= TREE_OPERAND (function
, 0);
4211 if (TREE_CODE (function
) == FUNCTION_DECL
)
4213 if (!mark_used (function
, complain
))
4214 return error_mark_node
;
4217 /* Convert anything with function type to a pointer-to-function. */
4218 if (DECL_MAIN_P (function
))
4220 if (complain
& tf_error
)
4221 pedwarn (input_location
, OPT_Wpedantic
,
4222 "ISO C++ forbids calling %<::main%> from within program");
4224 return error_mark_node
;
4226 function
= build_addr_func (function
, complain
);
4232 function
= build_addr_func (function
, complain
);
4235 if (function
== error_mark_node
)
4236 return error_mark_node
;
4238 fntype
= TREE_TYPE (function
);
4240 if (TYPE_PTRMEMFUNC_P (fntype
))
4242 if (complain
& tf_error
)
4243 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
4244 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
4245 original
, original
);
4246 return error_mark_node
;
4249 is_method
= (TYPE_PTR_P (fntype
)
4250 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
4252 if (!(TYPE_PTRFN_P (fntype
)
4254 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
4256 if (complain
& tf_error
)
4258 if (!flag_diagnostics_show_caret
)
4259 error_at (input_location
,
4260 "%qE cannot be used as a function", original
);
4261 else if (DECL_P (original
))
4262 error_at (input_location
,
4263 "%qD cannot be used as a function", original
);
4265 error_at (input_location
,
4266 "expression cannot be used as a function");
4269 return error_mark_node
;
4272 /* fntype now gets the type of function pointed to. */
4273 fntype
= TREE_TYPE (fntype
);
4274 parm_types
= TYPE_ARG_TYPES (fntype
);
4278 allocated
= make_tree_vector ();
4279 params
= &allocated
;
4282 nargs
= convert_arguments (parm_types
, params
, fndecl
, LOOKUP_NORMAL
,
4285 return error_mark_node
;
4287 argarray
= (*params
)->address ();
4289 /* Check for errors in format strings and inappropriately
4291 bool warned_p
= check_function_arguments (input_location
, fndecl
, fntype
,
4292 nargs
, argarray
, NULL
);
4294 ret
= build_cxx_call (function
, nargs
, argarray
, complain
, orig_fndecl
);
4298 tree c
= extract_call_expr (ret
);
4299 if (TREE_CODE (c
) == CALL_EXPR
)
4300 suppress_warning (c
, OPT_Wnonnull
);
4303 if (allocated
!= NULL
)
4304 release_tree_vector (allocated
);
4309 /* Subroutine of convert_arguments.
4310 Print an error message about a wrong number of arguments. */
4313 error_args_num (location_t loc
, tree fndecl
, bool too_many_p
)
4317 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
4319 if (DECL_NAME (fndecl
) == NULL_TREE
4320 || (DECL_NAME (fndecl
)
4321 == DECL_NAME (TYPE_NAME (DECL_CONTEXT (fndecl
)))))
4324 ? G_("too many arguments to constructor %q#D")
4325 : G_("too few arguments to constructor %q#D"),
4330 ? G_("too many arguments to member function %q#D")
4331 : G_("too few arguments to member function %q#D"),
4337 ? G_("too many arguments to function %q#D")
4338 : G_("too few arguments to function %q#D"),
4340 if (!DECL_IS_UNDECLARED_BUILTIN (fndecl
))
4341 inform (DECL_SOURCE_LOCATION (fndecl
), "declared here");
4345 if (c_dialect_objc () && objc_message_selector ())
4348 ? G_("too many arguments to method %q#D")
4349 : G_("too few arguments to method %q#D"),
4350 objc_message_selector ());
4352 error_at (loc
, too_many_p
? G_("too many arguments to function")
4353 : G_("too few arguments to function"));
4357 /* Convert the actual parameter expressions in the list VALUES to the
4358 types in the list TYPELIST. The converted expressions are stored
4359 back in the VALUES vector.
4360 If parmdecls is exhausted, or when an element has NULL as its type,
4361 perform the default conversions.
4363 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
4365 This is also where warnings about wrong number of args are generated.
4367 Returns the actual number of arguments processed (which might be less
4368 than the length of the vector), or -1 on error.
4370 In C++, unspecified trailing parameters can be filled in with their
4371 default arguments, if such were specified. Do so here. */
4374 convert_arguments (tree typelist
, vec
<tree
, va_gc
> **values
, tree fndecl
,
4375 int flags
, tsubst_flags_t complain
)
4380 /* Argument passing is always copy-initialization. */
4381 flags
|= LOOKUP_ONLYCONVERTING
;
4383 for (i
= 0, typetail
= typelist
;
4384 i
< vec_safe_length (*values
);
4387 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
4388 tree val
= (**values
)[i
];
4390 if (val
== error_mark_node
|| type
== error_mark_node
)
4393 if (type
== void_type_node
)
4395 if (complain
& tf_error
)
4397 error_args_num (input_location
, fndecl
, /*too_many_p=*/true);
4404 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4405 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
4406 if (TREE_CODE (val
) == NOP_EXPR
4407 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
4408 && (type
== 0 || !TYPE_REF_P (type
)))
4409 val
= TREE_OPERAND (val
, 0);
4411 if (type
== 0 || !TYPE_REF_P (type
))
4413 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
4414 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (val
)))
4415 val
= decay_conversion (val
, complain
);
4418 if (val
== error_mark_node
)
4423 /* Formal parm type is specified by a function prototype. */
4426 if (!COMPLETE_TYPE_P (complete_type (type
)))
4428 if (complain
& tf_error
)
4430 location_t loc
= EXPR_LOC_OR_LOC (val
, input_location
);
4433 auto_diagnostic_group d
;
4435 "parameter %P of %qD has incomplete type %qT",
4437 inform (get_fndecl_argument_location (fndecl
, i
),
4441 error_at (loc
, "parameter %P has incomplete type %qT", i
,
4444 parmval
= error_mark_node
;
4448 parmval
= convert_for_initialization
4449 (NULL_TREE
, type
, val
, flags
,
4450 ICR_ARGPASS
, fndecl
, i
, complain
);
4451 parmval
= convert_for_arg_passing (type
, parmval
, complain
);
4454 if (parmval
== error_mark_node
)
4457 (**values
)[i
] = parmval
;
4461 if (fndecl
&& magic_varargs_p (fndecl
))
4462 /* Don't do ellipsis conversion for __built_in_constant_p
4463 as this will result in spurious errors for non-trivial
4465 val
= require_complete_type_sfinae (val
, complain
);
4467 val
= convert_arg_to_ellipsis (val
, complain
);
4469 (**values
)[i
] = val
;
4473 typetail
= TREE_CHAIN (typetail
);
4476 if (typetail
!= 0 && typetail
!= void_list_node
)
4478 /* See if there are default arguments that can be used. Because
4479 we hold default arguments in the FUNCTION_TYPE (which is so
4480 wrong), we can see default parameters here from deduced
4481 contexts (and via typeof) for indirect function calls.
4482 Fortunately we know whether we have a function decl to
4483 provide default arguments in a language conformant
4485 if (fndecl
&& TREE_PURPOSE (typetail
)
4486 && TREE_CODE (TREE_PURPOSE (typetail
)) != DEFERRED_PARSE
)
4488 for (; typetail
!= void_list_node
; ++i
)
4490 /* After DR777, with explicit template args we can end up with a
4491 default argument followed by no default argument. */
4492 if (!TREE_PURPOSE (typetail
))
4495 = convert_default_arg (TREE_VALUE (typetail
),
4496 TREE_PURPOSE (typetail
),
4497 fndecl
, i
, complain
);
4499 if (parmval
== error_mark_node
)
4502 vec_safe_push (*values
, parmval
);
4503 typetail
= TREE_CHAIN (typetail
);
4504 /* ends with `...'. */
4505 if (typetail
== NULL_TREE
)
4510 if (typetail
&& typetail
!= void_list_node
)
4512 if (complain
& tf_error
)
4513 error_args_num (input_location
, fndecl
, /*too_many_p=*/false);
4521 /* Build a binary-operation expression, after performing default
4522 conversions on the operands. CODE is the kind of expression to
4523 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
4524 are the tree codes which correspond to ARG1 and ARG2 when issuing
4525 warnings about possibly misplaced parentheses. They may differ
4526 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
4527 folding (e.g., if the parser sees "a | 1 + 1", it may call this
4528 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
4529 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
4530 ARG2_CODE as ERROR_MARK. */
4533 build_x_binary_op (const op_location_t
&loc
, enum tree_code code
, tree arg1
,
4534 enum tree_code arg1_code
, tree arg2
,
4535 enum tree_code arg2_code
, tree lookups
,
4536 tree
*overload_p
, tsubst_flags_t complain
)
4541 tree overload
= NULL_TREE
;
4546 if (processing_template_decl
)
4548 if (type_dependent_expression_p (arg1
)
4549 || type_dependent_expression_p (arg2
))
4551 expr
= build_min_nt_loc (loc
, code
, arg1
, arg2
);
4553 = build_dependent_operator_type (lookups
, code
, false);
4556 arg1
= build_non_dependent_expr (arg1
);
4557 arg2
= build_non_dependent_expr (arg2
);
4560 if (code
== DOTSTAR_EXPR
)
4561 expr
= build_m_component_ref (arg1
, arg2
, complain
);
4563 expr
= build_new_op (loc
, code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
4564 lookups
, &overload
, complain
);
4566 if (overload_p
!= NULL
)
4567 *overload_p
= overload
;
4569 /* Check for cases such as x+y<<z which users are likely to
4570 misinterpret. But don't warn about obj << x + y, since that is a
4571 common idiom for I/O. */
4572 if (warn_parentheses
4573 && (complain
& tf_warning
)
4574 && !processing_template_decl
4575 && !error_operand_p (arg1
)
4576 && !error_operand_p (arg2
)
4577 && (code
!= LSHIFT_EXPR
4578 || !CLASS_TYPE_P (TREE_TYPE (arg1
))))
4579 warn_about_parentheses (loc
, code
, arg1_code
, orig_arg1
,
4580 arg2_code
, orig_arg2
);
4582 if (processing_template_decl
&& expr
!= error_mark_node
)
4584 if (overload
!= NULL_TREE
)
4585 return (build_min_non_dep_op_overload
4586 (code
, expr
, overload
, orig_arg1
, orig_arg2
));
4588 return build_min_non_dep (code
, expr
, orig_arg1
, orig_arg2
);
4594 /* Build and return an ARRAY_REF expression. */
4597 build_x_array_ref (location_t loc
, tree arg1
, tree arg2
,
4598 tsubst_flags_t complain
)
4600 tree orig_arg1
= arg1
;
4601 tree orig_arg2
= arg2
;
4603 tree overload
= NULL_TREE
;
4605 if (processing_template_decl
)
4607 if (type_dependent_expression_p (arg1
)
4608 || type_dependent_expression_p (arg2
))
4609 return build_min_nt_loc (loc
, ARRAY_REF
, arg1
, arg2
,
4610 NULL_TREE
, NULL_TREE
);
4611 arg1
= build_non_dependent_expr (arg1
);
4612 arg2
= build_non_dependent_expr (arg2
);
4615 expr
= build_new_op (loc
, ARRAY_REF
, LOOKUP_NORMAL
, arg1
, arg2
,
4616 NULL_TREE
, NULL_TREE
, &overload
, complain
);
4618 if (processing_template_decl
&& expr
!= error_mark_node
)
4620 if (overload
!= NULL_TREE
)
4621 return (build_min_non_dep_op_overload
4622 (ARRAY_REF
, expr
, overload
, orig_arg1
, orig_arg2
));
4624 return build_min_non_dep (ARRAY_REF
, expr
, orig_arg1
, orig_arg2
,
4625 NULL_TREE
, NULL_TREE
);
4630 /* Return whether OP is an expression of enum type cast to integer
4631 type. In C++ even unsigned enum types are cast to signed integer
4632 types. We do not want to issue warnings about comparisons between
4633 signed and unsigned types when one of the types is an enum type.
4634 Those warnings are always false positives in practice. */
4637 enum_cast_to_int (tree op
)
4639 if (CONVERT_EXPR_P (op
)
4640 && TREE_TYPE (op
) == integer_type_node
4641 && TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == ENUMERAL_TYPE
4642 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 0))))
4645 /* The cast may have been pushed into a COND_EXPR. */
4646 if (TREE_CODE (op
) == COND_EXPR
)
4647 return (enum_cast_to_int (TREE_OPERAND (op
, 1))
4648 || enum_cast_to_int (TREE_OPERAND (op
, 2)));
4653 /* For the c-common bits. */
4655 build_binary_op (location_t location
, enum tree_code code
, tree op0
, tree op1
,
4658 return cp_build_binary_op (location
, code
, op0
, op1
, tf_warning_or_error
);
4661 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
4662 into a value of TYPE type. Comparison is done via VEC_COND_EXPR. */
4665 build_vec_cmp (tree_code code
, tree type
,
4666 tree arg0
, tree arg1
)
4668 tree zero_vec
= build_zero_cst (type
);
4669 tree minus_one_vec
= build_minus_one_cst (type
);
4670 tree cmp_type
= truth_type_for (type
);
4671 tree cmp
= build2 (code
, cmp_type
, arg0
, arg1
);
4672 return build3 (VEC_COND_EXPR
, type
, cmp
, minus_one_vec
, zero_vec
);
4675 /* Possibly warn about an address never being NULL. */
4678 warn_for_null_address (location_t location
, tree op
, tsubst_flags_t complain
)
4680 /* Prevent warnings issued for macro expansion. */
4682 || (complain
& tf_warning
) == 0
4683 || c_inhibit_evaluation_warnings
!= 0
4684 || from_macro_expansion_at (location
)
4685 || warning_suppressed_p (op
, OPT_Waddress
))
4688 if (TREE_CODE (op
) == NON_DEPENDENT_EXPR
)
4689 op
= TREE_OPERAND (op
, 0);
4691 tree cop
= fold_for_warn (op
);
4693 if (TREE_CODE (cop
) == NON_LVALUE_EXPR
)
4694 /* Unwrap the expression for C++ 98. */
4695 cop
= TREE_OPERAND (cop
, 0);
4697 if (TREE_CODE (cop
) == PTRMEM_CST
)
4699 /* The address of a nonstatic data member is never null. */
4700 warning_at (location
, OPT_Waddress
,
4701 "the address %qE will never be NULL",
4706 if (TREE_CODE (cop
) == NOP_EXPR
)
4708 /* Allow casts to intptr_t to suppress the warning. */
4709 tree type
= TREE_TYPE (cop
);
4710 if (TREE_CODE (type
) == INTEGER_TYPE
)
4716 bool warned
= false;
4717 if (TREE_CODE (cop
) == ADDR_EXPR
)
4719 cop
= TREE_OPERAND (cop
, 0);
4721 /* Set to true in the loop below if OP dereferences its operand.
4722 In such a case the ultimate target need not be a decl for
4723 the null [in]equality test to be necessarily constant. */
4726 /* Get the outermost array or object, or member. */
4727 while (handled_component_p (cop
))
4729 if (TREE_CODE (cop
) == COMPONENT_REF
)
4731 /* Get the member (its address is never null). */
4732 cop
= TREE_OPERAND (cop
, 1);
4736 /* Get the outer array/object to refer to in the warning. */
4737 cop
= TREE_OPERAND (cop
, 0);
4741 if ((!deref
&& !decl_with_nonnull_addr_p (cop
))
4742 || from_macro_expansion_at (location
)
4743 || warning_suppressed_p (cop
, OPT_Waddress
))
4746 warned
= warning_at (location
, OPT_Waddress
,
4747 "the address of %qD will never be NULL", cop
);
4750 else if (TREE_CODE (cop
) == POINTER_PLUS_EXPR
)
4752 /* Adding zero to the null pointer is well-defined in C++. When
4753 the offset is unknown (i.e., not a constant) warn anyway since
4754 it's less likely that the pointer operand is null than not. */
4755 tree off
= TREE_OPERAND (cop
, 1);
4756 if (!integer_zerop (off
)
4757 && !warning_suppressed_p (cop
, OPT_Waddress
))
4758 warning_at (location
, OPT_Waddress
, "comparing the result of pointer "
4759 "addition %qE and NULL", cop
);
4762 else if (CONVERT_EXPR_P (op
)
4763 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (op
, 0))))
4767 if (TREE_CODE (op
) == COMPONENT_REF
)
4768 op
= TREE_OPERAND (op
, 1);
4771 warned
= warning_at (location
, OPT_Waddress
,
4772 "the compiler can assume that the address of "
4773 "%qD will never be NULL", op
);
4776 if (warned
&& DECL_P (op
))
4777 inform (DECL_SOURCE_LOCATION (op
), "%qD declared here", op
);
4780 /* Warn about [expr.arith.conv]/2: If one operand is of enumeration type and
4781 the other operand is of a different enumeration type or a floating-point
4782 type, this behavior is deprecated ([depr.arith.conv.enum]). CODE is the
4783 code of the binary operation, TYPE0 and TYPE1 are the types of the operands,
4784 and LOC is the location for the whole binary expression.
4785 TODO: Consider combining this with -Wenum-compare in build_new_op_1. */
4788 do_warn_enum_conversions (location_t loc
, enum tree_code code
, tree type0
,
4791 if (TREE_CODE (type0
) == ENUMERAL_TYPE
4792 && TREE_CODE (type1
) == ENUMERAL_TYPE
4793 && TYPE_MAIN_VARIANT (type0
) != TYPE_MAIN_VARIANT (type1
))
4795 /* In C++20, -Wdeprecated-enum-enum-conversion is on by default.
4796 Otherwise, warn if -Wenum-conversion is on. */
4798 if (warn_deprecated_enum_enum_conv
)
4799 opt
= OPT_Wdeprecated_enum_enum_conversion
;
4800 else if (warn_enum_conversion
)
4801 opt
= OPT_Wenum_conversion
;
4813 /* Comparisons are handled by -Wenum-compare. */
4815 case SPACESHIP_EXPR
:
4816 /* This is invalid, don't warn. */
4821 warning_at (loc
, opt
, "bitwise operation between different "
4822 "enumeration types %qT and %qT is deprecated",
4826 warning_at (loc
, opt
, "arithmetic between different enumeration "
4827 "types %qT and %qT is deprecated", type0
, type1
);
4831 else if ((TREE_CODE (type0
) == ENUMERAL_TYPE
4832 && TREE_CODE (type1
) == REAL_TYPE
)
4833 || (TREE_CODE (type0
) == REAL_TYPE
4834 && TREE_CODE (type1
) == ENUMERAL_TYPE
))
4836 const bool enum_first_p
= TREE_CODE (type0
) == ENUMERAL_TYPE
;
4837 /* In C++20, -Wdeprecated-enum-float-conversion is on by default.
4838 Otherwise, warn if -Wenum-conversion is on. */
4840 if (warn_deprecated_enum_float_conv
)
4841 opt
= OPT_Wdeprecated_enum_float_conversion
;
4842 else if (warn_enum_conversion
)
4843 opt
= OPT_Wenum_conversion
;
4856 warning_at (loc
, opt
, "comparison of enumeration type %qT with "
4857 "floating-point type %qT is deprecated",
4860 warning_at (loc
, opt
, "comparison of floating-point type %qT "
4861 "with enumeration type %qT is deprecated",
4864 case SPACESHIP_EXPR
:
4865 /* This is invalid, don't warn. */
4869 warning_at (loc
, opt
, "arithmetic between enumeration type %qT "
4870 "and floating-point type %qT is deprecated",
4873 warning_at (loc
, opt
, "arithmetic between floating-point type %qT "
4874 "and enumeration type %qT is deprecated",
4881 /* Build a binary-operation expression without default conversions.
4882 CODE is the kind of expression to build.
4883 LOCATION is the location_t of the operator in the source code.
4884 This function differs from `build' in several ways:
4885 the data type of the result is computed and recorded in it,
4886 warnings are generated if arg data types are invalid,
4887 special handling for addition and subtraction of pointers is known,
4888 and some optimization is done (operations on narrow ints
4889 are done in the narrower type when that gives the same result).
4890 Constant folding is also done before the result is returned.
4892 Note that the operands will never have enumeral types
4893 because either they have just had the default conversions performed
4894 or they have both just been converted to some other type in which
4895 the arithmetic is to be done.
4897 C++: must do special pointer arithmetic when implementing
4898 multiple inheritance, and deal with pointer to member functions. */
4901 cp_build_binary_op (const op_location_t
&location
,
4902 enum tree_code code
, tree orig_op0
, tree orig_op1
,
4903 tsubst_flags_t complain
)
4906 enum tree_code code0
, code1
;
4908 const char *invalid_op_diag
;
4910 /* Expression code to give to the expression when it is built.
4911 Normally this is CODE, which is what the caller asked for,
4912 but in some special cases we change it. */
4913 enum tree_code resultcode
= code
;
4915 /* Data type in which the computation is to be performed.
4916 In the simplest cases this is the common type of the arguments. */
4917 tree result_type
= NULL_TREE
;
4919 /* Nonzero means operands have already been type-converted
4920 in whatever way is necessary.
4921 Zero means they need to be converted to RESULT_TYPE. */
4924 /* Nonzero means create the expression with this type, rather than
4926 tree build_type
= 0;
4928 /* Nonzero means after finally constructing the expression
4929 convert it to this type. */
4930 tree final_type
= 0;
4932 tree result
, result_ovl
;
4934 /* Nonzero if this is an operation like MIN or MAX which can
4935 safely be computed in short if both args are promoted shorts.
4936 Also implies COMMON.
4937 -1 indicates a bitwise operation; this makes a difference
4938 in the exact conditions for when it is safe to do the operation
4939 in a narrower mode. */
4942 /* Nonzero if this is a comparison operation;
4943 if both args are promoted shorts, compare the original shorts.
4944 Also implies COMMON. */
4945 int short_compare
= 0;
4947 /* Nonzero if this is a right-shift operation, which can be computed on the
4948 original short and then promoted if the operand is a promoted short. */
4949 int short_shift
= 0;
4951 /* Nonzero means set RESULT_TYPE to the common type of the args. */
4954 /* True if both operands have arithmetic type. */
4955 bool arithmetic_types_p
;
4957 /* Remember whether we're doing / or %. */
4958 bool doing_div_or_mod
= false;
4960 /* Remember whether we're doing << or >>. */
4961 bool doing_shift
= false;
4963 /* Tree holding instrumentation expression. */
4964 tree instrument_expr
= NULL_TREE
;
4966 /* Apply default conversions. */
4967 op0
= resolve_nondeduced_context (orig_op0
, complain
);
4968 op1
= resolve_nondeduced_context (orig_op1
, complain
);
4970 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
4971 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
4972 || code
== TRUTH_XOR_EXPR
)
4974 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
4975 op0
= decay_conversion (op0
, complain
);
4976 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
4977 op1
= decay_conversion (op1
, complain
);
4981 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
4982 op0
= cp_default_conversion (op0
, complain
);
4983 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
4984 op1
= cp_default_conversion (op1
, complain
);
4987 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
4988 STRIP_TYPE_NOPS (op0
);
4989 STRIP_TYPE_NOPS (op1
);
4991 /* DTRT if one side is an overloaded function, but complain about it. */
4992 if (type_unknown_p (op0
))
4994 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, tf_none
);
4995 if (t
!= error_mark_node
)
4997 if (complain
& tf_error
)
4998 permerror (location
,
4999 "assuming cast to type %qT from overloaded function",
5004 if (type_unknown_p (op1
))
5006 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, tf_none
);
5007 if (t
!= error_mark_node
)
5009 if (complain
& tf_error
)
5010 permerror (location
,
5011 "assuming cast to type %qT from overloaded function",
5017 type0
= TREE_TYPE (op0
);
5018 type1
= TREE_TYPE (op1
);
5020 /* The expression codes of the data types of the arguments tell us
5021 whether the arguments are integers, floating, pointers, etc. */
5022 code0
= TREE_CODE (type0
);
5023 code1
= TREE_CODE (type1
);
5025 /* If an error was already reported for one of the arguments,
5026 avoid reporting another error. */
5027 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
5028 return error_mark_node
;
5030 if ((invalid_op_diag
5031 = targetm
.invalid_binary_op (code
, type0
, type1
)))
5033 if (complain
& tf_error
)
5034 error (invalid_op_diag
);
5035 return error_mark_node
;
5038 /* Issue warnings about peculiar, but valid, uses of NULL. */
5039 if ((null_node_p (orig_op0
) || null_node_p (orig_op1
))
5040 /* It's reasonable to use pointer values as operands of &&
5041 and ||, so NULL is no exception. */
5042 && code
!= TRUTH_ANDIF_EXPR
&& code
!= TRUTH_ORIF_EXPR
5043 && ( /* Both are NULL (or 0) and the operation was not a
5044 comparison or a pointer subtraction. */
5045 (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)
5046 && code
!= EQ_EXPR
&& code
!= NE_EXPR
&& code
!= MINUS_EXPR
)
5047 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
5048 || (!null_ptr_cst_p (orig_op0
)
5049 && !TYPE_PTR_OR_PTRMEM_P (type0
))
5050 || (!null_ptr_cst_p (orig_op1
)
5051 && !TYPE_PTR_OR_PTRMEM_P (type1
)))
5052 && (complain
& tf_warning
))
5055 expansion_point_location_if_in_system_header (input_location
);
5057 warning_at (loc
, OPT_Wpointer_arith
, "NULL used in arithmetic");
5060 /* In case when one of the operands of the binary operation is
5061 a vector and another is a scalar -- convert scalar to vector. */
5062 if ((gnu_vector_type_p (type0
) && code1
!= VECTOR_TYPE
)
5063 || (gnu_vector_type_p (type1
) && code0
!= VECTOR_TYPE
))
5065 enum stv_conv convert_flag
= scalar_to_vector (location
, code
, op0
, op1
,
5066 complain
& tf_error
);
5068 switch (convert_flag
)
5071 return error_mark_node
;
5074 op0
= convert (TREE_TYPE (type1
), op0
);
5075 op0
= save_expr (op0
);
5076 op0
= build_vector_from_val (type1
, op0
);
5077 type0
= TREE_TYPE (op0
);
5078 code0
= TREE_CODE (type0
);
5084 op1
= convert (TREE_TYPE (type0
), op1
);
5085 op1
= save_expr (op1
);
5086 op1
= build_vector_from_val (type0
, op1
);
5087 type1
= TREE_TYPE (op1
);
5088 code1
= TREE_CODE (type1
);
5100 /* Subtraction of two similar pointers.
5101 We must subtract them as integers, then divide by object size. */
5102 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
5103 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
5106 result
= pointer_diff (location
, op0
, op1
,
5107 common_pointer_type (type0
, type1
), complain
,
5109 if (instrument_expr
!= NULL
)
5110 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
5111 instrument_expr
, result
);
5115 /* In all other cases except pointer - int, the usual arithmetic
5117 else if (!(code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
))
5122 /* The pointer - int case is just like pointer + int; fall
5126 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
5127 && (code0
== INTEGER_TYPE
|| code1
== INTEGER_TYPE
))
5131 ptr_operand
= ((code0
== POINTER_TYPE
) ? op0
: op1
);
5132 int_operand
= ((code0
== INTEGER_TYPE
) ? op0
: op1
);
5133 if (processing_template_decl
)
5135 result_type
= TREE_TYPE (ptr_operand
);
5138 return cp_pointer_int_sum (location
, code
,
5150 case TRUNC_DIV_EXPR
:
5152 case FLOOR_DIV_EXPR
:
5153 case ROUND_DIV_EXPR
:
5154 case EXACT_DIV_EXPR
:
5155 if (TREE_CODE (op0
) == SIZEOF_EXPR
&& TREE_CODE (op1
) == SIZEOF_EXPR
)
5157 tree type0
= TREE_OPERAND (op0
, 0);
5158 tree type1
= TREE_OPERAND (op1
, 0);
5159 tree first_arg
= tree_strip_any_location_wrapper (type0
);
5160 if (!TYPE_P (type0
))
5161 type0
= TREE_TYPE (type0
);
5162 if (!TYPE_P (type1
))
5163 type1
= TREE_TYPE (type1
);
5164 if (INDIRECT_TYPE_P (type0
) && same_type_p (TREE_TYPE (type0
), type1
))
5166 if (!(TREE_CODE (first_arg
) == PARM_DECL
5167 && DECL_ARRAY_PARAMETER_P (first_arg
)
5168 && warn_sizeof_array_argument
)
5169 && (complain
& tf_warning
))
5171 auto_diagnostic_group d
;
5172 if (warning_at (location
, OPT_Wsizeof_pointer_div
,
5173 "division %<sizeof (%T) / sizeof (%T)%> does "
5174 "not compute the number of array elements",
5176 if (DECL_P (first_arg
))
5177 inform (DECL_SOURCE_LOCATION (first_arg
),
5178 "first %<sizeof%> operand was declared here");
5181 else if (TREE_CODE (type0
) == ARRAY_TYPE
5182 && !char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type0
)))
5183 /* Set by finish_parenthesized_expr. */
5184 && !warning_suppressed_p (op1
, OPT_Wsizeof_array_div
)
5185 && (complain
& tf_warning
))
5186 maybe_warn_sizeof_array_div (location
, first_arg
, type0
,
5187 op1
, non_reference (type1
));
5190 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
5191 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
5192 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5193 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
5195 enum tree_code tcode0
= code0
, tcode1
= code1
;
5196 doing_div_or_mod
= true;
5197 warn_for_div_by_zero (location
, fold_for_warn (op1
));
5199 if (tcode0
== COMPLEX_TYPE
|| tcode0
== VECTOR_TYPE
)
5200 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
5201 if (tcode1
== COMPLEX_TYPE
|| tcode1
== VECTOR_TYPE
)
5202 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
5204 if (!(tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
))
5205 resultcode
= RDIV_EXPR
;
5208 /* When dividing two signed integers, we have to promote to int.
5209 unless we divide by a constant != -1. Note that default
5210 conversion will have been performed on the operands at this
5211 point, so we have to dig out the original type to find out if
5213 tree stripped_op1
= tree_strip_any_location_wrapper (op1
);
5214 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
5215 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
5216 || (TREE_CODE (stripped_op1
) == INTEGER_CST
5217 && ! integer_all_onesp (stripped_op1
)));
5227 if ((code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5228 || (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
5229 && !VECTOR_FLOAT_TYPE_P (type0
)
5230 && !VECTOR_FLOAT_TYPE_P (type1
)))
5234 case TRUNC_MOD_EXPR
:
5235 case FLOOR_MOD_EXPR
:
5236 doing_div_or_mod
= true;
5237 warn_for_div_by_zero (location
, fold_for_warn (op1
));
5239 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
5240 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5241 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
5243 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5245 /* Although it would be tempting to shorten always here, that loses
5246 on some targets, since the modulo instruction is undefined if the
5247 quotient can't be represented in the computation mode. We shorten
5248 only if unsigned or if dividing by something we know != -1. */
5249 tree stripped_op1
= tree_strip_any_location_wrapper (op1
);
5250 shorten
= ((TREE_CODE (op0
) == NOP_EXPR
5251 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0
, 0))))
5252 || (TREE_CODE (stripped_op1
) == INTEGER_CST
5253 && ! integer_all_onesp (stripped_op1
)));
5258 case TRUTH_ANDIF_EXPR
:
5259 case TRUTH_ORIF_EXPR
:
5260 case TRUTH_AND_EXPR
:
5262 if (!VECTOR_TYPE_P (type0
) && gnu_vector_type_p (type1
))
5264 if (!COMPARISON_CLASS_P (op1
))
5265 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
5266 build_zero_cst (type1
), complain
);
5267 if (code
== TRUTH_ANDIF_EXPR
)
5269 tree z
= build_zero_cst (TREE_TYPE (op1
));
5270 return build_conditional_expr (location
, op0
, op1
, z
, complain
);
5272 else if (code
== TRUTH_ORIF_EXPR
)
5274 tree m1
= build_all_ones_cst (TREE_TYPE (op1
));
5275 return build_conditional_expr (location
, op0
, m1
, op1
, complain
);
5280 if (gnu_vector_type_p (type0
)
5281 && (!VECTOR_TYPE_P (type1
) || gnu_vector_type_p (type1
)))
5283 if (!COMPARISON_CLASS_P (op0
))
5284 op0
= cp_build_binary_op (EXPR_LOCATION (op0
), NE_EXPR
, op0
,
5285 build_zero_cst (type0
), complain
);
5286 if (!VECTOR_TYPE_P (type1
))
5288 tree m1
= build_all_ones_cst (TREE_TYPE (op0
));
5289 tree z
= build_zero_cst (TREE_TYPE (op0
));
5290 op1
= build_conditional_expr (location
, op1
, m1
, z
, complain
);
5292 else if (!COMPARISON_CLASS_P (op1
))
5293 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
5294 build_zero_cst (type1
), complain
);
5296 if (code
== TRUTH_ANDIF_EXPR
)
5297 code
= BIT_AND_EXPR
;
5298 else if (code
== TRUTH_ORIF_EXPR
)
5299 code
= BIT_IOR_EXPR
;
5303 return cp_build_binary_op (location
, code
, op0
, op1
, complain
);
5306 result_type
= boolean_type_node
;
5309 /* Shift operations: result has same type as first operand;
5310 always convert second operand to int.
5311 Also set SHORT_SHIFT if shifting rightward. */
5314 if (gnu_vector_type_p (type0
)
5315 && code1
== INTEGER_TYPE
5316 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
5318 result_type
= type0
;
5321 else if (gnu_vector_type_p (type0
)
5322 && gnu_vector_type_p (type1
)
5323 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5324 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
5325 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
5326 TYPE_VECTOR_SUBPARTS (type1
)))
5328 result_type
= type0
;
5331 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5333 tree const_op1
= fold_for_warn (op1
);
5334 if (TREE_CODE (const_op1
) != INTEGER_CST
)
5336 result_type
= type0
;
5338 if (TREE_CODE (const_op1
) == INTEGER_CST
)
5340 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
5342 if ((complain
& tf_warning
)
5343 && c_inhibit_evaluation_warnings
== 0)
5344 warning_at (location
, OPT_Wshift_count_negative
,
5345 "right shift count is negative");
5349 if (!integer_zerop (const_op1
))
5352 if (compare_tree_int (const_op1
, TYPE_PRECISION (type0
)) >= 0
5353 && (complain
& tf_warning
)
5354 && c_inhibit_evaluation_warnings
== 0)
5355 warning_at (location
, OPT_Wshift_count_overflow
,
5356 "right shift count >= width of type");
5359 /* Avoid converting op1 to result_type later. */
5365 if (gnu_vector_type_p (type0
)
5366 && code1
== INTEGER_TYPE
5367 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
5369 result_type
= type0
;
5372 else if (gnu_vector_type_p (type0
)
5373 && gnu_vector_type_p (type1
)
5374 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5375 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
5376 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
5377 TYPE_VECTOR_SUBPARTS (type1
)))
5379 result_type
= type0
;
5382 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5384 tree const_op0
= fold_for_warn (op0
);
5385 if (TREE_CODE (const_op0
) != INTEGER_CST
)
5387 tree const_op1
= fold_for_warn (op1
);
5388 if (TREE_CODE (const_op1
) != INTEGER_CST
)
5390 result_type
= type0
;
5392 if (TREE_CODE (const_op0
) == INTEGER_CST
5393 && tree_int_cst_sgn (const_op0
) < 0
5394 && !TYPE_OVERFLOW_WRAPS (type0
)
5395 && (complain
& tf_warning
)
5396 && c_inhibit_evaluation_warnings
== 0)
5397 warning_at (location
, OPT_Wshift_negative_value
,
5398 "left shift of negative value");
5399 if (TREE_CODE (const_op1
) == INTEGER_CST
)
5401 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
5403 if ((complain
& tf_warning
)
5404 && c_inhibit_evaluation_warnings
== 0)
5405 warning_at (location
, OPT_Wshift_count_negative
,
5406 "left shift count is negative");
5408 else if (compare_tree_int (const_op1
,
5409 TYPE_PRECISION (type0
)) >= 0)
5411 if ((complain
& tf_warning
)
5412 && c_inhibit_evaluation_warnings
== 0)
5413 warning_at (location
, OPT_Wshift_count_overflow
,
5414 "left shift count >= width of type");
5416 else if (TREE_CODE (const_op0
) == INTEGER_CST
5417 && (complain
& tf_warning
))
5418 maybe_warn_shift_overflow (location
, const_op0
, const_op1
);
5420 /* Avoid converting op1 to result_type later. */
5427 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
5428 goto vector_compare
;
5429 if ((complain
& tf_warning
)
5430 && c_inhibit_evaluation_warnings
== 0
5431 && (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
)))
5432 warning_at (location
, OPT_Wfloat_equal
,
5433 "comparing floating-point with %<==%> "
5434 "or %<!=%> is unsafe");
5435 if (complain
& tf_warning
)
5437 tree stripped_orig_op0
= tree_strip_any_location_wrapper (orig_op0
);
5438 tree stripped_orig_op1
= tree_strip_any_location_wrapper (orig_op1
);
5439 if ((TREE_CODE (stripped_orig_op0
) == STRING_CST
5440 && !integer_zerop (cp_fully_fold (op1
)))
5441 || (TREE_CODE (stripped_orig_op1
) == STRING_CST
5442 && !integer_zerop (cp_fully_fold (op0
))))
5443 warning_at (location
, OPT_Waddress
,
5444 "comparison with string literal results in "
5445 "unspecified behavior");
5446 else if (warn_array_compare
5447 && TREE_CODE (TREE_TYPE (orig_op0
)) == ARRAY_TYPE
5448 && TREE_CODE (TREE_TYPE (orig_op1
)) == ARRAY_TYPE
)
5449 do_warn_array_compare (location
, code
, stripped_orig_op0
,
5453 build_type
= boolean_type_node
;
5454 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
5455 || code0
== COMPLEX_TYPE
|| code0
== ENUMERAL_TYPE
)
5456 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5457 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
))
5459 else if (((code0
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type0
))
5460 && null_ptr_cst_p (orig_op1
))
5461 /* Handle, eg, (void*)0 (c++/43906), and more. */
5462 || (code0
== POINTER_TYPE
5463 && TYPE_PTR_P (type1
) && integer_zerop (op1
)))
5465 if (TYPE_PTR_P (type1
))
5466 result_type
= composite_pointer_type (location
,
5467 type0
, type1
, op0
, op1
,
5468 CPO_COMPARISON
, complain
);
5470 result_type
= type0
;
5472 if (char_type_p (TREE_TYPE (orig_op1
)))
5474 auto_diagnostic_group d
;
5475 if (warning_at (location
, OPT_Wpointer_compare
,
5476 "comparison between pointer and zero character "
5479 "did you mean to dereference the pointer?");
5481 warn_for_null_address (location
, op0
, complain
);
5483 else if (((code1
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type1
))
5484 && null_ptr_cst_p (orig_op0
))
5485 /* Handle, eg, (void*)0 (c++/43906), and more. */
5486 || (code1
== POINTER_TYPE
5487 && TYPE_PTR_P (type0
) && integer_zerop (op0
)))
5489 if (TYPE_PTR_P (type0
))
5490 result_type
= composite_pointer_type (location
,
5491 type0
, type1
, op0
, op1
,
5492 CPO_COMPARISON
, complain
);
5494 result_type
= type1
;
5496 if (char_type_p (TREE_TYPE (orig_op0
)))
5498 auto_diagnostic_group d
;
5499 if (warning_at (location
, OPT_Wpointer_compare
,
5500 "comparison between pointer and zero character "
5503 "did you mean to dereference the pointer?");
5505 warn_for_null_address (location
, op1
, complain
);
5507 else if ((code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
5508 || (TYPE_PTRDATAMEM_P (type0
) && TYPE_PTRDATAMEM_P (type1
)))
5509 result_type
= composite_pointer_type (location
,
5510 type0
, type1
, op0
, op1
,
5511 CPO_COMPARISON
, complain
);
5512 else if (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
))
5513 /* One of the operands must be of nullptr_t type. */
5514 result_type
= TREE_TYPE (nullptr_node
);
5515 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5517 result_type
= type0
;
5518 if (complain
& tf_error
)
5519 permerror (location
, "ISO C++ forbids comparison between "
5520 "pointer and integer");
5522 return error_mark_node
;
5524 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
5526 result_type
= type1
;
5527 if (complain
& tf_error
)
5528 permerror (location
, "ISO C++ forbids comparison between "
5529 "pointer and integer");
5531 return error_mark_node
;
5533 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (orig_op1
))
5535 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
5536 == ptrmemfunc_vbit_in_delta
)
5538 tree pfn0
, delta0
, e1
, e2
;
5540 if (TREE_SIDE_EFFECTS (op0
))
5541 op0
= cp_save_expr (op0
);
5543 pfn0
= pfn_from_ptrmemfunc (op0
);
5544 delta0
= delta_from_ptrmemfunc (op0
);
5545 e1
= cp_build_binary_op (location
,
5548 build_zero_cst (TREE_TYPE (pfn0
)),
5550 e2
= cp_build_binary_op (location
,
5556 if (complain
& tf_warning
)
5557 maybe_warn_zero_as_null_pointer_constant (op1
, input_location
);
5559 e2
= cp_build_binary_op (location
,
5560 EQ_EXPR
, e2
, integer_zero_node
,
5562 op0
= cp_build_binary_op (location
,
5563 TRUTH_ANDIF_EXPR
, e1
, e2
,
5565 op1
= cp_convert (TREE_TYPE (op0
), integer_one_node
, complain
);
5569 op0
= build_ptrmemfunc_access_expr (op0
, pfn_identifier
);
5570 op1
= cp_convert (TREE_TYPE (op0
), op1
, complain
);
5572 result_type
= TREE_TYPE (op0
);
5574 warn_for_null_address (location
, orig_op0
, complain
);
5576 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (orig_op0
))
5577 return cp_build_binary_op (location
, code
, op1
, op0
, complain
);
5578 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
))
5581 /* E will be the final comparison. */
5583 /* E1 and E2 are for scratch. */
5591 type
= composite_pointer_type (location
, type0
, type1
, op0
, op1
,
5592 CPO_COMPARISON
, complain
);
5594 if (!same_type_p (TREE_TYPE (op0
), type
))
5595 op0
= cp_convert_and_check (type
, op0
, complain
);
5596 if (!same_type_p (TREE_TYPE (op1
), type
))
5597 op1
= cp_convert_and_check (type
, op1
, complain
);
5599 if (op0
== error_mark_node
|| op1
== error_mark_node
)
5600 return error_mark_node
;
5602 if (TREE_SIDE_EFFECTS (op0
))
5603 op0
= save_expr (op0
);
5604 if (TREE_SIDE_EFFECTS (op1
))
5605 op1
= save_expr (op1
);
5607 pfn0
= pfn_from_ptrmemfunc (op0
);
5608 pfn0
= cp_fully_fold (pfn0
);
5609 /* Avoid -Waddress warnings (c++/64877). */
5610 if (TREE_CODE (pfn0
) == ADDR_EXPR
)
5611 suppress_warning (pfn0
, OPT_Waddress
);
5612 pfn1
= pfn_from_ptrmemfunc (op1
);
5613 pfn1
= cp_fully_fold (pfn1
);
5614 delta0
= delta_from_ptrmemfunc (op0
);
5615 delta1
= delta_from_ptrmemfunc (op1
);
5616 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
5617 == ptrmemfunc_vbit_in_delta
)
5622 && ((op0.delta == op1.delta)
5623 || (!op0.pfn && op0.delta & 1 == 0
5624 && op1.delta & 1 == 0))
5626 The reason for the `!op0.pfn' bit is that a NULL
5627 pointer-to-member is any member with a zero PFN and
5628 LSB of the DELTA field is 0. */
5630 e1
= cp_build_binary_op (location
, BIT_AND_EXPR
,
5634 e1
= cp_build_binary_op (location
,
5635 EQ_EXPR
, e1
, integer_zero_node
,
5637 e2
= cp_build_binary_op (location
, BIT_AND_EXPR
,
5641 e2
= cp_build_binary_op (location
,
5642 EQ_EXPR
, e2
, integer_zero_node
,
5644 e1
= cp_build_binary_op (location
,
5645 TRUTH_ANDIF_EXPR
, e2
, e1
,
5647 e2
= cp_build_binary_op (location
, EQ_EXPR
,
5649 build_zero_cst (TREE_TYPE (pfn0
)),
5651 e2
= cp_build_binary_op (location
,
5652 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
5653 e1
= cp_build_binary_op (location
,
5654 EQ_EXPR
, delta0
, delta1
, complain
);
5655 e1
= cp_build_binary_op (location
,
5656 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
5663 && (!op0.pfn || op0.delta == op1.delta))
5665 The reason for the `!op0.pfn' bit is that a NULL
5666 pointer-to-member is any member with a zero PFN; the
5667 DELTA field is unspecified. */
5669 e1
= cp_build_binary_op (location
,
5670 EQ_EXPR
, delta0
, delta1
, complain
);
5671 e2
= cp_build_binary_op (location
,
5674 build_zero_cst (TREE_TYPE (pfn0
)),
5676 e1
= cp_build_binary_op (location
,
5677 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
5679 e2
= build2 (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
5680 e
= cp_build_binary_op (location
,
5681 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
5682 if (code
== EQ_EXPR
)
5684 return cp_build_binary_op (location
,
5685 EQ_EXPR
, e
, integer_zero_node
, complain
);
5689 gcc_assert (!TYPE_PTRMEMFUNC_P (type0
)
5690 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
),
5692 gcc_assert (!TYPE_PTRMEMFUNC_P (type1
)
5693 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
),
5701 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
5702 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
5704 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
5705 result_type
= composite_pointer_type (location
,
5706 type0
, type1
, op0
, op1
,
5707 CPO_COMPARISON
, complain
);
5714 case SPACESHIP_EXPR
:
5715 if (TREE_CODE (orig_op0
) == STRING_CST
5716 || TREE_CODE (orig_op1
) == STRING_CST
)
5718 if (complain
& tf_warning
)
5719 warning_at (location
, OPT_Waddress
,
5720 "comparison with string literal results "
5721 "in unspecified behavior");
5723 else if (warn_array_compare
5724 && TREE_CODE (TREE_TYPE (orig_op0
)) == ARRAY_TYPE
5725 && TREE_CODE (TREE_TYPE (orig_op1
)) == ARRAY_TYPE
5726 && code
!= SPACESHIP_EXPR
5727 && (complain
& tf_warning
))
5728 do_warn_array_compare (location
, code
,
5729 tree_strip_any_location_wrapper (orig_op0
),
5730 tree_strip_any_location_wrapper (orig_op1
));
5732 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
5736 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
5738 && !vector_types_compatible_elements_p (type0
, type1
))
5740 if (complain
& tf_error
)
5742 error_at (location
, "comparing vectors with different "
5744 inform (location
, "operand types are %qT and %qT",
5747 return error_mark_node
;
5750 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0
),
5751 TYPE_VECTOR_SUBPARTS (type1
)))
5753 if (complain
& tf_error
)
5755 error_at (location
, "comparing vectors with different "
5756 "number of elements");
5757 inform (location
, "operand types are %qT and %qT",
5760 return error_mark_node
;
5763 /* It's not precisely specified how the usual arithmetic
5764 conversions apply to the vector types. Here, we use
5765 the unsigned type if one of the operands is signed and
5766 the other one is unsigned. */
5767 if (TYPE_UNSIGNED (type0
) != TYPE_UNSIGNED (type1
))
5769 if (!TYPE_UNSIGNED (type0
))
5770 op0
= build1 (VIEW_CONVERT_EXPR
, type1
, op0
);
5772 op1
= build1 (VIEW_CONVERT_EXPR
, type0
, op1
);
5773 warning_at (location
, OPT_Wsign_compare
, "comparison between "
5774 "types %qT and %qT", type0
, type1
);
5777 if (resultcode
== SPACESHIP_EXPR
)
5779 if (complain
& tf_error
)
5780 sorry_at (location
, "three-way comparison of vectors");
5781 return error_mark_node
;
5784 /* Always construct signed integer vector type. */
5785 intt
= c_common_type_for_size
5786 (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (type0
))), 0);
5789 if (complain
& tf_error
)
5790 error_at (location
, "could not find an integer type "
5791 "of the same size as %qT", TREE_TYPE (type0
));
5792 return error_mark_node
;
5794 result_type
= build_opaque_vector_type (intt
,
5795 TYPE_VECTOR_SUBPARTS (type0
));
5796 return build_vec_cmp (resultcode
, result_type
, op0
, op1
);
5798 build_type
= boolean_type_node
;
5799 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
5800 || code0
== ENUMERAL_TYPE
)
5801 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5802 || code1
== ENUMERAL_TYPE
))
5804 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
5805 result_type
= composite_pointer_type (location
,
5806 type0
, type1
, op0
, op1
,
5807 CPO_COMPARISON
, complain
);
5808 else if ((code0
== POINTER_TYPE
&& null_ptr_cst_p (orig_op1
))
5809 || (code1
== POINTER_TYPE
&& null_ptr_cst_p (orig_op0
))
5810 || (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)))
5812 /* Core Issue 1512 made this ill-formed. */
5813 if (complain
& tf_error
)
5814 error_at (location
, "ordered comparison of pointer with "
5815 "integer zero (%qT and %qT)", type0
, type1
);
5816 return error_mark_node
;
5818 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5820 result_type
= type0
;
5821 if (complain
& tf_error
)
5822 permerror (location
, "ISO C++ forbids comparison between "
5823 "pointer and integer");
5825 return error_mark_node
;
5827 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
5829 result_type
= type1
;
5830 if (complain
& tf_error
)
5831 permerror (location
, "ISO C++ forbids comparison between "
5832 "pointer and integer");
5834 return error_mark_node
;
5837 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
5838 && !processing_template_decl
5839 && sanitize_flags_p (SANITIZE_POINTER_COMPARE
))
5841 op0
= save_expr (op0
);
5842 op1
= save_expr (op1
);
5844 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_COMPARE
);
5845 instrument_expr
= build_call_expr_loc (location
, tt
, 2, op0
, op1
);
5850 case UNORDERED_EXPR
:
5857 build_type
= integer_type_node
;
5858 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
5860 if (complain
& tf_error
)
5861 error ("unordered comparison on non-floating-point argument");
5862 return error_mark_node
;
5871 if (((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
5872 || code0
== ENUMERAL_TYPE
)
5873 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5874 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
)))
5875 arithmetic_types_p
= 1;
5878 arithmetic_types_p
= 0;
5879 /* Vector arithmetic is only allowed when both sides are vectors. */
5880 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
5882 if (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
5883 || !vector_types_compatible_elements_p (type0
, type1
))
5885 if (complain
& tf_error
)
5887 /* "location" already embeds the locations of the
5888 operands, so we don't need to add them separately
5890 rich_location
richloc (line_table
, location
);
5891 binary_op_error (&richloc
, code
, type0
, type1
);
5893 return error_mark_node
;
5895 arithmetic_types_p
= 1;
5898 /* Determine the RESULT_TYPE, if it is not already known. */
5900 && arithmetic_types_p
5901 && (shorten
|| common
|| short_compare
))
5903 result_type
= cp_common_type (type0
, type1
);
5904 if (complain
& tf_warning
)
5906 do_warn_double_promotion (result_type
, type0
, type1
,
5907 "implicit conversion from %qH to %qI "
5908 "to match other operand of binary "
5911 do_warn_enum_conversions (location
, code
, TREE_TYPE (orig_op0
),
5912 TREE_TYPE (orig_op1
));
5916 if (code
== SPACESHIP_EXPR
)
5918 iloc_sentinel
s (location
);
5920 tree orig_type0
= TREE_TYPE (orig_op0
);
5921 tree_code orig_code0
= TREE_CODE (orig_type0
);
5922 tree orig_type1
= TREE_TYPE (orig_op1
);
5923 tree_code orig_code1
= TREE_CODE (orig_type1
);
5926 else if ((orig_code0
== BOOLEAN_TYPE
) != (orig_code1
== BOOLEAN_TYPE
))
5927 /* "If one of the operands is of type bool and the other is not, the
5928 program is ill-formed." */
5929 result_type
= NULL_TREE
;
5930 else if (code0
== POINTER_TYPE
&& orig_code0
!= POINTER_TYPE
5931 && code1
== POINTER_TYPE
&& orig_code1
!= POINTER_TYPE
)
5932 /* We only do array/function-to-pointer conversion if "at least one of
5933 the operands is of pointer type". */
5934 result_type
= NULL_TREE
;
5935 else if (TYPE_PTRFN_P (result_type
) || NULLPTR_TYPE_P (result_type
))
5936 /* <=> no longer supports equality relations. */
5937 result_type
= NULL_TREE
;
5938 else if (orig_code0
== ENUMERAL_TYPE
&& orig_code1
== ENUMERAL_TYPE
5939 && !(same_type_ignoring_top_level_qualifiers_p
5940 (orig_type0
, orig_type1
)))
5941 /* "If both operands have arithmetic types, or one operand has integral
5942 type and the other operand has unscoped enumeration type, the usual
5943 arithmetic conversions are applied to the operands." So we don't do
5944 arithmetic conversions if the operands both have enumeral type. */
5945 result_type
= NULL_TREE
;
5946 else if ((orig_code0
== ENUMERAL_TYPE
&& orig_code1
== REAL_TYPE
)
5947 || (orig_code0
== REAL_TYPE
&& orig_code1
== ENUMERAL_TYPE
))
5948 /* [depr.arith.conv.enum]: Three-way comparisons between such operands
5949 [where one is of enumeration type and the other is of a different
5950 enumeration type or a floating-point type] are ill-formed. */
5951 result_type
= NULL_TREE
;
5955 build_type
= spaceship_type (result_type
, complain
);
5956 if (build_type
== error_mark_node
)
5957 return error_mark_node
;
5960 if (result_type
&& arithmetic_types_p
)
5962 /* If a narrowing conversion is required, other than from an integral
5963 type to a floating point type, the program is ill-formed. */
5965 if (TREE_CODE (result_type
) == REAL_TYPE
5966 && CP_INTEGRAL_TYPE_P (orig_type0
))
5968 else if (!check_narrowing (result_type
, orig_op0
, complain
))
5970 if (TREE_CODE (result_type
) == REAL_TYPE
5971 && CP_INTEGRAL_TYPE_P (orig_type1
))
5973 else if (!check_narrowing (result_type
, orig_op1
, complain
))
5975 if (!ok
&& !(complain
& tf_error
))
5976 return error_mark_node
;
5982 if (complain
& tf_error
)
5984 binary_op_rich_location
richloc (location
,
5985 orig_op0
, orig_op1
, true);
5987 "invalid operands of types %qT and %qT to binary %qO",
5988 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
5990 return error_mark_node
;
5993 /* If we're in a template, the only thing we need to know is the
5995 if (processing_template_decl
)
5997 /* Since the middle-end checks the type when doing a build2, we
5998 need to build the tree in pieces. This built tree will never
5999 get out of the front-end as we replace it when instantiating
6001 tree tmp
= build2 (resultcode
,
6002 build_type
? build_type
: result_type
,
6004 TREE_OPERAND (tmp
, 0) = op0
;
6008 /* Remember the original type; RESULT_TYPE might be changed later on
6009 by shorten_binary_op. */
6010 tree orig_type
= result_type
;
6012 if (arithmetic_types_p
)
6014 bool first_complex
= (code0
== COMPLEX_TYPE
);
6015 bool second_complex
= (code1
== COMPLEX_TYPE
);
6016 int none_complex
= (!first_complex
&& !second_complex
);
6018 /* Adapted from patch for c/24581. */
6019 if (first_complex
!= second_complex
6020 && (code
== PLUS_EXPR
6021 || code
== MINUS_EXPR
6022 || code
== MULT_EXPR
6023 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
6024 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
6025 && flag_signed_zeros
)
6027 /* An operation on mixed real/complex operands must be
6028 handled specially, but the language-independent code can
6029 more easily optimize the plain complex arithmetic if
6030 -fno-signed-zeros. */
6031 tree real_type
= TREE_TYPE (result_type
);
6035 if (TREE_TYPE (op0
) != result_type
)
6036 op0
= cp_convert_and_check (result_type
, op0
, complain
);
6037 if (TREE_TYPE (op1
) != real_type
)
6038 op1
= cp_convert_and_check (real_type
, op1
, complain
);
6042 if (TREE_TYPE (op0
) != real_type
)
6043 op0
= cp_convert_and_check (real_type
, op0
, complain
);
6044 if (TREE_TYPE (op1
) != result_type
)
6045 op1
= cp_convert_and_check (result_type
, op1
, complain
);
6047 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
6048 return error_mark_node
;
6051 op0
= save_expr (op0
);
6052 real
= cp_build_unary_op (REALPART_EXPR
, op0
, true, complain
);
6053 imag
= cp_build_unary_op (IMAGPART_EXPR
, op0
, true, complain
);
6057 case TRUNC_DIV_EXPR
:
6058 op1
= save_expr (op1
);
6059 imag
= build2 (resultcode
, real_type
, imag
, op1
);
6063 real
= build2 (resultcode
, real_type
, real
, op1
);
6071 op1
= save_expr (op1
);
6072 real
= cp_build_unary_op (REALPART_EXPR
, op1
, true, complain
);
6073 imag
= cp_build_unary_op (IMAGPART_EXPR
, op1
, true, complain
);
6077 op0
= save_expr (op0
);
6078 imag
= build2 (resultcode
, real_type
, op0
, imag
);
6081 real
= build2 (resultcode
, real_type
, op0
, real
);
6084 real
= build2 (resultcode
, real_type
, op0
, real
);
6085 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
6091 result
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
6095 /* For certain operations (which identify themselves by shorten != 0)
6096 if both args were extended from the same smaller type,
6097 do the arithmetic in that type and then extend.
6099 shorten !=0 and !=1 indicates a bitwise operation.
6100 For them, this optimization is safe only if
6101 both args are zero-extended or both are sign-extended.
6102 Otherwise, we might change the result.
6103 E.g., (short)-1 | (unsigned short)-1 is (int)-1
6104 but calculated in (unsigned short) it would be (unsigned short)-1. */
6106 if (shorten
&& none_complex
)
6108 final_type
= result_type
;
6109 result_type
= shorten_binary_op (result_type
, op0
, op1
,
6113 /* Shifts can be shortened if shifting right. */
6118 tree arg0
= get_narrower (op0
, &unsigned_arg
);
6119 /* We're not really warning here but when we set short_shift we
6120 used fold_for_warn to fold the operand. */
6121 tree const_op1
= fold_for_warn (op1
);
6123 final_type
= result_type
;
6125 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
6126 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
6128 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
6129 && tree_int_cst_sgn (const_op1
) > 0
6130 /* We can shorten only if the shift count is less than the
6131 number of bits in the smaller type size. */
6132 && compare_tree_int (const_op1
,
6133 TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
6134 /* We cannot drop an unsigned shift after sign-extension. */
6135 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
6137 /* Do an unsigned shift if the operand was zero-extended. */
6139 = c_common_signed_or_unsigned_type (unsigned_arg
,
6141 /* Convert value-to-be-shifted to that type. */
6142 if (TREE_TYPE (op0
) != result_type
)
6143 op0
= convert (result_type
, op0
);
6148 /* Comparison operations are shortened too but differently.
6149 They identify themselves by setting short_compare = 1. */
6153 /* We call shorten_compare only for diagnostics. */
6154 tree xop0
= fold_simple (op0
);
6155 tree xop1
= fold_simple (op1
);
6156 tree xresult_type
= result_type
;
6157 enum tree_code xresultcode
= resultcode
;
6158 shorten_compare (location
, &xop0
, &xop1
, &xresult_type
,
6162 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
6163 && warn_sign_compare
6164 /* Do not warn until the template is instantiated; we cannot
6165 bound the ranges of the arguments until that point. */
6166 && !processing_template_decl
6167 && (complain
& tf_warning
)
6168 && c_inhibit_evaluation_warnings
== 0
6169 /* Even unsigned enum types promote to signed int. We don't
6170 want to issue -Wsign-compare warnings for this case. */
6171 && !enum_cast_to_int (orig_op0
)
6172 && !enum_cast_to_int (orig_op1
))
6174 warn_for_sign_compare (location
, orig_op0
, orig_op1
, op0
, op1
,
6175 result_type
, resultcode
);
6179 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
6180 Then the expression will be built.
6181 It will be given type FINAL_TYPE if that is nonzero;
6182 otherwise, it will be given type RESULT_TYPE. */
6185 warning_sentinel
w (warn_sign_conversion
, short_compare
);
6186 if (!same_type_p (TREE_TYPE (op0
), result_type
))
6187 op0
= cp_convert_and_check (result_type
, op0
, complain
);
6188 if (!same_type_p (TREE_TYPE (op1
), result_type
))
6189 op1
= cp_convert_and_check (result_type
, op1
, complain
);
6191 if (op0
== error_mark_node
|| op1
== error_mark_node
)
6192 return error_mark_node
;
6195 if (build_type
== NULL_TREE
)
6196 build_type
= result_type
;
6199 && flag_strong_eval_order
== 2
6200 && TREE_SIDE_EFFECTS (op1
)
6201 && !processing_template_decl
)
6203 /* In C++17, in both op0 << op1 and op0 >> op1 op0 is sequenced before
6204 op1, so if op1 has side-effects, use SAVE_EXPR around op0. */
6205 op0
= cp_save_expr (op0
);
6206 instrument_expr
= op0
;
6209 if (sanitize_flags_p ((SANITIZE_SHIFT
6211 | SANITIZE_FLOAT_DIVIDE
6212 | SANITIZE_SI_OVERFLOW
))
6213 && current_function_decl
!= NULL_TREE
6214 && !processing_template_decl
6215 && (doing_div_or_mod
|| doing_shift
))
6217 /* OP0 and/or OP1 might have side-effects. */
6218 op0
= cp_save_expr (op0
);
6219 op1
= cp_save_expr (op1
);
6220 op0
= fold_non_dependent_expr (op0
, complain
);
6221 op1
= fold_non_dependent_expr (op1
, complain
);
6222 tree instrument_expr1
= NULL_TREE
;
6223 if (doing_div_or_mod
6224 && sanitize_flags_p (SANITIZE_DIVIDE
6225 | SANITIZE_FLOAT_DIVIDE
6226 | SANITIZE_SI_OVERFLOW
))
6228 /* For diagnostics we want to use the promoted types without
6229 shorten_binary_op. So convert the arguments to the
6230 original result_type. */
6233 if (TREE_TYPE (cop0
) != orig_type
)
6234 cop0
= cp_convert (orig_type
, op0
, complain
);
6235 if (TREE_TYPE (cop1
) != orig_type
)
6236 cop1
= cp_convert (orig_type
, op1
, complain
);
6237 instrument_expr1
= ubsan_instrument_division (location
, cop0
, cop1
);
6239 else if (doing_shift
&& sanitize_flags_p (SANITIZE_SHIFT
))
6240 instrument_expr1
= ubsan_instrument_shift (location
, code
, op0
, op1
);
6241 if (instrument_expr
!= NULL
)
6242 instrument_expr
= add_stmt_to_compound (instrument_expr
,
6245 instrument_expr
= instrument_expr1
;
6248 result
= build2_loc (location
, resultcode
, build_type
, op0
, op1
);
6249 if (final_type
!= 0)
6250 result
= cp_convert (final_type
, result
, complain
);
6252 if (instrument_expr
!= NULL
)
6253 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
6254 instrument_expr
, result
);
6256 if (!processing_template_decl
)
6258 if (resultcode
== SPACESHIP_EXPR
)
6259 result
= get_target_expr_sfinae (result
, complain
);
6260 op0
= cp_fully_fold (op0
);
6261 /* Only consider the second argument if the first isn't overflowed. */
6262 if (!CONSTANT_CLASS_P (op0
) || TREE_OVERFLOW_P (op0
))
6264 op1
= cp_fully_fold (op1
);
6265 if (!CONSTANT_CLASS_P (op1
) || TREE_OVERFLOW_P (op1
))
6268 else if (!CONSTANT_CLASS_P (op0
) || !CONSTANT_CLASS_P (op1
)
6269 || TREE_OVERFLOW_P (op0
) || TREE_OVERFLOW_P (op1
))
6272 result_ovl
= fold_build2 (resultcode
, build_type
, op0
, op1
);
6273 if (TREE_OVERFLOW_P (result_ovl
))
6274 overflow_warning (location
, result_ovl
);
6279 /* Build a VEC_PERM_EXPR.
6280 This is a simple wrapper for c_build_vec_perm_expr. */
6282 build_x_vec_perm_expr (location_t loc
,
6283 tree arg0
, tree arg1
, tree arg2
,
6284 tsubst_flags_t complain
)
6286 tree orig_arg0
= arg0
;
6287 tree orig_arg1
= arg1
;
6288 tree orig_arg2
= arg2
;
6289 if (processing_template_decl
)
6291 if (type_dependent_expression_p (arg0
)
6292 || type_dependent_expression_p (arg1
)
6293 || type_dependent_expression_p (arg2
))
6294 return build_min_nt_loc (loc
, VEC_PERM_EXPR
, arg0
, arg1
, arg2
);
6295 arg0
= build_non_dependent_expr (arg0
);
6297 arg1
= build_non_dependent_expr (arg1
);
6298 arg2
= build_non_dependent_expr (arg2
);
6300 tree exp
= c_build_vec_perm_expr (loc
, arg0
, arg1
, arg2
, complain
& tf_error
);
6301 if (processing_template_decl
&& exp
!= error_mark_node
)
6302 return build_min_non_dep (VEC_PERM_EXPR
, exp
, orig_arg0
,
6303 orig_arg1
, orig_arg2
);
6307 /* Build a VEC_PERM_EXPR.
6308 This is a simple wrapper for c_build_shufflevector. */
6310 build_x_shufflevector (location_t loc
, vec
<tree
, va_gc
> *args
,
6311 tsubst_flags_t complain
)
6313 tree arg0
= (*args
)[0];
6314 tree arg1
= (*args
)[1];
6315 if (processing_template_decl
)
6317 for (unsigned i
= 0; i
< args
->length (); ++i
)
6318 if (type_dependent_expression_p ((*args
)[i
]))
6320 tree exp
= build_min_nt_call_vec (NULL
, args
);
6321 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6324 arg0
= build_non_dependent_expr (arg0
);
6325 arg1
= build_non_dependent_expr (arg1
);
6326 /* ??? Nothing needed for the index arguments? */
6328 auto_vec
<tree
, 16> mask
;
6329 for (unsigned i
= 2; i
< args
->length (); ++i
)
6331 tree idx
= maybe_constant_value ((*args
)[i
]);
6332 mask
.safe_push (idx
);
6334 tree exp
= c_build_shufflevector (loc
, arg0
, arg1
, mask
, complain
& tf_error
);
6335 if (processing_template_decl
&& exp
!= error_mark_node
)
6337 exp
= build_min_non_dep_call_vec (exp
, NULL
, args
);
6338 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6343 /* Return a tree for the sum or difference (RESULTCODE says which)
6344 of pointer PTROP and integer INTOP. */
6347 cp_pointer_int_sum (location_t loc
, enum tree_code resultcode
, tree ptrop
,
6348 tree intop
, tsubst_flags_t complain
)
6350 tree res_type
= TREE_TYPE (ptrop
);
6352 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
6353 in certain circumstance (when it's valid to do so). So we need
6354 to make sure it's complete. We don't need to check here, if we
6355 can actually complete it at all, as those checks will be done in
6356 pointer_int_sum() anyway. */
6357 complete_type (TREE_TYPE (res_type
));
6359 return pointer_int_sum (loc
, resultcode
, ptrop
,
6360 intop
, complain
& tf_warning_or_error
);
6363 /* Return a tree for the difference of pointers OP0 and OP1.
6364 The resulting tree has type int. If POINTER_SUBTRACT sanitization is
6365 enabled, assign to INSTRUMENT_EXPR call to libsanitizer. */
6368 pointer_diff (location_t loc
, tree op0
, tree op1
, tree ptrtype
,
6369 tsubst_flags_t complain
, tree
*instrument_expr
)
6371 tree result
, inttype
;
6372 tree restype
= ptrdiff_type_node
;
6373 tree target_type
= TREE_TYPE (ptrtype
);
6375 if (!complete_type_or_maybe_complain (target_type
, NULL_TREE
, complain
))
6376 return error_mark_node
;
6378 if (VOID_TYPE_P (target_type
))
6380 if (complain
& tf_error
)
6381 permerror (loc
, "ISO C++ forbids using pointer of "
6382 "type %<void *%> in subtraction");
6384 return error_mark_node
;
6386 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
6388 if (complain
& tf_error
)
6389 permerror (loc
, "ISO C++ forbids using pointer to "
6390 "a function in subtraction");
6392 return error_mark_node
;
6394 if (TREE_CODE (target_type
) == METHOD_TYPE
)
6396 if (complain
& tf_error
)
6397 permerror (loc
, "ISO C++ forbids using pointer to "
6398 "a method in subtraction");
6400 return error_mark_node
;
6402 else if (!verify_type_context (loc
, TCTX_POINTER_ARITH
,
6403 TREE_TYPE (TREE_TYPE (op0
)),
6404 !(complain
& tf_error
))
6405 || !verify_type_context (loc
, TCTX_POINTER_ARITH
,
6406 TREE_TYPE (TREE_TYPE (op1
)),
6407 !(complain
& tf_error
)))
6408 return error_mark_node
;
6410 /* Determine integer type result of the subtraction. This will usually
6411 be the same as the result type (ptrdiff_t), but may need to be a wider
6412 type if pointers for the address space are wider than ptrdiff_t. */
6413 if (TYPE_PRECISION (restype
) < TYPE_PRECISION (TREE_TYPE (op0
)))
6414 inttype
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0
)), 0);
6418 if (!processing_template_decl
6419 && sanitize_flags_p (SANITIZE_POINTER_SUBTRACT
))
6421 op0
= save_expr (op0
);
6422 op1
= save_expr (op1
);
6424 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT
);
6425 *instrument_expr
= build_call_expr_loc (loc
, tt
, 2, op0
, op1
);
6428 /* First do the subtraction, then build the divide operator
6429 and only convert at the very end.
6430 Do not do default conversions in case restype is a short type. */
6432 /* POINTER_DIFF_EXPR requires a signed integer type of the same size as
6433 pointers. If some platform cannot provide that, or has a larger
6434 ptrdiff_type to support differences larger than half the address
6435 space, cast the pointers to some larger integer type and do the
6436 computations in that type. */
6437 if (TYPE_PRECISION (inttype
) > TYPE_PRECISION (TREE_TYPE (op0
)))
6438 op0
= cp_build_binary_op (loc
,
6440 cp_convert (inttype
, op0
, complain
),
6441 cp_convert (inttype
, op1
, complain
),
6444 op0
= build2_loc (loc
, POINTER_DIFF_EXPR
, inttype
, op0
, op1
);
6446 /* This generates an error if op1 is a pointer to an incomplete type. */
6447 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
6449 if (complain
& tf_error
)
6450 error_at (loc
, "invalid use of a pointer to an incomplete type in "
6451 "pointer arithmetic");
6453 return error_mark_node
;
6456 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (op1
)))
6458 if (complain
& tf_error
)
6459 error_at (loc
, "arithmetic on pointer to an empty aggregate");
6461 return error_mark_node
;
6464 op1
= (TYPE_PTROB_P (ptrtype
)
6465 ? size_in_bytes_loc (loc
, target_type
)
6466 : integer_one_node
);
6468 /* Do the division. */
6470 result
= build2_loc (loc
, EXACT_DIV_EXPR
, inttype
, op0
,
6471 cp_convert (inttype
, op1
, complain
));
6472 return cp_convert (restype
, result
, complain
);
6475 /* Construct and perhaps optimize a tree representation
6476 for a unary operation. CODE, a tree_code, specifies the operation
6477 and XARG is the operand. */
6480 build_x_unary_op (location_t loc
, enum tree_code code
, cp_expr xarg
,
6481 tree lookups
, tsubst_flags_t complain
)
6483 tree orig_expr
= xarg
;
6486 tree overload
= NULL_TREE
;
6488 if (processing_template_decl
)
6490 if (type_dependent_expression_p (xarg
))
6492 tree e
= build_min_nt_loc (loc
, code
, xarg
.get_value (), NULL_TREE
);
6493 TREE_TYPE (e
) = build_dependent_operator_type (lookups
, code
, false);
6497 xarg
= build_non_dependent_expr (xarg
);
6502 /* [expr.unary.op] says:
6504 The address of an object of incomplete type can be taken.
6506 (And is just the ordinary address operator, not an overloaded
6507 "operator &".) However, if the type is a template
6508 specialization, we must complete the type at this point so that
6509 an overloaded "operator &" will be available if required. */
6510 if (code
== ADDR_EXPR
6511 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
6512 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
6513 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
6514 || (TREE_CODE (xarg
) == OFFSET_REF
)))
6515 /* Don't look for a function. */;
6517 exp
= build_new_op (loc
, code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
,
6518 NULL_TREE
, lookups
, &overload
, complain
);
6520 if (!exp
&& code
== ADDR_EXPR
)
6522 if (is_overloaded_fn (xarg
))
6524 tree fn
= get_first_fn (xarg
);
6525 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
6527 if (complain
& tf_error
)
6528 error_at (loc
, DECL_CONSTRUCTOR_P (fn
)
6529 ? G_("taking address of constructor %qD")
6530 : G_("taking address of destructor %qD"),
6532 return error_mark_node
;
6536 /* A pointer to member-function can be formed only by saying
6538 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
6539 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
6541 if (TREE_CODE (xarg
) != OFFSET_REF
6542 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
6544 if (complain
& tf_error
)
6546 error_at (loc
, "invalid use of %qE to form a "
6547 "pointer-to-member-function", xarg
.get_value ());
6548 if (TREE_CODE (xarg
) != OFFSET_REF
)
6549 inform (loc
, " a qualified-id is required");
6551 return error_mark_node
;
6555 if (complain
& tf_error
)
6556 error_at (loc
, "parentheses around %qE cannot be used to "
6557 "form a pointer-to-member-function",
6560 return error_mark_node
;
6561 PTRMEM_OK_P (xarg
) = 1;
6565 if (TREE_CODE (xarg
) == OFFSET_REF
)
6567 ptrmem
= PTRMEM_OK_P (xarg
);
6569 if (!ptrmem
&& !flag_ms_extensions
6570 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
6572 /* A single non-static member, make sure we don't allow a
6573 pointer-to-member. */
6574 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
6575 TREE_OPERAND (xarg
, 0),
6576 ovl_make (TREE_OPERAND (xarg
, 1)));
6577 PTRMEM_OK_P (xarg
) = ptrmem
;
6581 exp
= cp_build_addr_expr_strict (xarg
, complain
);
6583 if (TREE_CODE (exp
) == PTRMEM_CST
)
6584 PTRMEM_CST_LOCATION (exp
) = loc
;
6586 protected_set_expr_location (exp
, loc
);
6589 if (processing_template_decl
&& exp
!= error_mark_node
)
6591 if (overload
!= NULL_TREE
)
6592 return (build_min_non_dep_op_overload
6593 (code
, exp
, overload
, orig_expr
, integer_zero_node
));
6595 exp
= build_min_non_dep (code
, exp
, orig_expr
,
6596 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
6598 if (TREE_CODE (exp
) == ADDR_EXPR
)
6599 PTRMEM_OK_P (exp
) = ptrmem
;
6603 /* Construct and perhaps optimize a tree representation
6604 for __builtin_addressof operation. ARG specifies the operand. */
6607 cp_build_addressof (location_t loc
, tree arg
, tsubst_flags_t complain
)
6609 tree orig_expr
= arg
;
6611 if (processing_template_decl
)
6613 if (type_dependent_expression_p (arg
))
6614 return build_min_nt_loc (loc
, ADDRESSOF_EXPR
, arg
, NULL_TREE
);
6616 arg
= build_non_dependent_expr (arg
);
6619 tree exp
= cp_build_addr_expr_strict (arg
, complain
);
6621 if (processing_template_decl
&& exp
!= error_mark_node
)
6622 exp
= build_min_non_dep (ADDRESSOF_EXPR
, exp
, orig_expr
, NULL_TREE
);
6626 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
6627 constants, where a null value is represented by an INTEGER_CST of
6631 cp_truthvalue_conversion (tree expr
, tsubst_flags_t complain
)
6633 tree type
= TREE_TYPE (expr
);
6634 location_t loc
= cp_expr_loc_or_input_loc (expr
);
6635 if (TYPE_PTR_OR_PTRMEM_P (type
)
6636 /* Avoid ICE on invalid use of non-static member function. */
6637 || TREE_CODE (expr
) == FUNCTION_DECL
)
6638 return cp_build_binary_op (loc
, NE_EXPR
, expr
, nullptr_node
, complain
);
6640 return c_common_truthvalue_conversion (loc
, expr
);
6643 /* Returns EXPR contextually converted to bool. */
6646 contextual_conv_bool (tree expr
, tsubst_flags_t complain
)
6648 return perform_implicit_conversion_flags (boolean_type_node
, expr
,
6649 complain
, LOOKUP_NORMAL
);
6652 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. This
6653 is a low-level function; most callers should use maybe_convert_cond. */
6656 condition_conversion (tree expr
)
6658 tree t
= contextual_conv_bool (expr
, tf_warning_or_error
);
6659 if (!processing_template_decl
)
6660 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
6664 /* Returns the address of T. This function will fold away
6665 ADDR_EXPR of INDIRECT_REF. This is only for low-level usage;
6666 most places should use cp_build_addr_expr instead. */
6669 build_address (tree t
)
6671 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
6672 return error_mark_node
;
6673 gcc_checking_assert (TREE_CODE (t
) != CONSTRUCTOR
6674 || processing_template_decl
);
6675 t
= build_fold_addr_expr_loc (EXPR_LOCATION (t
), t
);
6676 if (TREE_CODE (t
) != ADDR_EXPR
)
6681 /* Return a NOP_EXPR converting EXPR to TYPE. */
6684 build_nop (tree type
, tree expr
)
6686 if (type
== error_mark_node
|| error_operand_p (expr
))
6688 return build1_loc (EXPR_LOCATION (expr
), NOP_EXPR
, type
, expr
);
6691 /* Take the address of ARG, whatever that means under C++ semantics.
6692 If STRICT_LVALUE is true, require an lvalue; otherwise, allow xvalues
6693 and class rvalues as well.
6695 Nothing should call this function directly; instead, callers should use
6696 cp_build_addr_expr or cp_build_addr_expr_strict. */
6699 cp_build_addr_expr_1 (tree arg
, bool strict_lvalue
, tsubst_flags_t complain
)
6704 if (!arg
|| error_operand_p (arg
))
6705 return error_mark_node
;
6707 arg
= mark_lvalue_use (arg
);
6708 if (error_operand_p (arg
))
6709 return error_mark_node
;
6711 argtype
= lvalue_type (arg
);
6712 location_t loc
= cp_expr_loc_or_input_loc (arg
);
6714 gcc_assert (!(identifier_p (arg
) && IDENTIFIER_ANY_OP_P (arg
)));
6716 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
6717 && !really_overloaded_fn (arg
))
6719 /* They're trying to take the address of a unique non-static
6720 member function. This is ill-formed (except in MS-land),
6721 but let's try to DTRT.
6722 Note: We only handle unique functions here because we don't
6723 want to complain if there's a static overload; non-unique
6724 cases will be handled by instantiate_type. But we need to
6725 handle this case here to allow casts on the resulting PMF.
6726 We could defer this in non-MS mode, but it's easier to give
6727 a useful error here. */
6729 /* Inside constant member functions, the `this' pointer
6730 contains an extra const qualifier. TYPE_MAIN_VARIANT
6731 is used here to remove this const from the diagnostics
6732 and the created OFFSET_REF. */
6733 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
6734 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
6735 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6736 return error_mark_node
;
6738 if (! flag_ms_extensions
)
6740 tree name
= DECL_NAME (fn
);
6741 if (!(complain
& tf_error
))
6742 return error_mark_node
;
6743 else if (current_class_type
6744 && TREE_OPERAND (arg
, 0) == current_class_ref
)
6745 /* An expression like &memfn. */
6747 "ISO C++ forbids taking the address of an unqualified"
6748 " or parenthesized non-static member function to form"
6749 " a pointer to member function. Say %<&%T::%D%>",
6753 "ISO C++ forbids taking the address of a bound member"
6754 " function to form a pointer to member function."
6758 arg
= build_offset_ref (base
, fn
, /*address_p=*/true, complain
);
6761 /* Uninstantiated types are all functions. Taking the
6762 address of a function is a no-op, so just return the
6764 if (type_unknown_p (arg
))
6765 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
6767 if (TREE_CODE (arg
) == OFFSET_REF
)
6768 /* We want a pointer to member; bypass all the code for actually taking
6769 the address of something. */
6772 /* Anything not already handled and not a true memory reference
6774 if (!FUNC_OR_METHOD_TYPE_P (argtype
))
6776 cp_lvalue_kind kind
= lvalue_kind (arg
);
6777 if (kind
== clk_none
)
6779 if (complain
& tf_error
)
6780 lvalue_error (loc
, lv_addressof
);
6781 return error_mark_node
;
6783 if (strict_lvalue
&& (kind
& (clk_rvalueref
|clk_class
)))
6785 if (!(complain
& tf_error
))
6786 return error_mark_node
;
6787 /* Make this a permerror because we used to accept it. */
6788 permerror (loc
, "taking address of rvalue");
6792 if (TYPE_REF_P (argtype
))
6794 tree type
= build_pointer_type (TREE_TYPE (argtype
));
6795 arg
= build1 (CONVERT_EXPR
, type
, arg
);
6798 else if (pedantic
&& DECL_MAIN_P (tree_strip_any_location_wrapper (arg
)))
6801 /* Apparently a lot of autoconf scripts for C++ packages do this,
6802 so only complain if -Wpedantic. */
6803 if (complain
& (flag_pedantic_errors
? tf_error
: tf_warning
))
6804 pedwarn (loc
, OPT_Wpedantic
,
6805 "ISO C++ forbids taking address of function %<::main%>");
6806 else if (flag_pedantic_errors
)
6807 return error_mark_node
;
6810 /* Let &* cancel out to simplify resulting code. */
6811 if (INDIRECT_REF_P (arg
))
6813 arg
= TREE_OPERAND (arg
, 0);
6814 if (TYPE_REF_P (TREE_TYPE (arg
)))
6816 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
6817 arg
= build1 (CONVERT_EXPR
, type
, arg
);
6820 /* Don't let this be an lvalue. */
6825 /* Handle complex lvalues (when permitted)
6826 by reduction to simpler cases. */
6827 val
= unary_complex_lvalue (ADDR_EXPR
, arg
);
6831 switch (TREE_CODE (arg
))
6835 case FIX_TRUNC_EXPR
:
6836 /* We should have handled this above in the lvalue_kind check. */
6841 arg
= BASELINK_FUNCTIONS (arg
);
6845 arg
= OVL_FIRST (arg
);
6850 /* Turn a reference to a non-static data member into a
6851 pointer-to-member. */
6856 gcc_assert (PTRMEM_OK_P (arg
));
6858 t
= TREE_OPERAND (arg
, 1);
6859 if (TYPE_REF_P (TREE_TYPE (t
)))
6861 if (complain
& tf_error
)
6863 "cannot create pointer to reference member %qD", t
);
6864 return error_mark_node
;
6867 /* Forming a pointer-to-member is a use of non-pure-virtual fns. */
6868 if (TREE_CODE (t
) == FUNCTION_DECL
6869 && !DECL_PURE_VIRTUAL_P (t
)
6870 && !mark_used (t
, complain
) && !(complain
& tf_error
))
6871 return error_mark_node
;
6873 type
= build_ptrmem_type (context_for_name_lookup (t
),
6875 t
= make_ptrmem_cst (type
, t
);
6883 if (argtype
!= error_mark_node
)
6884 argtype
= build_pointer_type (argtype
);
6886 if (bitfield_p (arg
))
6888 if (complain
& tf_error
)
6889 error_at (loc
, "attempt to take address of bit-field");
6890 return error_mark_node
;
6893 /* In a template, we are processing a non-dependent expression
6894 so we can just form an ADDR_EXPR with the correct type. */
6895 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
6897 if (!mark_single_function (arg
, complain
))
6898 return error_mark_node
;
6899 val
= build_address (arg
);
6900 if (TREE_CODE (arg
) == OFFSET_REF
)
6901 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
6903 else if (BASELINK_P (TREE_OPERAND (arg
, 1)))
6905 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
6907 /* We can only get here with a single static member
6909 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6910 && DECL_STATIC_FUNCTION_P (fn
));
6911 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6912 return error_mark_node
;
6913 val
= build_address (fn
);
6914 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
6915 /* Do not lose object's side effects. */
6916 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
6917 TREE_OPERAND (arg
, 0), val
);
6921 tree object
= TREE_OPERAND (arg
, 0);
6922 tree field
= TREE_OPERAND (arg
, 1);
6923 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6924 (TREE_TYPE (object
), decl_type_context (field
)));
6925 val
= build_address (arg
);
6928 if (TYPE_PTR_P (argtype
)
6929 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
6931 build_ptrmemfunc_type (argtype
);
6932 val
= build_ptrmemfunc (argtype
, val
, 0,
6937 /* For addresses of immediate functions ensure we have EXPR_LOCATION
6938 set for possible later diagnostics. */
6939 if (TREE_CODE (val
) == ADDR_EXPR
6940 && TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
6941 && DECL_IMMEDIATE_FUNCTION_P (TREE_OPERAND (val
, 0)))
6942 SET_EXPR_LOCATION (val
, input_location
);
6947 /* Take the address of ARG if it has one, even if it's an rvalue. */
6950 cp_build_addr_expr (tree arg
, tsubst_flags_t complain
)
6952 return cp_build_addr_expr_1 (arg
, 0, complain
);
6955 /* Take the address of ARG, but only if it's an lvalue. */
6958 cp_build_addr_expr_strict (tree arg
, tsubst_flags_t complain
)
6960 return cp_build_addr_expr_1 (arg
, 1, complain
);
6963 /* C++: Must handle pointers to members.
6965 Perhaps type instantiation should be extended to handle conversion
6966 from aggregates to types we don't yet know we want? (Or are those
6967 cases typically errors which should be reported?)
6969 NOCONVERT suppresses the default promotions (such as from short to int). */
6972 cp_build_unary_op (enum tree_code code
, tree xarg
, bool noconvert
,
6973 tsubst_flags_t complain
)
6975 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
6977 location_t location
= cp_expr_loc_or_input_loc (arg
);
6979 const char *errstring
= NULL
;
6981 const char *invalid_op_diag
;
6983 if (!arg
|| error_operand_p (arg
))
6984 return error_mark_node
;
6986 arg
= resolve_nondeduced_context (arg
, complain
);
6988 if ((invalid_op_diag
6989 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
6994 if (complain
& tf_error
)
6995 error (invalid_op_diag
);
6996 return error_mark_node
;
7001 case UNARY_PLUS_EXPR
:
7004 int flags
= WANT_ARITH
| WANT_ENUM
;
7005 /* Unary plus (but not unary minus) is allowed on pointers. */
7006 if (code
== UNARY_PLUS_EXPR
)
7007 flags
|= WANT_POINTER
;
7008 arg
= build_expr_type_conversion (flags
, arg
, true);
7010 errstring
= (code
== NEGATE_EXPR
7011 ? _("wrong type argument to unary minus")
7012 : _("wrong type argument to unary plus"));
7015 if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7016 arg
= cp_perform_integral_promotions (arg
, complain
);
7018 /* Make sure the result is not an lvalue: a unary plus or minus
7019 expression is always a rvalue. */
7026 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7031 arg
= cp_default_conversion (arg
, complain
);
7032 if (arg
== error_mark_node
)
7033 return error_mark_node
;
7036 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
7037 | WANT_VECTOR_OR_COMPLEX
,
7039 errstring
= _("wrong type argument to bit-complement");
7040 else if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7042 /* Warn if the expression has boolean value. */
7043 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
7044 && (complain
& tf_warning
)
7045 && warning_at (location
, OPT_Wbool_operation
,
7046 "%<~%> on an expression of type %<bool%>"))
7047 inform (location
, "did you mean to use logical not (%<!%>)?");
7048 arg
= cp_perform_integral_promotions (arg
, complain
);
7050 else if (!noconvert
&& VECTOR_TYPE_P (TREE_TYPE (arg
)))
7051 arg
= mark_rvalue_use (arg
);
7055 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7056 errstring
= _("wrong type argument to abs");
7057 else if (!noconvert
)
7059 arg
= cp_default_conversion (arg
, complain
);
7060 if (arg
== error_mark_node
)
7061 return error_mark_node
;
7066 /* Conjugating a real value is a no-op, but allow it anyway. */
7067 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7068 errstring
= _("wrong type argument to conjugation");
7069 else if (!noconvert
)
7071 arg
= cp_default_conversion (arg
, complain
);
7072 if (arg
== error_mark_node
)
7073 return error_mark_node
;
7077 case TRUTH_NOT_EXPR
:
7078 if (gnu_vector_type_p (TREE_TYPE (arg
)))
7079 return cp_build_binary_op (input_location
, EQ_EXPR
, arg
,
7080 build_zero_cst (TREE_TYPE (arg
)), complain
);
7081 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
7083 val
= invert_truthvalue_loc (location
, arg
);
7084 if (arg
!= error_mark_node
)
7086 errstring
= _("in argument to unary !");
7094 arg
= build_real_imag_expr (input_location
, code
, arg
);
7097 case PREINCREMENT_EXPR
:
7098 case POSTINCREMENT_EXPR
:
7099 case PREDECREMENT_EXPR
:
7100 case POSTDECREMENT_EXPR
:
7101 /* Handle complex lvalues (when permitted)
7102 by reduction to simpler cases. */
7104 val
= unary_complex_lvalue (code
, arg
);
7108 arg
= mark_lvalue_use (arg
);
7110 /* Increment or decrement the real part of the value,
7111 and don't change the imaginary part. */
7112 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7116 arg
= cp_stabilize_reference (arg
);
7117 real
= cp_build_unary_op (REALPART_EXPR
, arg
, true, complain
);
7118 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, true, complain
);
7119 real
= cp_build_unary_op (code
, real
, true, complain
);
7120 if (real
== error_mark_node
|| imag
== error_mark_node
)
7121 return error_mark_node
;
7122 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
7126 /* Report invalid types. */
7128 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
7131 if (code
== PREINCREMENT_EXPR
)
7132 errstring
= _("no pre-increment operator for type");
7133 else if (code
== POSTINCREMENT_EXPR
)
7134 errstring
= _("no post-increment operator for type");
7135 else if (code
== PREDECREMENT_EXPR
)
7136 errstring
= _("no pre-decrement operator for type");
7138 errstring
= _("no post-decrement operator for type");
7141 else if (arg
== error_mark_node
)
7142 return error_mark_node
;
7144 /* Report something read-only. */
7146 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
7147 || TREE_READONLY (arg
))
7149 if (complain
& tf_error
)
7150 cxx_readonly_error (location
, arg
,
7151 ((code
== PREINCREMENT_EXPR
7152 || code
== POSTINCREMENT_EXPR
)
7153 ? lv_increment
: lv_decrement
));
7155 return error_mark_node
;
7160 tree declared_type
= unlowered_expr_type (arg
);
7162 argtype
= TREE_TYPE (arg
);
7164 /* ARM $5.2.5 last annotation says this should be forbidden. */
7165 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
7167 if (complain
& tf_error
)
7168 permerror (location
, (code
== PREINCREMENT_EXPR
7169 || code
== POSTINCREMENT_EXPR
)
7170 ? G_("ISO C++ forbids incrementing an enum")
7171 : G_("ISO C++ forbids decrementing an enum"));
7173 return error_mark_node
;
7176 /* Compute the increment. */
7178 if (TYPE_PTR_P (argtype
))
7180 tree type
= complete_type (TREE_TYPE (argtype
));
7182 if (!COMPLETE_OR_VOID_TYPE_P (type
))
7184 if (complain
& tf_error
)
7185 error_at (location
, ((code
== PREINCREMENT_EXPR
7186 || code
== POSTINCREMENT_EXPR
))
7187 ? G_("cannot increment a pointer to incomplete "
7189 : G_("cannot decrement a pointer to incomplete "
7191 TREE_TYPE (argtype
));
7193 return error_mark_node
;
7195 else if (!TYPE_PTROB_P (argtype
))
7197 if (complain
& tf_error
)
7198 pedwarn (location
, OPT_Wpointer_arith
,
7199 (code
== PREINCREMENT_EXPR
7200 || code
== POSTINCREMENT_EXPR
)
7201 ? G_("ISO C++ forbids incrementing a pointer "
7203 : G_("ISO C++ forbids decrementing a pointer "
7207 return error_mark_node
;
7209 else if (!verify_type_context (location
, TCTX_POINTER_ARITH
,
7210 TREE_TYPE (argtype
),
7211 !(complain
& tf_error
)))
7212 return error_mark_node
;
7214 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
7217 inc
= VECTOR_TYPE_P (argtype
)
7218 ? build_one_cst (argtype
)
7221 inc
= cp_convert (argtype
, inc
, complain
);
7223 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
7224 need to ask Objective-C to build the increment or decrement
7225 expression for it. */
7226 if (objc_is_property_ref (arg
))
7227 return objc_build_incr_expr_for_property_ref (input_location
, code
,
7230 /* Complain about anything else that is not a true lvalue. */
7231 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
7232 || code
== POSTINCREMENT_EXPR
)
7233 ? lv_increment
: lv_decrement
),
7235 return error_mark_node
;
7237 /* [depr.volatile.type] "Postfix ++ and -- expressions and
7238 prefix ++ and -- expressions of volatile-qualified arithmetic
7239 and pointer types are deprecated." */
7240 if (TREE_THIS_VOLATILE (arg
) || CP_TYPE_VOLATILE_P (TREE_TYPE (arg
)))
7241 warning_at (location
, OPT_Wvolatile
,
7242 "%qs expression of %<volatile%>-qualified type is "
7244 ((code
== PREINCREMENT_EXPR
7245 || code
== POSTINCREMENT_EXPR
)
7248 /* Forbid using -- or ++ in C++17 on `bool'. */
7249 if (TREE_CODE (declared_type
) == BOOLEAN_TYPE
)
7251 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
7253 if (complain
& tf_error
)
7255 "use of an operand of type %qT in %<operator--%> "
7256 "is forbidden", boolean_type_node
);
7257 return error_mark_node
;
7261 if (cxx_dialect
>= cxx17
)
7263 if (complain
& tf_error
)
7265 "use of an operand of type %qT in "
7266 "%<operator++%> is forbidden in C++17",
7268 return error_mark_node
;
7270 /* Otherwise, [depr.incr.bool] says this is deprecated. */
7272 warning_at (location
, OPT_Wdeprecated
,
7273 "use of an operand of type %qT "
7274 "in %<operator++%> is deprecated",
7277 val
= boolean_increment (code
, arg
);
7279 else if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
7280 /* An rvalue has no cv-qualifiers. */
7281 val
= build2 (code
, cv_unqualified (TREE_TYPE (arg
)), arg
, inc
);
7283 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
7285 TREE_SIDE_EFFECTS (val
) = 1;
7290 /* Note that this operation never does default_conversion
7291 regardless of NOCONVERT. */
7292 return cp_build_addr_expr (arg
, complain
);
7301 argtype
= TREE_TYPE (arg
);
7302 return build1 (code
, argtype
, arg
);
7305 if (complain
& tf_error
)
7306 error_at (location
, "%s", errstring
);
7307 return error_mark_node
;
7310 /* Hook for the c-common bits that build a unary op. */
7312 build_unary_op (location_t
/*location*/,
7313 enum tree_code code
, tree xarg
, bool noconvert
)
7315 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
7318 /* Adjust LVALUE, an MODIFY_EXPR, PREINCREMENT_EXPR or PREDECREMENT_EXPR,
7319 so that it is a valid lvalue even for GENERIC by replacing
7320 (lhs = rhs) with ((lhs = rhs), lhs)
7321 (--lhs) with ((--lhs), lhs)
7322 (++lhs) with ((++lhs), lhs)
7323 and if lhs has side-effects, calling cp_stabilize_reference on it, so
7324 that it can be evaluated multiple times. */
7327 genericize_compound_lvalue (tree lvalue
)
7329 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lvalue
, 0)))
7330 lvalue
= build2 (TREE_CODE (lvalue
), TREE_TYPE (lvalue
),
7331 cp_stabilize_reference (TREE_OPERAND (lvalue
, 0)),
7332 TREE_OPERAND (lvalue
, 1));
7333 return build2 (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (lvalue
, 0)),
7334 lvalue
, TREE_OPERAND (lvalue
, 0));
7337 /* Apply unary lvalue-demanding operator CODE to the expression ARG
7338 for certain kinds of expressions which are not really lvalues
7339 but which we can accept as lvalues.
7341 If ARG is not a kind of expression we can handle, return
7345 unary_complex_lvalue (enum tree_code code
, tree arg
)
7347 /* Inside a template, making these kinds of adjustments is
7348 pointless; we are only concerned with the type of the
7350 if (processing_template_decl
)
7353 /* Handle (a, b) used as an "lvalue". */
7354 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
7356 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), false,
7357 tf_warning_or_error
);
7358 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7359 TREE_OPERAND (arg
, 0), real_result
);
7362 /* Handle (a ? b : c) used as an "lvalue". */
7363 if (TREE_CODE (arg
) == COND_EXPR
7364 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
7365 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
7367 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
7368 if (TREE_CODE (arg
) == MODIFY_EXPR
7369 || TREE_CODE (arg
) == PREINCREMENT_EXPR
7370 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
7371 return unary_complex_lvalue (code
, genericize_compound_lvalue (arg
));
7373 if (code
!= ADDR_EXPR
)
7376 /* Handle (a = b) used as an "lvalue" for `&'. */
7377 if (TREE_CODE (arg
) == MODIFY_EXPR
7378 || TREE_CODE (arg
) == INIT_EXPR
)
7380 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), false,
7381 tf_warning_or_error
);
7382 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7384 suppress_warning (arg
/* What warning? */);
7388 if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (arg
))
7389 || TREE_CODE (arg
) == OFFSET_REF
)
7392 /* We permit compiler to make function calls returning
7393 objects of aggregate type look like lvalues. */
7397 if (TREE_CODE (targ
) == SAVE_EXPR
)
7398 targ
= TREE_OPERAND (targ
, 0);
7400 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
7402 if (TREE_CODE (arg
) == SAVE_EXPR
)
7405 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, tf_warning_or_error
);
7406 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
7409 if (TREE_CODE (arg
) == SAVE_EXPR
&& INDIRECT_REF_P (targ
))
7410 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
7411 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
7414 /* Don't let anything else be handled specially. */
7418 /* Mark EXP saying that we need to be able to take the
7419 address of it; it should not be allocated in a register.
7420 Value is true if successful. ARRAY_REF_P is true if this
7421 is for ARRAY_REF construction - in that case we don't want
7422 to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
7423 it is fine to use ARRAY_REFs for vector subscripts on vector
7426 C++: we do not allow `current_class_ptr' to be addressable. */
7429 cxx_mark_addressable (tree exp
, bool array_ref_p
)
7434 switch (TREE_CODE (x
))
7436 case VIEW_CONVERT_EXPR
:
7438 && TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7439 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x
, 0))))
7441 x
= TREE_OPERAND (x
, 0);
7446 error ("attempt to take address of bit-field");
7452 x
= TREE_OPERAND (x
, 0);
7456 if (x
== current_class_ptr
)
7458 error ("cannot take the address of %<this%>, which is an rvalue expression");
7459 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
7465 /* Caller should not be trying to mark initialized
7466 constant fields addressable. */
7467 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
7468 || DECL_IN_AGGR_P (x
) == 0
7470 || DECL_EXTERNAL (x
));
7474 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
7475 && !DECL_ARTIFICIAL (x
))
7477 if (VAR_P (x
) && DECL_HARD_REGISTER (x
))
7480 ("address of explicit register variable %qD requested", x
);
7483 else if (extra_warnings
)
7485 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
7487 TREE_ADDRESSABLE (x
) = 1;
7492 TREE_ADDRESSABLE (x
) = 1;
7496 TREE_ADDRESSABLE (x
) = 1;
7500 TREE_ADDRESSABLE (x
) = 1;
7501 cxx_mark_addressable (TREE_OPERAND (x
, 0));
7509 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
7512 build_x_conditional_expr (location_t loc
, tree ifexp
, tree op1
, tree op2
,
7513 tsubst_flags_t complain
)
7515 tree orig_ifexp
= ifexp
;
7516 tree orig_op1
= op1
;
7517 tree orig_op2
= op2
;
7520 if (processing_template_decl
)
7522 /* The standard says that the expression is type-dependent if
7523 IFEXP is type-dependent, even though the eventual type of the
7524 expression doesn't dependent on IFEXP. */
7525 if (type_dependent_expression_p (ifexp
)
7526 /* As a GNU extension, the middle operand may be omitted. */
7527 || (op1
&& type_dependent_expression_p (op1
))
7528 || type_dependent_expression_p (op2
))
7529 return build_min_nt_loc (loc
, COND_EXPR
, ifexp
, op1
, op2
);
7530 ifexp
= build_non_dependent_expr (ifexp
);
7532 op1
= build_non_dependent_expr (op1
);
7533 op2
= build_non_dependent_expr (op2
);
7536 expr
= build_conditional_expr (loc
, ifexp
, op1
, op2
, complain
);
7537 if (processing_template_decl
&& expr
!= error_mark_node
)
7539 tree min
= build_min_non_dep (COND_EXPR
, expr
,
7540 orig_ifexp
, orig_op1
, orig_op2
);
7541 expr
= convert_from_reference (min
);
7546 /* Given a list of expressions, return a compound expression
7547 that performs them all and returns the value of the last of them. */
7550 build_x_compound_expr_from_list (tree list
, expr_list_kind exp
,
7551 tsubst_flags_t complain
)
7553 tree expr
= TREE_VALUE (list
);
7555 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7556 && !CONSTRUCTOR_IS_DIRECT_INIT (expr
))
7558 if (complain
& tf_error
)
7559 pedwarn (cp_expr_loc_or_input_loc (expr
), 0,
7560 "list-initializer for non-class type must not "
7561 "be parenthesized");
7563 return error_mark_node
;
7566 if (TREE_CHAIN (list
))
7568 if (complain
& tf_error
)
7572 permerror (input_location
, "expression list treated as compound "
7573 "expression in initializer");
7576 permerror (input_location
, "expression list treated as compound "
7577 "expression in mem-initializer");
7580 permerror (input_location
, "expression list treated as compound "
7581 "expression in functional cast");
7587 return error_mark_node
;
7589 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
7590 expr
= build_x_compound_expr (EXPR_LOCATION (TREE_VALUE (list
)),
7591 expr
, TREE_VALUE (list
), NULL_TREE
,
7598 /* Like build_x_compound_expr_from_list, but using a VEC. */
7601 build_x_compound_expr_from_vec (vec
<tree
, va_gc
> *vec
, const char *msg
,
7602 tsubst_flags_t complain
)
7604 if (vec_safe_is_empty (vec
))
7606 else if (vec
->length () == 1)
7616 if (complain
& tf_error
)
7617 permerror (input_location
,
7618 "%s expression list treated as compound expression",
7621 return error_mark_node
;
7625 for (ix
= 1; vec
->iterate (ix
, &t
); ++ix
)
7626 expr
= build_x_compound_expr (EXPR_LOCATION (t
), expr
,
7627 t
, NULL_TREE
, complain
);
7633 /* Handle overloading of the ',' operator when needed. */
7636 build_x_compound_expr (location_t loc
, tree op1
, tree op2
,
7637 tree lookups
, tsubst_flags_t complain
)
7640 tree orig_op1
= op1
;
7641 tree orig_op2
= op2
;
7642 tree overload
= NULL_TREE
;
7644 if (processing_template_decl
)
7646 if (type_dependent_expression_p (op1
)
7647 || type_dependent_expression_p (op2
))
7649 result
= build_min_nt_loc (loc
, COMPOUND_EXPR
, op1
, op2
);
7651 = build_dependent_operator_type (lookups
, COMPOUND_EXPR
, false);
7654 op1
= build_non_dependent_expr (op1
);
7655 op2
= build_non_dependent_expr (op2
);
7658 result
= build_new_op (loc
, COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
,
7659 NULL_TREE
, lookups
, &overload
, complain
);
7661 result
= cp_build_compound_expr (op1
, op2
, complain
);
7663 if (processing_template_decl
&& result
!= error_mark_node
)
7665 if (overload
!= NULL_TREE
)
7666 return (build_min_non_dep_op_overload
7667 (COMPOUND_EXPR
, result
, overload
, orig_op1
, orig_op2
));
7669 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
7675 /* Like cp_build_compound_expr, but for the c-common bits. */
7678 build_compound_expr (location_t
/*loc*/, tree lhs
, tree rhs
)
7680 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
7683 /* Build a compound expression. */
7686 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
7688 lhs
= convert_to_void (lhs
, ICV_LEFT_OF_COMMA
, complain
);
7690 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
7691 return error_mark_node
;
7693 if (TREE_CODE (rhs
) == TARGET_EXPR
)
7695 /* If the rhs is a TARGET_EXPR, then build the compound
7696 expression inside the target_expr's initializer. This
7697 helps the compiler to eliminate unnecessary temporaries. */
7698 tree init
= TREE_OPERAND (rhs
, 1);
7700 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
7701 TREE_OPERAND (rhs
, 1) = init
;
7706 if (type_unknown_p (rhs
))
7708 if (complain
& tf_error
)
7709 error_at (cp_expr_loc_or_input_loc (rhs
),
7710 "no context to resolve type of %qE", rhs
);
7711 return error_mark_node
;
7714 return build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
7717 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
7718 casts away constness. CAST gives the type of cast. Returns true
7719 if the cast is ill-formed, false if it is well-formed.
7721 ??? This function warns for casting away any qualifier not just
7722 const. We would like to specify exactly what qualifiers are casted
7727 check_for_casting_away_constness (location_t loc
, tree src_type
,
7728 tree dest_type
, enum tree_code cast
,
7729 tsubst_flags_t complain
)
7731 /* C-style casts are allowed to cast away constness. With
7732 WARN_CAST_QUAL, we still want to issue a warning. */
7733 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
7736 if (!casts_away_constness (src_type
, dest_type
, complain
))
7742 if (complain
& tf_warning
)
7743 warning_at (loc
, OPT_Wcast_qual
,
7744 "cast from type %qT to type %qT casts away qualifiers",
7745 src_type
, dest_type
);
7748 case STATIC_CAST_EXPR
:
7749 if (complain
& tf_error
)
7750 error_at (loc
, "%<static_cast%> from type %qT to type %qT casts "
7752 src_type
, dest_type
);
7755 case REINTERPRET_CAST_EXPR
:
7756 if (complain
& tf_error
)
7757 error_at (loc
, "%<reinterpret_cast%> from type %qT to type %qT "
7758 "casts away qualifiers",
7759 src_type
, dest_type
);
7767 /* Warns if the cast from expression EXPR to type TYPE is useless. */
7769 maybe_warn_about_useless_cast (location_t loc
, tree type
, tree expr
,
7770 tsubst_flags_t complain
)
7772 if (warn_useless_cast
7773 && complain
& tf_warning
)
7775 if ((TYPE_REF_P (type
)
7776 && (TYPE_REF_IS_RVALUE (type
)
7777 ? xvalue_p (expr
) : lvalue_p (expr
))
7778 && same_type_p (TREE_TYPE (expr
), TREE_TYPE (type
)))
7779 || same_type_p (TREE_TYPE (expr
), type
))
7780 warning_at (loc
, OPT_Wuseless_cast
,
7781 "useless cast to type %q#T", type
);
7785 /* Warns if the cast ignores cv-qualifiers on TYPE. */
7787 maybe_warn_about_cast_ignoring_quals (location_t loc
, tree type
,
7788 tsubst_flags_t complain
)
7790 if (warn_ignored_qualifiers
7791 && complain
& tf_warning
7792 && !CLASS_TYPE_P (type
)
7793 && (cp_type_quals (type
) & (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)))
7794 warning_at (loc
, OPT_Wignored_qualifiers
,
7795 "type qualifiers ignored on cast result type");
7798 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
7799 (another pointer-to-member type in the same hierarchy) and return
7800 the converted expression. If ALLOW_INVERSE_P is permitted, a
7801 pointer-to-derived may be converted to pointer-to-base; otherwise,
7802 only the other direction is permitted. If C_CAST_P is true, this
7803 conversion is taking place as part of a C-style cast. */
7806 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
7807 bool c_cast_p
, tsubst_flags_t complain
)
7809 if (same_type_p (type
, TREE_TYPE (expr
)))
7812 if (TYPE_PTRDATAMEM_P (type
))
7814 tree obase
= TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
));
7815 tree nbase
= TYPE_PTRMEM_CLASS_TYPE (type
);
7816 tree delta
= (get_delta_difference
7818 allow_inverse_p
, c_cast_p
, complain
));
7820 if (delta
== error_mark_node
)
7821 return error_mark_node
;
7823 if (!same_type_p (obase
, nbase
))
7825 if (TREE_CODE (expr
) == PTRMEM_CST
)
7826 expr
= cplus_expand_constant (expr
);
7828 tree cond
= cp_build_binary_op (input_location
, EQ_EXPR
, expr
,
7829 build_int_cst (TREE_TYPE (expr
), -1),
7831 tree op1
= build_nop (ptrdiff_type_node
, expr
);
7832 tree op2
= cp_build_binary_op (input_location
, PLUS_EXPR
, op1
, delta
,
7835 expr
= fold_build3_loc (input_location
,
7836 COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
7839 return build_nop (type
, expr
);
7842 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
7843 allow_inverse_p
, c_cast_p
, complain
);
7846 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
7847 this static_cast is being attempted as one of the possible casts
7848 allowed by a C-style cast. (In that case, accessibility of base
7849 classes is not considered, and it is OK to cast away
7850 constness.) Return the result of the cast. *VALID_P is set to
7851 indicate whether or not the cast was valid. */
7854 build_static_cast_1 (location_t loc
, tree type
, tree expr
, bool c_cast_p
,
7855 bool *valid_p
, tsubst_flags_t complain
)
7861 /* Assume the cast is valid. */
7864 intype
= unlowered_expr_type (expr
);
7866 /* Save casted types in the function's used types hash table. */
7867 used_types_insert (type
);
7869 /* A prvalue of non-class type is cv-unqualified. */
7870 if (!CLASS_TYPE_P (type
))
7871 type
= cv_unqualified (type
);
7873 /* [expr.static.cast]
7875 An lvalue of type "cv1 B", where B is a class type, can be cast
7876 to type "reference to cv2 D", where D is a class derived (clause
7877 _class.derived_) from B, if a valid standard conversion from
7878 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
7879 same cv-qualification as, or greater cv-qualification than, cv1,
7880 and B is not a virtual base class of D. */
7881 /* We check this case before checking the validity of "TYPE t =
7882 EXPR;" below because for this case:
7885 struct D : public B { D(const B&); };
7887 void f() { static_cast<const D&>(b); }
7889 we want to avoid constructing a new D. The standard is not
7890 completely clear about this issue, but our interpretation is
7891 consistent with other compilers. */
7892 if (TYPE_REF_P (type
)
7893 && CLASS_TYPE_P (TREE_TYPE (type
))
7894 && CLASS_TYPE_P (intype
)
7895 && (TYPE_REF_IS_RVALUE (type
) || lvalue_p (expr
))
7896 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
7897 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
7898 build_pointer_type (TYPE_MAIN_VARIANT
7899 (TREE_TYPE (type
))),
7902 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
7906 if (processing_template_decl
)
7909 /* There is a standard conversion from "D*" to "B*" even if "B"
7910 is ambiguous or inaccessible. If this is really a
7911 static_cast, then we check both for inaccessibility and
7912 ambiguity. However, if this is a static_cast being performed
7913 because the user wrote a C-style cast, then accessibility is
7915 base
= lookup_base (TREE_TYPE (type
), intype
,
7916 c_cast_p
? ba_unique
: ba_check
,
7918 expr
= cp_build_addr_expr (expr
, complain
);
7920 if (sanitize_flags_p (SANITIZE_VPTR
))
7923 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
7929 /* Convert from "B*" to "D*". This function will check that "B"
7930 is not a virtual base of "D". Even if we don't have a guarantee
7931 that expr is NULL, if the static_cast is to a reference type,
7932 it is UB if it would be NULL, so omit the non-NULL check. */
7933 expr
= build_base_path (MINUS_EXPR
, expr
, base
,
7934 /*nonnull=*/flag_delete_null_pointer_checks
,
7937 /* Convert the pointer to a reference -- but then remember that
7938 there are no expressions with reference type in C++.
7940 We call rvalue so that there's an actual tree code
7941 (NON_LVALUE_EXPR) for the static_cast; otherwise, if the operand
7942 is a variable with the same type, the conversion would get folded
7943 away, leaving just the variable and causing lvalue_kind to give
7944 the wrong answer. */
7945 expr
= cp_fold_convert (type
, expr
);
7947 /* When -fsanitize=null, make sure to diagnose reference binding to
7948 NULL even when the reference is converted to pointer later on. */
7949 if (sanitize_flags_p (SANITIZE_NULL
)
7950 && TREE_CODE (expr
) == COND_EXPR
7951 && TREE_OPERAND (expr
, 2)
7952 && TREE_CODE (TREE_OPERAND (expr
, 2)) == INTEGER_CST
7953 && TREE_TYPE (TREE_OPERAND (expr
, 2)) == type
)
7954 ubsan_maybe_instrument_reference (&TREE_OPERAND (expr
, 2));
7956 return convert_from_reference (rvalue (expr
));
7959 /* "A glvalue of type cv1 T1 can be cast to type rvalue reference to
7960 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
7961 if (TYPE_REF_P (type
)
7962 && TYPE_REF_IS_RVALUE (type
)
7963 && (clk
= real_lvalue_p (expr
))
7964 && reference_compatible_p (TREE_TYPE (type
), intype
)
7965 && (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
7967 if (processing_template_decl
)
7969 if (clk
== clk_ordinary
)
7971 /* Handle the (non-bit-field) lvalue case here by casting to
7972 lvalue reference and then changing it to an rvalue reference.
7973 Casting an xvalue to rvalue reference will be handled by the
7975 tree lref
= cp_build_reference_type (TREE_TYPE (type
), false);
7976 result
= (perform_direct_initialization_if_possible
7977 (lref
, expr
, c_cast_p
, complain
));
7978 result
= build1 (NON_LVALUE_EXPR
, type
, result
);
7979 return convert_from_reference (result
);
7982 /* For a bit-field or packed field, bind to a temporary. */
7983 expr
= rvalue (expr
);
7986 /* Resolve overloaded address here rather than once in
7987 implicit_conversion and again in the inverse code below. */
7988 if (TYPE_PTRMEMFUNC_P (type
) && type_unknown_p (expr
))
7990 expr
= instantiate_type (type
, expr
, complain
);
7991 intype
= TREE_TYPE (expr
);
7994 /* [expr.static.cast]
7996 Any expression can be explicitly converted to type cv void. */
7997 if (VOID_TYPE_P (type
))
7998 return convert_to_void (expr
, ICV_CAST
, complain
);
8001 An abstract class shall not be used ... as the type of an explicit
8003 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
8004 return error_mark_node
;
8006 /* [expr.static.cast]
8008 An expression e can be explicitly converted to a type T using a
8009 static_cast of the form static_cast<T>(e) if the declaration T
8010 t(e);" is well-formed, for some invented temporary variable
8012 result
= perform_direct_initialization_if_possible (type
, expr
,
8013 c_cast_p
, complain
);
8014 /* P1975 allows static_cast<Aggr>(42), as well as static_cast<T[5]>(42),
8015 which initialize the first element of the aggregate. We need to handle
8016 the array case specifically. */
8017 if (result
== NULL_TREE
8018 && cxx_dialect
>= cxx20
8019 && TREE_CODE (type
) == ARRAY_TYPE
)
8021 /* Create { EXPR } and perform direct-initialization from it. */
8022 tree e
= build_constructor_single (init_list_type_node
, NULL_TREE
, expr
);
8023 CONSTRUCTOR_IS_DIRECT_INIT (e
) = true;
8024 CONSTRUCTOR_IS_PAREN_INIT (e
) = true;
8025 result
= perform_direct_initialization_if_possible (type
, e
, c_cast_p
,
8030 if (processing_template_decl
)
8033 result
= convert_from_reference (result
);
8035 /* [expr.static.cast]
8037 If T is a reference type, the result is an lvalue; otherwise,
8038 the result is an rvalue. */
8039 if (!TYPE_REF_P (type
))
8041 result
= rvalue (result
);
8043 if (result
== expr
&& SCALAR_TYPE_P (type
))
8044 /* Leave some record of the cast. */
8045 result
= build_nop (type
, expr
);
8050 /* [expr.static.cast]
8052 The inverse of any standard conversion sequence (clause _conv_),
8053 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
8054 (_conv.array_), function-to-pointer (_conv.func_), and boolean
8055 (_conv.bool_) conversions, can be performed explicitly using
8056 static_cast subject to the restriction that the explicit
8057 conversion does not cast away constness (_expr.const.cast_), and
8058 the following additional rules for specific cases: */
8059 /* For reference, the conversions not excluded are: integral
8060 promotions, floating-point promotion, integral conversions,
8061 floating-point conversions, floating-integral conversions,
8062 pointer conversions, and pointer to member conversions. */
8065 A value of integral _or enumeration_ type can be explicitly
8066 converted to an enumeration type. */
8067 /* The effect of all that is that any conversion between any two
8068 types which are integral, floating, or enumeration types can be
8070 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8071 || SCALAR_FLOAT_TYPE_P (type
))
8072 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
8073 || SCALAR_FLOAT_TYPE_P (intype
)))
8075 if (processing_template_decl
)
8077 return ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
, complain
);
8080 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
8081 && CLASS_TYPE_P (TREE_TYPE (type
))
8082 && CLASS_TYPE_P (TREE_TYPE (intype
))
8083 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
8084 (TREE_TYPE (intype
))),
8085 build_pointer_type (TYPE_MAIN_VARIANT
8086 (TREE_TYPE (type
))),
8091 if (processing_template_decl
)
8095 && check_for_casting_away_constness (loc
, intype
, type
,
8098 return error_mark_node
;
8099 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
8100 c_cast_p
? ba_unique
: ba_check
,
8102 expr
= build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false,
8105 if (sanitize_flags_p (SANITIZE_VPTR
))
8108 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
8114 return cp_fold_convert (type
, expr
);
8117 if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8118 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
8125 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
8126 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
8128 if (TYPE_PTRDATAMEM_P (type
))
8130 t1
= (build_ptrmem_type
8132 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
8133 t2
= (build_ptrmem_type
8135 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
8142 if (can_convert (t1
, t2
, complain
) || can_convert (t2
, t1
, complain
))
8145 && check_for_casting_away_constness (loc
, intype
, type
,
8148 return error_mark_node
;
8149 if (processing_template_decl
)
8151 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
8152 c_cast_p
, complain
);
8156 /* [expr.static.cast]
8158 An rvalue of type "pointer to cv void" can be explicitly
8159 converted to a pointer to object type. A value of type pointer
8160 to object converted to "pointer to cv void" and back to the
8161 original pointer type will have its original value. */
8162 if (TYPE_PTR_P (intype
)
8163 && VOID_TYPE_P (TREE_TYPE (intype
))
8164 && TYPE_PTROB_P (type
))
8167 && check_for_casting_away_constness (loc
, intype
, type
,
8170 return error_mark_node
;
8171 if (processing_template_decl
)
8173 return build_nop (type
, expr
);
8177 return error_mark_node
;
8180 /* Return an expression representing static_cast<TYPE>(EXPR). */
8183 build_static_cast (location_t loc
, tree type
, tree oexpr
,
8184 tsubst_flags_t complain
)
8190 if (type
== error_mark_node
|| expr
== error_mark_node
)
8191 return error_mark_node
;
8193 bool dependent
= (dependent_type_p (type
)
8194 || type_dependent_expression_p (expr
));
8198 expr
= build_min (STATIC_CAST_EXPR
, type
, oexpr
);
8199 /* We don't know if it will or will not have side effects. */
8200 TREE_SIDE_EFFECTS (expr
) = 1;
8201 result
= convert_from_reference (expr
);
8202 protected_set_expr_location (result
, loc
);
8205 else if (processing_template_decl
)
8206 expr
= build_non_dependent_expr (expr
);
8208 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8209 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8210 if (!TYPE_REF_P (type
)
8211 && TREE_CODE (expr
) == NOP_EXPR
8212 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8213 expr
= TREE_OPERAND (expr
, 0);
8215 result
= build_static_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8216 &valid_p
, complain
);
8219 if (result
!= error_mark_node
)
8221 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8222 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8224 if (processing_template_decl
)
8226 protected_set_expr_location (result
, loc
);
8230 if (complain
& tf_error
)
8232 error_at (loc
, "invalid %<static_cast%> from type %qT to type %qT",
8233 TREE_TYPE (expr
), type
);
8234 if ((TYPE_PTR_P (type
) || TYPE_REF_P (type
))
8235 && CLASS_TYPE_P (TREE_TYPE (type
))
8236 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
8237 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (TREE_TYPE (type
))),
8238 "class type %qT is incomplete", TREE_TYPE (type
));
8239 tree expr_type
= TREE_TYPE (expr
);
8240 if (TYPE_PTR_P (expr_type
))
8241 expr_type
= TREE_TYPE (expr_type
);
8242 if (CLASS_TYPE_P (expr_type
) && !COMPLETE_TYPE_P (expr_type
))
8243 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (expr_type
)),
8244 "class type %qT is incomplete", expr_type
);
8246 return error_mark_node
;
8249 /* EXPR is an expression with member function or pointer-to-member
8250 function type. TYPE is a pointer type. Converting EXPR to TYPE is
8251 not permitted by ISO C++, but we accept it in some modes. If we
8252 are not in one of those modes, issue a diagnostic. Return the
8253 converted expression. */
8256 convert_member_func_to_ptr (tree type
, tree expr
, tsubst_flags_t complain
)
8261 intype
= TREE_TYPE (expr
);
8262 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
8263 || TREE_CODE (intype
) == METHOD_TYPE
);
8265 if (!(complain
& tf_warning_or_error
))
8266 return error_mark_node
;
8268 location_t loc
= cp_expr_loc_or_input_loc (expr
);
8270 if (pedantic
|| warn_pmf2ptr
)
8271 pedwarn (loc
, pedantic
? OPT_Wpedantic
: OPT_Wpmf_conversions
,
8272 "converting from %qH to %qI", intype
, type
);
8274 STRIP_ANY_LOCATION_WRAPPER (expr
);
8276 if (TREE_CODE (intype
) == METHOD_TYPE
)
8277 expr
= build_addr_func (expr
, complain
);
8278 else if (TREE_CODE (expr
) == PTRMEM_CST
)
8279 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
8282 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
8283 decl
= build_address (decl
);
8284 expr
= get_member_function_from_ptrfunc (&decl
, expr
, complain
);
8287 if (expr
== error_mark_node
)
8288 return error_mark_node
;
8290 expr
= build_nop (type
, expr
);
8291 SET_EXPR_LOCATION (expr
, loc
);
8295 /* Build a NOP_EXPR to TYPE, but mark it as a reinterpret_cast so that
8296 constexpr evaluation knows to reject it. */
8299 build_nop_reinterpret (tree type
, tree expr
)
8301 tree ret
= build_nop (type
, expr
);
8303 REINTERPRET_CAST_P (ret
) = true;
8307 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
8308 If C_CAST_P is true, this reinterpret cast is being done as part of
8309 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
8310 indicate whether or not reinterpret_cast was valid. */
8313 build_reinterpret_cast_1 (location_t loc
, tree type
, tree expr
,
8314 bool c_cast_p
, bool *valid_p
,
8315 tsubst_flags_t complain
)
8319 /* Assume the cast is invalid. */
8323 if (type
== error_mark_node
|| error_operand_p (expr
))
8324 return error_mark_node
;
8326 intype
= TREE_TYPE (expr
);
8328 /* Save casted types in the function's used types hash table. */
8329 used_types_insert (type
);
8331 /* A prvalue of non-class type is cv-unqualified. */
8332 if (!CLASS_TYPE_P (type
))
8333 type
= cv_unqualified (type
);
8335 /* [expr.reinterpret.cast]
8336 A glvalue of type T1, designating an object x, can be cast to the type
8337 "reference to T2" if an expression of type "pointer to T1" can be
8338 explicitly converted to the type "pointer to T2" using a reinterpret_cast.
8339 The result is that of *reinterpret_cast<T2 *>(p) where p is a pointer to x
8340 of type "pointer to T1". No temporary is created, no copy is made, and no
8341 constructors (11.4.4) or conversion functions (11.4.7) are called. */
8342 if (TYPE_REF_P (type
))
8344 if (!glvalue_p (expr
))
8346 if (complain
& tf_error
)
8347 error_at (loc
, "invalid cast of a prvalue expression of type "
8350 return error_mark_node
;
8353 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
8354 "B" are related class types; the reinterpret_cast does not
8355 adjust the pointer. */
8356 if (TYPE_PTR_P (intype
)
8357 && (complain
& tf_warning
)
8358 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
8359 COMPARE_BASE
| COMPARE_DERIVED
)))
8360 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
8363 expr
= cp_build_addr_expr (expr
, complain
);
8365 if (warn_strict_aliasing
> 2)
8366 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8368 if (expr
!= error_mark_node
)
8369 expr
= build_reinterpret_cast_1
8370 (loc
, build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
8372 if (expr
!= error_mark_node
)
8373 /* cp_build_indirect_ref isn't right for rvalue refs. */
8374 expr
= convert_from_reference (fold_convert (type
, expr
));
8378 /* As a G++ extension, we consider conversions from member
8379 functions, and pointers to member functions to
8380 pointer-to-function and pointer-to-void types. If
8381 -Wno-pmf-conversions has not been specified,
8382 convert_member_func_to_ptr will issue an error message. */
8383 if ((TYPE_PTRMEMFUNC_P (intype
)
8384 || TREE_CODE (intype
) == METHOD_TYPE
)
8385 && TYPE_PTR_P (type
)
8386 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
8387 || VOID_TYPE_P (TREE_TYPE (type
))))
8388 return convert_member_func_to_ptr (type
, expr
, complain
);
8390 /* If the cast is not to a reference type, the lvalue-to-rvalue,
8391 array-to-pointer, and function-to-pointer conversions are
8393 expr
= decay_conversion (expr
, complain
);
8395 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8396 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8397 if (TREE_CODE (expr
) == NOP_EXPR
8398 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8399 expr
= TREE_OPERAND (expr
, 0);
8401 if (error_operand_p (expr
))
8402 return error_mark_node
;
8404 intype
= TREE_TYPE (expr
);
8406 /* [expr.reinterpret.cast]
8407 A pointer can be converted to any integral type large enough to
8408 hold it. ... A value of type std::nullptr_t can be converted to
8409 an integral type; the conversion has the same meaning and
8410 validity as a conversion of (void*)0 to the integral type. */
8411 if (CP_INTEGRAL_TYPE_P (type
)
8412 && (TYPE_PTR_P (intype
) || NULLPTR_TYPE_P (intype
)))
8414 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
8416 if (complain
& tf_error
)
8417 permerror (loc
, "cast from %qH to %qI loses precision",
8420 return error_mark_node
;
8422 if (NULLPTR_TYPE_P (intype
))
8423 return build_int_cst (type
, 0);
8425 /* [expr.reinterpret.cast]
8426 A value of integral or enumeration type can be explicitly
8427 converted to a pointer. */
8428 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
8431 else if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8432 || TYPE_PTR_OR_PTRMEM_P (type
))
8433 && same_type_p (type
, intype
))
8435 return rvalue (expr
);
8436 else if (TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
8438 if ((complain
& tf_warning
)
8439 && !cxx_safe_function_type_cast_p (TREE_TYPE (type
),
8440 TREE_TYPE (intype
)))
8441 warning_at (loc
, OPT_Wcast_function_type
,
8442 "cast between incompatible function types"
8443 " from %qH to %qI", intype
, type
);
8444 return build_nop_reinterpret (type
, expr
);
8446 else if (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
))
8448 if ((complain
& tf_warning
)
8449 && !cxx_safe_function_type_cast_p
8450 (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (type
)),
8451 TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (intype
))))
8452 warning_at (loc
, OPT_Wcast_function_type
,
8453 "cast between incompatible pointer to member types"
8454 " from %qH to %qI", intype
, type
);
8455 return build_nop_reinterpret (type
, expr
);
8457 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8458 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
8461 && check_for_casting_away_constness (loc
, intype
, type
,
8462 REINTERPRET_CAST_EXPR
,
8464 return error_mark_node
;
8465 /* Warn about possible alignment problems. */
8466 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
8467 && (complain
& tf_warning
)
8468 && !VOID_TYPE_P (type
)
8469 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
8470 && COMPLETE_TYPE_P (TREE_TYPE (type
))
8471 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
8472 && min_align_of_type (TREE_TYPE (type
))
8473 > min_align_of_type (TREE_TYPE (intype
)))
8474 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
8475 "increases required alignment of target type",
8478 if (warn_strict_aliasing
<= 2)
8479 /* strict_aliasing_warning STRIP_NOPs its expr. */
8480 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8482 return build_nop_reinterpret (type
, expr
);
8484 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
8485 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
8487 if (complain
& tf_warning
)
8488 /* C++11 5.2.10 p8 says that "Converting a function pointer to an
8489 object pointer type or vice versa is conditionally-supported." */
8490 warning_at (loc
, OPT_Wconditionally_supported
,
8491 "casting between pointer-to-function and "
8492 "pointer-to-object is conditionally-supported");
8493 return build_nop_reinterpret (type
, expr
);
8495 else if (gnu_vector_type_p (type
) && scalarish_type_p (intype
))
8496 return convert_to_vector (type
, rvalue (expr
));
8497 else if (gnu_vector_type_p (intype
)
8498 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8499 return convert_to_integer_nofold (type
, expr
);
8504 if (complain
& tf_error
)
8505 error_at (loc
, "invalid cast from type %qT to type %qT",
8507 return error_mark_node
;
8510 expr
= cp_convert (type
, expr
, complain
);
8511 if (TREE_CODE (expr
) == NOP_EXPR
)
8512 /* Mark any nop_expr that created as a reintepret_cast. */
8513 REINTERPRET_CAST_P (expr
) = true;
8518 build_reinterpret_cast (location_t loc
, tree type
, tree expr
,
8519 tsubst_flags_t complain
)
8523 if (type
== error_mark_node
|| expr
== error_mark_node
)
8524 return error_mark_node
;
8526 if (processing_template_decl
)
8528 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
8530 if (!TREE_SIDE_EFFECTS (t
)
8531 && type_dependent_expression_p (expr
))
8532 /* There might turn out to be side effects inside expr. */
8533 TREE_SIDE_EFFECTS (t
) = 1;
8534 r
= convert_from_reference (t
);
8535 protected_set_expr_location (r
, loc
);
8539 r
= build_reinterpret_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8540 /*valid_p=*/NULL
, complain
);
8541 if (r
!= error_mark_node
)
8543 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8544 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8546 protected_set_expr_location (r
, loc
);
8550 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
8551 return an appropriate expression. Otherwise, return
8552 error_mark_node. If the cast is not valid, and COMPLAIN is true,
8553 then a diagnostic will be issued. If VALID_P is non-NULL, we are
8554 performing a C-style cast, its value upon return will indicate
8555 whether or not the conversion succeeded. */
8558 build_const_cast_1 (location_t loc
, tree dst_type
, tree expr
,
8559 tsubst_flags_t complain
, bool *valid_p
)
8562 tree reference_type
;
8564 /* Callers are responsible for handling error_mark_node as a
8565 destination type. */
8566 gcc_assert (dst_type
!= error_mark_node
);
8567 /* In a template, callers should be building syntactic
8568 representations of casts, not using this machinery. */
8569 gcc_assert (!processing_template_decl
);
8571 /* Assume the conversion is invalid. */
8575 if (!INDIRECT_TYPE_P (dst_type
) && !TYPE_PTRDATAMEM_P (dst_type
))
8577 if (complain
& tf_error
)
8578 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8579 "which is not a pointer, reference, "
8580 "nor a pointer-to-data-member type", dst_type
);
8581 return error_mark_node
;
8584 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
8586 if (complain
& tf_error
)
8587 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8588 "which is a pointer or reference to a function type",
8590 return error_mark_node
;
8593 /* A prvalue of non-class type is cv-unqualified. */
8594 dst_type
= cv_unqualified (dst_type
);
8596 /* Save casted types in the function's used types hash table. */
8597 used_types_insert (dst_type
);
8599 src_type
= TREE_TYPE (expr
);
8600 /* Expressions do not really have reference types. */
8601 if (TYPE_REF_P (src_type
))
8602 src_type
= TREE_TYPE (src_type
);
8604 /* [expr.const.cast]
8606 For two object types T1 and T2, if a pointer to T1 can be explicitly
8607 converted to the type "pointer to T2" using a const_cast, then the
8608 following conversions can also be made:
8610 -- an lvalue of type T1 can be explicitly converted to an lvalue of
8611 type T2 using the cast const_cast<T2&>;
8613 -- a glvalue of type T1 can be explicitly converted to an xvalue of
8614 type T2 using the cast const_cast<T2&&>; and
8616 -- if T1 is a class type, a prvalue of type T1 can be explicitly
8617 converted to an xvalue of type T2 using the cast const_cast<T2&&>. */
8619 if (TYPE_REF_P (dst_type
))
8621 reference_type
= dst_type
;
8622 if (!TYPE_REF_IS_RVALUE (dst_type
)
8628 if (complain
& tf_error
)
8629 error_at (loc
, "invalid %<const_cast%> of an rvalue of type %qT "
8631 src_type
, dst_type
);
8632 return error_mark_node
;
8634 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
8635 src_type
= build_pointer_type (src_type
);
8639 reference_type
= NULL_TREE
;
8640 /* If the destination type is not a reference type, the
8641 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
8642 conversions are performed. */
8643 src_type
= type_decays_to (src_type
);
8644 if (src_type
== error_mark_node
)
8645 return error_mark_node
;
8648 if (TYPE_PTR_P (src_type
) || TYPE_PTRDATAMEM_P (src_type
))
8650 if (comp_ptr_ttypes_const (dst_type
, src_type
, bounds_none
))
8655 /* This cast is actually a C-style cast. Issue a warning if
8656 the user is making a potentially unsafe cast. */
8657 check_for_casting_away_constness (loc
, src_type
, dst_type
,
8658 CAST_EXPR
, complain
);
8659 /* ??? comp_ptr_ttypes_const ignores TYPE_ALIGN. */
8660 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
8661 && (complain
& tf_warning
)
8662 && min_align_of_type (TREE_TYPE (dst_type
))
8663 > min_align_of_type (TREE_TYPE (src_type
)))
8664 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
8665 "increases required alignment of target type",
8666 src_type
, dst_type
);
8670 expr
= cp_build_addr_expr (expr
, complain
);
8671 if (expr
== error_mark_node
)
8672 return error_mark_node
;
8673 expr
= build_nop (reference_type
, expr
);
8674 return convert_from_reference (expr
);
8678 expr
= decay_conversion (expr
, complain
);
8679 if (expr
== error_mark_node
)
8680 return error_mark_node
;
8682 /* build_c_cast puts on a NOP_EXPR to make the result not an
8683 lvalue. Strip such NOP_EXPRs if VALUE is being used in
8684 non-lvalue context. */
8685 if (TREE_CODE (expr
) == NOP_EXPR
8686 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8687 expr
= TREE_OPERAND (expr
, 0);
8688 return build_nop (dst_type
, expr
);
8692 && !at_least_as_qualified_p (TREE_TYPE (dst_type
),
8693 TREE_TYPE (src_type
)))
8694 check_for_casting_away_constness (loc
, src_type
, dst_type
,
8695 CAST_EXPR
, complain
);
8698 if (complain
& tf_error
)
8699 error_at (loc
, "invalid %<const_cast%> from type %qT to type %qT",
8700 src_type
, dst_type
);
8701 return error_mark_node
;
8705 build_const_cast (location_t loc
, tree type
, tree expr
,
8706 tsubst_flags_t complain
)
8710 if (type
== error_mark_node
|| error_operand_p (expr
))
8711 return error_mark_node
;
8713 if (processing_template_decl
)
8715 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
8717 if (!TREE_SIDE_EFFECTS (t
)
8718 && type_dependent_expression_p (expr
))
8719 /* There might turn out to be side effects inside expr. */
8720 TREE_SIDE_EFFECTS (t
) = 1;
8721 r
= convert_from_reference (t
);
8722 protected_set_expr_location (r
, loc
);
8726 r
= build_const_cast_1 (loc
, type
, expr
, complain
, /*valid_p=*/NULL
);
8727 if (r
!= error_mark_node
)
8729 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8730 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8732 protected_set_expr_location (r
, loc
);
8736 /* Like cp_build_c_cast, but for the c-common bits. */
8739 build_c_cast (location_t loc
, tree type
, tree expr
)
8741 return cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
8744 /* Like the "build_c_cast" used for c-common, but using cp_expr to
8745 preserve location information even for tree nodes that don't
8749 build_c_cast (location_t loc
, tree type
, cp_expr expr
)
8751 cp_expr result
= cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
8752 result
.set_location (loc
);
8756 /* Build an expression representing an explicit C-style cast to type
8757 TYPE of expression EXPR. */
8760 cp_build_c_cast (location_t loc
, tree type
, tree expr
,
8761 tsubst_flags_t complain
)
8767 if (type
== error_mark_node
|| error_operand_p (expr
))
8768 return error_mark_node
;
8770 if (processing_template_decl
)
8772 tree t
= build_min (CAST_EXPR
, type
,
8773 tree_cons (NULL_TREE
, value
, NULL_TREE
));
8774 /* We don't know if it will or will not have side effects. */
8775 TREE_SIDE_EFFECTS (t
) = 1;
8776 return convert_from_reference (t
);
8779 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
8780 'Class') should always be retained, because this information aids
8781 in method lookup. */
8782 if (objc_is_object_ptr (type
)
8783 && objc_is_object_ptr (TREE_TYPE (expr
)))
8784 return build_nop (type
, expr
);
8786 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8787 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8788 if (!TYPE_REF_P (type
)
8789 && TREE_CODE (value
) == NOP_EXPR
8790 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
8791 value
= TREE_OPERAND (value
, 0);
8793 if (TREE_CODE (type
) == ARRAY_TYPE
)
8795 /* Allow casting from T1* to T2[] because Cfront allows it.
8796 NIHCL uses it. It is not valid ISO C++ however. */
8797 if (TYPE_PTR_P (TREE_TYPE (expr
)))
8799 if (complain
& tf_error
)
8800 permerror (loc
, "ISO C++ forbids casting to an array type %qT",
8803 return error_mark_node
;
8804 type
= build_pointer_type (TREE_TYPE (type
));
8808 if (complain
& tf_error
)
8809 error_at (loc
, "ISO C++ forbids casting to an array type %qT",
8811 return error_mark_node
;
8815 if (FUNC_OR_METHOD_TYPE_P (type
))
8817 if (complain
& tf_error
)
8818 error_at (loc
, "invalid cast to function type %qT", type
);
8819 return error_mark_node
;
8822 if (TYPE_PTR_P (type
)
8823 && TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
8824 /* Casting to an integer of smaller size is an error detected elsewhere. */
8825 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (value
))
8826 /* Don't warn about converting any constant. */
8827 && !TREE_CONSTANT (value
))
8828 warning_at (loc
, OPT_Wint_to_pointer_cast
,
8829 "cast to pointer from integer of different size");
8831 /* A C-style cast can be a const_cast. */
8832 result
= build_const_cast_1 (loc
, type
, value
, complain
& tf_warning
,
8836 if (result
!= error_mark_node
)
8838 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
8839 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8844 /* Or a static cast. */
8845 result
= build_static_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
8846 &valid_p
, complain
);
8847 /* Or a reinterpret_cast. */
8849 result
= build_reinterpret_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
8850 &valid_p
, complain
);
8851 /* The static_cast or reinterpret_cast may be followed by a
8854 /* A valid cast may result in errors if, for example, a
8855 conversion to an ambiguous base class is required. */
8856 && !error_operand_p (result
))
8860 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
8861 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8863 /* Non-class rvalues always have cv-unqualified type. */
8864 if (!CLASS_TYPE_P (type
))
8865 type
= TYPE_MAIN_VARIANT (type
);
8866 result_type
= TREE_TYPE (result
);
8867 if (!CLASS_TYPE_P (result_type
) && !TYPE_REF_P (type
))
8868 result_type
= TYPE_MAIN_VARIANT (result_type
);
8869 /* If the type of RESULT does not match TYPE, perform a
8870 const_cast to make it match. If the static_cast or
8871 reinterpret_cast succeeded, we will differ by at most
8872 cv-qualification, so the follow-on const_cast is guaranteed
8874 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
8876 result
= build_const_cast_1 (loc
, type
, result
, false, &valid_p
);
8877 gcc_assert (valid_p
);
8882 return error_mark_node
;
8885 /* For use from the C common bits. */
8887 build_modify_expr (location_t location
,
8888 tree lhs
, tree
/*lhs_origtype*/,
8889 enum tree_code modifycode
,
8890 location_t
/*rhs_location*/, tree rhs
,
8891 tree
/*rhs_origtype*/)
8893 return cp_build_modify_expr (location
, lhs
, modifycode
, rhs
,
8894 tf_warning_or_error
);
8897 /* Build an assignment expression of lvalue LHS from value RHS.
8898 MODIFYCODE is the code for a binary operator that we use
8899 to combine the old value of LHS with RHS to get the new value.
8900 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
8902 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
8905 cp_build_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
8906 tree rhs
, tsubst_flags_t complain
)
8908 lhs
= mark_lvalue_use_nonread (lhs
);
8910 tree result
= NULL_TREE
;
8912 tree lhstype
= TREE_TYPE (lhs
);
8914 tree olhstype
= lhstype
;
8915 bool plain_assign
= (modifycode
== NOP_EXPR
);
8916 bool compound_side_effects_p
= false;
8917 tree preeval
= NULL_TREE
;
8919 /* Avoid duplicate error messages from operands that had errors. */
8920 if (error_operand_p (lhs
) || error_operand_p (rhs
))
8921 return error_mark_node
;
8923 while (TREE_CODE (lhs
) == COMPOUND_EXPR
)
8925 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
8926 compound_side_effects_p
= true;
8927 lhs
= TREE_OPERAND (lhs
, 1);
8930 /* Handle control structure constructs used as "lvalues". Note that we
8931 leave COMPOUND_EXPR on the LHS because it is sequenced after the RHS. */
8932 switch (TREE_CODE (lhs
))
8934 /* Handle --foo = 5; as these are valid constructs in C++. */
8935 case PREDECREMENT_EXPR
:
8936 case PREINCREMENT_EXPR
:
8937 if (compound_side_effects_p
)
8938 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
8939 lhs
= genericize_compound_lvalue (lhs
);
8941 /* If we had (bar, --foo) = 5; or (bar, (baz, --foo)) = 5;
8942 and looked through the COMPOUND_EXPRs, readd them now around
8943 the resulting lhs. */
8944 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
8946 lhs
= build2 (COMPOUND_EXPR
, lhstype
, TREE_OPERAND (olhs
, 0), lhs
);
8947 tree
*ptr
= &TREE_OPERAND (lhs
, 1);
8948 for (olhs
= TREE_OPERAND (olhs
, 1);
8949 TREE_CODE (olhs
) == COMPOUND_EXPR
;
8950 olhs
= TREE_OPERAND (olhs
, 1))
8952 *ptr
= build2 (COMPOUND_EXPR
, lhstype
,
8953 TREE_OPERAND (olhs
, 0), *ptr
);
8954 ptr
= &TREE_OPERAND (*ptr
, 1);
8960 if (compound_side_effects_p
)
8961 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
8962 lhs
= genericize_compound_lvalue (lhs
);
8963 goto maybe_add_compound
;
8967 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
8968 when neither operand has side-effects. */
8969 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
8970 return error_mark_node
;
8972 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
8973 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
8975 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
8976 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
8978 TREE_OPERAND (lhs
, 0),
8979 TREE_OPERAND (lhs
, 1)),
8980 TREE_OPERAND (lhs
, 0),
8981 TREE_OPERAND (lhs
, 1));
8984 /* Handle (a ? b : c) used as an "lvalue". */
8987 /* Produce (a ? (b = rhs) : (c = rhs))
8988 except that the RHS goes through a save-expr
8989 so the code to compute it is only emitted once. */
8990 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
8992 if (complain
& tf_error
)
8993 error_at (cp_expr_loc_or_loc (rhs
, loc
),
8994 "void value not ignored as it ought to be");
8995 return error_mark_node
;
8998 rhs
= stabilize_expr (rhs
, &preeval
);
9000 /* Check this here to avoid odd errors when trying to convert
9001 a throw to the type of the COND_EXPR. */
9002 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9003 return error_mark_node
;
9005 tree op1
= TREE_OPERAND (lhs
, 1);
9006 if (TREE_CODE (op1
) != THROW_EXPR
)
9007 op1
= cp_build_modify_expr (loc
, op1
, modifycode
, rhs
, complain
);
9008 /* When sanitizing undefined behavior, even when rhs doesn't need
9009 stabilization at this point, the sanitization might add extra
9010 SAVE_EXPRs in there and so make sure there is no tree sharing
9011 in the rhs, otherwise those SAVE_EXPRs will have initialization
9012 only in one of the two branches. */
9013 if (sanitize_flags_p (SANITIZE_UNDEFINED
9014 | SANITIZE_UNDEFINED_NONDEFAULT
))
9015 rhs
= unshare_expr (rhs
);
9016 tree op2
= TREE_OPERAND (lhs
, 2);
9017 if (TREE_CODE (op2
) != THROW_EXPR
)
9018 op2
= cp_build_modify_expr (loc
, op2
, modifycode
, rhs
, complain
);
9019 tree cond
= build_conditional_expr (input_location
,
9020 TREE_OPERAND (lhs
, 0), op1
, op2
,
9023 if (cond
== error_mark_node
)
9025 /* If we had (e, (a ? b : c)) = d; or (e, (f, (a ? b : c))) = d;
9026 and looked through the COMPOUND_EXPRs, readd them now around
9027 the resulting cond before adding the preevaluated rhs. */
9028 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
9030 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9031 TREE_OPERAND (olhs
, 0), cond
);
9032 tree
*ptr
= &TREE_OPERAND (cond
, 1);
9033 for (olhs
= TREE_OPERAND (olhs
, 1);
9034 TREE_CODE (olhs
) == COMPOUND_EXPR
;
9035 olhs
= TREE_OPERAND (olhs
, 1))
9037 *ptr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9038 TREE_OPERAND (olhs
, 0), *ptr
);
9039 ptr
= &TREE_OPERAND (*ptr
, 1);
9042 /* Make sure the code to compute the rhs comes out
9043 before the split. */
9053 if (modifycode
== INIT_EXPR
)
9055 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
9056 /* Do the default thing. */;
9057 else if (TREE_CODE (rhs
) == CONSTRUCTOR
)
9059 /* Compound literal. */
9060 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
9061 /* Call convert to generate an error; see PR 11063. */
9062 rhs
= convert (lhstype
, rhs
);
9063 result
= build2 (INIT_EXPR
, lhstype
, lhs
, rhs
);
9064 TREE_SIDE_EFFECTS (result
) = 1;
9067 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
9068 /* Do the default thing. */;
9071 releasing_vec rhs_vec
= make_tree_vector_single (rhs
);
9072 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
9073 &rhs_vec
, lhstype
, LOOKUP_NORMAL
,
9075 if (result
== NULL_TREE
)
9076 return error_mark_node
;
9082 lhs
= require_complete_type_sfinae (lhs
, complain
);
9083 if (lhs
== error_mark_node
)
9084 return error_mark_node
;
9086 if (modifycode
== NOP_EXPR
)
9088 if (c_dialect_objc ())
9090 result
= objc_maybe_build_modify_expr (lhs
, rhs
);
9095 /* `operator=' is not an inheritable operator. */
9096 if (! MAYBE_CLASS_TYPE_P (lhstype
))
9097 /* Do the default thing. */;
9100 result
= build_new_op (input_location
, MODIFY_EXPR
,
9101 LOOKUP_NORMAL
, lhs
, rhs
,
9102 make_node (NOP_EXPR
), NULL_TREE
,
9103 /*overload=*/NULL
, complain
);
9104 if (result
== NULL_TREE
)
9105 return error_mark_node
;
9112 tree init
= NULL_TREE
;
9114 /* A binary op has been requested. Combine the old LHS
9115 value with the RHS producing the value we should actually
9116 store into the LHS. */
9117 gcc_assert (!((TYPE_REF_P (lhstype
)
9118 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
9119 || MAYBE_CLASS_TYPE_P (lhstype
)));
9121 /* An expression of the form E1 op= E2. [expr.ass] says:
9122 "Such expressions are deprecated if E1 has volatile-qualified
9123 type." We warn here rather than in cp_genericize_r because
9124 for compound assignments we are supposed to warn even if the
9125 assignment is a discarded-value expression. */
9126 if (TREE_THIS_VOLATILE (lhs
) || CP_TYPE_VOLATILE_P (lhstype
))
9127 warning_at (loc
, OPT_Wvolatile
,
9128 "compound assignment with %<volatile%>-qualified left "
9129 "operand is deprecated");
9130 /* Preevaluate the RHS to make sure its evaluation is complete
9131 before the lvalue-to-rvalue conversion of the LHS:
9133 [expr.ass] With respect to an indeterminately-sequenced
9134 function call, the operation of a compound assignment is a
9135 single evaluation. [ Note: Therefore, a function call shall
9136 not intervene between the lvalue-to-rvalue conversion and the
9137 side effect associated with any single compound assignment
9138 operator. -- end note ] */
9139 lhs
= cp_stabilize_reference (lhs
);
9140 rhs
= decay_conversion (rhs
, complain
);
9141 if (rhs
== error_mark_node
)
9142 return error_mark_node
;
9143 rhs
= stabilize_expr (rhs
, &init
);
9144 newrhs
= cp_build_binary_op (loc
, modifycode
, lhs
, rhs
, complain
);
9145 if (newrhs
== error_mark_node
)
9147 if (complain
& tf_error
)
9148 inform (loc
, " in evaluation of %<%Q(%#T, %#T)%>",
9149 modifycode
, TREE_TYPE (lhs
), TREE_TYPE (rhs
));
9150 return error_mark_node
;
9154 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), init
, newrhs
);
9156 /* Now it looks like a plain assignment. */
9157 modifycode
= NOP_EXPR
;
9158 if (c_dialect_objc ())
9160 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
9165 gcc_assert (!TYPE_REF_P (lhstype
));
9166 gcc_assert (!TYPE_REF_P (TREE_TYPE (newrhs
)));
9169 /* The left-hand side must be an lvalue. */
9170 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9171 return error_mark_node
;
9173 /* Warn about modifying something that is `const'. Don't warn if
9174 this is initialization. */
9175 if (modifycode
!= INIT_EXPR
9176 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
9177 /* Functions are not modifiable, even though they are
9179 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (lhs
))
9180 /* If it's an aggregate and any field is const, then it is
9181 effectively const. */
9182 || (CLASS_TYPE_P (lhstype
)
9183 && C_TYPE_FIELDS_READONLY (lhstype
))))
9185 if (complain
& tf_error
)
9186 cxx_readonly_error (loc
, lhs
, lv_assign
);
9187 return error_mark_node
;
9190 /* If storing into a structure or union member, it may have been given a
9191 lowered bitfield type. We need to convert to the declared type first,
9192 so retrieve it now. */
9194 olhstype
= unlowered_expr_type (lhs
);
9196 /* Convert new value to destination type. */
9198 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
9202 if (BRACE_ENCLOSED_INITIALIZER_P (newrhs
))
9204 if (modifycode
!= INIT_EXPR
)
9206 if (complain
& tf_error
)
9208 "assigning to an array from an initializer list");
9209 return error_mark_node
;
9211 if (check_array_initializer (lhs
, lhstype
, newrhs
))
9212 return error_mark_node
;
9213 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9214 if (newrhs
== error_mark_node
)
9215 return error_mark_node
;
9218 /* C++11 8.5/17: "If the destination type is an array of characters,
9219 an array of char16_t, an array of char32_t, or an array of wchar_t,
9220 and the initializer is a string literal...". */
9221 else if ((TREE_CODE (tree_strip_any_location_wrapper (newrhs
))
9223 && char_type_p (TREE_TYPE (TYPE_MAIN_VARIANT (lhstype
)))
9224 && modifycode
== INIT_EXPR
)
9226 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9227 if (newrhs
== error_mark_node
)
9228 return error_mark_node
;
9231 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
9232 TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))))
9234 if (complain
& tf_error
)
9235 error_at (loc
, "incompatible types in assignment of %qT to %qT",
9236 TREE_TYPE (rhs
), lhstype
);
9237 return error_mark_node
;
9240 /* Allow array assignment in compiler-generated code. */
9241 else if (!current_function_decl
9242 || !DECL_DEFAULTED_FN (current_function_decl
))
9244 /* This routine is used for both initialization and assignment.
9245 Make sure the diagnostic message differentiates the context. */
9246 if (complain
& tf_error
)
9248 if (modifycode
== INIT_EXPR
)
9249 error_at (loc
, "array used as initializer");
9251 error_at (loc
, "invalid array assignment");
9253 return error_mark_node
;
9256 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
9257 ? 1 + (modifycode
!= INIT_EXPR
): 0;
9258 result
= build_vec_init (lhs
, NULL_TREE
, newrhs
,
9259 /*explicit_value_init_p=*/false,
9260 from_array
, complain
);
9264 if (modifycode
== INIT_EXPR
)
9265 /* Calls with INIT_EXPR are all direct-initialization, so don't set
9266 LOOKUP_ONLYCONVERTING. */
9267 newrhs
= convert_for_initialization (lhs
, olhstype
, newrhs
, LOOKUP_NORMAL
,
9268 ICR_INIT
, NULL_TREE
, 0,
9269 complain
| tf_no_cleanup
);
9271 newrhs
= convert_for_assignment (olhstype
, newrhs
, ICR_ASSIGN
,
9272 NULL_TREE
, 0, complain
, LOOKUP_IMPLICIT
);
9274 if (!same_type_p (lhstype
, olhstype
))
9275 newrhs
= cp_convert_and_check (lhstype
, newrhs
, complain
);
9277 if (modifycode
!= INIT_EXPR
)
9279 if (TREE_CODE (newrhs
) == CALL_EXPR
9280 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
9281 newrhs
= build_cplus_new (lhstype
, newrhs
, complain
);
9283 /* Can't initialize directly from a TARGET_EXPR, since that would
9284 cause the lhs to be constructed twice, and possibly result in
9285 accidental self-initialization. So we force the TARGET_EXPR to be
9286 expanded without a target. */
9287 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
9288 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
9289 TREE_OPERAND (newrhs
, 0));
9292 if (newrhs
== error_mark_node
)
9293 return error_mark_node
;
9295 if (c_dialect_objc () && flag_objc_gc
)
9297 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
9303 result
= build2_loc (loc
, modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
9304 lhstype
, lhs
, newrhs
);
9306 TREE_SIDE_EFFECTS (result
) = 1;
9308 suppress_warning (result
, OPT_Wparentheses
);
9312 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), preeval
, result
);
9317 build_x_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
9318 tree rhs
, tree lookups
, tsubst_flags_t complain
)
9320 tree orig_lhs
= lhs
;
9321 tree orig_rhs
= rhs
;
9322 tree overload
= NULL_TREE
;
9324 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
9325 return cp_expr (error_mark_node
, loc
);
9327 if (processing_template_decl
)
9329 if (modifycode
== NOP_EXPR
9330 || type_dependent_expression_p (lhs
)
9331 || type_dependent_expression_p (rhs
))
9333 tree op
= build_min_nt_loc (loc
, modifycode
, NULL_TREE
, NULL_TREE
);
9334 tree rval
= build_min_nt_loc (loc
, MODOP_EXPR
, lhs
, op
, rhs
);
9335 if (modifycode
!= NOP_EXPR
)
9337 = build_dependent_operator_type (lookups
, modifycode
, true);
9341 lhs
= build_non_dependent_expr (lhs
);
9342 rhs
= build_non_dependent_expr (rhs
);
9345 if (modifycode
!= NOP_EXPR
)
9347 tree op
= build_nt (modifycode
, NULL_TREE
, NULL_TREE
);
9348 tree rval
= build_new_op (loc
, MODIFY_EXPR
, LOOKUP_NORMAL
,
9349 lhs
, rhs
, op
, lookups
, &overload
, complain
);
9352 if (rval
== error_mark_node
)
9354 suppress_warning (rval
/* What warning? */);
9355 if (processing_template_decl
)
9357 if (overload
!= NULL_TREE
)
9358 return (build_min_non_dep_op_overload
9359 (MODIFY_EXPR
, rval
, overload
, orig_lhs
, orig_rhs
));
9361 return (build_min_non_dep
9362 (MODOP_EXPR
, rval
, orig_lhs
, op
, orig_rhs
));
9367 return cp_build_modify_expr (loc
, lhs
, modifycode
, rhs
, complain
);
9370 /* Helper function for get_delta_difference which assumes FROM is a base
9371 class of TO. Returns a delta for the conversion of pointer-to-member
9372 of FROM to pointer-to-member of TO. If the conversion is invalid and
9373 tf_error is not set in COMPLAIN returns error_mark_node, otherwise
9374 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
9375 If C_CAST_P is true, this conversion is taking place as part of a
9379 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
,
9380 tsubst_flags_t complain
)
9385 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
,
9388 if (binfo
== error_mark_node
)
9390 if (!(complain
& tf_error
))
9391 return error_mark_node
;
9393 inform (input_location
, " in pointer to member function conversion");
9394 return size_zero_node
;
9398 if (kind
!= bk_via_virtual
)
9399 return BINFO_OFFSET (binfo
);
9401 /* FROM is a virtual base class of TO. Issue an error or warning
9402 depending on whether or not this is a reinterpret cast. */
9404 if (!(complain
& tf_error
))
9405 return error_mark_node
;
9407 error ("pointer to member conversion via virtual base %qT",
9408 BINFO_TYPE (binfo_from_vbase (binfo
)));
9410 return size_zero_node
;
9417 /* Get difference in deltas for different pointer to member function
9418 types. If the conversion is invalid and tf_error is not set in
9419 COMPLAIN, returns error_mark_node, otherwise returns an integer
9420 constant of type PTRDIFF_TYPE_NODE and its value is zero if the
9421 conversion is invalid. If ALLOW_INVERSE_P is true, then allow reverse
9422 conversions as well. If C_CAST_P is true this conversion is taking
9423 place as part of a C-style cast.
9425 Note that the naming of FROM and TO is kind of backwards; the return
9426 value is what we add to a TO in order to get a FROM. They are named
9427 this way because we call this function to find out how to convert from
9428 a pointer to member of FROM to a pointer to member of TO. */
9431 get_delta_difference (tree from
, tree to
,
9432 bool allow_inverse_p
,
9433 bool c_cast_p
, tsubst_flags_t complain
)
9437 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
9438 /* Pointer to member of incomplete class is permitted*/
9439 result
= size_zero_node
;
9441 result
= get_delta_difference_1 (from
, to
, c_cast_p
, complain
);
9443 if (result
== error_mark_node
)
9444 return error_mark_node
;
9448 if (!allow_inverse_p
)
9450 if (!(complain
& tf_error
))
9451 return error_mark_node
;
9453 error_not_base_type (from
, to
);
9454 inform (input_location
, " in pointer to member conversion");
9455 result
= size_zero_node
;
9459 result
= get_delta_difference_1 (to
, from
, c_cast_p
, complain
);
9461 if (result
== error_mark_node
)
9462 return error_mark_node
;
9465 result
= size_diffop_loc (input_location
,
9466 size_zero_node
, result
);
9469 if (!(complain
& tf_error
))
9470 return error_mark_node
;
9472 error_not_base_type (from
, to
);
9473 inform (input_location
, " in pointer to member conversion");
9474 result
= size_zero_node
;
9479 return convert_to_integer (ptrdiff_type_node
, result
);
9482 /* Return a constructor for the pointer-to-member-function TYPE using
9483 the other components as specified. */
9486 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
9491 vec
<constructor_elt
, va_gc
> *v
;
9493 /* Pull the FIELD_DECLs out of the type. */
9494 pfn_field
= TYPE_FIELDS (type
);
9495 delta_field
= DECL_CHAIN (pfn_field
);
9497 /* Make sure DELTA has the type we want. */
9498 delta
= convert_and_check (input_location
, delta_type_node
, delta
);
9500 /* Convert to the correct target type if necessary. */
9501 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
9503 /* Finish creating the initializer. */
9505 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
9506 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
9507 u
= build_constructor (type
, v
);
9508 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
9509 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
9510 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
9512 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
9517 /* Build a constructor for a pointer to member function. It can be
9518 used to initialize global variables, local variable, or used
9519 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
9522 If FORCE is nonzero, then force this conversion, even if
9523 we would rather not do it. Usually set when using an explicit
9524 cast. A C-style cast is being processed iff C_CAST_P is true.
9526 Return error_mark_node, if something goes wrong. */
9529 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
,
9530 tsubst_flags_t complain
)
9536 if (error_operand_p (pfn
))
9537 return error_mark_node
;
9539 pfn_type
= TREE_TYPE (pfn
);
9540 to_type
= build_ptrmemfunc_type (type
);
9542 /* Handle multiple conversions of pointer to member functions. */
9543 if (TYPE_PTRMEMFUNC_P (pfn_type
))
9545 tree delta
= NULL_TREE
;
9546 tree npfn
= NULL_TREE
;
9550 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
,
9551 LOOKUP_NORMAL
, complain
))
9553 if (complain
& tf_error
)
9554 error ("invalid conversion to type %qT from type %qT",
9557 return error_mark_node
;
9560 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
9561 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
9563 c_cast_p
, complain
);
9564 if (n
== error_mark_node
)
9565 return error_mark_node
;
9567 /* We don't have to do any conversion to convert a
9568 pointer-to-member to its own type. But, we don't want to
9569 just return a PTRMEM_CST if there's an explicit cast; that
9570 cast should make the expression an invalid template argument. */
9571 if (TREE_CODE (pfn
) != PTRMEM_CST
)
9573 if (same_type_p (to_type
, pfn_type
))
9575 else if (integer_zerop (n
) && TREE_CODE (pfn
) != CONSTRUCTOR
)
9576 return build_reinterpret_cast (input_location
, to_type
, pfn
,
9580 if (TREE_SIDE_EFFECTS (pfn
))
9581 pfn
= save_expr (pfn
);
9583 /* Obtain the function pointer and the current DELTA. */
9584 if (TREE_CODE (pfn
) == PTRMEM_CST
)
9585 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
9588 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
9589 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
9592 /* Just adjust the DELTA field. */
9593 gcc_assert (same_type_ignoring_top_level_qualifiers_p
9594 (TREE_TYPE (delta
), ptrdiff_type_node
));
9595 if (!integer_zerop (n
))
9597 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
9598 n
= cp_build_binary_op (input_location
,
9599 LSHIFT_EXPR
, n
, integer_one_node
,
9601 delta
= cp_build_binary_op (input_location
,
9602 PLUS_EXPR
, delta
, n
, complain
);
9604 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
9607 /* Handle null pointer to member function conversions. */
9608 if (null_ptr_cst_p (pfn
))
9610 pfn
= cp_build_c_cast (input_location
,
9611 TYPE_PTRMEMFUNC_FN_TYPE_RAW (to_type
),
9613 return build_ptrmemfunc1 (to_type
,
9618 if (type_unknown_p (pfn
))
9619 return instantiate_type (type
, pfn
, complain
);
9621 fn
= TREE_OPERAND (pfn
, 0);
9622 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
9623 /* In a template, we will have preserved the
9625 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
9626 return make_ptrmem_cst (to_type
, fn
);
9629 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
9632 ??? There is no consistency as to the types returned for the above
9633 values. Some code acts as if it were a sizetype and some as if it were
9634 integer_type_node. */
9637 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
9639 tree type
= TREE_TYPE (cst
);
9640 tree fn
= PTRMEM_CST_MEMBER (cst
);
9641 tree ptr_class
, fn_class
;
9643 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
9645 /* The class that the function belongs to. */
9646 fn_class
= DECL_CONTEXT (fn
);
9648 /* The class that we're creating a pointer to member of. */
9649 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
9651 /* First, calculate the adjustment to the function's class. */
9652 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
9653 /*c_cast_p=*/0, tf_warning_or_error
);
9655 if (!DECL_VIRTUAL_P (fn
))
9657 tree t
= build_addr_func (fn
, tf_warning_or_error
);
9658 if (TREE_CODE (t
) == ADDR_EXPR
)
9659 SET_EXPR_LOCATION (t
, PTRMEM_CST_LOCATION (cst
));
9660 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), t
);
9664 /* If we're dealing with a virtual function, we have to adjust 'this'
9665 again, to point to the base which provides the vtable entry for
9666 fn; the call will do the opposite adjustment. */
9667 tree orig_class
= DECL_CONTEXT (fn
);
9668 tree binfo
= binfo_or_else (orig_class
, fn_class
);
9669 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
9670 *delta
, BINFO_OFFSET (binfo
));
9672 /* We set PFN to the vtable offset at which the function can be
9673 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
9674 case delta is shifted left, and then incremented). */
9675 *pfn
= DECL_VINDEX (fn
);
9676 *pfn
= fold_build2 (MULT_EXPR
, integer_type_node
, *pfn
,
9677 TYPE_SIZE_UNIT (vtable_entry_type
));
9679 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
9681 case ptrmemfunc_vbit_in_pfn
:
9682 *pfn
= fold_build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
9686 case ptrmemfunc_vbit_in_delta
:
9687 *delta
= fold_build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
9688 *delta
, integer_one_node
);
9689 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
9690 *delta
, integer_one_node
);
9697 *pfn
= fold_convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
9701 /* Return an expression for PFN from the pointer-to-member function
9705 pfn_from_ptrmemfunc (tree t
)
9707 if (TREE_CODE (t
) == PTRMEM_CST
)
9712 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
9717 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
9720 /* Return an expression for DELTA from the pointer-to-member function
9724 delta_from_ptrmemfunc (tree t
)
9726 if (TREE_CODE (t
) == PTRMEM_CST
)
9731 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
9736 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
9739 /* Convert value RHS to type TYPE as preparation for an assignment to
9740 an lvalue of type TYPE. ERRTYPE indicates what kind of error the
9741 implicit conversion is. If FNDECL is non-NULL, we are doing the
9742 conversion in order to pass the PARMNUMth argument of FNDECL.
9743 If FNDECL is NULL, we are doing the conversion in function pointer
9744 argument passing, conversion in initialization, etc. */
9747 convert_for_assignment (tree type
, tree rhs
,
9748 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
9749 tsubst_flags_t complain
, int flags
)
9752 enum tree_code coder
;
9754 location_t rhs_loc
= cp_expr_loc_or_input_loc (rhs
);
9755 bool has_loc
= EXPR_LOCATION (rhs
) != UNKNOWN_LOCATION
;
9756 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue,
9757 but preserve location wrappers. */
9758 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
9759 && !location_wrapper_p (rhs
))
9760 rhs
= TREE_OPERAND (rhs
, 0);
9762 /* Handle [dcl.init.list] direct-list-initialization from
9763 single element of enumeration with a fixed underlying type. */
9764 if (is_direct_enum_init (type
, rhs
))
9766 tree elt
= CONSTRUCTOR_ELT (rhs
, 0)->value
;
9767 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
9769 warning_sentinel
w (warn_useless_cast
);
9770 warning_sentinel
w2 (warn_ignored_qualifiers
);
9771 rhs
= cp_build_c_cast (rhs_loc
, type
, elt
, complain
);
9774 rhs
= error_mark_node
;
9777 rhstype
= TREE_TYPE (rhs
);
9778 coder
= TREE_CODE (rhstype
);
9780 if (VECTOR_TYPE_P (type
) && coder
== VECTOR_TYPE
9781 && vector_types_convertible_p (type
, rhstype
, true))
9783 rhs
= mark_rvalue_use (rhs
);
9784 return convert (type
, rhs
);
9787 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
9788 return error_mark_node
;
9789 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
9790 return error_mark_node
;
9792 /* The RHS of an assignment cannot have void type. */
9793 if (coder
== VOID_TYPE
)
9795 if (complain
& tf_error
)
9796 error_at (rhs_loc
, "void value not ignored as it ought to be");
9797 return error_mark_node
;
9800 if (c_dialect_objc ())
9804 tree rname
= fndecl
;
9815 selector
= objc_message_selector ();
9817 if (selector
&& parmno
> 1)
9824 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
9826 rhs
= mark_rvalue_use (rhs
);
9827 return convert (type
, rhs
);
9833 The expression is implicitly converted (clause _conv_) to the
9834 cv-unqualified type of the left operand.
9836 We allow bad conversions here because by the time we get to this point
9837 we are committed to doing the conversion. If we end up doing a bad
9838 conversion, convert_like will complain. */
9839 if (!can_convert_arg_bad (type
, rhstype
, rhs
, flags
, complain
))
9841 /* When -Wno-pmf-conversions is use, we just silently allow
9842 conversions from pointers-to-members to plain pointers. If
9843 the conversion doesn't work, cp_convert will complain. */
9845 && TYPE_PTR_P (type
)
9846 && TYPE_PTRMEMFUNC_P (rhstype
))
9847 rhs
= cp_convert (strip_top_quals (type
), rhs
, complain
);
9850 if (complain
& tf_error
)
9852 /* If the right-hand side has unknown type, then it is an
9853 overloaded function. Call instantiate_type to get error
9855 if (rhstype
== unknown_type_node
)
9857 tree r
= instantiate_type (type
, rhs
, tf_warning_or_error
);
9858 /* -fpermissive might allow this; recurse. */
9860 return convert_for_assignment (type
, r
, errtype
, fndecl
,
9861 parmnum
, complain
, flags
);
9864 complain_about_bad_argument (rhs_loc
,
9869 range_label_for_type_mismatch
label (rhstype
, type
);
9870 gcc_rich_location
richloc (rhs_loc
, has_loc
? &label
: NULL
);
9873 case ICR_DEFAULT_ARGUMENT
:
9875 "cannot convert %qH to %qI in default argument",
9880 "cannot convert %qH to %qI in argument passing",
9883 case ICR_CONVERTING
:
9884 error_at (&richloc
, "cannot convert %qH to %qI",
9889 "cannot convert %qH to %qI in initialization",
9893 error_at (&richloc
, "cannot convert %qH to %qI in return",
9898 "cannot convert %qH to %qI in assignment",
9905 if (TYPE_PTR_P (rhstype
)
9906 && TYPE_PTR_P (type
)
9907 && CLASS_TYPE_P (TREE_TYPE (rhstype
))
9908 && CLASS_TYPE_P (TREE_TYPE (type
))
9909 && !COMPLETE_TYPE_P (TREE_TYPE (rhstype
)))
9910 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL
9911 (TREE_TYPE (rhstype
))),
9912 "class type %qT is incomplete", TREE_TYPE (rhstype
));
9914 return error_mark_node
;
9917 if (warn_suggest_attribute_format
)
9919 const enum tree_code codel
= TREE_CODE (type
);
9920 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
9922 && check_missing_format_attribute (type
, rhstype
)
9923 && (complain
& tf_warning
))
9927 case ICR_DEFAULT_ARGUMENT
:
9929 warning (OPT_Wsuggest_attribute_format
,
9930 "parameter %qP of %qD might be a candidate "
9931 "for a format attribute", parmnum
, fndecl
);
9933 warning (OPT_Wsuggest_attribute_format
,
9934 "parameter might be a candidate "
9935 "for a format attribute");
9937 case ICR_CONVERTING
:
9938 warning (OPT_Wsuggest_attribute_format
,
9939 "target of conversion might be a candidate "
9940 "for a format attribute");
9943 warning (OPT_Wsuggest_attribute_format
,
9944 "target of initialization might be a candidate "
9945 "for a format attribute");
9948 warning (OPT_Wsuggest_attribute_format
,
9949 "return type might be a candidate "
9950 "for a format attribute");
9953 warning (OPT_Wsuggest_attribute_format
,
9954 "left-hand side of assignment might be a candidate "
9955 "for a format attribute");
9962 /* If -Wparentheses, warn about a = b = c when a has type bool and b
9964 if (warn_parentheses
9965 && TREE_CODE (type
) == BOOLEAN_TYPE
9966 && TREE_CODE (rhs
) == MODIFY_EXPR
9967 && !warning_suppressed_p (rhs
, OPT_Wparentheses
)
9968 && TREE_CODE (TREE_TYPE (rhs
)) != BOOLEAN_TYPE
9969 && (complain
& tf_warning
)
9970 && warning_at (rhs_loc
, OPT_Wparentheses
,
9971 "suggest parentheses around assignment used as "
9973 suppress_warning (rhs
, OPT_Wparentheses
);
9975 if (complain
& tf_warning
)
9976 warn_for_address_or_pointer_of_packed_member (type
, rhs
);
9978 return perform_implicit_conversion_flags (strip_top_quals (type
), rhs
,
9982 /* Convert RHS to be of type TYPE.
9983 If EXP is nonzero, it is the target of the initialization.
9984 ERRTYPE indicates what kind of error the implicit conversion is.
9986 Two major differences between the behavior of
9987 `convert_for_assignment' and `convert_for_initialization'
9988 are that references are bashed in the former, while
9989 copied in the latter, and aggregates are assigned in
9990 the former (operator=) while initialized in the
9993 If using constructor make sure no conversion operator exists, if one does
9994 exist, an ambiguity exists. */
9997 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
9998 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
9999 tsubst_flags_t complain
)
10001 enum tree_code codel
= TREE_CODE (type
);
10003 enum tree_code coder
;
10005 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
10006 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
10007 if (TREE_CODE (rhs
) == NOP_EXPR
10008 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
10009 && codel
!= REFERENCE_TYPE
)
10010 rhs
= TREE_OPERAND (rhs
, 0);
10012 if (type
== error_mark_node
10013 || rhs
== error_mark_node
10014 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
10015 return error_mark_node
;
10017 if (MAYBE_CLASS_TYPE_P (non_reference (type
)))
10019 else if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
10020 && TREE_CODE (type
) != ARRAY_TYPE
10021 && (!TYPE_REF_P (type
)
10022 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
10023 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
10024 && !TYPE_REFFN_P (type
))
10025 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
10026 rhs
= decay_conversion (rhs
, complain
);
10028 rhstype
= TREE_TYPE (rhs
);
10029 coder
= TREE_CODE (rhstype
);
10031 if (coder
== ERROR_MARK
)
10032 return error_mark_node
;
10034 /* We accept references to incomplete types, so we can
10035 return here before checking if RHS is of complete type. */
10037 if (codel
== REFERENCE_TYPE
)
10039 auto_diagnostic_group d
;
10040 /* This should eventually happen in convert_arguments. */
10041 int savew
= 0, savee
= 0;
10044 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
10045 rhs
= initialize_reference (type
, rhs
, flags
, complain
);
10048 && (warningcount
+ werrorcount
> savew
|| errorcount
> savee
))
10049 inform (get_fndecl_argument_location (fndecl
, parmnum
),
10050 "in passing argument %P of %qD", parmnum
, fndecl
);
10055 exp
= require_complete_type_sfinae (exp
, complain
);
10056 if (exp
== error_mark_node
)
10057 return error_mark_node
;
10059 type
= complete_type (type
);
10061 if (DIRECT_INIT_EXPR_P (type
, rhs
))
10062 /* Don't try to do copy-initialization if we already have
10063 direct-initialization. */
10066 if (MAYBE_CLASS_TYPE_P (type
))
10067 return perform_implicit_conversion_flags (type
, rhs
, complain
, flags
);
10069 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
10073 /* If RETVAL is the address of, or a reference to, a local variable or
10074 temporary give an appropriate warning and return true. */
10077 maybe_warn_about_returning_address_of_local (tree retval
, location_t loc
)
10079 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
10080 tree whats_returned
= fold_for_warn (retval
);
10082 loc
= cp_expr_loc_or_input_loc (retval
);
10086 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
10087 whats_returned
= TREE_OPERAND (whats_returned
, 1);
10088 else if (CONVERT_EXPR_P (whats_returned
)
10089 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
10090 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10095 if (TREE_CODE (whats_returned
) == TARGET_EXPR
10096 && is_std_init_list (TREE_TYPE (whats_returned
)))
10098 tree init
= TARGET_EXPR_INITIAL (whats_returned
);
10099 if (TREE_CODE (init
) == CONSTRUCTOR
)
10100 /* Pull out the array address. */
10101 whats_returned
= CONSTRUCTOR_ELT (init
, 0)->value
;
10102 else if (TREE_CODE (init
) == INDIRECT_REF
)
10103 /* The source of a trivial copy looks like *(T*)&var. */
10104 whats_returned
= TREE_OPERAND (init
, 0);
10107 STRIP_NOPS (whats_returned
);
10110 /* As a special case, we handle a call to std::move or std::forward. */
10111 if (TREE_CODE (whats_returned
) == CALL_EXPR
10112 && (is_std_move_p (whats_returned
)
10113 || is_std_forward_p (whats_returned
)))
10115 tree arg
= CALL_EXPR_ARG (whats_returned
, 0);
10116 return maybe_warn_about_returning_address_of_local (arg
, loc
);
10119 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
10121 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10123 while (TREE_CODE (whats_returned
) == COMPONENT_REF
10124 || TREE_CODE (whats_returned
) == ARRAY_REF
)
10125 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10127 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
10128 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
10130 if (TYPE_REF_P (valtype
))
10131 warning_at (loc
, OPT_Wreturn_local_addr
,
10132 "returning reference to temporary");
10133 else if (is_std_init_list (valtype
))
10134 warning_at (loc
, OPT_Winit_list_lifetime
,
10135 "returning temporary %<initializer_list%> does not extend "
10136 "the lifetime of the underlying array");
10140 STRIP_ANY_LOCATION_WRAPPER (whats_returned
);
10142 if (DECL_P (whats_returned
)
10143 && DECL_NAME (whats_returned
)
10144 && DECL_FUNCTION_SCOPE_P (whats_returned
)
10145 && !is_capture_proxy (whats_returned
)
10146 && !(TREE_STATIC (whats_returned
)
10147 || TREE_PUBLIC (whats_returned
)))
10149 if (VAR_P (whats_returned
)
10150 && DECL_DECOMPOSITION_P (whats_returned
)
10151 && DECL_DECOMP_BASE (whats_returned
)
10152 && DECL_HAS_VALUE_EXPR_P (whats_returned
))
10154 /* When returning address of a structured binding, if the structured
10155 binding is not a reference, continue normally, if it is a
10156 reference, recurse on the initializer of the structured
10158 tree base
= DECL_DECOMP_BASE (whats_returned
);
10159 if (TYPE_REF_P (TREE_TYPE (base
)))
10161 if (tree init
= DECL_INITIAL (base
))
10162 return maybe_warn_about_returning_address_of_local (init
, loc
);
10168 auto_diagnostic_group d
;
10169 if (TYPE_REF_P (valtype
))
10170 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10171 "reference to local variable %qD returned",
10173 else if (is_std_init_list (valtype
))
10174 w
= warning_at (loc
, OPT_Winit_list_lifetime
,
10175 "returning local %<initializer_list%> variable %qD "
10176 "does not extend the lifetime of the underlying array",
10178 else if (POINTER_TYPE_P (valtype
)
10179 && TREE_CODE (whats_returned
) == LABEL_DECL
)
10180 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10181 "address of label %qD returned",
10183 else if (POINTER_TYPE_P (valtype
))
10184 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10185 "address of local variable %qD returned",
10188 inform (DECL_SOURCE_LOCATION (whats_returned
),
10196 /* Returns true if DECL is in the std namespace. */
10199 decl_in_std_namespace_p (tree decl
)
10203 decl
= decl_namespace_context (decl
);
10204 if (DECL_NAMESPACE_STD_P (decl
))
10206 /* Allow inline namespaces inside of std namespace, e.g. with
10207 --enable-symvers=gnu-versioned-namespace std::forward would be
10208 actually std::_8::forward. */
10209 if (!DECL_NAMESPACE_INLINE_P (decl
))
10211 decl
= CP_DECL_CONTEXT (decl
);
10216 /* Returns true if FN, a CALL_EXPR, is a call to std::forward. */
10219 is_std_forward_p (tree fn
)
10221 /* std::forward only takes one argument. */
10222 if (call_expr_nargs (fn
) != 1)
10225 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10226 if (!decl_in_std_namespace_p (fndecl
))
10229 tree name
= DECL_NAME (fndecl
);
10230 return name
&& id_equal (name
, "forward");
10233 /* Returns true if FN, a CALL_EXPR, is a call to std::move. */
10236 is_std_move_p (tree fn
)
10238 /* std::move only takes one argument. */
10239 if (call_expr_nargs (fn
) != 1)
10242 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10243 if (!decl_in_std_namespace_p (fndecl
))
10246 tree name
= DECL_NAME (fndecl
);
10247 return name
&& id_equal (name
, "move");
10250 /* Returns true if RETVAL is a good candidate for the NRVO as per
10251 [class.copy.elision]. FUNCTYPE is the type the function is declared
10255 can_do_nrvo_p (tree retval
, tree functype
)
10257 if (functype
== error_mark_node
)
10260 STRIP_ANY_LOCATION_WRAPPER (retval
);
10261 tree result
= DECL_RESULT (current_function_decl
);
10262 return (retval
!= NULL_TREE
10263 && !processing_template_decl
10264 /* Must be a local, automatic variable. */
10266 && DECL_CONTEXT (retval
) == current_function_decl
10267 && !TREE_STATIC (retval
)
10268 /* And not a lambda or anonymous union proxy. */
10269 && !DECL_HAS_VALUE_EXPR_P (retval
)
10270 && (DECL_ALIGN (retval
) <= DECL_ALIGN (result
))
10271 /* The cv-unqualified type of the returned value must be the
10272 same as the cv-unqualified return type of the
10274 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval
))),
10275 (TYPE_MAIN_VARIANT (functype
)))
10276 /* And the returned value must be non-volatile. */
10277 && !TYPE_VOLATILE (TREE_TYPE (retval
)));
10280 /* If we should treat RETVAL, an expression being returned, as if it were
10281 designated by an rvalue, returns it adjusted accordingly; otherwise, returns
10282 NULL_TREE. See [class.copy.elision]. RETURN_P is true if this is a return
10283 context (rather than throw). */
10286 treat_lvalue_as_rvalue_p (tree expr
, bool return_p
)
10288 if (cxx_dialect
== cxx98
)
10291 tree retval
= expr
;
10292 STRIP_ANY_LOCATION_WRAPPER (retval
);
10293 if (REFERENCE_REF_P (retval
))
10294 retval
= TREE_OPERAND (retval
, 0);
10296 /* An implicitly movable entity is a variable of automatic storage duration
10297 that is either a non-volatile object or (C++20) an rvalue reference to a
10298 non-volatile object type. */
10299 if (!(((VAR_P (retval
) && !DECL_HAS_VALUE_EXPR_P (retval
))
10300 || TREE_CODE (retval
) == PARM_DECL
)
10301 && !TREE_STATIC (retval
)
10302 && !CP_TYPE_VOLATILE_P (non_reference (TREE_TYPE (retval
)))
10303 && (TREE_CODE (TREE_TYPE (retval
)) != REFERENCE_TYPE
10304 || (cxx_dialect
>= cxx20
10305 && TYPE_REF_IS_RVALUE (TREE_TYPE (retval
))))))
10308 /* If the expression in a return or co_return statement is a (possibly
10309 parenthesized) id-expression that names an implicitly movable entity
10310 declared in the body or parameter-declaration-clause of the innermost
10311 enclosing function or lambda-expression, */
10312 if (DECL_CONTEXT (retval
) != current_function_decl
)
10315 return set_implicit_rvalue_p (move (expr
));
10317 /* if the operand of a throw-expression is a (possibly parenthesized)
10318 id-expression that names an implicitly movable entity whose scope does not
10319 extend beyond the compound-statement of the innermost try-block or
10320 function-try-block (if any) whose compound-statement or ctor-initializer
10321 encloses the throw-expression, */
10323 /* C++20 added move on throw of parms. */
10324 if (TREE_CODE (retval
) == PARM_DECL
&& cxx_dialect
< cxx20
)
10327 for (cp_binding_level
*b
= current_binding_level
;
10328 ; b
= b
->level_chain
)
10330 for (tree decl
= b
->names
; decl
; decl
= TREE_CHAIN (decl
))
10331 if (decl
== retval
)
10332 return set_implicit_rvalue_p (move (expr
));
10333 if (b
->kind
== sk_function_parms
|| b
->kind
== sk_try
)
10338 /* Warn about wrong usage of std::move in a return statement. RETVAL
10339 is the expression we are returning; FUNCTYPE is the type the function
10340 is declared to return. */
10343 maybe_warn_pessimizing_move (tree retval
, tree functype
)
10345 if (!(warn_pessimizing_move
|| warn_redundant_move
))
10348 location_t loc
= cp_expr_loc_or_input_loc (retval
);
10350 /* C++98 doesn't know move. */
10351 if (cxx_dialect
< cxx11
)
10354 /* Wait until instantiation time, since we can't gauge if we should do
10355 the NRVO until then. */
10356 if (processing_template_decl
)
10359 /* This is only interesting for class types. */
10360 if (!CLASS_TYPE_P (functype
))
10363 /* We're looking for *std::move<T&> ((T &) &arg). */
10364 if (REFERENCE_REF_P (retval
)
10365 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
10367 tree fn
= TREE_OPERAND (retval
, 0);
10368 if (is_std_move_p (fn
))
10370 tree arg
= CALL_EXPR_ARG (fn
, 0);
10372 if (TREE_CODE (arg
) != NOP_EXPR
)
10374 arg
= TREE_OPERAND (arg
, 0);
10375 if (TREE_CODE (arg
) != ADDR_EXPR
)
10377 arg
= TREE_OPERAND (arg
, 0);
10378 arg
= convert_from_reference (arg
);
10379 /* Warn if we could do copy elision were it not for the move. */
10380 if (can_do_nrvo_p (arg
, functype
))
10382 auto_diagnostic_group d
;
10383 if (warning_at (loc
, OPT_Wpessimizing_move
,
10384 "moving a local object in a return statement "
10385 "prevents copy elision"))
10386 inform (loc
, "remove %<std::move%> call");
10388 /* Warn if the move is redundant. It is redundant when we would
10389 do maybe-rvalue overload resolution even without std::move. */
10390 else if (warn_redundant_move
10391 && (moved
= treat_lvalue_as_rvalue_p (arg
, /*return*/true)))
10393 /* Make sure that the overload resolution would actually succeed
10394 if we removed the std::move call. */
10395 tree t
= convert_for_initialization (NULL_TREE
, functype
,
10398 | LOOKUP_ONLYCONVERTING
10399 | LOOKUP_PREFER_RVALUE
),
10400 ICR_RETURN
, NULL_TREE
, 0,
10402 /* If this worked, implicit rvalue would work, so the call to
10403 std::move is redundant. */
10404 if (t
!= error_mark_node
)
10406 auto_diagnostic_group d
;
10407 if (warning_at (loc
, OPT_Wredundant_move
,
10408 "redundant move in return statement"))
10409 inform (loc
, "remove %<std::move%> call");
10416 /* Check that returning RETVAL from the current function is valid.
10417 Return an expression explicitly showing all conversions required to
10418 change RETVAL into the function return type, and to assign it to
10419 the DECL_RESULT for the function. Set *NO_WARNING to true if
10420 code reaches end of non-void function warning shouldn't be issued
10421 on this RETURN_EXPR. */
10424 check_return_expr (tree retval
, bool *no_warning
)
10427 /* The type actually returned by the function. */
10429 /* The type the function is declared to return, or void if
10430 the declared type is incomplete. */
10432 int fn_returns_value_p
;
10433 location_t loc
= cp_expr_loc_or_input_loc (retval
);
10435 *no_warning
= false;
10437 /* A `volatile' function is one that isn't supposed to return, ever.
10438 (This is a G++ extension, used to get better code for functions
10439 that call the `volatile' function.) */
10440 if (TREE_THIS_VOLATILE (current_function_decl
))
10441 warning (0, "function declared %<noreturn%> has a %<return%> statement");
10443 /* Check for various simple errors. */
10444 if (DECL_DESTRUCTOR_P (current_function_decl
))
10447 error_at (loc
, "returning a value from a destructor");
10450 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10452 if (in_function_try_handler
)
10453 /* If a return statement appears in a handler of the
10454 function-try-block of a constructor, the program is ill-formed. */
10455 error ("cannot return from a handler of a function-try-block of a constructor");
10457 /* You can't return a value from a constructor. */
10458 error_at (loc
, "returning a value from a constructor");
10462 const tree saved_retval
= retval
;
10464 if (processing_template_decl
)
10466 current_function_returns_value
= 1;
10468 if (check_for_bare_parameter_packs (retval
))
10469 return error_mark_node
;
10471 /* If one of the types might be void, we can't tell whether we're
10472 returning a value. */
10473 if ((WILDCARD_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl
)))
10474 && !FNDECL_USED_AUTO (current_function_decl
))
10475 || (retval
!= NULL_TREE
10476 && (TREE_TYPE (retval
) == NULL_TREE
10477 || WILDCARD_TYPE_P (TREE_TYPE (retval
)))))
10481 functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
10483 /* Deduce auto return type from a return statement. */
10484 if (FNDECL_USED_AUTO (current_function_decl
))
10486 tree pattern
= DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
);
10490 if (!retval
&& !is_auto (pattern
))
10492 /* Give a helpful error message. */
10493 error ("return-statement with no value, in function returning %qT",
10495 inform (input_location
, "only plain %<auto%> return type can be "
10496 "deduced to %<void%>");
10497 type
= error_mark_node
;
10499 else if (retval
&& BRACE_ENCLOSED_INITIALIZER_P (retval
))
10501 error ("returning initializer list");
10502 type
= error_mark_node
;
10507 retval
= void_node
;
10508 auto_node
= type_uses_auto (pattern
);
10509 type
= do_auto_deduction (pattern
, retval
, auto_node
,
10510 tf_warning_or_error
, adc_return_type
);
10513 if (type
== error_mark_node
)
10515 else if (functype
== pattern
)
10516 apply_deduced_return_type (current_function_decl
, type
);
10517 else if (!same_type_p (type
, functype
))
10519 if (LAMBDA_FUNCTION_P (current_function_decl
))
10520 error_at (loc
, "inconsistent types %qT and %qT deduced for "
10521 "lambda return type", functype
, type
);
10523 error_at (loc
, "inconsistent deduction for auto return type: "
10524 "%qT and then %qT", functype
, type
);
10529 result
= DECL_RESULT (current_function_decl
);
10530 valtype
= TREE_TYPE (result
);
10531 gcc_assert (valtype
!= NULL_TREE
);
10532 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
10534 /* Check for a return statement with no return value in a function
10535 that's supposed to return a value. */
10536 if (!retval
&& fn_returns_value_p
)
10538 if (functype
!= error_mark_node
)
10539 permerror (input_location
, "return-statement with no value, in "
10540 "function returning %qT", valtype
);
10541 /* Remember that this function did return. */
10542 current_function_returns_value
= 1;
10543 /* And signal caller that TREE_NO_WARNING should be set on the
10544 RETURN_EXPR to avoid control reaches end of non-void function
10545 warnings in tree-cfg.cc. */
10546 *no_warning
= true;
10548 /* Check for a return statement with a value in a function that
10549 isn't supposed to return a value. */
10550 else if (retval
&& !fn_returns_value_p
)
10552 if (VOID_TYPE_P (TREE_TYPE (retval
)))
10553 /* You can return a `void' value from a function of `void'
10554 type. In that case, we have to evaluate the expression for
10555 its side-effects. */
10556 finish_expr_stmt (retval
);
10557 else if (retval
!= error_mark_node
)
10558 permerror (loc
, "return-statement with a value, in function "
10559 "returning %qT", valtype
);
10560 current_function_returns_null
= 1;
10562 /* There's really no value to return, after all. */
10566 /* Remember that this function can sometimes return without a
10568 current_function_returns_null
= 1;
10570 /* Remember that this function did return a value. */
10571 current_function_returns_value
= 1;
10573 /* Check for erroneous operands -- but after giving ourselves a
10574 chance to provide an error about returning a value from a void
10576 if (error_operand_p (retval
))
10578 current_function_return_value
= error_mark_node
;
10579 return error_mark_node
;
10582 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
10583 if (IDENTIFIER_NEW_OP_P (DECL_NAME (current_function_decl
))
10584 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
10585 && ! flag_check_new
10586 && retval
&& null_ptr_cst_p (retval
))
10587 warning (0, "%<operator new%> must not return NULL unless it is "
10588 "declared %<throw()%> (or %<-fcheck-new%> is in effect)");
10590 /* Effective C++ rule 15. See also start_function. */
10592 && DECL_NAME (current_function_decl
) == assign_op_identifier
10593 && !type_dependent_expression_p (retval
))
10597 /* The function return type must be a reference to the current
10599 if (TYPE_REF_P (valtype
)
10600 && same_type_ignoring_top_level_qualifiers_p
10601 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
10603 /* Returning '*this' is obviously OK. */
10604 if (retval
== current_class_ref
)
10606 /* If we are calling a function whose return type is the same of
10607 the current class reference, it is ok. */
10608 else if (INDIRECT_REF_P (retval
)
10609 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
10614 warning_at (loc
, OPT_Weffc__
,
10615 "%<operator=%> should return a reference to %<*this%>");
10618 if (dependent_type_p (functype
)
10619 || type_dependent_expression_p (retval
))
10622 /* We should not have changed the return value. */
10623 gcc_assert (retval
== saved_retval
);
10624 /* We don't know if this is an lvalue or rvalue use, but
10625 either way we can mark it as read. */
10626 mark_exp_read (retval
);
10630 /* The fabled Named Return Value optimization, as per [class.copy]/15:
10632 [...] For a function with a class return type, if the expression
10633 in the return statement is the name of a local object, and the cv-
10634 unqualified type of the local object is the same as the function
10635 return type, an implementation is permitted to omit creating the tem-
10636 porary object to hold the function return value [...]
10638 So, if this is a value-returning function that always returns the same
10639 local variable, remember it.
10641 It might be nice to be more flexible, and choose the first suitable
10642 variable even if the function sometimes returns something else, but
10643 then we run the risk of clobbering the variable we chose if the other
10644 returned expression uses the chosen variable somehow. And people expect
10645 this restriction, anyway. (jason 2000-11-19)
10647 See finish_function and finalize_nrv for the rest of this optimization. */
10648 tree bare_retval
= NULL_TREE
;
10651 retval
= maybe_undo_parenthesized_ref (retval
);
10652 bare_retval
= tree_strip_any_location_wrapper (retval
);
10655 bool named_return_value_okay_p
= can_do_nrvo_p (bare_retval
, functype
);
10656 if (fn_returns_value_p
&& flag_elide_constructors
)
10658 if (named_return_value_okay_p
10659 && (current_function_return_value
== NULL_TREE
10660 || current_function_return_value
== bare_retval
))
10661 current_function_return_value
= bare_retval
;
10663 current_function_return_value
= error_mark_node
;
10666 /* We don't need to do any conversions when there's nothing being
10671 if (!named_return_value_okay_p
)
10672 maybe_warn_pessimizing_move (retval
, functype
);
10674 /* Do any required conversions. */
10675 if (bare_retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
10676 /* No conversions are required. */
10680 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
10682 /* The functype's return type will have been set to void, if it
10683 was an incomplete type. Just treat this as 'return;' */
10684 if (VOID_TYPE_P (functype
))
10685 return error_mark_node
;
10687 if (processing_template_decl
)
10688 retval
= build_non_dependent_expr (retval
);
10690 /* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
10691 treated as an rvalue for the purposes of overload resolution to
10692 favor move constructors over copy constructors.
10694 Note that these conditions are similar to, but not as strict as,
10695 the conditions for the named return value optimization. */
10696 bool converted
= false;
10698 /* This is only interesting for class type. */
10699 if (CLASS_TYPE_P (functype
)
10700 && (moved
= treat_lvalue_as_rvalue_p (retval
, /*return*/true)))
10702 if (cxx_dialect
< cxx20
)
10704 moved
= convert_for_initialization
10705 (NULL_TREE
, functype
, moved
, flags
|LOOKUP_PREFER_RVALUE
,
10706 ICR_RETURN
, NULL_TREE
, 0, tf_none
);
10707 if (moved
!= error_mark_node
)
10714 /* In C++20 we just treat the return value as an rvalue that
10715 can bind to lvalue refs. */
10719 /* The call in a (lambda) thunk needs no conversions. */
10720 if (TREE_CODE (retval
) == CALL_EXPR
10721 && call_from_lambda_thunk_p (retval
))
10724 /* First convert the value to the function's return type, then
10725 to the type of return value's location to handle the
10726 case that functype is smaller than the valtype. */
10728 retval
= convert_for_initialization
10729 (NULL_TREE
, functype
, retval
, flags
, ICR_RETURN
, NULL_TREE
, 0,
10730 tf_warning_or_error
);
10731 retval
= convert (valtype
, retval
);
10733 /* If the conversion failed, treat this just like `return;'. */
10734 if (retval
== error_mark_node
)
10736 /* We can't initialize a register from a AGGR_INIT_EXPR. */
10737 else if (! cfun
->returns_struct
10738 && TREE_CODE (retval
) == TARGET_EXPR
10739 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
10740 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
10741 TREE_OPERAND (retval
, 0));
10742 else if (!processing_template_decl
10743 && maybe_warn_about_returning_address_of_local (retval
, loc
)
10744 && INDIRECT_TYPE_P (valtype
))
10745 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
10746 build_zero_cst (TREE_TYPE (retval
)));
10749 if (processing_template_decl
)
10750 return saved_retval
;
10752 /* Actually copy the value returned into the appropriate location. */
10753 if (retval
&& retval
!= result
)
10754 retval
= build2 (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
10756 if (tree set
= maybe_set_retval_sentinel ())
10757 retval
= build2 (COMPOUND_EXPR
, void_type_node
, retval
, set
);
10763 /* Returns nonzero if the pointer-type FROM can be converted to the
10764 pointer-type TO via a qualification conversion. If CONSTP is -1,
10765 then we return nonzero if the pointers are similar, and the
10766 cv-qualification signature of FROM is a proper subset of that of TO.
10768 If CONSTP is positive, then all outer pointers have been
10769 const-qualified. */
10772 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
10774 bool to_more_cv_qualified
= false;
10775 bool is_opaque_pointer
= false;
10777 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10779 if (TREE_CODE (to
) != TREE_CODE (from
))
10782 if (TREE_CODE (from
) == OFFSET_TYPE
10783 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
10784 TYPE_OFFSET_BASETYPE (to
)))
10787 /* Const and volatile mean something different for function and
10788 array types, so the usual checks are not appropriate. We'll
10789 check the array type elements in further iterations. */
10790 if (!FUNC_OR_METHOD_TYPE_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
10792 if (!at_least_as_qualified_p (to
, from
))
10795 if (!at_least_as_qualified_p (from
, to
))
10799 to_more_cv_qualified
= true;
10803 constp
&= TYPE_READONLY (to
);
10806 if (VECTOR_TYPE_P (to
))
10807 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
10809 /* P0388R4 allows a conversion from int[N] to int[] but not the
10810 other way round. When both arrays have bounds but they do
10811 not match, then no conversion is possible. */
10812 if (TREE_CODE (to
) == ARRAY_TYPE
10813 && !comp_array_types (to
, from
, bounds_first
, /*strict=*/false))
10816 if (!TYPE_PTR_P (to
)
10817 && !TYPE_PTRDATAMEM_P (to
)
10818 /* CWG 330 says we need to look through arrays. */
10819 && TREE_CODE (to
) != ARRAY_TYPE
)
10820 return ((constp
>= 0 || to_more_cv_qualified
)
10821 && (is_opaque_pointer
10822 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
10826 /* When comparing, say, char ** to char const **, this function takes
10827 the 'char *' and 'char const *'. Do not pass non-pointer/reference
10828 types to this function. */
10831 comp_ptr_ttypes (tree to
, tree from
)
10833 return comp_ptr_ttypes_real (to
, from
, 1);
10836 /* Returns true iff FNTYPE is a non-class type that involves
10837 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
10838 if a parameter type is ill-formed. */
10841 error_type_p (const_tree type
)
10845 switch (TREE_CODE (type
))
10851 case REFERENCE_TYPE
:
10853 return error_type_p (TREE_TYPE (type
));
10855 case FUNCTION_TYPE
:
10857 if (error_type_p (TREE_TYPE (type
)))
10859 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
10860 if (error_type_p (TREE_VALUE (t
)))
10865 if (TYPE_PTRMEMFUNC_P (type
))
10866 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type
));
10874 /* Returns true if to and from are (possibly multi-level) pointers to the same
10875 type or inheritance-related types, regardless of cv-quals. */
10878 ptr_reasonably_similar (const_tree to
, const_tree from
)
10880 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10882 /* Any target type is similar enough to void. */
10883 if (VOID_TYPE_P (to
))
10884 return !error_type_p (from
);
10885 if (VOID_TYPE_P (from
))
10886 return !error_type_p (to
);
10888 if (TREE_CODE (to
) != TREE_CODE (from
))
10891 if (TREE_CODE (from
) == OFFSET_TYPE
10892 && comptypes (TYPE_OFFSET_BASETYPE (to
),
10893 TYPE_OFFSET_BASETYPE (from
),
10894 COMPARE_BASE
| COMPARE_DERIVED
))
10897 if (VECTOR_TYPE_P (to
)
10898 && vector_types_convertible_p (to
, from
, false))
10901 if (TREE_CODE (to
) == INTEGER_TYPE
10902 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
10905 if (TREE_CODE (to
) == FUNCTION_TYPE
)
10906 return !error_type_p (to
) && !error_type_p (from
);
10908 if (!TYPE_PTR_P (to
))
10910 /* When either type is incomplete avoid DERIVED_FROM_P,
10911 which may call complete_type (c++/57942). */
10912 bool b
= !COMPLETE_TYPE_P (to
) || !COMPLETE_TYPE_P (from
);
10914 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
10915 b
? COMPARE_STRICT
: COMPARE_BASE
| COMPARE_DERIVED
);
10920 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
10921 pointer-to-member types) are the same, ignoring cv-qualification at
10922 all levels. CB says how we should behave when comparing array bounds. */
10925 comp_ptr_ttypes_const (tree to
, tree from
, compare_bounds_t cb
)
10927 bool is_opaque_pointer
= false;
10929 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10931 if (TREE_CODE (to
) != TREE_CODE (from
))
10934 if (TREE_CODE (from
) == OFFSET_TYPE
10935 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
10936 TYPE_OFFSET_BASETYPE (to
)))
10939 if (VECTOR_TYPE_P (to
))
10940 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
10942 if (TREE_CODE (to
) == ARRAY_TYPE
10943 /* Ignore cv-qualification, but if we see e.g. int[3] and int[4],
10945 && !comp_array_types (to
, from
, cb
, /*strict=*/false))
10948 /* CWG 330 says we need to look through arrays. */
10949 if (!TYPE_PTR_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
10950 return (is_opaque_pointer
10951 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
10955 /* Returns the type qualifiers for this type, including the qualifiers on the
10956 elements for an array type. */
10959 cp_type_quals (const_tree type
)
10962 /* This CONST_CAST is okay because strip_array_types returns its
10963 argument unmodified and we assign it to a const_tree. */
10964 type
= strip_array_types (CONST_CAST_TREE (type
));
10965 if (type
== error_mark_node
10966 /* Quals on a FUNCTION_TYPE are memfn quals. */
10967 || TREE_CODE (type
) == FUNCTION_TYPE
)
10968 return TYPE_UNQUALIFIED
;
10969 quals
= TYPE_QUALS (type
);
10970 /* METHOD and REFERENCE_TYPEs should never have quals. */
10971 gcc_assert ((TREE_CODE (type
) != METHOD_TYPE
10972 && !TYPE_REF_P (type
))
10973 || ((quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
))
10974 == TYPE_UNQUALIFIED
));
10978 /* Returns the function-ref-qualifier for TYPE */
10981 type_memfn_rqual (const_tree type
)
10983 gcc_assert (FUNC_OR_METHOD_TYPE_P (type
));
10985 if (!FUNCTION_REF_QUALIFIED (type
))
10986 return REF_QUAL_NONE
;
10987 else if (FUNCTION_RVALUE_QUALIFIED (type
))
10988 return REF_QUAL_RVALUE
;
10990 return REF_QUAL_LVALUE
;
10993 /* Returns the function-cv-quals for TYPE, which must be a FUNCTION_TYPE or
10997 type_memfn_quals (const_tree type
)
10999 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11000 return TYPE_QUALS (type
);
11001 else if (TREE_CODE (type
) == METHOD_TYPE
)
11002 return cp_type_quals (class_of_this_parm (type
));
11004 gcc_unreachable ();
11007 /* Returns the FUNCTION_TYPE TYPE with its function-cv-quals changed to
11008 MEMFN_QUALS and its ref-qualifier to RQUAL. */
11011 apply_memfn_quals (tree type
, cp_cv_quals memfn_quals
, cp_ref_qualifier rqual
)
11013 /* Could handle METHOD_TYPE here if necessary. */
11014 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
11015 if (TYPE_QUALS (type
) == memfn_quals
11016 && type_memfn_rqual (type
) == rqual
)
11019 /* This should really have a different TYPE_MAIN_VARIANT, but that gets
11021 tree result
= build_qualified_type (type
, memfn_quals
);
11022 return build_ref_qualified_type (result
, rqual
);
11025 /* Returns nonzero if TYPE is const or volatile. */
11028 cv_qualified_p (const_tree type
)
11030 int quals
= cp_type_quals (type
);
11031 return (quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)) != 0;
11034 /* Returns nonzero if the TYPE contains a mutable member. */
11037 cp_has_mutable_p (const_tree type
)
11039 /* This CONST_CAST is okay because strip_array_types returns its
11040 argument unmodified and we assign it to a const_tree. */
11041 type
= strip_array_types (CONST_CAST_TREE(type
));
11043 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
11046 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
11047 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
11048 approximation. In particular, consider:
11051 struct S { int i; };
11052 const S s = { f(); }
11054 Here, we will make "s" as TREE_READONLY (because it is declared
11055 "const") -- only to reverse ourselves upon seeing that the
11056 initializer is non-constant. */
11059 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
11061 tree type
= TREE_TYPE (decl
);
11063 if (type
== error_mark_node
)
11066 if (TREE_CODE (decl
) == TYPE_DECL
)
11069 gcc_assert (!(TREE_CODE (type
) == FUNCTION_TYPE
11070 && type_quals
!= TYPE_UNQUALIFIED
));
11072 /* Avoid setting TREE_READONLY incorrectly. */
11073 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
11074 constructor can produce constant init, so rely on cp_finish_decl to
11075 clear TREE_READONLY if the variable has non-constant init. */
11077 /* If the type has (or might have) a mutable component, that component
11078 might be modified. */
11079 if (TYPE_HAS_MUTABLE_P (type
) || !COMPLETE_TYPE_P (type
))
11080 type_quals
&= ~TYPE_QUAL_CONST
;
11082 c_apply_type_quals_to_decl (type_quals
, decl
);
11085 /* Subroutine of casts_away_constness. Make T1 and T2 point at
11086 exemplar types such that casting T1 to T2 is casting away constness
11087 if and only if there is no implicit conversion from T1 to T2. */
11090 casts_away_constness_r (tree
*t1
, tree
*t2
, tsubst_flags_t complain
)
11095 /* [expr.const.cast]
11097 For multi-level pointer to members and multi-level mixed pointers
11098 and pointers to members (conv.qual), the "member" aspect of a
11099 pointer to member level is ignored when determining if a const
11100 cv-qualifier has been cast away. */
11101 /* [expr.const.cast]
11103 For two pointer types:
11105 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
11106 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
11109 casting from X1 to X2 casts away constness if, for a non-pointer
11110 type T there does not exist an implicit conversion (clause
11113 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
11117 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
11118 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRDATAMEM_P (*t1
))
11119 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRDATAMEM_P (*t2
)))
11121 *t1
= cp_build_qualified_type (void_type_node
,
11122 cp_type_quals (*t1
));
11123 *t2
= cp_build_qualified_type (void_type_node
,
11124 cp_type_quals (*t2
));
11128 quals1
= cp_type_quals (*t1
);
11129 quals2
= cp_type_quals (*t2
);
11131 if (TYPE_PTRDATAMEM_P (*t1
))
11132 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
11134 *t1
= TREE_TYPE (*t1
);
11135 if (TYPE_PTRDATAMEM_P (*t2
))
11136 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
11138 *t2
= TREE_TYPE (*t2
);
11140 casts_away_constness_r (t1
, t2
, complain
);
11141 *t1
= build_pointer_type (*t1
);
11142 *t2
= build_pointer_type (*t2
);
11143 *t1
= cp_build_qualified_type (*t1
, quals1
);
11144 *t2
= cp_build_qualified_type (*t2
, quals2
);
11147 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
11150 ??? This function returns non-zero if casting away qualifiers not
11151 just const. We would like to return to the caller exactly which
11152 qualifiers are casted away to give more accurate diagnostics.
11156 casts_away_constness (tree t1
, tree t2
, tsubst_flags_t complain
)
11158 if (TYPE_REF_P (t2
))
11160 /* [expr.const.cast]
11162 Casting from an lvalue of type T1 to an lvalue of type T2
11163 using a reference cast casts away constness if a cast from an
11164 rvalue of type "pointer to T1" to the type "pointer to T2"
11165 casts away constness. */
11166 t1
= (TYPE_REF_P (t1
) ? TREE_TYPE (t1
) : t1
);
11167 return casts_away_constness (build_pointer_type (t1
),
11168 build_pointer_type (TREE_TYPE (t2
)),
11172 if (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
11173 /* [expr.const.cast]
11175 Casting from an rvalue of type "pointer to data member of X
11176 of type T1" to the type "pointer to data member of Y of type
11177 T2" casts away constness if a cast from an rvalue of type
11178 "pointer to T1" to the type "pointer to T2" casts away
11180 return casts_away_constness
11181 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
11182 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)),
11185 /* Casting away constness is only something that makes sense for
11186 pointer or reference types. */
11187 if (!TYPE_PTR_P (t1
) || !TYPE_PTR_P (t2
))
11190 /* Top-level qualifiers don't matter. */
11191 t1
= TYPE_MAIN_VARIANT (t1
);
11192 t2
= TYPE_MAIN_VARIANT (t2
);
11193 casts_away_constness_r (&t1
, &t2
, complain
);
11194 if (!can_convert (t2
, t1
, complain
))
11200 /* If T is a REFERENCE_TYPE return the type to which T refers.
11201 Otherwise, return T itself. */
11204 non_reference (tree t
)
11206 if (t
&& TYPE_REF_P (t
))
11212 /* Return nonzero if REF is an lvalue valid for this language;
11213 otherwise, print an error message and return zero. USE says
11214 how the lvalue is being used and so selects the error message. */
11217 lvalue_or_else (tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
11219 cp_lvalue_kind kind
= lvalue_kind (ref
);
11221 if (kind
== clk_none
)
11223 if (complain
& tf_error
)
11224 lvalue_error (cp_expr_loc_or_input_loc (ref
), use
);
11227 else if (kind
& (clk_rvalueref
|clk_class
))
11229 if (!(complain
& tf_error
))
11231 /* Make this a permerror because we used to accept it. */
11232 permerror (cp_expr_loc_or_input_loc (ref
),
11233 "using rvalue as lvalue");
11238 /* Return true if a user-defined literal operator is a raw operator. */
11241 check_raw_literal_operator (const_tree decl
)
11243 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11246 bool maybe_raw_p
= false;
11248 /* Count the number and type of arguments and check for ellipsis. */
11249 for (argtype
= argtypes
, arity
= 0;
11250 argtype
&& argtype
!= void_list_node
;
11251 ++arity
, argtype
= TREE_CHAIN (argtype
))
11253 tree t
= TREE_VALUE (argtype
);
11255 if (same_type_p (t
, const_string_type_node
))
11256 maybe_raw_p
= true;
11259 return false; /* Found ellipsis. */
11261 if (!maybe_raw_p
|| arity
!= 1)
11268 /* Return true if a user-defined literal operator has one of the allowed
11272 check_literal_operator_args (const_tree decl
,
11273 bool *long_long_unsigned_p
, bool *long_double_p
)
11275 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11277 *long_long_unsigned_p
= false;
11278 *long_double_p
= false;
11279 if (processing_template_decl
|| processing_specialization
)
11280 return argtypes
== void_list_node
;
11287 /* Count the number and type of arguments and check for ellipsis. */
11288 for (argtype
= argtypes
, arity
= 0;
11289 argtype
&& argtype
!= void_list_node
;
11290 argtype
= TREE_CHAIN (argtype
))
11292 tree t
= TREE_VALUE (argtype
);
11295 if (TYPE_PTR_P (t
))
11297 bool maybe_raw_p
= false;
11299 if (cp_type_quals (t
) != TYPE_QUAL_CONST
)
11301 t
= TYPE_MAIN_VARIANT (t
);
11302 if ((maybe_raw_p
= same_type_p (t
, char_type_node
))
11303 || same_type_p (t
, wchar_type_node
)
11304 || same_type_p (t
, char8_type_node
)
11305 || same_type_p (t
, char16_type_node
)
11306 || same_type_p (t
, char32_type_node
))
11308 argtype
= TREE_CHAIN (argtype
);
11311 t
= TREE_VALUE (argtype
);
11312 if (maybe_raw_p
&& argtype
== void_list_node
)
11314 else if (same_type_p (t
, size_type_node
))
11323 else if (same_type_p (t
, long_long_unsigned_type_node
))
11326 *long_long_unsigned_p
= true;
11328 else if (same_type_p (t
, long_double_type_node
))
11331 *long_double_p
= true;
11333 else if (same_type_p (t
, char_type_node
))
11335 else if (same_type_p (t
, wchar_type_node
))
11337 else if (same_type_p (t
, char8_type_node
))
11339 else if (same_type_p (t
, char16_type_node
))
11341 else if (same_type_p (t
, char32_type_node
))
11347 return false; /* Found ellipsis. */
11349 if (arity
!= max_arity
)
11356 /* Always returns false since unlike C90, C++ has no concept of implicit
11357 function declarations. */
11360 c_decl_implicit (const_tree
)