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
)
6319 ? type_dependent_expression_p ((*args
)[i
])
6320 : instantiation_dependent_expression_p ((*args
)[i
]))
6322 tree exp
= build_min_nt_call_vec (NULL
, args
);
6323 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6326 arg0
= build_non_dependent_expr (arg0
);
6327 arg1
= build_non_dependent_expr (arg1
);
6328 /* ??? Nothing needed for the index arguments? */
6330 auto_vec
<tree
, 16> mask
;
6331 for (unsigned i
= 2; i
< args
->length (); ++i
)
6333 tree idx
= maybe_constant_value ((*args
)[i
]);
6334 mask
.safe_push (idx
);
6336 tree exp
= c_build_shufflevector (loc
, arg0
, arg1
, mask
, complain
& tf_error
);
6337 if (processing_template_decl
&& exp
!= error_mark_node
)
6339 exp
= build_min_non_dep_call_vec (exp
, NULL
, args
);
6340 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6345 /* Return a tree for the sum or difference (RESULTCODE says which)
6346 of pointer PTROP and integer INTOP. */
6349 cp_pointer_int_sum (location_t loc
, enum tree_code resultcode
, tree ptrop
,
6350 tree intop
, tsubst_flags_t complain
)
6352 tree res_type
= TREE_TYPE (ptrop
);
6354 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
6355 in certain circumstance (when it's valid to do so). So we need
6356 to make sure it's complete. We don't need to check here, if we
6357 can actually complete it at all, as those checks will be done in
6358 pointer_int_sum() anyway. */
6359 complete_type (TREE_TYPE (res_type
));
6361 return pointer_int_sum (loc
, resultcode
, ptrop
,
6362 intop
, complain
& tf_warning_or_error
);
6365 /* Return a tree for the difference of pointers OP0 and OP1.
6366 The resulting tree has type int. If POINTER_SUBTRACT sanitization is
6367 enabled, assign to INSTRUMENT_EXPR call to libsanitizer. */
6370 pointer_diff (location_t loc
, tree op0
, tree op1
, tree ptrtype
,
6371 tsubst_flags_t complain
, tree
*instrument_expr
)
6373 tree result
, inttype
;
6374 tree restype
= ptrdiff_type_node
;
6375 tree target_type
= TREE_TYPE (ptrtype
);
6377 if (!complete_type_or_maybe_complain (target_type
, NULL_TREE
, complain
))
6378 return error_mark_node
;
6380 if (VOID_TYPE_P (target_type
))
6382 if (complain
& tf_error
)
6383 permerror (loc
, "ISO C++ forbids using pointer of "
6384 "type %<void *%> in subtraction");
6386 return error_mark_node
;
6388 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
6390 if (complain
& tf_error
)
6391 permerror (loc
, "ISO C++ forbids using pointer to "
6392 "a function in subtraction");
6394 return error_mark_node
;
6396 if (TREE_CODE (target_type
) == METHOD_TYPE
)
6398 if (complain
& tf_error
)
6399 permerror (loc
, "ISO C++ forbids using pointer to "
6400 "a method in subtraction");
6402 return error_mark_node
;
6404 else if (!verify_type_context (loc
, TCTX_POINTER_ARITH
,
6405 TREE_TYPE (TREE_TYPE (op0
)),
6406 !(complain
& tf_error
))
6407 || !verify_type_context (loc
, TCTX_POINTER_ARITH
,
6408 TREE_TYPE (TREE_TYPE (op1
)),
6409 !(complain
& tf_error
)))
6410 return error_mark_node
;
6412 /* Determine integer type result of the subtraction. This will usually
6413 be the same as the result type (ptrdiff_t), but may need to be a wider
6414 type if pointers for the address space are wider than ptrdiff_t. */
6415 if (TYPE_PRECISION (restype
) < TYPE_PRECISION (TREE_TYPE (op0
)))
6416 inttype
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0
)), 0);
6420 if (!processing_template_decl
6421 && sanitize_flags_p (SANITIZE_POINTER_SUBTRACT
))
6423 op0
= save_expr (op0
);
6424 op1
= save_expr (op1
);
6426 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT
);
6427 *instrument_expr
= build_call_expr_loc (loc
, tt
, 2, op0
, op1
);
6430 /* First do the subtraction, then build the divide operator
6431 and only convert at the very end.
6432 Do not do default conversions in case restype is a short type. */
6434 /* POINTER_DIFF_EXPR requires a signed integer type of the same size as
6435 pointers. If some platform cannot provide that, or has a larger
6436 ptrdiff_type to support differences larger than half the address
6437 space, cast the pointers to some larger integer type and do the
6438 computations in that type. */
6439 if (TYPE_PRECISION (inttype
) > TYPE_PRECISION (TREE_TYPE (op0
)))
6440 op0
= cp_build_binary_op (loc
,
6442 cp_convert (inttype
, op0
, complain
),
6443 cp_convert (inttype
, op1
, complain
),
6446 op0
= build2_loc (loc
, POINTER_DIFF_EXPR
, inttype
, op0
, op1
);
6448 /* This generates an error if op1 is a pointer to an incomplete type. */
6449 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
6451 if (complain
& tf_error
)
6452 error_at (loc
, "invalid use of a pointer to an incomplete type in "
6453 "pointer arithmetic");
6455 return error_mark_node
;
6458 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (op1
)))
6460 if (complain
& tf_error
)
6461 error_at (loc
, "arithmetic on pointer to an empty aggregate");
6463 return error_mark_node
;
6466 op1
= (TYPE_PTROB_P (ptrtype
)
6467 ? size_in_bytes_loc (loc
, target_type
)
6468 : integer_one_node
);
6470 /* Do the division. */
6472 result
= build2_loc (loc
, EXACT_DIV_EXPR
, inttype
, op0
,
6473 cp_convert (inttype
, op1
, complain
));
6474 return cp_convert (restype
, result
, complain
);
6477 /* Construct and perhaps optimize a tree representation
6478 for a unary operation. CODE, a tree_code, specifies the operation
6479 and XARG is the operand. */
6482 build_x_unary_op (location_t loc
, enum tree_code code
, cp_expr xarg
,
6483 tree lookups
, tsubst_flags_t complain
)
6485 tree orig_expr
= xarg
;
6488 tree overload
= NULL_TREE
;
6490 if (processing_template_decl
)
6492 if (type_dependent_expression_p (xarg
))
6494 tree e
= build_min_nt_loc (loc
, code
, xarg
.get_value (), NULL_TREE
);
6495 TREE_TYPE (e
) = build_dependent_operator_type (lookups
, code
, false);
6499 xarg
= build_non_dependent_expr (xarg
);
6504 /* [expr.unary.op] says:
6506 The address of an object of incomplete type can be taken.
6508 (And is just the ordinary address operator, not an overloaded
6509 "operator &".) However, if the type is a template
6510 specialization, we must complete the type at this point so that
6511 an overloaded "operator &" will be available if required. */
6512 if (code
== ADDR_EXPR
6513 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
6514 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
6515 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
6516 || (TREE_CODE (xarg
) == OFFSET_REF
)))
6517 /* Don't look for a function. */;
6519 exp
= build_new_op (loc
, code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
,
6520 NULL_TREE
, lookups
, &overload
, complain
);
6522 if (!exp
&& code
== ADDR_EXPR
)
6524 if (is_overloaded_fn (xarg
))
6526 tree fn
= get_first_fn (xarg
);
6527 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
6529 if (complain
& tf_error
)
6530 error_at (loc
, DECL_CONSTRUCTOR_P (fn
)
6531 ? G_("taking address of constructor %qD")
6532 : G_("taking address of destructor %qD"),
6534 return error_mark_node
;
6538 /* A pointer to member-function can be formed only by saying
6540 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
6541 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
6543 if (TREE_CODE (xarg
) != OFFSET_REF
6544 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
6546 if (complain
& tf_error
)
6548 error_at (loc
, "invalid use of %qE to form a "
6549 "pointer-to-member-function", xarg
.get_value ());
6550 if (TREE_CODE (xarg
) != OFFSET_REF
)
6551 inform (loc
, " a qualified-id is required");
6553 return error_mark_node
;
6557 if (complain
& tf_error
)
6558 error_at (loc
, "parentheses around %qE cannot be used to "
6559 "form a pointer-to-member-function",
6562 return error_mark_node
;
6563 PTRMEM_OK_P (xarg
) = 1;
6567 if (TREE_CODE (xarg
) == OFFSET_REF
)
6569 ptrmem
= PTRMEM_OK_P (xarg
);
6571 if (!ptrmem
&& !flag_ms_extensions
6572 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
6574 /* A single non-static member, make sure we don't allow a
6575 pointer-to-member. */
6576 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
6577 TREE_OPERAND (xarg
, 0),
6578 ovl_make (TREE_OPERAND (xarg
, 1)));
6579 PTRMEM_OK_P (xarg
) = ptrmem
;
6583 exp
= cp_build_addr_expr_strict (xarg
, complain
);
6585 if (TREE_CODE (exp
) == PTRMEM_CST
)
6586 PTRMEM_CST_LOCATION (exp
) = loc
;
6588 protected_set_expr_location (exp
, loc
);
6591 if (processing_template_decl
&& exp
!= error_mark_node
)
6593 if (overload
!= NULL_TREE
)
6594 return (build_min_non_dep_op_overload
6595 (code
, exp
, overload
, orig_expr
, integer_zero_node
));
6597 exp
= build_min_non_dep (code
, exp
, orig_expr
,
6598 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
6600 if (TREE_CODE (exp
) == ADDR_EXPR
)
6601 PTRMEM_OK_P (exp
) = ptrmem
;
6605 /* Construct and perhaps optimize a tree representation
6606 for __builtin_addressof operation. ARG specifies the operand. */
6609 cp_build_addressof (location_t loc
, tree arg
, tsubst_flags_t complain
)
6611 tree orig_expr
= arg
;
6613 if (processing_template_decl
)
6615 if (type_dependent_expression_p (arg
))
6616 return build_min_nt_loc (loc
, ADDRESSOF_EXPR
, arg
, NULL_TREE
);
6618 arg
= build_non_dependent_expr (arg
);
6621 tree exp
= cp_build_addr_expr_strict (arg
, complain
);
6623 if (processing_template_decl
&& exp
!= error_mark_node
)
6624 exp
= build_min_non_dep (ADDRESSOF_EXPR
, exp
, orig_expr
, NULL_TREE
);
6628 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
6629 constants, where a null value is represented by an INTEGER_CST of
6633 cp_truthvalue_conversion (tree expr
, tsubst_flags_t complain
)
6635 tree type
= TREE_TYPE (expr
);
6636 location_t loc
= cp_expr_loc_or_input_loc (expr
);
6637 if (TYPE_PTR_OR_PTRMEM_P (type
)
6638 /* Avoid ICE on invalid use of non-static member function. */
6639 || TREE_CODE (expr
) == FUNCTION_DECL
)
6640 return cp_build_binary_op (loc
, NE_EXPR
, expr
, nullptr_node
, complain
);
6642 return c_common_truthvalue_conversion (loc
, expr
);
6645 /* Returns EXPR contextually converted to bool. */
6648 contextual_conv_bool (tree expr
, tsubst_flags_t complain
)
6650 return perform_implicit_conversion_flags (boolean_type_node
, expr
,
6651 complain
, LOOKUP_NORMAL
);
6654 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. This
6655 is a low-level function; most callers should use maybe_convert_cond. */
6658 condition_conversion (tree expr
)
6660 tree t
= contextual_conv_bool (expr
, tf_warning_or_error
);
6661 if (!processing_template_decl
)
6662 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
6666 /* Returns the address of T. This function will fold away
6667 ADDR_EXPR of INDIRECT_REF. This is only for low-level usage;
6668 most places should use cp_build_addr_expr instead. */
6671 build_address (tree t
)
6673 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
6674 return error_mark_node
;
6675 gcc_checking_assert (TREE_CODE (t
) != CONSTRUCTOR
6676 || processing_template_decl
);
6677 t
= build_fold_addr_expr_loc (EXPR_LOCATION (t
), t
);
6678 if (TREE_CODE (t
) != ADDR_EXPR
)
6683 /* Return a NOP_EXPR converting EXPR to TYPE. */
6686 build_nop (tree type
, tree expr
)
6688 if (type
== error_mark_node
|| error_operand_p (expr
))
6690 return build1_loc (EXPR_LOCATION (expr
), NOP_EXPR
, type
, expr
);
6693 /* Take the address of ARG, whatever that means under C++ semantics.
6694 If STRICT_LVALUE is true, require an lvalue; otherwise, allow xvalues
6695 and class rvalues as well.
6697 Nothing should call this function directly; instead, callers should use
6698 cp_build_addr_expr or cp_build_addr_expr_strict. */
6701 cp_build_addr_expr_1 (tree arg
, bool strict_lvalue
, tsubst_flags_t complain
)
6706 if (!arg
|| error_operand_p (arg
))
6707 return error_mark_node
;
6709 arg
= mark_lvalue_use (arg
);
6710 if (error_operand_p (arg
))
6711 return error_mark_node
;
6713 argtype
= lvalue_type (arg
);
6714 location_t loc
= cp_expr_loc_or_input_loc (arg
);
6716 gcc_assert (!(identifier_p (arg
) && IDENTIFIER_ANY_OP_P (arg
)));
6718 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
6719 && !really_overloaded_fn (arg
))
6721 /* They're trying to take the address of a unique non-static
6722 member function. This is ill-formed (except in MS-land),
6723 but let's try to DTRT.
6724 Note: We only handle unique functions here because we don't
6725 want to complain if there's a static overload; non-unique
6726 cases will be handled by instantiate_type. But we need to
6727 handle this case here to allow casts on the resulting PMF.
6728 We could defer this in non-MS mode, but it's easier to give
6729 a useful error here. */
6731 /* Inside constant member functions, the `this' pointer
6732 contains an extra const qualifier. TYPE_MAIN_VARIANT
6733 is used here to remove this const from the diagnostics
6734 and the created OFFSET_REF. */
6735 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
6736 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
6737 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6738 return error_mark_node
;
6740 if (! flag_ms_extensions
)
6742 tree name
= DECL_NAME (fn
);
6743 if (!(complain
& tf_error
))
6744 return error_mark_node
;
6745 else if (current_class_type
6746 && TREE_OPERAND (arg
, 0) == current_class_ref
)
6747 /* An expression like &memfn. */
6749 "ISO C++ forbids taking the address of an unqualified"
6750 " or parenthesized non-static member function to form"
6751 " a pointer to member function. Say %<&%T::%D%>",
6755 "ISO C++ forbids taking the address of a bound member"
6756 " function to form a pointer to member function."
6760 arg
= build_offset_ref (base
, fn
, /*address_p=*/true, complain
);
6763 /* Uninstantiated types are all functions. Taking the
6764 address of a function is a no-op, so just return the
6766 if (type_unknown_p (arg
))
6767 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
6769 if (TREE_CODE (arg
) == OFFSET_REF
)
6770 /* We want a pointer to member; bypass all the code for actually taking
6771 the address of something. */
6774 /* Anything not already handled and not a true memory reference
6776 if (!FUNC_OR_METHOD_TYPE_P (argtype
))
6778 cp_lvalue_kind kind
= lvalue_kind (arg
);
6779 if (kind
== clk_none
)
6781 if (complain
& tf_error
)
6782 lvalue_error (loc
, lv_addressof
);
6783 return error_mark_node
;
6785 if (strict_lvalue
&& (kind
& (clk_rvalueref
|clk_class
)))
6787 if (!(complain
& tf_error
))
6788 return error_mark_node
;
6789 /* Make this a permerror because we used to accept it. */
6790 permerror (loc
, "taking address of rvalue");
6794 if (TYPE_REF_P (argtype
))
6796 tree type
= build_pointer_type (TREE_TYPE (argtype
));
6797 arg
= build1 (CONVERT_EXPR
, type
, arg
);
6800 else if (pedantic
&& DECL_MAIN_P (tree_strip_any_location_wrapper (arg
)))
6803 /* Apparently a lot of autoconf scripts for C++ packages do this,
6804 so only complain if -Wpedantic. */
6805 if (complain
& (flag_pedantic_errors
? tf_error
: tf_warning
))
6806 pedwarn (loc
, OPT_Wpedantic
,
6807 "ISO C++ forbids taking address of function %<::main%>");
6808 else if (flag_pedantic_errors
)
6809 return error_mark_node
;
6812 /* Let &* cancel out to simplify resulting code. */
6813 if (INDIRECT_REF_P (arg
))
6815 arg
= TREE_OPERAND (arg
, 0);
6816 if (TYPE_REF_P (TREE_TYPE (arg
)))
6818 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
6819 arg
= build1 (CONVERT_EXPR
, type
, arg
);
6822 /* Don't let this be an lvalue. */
6827 /* Handle complex lvalues (when permitted)
6828 by reduction to simpler cases. */
6829 val
= unary_complex_lvalue (ADDR_EXPR
, arg
);
6833 switch (TREE_CODE (arg
))
6837 case FIX_TRUNC_EXPR
:
6838 /* We should have handled this above in the lvalue_kind check. */
6843 arg
= BASELINK_FUNCTIONS (arg
);
6847 arg
= OVL_FIRST (arg
);
6852 /* Turn a reference to a non-static data member into a
6853 pointer-to-member. */
6858 gcc_assert (PTRMEM_OK_P (arg
));
6860 t
= TREE_OPERAND (arg
, 1);
6861 if (TYPE_REF_P (TREE_TYPE (t
)))
6863 if (complain
& tf_error
)
6865 "cannot create pointer to reference member %qD", t
);
6866 return error_mark_node
;
6869 /* Forming a pointer-to-member is a use of non-pure-virtual fns. */
6870 if (TREE_CODE (t
) == FUNCTION_DECL
6871 && !DECL_PURE_VIRTUAL_P (t
)
6872 && !mark_used (t
, complain
) && !(complain
& tf_error
))
6873 return error_mark_node
;
6875 type
= build_ptrmem_type (context_for_name_lookup (t
),
6877 t
= make_ptrmem_cst (type
, t
);
6885 if (argtype
!= error_mark_node
)
6886 argtype
= build_pointer_type (argtype
);
6888 if (bitfield_p (arg
))
6890 if (complain
& tf_error
)
6891 error_at (loc
, "attempt to take address of bit-field");
6892 return error_mark_node
;
6895 /* In a template, we are processing a non-dependent expression
6896 so we can just form an ADDR_EXPR with the correct type. */
6897 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
6899 if (!mark_single_function (arg
, complain
))
6900 return error_mark_node
;
6901 val
= build_address (arg
);
6902 if (TREE_CODE (arg
) == OFFSET_REF
)
6903 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
6905 else if (BASELINK_P (TREE_OPERAND (arg
, 1)))
6907 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
6909 /* We can only get here with a single static member
6911 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
6912 && DECL_STATIC_FUNCTION_P (fn
));
6913 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
6914 return error_mark_node
;
6915 val
= build_address (fn
);
6916 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
6917 /* Do not lose object's side effects. */
6918 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
6919 TREE_OPERAND (arg
, 0), val
);
6923 tree object
= TREE_OPERAND (arg
, 0);
6924 tree field
= TREE_OPERAND (arg
, 1);
6925 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6926 (TREE_TYPE (object
), decl_type_context (field
)));
6927 val
= build_address (arg
);
6930 if (TYPE_PTR_P (argtype
)
6931 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
6933 build_ptrmemfunc_type (argtype
);
6934 val
= build_ptrmemfunc (argtype
, val
, 0,
6939 /* For addresses of immediate functions ensure we have EXPR_LOCATION
6940 set for possible later diagnostics. */
6941 if (TREE_CODE (val
) == ADDR_EXPR
6942 && TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
6943 && DECL_IMMEDIATE_FUNCTION_P (TREE_OPERAND (val
, 0)))
6944 SET_EXPR_LOCATION (val
, input_location
);
6949 /* Take the address of ARG if it has one, even if it's an rvalue. */
6952 cp_build_addr_expr (tree arg
, tsubst_flags_t complain
)
6954 return cp_build_addr_expr_1 (arg
, 0, complain
);
6957 /* Take the address of ARG, but only if it's an lvalue. */
6960 cp_build_addr_expr_strict (tree arg
, tsubst_flags_t complain
)
6962 return cp_build_addr_expr_1 (arg
, 1, complain
);
6965 /* C++: Must handle pointers to members.
6967 Perhaps type instantiation should be extended to handle conversion
6968 from aggregates to types we don't yet know we want? (Or are those
6969 cases typically errors which should be reported?)
6971 NOCONVERT suppresses the default promotions (such as from short to int). */
6974 cp_build_unary_op (enum tree_code code
, tree xarg
, bool noconvert
,
6975 tsubst_flags_t complain
)
6977 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
6979 location_t location
= cp_expr_loc_or_input_loc (arg
);
6981 const char *errstring
= NULL
;
6983 const char *invalid_op_diag
;
6985 if (!arg
|| error_operand_p (arg
))
6986 return error_mark_node
;
6988 arg
= resolve_nondeduced_context (arg
, complain
);
6990 if ((invalid_op_diag
6991 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
6996 if (complain
& tf_error
)
6997 error (invalid_op_diag
);
6998 return error_mark_node
;
7003 case UNARY_PLUS_EXPR
:
7006 int flags
= WANT_ARITH
| WANT_ENUM
;
7007 /* Unary plus (but not unary minus) is allowed on pointers. */
7008 if (code
== UNARY_PLUS_EXPR
)
7009 flags
|= WANT_POINTER
;
7010 arg
= build_expr_type_conversion (flags
, arg
, true);
7012 errstring
= (code
== NEGATE_EXPR
7013 ? _("wrong type argument to unary minus")
7014 : _("wrong type argument to unary plus"));
7017 if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7018 arg
= cp_perform_integral_promotions (arg
, complain
);
7020 /* Make sure the result is not an lvalue: a unary plus or minus
7021 expression is always a rvalue. */
7028 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7033 arg
= cp_default_conversion (arg
, complain
);
7034 if (arg
== error_mark_node
)
7035 return error_mark_node
;
7038 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
7039 | WANT_VECTOR_OR_COMPLEX
,
7041 errstring
= _("wrong type argument to bit-complement");
7042 else if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7044 /* Warn if the expression has boolean value. */
7045 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
7046 && (complain
& tf_warning
)
7047 && warning_at (location
, OPT_Wbool_operation
,
7048 "%<~%> on an expression of type %<bool%>"))
7049 inform (location
, "did you mean to use logical not (%<!%>)?");
7050 arg
= cp_perform_integral_promotions (arg
, complain
);
7052 else if (!noconvert
&& VECTOR_TYPE_P (TREE_TYPE (arg
)))
7053 arg
= mark_rvalue_use (arg
);
7057 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7058 errstring
= _("wrong type argument to abs");
7059 else if (!noconvert
)
7061 arg
= cp_default_conversion (arg
, complain
);
7062 if (arg
== error_mark_node
)
7063 return error_mark_node
;
7068 /* Conjugating a real value is a no-op, but allow it anyway. */
7069 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7070 errstring
= _("wrong type argument to conjugation");
7071 else if (!noconvert
)
7073 arg
= cp_default_conversion (arg
, complain
);
7074 if (arg
== error_mark_node
)
7075 return error_mark_node
;
7079 case TRUTH_NOT_EXPR
:
7080 if (gnu_vector_type_p (TREE_TYPE (arg
)))
7081 return cp_build_binary_op (input_location
, EQ_EXPR
, arg
,
7082 build_zero_cst (TREE_TYPE (arg
)), complain
);
7083 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
7085 val
= invert_truthvalue_loc (location
, arg
);
7086 if (arg
!= error_mark_node
)
7088 errstring
= _("in argument to unary !");
7096 arg
= build_real_imag_expr (input_location
, code
, arg
);
7099 case PREINCREMENT_EXPR
:
7100 case POSTINCREMENT_EXPR
:
7101 case PREDECREMENT_EXPR
:
7102 case POSTDECREMENT_EXPR
:
7103 /* Handle complex lvalues (when permitted)
7104 by reduction to simpler cases. */
7106 val
= unary_complex_lvalue (code
, arg
);
7110 arg
= mark_lvalue_use (arg
);
7112 /* Increment or decrement the real part of the value,
7113 and don't change the imaginary part. */
7114 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7118 arg
= cp_stabilize_reference (arg
);
7119 real
= cp_build_unary_op (REALPART_EXPR
, arg
, true, complain
);
7120 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, true, complain
);
7121 real
= cp_build_unary_op (code
, real
, true, complain
);
7122 if (real
== error_mark_node
|| imag
== error_mark_node
)
7123 return error_mark_node
;
7124 return build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
7128 /* Report invalid types. */
7130 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
7133 if (code
== PREINCREMENT_EXPR
)
7134 errstring
= _("no pre-increment operator for type");
7135 else if (code
== POSTINCREMENT_EXPR
)
7136 errstring
= _("no post-increment operator for type");
7137 else if (code
== PREDECREMENT_EXPR
)
7138 errstring
= _("no pre-decrement operator for type");
7140 errstring
= _("no post-decrement operator for type");
7143 else if (arg
== error_mark_node
)
7144 return error_mark_node
;
7146 /* Report something read-only. */
7148 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
7149 || TREE_READONLY (arg
))
7151 if (complain
& tf_error
)
7152 cxx_readonly_error (location
, arg
,
7153 ((code
== PREINCREMENT_EXPR
7154 || code
== POSTINCREMENT_EXPR
)
7155 ? lv_increment
: lv_decrement
));
7157 return error_mark_node
;
7162 tree declared_type
= unlowered_expr_type (arg
);
7164 argtype
= TREE_TYPE (arg
);
7166 /* ARM $5.2.5 last annotation says this should be forbidden. */
7167 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
7169 if (complain
& tf_error
)
7170 permerror (location
, (code
== PREINCREMENT_EXPR
7171 || code
== POSTINCREMENT_EXPR
)
7172 ? G_("ISO C++ forbids incrementing an enum")
7173 : G_("ISO C++ forbids decrementing an enum"));
7175 return error_mark_node
;
7178 /* Compute the increment. */
7180 if (TYPE_PTR_P (argtype
))
7182 tree type
= complete_type (TREE_TYPE (argtype
));
7184 if (!COMPLETE_OR_VOID_TYPE_P (type
))
7186 if (complain
& tf_error
)
7187 error_at (location
, ((code
== PREINCREMENT_EXPR
7188 || code
== POSTINCREMENT_EXPR
))
7189 ? G_("cannot increment a pointer to incomplete "
7191 : G_("cannot decrement a pointer to incomplete "
7193 TREE_TYPE (argtype
));
7195 return error_mark_node
;
7197 else if (!TYPE_PTROB_P (argtype
))
7199 if (complain
& tf_error
)
7200 pedwarn (location
, OPT_Wpointer_arith
,
7201 (code
== PREINCREMENT_EXPR
7202 || code
== POSTINCREMENT_EXPR
)
7203 ? G_("ISO C++ forbids incrementing a pointer "
7205 : G_("ISO C++ forbids decrementing a pointer "
7209 return error_mark_node
;
7211 else if (!verify_type_context (location
, TCTX_POINTER_ARITH
,
7212 TREE_TYPE (argtype
),
7213 !(complain
& tf_error
)))
7214 return error_mark_node
;
7216 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
7219 inc
= VECTOR_TYPE_P (argtype
)
7220 ? build_one_cst (argtype
)
7223 inc
= cp_convert (argtype
, inc
, complain
);
7225 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
7226 need to ask Objective-C to build the increment or decrement
7227 expression for it. */
7228 if (objc_is_property_ref (arg
))
7229 return objc_build_incr_expr_for_property_ref (input_location
, code
,
7232 /* Complain about anything else that is not a true lvalue. */
7233 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
7234 || code
== POSTINCREMENT_EXPR
)
7235 ? lv_increment
: lv_decrement
),
7237 return error_mark_node
;
7239 /* [depr.volatile.type] "Postfix ++ and -- expressions and
7240 prefix ++ and -- expressions of volatile-qualified arithmetic
7241 and pointer types are deprecated." */
7242 if (TREE_THIS_VOLATILE (arg
) || CP_TYPE_VOLATILE_P (TREE_TYPE (arg
)))
7243 warning_at (location
, OPT_Wvolatile
,
7244 "%qs expression of %<volatile%>-qualified type is "
7246 ((code
== PREINCREMENT_EXPR
7247 || code
== POSTINCREMENT_EXPR
)
7250 /* Forbid using -- or ++ in C++17 on `bool'. */
7251 if (TREE_CODE (declared_type
) == BOOLEAN_TYPE
)
7253 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
7255 if (complain
& tf_error
)
7257 "use of an operand of type %qT in %<operator--%> "
7258 "is forbidden", boolean_type_node
);
7259 return error_mark_node
;
7263 if (cxx_dialect
>= cxx17
)
7265 if (complain
& tf_error
)
7267 "use of an operand of type %qT in "
7268 "%<operator++%> is forbidden in C++17",
7270 return error_mark_node
;
7272 /* Otherwise, [depr.incr.bool] says this is deprecated. */
7274 warning_at (location
, OPT_Wdeprecated
,
7275 "use of an operand of type %qT "
7276 "in %<operator++%> is deprecated",
7279 val
= boolean_increment (code
, arg
);
7281 else if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
7282 /* An rvalue has no cv-qualifiers. */
7283 val
= build2 (code
, cv_unqualified (TREE_TYPE (arg
)), arg
, inc
);
7285 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
7287 TREE_SIDE_EFFECTS (val
) = 1;
7292 /* Note that this operation never does default_conversion
7293 regardless of NOCONVERT. */
7294 return cp_build_addr_expr (arg
, complain
);
7303 argtype
= TREE_TYPE (arg
);
7304 return build1 (code
, argtype
, arg
);
7307 if (complain
& tf_error
)
7308 error_at (location
, "%s", errstring
);
7309 return error_mark_node
;
7312 /* Hook for the c-common bits that build a unary op. */
7314 build_unary_op (location_t
/*location*/,
7315 enum tree_code code
, tree xarg
, bool noconvert
)
7317 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
7320 /* Adjust LVALUE, an MODIFY_EXPR, PREINCREMENT_EXPR or PREDECREMENT_EXPR,
7321 so that it is a valid lvalue even for GENERIC by replacing
7322 (lhs = rhs) with ((lhs = rhs), lhs)
7323 (--lhs) with ((--lhs), lhs)
7324 (++lhs) with ((++lhs), lhs)
7325 and if lhs has side-effects, calling cp_stabilize_reference on it, so
7326 that it can be evaluated multiple times. */
7329 genericize_compound_lvalue (tree lvalue
)
7331 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lvalue
, 0)))
7332 lvalue
= build2 (TREE_CODE (lvalue
), TREE_TYPE (lvalue
),
7333 cp_stabilize_reference (TREE_OPERAND (lvalue
, 0)),
7334 TREE_OPERAND (lvalue
, 1));
7335 return build2 (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (lvalue
, 0)),
7336 lvalue
, TREE_OPERAND (lvalue
, 0));
7339 /* Apply unary lvalue-demanding operator CODE to the expression ARG
7340 for certain kinds of expressions which are not really lvalues
7341 but which we can accept as lvalues.
7343 If ARG is not a kind of expression we can handle, return
7347 unary_complex_lvalue (enum tree_code code
, tree arg
)
7349 /* Inside a template, making these kinds of adjustments is
7350 pointless; we are only concerned with the type of the
7352 if (processing_template_decl
)
7355 /* Handle (a, b) used as an "lvalue". */
7356 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
7358 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), false,
7359 tf_warning_or_error
);
7360 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7361 TREE_OPERAND (arg
, 0), real_result
);
7364 /* Handle (a ? b : c) used as an "lvalue". */
7365 if (TREE_CODE (arg
) == COND_EXPR
7366 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
7367 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
7369 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
7370 if (TREE_CODE (arg
) == MODIFY_EXPR
7371 || TREE_CODE (arg
) == PREINCREMENT_EXPR
7372 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
7373 return unary_complex_lvalue (code
, genericize_compound_lvalue (arg
));
7375 if (code
!= ADDR_EXPR
)
7378 /* Handle (a = b) used as an "lvalue" for `&'. */
7379 if (TREE_CODE (arg
) == MODIFY_EXPR
7380 || TREE_CODE (arg
) == INIT_EXPR
)
7382 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), false,
7383 tf_warning_or_error
);
7384 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7386 suppress_warning (arg
/* What warning? */);
7390 if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (arg
))
7391 || TREE_CODE (arg
) == OFFSET_REF
)
7394 /* We permit compiler to make function calls returning
7395 objects of aggregate type look like lvalues. */
7399 if (TREE_CODE (targ
) == SAVE_EXPR
)
7400 targ
= TREE_OPERAND (targ
, 0);
7402 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
7404 if (TREE_CODE (arg
) == SAVE_EXPR
)
7407 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, tf_warning_or_error
);
7408 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
7411 if (TREE_CODE (arg
) == SAVE_EXPR
&& INDIRECT_REF_P (targ
))
7412 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
7413 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
7416 /* Don't let anything else be handled specially. */
7420 /* Mark EXP saying that we need to be able to take the
7421 address of it; it should not be allocated in a register.
7422 Value is true if successful. ARRAY_REF_P is true if this
7423 is for ARRAY_REF construction - in that case we don't want
7424 to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
7425 it is fine to use ARRAY_REFs for vector subscripts on vector
7428 C++: we do not allow `current_class_ptr' to be addressable. */
7431 cxx_mark_addressable (tree exp
, bool array_ref_p
)
7436 switch (TREE_CODE (x
))
7438 case VIEW_CONVERT_EXPR
:
7440 && TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7441 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x
, 0))))
7443 x
= TREE_OPERAND (x
, 0);
7448 error ("attempt to take address of bit-field");
7454 x
= TREE_OPERAND (x
, 0);
7458 if (x
== current_class_ptr
)
7460 error ("cannot take the address of %<this%>, which is an rvalue expression");
7461 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
7467 /* Caller should not be trying to mark initialized
7468 constant fields addressable. */
7469 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
7470 || DECL_IN_AGGR_P (x
) == 0
7472 || DECL_EXTERNAL (x
));
7476 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
7477 && !DECL_ARTIFICIAL (x
))
7479 if (VAR_P (x
) && DECL_HARD_REGISTER (x
))
7482 ("address of explicit register variable %qD requested", x
);
7485 else if (extra_warnings
)
7487 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
7489 TREE_ADDRESSABLE (x
) = 1;
7494 TREE_ADDRESSABLE (x
) = 1;
7498 TREE_ADDRESSABLE (x
) = 1;
7502 TREE_ADDRESSABLE (x
) = 1;
7503 cxx_mark_addressable (TREE_OPERAND (x
, 0));
7511 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
7514 build_x_conditional_expr (location_t loc
, tree ifexp
, tree op1
, tree op2
,
7515 tsubst_flags_t complain
)
7517 tree orig_ifexp
= ifexp
;
7518 tree orig_op1
= op1
;
7519 tree orig_op2
= op2
;
7522 if (processing_template_decl
)
7524 /* The standard says that the expression is type-dependent if
7525 IFEXP is type-dependent, even though the eventual type of the
7526 expression doesn't dependent on IFEXP. */
7527 if (type_dependent_expression_p (ifexp
)
7528 /* As a GNU extension, the middle operand may be omitted. */
7529 || (op1
&& type_dependent_expression_p (op1
))
7530 || type_dependent_expression_p (op2
))
7531 return build_min_nt_loc (loc
, COND_EXPR
, ifexp
, op1
, op2
);
7532 ifexp
= build_non_dependent_expr (ifexp
);
7534 op1
= build_non_dependent_expr (op1
);
7535 op2
= build_non_dependent_expr (op2
);
7538 expr
= build_conditional_expr (loc
, ifexp
, op1
, op2
, complain
);
7539 if (processing_template_decl
&& expr
!= error_mark_node
)
7541 tree min
= build_min_non_dep (COND_EXPR
, expr
,
7542 orig_ifexp
, orig_op1
, orig_op2
);
7543 expr
= convert_from_reference (min
);
7548 /* Given a list of expressions, return a compound expression
7549 that performs them all and returns the value of the last of them. */
7552 build_x_compound_expr_from_list (tree list
, expr_list_kind exp
,
7553 tsubst_flags_t complain
)
7555 tree expr
= TREE_VALUE (list
);
7557 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7558 && !CONSTRUCTOR_IS_DIRECT_INIT (expr
))
7560 if (complain
& tf_error
)
7561 pedwarn (cp_expr_loc_or_input_loc (expr
), 0,
7562 "list-initializer for non-class type must not "
7563 "be parenthesized");
7565 return error_mark_node
;
7568 if (TREE_CHAIN (list
))
7570 if (complain
& tf_error
)
7574 permerror (input_location
, "expression list treated as compound "
7575 "expression in initializer");
7578 permerror (input_location
, "expression list treated as compound "
7579 "expression in mem-initializer");
7582 permerror (input_location
, "expression list treated as compound "
7583 "expression in functional cast");
7589 return error_mark_node
;
7591 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
7592 expr
= build_x_compound_expr (EXPR_LOCATION (TREE_VALUE (list
)),
7593 expr
, TREE_VALUE (list
), NULL_TREE
,
7600 /* Like build_x_compound_expr_from_list, but using a VEC. */
7603 build_x_compound_expr_from_vec (vec
<tree
, va_gc
> *vec
, const char *msg
,
7604 tsubst_flags_t complain
)
7606 if (vec_safe_is_empty (vec
))
7608 else if (vec
->length () == 1)
7618 if (complain
& tf_error
)
7619 permerror (input_location
,
7620 "%s expression list treated as compound expression",
7623 return error_mark_node
;
7627 for (ix
= 1; vec
->iterate (ix
, &t
); ++ix
)
7628 expr
= build_x_compound_expr (EXPR_LOCATION (t
), expr
,
7629 t
, NULL_TREE
, complain
);
7635 /* Handle overloading of the ',' operator when needed. */
7638 build_x_compound_expr (location_t loc
, tree op1
, tree op2
,
7639 tree lookups
, tsubst_flags_t complain
)
7642 tree orig_op1
= op1
;
7643 tree orig_op2
= op2
;
7644 tree overload
= NULL_TREE
;
7646 if (processing_template_decl
)
7648 if (type_dependent_expression_p (op1
)
7649 || type_dependent_expression_p (op2
))
7651 result
= build_min_nt_loc (loc
, COMPOUND_EXPR
, op1
, op2
);
7653 = build_dependent_operator_type (lookups
, COMPOUND_EXPR
, false);
7656 op1
= build_non_dependent_expr (op1
);
7657 op2
= build_non_dependent_expr (op2
);
7660 result
= build_new_op (loc
, COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
,
7661 NULL_TREE
, lookups
, &overload
, complain
);
7663 result
= cp_build_compound_expr (op1
, op2
, complain
);
7665 if (processing_template_decl
&& result
!= error_mark_node
)
7667 if (overload
!= NULL_TREE
)
7668 return (build_min_non_dep_op_overload
7669 (COMPOUND_EXPR
, result
, overload
, orig_op1
, orig_op2
));
7671 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
7677 /* Like cp_build_compound_expr, but for the c-common bits. */
7680 build_compound_expr (location_t
/*loc*/, tree lhs
, tree rhs
)
7682 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
7685 /* Build a compound expression. */
7688 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
7690 lhs
= convert_to_void (lhs
, ICV_LEFT_OF_COMMA
, complain
);
7692 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
7693 return error_mark_node
;
7695 if (TREE_CODE (rhs
) == TARGET_EXPR
)
7697 /* If the rhs is a TARGET_EXPR, then build the compound
7698 expression inside the target_expr's initializer. This
7699 helps the compiler to eliminate unnecessary temporaries. */
7700 tree init
= TREE_OPERAND (rhs
, 1);
7702 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
7703 TREE_OPERAND (rhs
, 1) = init
;
7708 if (type_unknown_p (rhs
))
7710 if (complain
& tf_error
)
7711 error_at (cp_expr_loc_or_input_loc (rhs
),
7712 "no context to resolve type of %qE", rhs
);
7713 return error_mark_node
;
7716 return build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
7719 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
7720 casts away constness. CAST gives the type of cast. Returns true
7721 if the cast is ill-formed, false if it is well-formed.
7723 ??? This function warns for casting away any qualifier not just
7724 const. We would like to specify exactly what qualifiers are casted
7729 check_for_casting_away_constness (location_t loc
, tree src_type
,
7730 tree dest_type
, enum tree_code cast
,
7731 tsubst_flags_t complain
)
7733 /* C-style casts are allowed to cast away constness. With
7734 WARN_CAST_QUAL, we still want to issue a warning. */
7735 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
7738 if (!casts_away_constness (src_type
, dest_type
, complain
))
7744 if (complain
& tf_warning
)
7745 warning_at (loc
, OPT_Wcast_qual
,
7746 "cast from type %qT to type %qT casts away qualifiers",
7747 src_type
, dest_type
);
7750 case STATIC_CAST_EXPR
:
7751 if (complain
& tf_error
)
7752 error_at (loc
, "%<static_cast%> from type %qT to type %qT casts "
7754 src_type
, dest_type
);
7757 case REINTERPRET_CAST_EXPR
:
7758 if (complain
& tf_error
)
7759 error_at (loc
, "%<reinterpret_cast%> from type %qT to type %qT "
7760 "casts away qualifiers",
7761 src_type
, dest_type
);
7769 /* Warns if the cast from expression EXPR to type TYPE is useless. */
7771 maybe_warn_about_useless_cast (location_t loc
, tree type
, tree expr
,
7772 tsubst_flags_t complain
)
7774 if (warn_useless_cast
7775 && complain
& tf_warning
)
7777 if ((TYPE_REF_P (type
)
7778 && (TYPE_REF_IS_RVALUE (type
)
7779 ? xvalue_p (expr
) : lvalue_p (expr
))
7780 && same_type_p (TREE_TYPE (expr
), TREE_TYPE (type
)))
7781 || same_type_p (TREE_TYPE (expr
), type
))
7782 warning_at (loc
, OPT_Wuseless_cast
,
7783 "useless cast to type %q#T", type
);
7787 /* Warns if the cast ignores cv-qualifiers on TYPE. */
7789 maybe_warn_about_cast_ignoring_quals (location_t loc
, tree type
,
7790 tsubst_flags_t complain
)
7792 if (warn_ignored_qualifiers
7793 && complain
& tf_warning
7794 && !CLASS_TYPE_P (type
)
7795 && (cp_type_quals (type
) & (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)))
7796 warning_at (loc
, OPT_Wignored_qualifiers
,
7797 "type qualifiers ignored on cast result type");
7800 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
7801 (another pointer-to-member type in the same hierarchy) and return
7802 the converted expression. If ALLOW_INVERSE_P is permitted, a
7803 pointer-to-derived may be converted to pointer-to-base; otherwise,
7804 only the other direction is permitted. If C_CAST_P is true, this
7805 conversion is taking place as part of a C-style cast. */
7808 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
7809 bool c_cast_p
, tsubst_flags_t complain
)
7811 if (same_type_p (type
, TREE_TYPE (expr
)))
7814 if (TYPE_PTRDATAMEM_P (type
))
7816 tree obase
= TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
));
7817 tree nbase
= TYPE_PTRMEM_CLASS_TYPE (type
);
7818 tree delta
= (get_delta_difference
7820 allow_inverse_p
, c_cast_p
, complain
));
7822 if (delta
== error_mark_node
)
7823 return error_mark_node
;
7825 if (!same_type_p (obase
, nbase
))
7827 if (TREE_CODE (expr
) == PTRMEM_CST
)
7828 expr
= cplus_expand_constant (expr
);
7830 tree cond
= cp_build_binary_op (input_location
, EQ_EXPR
, expr
,
7831 build_int_cst (TREE_TYPE (expr
), -1),
7833 tree op1
= build_nop (ptrdiff_type_node
, expr
);
7834 tree op2
= cp_build_binary_op (input_location
, PLUS_EXPR
, op1
, delta
,
7837 expr
= fold_build3_loc (input_location
,
7838 COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
7841 return build_nop (type
, expr
);
7844 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
7845 allow_inverse_p
, c_cast_p
, complain
);
7848 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
7849 this static_cast is being attempted as one of the possible casts
7850 allowed by a C-style cast. (In that case, accessibility of base
7851 classes is not considered, and it is OK to cast away
7852 constness.) Return the result of the cast. *VALID_P is set to
7853 indicate whether or not the cast was valid. */
7856 build_static_cast_1 (location_t loc
, tree type
, tree expr
, bool c_cast_p
,
7857 bool *valid_p
, tsubst_flags_t complain
)
7863 /* Assume the cast is valid. */
7866 intype
= unlowered_expr_type (expr
);
7868 /* Save casted types in the function's used types hash table. */
7869 used_types_insert (type
);
7871 /* A prvalue of non-class type is cv-unqualified. */
7872 if (!CLASS_TYPE_P (type
))
7873 type
= cv_unqualified (type
);
7875 /* [expr.static.cast]
7877 An lvalue of type "cv1 B", where B is a class type, can be cast
7878 to type "reference to cv2 D", where D is a class derived (clause
7879 _class.derived_) from B, if a valid standard conversion from
7880 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
7881 same cv-qualification as, or greater cv-qualification than, cv1,
7882 and B is not a virtual base class of D. */
7883 /* We check this case before checking the validity of "TYPE t =
7884 EXPR;" below because for this case:
7887 struct D : public B { D(const B&); };
7889 void f() { static_cast<const D&>(b); }
7891 we want to avoid constructing a new D. The standard is not
7892 completely clear about this issue, but our interpretation is
7893 consistent with other compilers. */
7894 if (TYPE_REF_P (type
)
7895 && CLASS_TYPE_P (TREE_TYPE (type
))
7896 && CLASS_TYPE_P (intype
)
7897 && (TYPE_REF_IS_RVALUE (type
) || lvalue_p (expr
))
7898 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
7899 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
7900 build_pointer_type (TYPE_MAIN_VARIANT
7901 (TREE_TYPE (type
))),
7904 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
7908 if (processing_template_decl
)
7911 /* There is a standard conversion from "D*" to "B*" even if "B"
7912 is ambiguous or inaccessible. If this is really a
7913 static_cast, then we check both for inaccessibility and
7914 ambiguity. However, if this is a static_cast being performed
7915 because the user wrote a C-style cast, then accessibility is
7917 base
= lookup_base (TREE_TYPE (type
), intype
,
7918 c_cast_p
? ba_unique
: ba_check
,
7920 expr
= cp_build_addr_expr (expr
, complain
);
7922 if (sanitize_flags_p (SANITIZE_VPTR
))
7925 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
7931 /* Convert from "B*" to "D*". This function will check that "B"
7932 is not a virtual base of "D". Even if we don't have a guarantee
7933 that expr is NULL, if the static_cast is to a reference type,
7934 it is UB if it would be NULL, so omit the non-NULL check. */
7935 expr
= build_base_path (MINUS_EXPR
, expr
, base
,
7936 /*nonnull=*/flag_delete_null_pointer_checks
,
7939 /* Convert the pointer to a reference -- but then remember that
7940 there are no expressions with reference type in C++.
7942 We call rvalue so that there's an actual tree code
7943 (NON_LVALUE_EXPR) for the static_cast; otherwise, if the operand
7944 is a variable with the same type, the conversion would get folded
7945 away, leaving just the variable and causing lvalue_kind to give
7946 the wrong answer. */
7947 expr
= cp_fold_convert (type
, expr
);
7949 /* When -fsanitize=null, make sure to diagnose reference binding to
7950 NULL even when the reference is converted to pointer later on. */
7951 if (sanitize_flags_p (SANITIZE_NULL
)
7952 && TREE_CODE (expr
) == COND_EXPR
7953 && TREE_OPERAND (expr
, 2)
7954 && TREE_CODE (TREE_OPERAND (expr
, 2)) == INTEGER_CST
7955 && TREE_TYPE (TREE_OPERAND (expr
, 2)) == type
)
7956 ubsan_maybe_instrument_reference (&TREE_OPERAND (expr
, 2));
7958 return convert_from_reference (rvalue (expr
));
7961 /* "A glvalue of type cv1 T1 can be cast to type rvalue reference to
7962 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
7963 if (TYPE_REF_P (type
)
7964 && TYPE_REF_IS_RVALUE (type
)
7965 && (clk
= real_lvalue_p (expr
))
7966 && reference_compatible_p (TREE_TYPE (type
), intype
)
7967 && (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
7969 if (processing_template_decl
)
7971 if (clk
== clk_ordinary
)
7973 /* Handle the (non-bit-field) lvalue case here by casting to
7974 lvalue reference and then changing it to an rvalue reference.
7975 Casting an xvalue to rvalue reference will be handled by the
7977 tree lref
= cp_build_reference_type (TREE_TYPE (type
), false);
7978 result
= (perform_direct_initialization_if_possible
7979 (lref
, expr
, c_cast_p
, complain
));
7980 result
= build1 (NON_LVALUE_EXPR
, type
, result
);
7981 return convert_from_reference (result
);
7984 /* For a bit-field or packed field, bind to a temporary. */
7985 expr
= rvalue (expr
);
7988 /* Resolve overloaded address here rather than once in
7989 implicit_conversion and again in the inverse code below. */
7990 if (TYPE_PTRMEMFUNC_P (type
) && type_unknown_p (expr
))
7992 expr
= instantiate_type (type
, expr
, complain
);
7993 intype
= TREE_TYPE (expr
);
7996 /* [expr.static.cast]
7998 Any expression can be explicitly converted to type cv void. */
7999 if (VOID_TYPE_P (type
))
8000 return convert_to_void (expr
, ICV_CAST
, complain
);
8003 An abstract class shall not be used ... as the type of an explicit
8005 if (abstract_virtuals_error_sfinae (ACU_CAST
, type
, complain
))
8006 return error_mark_node
;
8008 /* [expr.static.cast]
8010 An expression e can be explicitly converted to a type T using a
8011 static_cast of the form static_cast<T>(e) if the declaration T
8012 t(e);" is well-formed, for some invented temporary variable
8014 result
= perform_direct_initialization_if_possible (type
, expr
,
8015 c_cast_p
, complain
);
8016 /* P1975 allows static_cast<Aggr>(42), as well as static_cast<T[5]>(42),
8017 which initialize the first element of the aggregate. We need to handle
8018 the array case specifically. */
8019 if (result
== NULL_TREE
8020 && cxx_dialect
>= cxx20
8021 && TREE_CODE (type
) == ARRAY_TYPE
)
8023 /* Create { EXPR } and perform direct-initialization from it. */
8024 tree e
= build_constructor_single (init_list_type_node
, NULL_TREE
, expr
);
8025 CONSTRUCTOR_IS_DIRECT_INIT (e
) = true;
8026 CONSTRUCTOR_IS_PAREN_INIT (e
) = true;
8027 result
= perform_direct_initialization_if_possible (type
, e
, c_cast_p
,
8032 if (processing_template_decl
)
8035 result
= convert_from_reference (result
);
8037 /* [expr.static.cast]
8039 If T is a reference type, the result is an lvalue; otherwise,
8040 the result is an rvalue. */
8041 if (!TYPE_REF_P (type
))
8043 result
= rvalue (result
);
8045 if (result
== expr
&& SCALAR_TYPE_P (type
))
8046 /* Leave some record of the cast. */
8047 result
= build_nop (type
, expr
);
8052 /* [expr.static.cast]
8054 The inverse of any standard conversion sequence (clause _conv_),
8055 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
8056 (_conv.array_), function-to-pointer (_conv.func_), and boolean
8057 (_conv.bool_) conversions, can be performed explicitly using
8058 static_cast subject to the restriction that the explicit
8059 conversion does not cast away constness (_expr.const.cast_), and
8060 the following additional rules for specific cases: */
8061 /* For reference, the conversions not excluded are: integral
8062 promotions, floating-point promotion, integral conversions,
8063 floating-point conversions, floating-integral conversions,
8064 pointer conversions, and pointer to member conversions. */
8067 A value of integral _or enumeration_ type can be explicitly
8068 converted to an enumeration type. */
8069 /* The effect of all that is that any conversion between any two
8070 types which are integral, floating, or enumeration types can be
8072 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8073 || SCALAR_FLOAT_TYPE_P (type
))
8074 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
8075 || SCALAR_FLOAT_TYPE_P (intype
)))
8077 if (processing_template_decl
)
8079 return ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
, complain
);
8082 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
8083 && CLASS_TYPE_P (TREE_TYPE (type
))
8084 && CLASS_TYPE_P (TREE_TYPE (intype
))
8085 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
8086 (TREE_TYPE (intype
))),
8087 build_pointer_type (TYPE_MAIN_VARIANT
8088 (TREE_TYPE (type
))),
8093 if (processing_template_decl
)
8097 && check_for_casting_away_constness (loc
, intype
, type
,
8100 return error_mark_node
;
8101 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
8102 c_cast_p
? ba_unique
: ba_check
,
8104 expr
= build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false,
8107 if (sanitize_flags_p (SANITIZE_VPTR
))
8110 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
8116 return cp_fold_convert (type
, expr
);
8119 if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8120 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
8127 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
8128 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
8130 if (TYPE_PTRDATAMEM_P (type
))
8132 t1
= (build_ptrmem_type
8134 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
8135 t2
= (build_ptrmem_type
8137 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
8144 if (can_convert (t1
, t2
, complain
) || can_convert (t2
, t1
, complain
))
8147 && check_for_casting_away_constness (loc
, intype
, type
,
8150 return error_mark_node
;
8151 if (processing_template_decl
)
8153 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
8154 c_cast_p
, complain
);
8158 /* [expr.static.cast]
8160 An rvalue of type "pointer to cv void" can be explicitly
8161 converted to a pointer to object type. A value of type pointer
8162 to object converted to "pointer to cv void" and back to the
8163 original pointer type will have its original value. */
8164 if (TYPE_PTR_P (intype
)
8165 && VOID_TYPE_P (TREE_TYPE (intype
))
8166 && TYPE_PTROB_P (type
))
8169 && check_for_casting_away_constness (loc
, intype
, type
,
8172 return error_mark_node
;
8173 if (processing_template_decl
)
8175 return build_nop (type
, expr
);
8179 return error_mark_node
;
8182 /* Return an expression representing static_cast<TYPE>(EXPR). */
8185 build_static_cast (location_t loc
, tree type
, tree oexpr
,
8186 tsubst_flags_t complain
)
8192 if (type
== error_mark_node
|| expr
== error_mark_node
)
8193 return error_mark_node
;
8195 bool dependent
= (dependent_type_p (type
)
8196 || type_dependent_expression_p (expr
));
8200 expr
= build_min (STATIC_CAST_EXPR
, type
, oexpr
);
8201 /* We don't know if it will or will not have side effects. */
8202 TREE_SIDE_EFFECTS (expr
) = 1;
8203 result
= convert_from_reference (expr
);
8204 protected_set_expr_location (result
, loc
);
8207 else if (processing_template_decl
)
8208 expr
= build_non_dependent_expr (expr
);
8210 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8211 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8212 if (!TYPE_REF_P (type
)
8213 && TREE_CODE (expr
) == NOP_EXPR
8214 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8215 expr
= TREE_OPERAND (expr
, 0);
8217 result
= build_static_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8218 &valid_p
, complain
);
8221 if (result
!= error_mark_node
)
8223 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8224 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8226 if (processing_template_decl
)
8228 protected_set_expr_location (result
, loc
);
8232 if (complain
& tf_error
)
8234 error_at (loc
, "invalid %<static_cast%> from type %qT to type %qT",
8235 TREE_TYPE (expr
), type
);
8236 if ((TYPE_PTR_P (type
) || TYPE_REF_P (type
))
8237 && CLASS_TYPE_P (TREE_TYPE (type
))
8238 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
8239 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (TREE_TYPE (type
))),
8240 "class type %qT is incomplete", TREE_TYPE (type
));
8241 tree expr_type
= TREE_TYPE (expr
);
8242 if (TYPE_PTR_P (expr_type
))
8243 expr_type
= TREE_TYPE (expr_type
);
8244 if (CLASS_TYPE_P (expr_type
) && !COMPLETE_TYPE_P (expr_type
))
8245 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (expr_type
)),
8246 "class type %qT is incomplete", expr_type
);
8248 return error_mark_node
;
8251 /* EXPR is an expression with member function or pointer-to-member
8252 function type. TYPE is a pointer type. Converting EXPR to TYPE is
8253 not permitted by ISO C++, but we accept it in some modes. If we
8254 are not in one of those modes, issue a diagnostic. Return the
8255 converted expression. */
8258 convert_member_func_to_ptr (tree type
, tree expr
, tsubst_flags_t complain
)
8263 intype
= TREE_TYPE (expr
);
8264 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
8265 || TREE_CODE (intype
) == METHOD_TYPE
);
8267 if (!(complain
& tf_warning_or_error
))
8268 return error_mark_node
;
8270 location_t loc
= cp_expr_loc_or_input_loc (expr
);
8272 if (pedantic
|| warn_pmf2ptr
)
8273 pedwarn (loc
, pedantic
? OPT_Wpedantic
: OPT_Wpmf_conversions
,
8274 "converting from %qH to %qI", intype
, type
);
8276 STRIP_ANY_LOCATION_WRAPPER (expr
);
8278 if (TREE_CODE (intype
) == METHOD_TYPE
)
8279 expr
= build_addr_func (expr
, complain
);
8280 else if (TREE_CODE (expr
) == PTRMEM_CST
)
8281 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
8284 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
8285 decl
= build_address (decl
);
8286 expr
= get_member_function_from_ptrfunc (&decl
, expr
, complain
);
8289 if (expr
== error_mark_node
)
8290 return error_mark_node
;
8292 expr
= build_nop (type
, expr
);
8293 SET_EXPR_LOCATION (expr
, loc
);
8297 /* Build a NOP_EXPR to TYPE, but mark it as a reinterpret_cast so that
8298 constexpr evaluation knows to reject it. */
8301 build_nop_reinterpret (tree type
, tree expr
)
8303 tree ret
= build_nop (type
, expr
);
8305 REINTERPRET_CAST_P (ret
) = true;
8309 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
8310 If C_CAST_P is true, this reinterpret cast is being done as part of
8311 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
8312 indicate whether or not reinterpret_cast was valid. */
8315 build_reinterpret_cast_1 (location_t loc
, tree type
, tree expr
,
8316 bool c_cast_p
, bool *valid_p
,
8317 tsubst_flags_t complain
)
8321 /* Assume the cast is invalid. */
8325 if (type
== error_mark_node
|| error_operand_p (expr
))
8326 return error_mark_node
;
8328 intype
= TREE_TYPE (expr
);
8330 /* Save casted types in the function's used types hash table. */
8331 used_types_insert (type
);
8333 /* A prvalue of non-class type is cv-unqualified. */
8334 if (!CLASS_TYPE_P (type
))
8335 type
= cv_unqualified (type
);
8337 /* [expr.reinterpret.cast]
8338 A glvalue of type T1, designating an object x, can be cast to the type
8339 "reference to T2" if an expression of type "pointer to T1" can be
8340 explicitly converted to the type "pointer to T2" using a reinterpret_cast.
8341 The result is that of *reinterpret_cast<T2 *>(p) where p is a pointer to x
8342 of type "pointer to T1". No temporary is created, no copy is made, and no
8343 constructors (11.4.4) or conversion functions (11.4.7) are called. */
8344 if (TYPE_REF_P (type
))
8346 if (!glvalue_p (expr
))
8348 if (complain
& tf_error
)
8349 error_at (loc
, "invalid cast of a prvalue expression of type "
8352 return error_mark_node
;
8355 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
8356 "B" are related class types; the reinterpret_cast does not
8357 adjust the pointer. */
8358 if (TYPE_PTR_P (intype
)
8359 && (complain
& tf_warning
)
8360 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
8361 COMPARE_BASE
| COMPARE_DERIVED
)))
8362 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
8365 expr
= cp_build_addr_expr (expr
, complain
);
8367 if (warn_strict_aliasing
> 2)
8368 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8370 if (expr
!= error_mark_node
)
8371 expr
= build_reinterpret_cast_1
8372 (loc
, build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
8374 if (expr
!= error_mark_node
)
8375 /* cp_build_indirect_ref isn't right for rvalue refs. */
8376 expr
= convert_from_reference (fold_convert (type
, expr
));
8380 /* As a G++ extension, we consider conversions from member
8381 functions, and pointers to member functions to
8382 pointer-to-function and pointer-to-void types. If
8383 -Wno-pmf-conversions has not been specified,
8384 convert_member_func_to_ptr will issue an error message. */
8385 if ((TYPE_PTRMEMFUNC_P (intype
)
8386 || TREE_CODE (intype
) == METHOD_TYPE
)
8387 && TYPE_PTR_P (type
)
8388 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
8389 || VOID_TYPE_P (TREE_TYPE (type
))))
8390 return convert_member_func_to_ptr (type
, expr
, complain
);
8392 /* If the cast is not to a reference type, the lvalue-to-rvalue,
8393 array-to-pointer, and function-to-pointer conversions are
8395 expr
= decay_conversion (expr
, complain
);
8397 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8398 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8399 if (TREE_CODE (expr
) == NOP_EXPR
8400 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8401 expr
= TREE_OPERAND (expr
, 0);
8403 if (error_operand_p (expr
))
8404 return error_mark_node
;
8406 intype
= TREE_TYPE (expr
);
8408 /* [expr.reinterpret.cast]
8409 A pointer can be converted to any integral type large enough to
8410 hold it. ... A value of type std::nullptr_t can be converted to
8411 an integral type; the conversion has the same meaning and
8412 validity as a conversion of (void*)0 to the integral type. */
8413 if (CP_INTEGRAL_TYPE_P (type
)
8414 && (TYPE_PTR_P (intype
) || NULLPTR_TYPE_P (intype
)))
8416 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
8418 if (complain
& tf_error
)
8419 permerror (loc
, "cast from %qH to %qI loses precision",
8422 return error_mark_node
;
8424 if (NULLPTR_TYPE_P (intype
))
8425 return build_int_cst (type
, 0);
8427 /* [expr.reinterpret.cast]
8428 A value of integral or enumeration type can be explicitly
8429 converted to a pointer. */
8430 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
8433 else if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8434 || TYPE_PTR_OR_PTRMEM_P (type
))
8435 && same_type_p (type
, intype
))
8437 return rvalue (expr
);
8438 else if (TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
8440 if ((complain
& tf_warning
)
8441 && !cxx_safe_function_type_cast_p (TREE_TYPE (type
),
8442 TREE_TYPE (intype
)))
8443 warning_at (loc
, OPT_Wcast_function_type
,
8444 "cast between incompatible function types"
8445 " from %qH to %qI", intype
, type
);
8446 return build_nop_reinterpret (type
, expr
);
8448 else if (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
))
8450 if ((complain
& tf_warning
)
8451 && !cxx_safe_function_type_cast_p
8452 (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (type
)),
8453 TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (intype
))))
8454 warning_at (loc
, OPT_Wcast_function_type
,
8455 "cast between incompatible pointer to member types"
8456 " from %qH to %qI", intype
, type
);
8457 return build_nop_reinterpret (type
, expr
);
8459 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8460 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
8463 && check_for_casting_away_constness (loc
, intype
, type
,
8464 REINTERPRET_CAST_EXPR
,
8466 return error_mark_node
;
8467 /* Warn about possible alignment problems. */
8468 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
8469 && (complain
& tf_warning
)
8470 && !VOID_TYPE_P (type
)
8471 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
8472 && COMPLETE_TYPE_P (TREE_TYPE (type
))
8473 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
8474 && min_align_of_type (TREE_TYPE (type
))
8475 > min_align_of_type (TREE_TYPE (intype
)))
8476 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
8477 "increases required alignment of target type",
8480 if (warn_strict_aliasing
<= 2)
8481 /* strict_aliasing_warning STRIP_NOPs its expr. */
8482 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8484 return build_nop_reinterpret (type
, expr
);
8486 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
8487 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
8489 if (complain
& tf_warning
)
8490 /* C++11 5.2.10 p8 says that "Converting a function pointer to an
8491 object pointer type or vice versa is conditionally-supported." */
8492 warning_at (loc
, OPT_Wconditionally_supported
,
8493 "casting between pointer-to-function and "
8494 "pointer-to-object is conditionally-supported");
8495 return build_nop_reinterpret (type
, expr
);
8497 else if (gnu_vector_type_p (type
) && scalarish_type_p (intype
))
8498 return convert_to_vector (type
, rvalue (expr
));
8499 else if (gnu_vector_type_p (intype
)
8500 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8501 return convert_to_integer_nofold (type
, expr
);
8506 if (complain
& tf_error
)
8507 error_at (loc
, "invalid cast from type %qT to type %qT",
8509 return error_mark_node
;
8512 expr
= cp_convert (type
, expr
, complain
);
8513 if (TREE_CODE (expr
) == NOP_EXPR
)
8514 /* Mark any nop_expr that created as a reintepret_cast. */
8515 REINTERPRET_CAST_P (expr
) = true;
8520 build_reinterpret_cast (location_t loc
, tree type
, tree expr
,
8521 tsubst_flags_t complain
)
8525 if (type
== error_mark_node
|| expr
== error_mark_node
)
8526 return error_mark_node
;
8528 if (processing_template_decl
)
8530 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
8532 if (!TREE_SIDE_EFFECTS (t
)
8533 && type_dependent_expression_p (expr
))
8534 /* There might turn out to be side effects inside expr. */
8535 TREE_SIDE_EFFECTS (t
) = 1;
8536 r
= convert_from_reference (t
);
8537 protected_set_expr_location (r
, loc
);
8541 r
= build_reinterpret_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8542 /*valid_p=*/NULL
, complain
);
8543 if (r
!= error_mark_node
)
8545 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8546 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8548 protected_set_expr_location (r
, loc
);
8552 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
8553 return an appropriate expression. Otherwise, return
8554 error_mark_node. If the cast is not valid, and COMPLAIN is true,
8555 then a diagnostic will be issued. If VALID_P is non-NULL, we are
8556 performing a C-style cast, its value upon return will indicate
8557 whether or not the conversion succeeded. */
8560 build_const_cast_1 (location_t loc
, tree dst_type
, tree expr
,
8561 tsubst_flags_t complain
, bool *valid_p
)
8564 tree reference_type
;
8566 /* Callers are responsible for handling error_mark_node as a
8567 destination type. */
8568 gcc_assert (dst_type
!= error_mark_node
);
8569 /* In a template, callers should be building syntactic
8570 representations of casts, not using this machinery. */
8571 gcc_assert (!processing_template_decl
);
8573 /* Assume the conversion is invalid. */
8577 if (!INDIRECT_TYPE_P (dst_type
) && !TYPE_PTRDATAMEM_P (dst_type
))
8579 if (complain
& tf_error
)
8580 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8581 "which is not a pointer, reference, "
8582 "nor a pointer-to-data-member type", dst_type
);
8583 return error_mark_node
;
8586 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
8588 if (complain
& tf_error
)
8589 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8590 "which is a pointer or reference to a function type",
8592 return error_mark_node
;
8595 /* A prvalue of non-class type is cv-unqualified. */
8596 dst_type
= cv_unqualified (dst_type
);
8598 /* Save casted types in the function's used types hash table. */
8599 used_types_insert (dst_type
);
8601 src_type
= TREE_TYPE (expr
);
8602 /* Expressions do not really have reference types. */
8603 if (TYPE_REF_P (src_type
))
8604 src_type
= TREE_TYPE (src_type
);
8606 /* [expr.const.cast]
8608 For two object types T1 and T2, if a pointer to T1 can be explicitly
8609 converted to the type "pointer to T2" using a const_cast, then the
8610 following conversions can also be made:
8612 -- an lvalue of type T1 can be explicitly converted to an lvalue of
8613 type T2 using the cast const_cast<T2&>;
8615 -- a glvalue of type T1 can be explicitly converted to an xvalue of
8616 type T2 using the cast const_cast<T2&&>; and
8618 -- if T1 is a class type, a prvalue of type T1 can be explicitly
8619 converted to an xvalue of type T2 using the cast const_cast<T2&&>. */
8621 if (TYPE_REF_P (dst_type
))
8623 reference_type
= dst_type
;
8624 if (!TYPE_REF_IS_RVALUE (dst_type
)
8630 if (complain
& tf_error
)
8631 error_at (loc
, "invalid %<const_cast%> of an rvalue of type %qT "
8633 src_type
, dst_type
);
8634 return error_mark_node
;
8636 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
8637 src_type
= build_pointer_type (src_type
);
8641 reference_type
= NULL_TREE
;
8642 /* If the destination type is not a reference type, the
8643 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
8644 conversions are performed. */
8645 src_type
= type_decays_to (src_type
);
8646 if (src_type
== error_mark_node
)
8647 return error_mark_node
;
8650 if (TYPE_PTR_P (src_type
) || TYPE_PTRDATAMEM_P (src_type
))
8652 if (comp_ptr_ttypes_const (dst_type
, src_type
, bounds_none
))
8657 /* This cast is actually a C-style cast. Issue a warning if
8658 the user is making a potentially unsafe cast. */
8659 check_for_casting_away_constness (loc
, src_type
, dst_type
,
8660 CAST_EXPR
, complain
);
8661 /* ??? comp_ptr_ttypes_const ignores TYPE_ALIGN. */
8662 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
8663 && (complain
& tf_warning
)
8664 && min_align_of_type (TREE_TYPE (dst_type
))
8665 > min_align_of_type (TREE_TYPE (src_type
)))
8666 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
8667 "increases required alignment of target type",
8668 src_type
, dst_type
);
8672 expr
= cp_build_addr_expr (expr
, complain
);
8673 if (expr
== error_mark_node
)
8674 return error_mark_node
;
8675 expr
= build_nop (reference_type
, expr
);
8676 return convert_from_reference (expr
);
8680 expr
= decay_conversion (expr
, complain
);
8681 if (expr
== error_mark_node
)
8682 return error_mark_node
;
8684 /* build_c_cast puts on a NOP_EXPR to make the result not an
8685 lvalue. Strip such NOP_EXPRs if VALUE is being used in
8686 non-lvalue context. */
8687 if (TREE_CODE (expr
) == NOP_EXPR
8688 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8689 expr
= TREE_OPERAND (expr
, 0);
8690 return build_nop (dst_type
, expr
);
8694 && !at_least_as_qualified_p (TREE_TYPE (dst_type
),
8695 TREE_TYPE (src_type
)))
8696 check_for_casting_away_constness (loc
, src_type
, dst_type
,
8697 CAST_EXPR
, complain
);
8700 if (complain
& tf_error
)
8701 error_at (loc
, "invalid %<const_cast%> from type %qT to type %qT",
8702 src_type
, dst_type
);
8703 return error_mark_node
;
8707 build_const_cast (location_t loc
, tree type
, tree expr
,
8708 tsubst_flags_t complain
)
8712 if (type
== error_mark_node
|| error_operand_p (expr
))
8713 return error_mark_node
;
8715 if (processing_template_decl
)
8717 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
8719 if (!TREE_SIDE_EFFECTS (t
)
8720 && type_dependent_expression_p (expr
))
8721 /* There might turn out to be side effects inside expr. */
8722 TREE_SIDE_EFFECTS (t
) = 1;
8723 r
= convert_from_reference (t
);
8724 protected_set_expr_location (r
, loc
);
8728 r
= build_const_cast_1 (loc
, type
, expr
, complain
, /*valid_p=*/NULL
);
8729 if (r
!= error_mark_node
)
8731 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8732 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8734 protected_set_expr_location (r
, loc
);
8738 /* Like cp_build_c_cast, but for the c-common bits. */
8741 build_c_cast (location_t loc
, tree type
, tree expr
)
8743 return cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
8746 /* Like the "build_c_cast" used for c-common, but using cp_expr to
8747 preserve location information even for tree nodes that don't
8751 build_c_cast (location_t loc
, tree type
, cp_expr expr
)
8753 cp_expr result
= cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
8754 result
.set_location (loc
);
8758 /* Build an expression representing an explicit C-style cast to type
8759 TYPE of expression EXPR. */
8762 cp_build_c_cast (location_t loc
, tree type
, tree expr
,
8763 tsubst_flags_t complain
)
8769 if (type
== error_mark_node
|| error_operand_p (expr
))
8770 return error_mark_node
;
8772 if (processing_template_decl
)
8774 tree t
= build_min (CAST_EXPR
, type
,
8775 tree_cons (NULL_TREE
, value
, NULL_TREE
));
8776 /* We don't know if it will or will not have side effects. */
8777 TREE_SIDE_EFFECTS (t
) = 1;
8778 return convert_from_reference (t
);
8781 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
8782 'Class') should always be retained, because this information aids
8783 in method lookup. */
8784 if (objc_is_object_ptr (type
)
8785 && objc_is_object_ptr (TREE_TYPE (expr
)))
8786 return build_nop (type
, expr
);
8788 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8789 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8790 if (!TYPE_REF_P (type
)
8791 && TREE_CODE (value
) == NOP_EXPR
8792 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
8793 value
= TREE_OPERAND (value
, 0);
8795 if (TREE_CODE (type
) == ARRAY_TYPE
)
8797 /* Allow casting from T1* to T2[] because Cfront allows it.
8798 NIHCL uses it. It is not valid ISO C++ however. */
8799 if (TYPE_PTR_P (TREE_TYPE (expr
)))
8801 if (complain
& tf_error
)
8802 permerror (loc
, "ISO C++ forbids casting to an array type %qT",
8805 return error_mark_node
;
8806 type
= build_pointer_type (TREE_TYPE (type
));
8810 if (complain
& tf_error
)
8811 error_at (loc
, "ISO C++ forbids casting to an array type %qT",
8813 return error_mark_node
;
8817 if (FUNC_OR_METHOD_TYPE_P (type
))
8819 if (complain
& tf_error
)
8820 error_at (loc
, "invalid cast to function type %qT", type
);
8821 return error_mark_node
;
8824 if (TYPE_PTR_P (type
)
8825 && TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
8826 /* Casting to an integer of smaller size is an error detected elsewhere. */
8827 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (value
))
8828 /* Don't warn about converting any constant. */
8829 && !TREE_CONSTANT (value
))
8830 warning_at (loc
, OPT_Wint_to_pointer_cast
,
8831 "cast to pointer from integer of different size");
8833 /* A C-style cast can be a const_cast. */
8834 result
= build_const_cast_1 (loc
, type
, value
, complain
& tf_warning
,
8838 if (result
!= error_mark_node
)
8840 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
8841 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8846 /* Or a static cast. */
8847 result
= build_static_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
8848 &valid_p
, complain
);
8849 /* Or a reinterpret_cast. */
8851 result
= build_reinterpret_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
8852 &valid_p
, complain
);
8853 /* The static_cast or reinterpret_cast may be followed by a
8856 /* A valid cast may result in errors if, for example, a
8857 conversion to an ambiguous base class is required. */
8858 && !error_operand_p (result
))
8862 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
8863 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8865 /* Non-class rvalues always have cv-unqualified type. */
8866 if (!CLASS_TYPE_P (type
))
8867 type
= TYPE_MAIN_VARIANT (type
);
8868 result_type
= TREE_TYPE (result
);
8869 if (!CLASS_TYPE_P (result_type
) && !TYPE_REF_P (type
))
8870 result_type
= TYPE_MAIN_VARIANT (result_type
);
8871 /* If the type of RESULT does not match TYPE, perform a
8872 const_cast to make it match. If the static_cast or
8873 reinterpret_cast succeeded, we will differ by at most
8874 cv-qualification, so the follow-on const_cast is guaranteed
8876 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
8878 result
= build_const_cast_1 (loc
, type
, result
, false, &valid_p
);
8879 gcc_assert (valid_p
);
8884 return error_mark_node
;
8887 /* For use from the C common bits. */
8889 build_modify_expr (location_t location
,
8890 tree lhs
, tree
/*lhs_origtype*/,
8891 enum tree_code modifycode
,
8892 location_t
/*rhs_location*/, tree rhs
,
8893 tree
/*rhs_origtype*/)
8895 return cp_build_modify_expr (location
, lhs
, modifycode
, rhs
,
8896 tf_warning_or_error
);
8899 /* Build an assignment expression of lvalue LHS from value RHS.
8900 MODIFYCODE is the code for a binary operator that we use
8901 to combine the old value of LHS with RHS to get the new value.
8902 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
8904 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
8907 cp_build_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
8908 tree rhs
, tsubst_flags_t complain
)
8910 lhs
= mark_lvalue_use_nonread (lhs
);
8912 tree result
= NULL_TREE
;
8914 tree lhstype
= TREE_TYPE (lhs
);
8916 tree olhstype
= lhstype
;
8917 bool plain_assign
= (modifycode
== NOP_EXPR
);
8918 bool compound_side_effects_p
= false;
8919 tree preeval
= NULL_TREE
;
8921 /* Avoid duplicate error messages from operands that had errors. */
8922 if (error_operand_p (lhs
) || error_operand_p (rhs
))
8923 return error_mark_node
;
8925 while (TREE_CODE (lhs
) == COMPOUND_EXPR
)
8927 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
8928 compound_side_effects_p
= true;
8929 lhs
= TREE_OPERAND (lhs
, 1);
8932 /* Handle control structure constructs used as "lvalues". Note that we
8933 leave COMPOUND_EXPR on the LHS because it is sequenced after the RHS. */
8934 switch (TREE_CODE (lhs
))
8936 /* Handle --foo = 5; as these are valid constructs in C++. */
8937 case PREDECREMENT_EXPR
:
8938 case PREINCREMENT_EXPR
:
8939 if (compound_side_effects_p
)
8940 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
8941 lhs
= genericize_compound_lvalue (lhs
);
8943 /* If we had (bar, --foo) = 5; or (bar, (baz, --foo)) = 5;
8944 and looked through the COMPOUND_EXPRs, readd them now around
8945 the resulting lhs. */
8946 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
8948 lhs
= build2 (COMPOUND_EXPR
, lhstype
, TREE_OPERAND (olhs
, 0), lhs
);
8949 tree
*ptr
= &TREE_OPERAND (lhs
, 1);
8950 for (olhs
= TREE_OPERAND (olhs
, 1);
8951 TREE_CODE (olhs
) == COMPOUND_EXPR
;
8952 olhs
= TREE_OPERAND (olhs
, 1))
8954 *ptr
= build2 (COMPOUND_EXPR
, lhstype
,
8955 TREE_OPERAND (olhs
, 0), *ptr
);
8956 ptr
= &TREE_OPERAND (*ptr
, 1);
8962 if (compound_side_effects_p
)
8963 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
8964 lhs
= genericize_compound_lvalue (lhs
);
8965 goto maybe_add_compound
;
8969 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
8970 when neither operand has side-effects. */
8971 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
8972 return error_mark_node
;
8974 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
8975 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
8977 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
8978 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
8980 TREE_OPERAND (lhs
, 0),
8981 TREE_OPERAND (lhs
, 1)),
8982 TREE_OPERAND (lhs
, 0),
8983 TREE_OPERAND (lhs
, 1));
8986 /* Handle (a ? b : c) used as an "lvalue". */
8989 /* Produce (a ? (b = rhs) : (c = rhs))
8990 except that the RHS goes through a save-expr
8991 so the code to compute it is only emitted once. */
8992 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
8994 if (complain
& tf_error
)
8995 error_at (cp_expr_loc_or_loc (rhs
, loc
),
8996 "void value not ignored as it ought to be");
8997 return error_mark_node
;
9000 rhs
= stabilize_expr (rhs
, &preeval
);
9002 /* Check this here to avoid odd errors when trying to convert
9003 a throw to the type of the COND_EXPR. */
9004 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9005 return error_mark_node
;
9007 tree op1
= TREE_OPERAND (lhs
, 1);
9008 if (TREE_CODE (op1
) != THROW_EXPR
)
9009 op1
= cp_build_modify_expr (loc
, op1
, modifycode
, rhs
, complain
);
9010 /* When sanitizing undefined behavior, even when rhs doesn't need
9011 stabilization at this point, the sanitization might add extra
9012 SAVE_EXPRs in there and so make sure there is no tree sharing
9013 in the rhs, otherwise those SAVE_EXPRs will have initialization
9014 only in one of the two branches. */
9015 if (sanitize_flags_p (SANITIZE_UNDEFINED
9016 | SANITIZE_UNDEFINED_NONDEFAULT
))
9017 rhs
= unshare_expr (rhs
);
9018 tree op2
= TREE_OPERAND (lhs
, 2);
9019 if (TREE_CODE (op2
) != THROW_EXPR
)
9020 op2
= cp_build_modify_expr (loc
, op2
, modifycode
, rhs
, complain
);
9021 tree cond
= build_conditional_expr (input_location
,
9022 TREE_OPERAND (lhs
, 0), op1
, op2
,
9025 if (cond
== error_mark_node
)
9027 /* If we had (e, (a ? b : c)) = d; or (e, (f, (a ? b : c))) = d;
9028 and looked through the COMPOUND_EXPRs, readd them now around
9029 the resulting cond before adding the preevaluated rhs. */
9030 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
9032 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9033 TREE_OPERAND (olhs
, 0), cond
);
9034 tree
*ptr
= &TREE_OPERAND (cond
, 1);
9035 for (olhs
= TREE_OPERAND (olhs
, 1);
9036 TREE_CODE (olhs
) == COMPOUND_EXPR
;
9037 olhs
= TREE_OPERAND (olhs
, 1))
9039 *ptr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9040 TREE_OPERAND (olhs
, 0), *ptr
);
9041 ptr
= &TREE_OPERAND (*ptr
, 1);
9044 /* Make sure the code to compute the rhs comes out
9045 before the split. */
9055 if (modifycode
== INIT_EXPR
)
9057 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
9058 /* Do the default thing. */;
9059 else if (TREE_CODE (rhs
) == CONSTRUCTOR
)
9061 /* Compound literal. */
9062 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
9063 /* Call convert to generate an error; see PR 11063. */
9064 rhs
= convert (lhstype
, rhs
);
9065 result
= build2 (INIT_EXPR
, lhstype
, lhs
, rhs
);
9066 TREE_SIDE_EFFECTS (result
) = 1;
9069 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
9070 /* Do the default thing. */;
9073 releasing_vec rhs_vec
= make_tree_vector_single (rhs
);
9074 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
9075 &rhs_vec
, lhstype
, LOOKUP_NORMAL
,
9077 if (result
== NULL_TREE
)
9078 return error_mark_node
;
9084 lhs
= require_complete_type_sfinae (lhs
, complain
);
9085 if (lhs
== error_mark_node
)
9086 return error_mark_node
;
9088 if (modifycode
== NOP_EXPR
)
9090 if (c_dialect_objc ())
9092 result
= objc_maybe_build_modify_expr (lhs
, rhs
);
9097 /* `operator=' is not an inheritable operator. */
9098 if (! MAYBE_CLASS_TYPE_P (lhstype
))
9099 /* Do the default thing. */;
9102 result
= build_new_op (input_location
, MODIFY_EXPR
,
9103 LOOKUP_NORMAL
, lhs
, rhs
,
9104 make_node (NOP_EXPR
), NULL_TREE
,
9105 /*overload=*/NULL
, complain
);
9106 if (result
== NULL_TREE
)
9107 return error_mark_node
;
9114 tree init
= NULL_TREE
;
9116 /* A binary op has been requested. Combine the old LHS
9117 value with the RHS producing the value we should actually
9118 store into the LHS. */
9119 gcc_assert (!((TYPE_REF_P (lhstype
)
9120 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
9121 || MAYBE_CLASS_TYPE_P (lhstype
)));
9123 /* An expression of the form E1 op= E2. [expr.ass] says:
9124 "Such expressions are deprecated if E1 has volatile-qualified
9125 type." We warn here rather than in cp_genericize_r because
9126 for compound assignments we are supposed to warn even if the
9127 assignment is a discarded-value expression. */
9128 if (TREE_THIS_VOLATILE (lhs
) || CP_TYPE_VOLATILE_P (lhstype
))
9129 warning_at (loc
, OPT_Wvolatile
,
9130 "compound assignment with %<volatile%>-qualified left "
9131 "operand is deprecated");
9132 /* Preevaluate the RHS to make sure its evaluation is complete
9133 before the lvalue-to-rvalue conversion of the LHS:
9135 [expr.ass] With respect to an indeterminately-sequenced
9136 function call, the operation of a compound assignment is a
9137 single evaluation. [ Note: Therefore, a function call shall
9138 not intervene between the lvalue-to-rvalue conversion and the
9139 side effect associated with any single compound assignment
9140 operator. -- end note ] */
9141 lhs
= cp_stabilize_reference (lhs
);
9142 rhs
= decay_conversion (rhs
, complain
);
9143 if (rhs
== error_mark_node
)
9144 return error_mark_node
;
9145 rhs
= stabilize_expr (rhs
, &init
);
9146 newrhs
= cp_build_binary_op (loc
, modifycode
, lhs
, rhs
, complain
);
9147 if (newrhs
== error_mark_node
)
9149 if (complain
& tf_error
)
9150 inform (loc
, " in evaluation of %<%Q(%#T, %#T)%>",
9151 modifycode
, TREE_TYPE (lhs
), TREE_TYPE (rhs
));
9152 return error_mark_node
;
9156 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), init
, newrhs
);
9158 /* Now it looks like a plain assignment. */
9159 modifycode
= NOP_EXPR
;
9160 if (c_dialect_objc ())
9162 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
9167 gcc_assert (!TYPE_REF_P (lhstype
));
9168 gcc_assert (!TYPE_REF_P (TREE_TYPE (newrhs
)));
9171 /* The left-hand side must be an lvalue. */
9172 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9173 return error_mark_node
;
9175 /* Warn about modifying something that is `const'. Don't warn if
9176 this is initialization. */
9177 if (modifycode
!= INIT_EXPR
9178 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
9179 /* Functions are not modifiable, even though they are
9181 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (lhs
))
9182 /* If it's an aggregate and any field is const, then it is
9183 effectively const. */
9184 || (CLASS_TYPE_P (lhstype
)
9185 && C_TYPE_FIELDS_READONLY (lhstype
))))
9187 if (complain
& tf_error
)
9188 cxx_readonly_error (loc
, lhs
, lv_assign
);
9189 return error_mark_node
;
9192 /* If storing into a structure or union member, it may have been given a
9193 lowered bitfield type. We need to convert to the declared type first,
9194 so retrieve it now. */
9196 olhstype
= unlowered_expr_type (lhs
);
9198 /* Convert new value to destination type. */
9200 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
9204 if (BRACE_ENCLOSED_INITIALIZER_P (newrhs
))
9206 if (modifycode
!= INIT_EXPR
)
9208 if (complain
& tf_error
)
9210 "assigning to an array from an initializer list");
9211 return error_mark_node
;
9213 if (check_array_initializer (lhs
, lhstype
, newrhs
))
9214 return error_mark_node
;
9215 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9216 if (newrhs
== error_mark_node
)
9217 return error_mark_node
;
9220 /* C++11 8.5/17: "If the destination type is an array of characters,
9221 an array of char16_t, an array of char32_t, or an array of wchar_t,
9222 and the initializer is a string literal...". */
9223 else if ((TREE_CODE (tree_strip_any_location_wrapper (newrhs
))
9225 && char_type_p (TREE_TYPE (TYPE_MAIN_VARIANT (lhstype
)))
9226 && modifycode
== INIT_EXPR
)
9228 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9229 if (newrhs
== error_mark_node
)
9230 return error_mark_node
;
9233 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
9234 TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))))
9236 if (complain
& tf_error
)
9237 error_at (loc
, "incompatible types in assignment of %qT to %qT",
9238 TREE_TYPE (rhs
), lhstype
);
9239 return error_mark_node
;
9242 /* Allow array assignment in compiler-generated code. */
9243 else if (!current_function_decl
9244 || !DECL_DEFAULTED_FN (current_function_decl
))
9246 /* This routine is used for both initialization and assignment.
9247 Make sure the diagnostic message differentiates the context. */
9248 if (complain
& tf_error
)
9250 if (modifycode
== INIT_EXPR
)
9251 error_at (loc
, "array used as initializer");
9253 error_at (loc
, "invalid array assignment");
9255 return error_mark_node
;
9258 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
9259 ? 1 + (modifycode
!= INIT_EXPR
): 0;
9260 result
= build_vec_init (lhs
, NULL_TREE
, newrhs
,
9261 /*explicit_value_init_p=*/false,
9262 from_array
, complain
);
9266 if (modifycode
== INIT_EXPR
)
9267 /* Calls with INIT_EXPR are all direct-initialization, so don't set
9268 LOOKUP_ONLYCONVERTING. */
9269 newrhs
= convert_for_initialization (lhs
, olhstype
, newrhs
, LOOKUP_NORMAL
,
9270 ICR_INIT
, NULL_TREE
, 0,
9271 complain
| tf_no_cleanup
);
9273 newrhs
= convert_for_assignment (olhstype
, newrhs
, ICR_ASSIGN
,
9274 NULL_TREE
, 0, complain
, LOOKUP_IMPLICIT
);
9276 if (!same_type_p (lhstype
, olhstype
))
9277 newrhs
= cp_convert_and_check (lhstype
, newrhs
, complain
);
9279 if (modifycode
!= INIT_EXPR
)
9281 if (TREE_CODE (newrhs
) == CALL_EXPR
9282 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
9283 newrhs
= build_cplus_new (lhstype
, newrhs
, complain
);
9285 /* Can't initialize directly from a TARGET_EXPR, since that would
9286 cause the lhs to be constructed twice, and possibly result in
9287 accidental self-initialization. So we force the TARGET_EXPR to be
9288 expanded without a target. */
9289 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
9290 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
9291 TREE_OPERAND (newrhs
, 0));
9294 if (newrhs
== error_mark_node
)
9295 return error_mark_node
;
9297 if (c_dialect_objc () && flag_objc_gc
)
9299 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
9305 result
= build2_loc (loc
, modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
9306 lhstype
, lhs
, newrhs
);
9308 TREE_SIDE_EFFECTS (result
) = 1;
9310 suppress_warning (result
, OPT_Wparentheses
);
9314 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), preeval
, result
);
9319 build_x_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
9320 tree rhs
, tree lookups
, tsubst_flags_t complain
)
9322 tree orig_lhs
= lhs
;
9323 tree orig_rhs
= rhs
;
9324 tree overload
= NULL_TREE
;
9326 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
9327 return cp_expr (error_mark_node
, loc
);
9329 if (processing_template_decl
)
9331 if (modifycode
== NOP_EXPR
9332 || type_dependent_expression_p (lhs
)
9333 || type_dependent_expression_p (rhs
))
9335 tree op
= build_min_nt_loc (loc
, modifycode
, NULL_TREE
, NULL_TREE
);
9336 tree rval
= build_min_nt_loc (loc
, MODOP_EXPR
, lhs
, op
, rhs
);
9337 if (modifycode
!= NOP_EXPR
)
9339 = build_dependent_operator_type (lookups
, modifycode
, true);
9343 lhs
= build_non_dependent_expr (lhs
);
9344 rhs
= build_non_dependent_expr (rhs
);
9347 if (modifycode
!= NOP_EXPR
)
9349 tree op
= build_nt (modifycode
, NULL_TREE
, NULL_TREE
);
9350 tree rval
= build_new_op (loc
, MODIFY_EXPR
, LOOKUP_NORMAL
,
9351 lhs
, rhs
, op
, lookups
, &overload
, complain
);
9354 if (rval
== error_mark_node
)
9356 suppress_warning (rval
/* What warning? */);
9357 if (processing_template_decl
)
9359 if (overload
!= NULL_TREE
)
9360 return (build_min_non_dep_op_overload
9361 (MODIFY_EXPR
, rval
, overload
, orig_lhs
, orig_rhs
));
9363 return (build_min_non_dep
9364 (MODOP_EXPR
, rval
, orig_lhs
, op
, orig_rhs
));
9369 return cp_build_modify_expr (loc
, lhs
, modifycode
, rhs
, complain
);
9372 /* Helper function for get_delta_difference which assumes FROM is a base
9373 class of TO. Returns a delta for the conversion of pointer-to-member
9374 of FROM to pointer-to-member of TO. If the conversion is invalid and
9375 tf_error is not set in COMPLAIN returns error_mark_node, otherwise
9376 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
9377 If C_CAST_P is true, this conversion is taking place as part of a
9381 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
,
9382 tsubst_flags_t complain
)
9387 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
,
9390 if (binfo
== error_mark_node
)
9392 if (!(complain
& tf_error
))
9393 return error_mark_node
;
9395 inform (input_location
, " in pointer to member function conversion");
9396 return size_zero_node
;
9400 if (kind
!= bk_via_virtual
)
9401 return BINFO_OFFSET (binfo
);
9403 /* FROM is a virtual base class of TO. Issue an error or warning
9404 depending on whether or not this is a reinterpret cast. */
9406 if (!(complain
& tf_error
))
9407 return error_mark_node
;
9409 error ("pointer to member conversion via virtual base %qT",
9410 BINFO_TYPE (binfo_from_vbase (binfo
)));
9412 return size_zero_node
;
9419 /* Get difference in deltas for different pointer to member function
9420 types. If the conversion is invalid and tf_error is not set in
9421 COMPLAIN, returns error_mark_node, otherwise returns an integer
9422 constant of type PTRDIFF_TYPE_NODE and its value is zero if the
9423 conversion is invalid. If ALLOW_INVERSE_P is true, then allow reverse
9424 conversions as well. If C_CAST_P is true this conversion is taking
9425 place as part of a C-style cast.
9427 Note that the naming of FROM and TO is kind of backwards; the return
9428 value is what we add to a TO in order to get a FROM. They are named
9429 this way because we call this function to find out how to convert from
9430 a pointer to member of FROM to a pointer to member of TO. */
9433 get_delta_difference (tree from
, tree to
,
9434 bool allow_inverse_p
,
9435 bool c_cast_p
, tsubst_flags_t complain
)
9439 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
9440 /* Pointer to member of incomplete class is permitted*/
9441 result
= size_zero_node
;
9443 result
= get_delta_difference_1 (from
, to
, c_cast_p
, complain
);
9445 if (result
== error_mark_node
)
9446 return error_mark_node
;
9450 if (!allow_inverse_p
)
9452 if (!(complain
& tf_error
))
9453 return error_mark_node
;
9455 error_not_base_type (from
, to
);
9456 inform (input_location
, " in pointer to member conversion");
9457 result
= size_zero_node
;
9461 result
= get_delta_difference_1 (to
, from
, c_cast_p
, complain
);
9463 if (result
== error_mark_node
)
9464 return error_mark_node
;
9467 result
= size_diffop_loc (input_location
,
9468 size_zero_node
, result
);
9471 if (!(complain
& tf_error
))
9472 return error_mark_node
;
9474 error_not_base_type (from
, to
);
9475 inform (input_location
, " in pointer to member conversion");
9476 result
= size_zero_node
;
9481 return convert_to_integer (ptrdiff_type_node
, result
);
9484 /* Return a constructor for the pointer-to-member-function TYPE using
9485 the other components as specified. */
9488 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
9493 vec
<constructor_elt
, va_gc
> *v
;
9495 /* Pull the FIELD_DECLs out of the type. */
9496 pfn_field
= TYPE_FIELDS (type
);
9497 delta_field
= DECL_CHAIN (pfn_field
);
9499 /* Make sure DELTA has the type we want. */
9500 delta
= convert_and_check (input_location
, delta_type_node
, delta
);
9502 /* Convert to the correct target type if necessary. */
9503 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
9505 /* Finish creating the initializer. */
9507 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
9508 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
9509 u
= build_constructor (type
, v
);
9510 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
9511 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
9512 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
9514 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
9519 /* Build a constructor for a pointer to member function. It can be
9520 used to initialize global variables, local variable, or used
9521 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
9524 If FORCE is nonzero, then force this conversion, even if
9525 we would rather not do it. Usually set when using an explicit
9526 cast. A C-style cast is being processed iff C_CAST_P is true.
9528 Return error_mark_node, if something goes wrong. */
9531 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
,
9532 tsubst_flags_t complain
)
9538 if (error_operand_p (pfn
))
9539 return error_mark_node
;
9541 pfn_type
= TREE_TYPE (pfn
);
9542 to_type
= build_ptrmemfunc_type (type
);
9544 /* Handle multiple conversions of pointer to member functions. */
9545 if (TYPE_PTRMEMFUNC_P (pfn_type
))
9547 tree delta
= NULL_TREE
;
9548 tree npfn
= NULL_TREE
;
9552 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
,
9553 LOOKUP_NORMAL
, complain
))
9555 if (complain
& tf_error
)
9556 error ("invalid conversion to type %qT from type %qT",
9559 return error_mark_node
;
9562 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
9563 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
9565 c_cast_p
, complain
);
9566 if (n
== error_mark_node
)
9567 return error_mark_node
;
9569 /* We don't have to do any conversion to convert a
9570 pointer-to-member to its own type. But, we don't want to
9571 just return a PTRMEM_CST if there's an explicit cast; that
9572 cast should make the expression an invalid template argument. */
9573 if (TREE_CODE (pfn
) != PTRMEM_CST
)
9575 if (same_type_p (to_type
, pfn_type
))
9577 else if (integer_zerop (n
) && TREE_CODE (pfn
) != CONSTRUCTOR
)
9578 return build_reinterpret_cast (input_location
, to_type
, pfn
,
9582 if (TREE_SIDE_EFFECTS (pfn
))
9583 pfn
= save_expr (pfn
);
9585 /* Obtain the function pointer and the current DELTA. */
9586 if (TREE_CODE (pfn
) == PTRMEM_CST
)
9587 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
9590 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
9591 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
9594 /* Just adjust the DELTA field. */
9595 gcc_assert (same_type_ignoring_top_level_qualifiers_p
9596 (TREE_TYPE (delta
), ptrdiff_type_node
));
9597 if (!integer_zerop (n
))
9599 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
9600 n
= cp_build_binary_op (input_location
,
9601 LSHIFT_EXPR
, n
, integer_one_node
,
9603 delta
= cp_build_binary_op (input_location
,
9604 PLUS_EXPR
, delta
, n
, complain
);
9606 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
9609 /* Handle null pointer to member function conversions. */
9610 if (null_ptr_cst_p (pfn
))
9612 pfn
= cp_build_c_cast (input_location
,
9613 TYPE_PTRMEMFUNC_FN_TYPE_RAW (to_type
),
9615 return build_ptrmemfunc1 (to_type
,
9620 if (type_unknown_p (pfn
))
9621 return instantiate_type (type
, pfn
, complain
);
9623 fn
= TREE_OPERAND (pfn
, 0);
9624 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
9625 /* In a template, we will have preserved the
9627 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
9628 return make_ptrmem_cst (to_type
, fn
);
9631 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
9634 ??? There is no consistency as to the types returned for the above
9635 values. Some code acts as if it were a sizetype and some as if it were
9636 integer_type_node. */
9639 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
9641 tree type
= TREE_TYPE (cst
);
9642 tree fn
= PTRMEM_CST_MEMBER (cst
);
9643 tree ptr_class
, fn_class
;
9645 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
9647 /* The class that the function belongs to. */
9648 fn_class
= DECL_CONTEXT (fn
);
9650 /* The class that we're creating a pointer to member of. */
9651 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
9653 /* First, calculate the adjustment to the function's class. */
9654 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
9655 /*c_cast_p=*/0, tf_warning_or_error
);
9657 if (!DECL_VIRTUAL_P (fn
))
9659 tree t
= build_addr_func (fn
, tf_warning_or_error
);
9660 if (TREE_CODE (t
) == ADDR_EXPR
)
9661 SET_EXPR_LOCATION (t
, PTRMEM_CST_LOCATION (cst
));
9662 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), t
);
9666 /* If we're dealing with a virtual function, we have to adjust 'this'
9667 again, to point to the base which provides the vtable entry for
9668 fn; the call will do the opposite adjustment. */
9669 tree orig_class
= DECL_CONTEXT (fn
);
9670 tree binfo
= binfo_or_else (orig_class
, fn_class
);
9671 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
9672 *delta
, BINFO_OFFSET (binfo
));
9674 /* We set PFN to the vtable offset at which the function can be
9675 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
9676 case delta is shifted left, and then incremented). */
9677 *pfn
= DECL_VINDEX (fn
);
9678 *pfn
= fold_build2 (MULT_EXPR
, integer_type_node
, *pfn
,
9679 TYPE_SIZE_UNIT (vtable_entry_type
));
9681 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
9683 case ptrmemfunc_vbit_in_pfn
:
9684 *pfn
= fold_build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
9688 case ptrmemfunc_vbit_in_delta
:
9689 *delta
= fold_build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
9690 *delta
, integer_one_node
);
9691 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
9692 *delta
, integer_one_node
);
9699 *pfn
= fold_convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
9703 /* Return an expression for PFN from the pointer-to-member function
9707 pfn_from_ptrmemfunc (tree t
)
9709 if (TREE_CODE (t
) == PTRMEM_CST
)
9714 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
9719 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
9722 /* Return an expression for DELTA from the pointer-to-member function
9726 delta_from_ptrmemfunc (tree t
)
9728 if (TREE_CODE (t
) == PTRMEM_CST
)
9733 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
9738 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
9741 /* Convert value RHS to type TYPE as preparation for an assignment to
9742 an lvalue of type TYPE. ERRTYPE indicates what kind of error the
9743 implicit conversion is. If FNDECL is non-NULL, we are doing the
9744 conversion in order to pass the PARMNUMth argument of FNDECL.
9745 If FNDECL is NULL, we are doing the conversion in function pointer
9746 argument passing, conversion in initialization, etc. */
9749 convert_for_assignment (tree type
, tree rhs
,
9750 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
9751 tsubst_flags_t complain
, int flags
)
9754 enum tree_code coder
;
9756 location_t rhs_loc
= cp_expr_loc_or_input_loc (rhs
);
9757 bool has_loc
= EXPR_LOCATION (rhs
) != UNKNOWN_LOCATION
;
9758 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue,
9759 but preserve location wrappers. */
9760 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
9761 && !location_wrapper_p (rhs
))
9762 rhs
= TREE_OPERAND (rhs
, 0);
9764 /* Handle [dcl.init.list] direct-list-initialization from
9765 single element of enumeration with a fixed underlying type. */
9766 if (is_direct_enum_init (type
, rhs
))
9768 tree elt
= CONSTRUCTOR_ELT (rhs
, 0)->value
;
9769 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
9771 warning_sentinel
w (warn_useless_cast
);
9772 warning_sentinel
w2 (warn_ignored_qualifiers
);
9773 rhs
= cp_build_c_cast (rhs_loc
, type
, elt
, complain
);
9776 rhs
= error_mark_node
;
9779 rhstype
= TREE_TYPE (rhs
);
9780 coder
= TREE_CODE (rhstype
);
9782 if (VECTOR_TYPE_P (type
) && coder
== VECTOR_TYPE
9783 && vector_types_convertible_p (type
, rhstype
, true))
9785 rhs
= mark_rvalue_use (rhs
);
9786 return convert (type
, rhs
);
9789 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
9790 return error_mark_node
;
9791 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
9792 return error_mark_node
;
9794 /* The RHS of an assignment cannot have void type. */
9795 if (coder
== VOID_TYPE
)
9797 if (complain
& tf_error
)
9798 error_at (rhs_loc
, "void value not ignored as it ought to be");
9799 return error_mark_node
;
9802 if (c_dialect_objc ())
9806 tree rname
= fndecl
;
9817 selector
= objc_message_selector ();
9819 if (selector
&& parmno
> 1)
9826 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
9828 rhs
= mark_rvalue_use (rhs
);
9829 return convert (type
, rhs
);
9835 The expression is implicitly converted (clause _conv_) to the
9836 cv-unqualified type of the left operand.
9838 We allow bad conversions here because by the time we get to this point
9839 we are committed to doing the conversion. If we end up doing a bad
9840 conversion, convert_like will complain. */
9841 if (!can_convert_arg_bad (type
, rhstype
, rhs
, flags
, complain
))
9843 /* When -Wno-pmf-conversions is use, we just silently allow
9844 conversions from pointers-to-members to plain pointers. If
9845 the conversion doesn't work, cp_convert will complain. */
9847 && TYPE_PTR_P (type
)
9848 && TYPE_PTRMEMFUNC_P (rhstype
))
9849 rhs
= cp_convert (strip_top_quals (type
), rhs
, complain
);
9852 if (complain
& tf_error
)
9854 /* If the right-hand side has unknown type, then it is an
9855 overloaded function. Call instantiate_type to get error
9857 if (rhstype
== unknown_type_node
)
9859 tree r
= instantiate_type (type
, rhs
, tf_warning_or_error
);
9860 /* -fpermissive might allow this; recurse. */
9862 return convert_for_assignment (type
, r
, errtype
, fndecl
,
9863 parmnum
, complain
, flags
);
9866 complain_about_bad_argument (rhs_loc
,
9871 range_label_for_type_mismatch
label (rhstype
, type
);
9872 gcc_rich_location
richloc (rhs_loc
, has_loc
? &label
: NULL
);
9875 case ICR_DEFAULT_ARGUMENT
:
9877 "cannot convert %qH to %qI in default argument",
9882 "cannot convert %qH to %qI in argument passing",
9885 case ICR_CONVERTING
:
9886 error_at (&richloc
, "cannot convert %qH to %qI",
9891 "cannot convert %qH to %qI in initialization",
9895 error_at (&richloc
, "cannot convert %qH to %qI in return",
9900 "cannot convert %qH to %qI in assignment",
9907 if (TYPE_PTR_P (rhstype
)
9908 && TYPE_PTR_P (type
)
9909 && CLASS_TYPE_P (TREE_TYPE (rhstype
))
9910 && CLASS_TYPE_P (TREE_TYPE (type
))
9911 && !COMPLETE_TYPE_P (TREE_TYPE (rhstype
)))
9912 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL
9913 (TREE_TYPE (rhstype
))),
9914 "class type %qT is incomplete", TREE_TYPE (rhstype
));
9916 return error_mark_node
;
9919 if (warn_suggest_attribute_format
)
9921 const enum tree_code codel
= TREE_CODE (type
);
9922 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
9924 && check_missing_format_attribute (type
, rhstype
)
9925 && (complain
& tf_warning
))
9929 case ICR_DEFAULT_ARGUMENT
:
9931 warning (OPT_Wsuggest_attribute_format
,
9932 "parameter %qP of %qD might be a candidate "
9933 "for a format attribute", parmnum
, fndecl
);
9935 warning (OPT_Wsuggest_attribute_format
,
9936 "parameter might be a candidate "
9937 "for a format attribute");
9939 case ICR_CONVERTING
:
9940 warning (OPT_Wsuggest_attribute_format
,
9941 "target of conversion might be a candidate "
9942 "for a format attribute");
9945 warning (OPT_Wsuggest_attribute_format
,
9946 "target of initialization might be a candidate "
9947 "for a format attribute");
9950 warning (OPT_Wsuggest_attribute_format
,
9951 "return type might be a candidate "
9952 "for a format attribute");
9955 warning (OPT_Wsuggest_attribute_format
,
9956 "left-hand side of assignment might be a candidate "
9957 "for a format attribute");
9964 /* If -Wparentheses, warn about a = b = c when a has type bool and b
9966 if (warn_parentheses
9967 && TREE_CODE (type
) == BOOLEAN_TYPE
9968 && TREE_CODE (rhs
) == MODIFY_EXPR
9969 && !warning_suppressed_p (rhs
, OPT_Wparentheses
)
9970 && TREE_CODE (TREE_TYPE (rhs
)) != BOOLEAN_TYPE
9971 && (complain
& tf_warning
)
9972 && warning_at (rhs_loc
, OPT_Wparentheses
,
9973 "suggest parentheses around assignment used as "
9975 suppress_warning (rhs
, OPT_Wparentheses
);
9977 if (complain
& tf_warning
)
9978 warn_for_address_or_pointer_of_packed_member (type
, rhs
);
9980 return perform_implicit_conversion_flags (strip_top_quals (type
), rhs
,
9984 /* Convert RHS to be of type TYPE.
9985 If EXP is nonzero, it is the target of the initialization.
9986 ERRTYPE indicates what kind of error the implicit conversion is.
9988 Two major differences between the behavior of
9989 `convert_for_assignment' and `convert_for_initialization'
9990 are that references are bashed in the former, while
9991 copied in the latter, and aggregates are assigned in
9992 the former (operator=) while initialized in the
9995 If using constructor make sure no conversion operator exists, if one does
9996 exist, an ambiguity exists. */
9999 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
10000 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
10001 tsubst_flags_t complain
)
10003 enum tree_code codel
= TREE_CODE (type
);
10005 enum tree_code coder
;
10007 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
10008 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
10009 if (TREE_CODE (rhs
) == NOP_EXPR
10010 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
10011 && codel
!= REFERENCE_TYPE
)
10012 rhs
= TREE_OPERAND (rhs
, 0);
10014 if (type
== error_mark_node
10015 || rhs
== error_mark_node
10016 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
10017 return error_mark_node
;
10019 if (MAYBE_CLASS_TYPE_P (non_reference (type
)))
10021 else if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
10022 && TREE_CODE (type
) != ARRAY_TYPE
10023 && (!TYPE_REF_P (type
)
10024 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
10025 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
10026 && !TYPE_REFFN_P (type
))
10027 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
10028 rhs
= decay_conversion (rhs
, complain
);
10030 rhstype
= TREE_TYPE (rhs
);
10031 coder
= TREE_CODE (rhstype
);
10033 if (coder
== ERROR_MARK
)
10034 return error_mark_node
;
10036 /* We accept references to incomplete types, so we can
10037 return here before checking if RHS is of complete type. */
10039 if (codel
== REFERENCE_TYPE
)
10041 auto_diagnostic_group d
;
10042 /* This should eventually happen in convert_arguments. */
10043 int savew
= 0, savee
= 0;
10046 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
10047 rhs
= initialize_reference (type
, rhs
, flags
, complain
);
10050 && (warningcount
+ werrorcount
> savew
|| errorcount
> savee
))
10051 inform (get_fndecl_argument_location (fndecl
, parmnum
),
10052 "in passing argument %P of %qD", parmnum
, fndecl
);
10057 exp
= require_complete_type_sfinae (exp
, complain
);
10058 if (exp
== error_mark_node
)
10059 return error_mark_node
;
10061 type
= complete_type (type
);
10063 if (DIRECT_INIT_EXPR_P (type
, rhs
))
10064 /* Don't try to do copy-initialization if we already have
10065 direct-initialization. */
10068 if (MAYBE_CLASS_TYPE_P (type
))
10069 return perform_implicit_conversion_flags (type
, rhs
, complain
, flags
);
10071 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
10075 /* If RETVAL is the address of, or a reference to, a local variable or
10076 temporary give an appropriate warning and return true. */
10079 maybe_warn_about_returning_address_of_local (tree retval
, location_t loc
)
10081 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
10082 tree whats_returned
= fold_for_warn (retval
);
10084 loc
= cp_expr_loc_or_input_loc (retval
);
10088 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
10089 whats_returned
= TREE_OPERAND (whats_returned
, 1);
10090 else if (CONVERT_EXPR_P (whats_returned
)
10091 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
10092 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10097 if (TREE_CODE (whats_returned
) == TARGET_EXPR
10098 && is_std_init_list (TREE_TYPE (whats_returned
)))
10100 tree init
= TARGET_EXPR_INITIAL (whats_returned
);
10101 if (TREE_CODE (init
) == CONSTRUCTOR
)
10102 /* Pull out the array address. */
10103 whats_returned
= CONSTRUCTOR_ELT (init
, 0)->value
;
10104 else if (TREE_CODE (init
) == INDIRECT_REF
)
10105 /* The source of a trivial copy looks like *(T*)&var. */
10106 whats_returned
= TREE_OPERAND (init
, 0);
10109 STRIP_NOPS (whats_returned
);
10112 /* As a special case, we handle a call to std::move or std::forward. */
10113 if (TREE_CODE (whats_returned
) == CALL_EXPR
10114 && (is_std_move_p (whats_returned
)
10115 || is_std_forward_p (whats_returned
)))
10117 tree arg
= CALL_EXPR_ARG (whats_returned
, 0);
10118 return maybe_warn_about_returning_address_of_local (arg
, loc
);
10121 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
10123 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10125 while (TREE_CODE (whats_returned
) == COMPONENT_REF
10126 || TREE_CODE (whats_returned
) == ARRAY_REF
)
10127 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10129 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
10130 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
10132 if (TYPE_REF_P (valtype
))
10133 warning_at (loc
, OPT_Wreturn_local_addr
,
10134 "returning reference to temporary");
10135 else if (is_std_init_list (valtype
))
10136 warning_at (loc
, OPT_Winit_list_lifetime
,
10137 "returning temporary %<initializer_list%> does not extend "
10138 "the lifetime of the underlying array");
10142 STRIP_ANY_LOCATION_WRAPPER (whats_returned
);
10144 if (DECL_P (whats_returned
)
10145 && DECL_NAME (whats_returned
)
10146 && DECL_FUNCTION_SCOPE_P (whats_returned
)
10147 && !is_capture_proxy (whats_returned
)
10148 && !(TREE_STATIC (whats_returned
)
10149 || TREE_PUBLIC (whats_returned
)))
10151 if (VAR_P (whats_returned
)
10152 && DECL_DECOMPOSITION_P (whats_returned
)
10153 && DECL_DECOMP_BASE (whats_returned
)
10154 && DECL_HAS_VALUE_EXPR_P (whats_returned
))
10156 /* When returning address of a structured binding, if the structured
10157 binding is not a reference, continue normally, if it is a
10158 reference, recurse on the initializer of the structured
10160 tree base
= DECL_DECOMP_BASE (whats_returned
);
10161 if (TYPE_REF_P (TREE_TYPE (base
)))
10163 if (tree init
= DECL_INITIAL (base
))
10164 return maybe_warn_about_returning_address_of_local (init
, loc
);
10170 auto_diagnostic_group d
;
10171 if (TYPE_REF_P (valtype
))
10172 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10173 "reference to local variable %qD returned",
10175 else if (is_std_init_list (valtype
))
10176 w
= warning_at (loc
, OPT_Winit_list_lifetime
,
10177 "returning local %<initializer_list%> variable %qD "
10178 "does not extend the lifetime of the underlying array",
10180 else if (POINTER_TYPE_P (valtype
)
10181 && TREE_CODE (whats_returned
) == LABEL_DECL
)
10182 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10183 "address of label %qD returned",
10185 else if (POINTER_TYPE_P (valtype
))
10186 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10187 "address of local variable %qD returned",
10190 inform (DECL_SOURCE_LOCATION (whats_returned
),
10198 /* Returns true if DECL is in the std namespace. */
10201 decl_in_std_namespace_p (tree decl
)
10205 decl
= decl_namespace_context (decl
);
10206 if (DECL_NAMESPACE_STD_P (decl
))
10208 /* Allow inline namespaces inside of std namespace, e.g. with
10209 --enable-symvers=gnu-versioned-namespace std::forward would be
10210 actually std::_8::forward. */
10211 if (!DECL_NAMESPACE_INLINE_P (decl
))
10213 decl
= CP_DECL_CONTEXT (decl
);
10218 /* Returns true if FN, a CALL_EXPR, is a call to std::forward. */
10221 is_std_forward_p (tree fn
)
10223 /* std::forward only takes one argument. */
10224 if (call_expr_nargs (fn
) != 1)
10227 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10228 if (!decl_in_std_namespace_p (fndecl
))
10231 tree name
= DECL_NAME (fndecl
);
10232 return name
&& id_equal (name
, "forward");
10235 /* Returns true if FN, a CALL_EXPR, is a call to std::move. */
10238 is_std_move_p (tree fn
)
10240 /* std::move only takes one argument. */
10241 if (call_expr_nargs (fn
) != 1)
10244 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10245 if (!decl_in_std_namespace_p (fndecl
))
10248 tree name
= DECL_NAME (fndecl
);
10249 return name
&& id_equal (name
, "move");
10252 /* Returns true if RETVAL is a good candidate for the NRVO as per
10253 [class.copy.elision]. FUNCTYPE is the type the function is declared
10257 can_do_nrvo_p (tree retval
, tree functype
)
10259 if (functype
== error_mark_node
)
10262 STRIP_ANY_LOCATION_WRAPPER (retval
);
10263 tree result
= DECL_RESULT (current_function_decl
);
10264 return (retval
!= NULL_TREE
10265 && !processing_template_decl
10266 /* Must be a local, automatic variable. */
10268 && DECL_CONTEXT (retval
) == current_function_decl
10269 && !TREE_STATIC (retval
)
10270 /* And not a lambda or anonymous union proxy. */
10271 && !DECL_HAS_VALUE_EXPR_P (retval
)
10272 && (DECL_ALIGN (retval
) <= DECL_ALIGN (result
))
10273 /* The cv-unqualified type of the returned value must be the
10274 same as the cv-unqualified return type of the
10276 && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval
))),
10277 (TYPE_MAIN_VARIANT (functype
)))
10278 /* And the returned value must be non-volatile. */
10279 && !TYPE_VOLATILE (TREE_TYPE (retval
)));
10282 /* If we should treat RETVAL, an expression being returned, as if it were
10283 designated by an rvalue, returns it adjusted accordingly; otherwise, returns
10284 NULL_TREE. See [class.copy.elision]. RETURN_P is true if this is a return
10285 context (rather than throw). */
10288 treat_lvalue_as_rvalue_p (tree expr
, bool return_p
)
10290 if (cxx_dialect
== cxx98
)
10293 tree retval
= expr
;
10294 STRIP_ANY_LOCATION_WRAPPER (retval
);
10295 if (REFERENCE_REF_P (retval
))
10296 retval
= TREE_OPERAND (retval
, 0);
10298 /* An implicitly movable entity is a variable of automatic storage duration
10299 that is either a non-volatile object or (C++20) an rvalue reference to a
10300 non-volatile object type. */
10301 if (!(((VAR_P (retval
) && !DECL_HAS_VALUE_EXPR_P (retval
))
10302 || TREE_CODE (retval
) == PARM_DECL
)
10303 && !TREE_STATIC (retval
)
10304 && !CP_TYPE_VOLATILE_P (non_reference (TREE_TYPE (retval
)))
10305 && (TREE_CODE (TREE_TYPE (retval
)) != REFERENCE_TYPE
10306 || (cxx_dialect
>= cxx20
10307 && TYPE_REF_IS_RVALUE (TREE_TYPE (retval
))))))
10310 /* If the expression in a return or co_return statement is a (possibly
10311 parenthesized) id-expression that names an implicitly movable entity
10312 declared in the body or parameter-declaration-clause of the innermost
10313 enclosing function or lambda-expression, */
10314 if (DECL_CONTEXT (retval
) != current_function_decl
)
10317 return set_implicit_rvalue_p (move (expr
));
10319 /* if the operand of a throw-expression is a (possibly parenthesized)
10320 id-expression that names an implicitly movable entity whose scope does not
10321 extend beyond the compound-statement of the innermost try-block or
10322 function-try-block (if any) whose compound-statement or ctor-initializer
10323 encloses the throw-expression, */
10325 /* C++20 added move on throw of parms. */
10326 if (TREE_CODE (retval
) == PARM_DECL
&& cxx_dialect
< cxx20
)
10329 for (cp_binding_level
*b
= current_binding_level
;
10330 ; b
= b
->level_chain
)
10332 for (tree decl
= b
->names
; decl
; decl
= TREE_CHAIN (decl
))
10333 if (decl
== retval
)
10334 return set_implicit_rvalue_p (move (expr
));
10335 if (b
->kind
== sk_function_parms
|| b
->kind
== sk_try
)
10340 /* Warn about wrong usage of std::move in a return statement. RETVAL
10341 is the expression we are returning; FUNCTYPE is the type the function
10342 is declared to return. */
10345 maybe_warn_pessimizing_move (tree retval
, tree functype
)
10347 if (!(warn_pessimizing_move
|| warn_redundant_move
))
10350 location_t loc
= cp_expr_loc_or_input_loc (retval
);
10352 /* C++98 doesn't know move. */
10353 if (cxx_dialect
< cxx11
)
10356 /* Wait until instantiation time, since we can't gauge if we should do
10357 the NRVO until then. */
10358 if (processing_template_decl
)
10361 /* This is only interesting for class types. */
10362 if (!CLASS_TYPE_P (functype
))
10365 /* We're looking for *std::move<T&> ((T &) &arg). */
10366 if (REFERENCE_REF_P (retval
)
10367 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
10369 tree fn
= TREE_OPERAND (retval
, 0);
10370 if (is_std_move_p (fn
))
10372 tree arg
= CALL_EXPR_ARG (fn
, 0);
10374 if (TREE_CODE (arg
) != NOP_EXPR
)
10376 arg
= TREE_OPERAND (arg
, 0);
10377 if (TREE_CODE (arg
) != ADDR_EXPR
)
10379 arg
= TREE_OPERAND (arg
, 0);
10380 arg
= convert_from_reference (arg
);
10381 /* Warn if we could do copy elision were it not for the move. */
10382 if (can_do_nrvo_p (arg
, functype
))
10384 auto_diagnostic_group d
;
10385 if (warning_at (loc
, OPT_Wpessimizing_move
,
10386 "moving a local object in a return statement "
10387 "prevents copy elision"))
10388 inform (loc
, "remove %<std::move%> call");
10390 /* Warn if the move is redundant. It is redundant when we would
10391 do maybe-rvalue overload resolution even without std::move. */
10392 else if (warn_redundant_move
10393 && (moved
= treat_lvalue_as_rvalue_p (arg
, /*return*/true)))
10395 /* Make sure that the overload resolution would actually succeed
10396 if we removed the std::move call. */
10397 tree t
= convert_for_initialization (NULL_TREE
, functype
,
10400 | LOOKUP_ONLYCONVERTING
10401 | LOOKUP_PREFER_RVALUE
),
10402 ICR_RETURN
, NULL_TREE
, 0,
10404 /* If this worked, implicit rvalue would work, so the call to
10405 std::move is redundant. */
10406 if (t
!= error_mark_node
)
10408 auto_diagnostic_group d
;
10409 if (warning_at (loc
, OPT_Wredundant_move
,
10410 "redundant move in return statement"))
10411 inform (loc
, "remove %<std::move%> call");
10418 /* Check that returning RETVAL from the current function is valid.
10419 Return an expression explicitly showing all conversions required to
10420 change RETVAL into the function return type, and to assign it to
10421 the DECL_RESULT for the function. Set *NO_WARNING to true if
10422 code reaches end of non-void function warning shouldn't be issued
10423 on this RETURN_EXPR. */
10426 check_return_expr (tree retval
, bool *no_warning
)
10429 /* The type actually returned by the function. */
10431 /* The type the function is declared to return, or void if
10432 the declared type is incomplete. */
10434 int fn_returns_value_p
;
10435 location_t loc
= cp_expr_loc_or_input_loc (retval
);
10437 *no_warning
= false;
10439 /* A `volatile' function is one that isn't supposed to return, ever.
10440 (This is a G++ extension, used to get better code for functions
10441 that call the `volatile' function.) */
10442 if (TREE_THIS_VOLATILE (current_function_decl
))
10443 warning (0, "function declared %<noreturn%> has a %<return%> statement");
10445 /* Check for various simple errors. */
10446 if (DECL_DESTRUCTOR_P (current_function_decl
))
10449 error_at (loc
, "returning a value from a destructor");
10451 if (targetm
.cxx
.cdtor_returns_this () && !processing_template_decl
)
10452 retval
= current_class_ptr
;
10456 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10458 if (in_function_try_handler
)
10459 /* If a return statement appears in a handler of the
10460 function-try-block of a constructor, the program is ill-formed. */
10461 error ("cannot return from a handler of a function-try-block of a constructor");
10463 /* You can't return a value from a constructor. */
10464 error_at (loc
, "returning a value from a constructor");
10466 if (targetm
.cxx
.cdtor_returns_this () && !processing_template_decl
)
10467 retval
= current_class_ptr
;
10472 const tree saved_retval
= retval
;
10474 if (processing_template_decl
)
10476 current_function_returns_value
= 1;
10478 if (check_for_bare_parameter_packs (retval
))
10479 return error_mark_node
;
10481 /* If one of the types might be void, we can't tell whether we're
10482 returning a value. */
10483 if ((WILDCARD_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl
)))
10484 && !FNDECL_USED_AUTO (current_function_decl
))
10485 || (retval
!= NULL_TREE
10486 && (TREE_TYPE (retval
) == NULL_TREE
10487 || WILDCARD_TYPE_P (TREE_TYPE (retval
)))))
10491 functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
10493 /* Deduce auto return type from a return statement. */
10494 if (FNDECL_USED_AUTO (current_function_decl
))
10496 tree pattern
= DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
);
10500 if (!retval
&& !is_auto (pattern
))
10502 /* Give a helpful error message. */
10503 error ("return-statement with no value, in function returning %qT",
10505 inform (input_location
, "only plain %<auto%> return type can be "
10506 "deduced to %<void%>");
10507 type
= error_mark_node
;
10509 else if (retval
&& BRACE_ENCLOSED_INITIALIZER_P (retval
))
10511 error ("returning initializer list");
10512 type
= error_mark_node
;
10517 retval
= void_node
;
10518 auto_node
= type_uses_auto (pattern
);
10519 type
= do_auto_deduction (pattern
, retval
, auto_node
,
10520 tf_warning_or_error
, adc_return_type
);
10523 if (type
== error_mark_node
)
10525 else if (functype
== pattern
)
10526 apply_deduced_return_type (current_function_decl
, type
);
10527 else if (!same_type_p (type
, functype
))
10529 if (LAMBDA_FUNCTION_P (current_function_decl
))
10530 error_at (loc
, "inconsistent types %qT and %qT deduced for "
10531 "lambda return type", functype
, type
);
10533 error_at (loc
, "inconsistent deduction for auto return type: "
10534 "%qT and then %qT", functype
, type
);
10539 result
= DECL_RESULT (current_function_decl
);
10540 valtype
= TREE_TYPE (result
);
10541 gcc_assert (valtype
!= NULL_TREE
);
10542 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
10544 /* Check for a return statement with no return value in a function
10545 that's supposed to return a value. */
10546 if (!retval
&& fn_returns_value_p
)
10548 if (functype
!= error_mark_node
)
10549 permerror (input_location
, "return-statement with no value, in "
10550 "function returning %qT", valtype
);
10551 /* Remember that this function did return. */
10552 current_function_returns_value
= 1;
10553 /* And signal caller that TREE_NO_WARNING should be set on the
10554 RETURN_EXPR to avoid control reaches end of non-void function
10555 warnings in tree-cfg.cc. */
10556 *no_warning
= true;
10558 /* Check for a return statement with a value in a function that
10559 isn't supposed to return a value. */
10560 else if (retval
&& !fn_returns_value_p
)
10562 if (VOID_TYPE_P (TREE_TYPE (retval
)))
10563 /* You can return a `void' value from a function of `void'
10564 type. In that case, we have to evaluate the expression for
10565 its side-effects. */
10566 finish_expr_stmt (retval
);
10567 else if (retval
!= error_mark_node
)
10568 permerror (loc
, "return-statement with a value, in function "
10569 "returning %qT", valtype
);
10570 current_function_returns_null
= 1;
10572 /* There's really no value to return, after all. */
10576 /* Remember that this function can sometimes return without a
10578 current_function_returns_null
= 1;
10580 /* Remember that this function did return a value. */
10581 current_function_returns_value
= 1;
10583 /* Check for erroneous operands -- but after giving ourselves a
10584 chance to provide an error about returning a value from a void
10586 if (error_operand_p (retval
))
10588 current_function_return_value
= error_mark_node
;
10589 return error_mark_node
;
10592 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
10593 if (IDENTIFIER_NEW_OP_P (DECL_NAME (current_function_decl
))
10594 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
10595 && ! flag_check_new
10596 && retval
&& null_ptr_cst_p (retval
))
10597 warning (0, "%<operator new%> must not return NULL unless it is "
10598 "declared %<throw()%> (or %<-fcheck-new%> is in effect)");
10600 /* Effective C++ rule 15. See also start_function. */
10602 && DECL_NAME (current_function_decl
) == assign_op_identifier
10603 && !type_dependent_expression_p (retval
))
10607 /* The function return type must be a reference to the current
10609 if (TYPE_REF_P (valtype
)
10610 && same_type_ignoring_top_level_qualifiers_p
10611 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
10613 /* Returning '*this' is obviously OK. */
10614 if (retval
== current_class_ref
)
10616 /* If we are calling a function whose return type is the same of
10617 the current class reference, it is ok. */
10618 else if (INDIRECT_REF_P (retval
)
10619 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
10624 warning_at (loc
, OPT_Weffc__
,
10625 "%<operator=%> should return a reference to %<*this%>");
10628 if (dependent_type_p (functype
)
10629 || type_dependent_expression_p (retval
))
10632 /* We should not have changed the return value. */
10633 gcc_assert (retval
== saved_retval
);
10634 /* We don't know if this is an lvalue or rvalue use, but
10635 either way we can mark it as read. */
10636 mark_exp_read (retval
);
10640 /* The fabled Named Return Value optimization, as per [class.copy]/15:
10642 [...] For a function with a class return type, if the expression
10643 in the return statement is the name of a local object, and the cv-
10644 unqualified type of the local object is the same as the function
10645 return type, an implementation is permitted to omit creating the tem-
10646 porary object to hold the function return value [...]
10648 So, if this is a value-returning function that always returns the same
10649 local variable, remember it.
10651 It might be nice to be more flexible, and choose the first suitable
10652 variable even if the function sometimes returns something else, but
10653 then we run the risk of clobbering the variable we chose if the other
10654 returned expression uses the chosen variable somehow. And people expect
10655 this restriction, anyway. (jason 2000-11-19)
10657 See finish_function and finalize_nrv for the rest of this optimization. */
10658 tree bare_retval
= NULL_TREE
;
10661 retval
= maybe_undo_parenthesized_ref (retval
);
10662 bare_retval
= tree_strip_any_location_wrapper (retval
);
10665 bool named_return_value_okay_p
= can_do_nrvo_p (bare_retval
, functype
);
10666 if (fn_returns_value_p
&& flag_elide_constructors
)
10668 if (named_return_value_okay_p
10669 && (current_function_return_value
== NULL_TREE
10670 || current_function_return_value
== bare_retval
))
10671 current_function_return_value
= bare_retval
;
10673 current_function_return_value
= error_mark_node
;
10676 /* We don't need to do any conversions when there's nothing being
10681 if (!named_return_value_okay_p
)
10682 maybe_warn_pessimizing_move (retval
, functype
);
10684 /* Do any required conversions. */
10685 if (bare_retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
10686 /* No conversions are required. */
10690 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
10692 /* The functype's return type will have been set to void, if it
10693 was an incomplete type. Just treat this as 'return;' */
10694 if (VOID_TYPE_P (functype
))
10695 return error_mark_node
;
10697 if (processing_template_decl
)
10698 retval
= build_non_dependent_expr (retval
);
10700 /* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
10701 treated as an rvalue for the purposes of overload resolution to
10702 favor move constructors over copy constructors.
10704 Note that these conditions are similar to, but not as strict as,
10705 the conditions for the named return value optimization. */
10706 bool converted
= false;
10708 /* This is only interesting for class type. */
10709 if (CLASS_TYPE_P (functype
)
10710 && (moved
= treat_lvalue_as_rvalue_p (retval
, /*return*/true)))
10712 if (cxx_dialect
< cxx20
)
10714 moved
= convert_for_initialization
10715 (NULL_TREE
, functype
, moved
, flags
|LOOKUP_PREFER_RVALUE
,
10716 ICR_RETURN
, NULL_TREE
, 0, tf_none
);
10717 if (moved
!= error_mark_node
)
10724 /* In C++20 we just treat the return value as an rvalue that
10725 can bind to lvalue refs. */
10729 /* The call in a (lambda) thunk needs no conversions. */
10730 if (TREE_CODE (retval
) == CALL_EXPR
10731 && call_from_lambda_thunk_p (retval
))
10734 /* First convert the value to the function's return type, then
10735 to the type of return value's location to handle the
10736 case that functype is smaller than the valtype. */
10738 retval
= convert_for_initialization
10739 (NULL_TREE
, functype
, retval
, flags
, ICR_RETURN
, NULL_TREE
, 0,
10740 tf_warning_or_error
);
10741 retval
= convert (valtype
, retval
);
10743 /* If the conversion failed, treat this just like `return;'. */
10744 if (retval
== error_mark_node
)
10746 /* We can't initialize a register from a AGGR_INIT_EXPR. */
10747 else if (! cfun
->returns_struct
10748 && TREE_CODE (retval
) == TARGET_EXPR
10749 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
10750 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
10751 TREE_OPERAND (retval
, 0));
10752 else if (!processing_template_decl
10753 && maybe_warn_about_returning_address_of_local (retval
, loc
)
10754 && INDIRECT_TYPE_P (valtype
))
10755 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
10756 build_zero_cst (TREE_TYPE (retval
)));
10759 if (processing_template_decl
)
10760 return saved_retval
;
10762 /* Actually copy the value returned into the appropriate location. */
10763 if (retval
&& retval
!= result
)
10764 retval
= build2 (INIT_EXPR
, TREE_TYPE (result
), result
, retval
);
10766 if (tree set
= maybe_set_retval_sentinel ())
10767 retval
= build2 (COMPOUND_EXPR
, void_type_node
, retval
, set
);
10773 /* Returns nonzero if the pointer-type FROM can be converted to the
10774 pointer-type TO via a qualification conversion. If CONSTP is -1,
10775 then we return nonzero if the pointers are similar, and the
10776 cv-qualification signature of FROM is a proper subset of that of TO.
10778 If CONSTP is positive, then all outer pointers have been
10779 const-qualified. */
10782 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
10784 bool to_more_cv_qualified
= false;
10785 bool is_opaque_pointer
= false;
10787 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10789 if (TREE_CODE (to
) != TREE_CODE (from
))
10792 if (TREE_CODE (from
) == OFFSET_TYPE
10793 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
10794 TYPE_OFFSET_BASETYPE (to
)))
10797 /* Const and volatile mean something different for function and
10798 array types, so the usual checks are not appropriate. We'll
10799 check the array type elements in further iterations. */
10800 if (!FUNC_OR_METHOD_TYPE_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
10802 if (!at_least_as_qualified_p (to
, from
))
10805 if (!at_least_as_qualified_p (from
, to
))
10809 to_more_cv_qualified
= true;
10813 constp
&= TYPE_READONLY (to
);
10816 if (VECTOR_TYPE_P (to
))
10817 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
10819 /* P0388R4 allows a conversion from int[N] to int[] but not the
10820 other way round. When both arrays have bounds but they do
10821 not match, then no conversion is possible. */
10822 if (TREE_CODE (to
) == ARRAY_TYPE
10823 && !comp_array_types (to
, from
, bounds_first
, /*strict=*/false))
10826 if (!TYPE_PTR_P (to
)
10827 && !TYPE_PTRDATAMEM_P (to
)
10828 /* CWG 330 says we need to look through arrays. */
10829 && TREE_CODE (to
) != ARRAY_TYPE
)
10830 return ((constp
>= 0 || to_more_cv_qualified
)
10831 && (is_opaque_pointer
10832 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
10836 /* When comparing, say, char ** to char const **, this function takes
10837 the 'char *' and 'char const *'. Do not pass non-pointer/reference
10838 types to this function. */
10841 comp_ptr_ttypes (tree to
, tree from
)
10843 return comp_ptr_ttypes_real (to
, from
, 1);
10846 /* Returns true iff FNTYPE is a non-class type that involves
10847 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
10848 if a parameter type is ill-formed. */
10851 error_type_p (const_tree type
)
10855 switch (TREE_CODE (type
))
10861 case REFERENCE_TYPE
:
10863 return error_type_p (TREE_TYPE (type
));
10865 case FUNCTION_TYPE
:
10867 if (error_type_p (TREE_TYPE (type
)))
10869 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
10870 if (error_type_p (TREE_VALUE (t
)))
10875 if (TYPE_PTRMEMFUNC_P (type
))
10876 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type
));
10884 /* Returns true if to and from are (possibly multi-level) pointers to the same
10885 type or inheritance-related types, regardless of cv-quals. */
10888 ptr_reasonably_similar (const_tree to
, const_tree from
)
10890 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10892 /* Any target type is similar enough to void. */
10893 if (VOID_TYPE_P (to
))
10894 return !error_type_p (from
);
10895 if (VOID_TYPE_P (from
))
10896 return !error_type_p (to
);
10898 if (TREE_CODE (to
) != TREE_CODE (from
))
10901 if (TREE_CODE (from
) == OFFSET_TYPE
10902 && comptypes (TYPE_OFFSET_BASETYPE (to
),
10903 TYPE_OFFSET_BASETYPE (from
),
10904 COMPARE_BASE
| COMPARE_DERIVED
))
10907 if (VECTOR_TYPE_P (to
)
10908 && vector_types_convertible_p (to
, from
, false))
10911 if (TREE_CODE (to
) == INTEGER_TYPE
10912 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
10915 if (TREE_CODE (to
) == FUNCTION_TYPE
)
10916 return !error_type_p (to
) && !error_type_p (from
);
10918 if (!TYPE_PTR_P (to
))
10920 /* When either type is incomplete avoid DERIVED_FROM_P,
10921 which may call complete_type (c++/57942). */
10922 bool b
= !COMPLETE_TYPE_P (to
) || !COMPLETE_TYPE_P (from
);
10924 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
10925 b
? COMPARE_STRICT
: COMPARE_BASE
| COMPARE_DERIVED
);
10930 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
10931 pointer-to-member types) are the same, ignoring cv-qualification at
10932 all levels. CB says how we should behave when comparing array bounds. */
10935 comp_ptr_ttypes_const (tree to
, tree from
, compare_bounds_t cb
)
10937 bool is_opaque_pointer
= false;
10939 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
10941 if (TREE_CODE (to
) != TREE_CODE (from
))
10944 if (TREE_CODE (from
) == OFFSET_TYPE
10945 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
10946 TYPE_OFFSET_BASETYPE (to
)))
10949 if (VECTOR_TYPE_P (to
))
10950 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
10952 if (TREE_CODE (to
) == ARRAY_TYPE
10953 /* Ignore cv-qualification, but if we see e.g. int[3] and int[4],
10955 && !comp_array_types (to
, from
, cb
, /*strict=*/false))
10958 /* CWG 330 says we need to look through arrays. */
10959 if (!TYPE_PTR_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
10960 return (is_opaque_pointer
10961 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
10965 /* Returns the type qualifiers for this type, including the qualifiers on the
10966 elements for an array type. */
10969 cp_type_quals (const_tree type
)
10972 /* This CONST_CAST is okay because strip_array_types returns its
10973 argument unmodified and we assign it to a const_tree. */
10974 type
= strip_array_types (CONST_CAST_TREE (type
));
10975 if (type
== error_mark_node
10976 /* Quals on a FUNCTION_TYPE are memfn quals. */
10977 || TREE_CODE (type
) == FUNCTION_TYPE
)
10978 return TYPE_UNQUALIFIED
;
10979 quals
= TYPE_QUALS (type
);
10980 /* METHOD and REFERENCE_TYPEs should never have quals. */
10981 gcc_assert ((TREE_CODE (type
) != METHOD_TYPE
10982 && !TYPE_REF_P (type
))
10983 || ((quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
))
10984 == TYPE_UNQUALIFIED
));
10988 /* Returns the function-ref-qualifier for TYPE */
10991 type_memfn_rqual (const_tree type
)
10993 gcc_assert (FUNC_OR_METHOD_TYPE_P (type
));
10995 if (!FUNCTION_REF_QUALIFIED (type
))
10996 return REF_QUAL_NONE
;
10997 else if (FUNCTION_RVALUE_QUALIFIED (type
))
10998 return REF_QUAL_RVALUE
;
11000 return REF_QUAL_LVALUE
;
11003 /* Returns the function-cv-quals for TYPE, which must be a FUNCTION_TYPE or
11007 type_memfn_quals (const_tree type
)
11009 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11010 return TYPE_QUALS (type
);
11011 else if (TREE_CODE (type
) == METHOD_TYPE
)
11012 return cp_type_quals (class_of_this_parm (type
));
11014 gcc_unreachable ();
11017 /* Returns the FUNCTION_TYPE TYPE with its function-cv-quals changed to
11018 MEMFN_QUALS and its ref-qualifier to RQUAL. */
11021 apply_memfn_quals (tree type
, cp_cv_quals memfn_quals
, cp_ref_qualifier rqual
)
11023 /* Could handle METHOD_TYPE here if necessary. */
11024 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
11025 if (TYPE_QUALS (type
) == memfn_quals
11026 && type_memfn_rqual (type
) == rqual
)
11029 /* This should really have a different TYPE_MAIN_VARIANT, but that gets
11031 tree result
= build_qualified_type (type
, memfn_quals
);
11032 return build_ref_qualified_type (result
, rqual
);
11035 /* Returns nonzero if TYPE is const or volatile. */
11038 cv_qualified_p (const_tree type
)
11040 int quals
= cp_type_quals (type
);
11041 return (quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)) != 0;
11044 /* Returns nonzero if the TYPE contains a mutable member. */
11047 cp_has_mutable_p (const_tree type
)
11049 /* This CONST_CAST is okay because strip_array_types returns its
11050 argument unmodified and we assign it to a const_tree. */
11051 type
= strip_array_types (CONST_CAST_TREE(type
));
11053 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
11056 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
11057 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
11058 approximation. In particular, consider:
11061 struct S { int i; };
11062 const S s = { f(); }
11064 Here, we will make "s" as TREE_READONLY (because it is declared
11065 "const") -- only to reverse ourselves upon seeing that the
11066 initializer is non-constant. */
11069 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
11071 tree type
= TREE_TYPE (decl
);
11073 if (type
== error_mark_node
)
11076 if (TREE_CODE (decl
) == TYPE_DECL
)
11079 gcc_assert (!(TREE_CODE (type
) == FUNCTION_TYPE
11080 && type_quals
!= TYPE_UNQUALIFIED
));
11082 /* Avoid setting TREE_READONLY incorrectly. */
11083 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
11084 constructor can produce constant init, so rely on cp_finish_decl to
11085 clear TREE_READONLY if the variable has non-constant init. */
11087 /* If the type has (or might have) a mutable component, that component
11088 might be modified. */
11089 if (TYPE_HAS_MUTABLE_P (type
) || !COMPLETE_TYPE_P (type
))
11090 type_quals
&= ~TYPE_QUAL_CONST
;
11092 c_apply_type_quals_to_decl (type_quals
, decl
);
11095 /* Subroutine of casts_away_constness. Make T1 and T2 point at
11096 exemplar types such that casting T1 to T2 is casting away constness
11097 if and only if there is no implicit conversion from T1 to T2. */
11100 casts_away_constness_r (tree
*t1
, tree
*t2
, tsubst_flags_t complain
)
11105 /* [expr.const.cast]
11107 For multi-level pointer to members and multi-level mixed pointers
11108 and pointers to members (conv.qual), the "member" aspect of a
11109 pointer to member level is ignored when determining if a const
11110 cv-qualifier has been cast away. */
11111 /* [expr.const.cast]
11113 For two pointer types:
11115 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
11116 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
11119 casting from X1 to X2 casts away constness if, for a non-pointer
11120 type T there does not exist an implicit conversion (clause
11123 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
11127 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
11128 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRDATAMEM_P (*t1
))
11129 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRDATAMEM_P (*t2
)))
11131 *t1
= cp_build_qualified_type (void_type_node
,
11132 cp_type_quals (*t1
));
11133 *t2
= cp_build_qualified_type (void_type_node
,
11134 cp_type_quals (*t2
));
11138 quals1
= cp_type_quals (*t1
);
11139 quals2
= cp_type_quals (*t2
);
11141 if (TYPE_PTRDATAMEM_P (*t1
))
11142 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
11144 *t1
= TREE_TYPE (*t1
);
11145 if (TYPE_PTRDATAMEM_P (*t2
))
11146 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
11148 *t2
= TREE_TYPE (*t2
);
11150 casts_away_constness_r (t1
, t2
, complain
);
11151 *t1
= build_pointer_type (*t1
);
11152 *t2
= build_pointer_type (*t2
);
11153 *t1
= cp_build_qualified_type (*t1
, quals1
);
11154 *t2
= cp_build_qualified_type (*t2
, quals2
);
11157 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
11160 ??? This function returns non-zero if casting away qualifiers not
11161 just const. We would like to return to the caller exactly which
11162 qualifiers are casted away to give more accurate diagnostics.
11166 casts_away_constness (tree t1
, tree t2
, tsubst_flags_t complain
)
11168 if (TYPE_REF_P (t2
))
11170 /* [expr.const.cast]
11172 Casting from an lvalue of type T1 to an lvalue of type T2
11173 using a reference cast casts away constness if a cast from an
11174 rvalue of type "pointer to T1" to the type "pointer to T2"
11175 casts away constness. */
11176 t1
= (TYPE_REF_P (t1
) ? TREE_TYPE (t1
) : t1
);
11177 return casts_away_constness (build_pointer_type (t1
),
11178 build_pointer_type (TREE_TYPE (t2
)),
11182 if (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
11183 /* [expr.const.cast]
11185 Casting from an rvalue of type "pointer to data member of X
11186 of type T1" to the type "pointer to data member of Y of type
11187 T2" casts away constness if a cast from an rvalue of type
11188 "pointer to T1" to the type "pointer to T2" casts away
11190 return casts_away_constness
11191 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
11192 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)),
11195 /* Casting away constness is only something that makes sense for
11196 pointer or reference types. */
11197 if (!TYPE_PTR_P (t1
) || !TYPE_PTR_P (t2
))
11200 /* Top-level qualifiers don't matter. */
11201 t1
= TYPE_MAIN_VARIANT (t1
);
11202 t2
= TYPE_MAIN_VARIANT (t2
);
11203 casts_away_constness_r (&t1
, &t2
, complain
);
11204 if (!can_convert (t2
, t1
, complain
))
11210 /* If T is a REFERENCE_TYPE return the type to which T refers.
11211 Otherwise, return T itself. */
11214 non_reference (tree t
)
11216 if (t
&& TYPE_REF_P (t
))
11222 /* Return nonzero if REF is an lvalue valid for this language;
11223 otherwise, print an error message and return zero. USE says
11224 how the lvalue is being used and so selects the error message. */
11227 lvalue_or_else (tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
11229 cp_lvalue_kind kind
= lvalue_kind (ref
);
11231 if (kind
== clk_none
)
11233 if (complain
& tf_error
)
11234 lvalue_error (cp_expr_loc_or_input_loc (ref
), use
);
11237 else if (kind
& (clk_rvalueref
|clk_class
))
11239 if (!(complain
& tf_error
))
11241 /* Make this a permerror because we used to accept it. */
11242 permerror (cp_expr_loc_or_input_loc (ref
),
11243 "using rvalue as lvalue");
11248 /* Return true if a user-defined literal operator is a raw operator. */
11251 check_raw_literal_operator (const_tree decl
)
11253 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11256 bool maybe_raw_p
= false;
11258 /* Count the number and type of arguments and check for ellipsis. */
11259 for (argtype
= argtypes
, arity
= 0;
11260 argtype
&& argtype
!= void_list_node
;
11261 ++arity
, argtype
= TREE_CHAIN (argtype
))
11263 tree t
= TREE_VALUE (argtype
);
11265 if (same_type_p (t
, const_string_type_node
))
11266 maybe_raw_p
= true;
11269 return false; /* Found ellipsis. */
11271 if (!maybe_raw_p
|| arity
!= 1)
11278 /* Return true if a user-defined literal operator has one of the allowed
11282 check_literal_operator_args (const_tree decl
,
11283 bool *long_long_unsigned_p
, bool *long_double_p
)
11285 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11287 *long_long_unsigned_p
= false;
11288 *long_double_p
= false;
11289 if (processing_template_decl
|| processing_specialization
)
11290 return argtypes
== void_list_node
;
11297 /* Count the number and type of arguments and check for ellipsis. */
11298 for (argtype
= argtypes
, arity
= 0;
11299 argtype
&& argtype
!= void_list_node
;
11300 argtype
= TREE_CHAIN (argtype
))
11302 tree t
= TREE_VALUE (argtype
);
11305 if (TYPE_PTR_P (t
))
11307 bool maybe_raw_p
= false;
11309 if (cp_type_quals (t
) != TYPE_QUAL_CONST
)
11311 t
= TYPE_MAIN_VARIANT (t
);
11312 if ((maybe_raw_p
= same_type_p (t
, char_type_node
))
11313 || same_type_p (t
, wchar_type_node
)
11314 || same_type_p (t
, char8_type_node
)
11315 || same_type_p (t
, char16_type_node
)
11316 || same_type_p (t
, char32_type_node
))
11318 argtype
= TREE_CHAIN (argtype
);
11321 t
= TREE_VALUE (argtype
);
11322 if (maybe_raw_p
&& argtype
== void_list_node
)
11324 else if (same_type_p (t
, size_type_node
))
11333 else if (same_type_p (t
, long_long_unsigned_type_node
))
11336 *long_long_unsigned_p
= true;
11338 else if (same_type_p (t
, long_double_type_node
))
11341 *long_double_p
= true;
11343 else if (same_type_p (t
, char_type_node
))
11345 else if (same_type_p (t
, wchar_type_node
))
11347 else if (same_type_p (t
, char8_type_node
))
11349 else if (same_type_p (t
, char16_type_node
))
11351 else if (same_type_p (t
, char32_type_node
))
11357 return false; /* Found ellipsis. */
11359 if (arity
!= max_arity
)
11366 /* Always returns false since unlike C90, C++ has no concept of implicit
11367 function declarations. */
11370 c_decl_implicit (const_tree
)