1 /* Build expressions with type checking for C++ compiler.
2 Copyright (C) 1987-2023 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 (tree value
,
75 tsubst_flags_t complain
/* = tf_warning_or_error */)
79 if (processing_template_decl
|| value
== error_mark_node
)
82 if (TREE_CODE (value
) == OVERLOAD
)
83 type
= unknown_type_node
;
85 type
= TREE_TYPE (value
);
87 if (type
== error_mark_node
)
88 return error_mark_node
;
90 /* First, detect a valid value with a complete type. */
91 if (COMPLETE_TYPE_P (type
))
94 if (complete_type_or_maybe_complain (type
, value
, complain
))
97 return error_mark_node
;
100 /* Try to complete TYPE, if it is incomplete. For example, if TYPE is
101 a template instantiation, do the instantiation. Returns TYPE,
102 whether or not it could be completed, unless something goes
103 horribly wrong, in which case the error_mark_node is returned. */
106 complete_type (tree type
)
108 if (type
== NULL_TREE
)
109 /* Rather than crash, we return something sure to cause an error
111 return error_mark_node
;
113 if (type
== error_mark_node
|| COMPLETE_TYPE_P (type
))
115 else if (TREE_CODE (type
) == ARRAY_TYPE
)
117 tree t
= complete_type (TREE_TYPE (type
));
118 unsigned int needs_constructing
, has_nontrivial_dtor
;
119 if (COMPLETE_TYPE_P (t
) && !dependent_type_p (type
))
122 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t
));
124 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t
));
125 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
127 TYPE_NEEDS_CONSTRUCTING (t
) = needs_constructing
;
128 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = has_nontrivial_dtor
;
131 else if (CLASS_TYPE_P (type
))
134 /* TYPE could be a class member we've not loaded the definition of. */
135 lazy_load_pendings (TYPE_NAME (TYPE_MAIN_VARIANT (type
)));
137 if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
138 instantiate_class_template (TYPE_MAIN_VARIANT (type
));
144 /* Like complete_type, but issue an error if the TYPE cannot be completed.
145 VALUE is used for informative diagnostics.
146 Returns NULL_TREE if the type cannot be made complete. */
149 complete_type_or_maybe_complain (tree type
, tree value
, tsubst_flags_t complain
)
151 type
= complete_type (type
);
152 if (type
== error_mark_node
)
153 /* We already issued an error. */
155 else if (!COMPLETE_TYPE_P (type
))
157 if (complain
& tf_error
)
158 cxx_incomplete_type_diagnostic (value
, type
, DK_ERROR
);
159 note_failed_type_completion_for_satisfaction (type
);
167 complete_type_or_else (tree type
, tree value
)
169 return complete_type_or_maybe_complain (type
, value
, tf_warning_or_error
);
173 /* Return the common type of two parameter lists.
174 We assume that comptypes has already been done and returned 1;
175 if that isn't so, this may crash.
177 As an optimization, free the space we allocate if the parameter
178 lists are already common. */
181 commonparms (tree p1
, tree p2
)
183 tree oldargs
= p1
, newargs
, n
;
187 len
= list_length (p1
);
188 newargs
= tree_last (p1
);
190 if (newargs
== void_list_node
)
199 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
204 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
), i
++)
206 if (TREE_PURPOSE (p1
) && !TREE_PURPOSE (p2
))
208 TREE_PURPOSE (n
) = TREE_PURPOSE (p1
);
211 else if (! TREE_PURPOSE (p1
))
213 if (TREE_PURPOSE (p2
))
215 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
221 if (simple_cst_equal (TREE_PURPOSE (p1
), TREE_PURPOSE (p2
)) != 1)
223 TREE_PURPOSE (n
) = TREE_PURPOSE (p2
);
225 if (TREE_VALUE (p1
) != TREE_VALUE (p2
))
228 TREE_VALUE (n
) = merge_types (TREE_VALUE (p1
), TREE_VALUE (p2
));
231 TREE_VALUE (n
) = TREE_VALUE (p1
);
239 /* Given a type, perhaps copied for a typedef,
240 find the "original" version of it. */
242 original_type (tree t
)
244 int quals
= cp_type_quals (t
);
245 while (t
!= error_mark_node
246 && TYPE_NAME (t
) != NULL_TREE
)
248 tree x
= TYPE_NAME (t
);
249 if (TREE_CODE (x
) != TYPE_DECL
)
251 x
= DECL_ORIGINAL_TYPE (x
);
256 return cp_build_qualified_type (t
, quals
);
259 /* Merge the attributes of type OTHER_TYPE into the attributes of type TYPE
260 and return a variant of TYPE with the merged attributes. */
263 merge_type_attributes_from (tree type
, tree other_type
)
265 tree attrs
= targetm
.merge_type_attributes (type
, other_type
);
266 attrs
= restrict_type_identity_attributes_to (attrs
, TYPE_ATTRIBUTES (type
));
267 return cp_build_type_attribute_variant (type
, attrs
);
270 /* Compare floating point conversion ranks and subranks of T1 and T2
271 types. If T1 and T2 have unordered conversion ranks, return 3.
272 If T1 has greater conversion rank than T2, return 2.
273 If T2 has greater conversion rank than T1, return -2.
274 If T1 has equal conversion rank as T2, return -1, 0 or 1 depending
275 on if T1 has smaller, equal or greater conversion subrank than
279 cp_compare_floating_point_conversion_ranks (tree t1
, tree t2
)
281 tree mv1
= TYPE_MAIN_VARIANT (t1
);
282 tree mv2
= TYPE_MAIN_VARIANT (t2
);
289 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; ++i
)
291 if (mv1
== FLOATN_NX_TYPE_NODE (i
))
293 if (mv2
== FLOATN_NX_TYPE_NODE (i
))
296 if (mv1
== bfloat16_type_node
)
298 if (mv2
== bfloat16_type_node
)
300 if (extended2
&& !extended1
)
302 int ret
= cp_compare_floating_point_conversion_ranks (t2
, t1
);
303 return ret
== 3 ? 3 : -ret
;
306 const struct real_format
*fmt1
= REAL_MODE_FORMAT (TYPE_MODE (t1
));
307 const struct real_format
*fmt2
= REAL_MODE_FORMAT (TYPE_MODE (t2
));
308 gcc_assert (fmt1
->b
== 2 && fmt2
->b
== 2);
309 /* For {ibm,mips}_extended_format formats, the type has variable
310 precision up to ~2150 bits when the first double is around maximum
311 representable double and second double is subnormal minimum.
312 So, e.g. for __ibm128 vs. std::float128_t, they have unordered
314 int p1
= (MODE_COMPOSITE_P (TYPE_MODE (t1
))
315 ? fmt1
->emax
- fmt1
->emin
+ fmt1
->p
- 1 : fmt1
->p
);
316 int p2
= (MODE_COMPOSITE_P (TYPE_MODE (t2
))
317 ? fmt2
->emax
- fmt2
->emin
+ fmt2
->p
- 1 : fmt2
->p
);
318 /* The rank of a floating point type T is greater than the rank of
319 any floating-point type whose set of values is a proper subset
320 of the set of values of T. */
321 if ((p1
> p2
&& fmt1
->emax
>= fmt2
->emax
)
322 || (p1
== p2
&& fmt1
->emax
> fmt2
->emax
))
324 if ((p1
< p2
&& fmt1
->emax
<= fmt2
->emax
)
325 || (p1
== p2
&& fmt1
->emax
< fmt2
->emax
))
327 if ((p1
> p2
&& fmt1
->emax
< fmt2
->emax
)
328 || (p1
< p2
&& fmt1
->emax
> fmt2
->emax
))
330 if (!extended1
&& !extended2
)
332 /* The rank of long double is greater than the rank of double, which
333 is greater than the rank of float. */
334 if (t1
== long_double_type_node
)
336 else if (t2
== long_double_type_node
)
338 if (t1
== double_type_node
)
340 else if (t2
== double_type_node
)
342 if (t1
== float_type_node
)
344 else if (t2
== float_type_node
)
348 /* Two extended floating-point types with the same set of values have equal
350 if (extended1
&& extended2
)
352 if ((extended1
<= NUM_FLOATN_TYPES
) == (extended2
<= NUM_FLOATN_TYPES
))
354 /* Prefer higher extendedN value. */
355 if (extended1
> extended2
)
357 else if (extended1
< extended2
)
362 else if (extended1
<= NUM_FLOATN_TYPES
)
363 /* Prefer _FloatN type over _FloatMx type. */
365 else if (extended2
<= NUM_FLOATN_TYPES
)
371 /* gcc_assert (extended1 && !extended2); */
374 for (p
= &float_type_node
; p
<= &long_double_type_node
; ++p
)
376 const struct real_format
*fmt3
= REAL_MODE_FORMAT (TYPE_MODE (*p
));
377 gcc_assert (fmt3
->b
== 2);
378 int p3
= (MODE_COMPOSITE_P (TYPE_MODE (*p
))
379 ? fmt3
->emax
- fmt3
->emin
+ fmt3
->p
- 1 : fmt3
->p
);
380 if (p1
== p3
&& fmt1
->emax
== fmt3
->emax
)
383 /* An extended floating-point type with the same set of values
384 as exactly one cv-unqualified standard floating-point type
385 has a rank equal to the rank of that standard floating-point
388 An extended floating-point type with the same set of values
389 as more than one cv-unqualified standard floating-point type
390 has a rank equal to the rank of double.
392 Thus, if the latter is true and t2 is long double, t2
394 if (cnt
> 1 && mv2
== long_double_type_node
)
396 /* Otherwise, they have equal rank, but extended types
397 (other than std::bfloat16_t) have higher subrank.
398 std::bfloat16_t shouldn't have equal rank to any standard
399 floating point type. */
403 /* Return the common type for two arithmetic types T1 and T2 under the
404 usual arithmetic conversions. The default conversions have already
405 been applied, and enumerated types converted to their compatible
409 cp_common_type (tree t1
, tree t2
)
411 enum tree_code code1
= TREE_CODE (t1
);
412 enum tree_code code2
= TREE_CODE (t2
);
417 /* In what follows, we slightly generalize the rules given in [expr] so
418 as to deal with `long long' and `complex'. First, merge the
420 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
422 if (SCOPED_ENUM_P (t1
) || SCOPED_ENUM_P (t2
))
424 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
425 return build_type_attribute_variant (t1
, attributes
);
430 /* FIXME: Attributes. */
431 gcc_assert (ARITHMETIC_TYPE_P (t1
)
432 || VECTOR_TYPE_P (t1
)
433 || UNSCOPED_ENUM_P (t1
));
434 gcc_assert (ARITHMETIC_TYPE_P (t2
)
435 || VECTOR_TYPE_P (t2
)
436 || UNSCOPED_ENUM_P (t2
));
438 /* If one type is complex, form the common type of the non-complex
439 components, then make that complex. Use T1 or T2 if it is the
441 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
443 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
444 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
446 = type_after_usual_arithmetic_conversions (subtype1
, subtype2
);
448 if (subtype
== error_mark_node
)
450 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
451 return build_type_attribute_variant (t1
, attributes
);
452 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
453 return build_type_attribute_variant (t2
, attributes
);
455 return build_type_attribute_variant (build_complex_type (subtype
),
459 if (code1
== VECTOR_TYPE
)
461 /* When we get here we should have two vectors of the same size.
462 Just prefer the unsigned one if present. */
463 if (TYPE_UNSIGNED (t1
))
464 return merge_type_attributes_from (t1
, t2
);
466 return merge_type_attributes_from (t2
, t1
);
469 /* If only one is real, use it as the result. */
470 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
471 return build_type_attribute_variant (t1
, attributes
);
472 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
473 return build_type_attribute_variant (t2
, attributes
);
475 if (code1
== REAL_TYPE
476 && (extended_float_type_p (t1
) || extended_float_type_p (t2
)))
478 tree mv1
= TYPE_MAIN_VARIANT (t1
);
479 tree mv2
= TYPE_MAIN_VARIANT (t2
);
481 return build_type_attribute_variant (t1
, attributes
);
483 int cmpret
= cp_compare_floating_point_conversion_ranks (mv1
, mv2
);
485 return error_mark_node
;
486 else if (cmpret
>= 0)
487 return build_type_attribute_variant (t1
, attributes
);
489 return build_type_attribute_variant (t2
, attributes
);
492 /* Both real or both integers; use the one with greater precision. */
493 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
494 return build_type_attribute_variant (t1
, attributes
);
495 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
496 return build_type_attribute_variant (t2
, attributes
);
498 /* The types are the same; no need to do anything fancy. */
499 if (TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
500 return build_type_attribute_variant (t1
, attributes
);
502 if (code1
!= REAL_TYPE
)
504 /* If one is unsigned long long, then convert the other to unsigned
506 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_unsigned_type_node
)
507 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_unsigned_type_node
))
508 return build_type_attribute_variant (long_long_unsigned_type_node
,
510 /* If one is a long long, and the other is an unsigned long, and
511 long long can represent all the values of an unsigned long, then
512 convert to a long long. Otherwise, convert to an unsigned long
513 long. Otherwise, if either operand is long long, convert the
516 Since we're here, we know the TYPE_PRECISION is the same;
517 therefore converting to long long cannot represent all the values
518 of an unsigned long, so we choose unsigned long long in that
520 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_long_integer_type_node
)
521 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_long_integer_type_node
))
523 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
524 ? long_long_unsigned_type_node
525 : long_long_integer_type_node
);
526 return build_type_attribute_variant (t
, attributes
);
529 /* Go through the same procedure, but for longs. */
530 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_unsigned_type_node
)
531 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_unsigned_type_node
))
532 return build_type_attribute_variant (long_unsigned_type_node
,
534 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_integer_type_node
)
535 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_integer_type_node
))
537 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
538 ? long_unsigned_type_node
: long_integer_type_node
);
539 return build_type_attribute_variant (t
, attributes
);
542 /* For __intN types, either the type is __int128 (and is lower
543 priority than the types checked above, but higher than other
544 128-bit types) or it's known to not be the same size as other
545 types (enforced in toplev.cc). Prefer the unsigned type. */
546 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
548 if (int_n_enabled_p
[i
]
549 && (same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].signed_type
)
550 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].signed_type
)
551 || same_type_p (TYPE_MAIN_VARIANT (t1
), int_n_trees
[i
].unsigned_type
)
552 || same_type_p (TYPE_MAIN_VARIANT (t2
), int_n_trees
[i
].unsigned_type
)))
554 tree t
= ((TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
555 ? int_n_trees
[i
].unsigned_type
556 : int_n_trees
[i
].signed_type
);
557 return build_type_attribute_variant (t
, attributes
);
561 /* Otherwise prefer the unsigned one. */
562 if (TYPE_UNSIGNED (t1
))
563 return build_type_attribute_variant (t1
, attributes
);
565 return build_type_attribute_variant (t2
, attributes
);
569 if (same_type_p (TYPE_MAIN_VARIANT (t1
), long_double_type_node
)
570 || same_type_p (TYPE_MAIN_VARIANT (t2
), long_double_type_node
))
571 return build_type_attribute_variant (long_double_type_node
,
573 if (same_type_p (TYPE_MAIN_VARIANT (t1
), double_type_node
)
574 || same_type_p (TYPE_MAIN_VARIANT (t2
), double_type_node
))
575 return build_type_attribute_variant (double_type_node
,
577 if (same_type_p (TYPE_MAIN_VARIANT (t1
), float_type_node
)
578 || same_type_p (TYPE_MAIN_VARIANT (t2
), float_type_node
))
579 return build_type_attribute_variant (float_type_node
,
582 /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
583 the standard C++ floating-point types. Logic earlier in this
584 function has already eliminated the possibility that
585 TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
586 compelling reason to choose one or the other. */
587 return build_type_attribute_variant (t1
, attributes
);
591 /* T1 and T2 are arithmetic or enumeration types. Return the type
592 that will result from the "usual arithmetic conversions" on T1 and
593 T2 as described in [expr]. */
596 type_after_usual_arithmetic_conversions (tree t1
, tree t2
)
598 gcc_assert (ARITHMETIC_TYPE_P (t1
)
599 || VECTOR_TYPE_P (t1
)
600 || UNSCOPED_ENUM_P (t1
));
601 gcc_assert (ARITHMETIC_TYPE_P (t2
)
602 || VECTOR_TYPE_P (t2
)
603 || UNSCOPED_ENUM_P (t2
));
605 /* Perform the integral promotions. We do not promote real types here. */
606 if (INTEGRAL_OR_ENUMERATION_TYPE_P (t1
)
607 && INTEGRAL_OR_ENUMERATION_TYPE_P (t2
))
609 t1
= type_promotes_to (t1
);
610 t2
= type_promotes_to (t2
);
613 return cp_common_type (t1
, t2
);
617 composite_pointer_error (const op_location_t
&location
,
618 diagnostic_t kind
, tree t1
, tree t2
,
619 composite_pointer_operation operation
)
624 emit_diagnostic (kind
, location
, 0,
625 "comparison between "
626 "distinct pointer types %qT and %qT lacks a cast",
630 emit_diagnostic (kind
, location
, 0,
631 "conversion between "
632 "distinct pointer types %qT and %qT lacks a cast",
635 case CPO_CONDITIONAL_EXPR
:
636 emit_diagnostic (kind
, location
, 0,
637 "conditional expression between "
638 "distinct pointer types %qT and %qT lacks a cast",
646 /* Subroutine of composite_pointer_type to implement the recursive
647 case. See that function for documentation of the parameters. And ADD_CONST
648 is used to track adding "const" where needed. */
651 composite_pointer_type_r (const op_location_t
&location
,
652 tree t1
, tree t2
, bool *add_const
,
653 composite_pointer_operation operation
,
654 tsubst_flags_t complain
)
661 /* Determine the types pointed to by T1 and T2. */
664 pointee1
= TREE_TYPE (t1
);
665 pointee2
= TREE_TYPE (t2
);
669 pointee1
= TYPE_PTRMEM_POINTED_TO_TYPE (t1
);
670 pointee2
= TYPE_PTRMEM_POINTED_TO_TYPE (t2
);
675 If T1 and T2 are similar types, the result is the cv-combined type of
677 if (same_type_ignoring_top_level_qualifiers_p (pointee1
, pointee2
))
678 result_type
= pointee1
;
679 else if ((TYPE_PTR_P (pointee1
) && TYPE_PTR_P (pointee2
))
680 || (TYPE_PTRMEM_P (pointee1
) && TYPE_PTRMEM_P (pointee2
)))
682 result_type
= composite_pointer_type_r (location
, pointee1
, pointee2
,
683 add_const
, operation
, complain
);
684 if (result_type
== error_mark_node
)
685 return error_mark_node
;
689 if (complain
& tf_error
)
690 composite_pointer_error (location
, DK_PERMERROR
,
693 return error_mark_node
;
694 result_type
= void_type_node
;
696 const int q1
= cp_type_quals (pointee1
);
697 const int q2
= cp_type_quals (pointee2
);
698 const int quals
= q1
| q2
;
699 result_type
= cp_build_qualified_type (result_type
,
702 : TYPE_UNQUALIFIED
)));
703 /* The cv-combined type can add "const" as per [conv.qual]/3.3 (except for
704 the TLQ). The reason is that both T1 and T2 can then be converted to the
705 cv-combined type of T1 and T2. */
706 if (quals
!= q1
|| quals
!= q2
)
708 /* If the original types were pointers to members, so is the
710 if (TYPE_PTRMEM_P (t1
))
712 if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
713 TYPE_PTRMEM_CLASS_TYPE (t2
)))
715 if (complain
& tf_error
)
716 composite_pointer_error (location
, DK_PERMERROR
,
719 return error_mark_node
;
721 result_type
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
725 result_type
= build_pointer_type (result_type
);
727 /* Merge the attributes. */
728 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
729 return build_type_attribute_variant (result_type
, attributes
);
732 /* Return the composite pointer type (see [expr.type]) for T1 and T2.
733 ARG1 and ARG2 are the values with those types. The OPERATION is to
734 describe the operation between the pointer types,
735 in case an error occurs.
737 This routine also implements the computation of a common type for
738 pointers-to-members as per [expr.eq]. */
741 composite_pointer_type (const op_location_t
&location
,
742 tree t1
, tree t2
, tree arg1
, tree arg2
,
743 composite_pointer_operation operation
,
744 tsubst_flags_t complain
)
751 If one operand is a null pointer constant, the composite pointer
752 type is the type of the other operand. */
753 if (null_ptr_cst_p (arg1
))
755 if (null_ptr_cst_p (arg2
))
762 If one of the operands has type "pointer to cv1 void", then
763 the other has type "pointer to cv2 T", and the composite pointer
764 type is "pointer to cv12 void", where cv12 is the union of cv1
767 If either type is a pointer to void, make sure it is T1. */
768 if (TYPE_PTR_P (t2
) && VOID_TYPE_P (TREE_TYPE (t2
)))
771 /* Now, if T1 is a pointer to void, merge the qualifiers. */
772 if (TYPE_PTR_P (t1
) && VOID_TYPE_P (TREE_TYPE (t1
)))
777 if (TYPE_PTRFN_P (t2
))
779 if (complain
& tf_error
)
784 pedwarn (location
, OPT_Wpedantic
,
785 "ISO C++ forbids comparison between pointer "
786 "of type %<void *%> and pointer-to-function");
789 pedwarn (location
, OPT_Wpedantic
,
790 "ISO C++ forbids conversion between pointer "
791 "of type %<void *%> and pointer-to-function");
793 case CPO_CONDITIONAL_EXPR
:
794 pedwarn (location
, OPT_Wpedantic
,
795 "ISO C++ forbids conditional expression between "
796 "pointer of type %<void *%> and "
797 "pointer-to-function");
804 return error_mark_node
;
807 = cp_build_qualified_type (void_type_node
,
808 (cp_type_quals (TREE_TYPE (t1
))
809 | cp_type_quals (TREE_TYPE (t2
))));
810 result_type
= build_pointer_type (result_type
);
811 /* Merge the attributes. */
812 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
813 return build_type_attribute_variant (result_type
, attributes
);
816 if (c_dialect_objc () && TYPE_PTR_P (t1
)
819 if (objc_have_common_type (t1
, t2
, -3, NULL_TREE
))
820 return objc_common_type (t1
, t2
);
823 /* if T1 or T2 is "pointer to noexcept function" and the other type is
824 "pointer to function", where the function types are otherwise the same,
825 "pointer to function" */
826 if (fnptr_conv_p (t1
, t2
))
828 if (fnptr_conv_p (t2
, t1
))
831 /* [expr.eq] permits the application of a pointer conversion to
832 bring the pointers to a common type. */
833 if (TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
)
834 && CLASS_TYPE_P (TREE_TYPE (t1
))
835 && CLASS_TYPE_P (TREE_TYPE (t2
))
836 && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1
),
839 class1
= TREE_TYPE (t1
);
840 class2
= TREE_TYPE (t2
);
842 if (DERIVED_FROM_P (class1
, class2
))
843 t2
= (build_pointer_type
844 (cp_build_qualified_type (class1
, cp_type_quals (class2
))));
845 else if (DERIVED_FROM_P (class2
, class1
))
846 t1
= (build_pointer_type
847 (cp_build_qualified_type (class2
, cp_type_quals (class1
))));
850 if (complain
& tf_error
)
851 composite_pointer_error (location
, DK_ERROR
, t1
, t2
, operation
);
852 return error_mark_node
;
855 /* [expr.eq] permits the application of a pointer-to-member
856 conversion to change the class type of one of the types. */
857 else if (TYPE_PTRMEM_P (t1
)
858 && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1
),
859 TYPE_PTRMEM_CLASS_TYPE (t2
)))
861 class1
= TYPE_PTRMEM_CLASS_TYPE (t1
);
862 class2
= TYPE_PTRMEM_CLASS_TYPE (t2
);
864 if (DERIVED_FROM_P (class1
, class2
))
865 t1
= build_ptrmem_type (class2
, TYPE_PTRMEM_POINTED_TO_TYPE (t1
));
866 else if (DERIVED_FROM_P (class2
, class1
))
867 t2
= build_ptrmem_type (class1
, TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
870 if (complain
& tf_error
)
874 error_at (location
, "comparison between distinct "
875 "pointer-to-member types %qT and %qT lacks a cast",
879 error_at (location
, "conversion between distinct "
880 "pointer-to-member types %qT and %qT lacks a cast",
883 case CPO_CONDITIONAL_EXPR
:
884 error_at (location
, "conditional expression between distinct "
885 "pointer-to-member types %qT and %qT lacks a cast",
891 return error_mark_node
;
895 bool add_const
= false;
896 return composite_pointer_type_r (location
, t1
, t2
, &add_const
, operation
,
900 /* Return the merged type of two types.
901 We assume that comptypes has already been done and returned 1;
902 if that isn't so, this may crash.
904 This just combines attributes and default arguments; any other
905 differences would cause the two types to compare unalike. */
908 merge_types (tree t1
, tree t2
)
910 enum tree_code code1
;
911 enum tree_code code2
;
914 /* Save time if the two types are the same. */
917 if (original_type (t1
) == original_type (t2
))
920 /* If one type is nonsense, use the other. */
921 if (t1
== error_mark_node
)
923 if (t2
== error_mark_node
)
926 /* Handle merging an auto redeclaration with a previous deduced
931 /* Merge the attributes. */
932 attributes
= (*targetm
.merge_type_attributes
) (t1
, t2
);
934 if (TYPE_PTRMEMFUNC_P (t1
))
935 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
936 if (TYPE_PTRMEMFUNC_P (t2
))
937 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
939 code1
= TREE_CODE (t1
);
940 code2
= TREE_CODE (t2
);
943 gcc_assert (code1
== TYPENAME_TYPE
|| code2
== TYPENAME_TYPE
);
944 if (code1
== TYPENAME_TYPE
)
946 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
947 code1
= TREE_CODE (t1
);
951 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
952 code2
= TREE_CODE (t2
);
960 /* For two pointers, do this recursively on the target type. */
962 tree target
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
963 int quals
= cp_type_quals (t1
);
965 if (code1
== POINTER_TYPE
)
967 t1
= build_pointer_type (target
);
968 if (TREE_CODE (target
) == METHOD_TYPE
)
969 t1
= build_ptrmemfunc_type (t1
);
972 t1
= cp_build_reference_type (target
, TYPE_REF_IS_RVALUE (t1
));
973 t1
= build_type_attribute_variant (t1
, attributes
);
974 t1
= cp_build_qualified_type (t1
, quals
);
983 quals
= cp_type_quals (t1
);
984 pointee
= merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1
),
985 TYPE_PTRMEM_POINTED_TO_TYPE (t2
));
986 t1
= build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1
),
988 t1
= cp_build_qualified_type (t1
, quals
);
994 tree elt
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
995 /* Save space: see if the result is identical to one of the args. */
996 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
))
997 return build_type_attribute_variant (t1
, attributes
);
998 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
))
999 return build_type_attribute_variant (t2
, attributes
);
1000 /* Merge the element types, and have a size if either arg has one. */
1001 t1
= build_cplus_array_type
1002 (elt
, TYPE_DOMAIN (TYPE_DOMAIN (t1
) ? t1
: t2
));
1007 /* Function types: prefer the one that specified arg types.
1008 If both do, merge the arg types. Also merge the return types. */
1010 tree valtype
= merge_types (TREE_TYPE (t1
), TREE_TYPE (t2
));
1011 tree p1
= TYPE_ARG_TYPES (t1
);
1012 tree p2
= TYPE_ARG_TYPES (t2
);
1015 /* Save space: see if the result is identical to one of the args. */
1016 if (valtype
== TREE_TYPE (t1
) && ! p2
)
1017 return cp_build_type_attribute_variant (t1
, attributes
);
1018 if (valtype
== TREE_TYPE (t2
) && ! p1
)
1019 return cp_build_type_attribute_variant (t2
, attributes
);
1021 /* Simple way if one arg fails to specify argument types. */
1022 if (p1
== NULL_TREE
|| TREE_VALUE (p1
) == void_type_node
)
1024 else if (p2
== NULL_TREE
|| TREE_VALUE (p2
) == void_type_node
)
1027 parms
= commonparms (p1
, p2
);
1029 cp_cv_quals quals
= type_memfn_quals (t1
);
1030 cp_ref_qualifier rqual
= type_memfn_rqual (t1
);
1031 gcc_assert (quals
== type_memfn_quals (t2
));
1032 gcc_assert (rqual
== type_memfn_rqual (t2
));
1034 tree rval
= build_function_type (valtype
, parms
);
1035 rval
= apply_memfn_quals (rval
, quals
);
1036 tree raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
1037 TYPE_RAISES_EXCEPTIONS (t2
));
1038 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
1039 t1
= build_cp_fntype_variant (rval
, rqual
, raises
, late_return_type_p
);
1045 /* Get this value the long way, since TYPE_METHOD_BASETYPE
1046 is just the main variant of this. */
1047 tree basetype
= class_of_this_parm (t2
);
1048 tree raises
= merge_exception_specifiers (TYPE_RAISES_EXCEPTIONS (t1
),
1049 TYPE_RAISES_EXCEPTIONS (t2
));
1050 cp_ref_qualifier rqual
= type_memfn_rqual (t1
);
1052 bool late_return_type_1_p
= TYPE_HAS_LATE_RETURN_TYPE (t1
);
1054 /* If this was a member function type, get back to the
1055 original type of type member function (i.e., without
1056 the class instance variable up front. */
1057 t1
= build_function_type (TREE_TYPE (t1
),
1058 TREE_CHAIN (TYPE_ARG_TYPES (t1
)));
1059 t2
= build_function_type (TREE_TYPE (t2
),
1060 TREE_CHAIN (TYPE_ARG_TYPES (t2
)));
1061 t3
= merge_types (t1
, t2
);
1062 t3
= build_method_type_directly (basetype
, TREE_TYPE (t3
),
1063 TYPE_ARG_TYPES (t3
));
1064 t1
= build_cp_fntype_variant (t3
, rqual
, raises
, late_return_type_1_p
);
1069 /* There is no need to merge attributes into a TYPENAME_TYPE.
1070 When the type is instantiated it will have whatever
1071 attributes result from the instantiation. */
1075 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
1077 else if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
1082 return cp_build_type_attribute_variant (t1
, attributes
);
1085 /* Return the ARRAY_TYPE type without its domain. */
1088 strip_array_domain (tree type
)
1091 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
1092 if (TYPE_DOMAIN (type
) == NULL_TREE
)
1094 t2
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
1095 return cp_build_type_attribute_variant (t2
, TYPE_ATTRIBUTES (type
));
1098 /* Wrapper around cp_common_type that is used by c-common.cc and other
1099 front end optimizations that remove promotions.
1101 Return the common type for two arithmetic types T1 and T2 under the
1102 usual arithmetic conversions. The default conversions have already
1103 been applied, and enumerated types converted to their compatible
1107 common_type (tree t1
, tree t2
)
1109 /* If one type is nonsense, use the other */
1110 if (t1
== error_mark_node
)
1112 if (t2
== error_mark_node
)
1115 return cp_common_type (t1
, t2
);
1118 /* Return the common type of two pointer types T1 and T2. This is the
1119 type for the result of most arithmetic operations if the operands
1120 have the given two types.
1122 We assume that comp_target_types has already been done and returned
1123 nonzero; if that isn't so, this may crash. */
1126 common_pointer_type (tree t1
, tree t2
)
1128 gcc_assert ((TYPE_PTR_P (t1
) && TYPE_PTR_P (t2
))
1129 || (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
1130 || (TYPE_PTRMEMFUNC_P (t1
) && TYPE_PTRMEMFUNC_P (t2
)));
1132 return composite_pointer_type (input_location
, t1
, t2
,
1133 error_mark_node
, error_mark_node
,
1134 CPO_CONVERSION
, tf_warning_or_error
);
1137 /* Compare two exception specifier types for exactness or subsetness, if
1138 allowed. Returns false for mismatch, true for match (same, or
1139 derived and !exact).
1141 [except.spec] "If a class X ... objects of class X or any class publicly
1142 and unambiguously derived from X. Similarly, if a pointer type Y * ...
1143 exceptions of type Y * or that are pointers to any type publicly and
1144 unambiguously derived from Y. Otherwise a function only allows exceptions
1145 that have the same type ..."
1146 This does not mention cv qualifiers and is different to what throw
1147 [except.throw] and catch [except.catch] will do. They will ignore the
1148 top level cv qualifiers, and allow qualifiers in the pointer to class
1151 We implement the letter of the standard. */
1154 comp_except_types (tree a
, tree b
, bool exact
)
1156 if (same_type_p (a
, b
))
1160 if (cp_type_quals (a
) || cp_type_quals (b
))
1163 if (TYPE_PTR_P (a
) && TYPE_PTR_P (b
))
1167 if (cp_type_quals (a
) || cp_type_quals (b
))
1171 if (TREE_CODE (a
) != RECORD_TYPE
1172 || TREE_CODE (b
) != RECORD_TYPE
)
1175 if (publicly_uniquely_derived_p (a
, b
))
1181 /* Return true if TYPE1 and TYPE2 are equivalent exception specifiers.
1182 If EXACT is ce_derived, T2 can be stricter than T1 (according to 15.4/5).
1183 If EXACT is ce_type, the C++17 type compatibility rules apply.
1184 If EXACT is ce_normal, the compatibility rules in 15.4/3 apply.
1185 If EXACT is ce_exact, the specs must be exactly the same. Exception lists
1186 are unordered, but we've already filtered out duplicates. Most lists will
1187 be in order, we should try to make use of that. */
1190 comp_except_specs (const_tree t1
, const_tree t2
, int exact
)
1199 /* First handle noexcept. */
1200 if (exact
< ce_exact
)
1202 if (exact
== ce_type
1203 && (canonical_eh_spec (CONST_CAST_TREE (t1
))
1204 == canonical_eh_spec (CONST_CAST_TREE (t2
))))
1207 /* noexcept(false) is compatible with no exception-specification,
1208 and less strict than any spec. */
1209 if (t1
== noexcept_false_spec
)
1210 return t2
== NULL_TREE
|| exact
== ce_derived
;
1211 /* Even a derived noexcept(false) is compatible with no
1212 exception-specification. */
1213 if (t2
== noexcept_false_spec
)
1214 return t1
== NULL_TREE
;
1216 /* Otherwise, if we aren't looking for an exact match, noexcept is
1217 equivalent to throw(). */
1218 if (t1
== noexcept_true_spec
)
1219 t1
= empty_except_spec
;
1220 if (t2
== noexcept_true_spec
)
1221 t2
= empty_except_spec
;
1224 /* If any noexcept is left, it is only comparable to itself;
1225 either we're looking for an exact match or we're redeclaring a
1226 template with dependent noexcept. */
1227 if ((t1
&& TREE_PURPOSE (t1
))
1228 || (t2
&& TREE_PURPOSE (t2
)))
1230 && cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)));
1232 if (t1
== NULL_TREE
) /* T1 is ... */
1233 return t2
== NULL_TREE
|| exact
== ce_derived
;
1234 if (!TREE_VALUE (t1
)) /* t1 is EMPTY */
1235 return t2
!= NULL_TREE
&& !TREE_VALUE (t2
);
1236 if (t2
== NULL_TREE
) /* T2 is ... */
1238 if (TREE_VALUE (t1
) && !TREE_VALUE (t2
)) /* T2 is EMPTY, T1 is not */
1239 return exact
== ce_derived
;
1241 /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
1242 Count how many we find, to determine exactness. For exact matching and
1243 ordered T1, T2, this is an O(n) operation, otherwise its worst case is
1245 for (base
= t1
; t2
!= NULL_TREE
; t2
= TREE_CHAIN (t2
))
1247 for (probe
= base
; probe
!= NULL_TREE
; probe
= TREE_CHAIN (probe
))
1249 tree a
= TREE_VALUE (probe
);
1250 tree b
= TREE_VALUE (t2
);
1252 if (comp_except_types (a
, b
, exact
))
1254 if (probe
== base
&& exact
> ce_derived
)
1255 base
= TREE_CHAIN (probe
);
1260 if (probe
== NULL_TREE
)
1263 return exact
== ce_derived
|| base
== NULL_TREE
|| length
== list_length (t1
);
1266 /* Compare the array types T1 and T2. CB says how we should behave when
1267 comparing array bounds: bounds_none doesn't allow dimensionless arrays,
1268 bounds_either says than any array can be [], bounds_first means that
1269 onlt T1 can be an array with unknown bounds. STRICT is true if
1270 qualifiers must match when comparing the types of the array elements. */
1273 comp_array_types (const_tree t1
, const_tree t2
, compare_bounds_t cb
,
1283 /* The type of the array elements must be the same. */
1285 ? !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1286 : !similar_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1289 d1
= TYPE_DOMAIN (t1
);
1290 d2
= TYPE_DOMAIN (t2
);
1295 /* If one of the arrays is dimensionless, and the other has a
1296 dimension, they are of different types. However, it is valid to
1304 declarations for an array object can specify
1305 array types that differ by the presence or absence of a major
1306 array bound (_dcl.array_). */
1308 return cb
>= bounds_either
;
1310 return cb
== bounds_either
;
1312 /* Check that the dimensions are the same. */
1314 if (!cp_tree_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
)))
1316 max1
= TYPE_MAX_VALUE (d1
);
1317 max2
= TYPE_MAX_VALUE (d2
);
1319 if (!cp_tree_equal (max1
, max2
))
1325 /* Compare the relative position of T1 and T2 into their respective
1326 template parameter list.
1327 T1 and T2 must be template parameter types.
1328 Return TRUE if T1 and T2 have the same position, FALSE otherwise. */
1331 comp_template_parms_position (tree t1
, tree t2
)
1333 tree index1
, index2
;
1334 gcc_assert (t1
&& t2
1335 && TREE_CODE (t1
) == TREE_CODE (t2
)
1336 && (TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
1337 || TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
1338 || TREE_CODE (t1
) == TEMPLATE_TYPE_PARM
));
1340 index1
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t1
));
1341 index2
= TEMPLATE_TYPE_PARM_INDEX (TYPE_MAIN_VARIANT (t2
));
1343 /* Then compare their relative position. */
1344 if (TEMPLATE_PARM_IDX (index1
) != TEMPLATE_PARM_IDX (index2
)
1345 || TEMPLATE_PARM_LEVEL (index1
) != TEMPLATE_PARM_LEVEL (index2
)
1346 || (TEMPLATE_PARM_PARAMETER_PACK (index1
)
1347 != TEMPLATE_PARM_PARAMETER_PACK (index2
)))
1350 /* In C++14 we can end up comparing 'auto' to a normal template
1351 parameter. Don't confuse them. */
1352 if (cxx_dialect
>= cxx14
&& (is_auto (t1
) || is_auto (t2
)))
1353 return TYPE_IDENTIFIER (t1
) == TYPE_IDENTIFIER (t2
);
1358 /* Heuristic check if two parameter types can be considered ABI-equivalent. */
1361 cxx_safe_arg_type_equiv_p (tree t1
, tree t2
)
1363 t1
= TYPE_MAIN_VARIANT (t1
);
1364 t2
= TYPE_MAIN_VARIANT (t2
);
1370 /* The signedness of the parameter matters only when an integral
1371 type smaller than int is promoted to int, otherwise only the
1372 precision of the parameter matters.
1373 This check should make sure that the callee does not see
1374 undefined values in argument registers. */
1375 if (INTEGRAL_TYPE_P (t1
)
1376 && INTEGRAL_TYPE_P (t2
)
1377 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
)
1378 && (TYPE_UNSIGNED (t1
) == TYPE_UNSIGNED (t2
)
1379 || !targetm
.calls
.promote_prototypes (NULL_TREE
)
1380 || TYPE_PRECISION (t1
) >= TYPE_PRECISION (integer_type_node
)))
1383 return same_type_p (t1
, t2
);
1386 /* Check if a type cast between two function types can be considered safe. */
1389 cxx_safe_function_type_cast_p (tree t1
, tree t2
)
1391 if (TREE_TYPE (t1
) == void_type_node
&&
1392 TYPE_ARG_TYPES (t1
) == void_list_node
)
1395 if (TREE_TYPE (t2
) == void_type_node
&&
1396 TYPE_ARG_TYPES (t2
) == void_list_node
)
1399 if (!cxx_safe_arg_type_equiv_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1402 for (t1
= TYPE_ARG_TYPES (t1
), t2
= TYPE_ARG_TYPES (t2
);
1404 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1405 if (!cxx_safe_arg_type_equiv_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1411 /* Subroutine in comptypes. */
1414 structural_comptypes (tree t1
, tree t2
, int strict
)
1416 /* Both should be types that are not obviously the same. */
1417 gcc_checking_assert (t1
!= t2
&& TYPE_P (t1
) && TYPE_P (t2
));
1419 /* Suppress typename resolution under spec_hasher::equal in place of calling
1420 push_to_top_level there. */
1421 if (!comparing_specializations
)
1423 /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
1424 current instantiation. */
1425 if (TREE_CODE (t1
) == TYPENAME_TYPE
)
1426 t1
= resolve_typename_type (t1
, /*only_current_p=*/true);
1428 if (TREE_CODE (t2
) == TYPENAME_TYPE
)
1429 t2
= resolve_typename_type (t2
, /*only_current_p=*/true);
1432 if (TYPE_PTRMEMFUNC_P (t1
))
1433 t1
= TYPE_PTRMEMFUNC_FN_TYPE (t1
);
1434 if (TYPE_PTRMEMFUNC_P (t2
))
1435 t2
= TYPE_PTRMEMFUNC_FN_TYPE (t2
);
1437 /* Different classes of types can't be compatible. */
1438 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1441 /* Qualifiers must match. For array types, we will check when we
1442 recur on the array element types. */
1443 if (TREE_CODE (t1
) != ARRAY_TYPE
1444 && cp_type_quals (t1
) != cp_type_quals (t2
))
1446 if (TREE_CODE (t1
) == FUNCTION_TYPE
1447 && type_memfn_quals (t1
) != type_memfn_quals (t2
))
1449 /* Need to check this before TYPE_MAIN_VARIANT.
1450 FIXME function qualifiers should really change the main variant. */
1451 if (FUNC_OR_METHOD_TYPE_P (t1
))
1453 if (type_memfn_rqual (t1
) != type_memfn_rqual (t2
))
1455 if (flag_noexcept_type
1456 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (t1
),
1457 TYPE_RAISES_EXCEPTIONS (t2
),
1462 /* Allow for two different type nodes which have essentially the same
1463 definition. Note that we already checked for equality of the type
1464 qualifiers (just above). */
1465 if (TREE_CODE (t1
) != ARRAY_TYPE
1466 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1469 /* Compare the types. Return false on known not-same. Break on not
1470 known. Never return true from this switch -- you'll break
1471 specialization comparison. */
1472 switch (TREE_CODE (t1
))
1476 /* All void and bool types are the same. */
1481 case FIXED_POINT_TYPE
:
1483 /* With these nodes, we can't determine type equivalence by
1484 looking at what is stored in the nodes themselves, because
1485 two nodes might have different TYPE_MAIN_VARIANTs but still
1486 represent the same type. For example, wchar_t and int could
1487 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1488 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1489 and are distinct types. On the other hand, int and the
1492 typedef int INT __attribute((may_alias));
1494 have identical properties, different TYPE_MAIN_VARIANTs, but
1495 represent the same type. The canonical type system keeps
1496 track of equivalence in this case, so we fall back on it. */
1497 if (TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1500 /* We don't need or want the attribute comparison. */
1503 case TEMPLATE_TEMPLATE_PARM
:
1504 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1505 if (!comp_template_parms_position (t1
, t2
))
1507 if (!comp_template_parms
1508 (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1
)),
1509 DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2
))))
1511 if (TREE_CODE (t1
) == TEMPLATE_TEMPLATE_PARM
)
1513 /* Don't check inheritance. */
1514 strict
= COMPARE_STRICT
;
1519 if (TYPE_TEMPLATE_INFO (t1
) && TYPE_TEMPLATE_INFO (t2
)
1520 && (TYPE_TI_TEMPLATE (t1
) == TYPE_TI_TEMPLATE (t2
)
1521 || TREE_CODE (t1
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
1522 && comp_template_args (TYPE_TI_ARGS (t1
), TYPE_TI_ARGS (t2
)))
1525 if ((strict
& COMPARE_BASE
) && DERIVED_FROM_P (t1
, t2
))
1527 else if ((strict
& COMPARE_DERIVED
) && DERIVED_FROM_P (t2
, t1
))
1533 if (!comptypes (TYPE_OFFSET_BASETYPE (t1
), TYPE_OFFSET_BASETYPE (t2
),
1534 strict
& ~COMPARE_REDECLARATION
))
1536 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1540 case REFERENCE_TYPE
:
1541 if (TYPE_REF_IS_RVALUE (t1
) != TYPE_REF_IS_RVALUE (t2
))
1543 /* fall through to checks for pointer types */
1547 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1548 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1554 /* Exception specs and memfn_rquals were checked above. */
1555 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1557 if (!compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
)))
1562 /* Target types must match incl. qualifiers. */
1563 if (!comp_array_types (t1
, t2
, ((strict
& COMPARE_REDECLARATION
)
1564 ? bounds_either
: bounds_none
),
1569 case TEMPLATE_TYPE_PARM
:
1570 /* If T1 and T2 don't have the same relative position in their
1571 template parameters set, they can't be equal. */
1572 if (!comp_template_parms_position (t1
, t2
))
1574 /* If T1 and T2 don't represent the same class template deduction,
1575 they aren't equal. */
1576 if (CLASS_PLACEHOLDER_TEMPLATE (t1
)
1577 != CLASS_PLACEHOLDER_TEMPLATE (t2
))
1579 /* Constrained 'auto's are distinct from parms that don't have the same
1581 if (!equivalent_placeholder_constraints (t1
, t2
))
1586 if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1
),
1587 TYPENAME_TYPE_FULLNAME (t2
)))
1589 /* Qualifiers don't matter on scopes. */
1590 if (!same_type_ignoring_top_level_qualifiers_p (TYPE_CONTEXT (t1
),
1595 case UNBOUND_CLASS_TEMPLATE
:
1596 if (!cp_tree_equal (TYPE_IDENTIFIER (t1
), TYPE_IDENTIFIER (t2
)))
1598 if (!same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
)))
1603 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1608 if (gnu_vector_type_p (t1
) != gnu_vector_type_p (t2
)
1609 || maybe_ne (TYPE_VECTOR_SUBPARTS (t1
), TYPE_VECTOR_SUBPARTS (t2
))
1610 || !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1614 case TYPE_PACK_EXPANSION
:
1615 return (same_type_p (PACK_EXPANSION_PATTERN (t1
),
1616 PACK_EXPANSION_PATTERN (t2
))
1617 && comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
1618 PACK_EXPANSION_EXTRA_ARGS (t2
)));
1621 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t1
)
1622 != DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t2
))
1624 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t1
) != DECLTYPE_FOR_LAMBDA_CAPTURE (t2
))
1626 if (DECLTYPE_FOR_LAMBDA_PROXY (t1
) != DECLTYPE_FOR_LAMBDA_PROXY (t2
))
1628 if (!cp_tree_equal (DECLTYPE_TYPE_EXPR (t1
), DECLTYPE_TYPE_EXPR (t2
)))
1633 if (TRAIT_TYPE_KIND (t1
) != TRAIT_TYPE_KIND (t2
))
1635 if (!cp_tree_equal (TRAIT_TYPE_TYPE1 (t1
), TRAIT_TYPE_TYPE1 (t2
))
1636 || !cp_tree_equal (TRAIT_TYPE_TYPE2 (t1
), TRAIT_TYPE_TYPE2 (t2
)))
1641 if (!cp_tree_equal (TYPEOF_TYPE_EXPR (t1
), TYPEOF_TYPE_EXPR (t2
)))
1649 /* If we get here, we know that from a target independent POV the
1650 types are the same. Make sure the target attributes are also
1652 if (!comp_type_attributes (t1
, t2
))
1656 if (comparing_dependent_aliases
)
1658 /* Don't treat an alias template specialization with dependent
1659 arguments as equivalent to its underlying type when used as a
1660 template argument; we need them to be distinct so that we
1661 substitute into the specialization arguments at instantiation
1662 time. And aliases can't be equivalent without being ==, so
1663 we don't need to look any deeper. */
1664 ++processing_template_decl
;
1665 tree dep1
= dependent_alias_template_spec_p (t1
, nt_transparent
);
1666 tree dep2
= dependent_alias_template_spec_p (t2
, nt_transparent
);
1667 --processing_template_decl
;
1668 if ((dep1
|| dep2
) && dep1
!= dep2
)
1675 /* Return true if T1 and T2 are related as allowed by STRICT. STRICT
1676 is a bitwise-or of the COMPARE_* flags. */
1679 comptypes (tree t1
, tree t2
, int strict
)
1681 gcc_checking_assert (t1
&& t2
);
1683 /* TYPE_ARGUMENT_PACKS are not really types. */
1684 gcc_checking_assert (TREE_CODE (t1
) != TYPE_ARGUMENT_PACK
1685 && TREE_CODE (t2
) != TYPE_ARGUMENT_PACK
);
1690 /* Suppress errors caused by previously reported errors. */
1691 if (t1
== error_mark_node
|| t2
== error_mark_node
)
1694 if (strict
== COMPARE_STRICT
)
1696 if (TYPE_STRUCTURAL_EQUALITY_P (t1
) || TYPE_STRUCTURAL_EQUALITY_P (t2
))
1697 /* At least one of the types requires structural equality, so
1698 perform a deep check. */
1699 return structural_comptypes (t1
, t2
, strict
);
1701 if (flag_checking
&& param_use_canonical_types
)
1703 bool result
= structural_comptypes (t1
, t2
, strict
);
1705 if (result
&& TYPE_CANONICAL (t1
) != TYPE_CANONICAL (t2
))
1706 /* The two types are structurally equivalent, but their
1707 canonical types were different. This is a failure of the
1708 canonical type propagation code.*/
1710 ("canonical types differ for identical types %qT and %qT",
1712 else if (!result
&& TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
1713 /* Two types are structurally different, but the canonical
1714 types are the same. This means we were over-eager in
1715 assigning canonical types. */
1717 ("same canonical type node for different types %qT and %qT",
1722 if (!flag_checking
&& param_use_canonical_types
)
1723 return TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
);
1725 return structural_comptypes (t1
, t2
, strict
);
1727 else if (strict
== COMPARE_STRUCTURAL
)
1728 return structural_comptypes (t1
, t2
, COMPARE_STRICT
);
1730 return structural_comptypes (t1
, t2
, strict
);
1733 /* Returns nonzero iff TYPE1 and TYPE2 are the same type, ignoring
1734 top-level qualifiers. */
1737 same_type_ignoring_top_level_qualifiers_p (tree type1
, tree type2
)
1739 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1744 type1
= cp_build_qualified_type (type1
, TYPE_UNQUALIFIED
);
1745 type2
= cp_build_qualified_type (type2
, TYPE_UNQUALIFIED
);
1746 return same_type_p (type1
, type2
);
1749 /* Returns nonzero iff TYPE1 and TYPE2 are similar, as per [conv.qual]. */
1752 similar_type_p (tree type1
, tree type2
)
1754 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1757 /* Informally, two types are similar if, ignoring top-level cv-qualification:
1758 * they are the same type; or
1759 * they are both pointers, and the pointed-to types are similar; or
1760 * they are both pointers to member of the same class, and the types of
1761 the pointed-to members are similar; or
1762 * they are both arrays of the same size or both arrays of unknown bound,
1763 and the array element types are similar. */
1765 if (same_type_ignoring_top_level_qualifiers_p (type1
, type2
))
1768 if ((TYPE_PTR_P (type1
) && TYPE_PTR_P (type2
))
1769 || (TYPE_PTRDATAMEM_P (type1
) && TYPE_PTRDATAMEM_P (type2
))
1770 || (TREE_CODE (type1
) == ARRAY_TYPE
&& TREE_CODE (type2
) == ARRAY_TYPE
))
1771 return comp_ptr_ttypes_const (type1
, type2
, bounds_either
);
1776 /* Helper function for layout_compatible_type_p and
1777 is_corresponding_member_aggr. Advance to next members (NULL if
1778 no further ones) and return true if those members are still part of
1779 the common initial sequence. */
1782 next_common_initial_sequence (tree
&memb1
, tree
&memb2
)
1786 if (TREE_CODE (memb1
) != FIELD_DECL
1787 || (DECL_FIELD_IS_BASE (memb1
) && is_empty_field (memb1
)))
1789 memb1
= DECL_CHAIN (memb1
);
1792 if (DECL_FIELD_IS_BASE (memb1
))
1794 memb1
= TYPE_FIELDS (TREE_TYPE (memb1
));
1801 if (TREE_CODE (memb2
) != FIELD_DECL
1802 || (DECL_FIELD_IS_BASE (memb2
) && is_empty_field (memb2
)))
1804 memb2
= DECL_CHAIN (memb2
);
1807 if (DECL_FIELD_IS_BASE (memb2
))
1809 memb2
= TYPE_FIELDS (TREE_TYPE (memb2
));
1814 if (memb1
== NULL_TREE
&& memb2
== NULL_TREE
)
1816 if (memb1
== NULL_TREE
|| memb2
== NULL_TREE
)
1818 if (DECL_BIT_FIELD_TYPE (memb1
))
1820 if (!DECL_BIT_FIELD_TYPE (memb2
))
1822 if (!layout_compatible_type_p (DECL_BIT_FIELD_TYPE (memb1
),
1823 DECL_BIT_FIELD_TYPE (memb2
)))
1825 if (TYPE_PRECISION (TREE_TYPE (memb1
))
1826 != TYPE_PRECISION (TREE_TYPE (memb2
)))
1829 else if (DECL_BIT_FIELD_TYPE (memb2
))
1831 else if (!layout_compatible_type_p (TREE_TYPE (memb1
), TREE_TYPE (memb2
)))
1833 if ((!lookup_attribute ("no_unique_address", DECL_ATTRIBUTES (memb1
)))
1834 != !lookup_attribute ("no_unique_address", DECL_ATTRIBUTES (memb2
)))
1836 if (DECL_ALIGN (memb1
) != DECL_ALIGN (memb2
))
1838 if (!tree_int_cst_equal (bit_position (memb1
), bit_position (memb2
)))
1843 /* Return true if TYPE1 and TYPE2 are layout-compatible types. */
1846 layout_compatible_type_p (tree type1
, tree type2
)
1848 if (type1
== error_mark_node
|| type2
== error_mark_node
)
1852 if (TREE_CODE (type1
) != TREE_CODE (type2
))
1855 type1
= cp_build_qualified_type (type1
, TYPE_UNQUALIFIED
);
1856 type2
= cp_build_qualified_type (type2
, TYPE_UNQUALIFIED
);
1858 if (TREE_CODE (type1
) == ENUMERAL_TYPE
)
1859 return (tree_int_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
))
1860 && same_type_p (finish_underlying_type (type1
),
1861 finish_underlying_type (type2
)));
1863 if (CLASS_TYPE_P (type1
)
1864 && std_layout_type_p (type1
)
1865 && std_layout_type_p (type2
)
1866 && tree_int_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
)))
1868 tree field1
= TYPE_FIELDS (type1
);
1869 tree field2
= TYPE_FIELDS (type2
);
1870 if (TREE_CODE (type1
) == RECORD_TYPE
)
1874 if (!next_common_initial_sequence (field1
, field2
))
1876 if (field1
== NULL_TREE
)
1878 field1
= DECL_CHAIN (field1
);
1879 field2
= DECL_CHAIN (field2
);
1882 /* Otherwise both types must be union types.
1884 "Two standard-layout unions are layout-compatible if they have
1885 the same number of non-static data members and corresponding
1886 non-static data members (in any order) have layout-compatible
1888 but the code anticipates that bitfield vs. non-bitfield,
1889 different bitfield widths or presence/absence of
1890 [[no_unique_address]] should be checked as well. */
1891 auto_vec
<tree
, 16> vec
;
1892 unsigned int count
= 0;
1893 for (; field1
; field1
= DECL_CHAIN (field1
))
1894 if (TREE_CODE (field1
) == FIELD_DECL
)
1896 for (; field2
; field2
= DECL_CHAIN (field2
))
1897 if (TREE_CODE (field2
) == FIELD_DECL
)
1898 vec
.safe_push (field2
);
1899 /* Discussions on core lean towards treating multiple union fields
1900 of the same type as the same field, so this might need changing
1902 if (count
!= vec
.length ())
1904 for (field1
= TYPE_FIELDS (type1
); field1
; field1
= DECL_CHAIN (field1
))
1906 if (TREE_CODE (field1
) != FIELD_DECL
)
1909 tree t1
= DECL_BIT_FIELD_TYPE (field1
);
1910 if (t1
== NULL_TREE
)
1911 t1
= TREE_TYPE (field1
);
1912 FOR_EACH_VEC_ELT (vec
, j
, field2
)
1914 tree t2
= DECL_BIT_FIELD_TYPE (field2
);
1915 if (t2
== NULL_TREE
)
1916 t2
= TREE_TYPE (field2
);
1917 if (DECL_BIT_FIELD_TYPE (field1
))
1919 if (!DECL_BIT_FIELD_TYPE (field2
))
1921 if (TYPE_PRECISION (TREE_TYPE (field1
))
1922 != TYPE_PRECISION (TREE_TYPE (field2
)))
1925 else if (DECL_BIT_FIELD_TYPE (field2
))
1927 if (!layout_compatible_type_p (t1
, t2
))
1929 if ((!lookup_attribute ("no_unique_address",
1930 DECL_ATTRIBUTES (field1
)))
1931 != !lookup_attribute ("no_unique_address",
1932 DECL_ATTRIBUTES (field2
)))
1936 if (j
== vec
.length ())
1938 vec
.unordered_remove (j
);
1943 return same_type_p (type1
, type2
);
1946 /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */
1949 at_least_as_qualified_p (const_tree type1
, const_tree type2
)
1951 int q1
= cp_type_quals (type1
);
1952 int q2
= cp_type_quals (type2
);
1954 /* All qualifiers for TYPE2 must also appear in TYPE1. */
1955 return (q1
& q2
) == q2
;
1958 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1959 more cv-qualified that TYPE1, and 0 otherwise. */
1962 comp_cv_qualification (int q1
, int q2
)
1967 if ((q1
& q2
) == q2
)
1969 else if ((q1
& q2
) == q1
)
1976 comp_cv_qualification (const_tree type1
, const_tree type2
)
1978 int q1
= cp_type_quals (type1
);
1979 int q2
= cp_type_quals (type2
);
1980 return comp_cv_qualification (q1
, q2
);
1983 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1984 subset of the cv-qualification signature of TYPE2, and the types
1985 are similar. Returns -1 if the other way 'round, and 0 otherwise. */
1988 comp_cv_qual_signature (tree type1
, tree type2
)
1990 if (comp_ptr_ttypes_real (type2
, type1
, -1))
1992 else if (comp_ptr_ttypes_real (type1
, type2
, -1))
1998 /* Subroutines of `comptypes'. */
2000 /* Return true if two parameter type lists PARMS1 and PARMS2 are
2001 equivalent in the sense that functions with those parameter types
2002 can have equivalent types. The two lists must be equivalent,
2003 element by element. */
2006 compparms (const_tree parms1
, const_tree parms2
)
2010 /* An unspecified parmlist matches any specified parmlist
2011 whose argument types don't need default promotions. */
2013 for (t1
= parms1
, t2
= parms2
;
2015 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
2017 /* If one parmlist is shorter than the other,
2018 they fail to match. */
2021 if (!same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
2028 /* Process a sizeof or alignof expression where the operand is a type.
2029 STD_ALIGNOF indicates whether an alignof has C++11 (minimum alignment)
2030 or GNU (preferred alignment) semantics; it is ignored if OP is
2034 cxx_sizeof_or_alignof_type (location_t loc
, tree type
, enum tree_code op
,
2035 bool std_alignof
, bool complain
)
2037 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
2038 if (type
== error_mark_node
)
2039 return error_mark_node
;
2041 type
= non_reference (type
);
2042 if (TREE_CODE (type
) == METHOD_TYPE
)
2046 pedwarn (loc
, OPT_Wpointer_arith
,
2047 "invalid application of %qs to a member function",
2048 OVL_OP_INFO (false, op
)->name
);
2049 return size_one_node
;
2052 return error_mark_node
;
2054 else if (VOID_TYPE_P (type
) && std_alignof
)
2057 error_at (loc
, "invalid application of %qs to a void type",
2058 OVL_OP_INFO (false, op
)->name
);
2059 return error_mark_node
;
2062 bool dependent_p
= dependent_type_p (type
);
2064 complete_type (type
);
2066 /* VLA types will have a non-constant size. In the body of an
2067 uninstantiated template, we don't need to try to compute the
2068 value, because the sizeof expression is not an integral
2069 constant expression in that case. And, if we do try to
2070 compute the value, we'll likely end up with SAVE_EXPRs, which
2071 the template substitution machinery does not expect to see. */
2072 || (processing_template_decl
2073 && COMPLETE_TYPE_P (type
)
2074 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
))
2076 tree value
= build_min (op
, size_type_node
, type
);
2077 TREE_READONLY (value
) = 1;
2078 if (op
== ALIGNOF_EXPR
&& std_alignof
)
2079 ALIGNOF_EXPR_STD_P (value
) = true;
2080 SET_EXPR_LOCATION (value
, loc
);
2084 return c_sizeof_or_alignof_type (loc
, complete_type (type
),
2085 op
== SIZEOF_EXPR
, std_alignof
,
2089 /* Return the size of the type, without producing any warnings for
2090 types whose size cannot be taken. This routine should be used only
2091 in some other routine that has already produced a diagnostic about
2092 using the size of such a type. */
2094 cxx_sizeof_nowarn (tree type
)
2096 if (TREE_CODE (type
) == FUNCTION_TYPE
2097 || VOID_TYPE_P (type
)
2098 || TREE_CODE (type
) == ERROR_MARK
)
2099 return size_one_node
;
2100 else if (!COMPLETE_TYPE_P (type
))
2101 return size_zero_node
;
2103 return cxx_sizeof_or_alignof_type (input_location
, type
,
2104 SIZEOF_EXPR
, false, false);
2107 /* Process a sizeof expression where the operand is an expression. */
2110 cxx_sizeof_expr (location_t loc
, tree e
, tsubst_flags_t complain
)
2112 if (e
== error_mark_node
)
2113 return error_mark_node
;
2115 if (instantiation_dependent_uneval_expression_p (e
))
2117 e
= build_min (SIZEOF_EXPR
, size_type_node
, e
);
2118 TREE_SIDE_EFFECTS (e
) = 0;
2119 TREE_READONLY (e
) = 1;
2120 SET_EXPR_LOCATION (e
, loc
);
2125 location_t e_loc
= cp_expr_loc_or_loc (e
, loc
);
2126 STRIP_ANY_LOCATION_WRAPPER (e
);
2128 /* To get the size of a static data member declared as an array of
2129 unknown bound, we need to instantiate it. */
2131 && VAR_HAD_UNKNOWN_BOUND (e
)
2132 && DECL_TEMPLATE_INSTANTIATION (e
))
2133 instantiate_decl (e
, /*defer_ok*/true, /*expl_inst_mem*/false);
2135 if (TREE_CODE (e
) == PARM_DECL
2136 && DECL_ARRAY_PARAMETER_P (e
)
2137 && (complain
& tf_warning
))
2139 auto_diagnostic_group d
;
2140 if (warning_at (e_loc
, OPT_Wsizeof_array_argument
,
2141 "%<sizeof%> on array function parameter %qE "
2142 "will return size of %qT", e
, TREE_TYPE (e
)))
2143 inform (DECL_SOURCE_LOCATION (e
), "declared here");
2146 e
= mark_type_use (e
);
2150 if (complain
& tf_error
)
2152 "invalid application of %<sizeof%> to a bit-field");
2154 return error_mark_node
;
2157 else if (is_overloaded_fn (e
))
2159 if (complain
& tf_error
)
2160 permerror (e_loc
, "ISO C++ forbids applying %<sizeof%> to "
2161 "an expression of function type");
2163 return error_mark_node
;
2166 else if (type_unknown_p (e
))
2168 if (complain
& tf_error
)
2169 cxx_incomplete_type_error (e_loc
, e
, TREE_TYPE (e
));
2171 return error_mark_node
;
2177 return cxx_sizeof_or_alignof_type (loc
, e
, SIZEOF_EXPR
, false,
2178 complain
& tf_error
);
2181 /* Implement the __alignof keyword: Return the minimum required
2182 alignment of E, measured in bytes. For VAR_DECL's and
2183 FIELD_DECL's return DECL_ALIGN (which can be set from an
2184 "aligned" __attribute__ specification). STD_ALIGNOF acts
2185 like in cxx_sizeof_or_alignof_type. */
2188 cxx_alignof_expr (location_t loc
, tree e
, bool std_alignof
,
2189 tsubst_flags_t complain
)
2193 if (e
== error_mark_node
)
2194 return error_mark_node
;
2196 if (processing_template_decl
)
2198 e
= build_min (ALIGNOF_EXPR
, size_type_node
, e
);
2199 TREE_SIDE_EFFECTS (e
) = 0;
2200 TREE_READONLY (e
) = 1;
2201 SET_EXPR_LOCATION (e
, loc
);
2202 ALIGNOF_EXPR_STD_P (e
) = std_alignof
;
2207 location_t e_loc
= cp_expr_loc_or_loc (e
, loc
);
2208 STRIP_ANY_LOCATION_WRAPPER (e
);
2210 e
= mark_type_use (e
);
2212 if (!verify_type_context (loc
, TCTX_ALIGNOF
, TREE_TYPE (e
),
2213 !(complain
& tf_error
)))
2215 if (!(complain
& tf_error
))
2216 return error_mark_node
;
2220 t
= size_int (DECL_ALIGN_UNIT (e
));
2221 else if (bitfield_p (e
))
2223 if (complain
& tf_error
)
2225 "invalid application of %<__alignof%> to a bit-field");
2227 return error_mark_node
;
2230 else if (TREE_CODE (e
) == COMPONENT_REF
2231 && TREE_CODE (TREE_OPERAND (e
, 1)) == FIELD_DECL
)
2232 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e
, 1)));
2233 else if (is_overloaded_fn (e
))
2235 if (complain
& tf_error
)
2236 permerror (e_loc
, "ISO C++ forbids applying %<__alignof%> to "
2237 "an expression of function type");
2239 return error_mark_node
;
2240 if (TREE_CODE (e
) == FUNCTION_DECL
)
2241 t
= size_int (DECL_ALIGN_UNIT (e
));
2245 else if (type_unknown_p (e
))
2247 if (complain
& tf_error
)
2248 cxx_incomplete_type_error (e_loc
, e
, TREE_TYPE (e
));
2250 return error_mark_node
;
2254 return cxx_sizeof_or_alignof_type (loc
, TREE_TYPE (e
),
2255 ALIGNOF_EXPR
, std_alignof
,
2256 complain
& tf_error
);
2258 return fold_convert_loc (loc
, size_type_node
, t
);
2261 /* Process a sizeof or alignof expression E with code OP where the operand
2262 is an expression. STD_ALIGNOF acts like in cxx_sizeof_or_alignof_type. */
2265 cxx_sizeof_or_alignof_expr (location_t loc
, tree e
, enum tree_code op
,
2266 bool std_alignof
, bool complain
)
2268 gcc_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
);
2269 if (op
== SIZEOF_EXPR
)
2270 return cxx_sizeof_expr (loc
, e
, complain
? tf_warning_or_error
: tf_none
);
2272 return cxx_alignof_expr (loc
, e
, std_alignof
,
2273 complain
? tf_warning_or_error
: tf_none
);
2276 /* Build a representation of an expression 'alignas(E).' Return the
2277 folded integer value of E if it is an integral constant expression
2278 that resolves to a valid alignment. If E depends on a template
2279 parameter, return a syntactic representation tree of kind
2280 ALIGNOF_EXPR. Otherwise, return an error_mark_node if the
2281 expression is ill formed, or NULL_TREE if E is NULL_TREE. */
2284 cxx_alignas_expr (tree e
)
2286 if (e
== NULL_TREE
|| e
== error_mark_node
2287 || (!TYPE_P (e
) && !require_potential_rvalue_constant_expression (e
)))
2293 When the alignment-specifier is of the form
2294 alignas(type-id), it shall have the same effect as
2295 alignas(alignof(type-id)). */
2297 return cxx_sizeof_or_alignof_type (input_location
,
2299 /*std_alignof=*/true,
2302 /* If we reach this point, it means the alignas expression if of
2303 the form "alignas(assignment-expression)", so we should follow
2304 what is stated by [dcl.align]/2. */
2306 if (value_dependent_expression_p (e
))
2307 /* Leave value-dependent expression alone for now. */
2310 e
= instantiate_non_dependent_expr (e
);
2311 e
= mark_rvalue_use (e
);
2313 /* [dcl.align]/2 says:
2315 the assignment-expression shall be an integral constant
2318 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (e
)))
2320 error ("%<alignas%> argument has non-integral type %qT", TREE_TYPE (e
));
2321 return error_mark_node
;
2324 return cxx_constant_value (e
);
2328 /* EXPR is being used in a context that is not a function call.
2333 The expression can be used only as the left-hand operand of a
2334 member function call.
2336 [expr.mptr.operator]
2338 If the result of .* or ->* is a function, then that result can be
2339 used only as the operand for the function call operator ().
2341 by issuing an error message if appropriate. Returns true iff EXPR
2342 violates these rules. */
2345 invalid_nonstatic_memfn_p (location_t loc
, tree expr
, tsubst_flags_t complain
)
2347 if (expr
== NULL_TREE
)
2349 /* Don't enforce this in MS mode. */
2350 if (flag_ms_extensions
)
2352 if (is_overloaded_fn (expr
) && !really_overloaded_fn (expr
))
2353 expr
= get_first_fn (expr
);
2354 if (TREE_TYPE (expr
)
2355 && DECL_NONSTATIC_MEMBER_FUNCTION_P (expr
))
2357 if (complain
& tf_error
)
2361 error_at (loc
, "invalid use of non-static member function %qD",
2363 inform (DECL_SOURCE_LOCATION (expr
), "declared here");
2366 error_at (loc
, "invalid use of non-static member function of "
2367 "type %qT", TREE_TYPE (expr
));
2374 /* If EXP is a reference to a bit-field, and the type of EXP does not
2375 match the declared type of the bit-field, return the declared type
2376 of the bit-field. Otherwise, return NULL_TREE. */
2379 is_bitfield_expr_with_lowered_type (const_tree exp
)
2381 switch (TREE_CODE (exp
))
2384 if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1)
2385 ? TREE_OPERAND (exp
, 1)
2386 : TREE_OPERAND (exp
, 0)))
2388 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 2));
2391 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 1));
2395 case UNARY_PLUS_EXPR
:
2396 case PREDECREMENT_EXPR
:
2397 case PREINCREMENT_EXPR
:
2398 case POSTDECREMENT_EXPR
:
2399 case POSTINCREMENT_EXPR
:
2401 case NON_LVALUE_EXPR
:
2403 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
2409 field
= TREE_OPERAND (exp
, 1);
2410 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_BIT_FIELD_TYPE (field
))
2412 if (same_type_ignoring_top_level_qualifiers_p
2413 (TREE_TYPE (exp
), DECL_BIT_FIELD_TYPE (field
)))
2415 return DECL_BIT_FIELD_TYPE (field
);
2419 if (DECL_HAS_VALUE_EXPR_P (exp
))
2420 return is_bitfield_expr_with_lowered_type (DECL_VALUE_EXPR
2421 (CONST_CAST_TREE (exp
)));
2424 case VIEW_CONVERT_EXPR
:
2425 if (location_wrapper_p (exp
))
2426 return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp
, 0));
2435 /* Like is_bitfield_with_lowered_type, except that if EXP is not a
2436 bitfield with a lowered type, the type of EXP is returned, rather
2440 unlowered_expr_type (const_tree exp
)
2443 tree etype
= TREE_TYPE (exp
);
2445 type
= is_bitfield_expr_with_lowered_type (exp
);
2447 type
= cp_build_qualified_type (type
, cp_type_quals (etype
));
2454 /* Perform the conversions in [expr] that apply when an lvalue appears
2455 in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and
2456 function-to-pointer conversions. In addition, bitfield references are
2457 converted to their declared types. Note that this function does not perform
2458 the lvalue-to-rvalue conversion for class types. If you need that conversion
2459 for class types, then you probably need to use force_rvalue.
2461 Although the returned value is being used as an rvalue, this
2462 function does not wrap the returned expression in a
2463 NON_LVALUE_EXPR; the caller is expected to be mindful of the fact
2464 that the return value is no longer an lvalue. */
2467 decay_conversion (tree exp
,
2468 tsubst_flags_t complain
,
2469 bool reject_builtin
/* = true */)
2472 enum tree_code code
;
2473 location_t loc
= cp_expr_loc_or_input_loc (exp
);
2475 type
= TREE_TYPE (exp
);
2476 if (type
== error_mark_node
)
2477 return error_mark_node
;
2479 exp
= resolve_nondeduced_context_or_error (exp
, complain
);
2481 code
= TREE_CODE (type
);
2483 if (error_operand_p (exp
))
2484 return error_mark_node
;
2486 if (NULLPTR_TYPE_P (type
) && !TREE_SIDE_EFFECTS (exp
))
2488 mark_rvalue_use (exp
, loc
, reject_builtin
);
2489 return nullptr_node
;
2492 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2493 Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */
2494 if (code
== VOID_TYPE
)
2496 if (complain
& tf_error
)
2497 error_at (loc
, "void value not ignored as it ought to be");
2498 return error_mark_node
;
2500 if (invalid_nonstatic_memfn_p (loc
, exp
, complain
))
2501 return error_mark_node
;
2502 if (code
== FUNCTION_TYPE
|| is_overloaded_fn (exp
))
2504 exp
= mark_lvalue_use (exp
);
2505 if (reject_builtin
&& reject_gcc_builtin (exp
, loc
))
2506 return error_mark_node
;
2507 return cp_build_addr_expr (exp
, complain
);
2509 if (code
== ARRAY_TYPE
)
2514 exp
= mark_lvalue_use (exp
);
2516 if (INDIRECT_REF_P (exp
))
2517 return build_nop (build_pointer_type (TREE_TYPE (type
)),
2518 TREE_OPERAND (exp
, 0));
2520 if (TREE_CODE (exp
) == COMPOUND_EXPR
)
2522 tree op1
= decay_conversion (TREE_OPERAND (exp
, 1), complain
);
2523 if (op1
== error_mark_node
)
2524 return error_mark_node
;
2525 return build2 (COMPOUND_EXPR
, TREE_TYPE (op1
),
2526 TREE_OPERAND (exp
, 0), op1
);
2529 if (!obvalue_p (exp
)
2530 && ! (TREE_CODE (exp
) == CONSTRUCTOR
&& TREE_STATIC (exp
)))
2532 if (complain
& tf_error
)
2533 error_at (loc
, "invalid use of non-lvalue array");
2534 return error_mark_node
;
2537 ptrtype
= build_pointer_type (TREE_TYPE (type
));
2541 if (!cxx_mark_addressable (exp
))
2542 return error_mark_node
;
2543 adr
= build_nop (ptrtype
, build_address (exp
));
2546 /* This way is better for a COMPONENT_REF since it can
2547 simplify the offset for a component. */
2548 adr
= cp_build_addr_expr (exp
, complain
);
2549 return cp_convert (ptrtype
, adr
, complain
);
2552 /* Otherwise, it's the lvalue-to-rvalue conversion. */
2553 exp
= mark_rvalue_use (exp
, loc
, reject_builtin
);
2555 /* If a bitfield is used in a context where integral promotion
2556 applies, then the caller is expected to have used
2557 default_conversion. That function promotes bitfields correctly
2558 before calling this function. At this point, if we have a
2559 bitfield referenced, we may assume that is not subject to
2560 promotion, and that, therefore, the type of the resulting rvalue
2561 is the declared type of the bitfield. */
2562 exp
= convert_bitfield_to_declared_type (exp
);
2564 /* We do not call rvalue() here because we do not want to wrap EXP
2565 in a NON_LVALUE_EXPR. */
2569 Non-class rvalues always have cv-unqualified types. */
2570 type
= TREE_TYPE (exp
);
2571 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
2572 exp
= build_nop (cv_unqualified (type
), exp
);
2574 if (!complete_type_or_maybe_complain (type
, exp
, complain
))
2575 return error_mark_node
;
2580 /* Perform preparatory conversions, as part of the "usual arithmetic
2581 conversions". In particular, as per [expr]:
2583 Whenever an lvalue expression appears as an operand of an
2584 operator that expects the rvalue for that operand, the
2585 lvalue-to-rvalue, array-to-pointer, or function-to-pointer
2586 standard conversions are applied to convert the expression to an
2589 In addition, we perform integral promotions here, as those are
2590 applied to both operands to a binary operator before determining
2591 what additional conversions should apply. */
2594 cp_default_conversion (tree exp
, tsubst_flags_t complain
)
2596 /* Check for target-specific promotions. */
2597 tree promoted_type
= targetm
.promoted_type (TREE_TYPE (exp
));
2599 exp
= cp_convert (promoted_type
, exp
, complain
);
2600 /* Perform the integral promotions first so that bitfield
2601 expressions (which may promote to "int", even if the bitfield is
2602 declared "unsigned") are promoted correctly. */
2603 else if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (exp
)))
2604 exp
= cp_perform_integral_promotions (exp
, complain
);
2605 /* Perform the other conversions. */
2606 exp
= decay_conversion (exp
, complain
);
2614 default_conversion (tree exp
)
2616 return cp_default_conversion (exp
, tf_warning_or_error
);
2619 /* EXPR is an expression with an integral or enumeration type.
2620 Perform the integral promotions in [conv.prom], and return the
2624 cp_perform_integral_promotions (tree expr
, tsubst_flags_t complain
)
2629 expr
= mark_rvalue_use (expr
);
2630 if (error_operand_p (expr
))
2631 return error_mark_node
;
2633 type
= TREE_TYPE (expr
);
2637 A prvalue for an integral bit-field (11.3.9) can be converted to a prvalue
2638 of type int if int can represent all the values of the bit-field;
2639 otherwise, it can be converted to unsigned int if unsigned int can
2640 represent all the values of the bit-field. If the bit-field is larger yet,
2641 no integral promotion applies to it. If the bit-field has an enumerated
2642 type, it is treated as any other value of that type for promotion
2644 tree bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
2646 && (TREE_CODE (bitfield_type
) == ENUMERAL_TYPE
2647 || TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)))
2648 type
= bitfield_type
;
2650 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
2651 /* Scoped enums don't promote. */
2652 if (SCOPED_ENUM_P (type
))
2654 promoted_type
= type_promotes_to (type
);
2655 if (type
!= promoted_type
)
2656 expr
= cp_convert (promoted_type
, expr
, complain
);
2657 else if (bitfield_type
&& bitfield_type
!= type
)
2658 /* Prevent decay_conversion from converting to bitfield_type. */
2659 expr
= build_nop (type
, expr
);
2666 perform_integral_promotions (tree expr
)
2668 return cp_perform_integral_promotions (expr
, tf_warning_or_error
);
2671 /* Returns nonzero iff exp is a STRING_CST or the result of applying
2672 decay_conversion to one. */
2675 string_conv_p (const_tree totype
, const_tree exp
, int warn
)
2679 if (!TYPE_PTR_P (totype
))
2682 t
= TREE_TYPE (totype
);
2683 if (!same_type_p (t
, char_type_node
)
2684 && !same_type_p (t
, char8_type_node
)
2685 && !same_type_p (t
, char16_type_node
)
2686 && !same_type_p (t
, char32_type_node
)
2687 && !same_type_p (t
, wchar_type_node
))
2690 location_t loc
= EXPR_LOC_OR_LOC (exp
, input_location
);
2692 STRIP_ANY_LOCATION_WRAPPER (exp
);
2694 if (TREE_CODE (exp
) == STRING_CST
)
2696 /* Make sure that we don't try to convert between char and wide chars. */
2697 if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp
))), t
))
2702 /* Is this a string constant which has decayed to 'const char *'? */
2703 t
= build_pointer_type (cp_build_qualified_type (t
, TYPE_QUAL_CONST
));
2704 if (!same_type_p (TREE_TYPE (exp
), t
))
2707 if (TREE_CODE (exp
) != ADDR_EXPR
2708 || TREE_CODE (TREE_OPERAND (exp
, 0)) != STRING_CST
)
2713 if (cxx_dialect
>= cxx11
)
2714 pedwarn (loc
, OPT_Wwrite_strings
,
2715 "ISO C++ forbids converting a string constant to %qT",
2718 warning_at (loc
, OPT_Wwrite_strings
,
2719 "deprecated conversion from string constant to %qT",
2726 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
2727 can, for example, use as an lvalue. This code used to be in
2728 unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
2729 expressions, where we're dealing with aggregates. But now it's again only
2730 called from unary_complex_lvalue. The case (in particular) that led to
2731 this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
2735 rationalize_conditional_expr (enum tree_code code
, tree t
,
2736 tsubst_flags_t complain
)
2738 location_t loc
= cp_expr_loc_or_input_loc (t
);
2740 /* For MIN_EXPR or MAX_EXPR, fold-const.cc has arranged things so that
2741 the first operand is always the one to be used if both operands
2742 are equal, so we know what conditional expression this used to be. */
2743 if (TREE_CODE (t
) == MIN_EXPR
|| TREE_CODE (t
) == MAX_EXPR
)
2745 tree op0
= TREE_OPERAND (t
, 0);
2746 tree op1
= TREE_OPERAND (t
, 1);
2748 /* The following code is incorrect if either operand side-effects. */
2749 gcc_assert (!TREE_SIDE_EFFECTS (op0
)
2750 && !TREE_SIDE_EFFECTS (op1
));
2752 build_conditional_expr (loc
,
2753 build_x_binary_op (loc
,
2754 (TREE_CODE (t
) == MIN_EXPR
2755 ? LE_EXPR
: GE_EXPR
),
2756 op0
, TREE_CODE (op0
),
2757 op1
, TREE_CODE (op1
),
2761 cp_build_unary_op (code
, op0
, false, complain
),
2762 cp_build_unary_op (code
, op1
, false, complain
),
2766 tree op1
= TREE_OPERAND (t
, 1);
2767 if (TREE_CODE (op1
) != THROW_EXPR
)
2768 op1
= cp_build_unary_op (code
, op1
, false, complain
);
2769 tree op2
= TREE_OPERAND (t
, 2);
2770 if (TREE_CODE (op2
) != THROW_EXPR
)
2771 op2
= cp_build_unary_op (code
, op2
, false, complain
);
2774 build_conditional_expr (loc
, TREE_OPERAND (t
, 0), op1
, op2
, complain
);
2777 /* Given the TYPE of an anonymous union field inside T, return the
2778 FIELD_DECL for the field. If not found return NULL_TREE. Because
2779 anonymous unions can nest, we must also search all anonymous unions
2780 that are directly reachable. */
2783 lookup_anon_field (tree
, tree type
)
2787 type
= TYPE_MAIN_VARIANT (type
);
2788 field
= ANON_AGGR_TYPE_FIELD (type
);
2793 /* Build an expression representing OBJECT.MEMBER. OBJECT is an
2794 expression; MEMBER is a DECL or baselink. If ACCESS_PATH is
2795 non-NULL, it indicates the path to the base used to name MEMBER.
2796 If PRESERVE_REFERENCE is true, the expression returned will have
2797 REFERENCE_TYPE if the MEMBER does. Otherwise, the expression
2798 returned will have the type referred to by the reference.
2800 This function does not perform access control; that is either done
2801 earlier by the parser when the name of MEMBER is resolved to MEMBER
2802 itself, or later when overload resolution selects one of the
2803 functions indicated by MEMBER. */
2806 build_class_member_access_expr (cp_expr object
, tree member
,
2807 tree access_path
, bool preserve_reference
,
2808 tsubst_flags_t complain
)
2812 tree result
= NULL_TREE
;
2813 tree using_decl
= NULL_TREE
;
2815 if (error_operand_p (object
) || error_operand_p (member
))
2816 return error_mark_node
;
2818 gcc_assert (DECL_P (member
) || BASELINK_P (member
));
2822 The type of the first expression shall be "class object" (of a
2824 object_type
= TREE_TYPE (object
);
2825 if (!currently_open_class (object_type
)
2826 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
2827 return error_mark_node
;
2828 if (!CLASS_TYPE_P (object_type
))
2830 if (complain
& tf_error
)
2832 if (INDIRECT_TYPE_P (object_type
)
2833 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
2834 error ("request for member %qD in %qE, which is of pointer "
2835 "type %qT (maybe you meant to use %<->%> ?)",
2836 member
, object
.get_value (), object_type
);
2838 error ("request for member %qD in %qE, which is of non-class "
2839 "type %qT", member
, object
.get_value (), object_type
);
2841 return error_mark_node
;
2844 /* The standard does not seem to actually say that MEMBER must be a
2845 member of OBJECT_TYPE. However, that is clearly what is
2847 if (DECL_P (member
))
2849 member_scope
= DECL_CLASS_CONTEXT (member
);
2850 if (!mark_used (member
, complain
) && !(complain
& tf_error
))
2851 return error_mark_node
;
2853 if (TREE_UNAVAILABLE (member
))
2854 error_unavailable_use (member
, NULL_TREE
);
2855 else if (TREE_DEPRECATED (member
))
2856 warn_deprecated_use (member
, NULL_TREE
);
2859 member_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (member
));
2860 /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
2861 presently be the anonymous union. Go outwards until we find a
2862 type related to OBJECT_TYPE. */
2863 while ((ANON_AGGR_TYPE_P (member_scope
) || UNSCOPED_ENUM_P (member_scope
))
2864 && !same_type_ignoring_top_level_qualifiers_p (member_scope
,
2866 member_scope
= TYPE_CONTEXT (member_scope
);
2867 if (!member_scope
|| !DERIVED_FROM_P (member_scope
, object_type
))
2869 if (complain
& tf_error
)
2871 if (TREE_CODE (member
) == FIELD_DECL
)
2872 error ("invalid use of non-static data member %qE", member
);
2874 error ("%qD is not a member of %qT", member
, object_type
);
2876 return error_mark_node
;
2879 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
2880 `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
2881 in the front end; only _DECLs and _REFs are lvalues in the back end. */
2882 if (tree temp
= unary_complex_lvalue (ADDR_EXPR
, object
))
2884 temp
= cp_build_fold_indirect_ref (temp
);
2885 if (!lvalue_p (object
) && lvalue_p (temp
))
2886 /* Preserve rvalueness. */
2891 /* In [expr.ref], there is an explicit list of the valid choices for
2892 MEMBER. We check for each of those cases here. */
2895 /* A static data member. */
2897 mark_exp_read (object
);
2899 if (tree wrap
= maybe_get_tls_wrapper_call (result
))
2900 /* Replace an evaluated use of the thread_local variable with
2901 a call to its wrapper. */
2904 /* If OBJECT has side-effects, they are supposed to occur. */
2905 if (TREE_SIDE_EFFECTS (object
))
2906 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), object
, result
);
2908 else if (TREE_CODE (member
) == FIELD_DECL
)
2910 /* A non-static data member. */
2915 if (INDIRECT_REF_P (object
))
2917 integer_zerop (tree_strip_nop_conversions (TREE_OPERAND (object
, 0)));
2919 null_object_p
= false;
2921 /* Convert OBJECT to the type of MEMBER. */
2922 if (!same_type_p (TYPE_MAIN_VARIANT (object_type
),
2923 TYPE_MAIN_VARIANT (member_scope
)))
2928 /* We didn't complain above about a currently open class, but now we
2929 must: we don't know how to refer to a base member before layout is
2930 complete. But still don't complain in a template. */
2931 if (!cp_unevaluated_operand
2932 && !dependent_type_p (object_type
)
2933 && !complete_type_or_maybe_complain (object_type
, object
,
2935 return error_mark_node
;
2937 binfo
= lookup_base (access_path
? access_path
: object_type
,
2938 member_scope
, ba_unique
, &kind
, complain
);
2939 if (binfo
== error_mark_node
)
2940 return error_mark_node
;
2942 /* It is invalid to try to get to a virtual base of a
2943 NULL object. The most common cause is invalid use of
2945 if (null_object_p
&& kind
== bk_via_virtual
)
2947 if (complain
& tf_error
)
2949 error ("invalid access to non-static data member %qD in "
2950 "virtual base of NULL object", member
);
2952 return error_mark_node
;
2955 /* Convert to the base. */
2956 object
= build_base_path (PLUS_EXPR
, object
, binfo
,
2957 /*nonnull=*/1, complain
);
2958 /* If we found the base successfully then we should be able
2959 to convert to it successfully. */
2960 gcc_assert (object
!= error_mark_node
);
2963 /* If MEMBER is from an anonymous aggregate, we have converted
2964 OBJECT so that it refers to the class containing the
2965 anonymous union. Generate a reference to the anonymous union
2966 itself, and recur to find MEMBER. */
2967 if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member
))
2968 /* When this code is called from build_field_call, the
2969 object already has the type of the anonymous union.
2970 That is because the COMPONENT_REF was already
2971 constructed, and was then disassembled before calling
2972 build_field_call. After the function-call code is
2973 cleaned up, this waste can be eliminated. */
2974 && (!same_type_ignoring_top_level_qualifiers_p
2975 (TREE_TYPE (object
), DECL_CONTEXT (member
))))
2977 tree anonymous_union
;
2979 anonymous_union
= lookup_anon_field (TREE_TYPE (object
),
2980 DECL_CONTEXT (member
));
2981 object
= build_class_member_access_expr (object
,
2983 /*access_path=*/NULL_TREE
,
2988 /* Compute the type of the field, as described in [expr.ref]. */
2989 type_quals
= TYPE_UNQUALIFIED
;
2990 member_type
= TREE_TYPE (member
);
2991 if (!TYPE_REF_P (member_type
))
2993 type_quals
= (cp_type_quals (member_type
)
2994 | cp_type_quals (object_type
));
2996 /* A field is const (volatile) if the enclosing object, or the
2997 field itself, is const (volatile). But, a mutable field is
2998 not const, even within a const object. */
2999 if (DECL_MUTABLE_P (member
))
3000 type_quals
&= ~TYPE_QUAL_CONST
;
3001 member_type
= cp_build_qualified_type (member_type
, type_quals
);
3004 result
= build3_loc (input_location
, COMPONENT_REF
, member_type
,
3005 object
, member
, NULL_TREE
);
3007 /* Mark the expression const or volatile, as appropriate. Even
3008 though we've dealt with the type above, we still have to mark the
3009 expression itself. */
3010 if (type_quals
& TYPE_QUAL_CONST
)
3011 TREE_READONLY (result
) = 1;
3012 if (type_quals
& TYPE_QUAL_VOLATILE
)
3013 TREE_THIS_VOLATILE (result
) = 1;
3015 else if (BASELINK_P (member
))
3017 /* The member is a (possibly overloaded) member function. */
3021 /* If the MEMBER is exactly one static member function, then we
3022 know the type of the expression. Otherwise, we must wait
3023 until overload resolution has been performed. */
3024 functions
= BASELINK_FUNCTIONS (member
);
3025 if (TREE_CODE (functions
) == FUNCTION_DECL
3026 && DECL_STATIC_FUNCTION_P (functions
))
3027 type
= TREE_TYPE (functions
);
3029 type
= unknown_type_node
;
3030 /* Note that we do not convert OBJECT to the BASELINK_BINFO
3031 base. That will happen when the function is called. */
3032 result
= build3_loc (input_location
, COMPONENT_REF
, type
, object
, member
,
3035 else if (TREE_CODE (member
) == CONST_DECL
)
3037 /* The member is an enumerator. */
3039 /* If OBJECT has side-effects, they are supposed to occur. */
3040 if (TREE_SIDE_EFFECTS (object
))
3041 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
3044 else if ((using_decl
= strip_using_decl (member
)) != member
)
3045 result
= build_class_member_access_expr (object
,
3047 access_path
, preserve_reference
,
3051 if (complain
& tf_error
)
3052 error ("invalid use of %qD", member
);
3053 return error_mark_node
;
3056 if (!preserve_reference
)
3059 If E2 is declared to have type "reference to T", then ... the
3060 type of E1.E2 is T. */
3061 result
= convert_from_reference (result
);
3066 /* Return the destructor denoted by OBJECT.SCOPE::DTOR_NAME, or, if
3067 SCOPE is NULL, by OBJECT.DTOR_NAME, where DTOR_NAME is ~type. */
3070 lookup_destructor (tree object
, tree scope
, tree dtor_name
,
3071 tsubst_flags_t complain
)
3073 tree object_type
= TREE_TYPE (object
);
3074 tree dtor_type
= TREE_OPERAND (dtor_name
, 0);
3077 /* We've already complained about this destructor. */
3078 if (dtor_type
== error_mark_node
)
3079 return error_mark_node
;
3081 if (scope
&& !check_dtor_name (scope
, dtor_type
))
3083 if (complain
& tf_error
)
3084 error ("qualified type %qT does not match destructor name ~%qT",
3086 return error_mark_node
;
3088 if (is_auto (dtor_type
))
3089 dtor_type
= object_type
;
3090 else if (identifier_p (dtor_type
))
3092 /* In a template, names we can't find a match for are still accepted
3093 destructor names, and we check them here. */
3094 if (check_dtor_name (object_type
, dtor_type
))
3095 dtor_type
= object_type
;
3098 if (complain
& tf_error
)
3099 error ("object type %qT does not match destructor name ~%qT",
3100 object_type
, dtor_type
);
3101 return error_mark_node
;
3105 else if (!DERIVED_FROM_P (dtor_type
, TYPE_MAIN_VARIANT (object_type
)))
3107 if (complain
& tf_error
)
3108 error ("the type being destroyed is %qT, but the destructor "
3109 "refers to %qT", TYPE_MAIN_VARIANT (object_type
), dtor_type
);
3110 return error_mark_node
;
3112 expr
= lookup_member (dtor_type
, complete_dtor_identifier
,
3113 /*protect=*/1, /*want_type=*/false,
3114 tf_warning_or_error
);
3117 if (complain
& tf_error
)
3118 cxx_incomplete_type_error (dtor_name
, dtor_type
);
3119 return error_mark_node
;
3121 expr
= (adjust_result_of_qualified_name_lookup
3122 (expr
, dtor_type
, object_type
));
3123 if (scope
== NULL_TREE
)
3124 /* We need to call adjust_result_of_qualified_name_lookup in case the
3125 destructor names a base class, but we unset BASELINK_QUALIFIED_P so
3126 that we still get virtual function binding. */
3127 BASELINK_QUALIFIED_P (expr
) = false;
3131 /* An expression of the form "A::template B" has been resolved to
3132 DECL. Issue a diagnostic if B is not a template or template
3136 check_template_keyword (tree decl
)
3138 /* The standard says:
3142 If a name prefixed by the keyword template is not a member
3143 template, the program is ill-formed.
3145 DR 228 removed the restriction that the template be a member
3148 DR 96, if accepted would add the further restriction that explicit
3149 template arguments must be provided if the template keyword is
3150 used, but, as of 2005-10-16, that DR is still in "drafting". If
3151 this DR is accepted, then the semantic checks here can be
3152 simplified, as the entity named must in fact be a template
3153 specialization, rather than, as at present, a set of overloaded
3154 functions containing at least one template function. */
3155 if (TREE_CODE (decl
) != TEMPLATE_DECL
3156 && TREE_CODE (decl
) != TEMPLATE_ID_EXPR
)
3160 if (DECL_USE_TEMPLATE (decl
)
3161 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
3164 permerror (input_location
, "%qD is not a template", decl
);
3166 else if (!is_overloaded_fn (decl
))
3167 permerror (input_location
, "%qD is not a template", decl
);
3172 for (lkp_iterator
iter (MAYBE_BASELINK_FUNCTIONS (decl
));
3173 !found
&& iter
; ++iter
)
3176 if (TREE_CODE (fn
) == TEMPLATE_DECL
3177 || TREE_CODE (fn
) == TEMPLATE_ID_EXPR
3178 || (TREE_CODE (fn
) == FUNCTION_DECL
3179 && DECL_USE_TEMPLATE (fn
)
3180 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn
))))
3184 permerror (input_location
, "%qD is not a template", decl
);
3189 /* Record that an access failure occurred on BASETYPE_PATH attempting
3190 to access DECL, where DIAG_DECL should be used for diagnostics. */
3193 access_failure_info::record_access_failure (tree basetype_path
,
3194 tree decl
, tree diag_decl
)
3196 m_was_inaccessible
= true;
3197 m_basetype_path
= basetype_path
;
3199 m_diag_decl
= diag_decl
;
3202 /* If an access failure was recorded, then attempt to locate an
3203 accessor function for the pertinent field.
3204 Otherwise, return NULL_TREE. */
3207 access_failure_info::get_any_accessor (bool const_p
) const
3209 if (!was_inaccessible_p ())
3213 = locate_field_accessor (m_basetype_path
, m_diag_decl
, const_p
);
3217 /* The accessor must itself be accessible for it to be a reasonable
3219 if (!accessible_p (m_basetype_path
, accessor
, true))
3225 /* Add a fix-it hint to RICHLOC suggesting the use of ACCESSOR_DECL, by
3226 replacing the primary location in RICHLOC with "accessor()". */
3229 access_failure_info::add_fixit_hint (rich_location
*richloc
,
3233 pp_string (&pp
, IDENTIFIER_POINTER (DECL_NAME (accessor_decl
)));
3234 pp_string (&pp
, "()");
3235 richloc
->add_fixit_replace (pp_formatted_text (&pp
));
3238 /* If an access failure was recorded, then attempt to locate an
3239 accessor function for the pertinent field, and if one is
3240 available, add a note and fix-it hint suggesting using it. */
3243 access_failure_info::maybe_suggest_accessor (bool const_p
) const
3245 tree accessor
= get_any_accessor (const_p
);
3246 if (accessor
== NULL_TREE
)
3248 rich_location
richloc (line_table
, input_location
);
3249 add_fixit_hint (&richloc
, accessor
);
3250 inform (&richloc
, "field %q#D can be accessed via %q#D",
3251 m_diag_decl
, accessor
);
3254 /* Subroutine of finish_class_member_access_expr.
3255 Issue an error about NAME not being a member of ACCESS_PATH (or
3256 OBJECT_TYPE), potentially providing a fix-it hint for misspelled
3260 complain_about_unrecognized_member (tree access_path
, tree name
,
3263 /* Attempt to provide a hint about misspelled names. */
3264 tree guessed_id
= lookup_member_fuzzy (access_path
, name
,
3265 /*want_type=*/false);
3266 if (guessed_id
== NULL_TREE
)
3269 error ("%q#T has no member named %qE",
3270 TREE_CODE (access_path
) == TREE_BINFO
3271 ? TREE_TYPE (access_path
) : object_type
, name
);
3275 location_t bogus_component_loc
= input_location
;
3276 gcc_rich_location
rich_loc (bogus_component_loc
);
3278 /* Check that the guessed name is accessible along access_path. */
3279 access_failure_info afi
;
3280 lookup_member (access_path
, guessed_id
, /*protect=*/1,
3281 /*want_type=*/false, /*complain=*/false,
3283 if (afi
.was_inaccessible_p ())
3285 tree accessor
= afi
.get_any_accessor (TYPE_READONLY (object_type
));
3288 /* The guessed name isn't directly accessible, but can be accessed
3289 via an accessor member function. */
3290 afi
.add_fixit_hint (&rich_loc
, accessor
);
3291 error_at (&rich_loc
,
3292 "%q#T has no member named %qE;"
3293 " did you mean %q#D? (accessible via %q#D)",
3294 TREE_CODE (access_path
) == TREE_BINFO
3295 ? TREE_TYPE (access_path
) : object_type
,
3296 name
, afi
.get_diag_decl (), accessor
);
3300 /* The guessed name isn't directly accessible, and no accessor
3301 member function could be found. */
3302 error_at (&rich_loc
,
3303 "%q#T has no member named %qE;"
3304 " did you mean %q#D? (not accessible from this context)",
3305 TREE_CODE (access_path
) == TREE_BINFO
3306 ? TREE_TYPE (access_path
) : object_type
,
3307 name
, afi
.get_diag_decl ());
3308 complain_about_access (afi
.get_decl (), afi
.get_diag_decl (),
3309 afi
.get_diag_decl (), false, ak_none
);
3314 /* The guessed name is directly accessible; suggest it. */
3315 rich_loc
.add_fixit_misspelled_id (bogus_component_loc
,
3317 error_at (&rich_loc
,
3318 "%q#T has no member named %qE;"
3319 " did you mean %qE?",
3320 TREE_CODE (access_path
) == TREE_BINFO
3321 ? TREE_TYPE (access_path
) : object_type
,
3326 /* This function is called by the parser to process a class member
3327 access expression of the form OBJECT.NAME. NAME is a node used by
3328 the parser to represent a name; it is not yet a DECL. It may,
3329 however, be a BASELINK where the BASELINK_FUNCTIONS is a
3330 TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and
3331 there is no reason to do the lookup twice, so the parser keeps the
3332 BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to
3333 be a template via the use of the "A::template B" syntax. */
3336 finish_class_member_access_expr (cp_expr object
, tree name
, bool template_p
,
3337 tsubst_flags_t complain
)
3342 tree access_path
= NULL_TREE
;
3343 tree orig_object
= object
;
3344 tree orig_name
= name
;
3346 if (object
== error_mark_node
|| name
== error_mark_node
)
3347 return error_mark_node
;
3349 /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */
3350 if (!objc_is_public (object
, name
))
3351 return error_mark_node
;
3353 object_type
= TREE_TYPE (object
);
3355 if (processing_template_decl
)
3357 if (/* If OBJECT is dependent, so is OBJECT.NAME. */
3358 type_dependent_object_expression_p (object
)
3359 /* If NAME is "f<args>", where either 'f' or 'args' is
3360 dependent, then the expression is dependent. */
3361 || (TREE_CODE (name
) == TEMPLATE_ID_EXPR
3362 && dependent_template_id_p (TREE_OPERAND (name
, 0),
3363 TREE_OPERAND (name
, 1)))
3364 /* If NAME is "T::X" where "T" is dependent, then the
3365 expression is dependent. */
3366 || (TREE_CODE (name
) == SCOPE_REF
3367 && TYPE_P (TREE_OPERAND (name
, 0))
3368 && dependent_scope_p (TREE_OPERAND (name
, 0)))
3369 /* If NAME is operator T where "T" is dependent, we can't
3370 lookup until we instantiate the T. */
3371 || (TREE_CODE (name
) == IDENTIFIER_NODE
3372 && IDENTIFIER_CONV_OP_P (name
)
3373 && dependent_type_p (TREE_TYPE (name
))))
3376 return build_min_nt_loc (UNKNOWN_LOCATION
, COMPONENT_REF
,
3377 orig_object
, orig_name
, NULL_TREE
);
3380 else if (c_dialect_objc ()
3381 && identifier_p (name
)
3382 && (expr
= objc_maybe_build_component_ref (object
, name
)))
3387 The type of the first expression shall be "class object" (of a
3389 if (!currently_open_class (object_type
)
3390 && !complete_type_or_maybe_complain (object_type
, object
, complain
))
3391 return error_mark_node
;
3392 if (!CLASS_TYPE_P (object_type
))
3394 if (complain
& tf_error
)
3396 if (INDIRECT_TYPE_P (object_type
)
3397 && CLASS_TYPE_P (TREE_TYPE (object_type
)))
3398 error ("request for member %qD in %qE, which is of pointer "
3399 "type %qT (maybe you meant to use %<->%> ?)",
3400 name
, object
.get_value (), object_type
);
3402 error ("request for member %qD in %qE, which is of non-class "
3403 "type %qT", name
, object
.get_value (), object_type
);
3405 return error_mark_node
;
3408 if (BASELINK_P (name
))
3409 /* A member function that has already been looked up. */
3413 bool is_template_id
= false;
3414 tree template_args
= NULL_TREE
;
3415 tree scope
= NULL_TREE
;
3417 access_path
= object_type
;
3419 if (TREE_CODE (name
) == SCOPE_REF
)
3421 /* A qualified name. The qualifying class or namespace `S'
3422 has already been looked up; it is either a TYPE or a
3424 scope
= TREE_OPERAND (name
, 0);
3425 name
= TREE_OPERAND (name
, 1);
3427 /* If SCOPE is a namespace, then the qualified name does not
3428 name a member of OBJECT_TYPE. */
3429 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
3431 if (complain
& tf_error
)
3432 error ("%<%D::%D%> is not a member of %qT",
3433 scope
, name
, object_type
);
3434 return error_mark_node
;
3438 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3440 is_template_id
= true;
3441 template_args
= TREE_OPERAND (name
, 1);
3442 name
= TREE_OPERAND (name
, 0);
3444 if (!identifier_p (name
))
3445 name
= OVL_NAME (name
);
3450 if (TREE_CODE (scope
) == ENUMERAL_TYPE
)
3452 gcc_assert (!is_template_id
);
3453 /* Looking up a member enumerator (c++/56793). */
3454 if (!TYPE_CLASS_SCOPE_P (scope
)
3455 || !DERIVED_FROM_P (TYPE_CONTEXT (scope
), object_type
))
3457 if (complain
& tf_error
)
3458 error ("%<%D::%D%> is not a member of %qT",
3459 scope
, name
, object_type
);
3460 return error_mark_node
;
3462 tree val
= lookup_enumerator (scope
, name
);
3465 if (complain
& tf_error
)
3466 error ("%qD is not a member of %qD",
3468 return error_mark_node
;
3471 if (TREE_SIDE_EFFECTS (object
))
3472 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
), object
, val
);
3476 gcc_assert (CLASS_TYPE_P (scope
));
3477 gcc_assert (identifier_p (name
) || TREE_CODE (name
) == BIT_NOT_EXPR
);
3479 if (constructor_name_p (name
, scope
))
3481 if (complain
& tf_error
)
3482 error ("cannot call constructor %<%T::%D%> directly",
3484 return error_mark_node
;
3487 /* Find the base of OBJECT_TYPE corresponding to SCOPE. */
3488 access_path
= lookup_base (object_type
, scope
, ba_check
,
3490 if (access_path
== error_mark_node
)
3491 return error_mark_node
;
3494 if (any_dependent_bases_p (object_type
))
3496 if (complain
& tf_error
)
3497 error ("%qT is not a base of %qT", scope
, object_type
);
3498 return error_mark_node
;
3502 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
3504 if (dependent_type_p (object_type
))
3505 /* The destructor isn't declared yet. */
3507 member
= lookup_destructor (object
, scope
, name
, complain
);
3511 /* Look up the member. */
3512 access_failure_info afi
;
3513 if (processing_template_decl
)
3514 /* Even though this class member access expression is at this
3515 point not dependent, the member itself may be dependent, and
3516 we must not potentially push a access check for a dependent
3517 member onto TI_DEFERRED_ACCESS_CHECKS. So don't check access
3518 ahead of time here; we're going to redo this member lookup at
3519 instantiation time anyway. */
3520 push_deferring_access_checks (dk_no_check
);
3521 member
= lookup_member (access_path
, name
, /*protect=*/1,
3522 /*want_type=*/false, complain
,
3524 if (processing_template_decl
)
3525 pop_deferring_access_checks ();
3526 afi
.maybe_suggest_accessor (TYPE_READONLY (object_type
));
3527 if (member
== NULL_TREE
)
3529 if (dependent_type_p (object_type
))
3530 /* Try again at instantiation time. */
3532 if (complain
& tf_error
)
3533 complain_about_unrecognized_member (access_path
, name
,
3535 return error_mark_node
;
3537 if (member
== error_mark_node
)
3538 return error_mark_node
;
3540 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (member
)))
3541 /* Dependent type attributes on the decl mean that the TREE_TYPE is
3542 wrong, so don't use it. */
3544 if (TREE_CODE (member
) == USING_DECL
&& DECL_DEPENDENT_P (member
))
3550 tree templ
= member
;
3552 if (BASELINK_P (templ
))
3553 member
= lookup_template_function (templ
, template_args
);
3554 else if (variable_template_p (templ
))
3555 member
= (lookup_and_finish_template_variable
3556 (templ
, template_args
, complain
));
3559 if (complain
& tf_error
)
3560 error ("%qD is not a member template function", name
);
3561 return error_mark_node
;
3566 if (TREE_UNAVAILABLE (member
))
3567 error_unavailable_use (member
, NULL_TREE
);
3568 else if (TREE_DEPRECATED (member
))
3569 warn_deprecated_use (member
, NULL_TREE
);
3572 check_template_keyword (member
);
3574 expr
= build_class_member_access_expr (object
, member
, access_path
,
3575 /*preserve_reference=*/false,
3577 if (processing_template_decl
&& expr
!= error_mark_node
)
3579 if (BASELINK_P (member
))
3581 if (TREE_CODE (orig_name
) == SCOPE_REF
)
3582 BASELINK_QUALIFIED_P (member
) = 1;
3585 return build_min_non_dep (COMPONENT_REF
, expr
,
3586 orig_object
, orig_name
,
3593 /* Build a COMPONENT_REF of OBJECT and MEMBER with the appropriate
3597 build_simple_component_ref (tree object
, tree member
)
3599 tree type
= cp_build_qualified_type (TREE_TYPE (member
),
3600 cp_type_quals (TREE_TYPE (object
)));
3601 return build3_loc (input_location
,
3602 COMPONENT_REF
, type
,
3603 object
, member
, NULL_TREE
);
3606 /* Return an expression for the MEMBER_NAME field in the internal
3607 representation of PTRMEM, a pointer-to-member function. (Each
3608 pointer-to-member function type gets its own RECORD_TYPE so it is
3609 more convenient to access the fields by name than by FIELD_DECL.)
3610 This routine converts the NAME to a FIELD_DECL and then creates the
3611 node for the complete expression. */
3614 build_ptrmemfunc_access_expr (tree ptrmem
, tree member_name
)
3619 if (TREE_CODE (ptrmem
) == CONSTRUCTOR
)
3621 for (auto &e
: CONSTRUCTOR_ELTS (ptrmem
))
3622 if (e
.index
&& DECL_P (e
.index
) && DECL_NAME (e
.index
) == member_name
)
3627 /* This code is a stripped down version of
3628 build_class_member_access_expr. It does not work to use that
3629 routine directly because it expects the object to be of class
3631 ptrmem_type
= TREE_TYPE (ptrmem
);
3632 gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type
));
3633 for (member
= TYPE_FIELDS (ptrmem_type
); member
;
3634 member
= DECL_CHAIN (member
))
3635 if (DECL_NAME (member
) == member_name
)
3637 return build_simple_component_ref (ptrmem
, member
);
3640 /* Return a TREE_LIST of namespace-scope overloads for the given operator,
3641 and for any other relevant operator. */
3644 op_unqualified_lookup (tree_code code
, bool is_assign
)
3646 tree lookups
= NULL_TREE
;
3648 if (cxx_dialect
>= cxx20
&& !is_assign
)
3650 if (code
== NE_EXPR
)
3652 /* != can get rewritten in terms of ==. */
3653 tree fnname
= ovl_op_identifier (false, EQ_EXPR
);
3654 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3655 lookups
= tree_cons (fnname
, fns
, lookups
);
3657 else if (code
== GT_EXPR
|| code
== LE_EXPR
3658 || code
== LT_EXPR
|| code
== GE_EXPR
)
3660 /* These can get rewritten in terms of <=>. */
3661 tree fnname
= ovl_op_identifier (false, SPACESHIP_EXPR
);
3662 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3663 lookups
= tree_cons (fnname
, fns
, lookups
);
3667 tree fnname
= ovl_op_identifier (is_assign
, code
);
3668 if (tree fns
= lookup_name (fnname
, LOOK_where::BLOCK_NAMESPACE
))
3669 lookups
= tree_cons (fnname
, fns
, lookups
);
3674 return build_tree_list (NULL_TREE
, NULL_TREE
);
3677 /* Create a DEPENDENT_OPERATOR_TYPE for a dependent operator expression of
3678 the given operator. LOOKUPS, if non-NULL, is the result of phase 1
3679 name lookup for the given operator. */
3682 build_dependent_operator_type (tree lookups
, tree_code code
, bool is_assign
)
3685 /* We're partially instantiating a dependent operator expression, and
3686 LOOKUPS is the result of phase 1 name lookup that we performed
3687 earlier at template definition time, so just reuse the corresponding
3688 DEPENDENT_OPERATOR_TYPE. */
3689 return TREE_TYPE (lookups
);
3691 /* Otherwise we're processing a dependent operator expression at template
3692 definition time, so perform phase 1 name lookup now. */
3693 lookups
= op_unqualified_lookup (code
, is_assign
);
3695 tree type
= cxx_make_type (DEPENDENT_OPERATOR_TYPE
);
3696 DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (type
) = lookups
;
3697 TREE_TYPE (lookups
) = type
;
3701 /* Given an expression PTR for a pointer, return an expression
3702 for the value pointed to.
3703 ERRORSTRING is the name of the operator to appear in error messages.
3705 This function may need to overload OPERATOR_FNNAME.
3706 Must also handle REFERENCE_TYPEs for C++. */
3709 build_x_indirect_ref (location_t loc
, tree expr
, ref_operator errorstring
,
3710 tree lookups
, tsubst_flags_t complain
)
3712 tree orig_expr
= expr
;
3714 tree overload
= NULL_TREE
;
3716 if (processing_template_decl
)
3718 /* Retain the type if we know the operand is a pointer. */
3719 if (TREE_TYPE (expr
) && INDIRECT_TYPE_P (TREE_TYPE (expr
)))
3721 if (expr
== current_class_ptr
3722 || (TREE_CODE (expr
) == NOP_EXPR
3723 && TREE_OPERAND (expr
, 0) == current_class_ptr
3724 && (same_type_ignoring_top_level_qualifiers_p
3725 (TREE_TYPE (expr
), TREE_TYPE (current_class_ptr
)))))
3726 return current_class_ref
;
3727 return build_min (INDIRECT_REF
, TREE_TYPE (TREE_TYPE (expr
)), expr
);
3729 if (type_dependent_expression_p (expr
))
3731 expr
= build_min_nt_loc (loc
, INDIRECT_REF
, expr
);
3733 = build_dependent_operator_type (lookups
, INDIRECT_REF
, false);
3738 rval
= build_new_op (loc
, INDIRECT_REF
, LOOKUP_NORMAL
, expr
,
3739 NULL_TREE
, NULL_TREE
, lookups
,
3740 &overload
, complain
);
3742 rval
= cp_build_indirect_ref (loc
, expr
, errorstring
, complain
);
3744 if (processing_template_decl
&& rval
!= error_mark_node
)
3746 if (overload
!= NULL_TREE
)
3747 return (build_min_non_dep_op_overload
3748 (INDIRECT_REF
, rval
, overload
, orig_expr
));
3750 return build_min_non_dep (INDIRECT_REF
, rval
, orig_expr
);
3756 /* Like c-family strict_aliasing_warning, but don't warn for dependent
3757 types or expressions. */
3760 cp_strict_aliasing_warning (location_t loc
, tree type
, tree expr
)
3762 if (processing_template_decl
)
3766 if (dependent_type_p (type
) || type_dependent_expression_p (e
))
3769 return strict_aliasing_warning (loc
, type
, expr
);
3772 /* The implementation of the above, and of indirection implied by other
3773 constructs. If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR. */
3776 cp_build_indirect_ref_1 (location_t loc
, tree ptr
, ref_operator errorstring
,
3777 tsubst_flags_t complain
, bool do_fold
)
3781 /* RO_NULL should only be used with the folding entry points below, not
3782 cp_build_indirect_ref. */
3783 gcc_checking_assert (errorstring
!= RO_NULL
|| do_fold
);
3785 if (ptr
== current_class_ptr
3786 || (TREE_CODE (ptr
) == NOP_EXPR
3787 && TREE_OPERAND (ptr
, 0) == current_class_ptr
3788 && (same_type_ignoring_top_level_qualifiers_p
3789 (TREE_TYPE (ptr
), TREE_TYPE (current_class_ptr
)))))
3790 return current_class_ref
;
3792 pointer
= (TYPE_REF_P (TREE_TYPE (ptr
))
3793 ? ptr
: decay_conversion (ptr
, complain
));
3794 if (pointer
== error_mark_node
)
3795 return error_mark_node
;
3797 type
= TREE_TYPE (pointer
);
3799 if (INDIRECT_TYPE_P (type
))
3803 If the type of the expression is "pointer to T," the type
3804 of the result is "T." */
3805 tree t
= TREE_TYPE (type
);
3807 if ((CONVERT_EXPR_P (ptr
)
3808 || TREE_CODE (ptr
) == VIEW_CONVERT_EXPR
)
3809 && (!CLASS_TYPE_P (t
) || !CLASSTYPE_EMPTY_P (t
)))
3811 /* If a warning is issued, mark it to avoid duplicates from
3812 the backend. This only needs to be done at
3813 warn_strict_aliasing > 2. */
3814 if (warn_strict_aliasing
> 2
3815 && cp_strict_aliasing_warning (EXPR_LOCATION (ptr
),
3816 type
, TREE_OPERAND (ptr
, 0)))
3817 suppress_warning (ptr
, OPT_Wstrict_aliasing
);
3820 if (VOID_TYPE_P (t
))
3822 /* A pointer to incomplete type (other than cv void) can be
3823 dereferenced [expr.unary.op]/1 */
3824 if (complain
& tf_error
)
3825 error_at (loc
, "%qT is not a pointer-to-object type", type
);
3826 return error_mark_node
;
3828 else if (do_fold
&& TREE_CODE (pointer
) == ADDR_EXPR
3829 && same_type_p (t
, TREE_TYPE (TREE_OPERAND (pointer
, 0))))
3830 /* The POINTER was something like `&x'. We simplify `*&x' to
3832 return TREE_OPERAND (pointer
, 0);
3835 tree ref
= build1 (INDIRECT_REF
, t
, pointer
);
3837 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
3838 so that we get the proper error message if the result is used
3839 to assign to. Also, &* is supposed to be a no-op. */
3840 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
3841 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
3842 TREE_SIDE_EFFECTS (ref
)
3843 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (pointer
));
3847 else if (!(complain
& tf_error
))
3848 /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */
3850 /* `pointer' won't be an error_mark_node if we were given a
3851 pointer to member, so it's cool to check for this here. */
3852 else if (TYPE_PTRMEM_P (type
))
3853 switch (errorstring
)
3855 case RO_ARRAY_INDEXING
:
3857 "invalid use of array indexing on pointer to member");
3860 error_at (loc
, "invalid use of unary %<*%> on pointer to member");
3862 case RO_IMPLICIT_CONVERSION
:
3863 error_at (loc
, "invalid use of implicit conversion on pointer "
3867 error_at (loc
, "left hand operand of %<->*%> must be a pointer to "
3868 "class, but is a pointer to member of type %qT", type
);
3873 else if (pointer
!= error_mark_node
)
3874 invalid_indirection_error (loc
, type
, errorstring
);
3876 return error_mark_node
;
3879 /* Entry point used by c-common, which expects folding. */
3882 build_indirect_ref (location_t loc
, tree ptr
, ref_operator errorstring
)
3884 return cp_build_indirect_ref_1 (loc
, ptr
, errorstring
,
3885 tf_warning_or_error
, true);
3888 /* Entry point used by internal indirection needs that don't correspond to any
3889 syntactic construct. */
3892 cp_build_fold_indirect_ref (tree pointer
)
3894 return cp_build_indirect_ref_1 (input_location
, pointer
, RO_NULL
,
3895 tf_warning_or_error
, true);
3898 /* Entry point used by indirection needs that correspond to some syntactic
3902 cp_build_indirect_ref (location_t loc
, tree ptr
, ref_operator errorstring
,
3903 tsubst_flags_t complain
)
3905 return cp_build_indirect_ref_1 (loc
, ptr
, errorstring
, complain
, false);
3908 /* This handles expressions of the form "a[i]", which denotes
3911 This is logically equivalent in C to *(a+i), but we may do it differently.
3912 If A is a variable or a member, we generate a primitive ARRAY_REF.
3913 This avoids forcing the array out of registers, and can work on
3914 arrays that are not lvalues (for example, members of structures returned
3917 If INDEX is of some user-defined type, it must be converted to
3918 integer type. Otherwise, to make a compatible PLUS_EXPR, it
3919 will inherit the type of the array, which will be some pointer type.
3921 LOC is the location to use in building the array reference. */
3924 cp_build_array_ref (location_t loc
, tree array
, tree idx
,
3925 tsubst_flags_t complain
)
3931 if (complain
& tf_error
)
3932 error_at (loc
, "subscript missing in array reference");
3933 return error_mark_node
;
3936 if (TREE_TYPE (array
) == error_mark_node
3937 || TREE_TYPE (idx
) == error_mark_node
)
3938 return error_mark_node
;
3940 /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
3942 switch (TREE_CODE (array
))
3946 tree value
= cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3948 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3949 TREE_OPERAND (array
, 0), value
);
3950 SET_EXPR_LOCATION (ret
, loc
);
3955 ret
= build_conditional_expr
3956 (loc
, TREE_OPERAND (array
, 0),
3957 cp_build_array_ref (loc
, TREE_OPERAND (array
, 1), idx
,
3959 cp_build_array_ref (loc
, TREE_OPERAND (array
, 2), idx
,
3962 protected_set_expr_location (ret
, loc
);
3969 bool non_lvalue
= convert_vector_to_array_for_subscript (loc
, &array
, idx
);
3971 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
3975 warn_array_subscript_with_type_char (loc
, idx
);
3977 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx
)))
3979 if (complain
& tf_error
)
3980 error_at (loc
, "array subscript is not an integer");
3981 return error_mark_node
;
3984 /* Apply integral promotions *after* noticing character types.
3985 (It is unclear why we do these promotions -- the standard
3986 does not say that we should. In fact, the natural thing would
3987 seem to be to convert IDX to ptrdiff_t; we're performing
3988 pointer arithmetic.) */
3989 idx
= cp_perform_integral_promotions (idx
, complain
);
3991 idx
= maybe_fold_non_dependent_expr (idx
, complain
);
3993 /* An array that is indexed by a non-constant
3994 cannot be stored in a register; we must be able to do
3995 address arithmetic on its address.
3996 Likewise an array of elements of variable size. */
3997 if (TREE_CODE (idx
) != INTEGER_CST
3998 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
3999 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
))))
4002 if (!cxx_mark_addressable (array
, true))
4003 return error_mark_node
;
4006 /* An array that is indexed by a constant value which is not within
4007 the array bounds cannot be stored in a register either; because we
4008 would get a crash in store_bit_field/extract_bit_field when trying
4009 to access a non-existent part of the register. */
4010 if (TREE_CODE (idx
) == INTEGER_CST
4011 && TYPE_DOMAIN (TREE_TYPE (array
))
4012 && ! int_fits_type_p (idx
, TYPE_DOMAIN (TREE_TYPE (array
))))
4014 if (!cxx_mark_addressable (array
))
4015 return error_mark_node
;
4018 /* Note in C++ it is valid to subscript a `register' array, since
4019 it is valid to take the address of something with that
4020 storage specification. */
4024 while (TREE_CODE (foo
) == COMPONENT_REF
)
4025 foo
= TREE_OPERAND (foo
, 0);
4026 if (VAR_P (foo
) && DECL_REGISTER (foo
)
4027 && (complain
& tf_warning
))
4028 warning_at (loc
, OPT_Wextra
,
4029 "subscripting array declared %<register%>");
4032 type
= TREE_TYPE (TREE_TYPE (array
));
4033 rval
= build4 (ARRAY_REF
, type
, array
, idx
, NULL_TREE
, NULL_TREE
);
4034 /* Array ref is const/volatile if the array elements are
4035 or if the array is.. */
4036 TREE_READONLY (rval
)
4037 |= (CP_TYPE_CONST_P (type
) | TREE_READONLY (array
));
4038 TREE_SIDE_EFFECTS (rval
)
4039 |= (CP_TYPE_VOLATILE_P (type
) | TREE_SIDE_EFFECTS (array
));
4040 TREE_THIS_VOLATILE (rval
)
4041 |= (CP_TYPE_VOLATILE_P (type
) | TREE_THIS_VOLATILE (array
));
4042 ret
= require_complete_type (rval
, complain
);
4043 protected_set_expr_location (ret
, loc
);
4045 ret
= non_lvalue_loc (loc
, ret
);
4050 tree ar
= cp_default_conversion (array
, complain
);
4051 tree ind
= cp_default_conversion (idx
, complain
);
4052 tree first
= NULL_TREE
;
4054 if (flag_strong_eval_order
== 2 && TREE_SIDE_EFFECTS (ind
))
4055 ar
= first
= save_expr (ar
);
4057 /* Put the integer in IND to simplify error checking. */
4058 if (TREE_CODE (TREE_TYPE (ar
)) == INTEGER_TYPE
)
4059 std::swap (ar
, ind
);
4061 if (ar
== error_mark_node
|| ind
== error_mark_node
)
4062 return error_mark_node
;
4064 if (!TYPE_PTR_P (TREE_TYPE (ar
)))
4066 if (complain
& tf_error
)
4067 error_at (loc
, "subscripted value is neither array nor pointer");
4068 return error_mark_node
;
4070 if (TREE_CODE (TREE_TYPE (ind
)) != INTEGER_TYPE
)
4072 if (complain
& tf_error
)
4073 error_at (loc
, "array subscript is not an integer");
4074 return error_mark_node
;
4077 warn_array_subscript_with_type_char (loc
, idx
);
4079 ret
= cp_build_binary_op (input_location
, PLUS_EXPR
, ar
, ind
, complain
);
4081 ret
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (ret
), first
, ret
);
4082 ret
= cp_build_indirect_ref (loc
, ret
, RO_ARRAY_INDEXING
, complain
);
4083 protected_set_expr_location (ret
, loc
);
4085 ret
= non_lvalue_loc (loc
, ret
);
4090 /* Entry point for Obj-C++. */
4093 build_array_ref (location_t loc
, tree array
, tree idx
)
4095 return cp_build_array_ref (loc
, array
, idx
, tf_warning_or_error
);
4098 /* Resolve a pointer to member function. INSTANCE is the object
4099 instance to use, if the member points to a virtual member.
4101 This used to avoid checking for virtual functions if basetype
4102 has no virtual functions, according to an earlier ANSI draft.
4103 With the final ISO C++ rules, such an optimization is
4104 incorrect: A pointer to a derived member can be static_cast
4105 to pointer-to-base-member, as long as the dynamic object
4106 later has the right member. So now we only do this optimization
4107 when we know the dynamic type of the object. */
4110 get_member_function_from_ptrfunc (tree
*instance_ptrptr
, tree function
,
4111 tsubst_flags_t complain
)
4113 if (TREE_CODE (function
) == OFFSET_REF
)
4114 function
= TREE_OPERAND (function
, 1);
4116 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function
)))
4118 tree idx
, delta
, e1
, e2
, e3
, vtbl
;
4120 tree fntype
= TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function
));
4121 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (fntype
));
4123 tree instance_ptr
= *instance_ptrptr
;
4124 tree instance_save_expr
= 0;
4125 if (instance_ptr
== error_mark_node
)
4127 if (TREE_CODE (function
) == PTRMEM_CST
)
4129 /* Extracting the function address from a pmf is only
4130 allowed with -Wno-pmf-conversions. It only works for
4132 e1
= build_addr_func (PTRMEM_CST_MEMBER (function
), complain
);
4133 e1
= convert (fntype
, e1
);
4138 if (complain
& tf_error
)
4139 error ("object missing in use of %qE", function
);
4140 return error_mark_node
;
4144 /* True if we know that the dynamic type of the object doesn't have
4145 virtual functions, so we can assume the PFN field is a pointer. */
4146 nonvirtual
= (COMPLETE_TYPE_P (basetype
)
4147 && !TYPE_POLYMORPHIC_P (basetype
)
4148 && resolves_to_fixed_type_p (instance_ptr
, 0));
4150 /* If we don't really have an object (i.e. in an ill-formed
4151 conversion from PMF to pointer), we can't resolve virtual
4152 functions anyway. */
4153 if (!nonvirtual
&& is_dummy_object (instance_ptr
))
4156 if (TREE_SIDE_EFFECTS (instance_ptr
))
4157 instance_ptr
= instance_save_expr
= save_expr (instance_ptr
);
4159 if (TREE_SIDE_EFFECTS (function
))
4160 function
= save_expr (function
);
4162 /* Start by extracting all the information from the PMF itself. */
4163 e3
= pfn_from_ptrmemfunc (function
);
4164 delta
= delta_from_ptrmemfunc (function
);
4165 idx
= build1 (NOP_EXPR
, vtable_index_type
, e3
);
4166 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
4168 int flag_sanitize_save
;
4169 case ptrmemfunc_vbit_in_pfn
:
4170 e1
= cp_build_binary_op (input_location
,
4171 BIT_AND_EXPR
, idx
, integer_one_node
,
4173 idx
= cp_build_binary_op (input_location
,
4174 MINUS_EXPR
, idx
, integer_one_node
,
4176 if (idx
== error_mark_node
)
4177 return error_mark_node
;
4180 case ptrmemfunc_vbit_in_delta
:
4181 e1
= cp_build_binary_op (input_location
,
4182 BIT_AND_EXPR
, delta
, integer_one_node
,
4184 /* Don't instrument the RSHIFT_EXPR we're about to create because
4185 we're going to use DELTA number of times, and that wouldn't play
4186 well with SAVE_EXPRs therein. */
4187 flag_sanitize_save
= flag_sanitize
;
4189 delta
= cp_build_binary_op (input_location
,
4190 RSHIFT_EXPR
, delta
, integer_one_node
,
4192 flag_sanitize
= flag_sanitize_save
;
4193 if (delta
== error_mark_node
)
4194 return error_mark_node
;
4201 if (e1
== error_mark_node
)
4202 return error_mark_node
;
4204 /* Convert down to the right base before using the instance. A
4205 special case is that in a pointer to member of class C, C may
4206 be incomplete. In that case, the function will of course be
4207 a member of C, and no conversion is required. In fact,
4208 lookup_base will fail in that case, because incomplete
4209 classes do not have BINFOs. */
4210 if (!same_type_ignoring_top_level_qualifiers_p
4211 (basetype
, TREE_TYPE (TREE_TYPE (instance_ptr
))))
4213 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr
)),
4214 basetype
, ba_check
, NULL
, complain
);
4215 instance_ptr
= build_base_path (PLUS_EXPR
, instance_ptr
, basetype
,
4217 if (instance_ptr
== error_mark_node
)
4218 return error_mark_node
;
4220 /* ...and then the delta in the PMF. */
4221 instance_ptr
= fold_build_pointer_plus (instance_ptr
, delta
);
4223 /* Hand back the adjusted 'this' argument to our caller. */
4224 *instance_ptrptr
= instance_ptr
;
4227 /* Now just return the pointer. */
4230 /* Next extract the vtable pointer from the object. */
4231 vtbl
= build1 (NOP_EXPR
, build_pointer_type (vtbl_ptr_type_node
),
4233 vtbl
= cp_build_fold_indirect_ref (vtbl
);
4234 if (vtbl
== error_mark_node
)
4235 return error_mark_node
;
4237 /* Finally, extract the function pointer from the vtable. */
4238 e2
= fold_build_pointer_plus_loc (input_location
, vtbl
, idx
);
4239 e2
= cp_build_fold_indirect_ref (e2
);
4240 if (e2
== error_mark_node
)
4241 return error_mark_node
;
4242 TREE_CONSTANT (e2
) = 1;
4244 /* When using function descriptors, the address of the
4245 vtable entry is treated as a function pointer. */
4246 if (TARGET_VTABLE_USES_DESCRIPTORS
)
4247 e2
= build1 (NOP_EXPR
, TREE_TYPE (e2
),
4248 cp_build_addr_expr (e2
, complain
));
4250 e2
= fold_convert (TREE_TYPE (e3
), e2
);
4251 e1
= build_conditional_expr (input_location
, e1
, e2
, e3
, complain
);
4252 if (e1
== error_mark_node
)
4253 return error_mark_node
;
4255 /* Make sure this doesn't get evaluated first inside one of the
4256 branches of the COND_EXPR. */
4257 if (instance_save_expr
)
4258 e1
= build2 (COMPOUND_EXPR
, TREE_TYPE (e1
),
4259 instance_save_expr
, e1
);
4266 /* Used by the C-common bits. */
4268 build_function_call (location_t
/*loc*/,
4269 tree function
, tree params
)
4271 return cp_build_function_call (function
, params
, tf_warning_or_error
);
4274 /* Used by the C-common bits. */
4276 build_function_call_vec (location_t
/*loc*/, vec
<location_t
> /*arg_loc*/,
4277 tree function
, vec
<tree
, va_gc
> *params
,
4278 vec
<tree
, va_gc
> * /*origtypes*/, tree orig_function
)
4280 vec
<tree
, va_gc
> *orig_params
= params
;
4281 tree ret
= cp_build_function_call_vec (function
, ¶ms
,
4282 tf_warning_or_error
, orig_function
);
4284 /* cp_build_function_call_vec can reallocate PARAMS by adding
4285 default arguments. That should never happen here. Verify
4287 gcc_assert (params
== orig_params
);
4292 /* Build a function call using a tree list of arguments. */
4295 cp_build_function_call (tree function
, tree params
, tsubst_flags_t complain
)
4300 for (; params
!= NULL_TREE
; params
= TREE_CHAIN (params
))
4301 vec_safe_push (vec
, TREE_VALUE (params
));
4302 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
4306 /* Build a function call using varargs. */
4309 cp_build_function_call_nary (tree function
, tsubst_flags_t complain
, ...)
4315 va_start (args
, complain
);
4316 for (t
= va_arg (args
, tree
); t
!= NULL_TREE
; t
= va_arg (args
, tree
))
4317 vec_safe_push (vec
, t
);
4319 ret
= cp_build_function_call_vec (function
, &vec
, complain
);
4323 /* Build a function call using a vector of arguments.
4324 If FUNCTION is the result of resolving an overloaded target built-in,
4325 ORIG_FNDECL is the original function decl, otherwise it is null.
4326 PARAMS may be NULL if there are no parameters. This changes the
4327 contents of PARAMS. */
4330 cp_build_function_call_vec (tree function
, vec
<tree
, va_gc
> **params
,
4331 tsubst_flags_t complain
, tree orig_fndecl
)
4333 tree fntype
, fndecl
;
4335 tree original
= function
;
4339 vec
<tree
, va_gc
> *allocated
= NULL
;
4342 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
4343 expressions, like those used for ObjC messenger dispatches. */
4344 if (params
!= NULL
&& !vec_safe_is_empty (*params
))
4345 function
= objc_rewrite_function_call (function
, (**params
)[0]);
4347 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4348 Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */
4349 if (TREE_CODE (function
) == NOP_EXPR
4350 && TREE_TYPE (function
) == TREE_TYPE (TREE_OPERAND (function
, 0)))
4351 function
= TREE_OPERAND (function
, 0);
4353 if (TREE_CODE (function
) == FUNCTION_DECL
)
4355 if (!mark_used (function
, complain
))
4356 return error_mark_node
;
4359 /* Convert anything with function type to a pointer-to-function. */
4360 if (DECL_MAIN_P (function
))
4362 if (complain
& tf_error
)
4363 pedwarn (input_location
, OPT_Wpedantic
,
4364 "ISO C++ forbids calling %<::main%> from within program");
4366 return error_mark_node
;
4368 function
= build_addr_func (function
, complain
);
4374 function
= build_addr_func (function
, complain
);
4377 if (function
== error_mark_node
)
4378 return error_mark_node
;
4380 fntype
= TREE_TYPE (function
);
4382 if (TYPE_PTRMEMFUNC_P (fntype
))
4384 if (complain
& tf_error
)
4385 error ("must use %<.*%> or %<->*%> to call pointer-to-member "
4386 "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
4387 original
, original
);
4388 return error_mark_node
;
4391 is_method
= (TYPE_PTR_P (fntype
)
4392 && TREE_CODE (TREE_TYPE (fntype
)) == METHOD_TYPE
);
4394 if (!(TYPE_PTRFN_P (fntype
)
4396 || TREE_CODE (function
) == TEMPLATE_ID_EXPR
))
4398 if (complain
& tf_error
)
4400 if (!flag_diagnostics_show_caret
)
4401 error_at (input_location
,
4402 "%qE cannot be used as a function", original
);
4403 else if (DECL_P (original
))
4404 error_at (input_location
,
4405 "%qD cannot be used as a function", original
);
4407 error_at (input_location
,
4408 "expression cannot be used as a function");
4411 return error_mark_node
;
4414 /* fntype now gets the type of function pointed to. */
4415 fntype
= TREE_TYPE (fntype
);
4416 parm_types
= TYPE_ARG_TYPES (fntype
);
4420 allocated
= make_tree_vector ();
4421 params
= &allocated
;
4424 nargs
= convert_arguments (parm_types
, params
, fndecl
, LOOKUP_NORMAL
,
4427 return error_mark_node
;
4429 argarray
= (*params
)->address ();
4431 /* Check for errors in format strings and inappropriately
4433 bool warned_p
= check_function_arguments (input_location
, fndecl
, fntype
,
4434 nargs
, argarray
, NULL
);
4436 ret
= build_cxx_call (function
, nargs
, argarray
, complain
, orig_fndecl
);
4440 tree c
= extract_call_expr (ret
);
4441 if (TREE_CODE (c
) == CALL_EXPR
)
4442 suppress_warning (c
, OPT_Wnonnull
);
4445 if (allocated
!= NULL
)
4446 release_tree_vector (allocated
);
4451 /* Subroutine of convert_arguments.
4452 Print an error message about a wrong number of arguments. */
4455 error_args_num (location_t loc
, tree fndecl
, bool too_many_p
)
4459 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
)
4461 if (DECL_NAME (fndecl
) == NULL_TREE
4462 || (DECL_NAME (fndecl
)
4463 == DECL_NAME (TYPE_NAME (DECL_CONTEXT (fndecl
)))))
4466 ? G_("too many arguments to constructor %q#D")
4467 : G_("too few arguments to constructor %q#D"),
4472 ? G_("too many arguments to member function %q#D")
4473 : G_("too few arguments to member function %q#D"),
4479 ? G_("too many arguments to function %q#D")
4480 : G_("too few arguments to function %q#D"),
4482 if (!DECL_IS_UNDECLARED_BUILTIN (fndecl
))
4483 inform (DECL_SOURCE_LOCATION (fndecl
), "declared here");
4487 if (c_dialect_objc () && objc_message_selector ())
4490 ? G_("too many arguments to method %q#D")
4491 : G_("too few arguments to method %q#D"),
4492 objc_message_selector ());
4494 error_at (loc
, too_many_p
? G_("too many arguments to function")
4495 : G_("too few arguments to function"));
4499 /* Convert the actual parameter expressions in the list VALUES to the
4500 types in the list TYPELIST. The converted expressions are stored
4501 back in the VALUES vector.
4502 If parmdecls is exhausted, or when an element has NULL as its type,
4503 perform the default conversions.
4505 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
4507 This is also where warnings about wrong number of args are generated.
4509 Returns the actual number of arguments processed (which might be less
4510 than the length of the vector), or -1 on error.
4512 In C++, unspecified trailing parameters can be filled in with their
4513 default arguments, if such were specified. Do so here. */
4516 convert_arguments (tree typelist
, vec
<tree
, va_gc
> **values
, tree fndecl
,
4517 int flags
, tsubst_flags_t complain
)
4522 /* Argument passing is always copy-initialization. */
4523 flags
|= LOOKUP_ONLYCONVERTING
;
4525 for (i
= 0, typetail
= typelist
;
4526 i
< vec_safe_length (*values
);
4529 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
4530 tree val
= (**values
)[i
];
4532 if (val
== error_mark_node
|| type
== error_mark_node
)
4535 if (type
== void_type_node
)
4537 if (complain
& tf_error
)
4539 error_args_num (input_location
, fndecl
, /*too_many_p=*/true);
4546 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4547 Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */
4548 if (TREE_CODE (val
) == NOP_EXPR
4549 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0))
4550 && (type
== 0 || !TYPE_REF_P (type
)))
4551 val
= TREE_OPERAND (val
, 0);
4553 if (type
== 0 || !TYPE_REF_P (type
))
4555 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
4556 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (val
)))
4557 val
= decay_conversion (val
, complain
);
4560 if (val
== error_mark_node
)
4565 /* Formal parm type is specified by a function prototype. */
4568 if (!COMPLETE_TYPE_P (complete_type (type
)))
4570 if (complain
& tf_error
)
4572 location_t loc
= EXPR_LOC_OR_LOC (val
, input_location
);
4575 auto_diagnostic_group d
;
4577 "parameter %P of %qD has incomplete type %qT",
4579 inform (get_fndecl_argument_location (fndecl
, i
),
4583 error_at (loc
, "parameter %P has incomplete type %qT", i
,
4586 parmval
= error_mark_node
;
4590 parmval
= convert_for_initialization
4591 (NULL_TREE
, type
, val
, flags
,
4592 ICR_ARGPASS
, fndecl
, i
, complain
);
4593 parmval
= convert_for_arg_passing (type
, parmval
, complain
);
4596 if (parmval
== error_mark_node
)
4599 (**values
)[i
] = parmval
;
4603 int magic
= fndecl
? magic_varargs_p (fndecl
) : 0;
4606 /* Don't truncate excess precision to the semantic type. */
4607 if (magic
== 1 && TREE_CODE (val
) == EXCESS_PRECISION_EXPR
)
4608 val
= TREE_OPERAND (val
, 0);
4609 /* Don't do ellipsis conversion for __built_in_constant_p
4610 as this will result in spurious errors for non-trivial
4612 val
= require_complete_type (val
, complain
);
4615 val
= convert_arg_to_ellipsis (val
, complain
);
4617 (**values
)[i
] = val
;
4621 typetail
= TREE_CHAIN (typetail
);
4624 if (typetail
!= 0 && typetail
!= void_list_node
)
4626 /* See if there are default arguments that can be used. Because
4627 we hold default arguments in the FUNCTION_TYPE (which is so
4628 wrong), we can see default parameters here from deduced
4629 contexts (and via typeof) for indirect function calls.
4630 Fortunately we know whether we have a function decl to
4631 provide default arguments in a language conformant
4633 if (fndecl
&& TREE_PURPOSE (typetail
)
4634 && TREE_CODE (TREE_PURPOSE (typetail
)) != DEFERRED_PARSE
)
4636 for (; typetail
!= void_list_node
; ++i
)
4638 /* After DR777, with explicit template args we can end up with a
4639 default argument followed by no default argument. */
4640 if (!TREE_PURPOSE (typetail
))
4643 = convert_default_arg (TREE_VALUE (typetail
),
4644 TREE_PURPOSE (typetail
),
4645 fndecl
, i
, complain
);
4647 if (parmval
== error_mark_node
)
4650 vec_safe_push (*values
, parmval
);
4651 typetail
= TREE_CHAIN (typetail
);
4652 /* ends with `...'. */
4653 if (typetail
== NULL_TREE
)
4658 if (typetail
&& typetail
!= void_list_node
)
4660 if (complain
& tf_error
)
4661 error_args_num (input_location
, fndecl
, /*too_many_p=*/false);
4669 /* Build a binary-operation expression, after performing default
4670 conversions on the operands. CODE is the kind of expression to
4671 build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE
4672 are the tree codes which correspond to ARG1 and ARG2 when issuing
4673 warnings about possibly misplaced parentheses. They may differ
4674 from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
4675 folding (e.g., if the parser sees "a | 1 + 1", it may call this
4676 routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
4677 To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
4678 ARG2_CODE as ERROR_MARK. */
4681 build_x_binary_op (const op_location_t
&loc
, enum tree_code code
, tree arg1
,
4682 enum tree_code arg1_code
, tree arg2
,
4683 enum tree_code arg2_code
, tree lookups
,
4684 tree
*overload_p
, tsubst_flags_t complain
)
4689 tree overload
= NULL_TREE
;
4694 if (processing_template_decl
)
4696 if (type_dependent_expression_p (arg1
)
4697 || type_dependent_expression_p (arg2
))
4699 expr
= build_min_nt_loc (loc
, code
, arg1
, arg2
);
4701 = build_dependent_operator_type (lookups
, code
, false);
4706 if (code
== DOTSTAR_EXPR
)
4707 expr
= build_m_component_ref (arg1
, arg2
, complain
);
4709 expr
= build_new_op (loc
, code
, LOOKUP_NORMAL
, arg1
, arg2
, NULL_TREE
,
4710 lookups
, &overload
, complain
);
4712 if (overload_p
!= NULL
)
4713 *overload_p
= overload
;
4715 /* Check for cases such as x+y<<z which users are likely to
4716 misinterpret. But don't warn about obj << x + y, since that is a
4717 common idiom for I/O. */
4718 if (warn_parentheses
4719 && (complain
& tf_warning
)
4720 && !processing_template_decl
4721 && !error_operand_p (arg1
)
4722 && !error_operand_p (arg2
)
4723 && (code
!= LSHIFT_EXPR
4724 || !CLASS_TYPE_P (TREE_TYPE (arg1
))))
4725 warn_about_parentheses (loc
, code
, arg1_code
, orig_arg1
,
4726 arg2_code
, orig_arg2
);
4728 if (processing_template_decl
&& expr
!= error_mark_node
)
4730 if (overload
!= NULL_TREE
)
4731 return (build_min_non_dep_op_overload
4732 (code
, expr
, overload
, orig_arg1
, orig_arg2
));
4734 return build_min_non_dep (code
, expr
, orig_arg1
, orig_arg2
);
4740 /* Build and return an ARRAY_REF expression. */
4743 build_x_array_ref (location_t loc
, tree arg1
, tree arg2
,
4744 tsubst_flags_t complain
)
4746 tree orig_arg1
= arg1
;
4747 tree orig_arg2
= arg2
;
4749 tree overload
= NULL_TREE
;
4751 if (processing_template_decl
)
4753 if (type_dependent_expression_p (arg1
)
4754 || type_dependent_expression_p (arg2
))
4755 return build_min_nt_loc (loc
, ARRAY_REF
, arg1
, arg2
,
4756 NULL_TREE
, NULL_TREE
);
4759 expr
= build_new_op (loc
, ARRAY_REF
, LOOKUP_NORMAL
, arg1
, arg2
,
4760 NULL_TREE
, NULL_TREE
, &overload
, complain
);
4762 if (processing_template_decl
&& expr
!= error_mark_node
)
4764 if (overload
!= NULL_TREE
)
4765 return (build_min_non_dep_op_overload
4766 (ARRAY_REF
, expr
, overload
, orig_arg1
, orig_arg2
));
4768 return build_min_non_dep (ARRAY_REF
, expr
, orig_arg1
, orig_arg2
,
4769 NULL_TREE
, NULL_TREE
);
4774 /* Return whether OP is an expression of enum type cast to integer
4775 type. In C++ even unsigned enum types are cast to signed integer
4776 types. We do not want to issue warnings about comparisons between
4777 signed and unsigned types when one of the types is an enum type.
4778 Those warnings are always false positives in practice. */
4781 enum_cast_to_int (tree op
)
4783 if (CONVERT_EXPR_P (op
)
4784 && TREE_TYPE (op
) == integer_type_node
4785 && TREE_CODE (TREE_TYPE (TREE_OPERAND (op
, 0))) == ENUMERAL_TYPE
4786 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op
, 0))))
4789 /* The cast may have been pushed into a COND_EXPR. */
4790 if (TREE_CODE (op
) == COND_EXPR
)
4791 return (enum_cast_to_int (TREE_OPERAND (op
, 1))
4792 || enum_cast_to_int (TREE_OPERAND (op
, 2)));
4797 /* For the c-common bits. */
4799 build_binary_op (location_t location
, enum tree_code code
, tree op0
, tree op1
,
4802 return cp_build_binary_op (location
, code
, op0
, op1
, tf_warning_or_error
);
4805 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
4806 into a value of TYPE type. Comparison is done via VEC_COND_EXPR. */
4809 build_vec_cmp (tree_code code
, tree type
,
4810 tree arg0
, tree arg1
)
4812 tree zero_vec
= build_zero_cst (type
);
4813 tree minus_one_vec
= build_minus_one_cst (type
);
4814 tree cmp_type
= truth_type_for (TREE_TYPE (arg0
));
4815 tree cmp
= build2 (code
, cmp_type
, arg0
, arg1
);
4816 return build3 (VEC_COND_EXPR
, type
, cmp
, minus_one_vec
, zero_vec
);
4819 /* Possibly warn about an address never being NULL. */
4822 warn_for_null_address (location_t location
, tree op
, tsubst_flags_t complain
)
4824 /* Prevent warnings issued for macro expansion. */
4826 || (complain
& tf_warning
) == 0
4827 || c_inhibit_evaluation_warnings
!= 0
4828 || from_macro_expansion_at (location
)
4829 || warning_suppressed_p (op
, OPT_Waddress
))
4832 tree cop
= fold_for_warn (op
);
4834 if (TREE_CODE (cop
) == NON_LVALUE_EXPR
)
4835 /* Unwrap the expression for C++ 98. */
4836 cop
= TREE_OPERAND (cop
, 0);
4838 if (TREE_CODE (cop
) == PTRMEM_CST
)
4840 /* The address of a nonstatic data member is never null. */
4841 warning_at (location
, OPT_Waddress
,
4842 "the address %qE will never be NULL",
4847 if (TREE_CODE (cop
) == NOP_EXPR
)
4849 /* Allow casts to intptr_t to suppress the warning. */
4850 tree type
= TREE_TYPE (cop
);
4851 if (TREE_CODE (type
) == INTEGER_TYPE
)
4857 bool warned
= false;
4858 if (TREE_CODE (cop
) == ADDR_EXPR
)
4860 cop
= TREE_OPERAND (cop
, 0);
4862 /* Set to true in the loop below if OP dereferences its operand.
4863 In such a case the ultimate target need not be a decl for
4864 the null [in]equality test to be necessarily constant. */
4867 /* Get the outermost array or object, or member. */
4868 while (handled_component_p (cop
))
4870 if (TREE_CODE (cop
) == COMPONENT_REF
)
4872 /* Get the member (its address is never null). */
4873 cop
= TREE_OPERAND (cop
, 1);
4877 /* Get the outer array/object to refer to in the warning. */
4878 cop
= TREE_OPERAND (cop
, 0);
4882 if ((!deref
&& !decl_with_nonnull_addr_p (cop
))
4883 || from_macro_expansion_at (location
)
4884 || warning_suppressed_p (cop
, OPT_Waddress
))
4887 warned
= warning_at (location
, OPT_Waddress
,
4888 "the address of %qD will never be NULL", cop
);
4891 else if (TREE_CODE (cop
) == POINTER_PLUS_EXPR
)
4893 /* Adding zero to the null pointer is well-defined in C++. When
4894 the offset is unknown (i.e., not a constant) warn anyway since
4895 it's less likely that the pointer operand is null than not. */
4896 tree off
= TREE_OPERAND (cop
, 1);
4897 if (!integer_zerop (off
)
4898 && !warning_suppressed_p (cop
, OPT_Waddress
))
4900 tree base
= TREE_OPERAND (cop
, 0);
4902 if (TYPE_REF_P (TREE_TYPE (base
)))
4903 warning_at (location
, OPT_Waddress
, "the compiler can assume that "
4904 "the address of %qE will never be NULL", base
);
4906 warning_at (location
, OPT_Waddress
, "comparing the result of "
4907 "pointer addition %qE and NULL", cop
);
4911 else if (CONVERT_EXPR_P (op
)
4912 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (op
, 0))))
4916 if (TREE_CODE (op
) == COMPONENT_REF
)
4917 op
= TREE_OPERAND (op
, 1);
4920 warned
= warning_at (location
, OPT_Waddress
,
4921 "the compiler can assume that the address of "
4922 "%qD will never be NULL", op
);
4925 if (warned
&& DECL_P (op
))
4926 inform (DECL_SOURCE_LOCATION (op
), "%qD declared here", op
);
4929 /* Warn about [expr.arith.conv]/2: If one operand is of enumeration type and
4930 the other operand is of a different enumeration type or a floating-point
4931 type, this behavior is deprecated ([depr.arith.conv.enum]). CODE is the
4932 code of the binary operation, TYPE0 and TYPE1 are the types of the operands,
4933 and LOC is the location for the whole binary expression.
4934 For C++26 this is ill-formed rather than deprecated.
4935 Return true for SFINAE errors.
4936 TODO: Consider combining this with -Wenum-compare in build_new_op_1. */
4939 do_warn_enum_conversions (location_t loc
, enum tree_code code
, tree type0
,
4940 tree type1
, tsubst_flags_t complain
)
4942 if (TREE_CODE (type0
) == ENUMERAL_TYPE
4943 && TREE_CODE (type1
) == ENUMERAL_TYPE
4944 && TYPE_MAIN_VARIANT (type0
) != TYPE_MAIN_VARIANT (type1
))
4946 if (cxx_dialect
>= cxx26
)
4948 if ((complain
& tf_warning_or_error
) == 0)
4951 else if ((complain
& tf_warning
) == 0)
4953 /* In C++20, -Wdeprecated-enum-enum-conversion is on by default.
4954 Otherwise, warn if -Wenum-conversion is on. */
4956 if (warn_deprecated_enum_enum_conv
)
4957 opt
= OPT_Wdeprecated_enum_enum_conversion
;
4958 else if (warn_enum_conversion
)
4959 opt
= OPT_Wenum_conversion
;
4971 /* Comparisons are handled by -Wenum-compare. */
4973 case SPACESHIP_EXPR
:
4974 /* This is invalid, don't warn. */
4979 if (cxx_dialect
>= cxx26
)
4980 pedwarn (loc
, opt
, "bitwise operation between different "
4981 "enumeration types %qT and %qT", type0
, type1
);
4983 warning_at (loc
, opt
, "bitwise operation between different "
4984 "enumeration types %qT and %qT is deprecated",
4988 if (cxx_dialect
>= cxx26
)
4989 pedwarn (loc
, opt
, "arithmetic between different enumeration "
4990 "types %qT and %qT", type0
, type1
);
4992 warning_at (loc
, opt
, "arithmetic between different enumeration "
4993 "types %qT and %qT is deprecated", type0
, type1
);
4997 else if ((TREE_CODE (type0
) == ENUMERAL_TYPE
4998 && SCALAR_FLOAT_TYPE_P (type1
))
4999 || (SCALAR_FLOAT_TYPE_P (type0
)
5000 && TREE_CODE (type1
) == ENUMERAL_TYPE
))
5002 if (cxx_dialect
>= cxx26
)
5004 if ((complain
& tf_warning_or_error
) == 0)
5007 else if ((complain
& tf_warning
) == 0)
5009 const bool enum_first_p
= TREE_CODE (type0
) == ENUMERAL_TYPE
;
5010 /* In C++20, -Wdeprecated-enum-float-conversion is on by default.
5011 Otherwise, warn if -Wenum-conversion is on. */
5013 if (warn_deprecated_enum_float_conv
)
5014 opt
= OPT_Wdeprecated_enum_float_conversion
;
5015 else if (warn_enum_conversion
)
5016 opt
= OPT_Wenum_conversion
;
5028 if (enum_first_p
&& cxx_dialect
>= cxx26
)
5029 pedwarn (loc
, opt
, "comparison of enumeration type %qT with "
5030 "floating-point type %qT", type0
, type1
);
5031 else if (cxx_dialect
>= cxx26
)
5032 pedwarn (loc
, opt
, "comparison of floating-point type %qT "
5033 "with enumeration type %qT", type0
, type1
);
5034 else if (enum_first_p
)
5035 warning_at (loc
, opt
, "comparison of enumeration type %qT with "
5036 "floating-point type %qT is deprecated",
5039 warning_at (loc
, opt
, "comparison of floating-point type %qT "
5040 "with enumeration type %qT is deprecated",
5043 case SPACESHIP_EXPR
:
5044 /* This is invalid, don't warn. */
5047 if (enum_first_p
&& cxx_dialect
>= cxx26
)
5048 pedwarn (loc
, opt
, "arithmetic between enumeration type %qT "
5049 "and floating-point type %qT", type0
, type1
);
5050 else if (cxx_dialect
>= cxx26
)
5051 pedwarn (loc
, opt
, "arithmetic between floating-point type %qT "
5052 "and enumeration type %qT", type0
, type1
);
5053 else if (enum_first_p
)
5054 warning_at (loc
, opt
, "arithmetic between enumeration type %qT "
5055 "and floating-point type %qT is deprecated",
5058 warning_at (loc
, opt
, "arithmetic between floating-point type %qT "
5059 "and enumeration type %qT is deprecated",
5067 /* Build a binary-operation expression without default conversions.
5068 CODE is the kind of expression to build.
5069 LOCATION is the location_t of the operator in the source code.
5070 This function differs from `build' in several ways:
5071 the data type of the result is computed and recorded in it,
5072 warnings are generated if arg data types are invalid,
5073 special handling for addition and subtraction of pointers is known,
5074 and some optimization is done (operations on narrow ints
5075 are done in the narrower type when that gives the same result).
5076 Constant folding is also done before the result is returned.
5078 Note that the operands will never have enumeral types
5079 because either they have just had the default conversions performed
5080 or they have both just been converted to some other type in which
5081 the arithmetic is to be done.
5083 C++: must do special pointer arithmetic when implementing
5084 multiple inheritance, and deal with pointer to member functions. */
5087 cp_build_binary_op (const op_location_t
&location
,
5088 enum tree_code code
, tree orig_op0
, tree orig_op1
,
5089 tsubst_flags_t complain
)
5092 enum tree_code code0
, code1
;
5093 tree type0
, type1
, orig_type0
, orig_type1
;
5094 const char *invalid_op_diag
;
5096 /* Expression code to give to the expression when it is built.
5097 Normally this is CODE, which is what the caller asked for,
5098 but in some special cases we change it. */
5099 enum tree_code resultcode
= code
;
5101 /* Data type in which the computation is to be performed.
5102 In the simplest cases this is the common type of the arguments. */
5103 tree result_type
= NULL_TREE
;
5105 /* When the computation is in excess precision, the type of the
5106 final EXCESS_PRECISION_EXPR. */
5107 tree semantic_result_type
= NULL
;
5109 /* Nonzero means operands have already been type-converted
5110 in whatever way is necessary.
5111 Zero means they need to be converted to RESULT_TYPE. */
5114 /* Nonzero means create the expression with this type, rather than
5116 tree build_type
= 0;
5118 /* Nonzero means after finally constructing the expression
5119 convert it to this type. */
5120 tree final_type
= 0;
5124 /* Nonzero if this is an operation like MIN or MAX which can
5125 safely be computed in short if both args are promoted shorts.
5126 Also implies COMMON.
5127 -1 indicates a bitwise operation; this makes a difference
5128 in the exact conditions for when it is safe to do the operation
5129 in a narrower mode. */
5132 /* Nonzero if this is a comparison operation;
5133 if both args are promoted shorts, compare the original shorts.
5134 Also implies COMMON. */
5135 int short_compare
= 0;
5137 /* Nonzero if this is a right-shift operation, which can be computed on the
5138 original short and then promoted if the operand is a promoted short. */
5139 int short_shift
= 0;
5141 /* Nonzero means set RESULT_TYPE to the common type of the args. */
5144 /* True if both operands have arithmetic type. */
5145 bool arithmetic_types_p
;
5147 /* Remember whether we're doing / or %. */
5148 bool doing_div_or_mod
= false;
5150 /* Remember whether we're doing << or >>. */
5151 bool doing_shift
= false;
5153 /* Tree holding instrumentation expression. */
5154 tree instrument_expr
= NULL_TREE
;
5156 /* True means this is an arithmetic operation that may need excess
5158 bool may_need_excess_precision
;
5160 /* Apply default conversions. */
5161 op0
= resolve_nondeduced_context (orig_op0
, complain
);
5162 op1
= resolve_nondeduced_context (orig_op1
, complain
);
5164 if (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
5165 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
5166 || code
== TRUTH_XOR_EXPR
)
5168 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
5169 op0
= decay_conversion (op0
, complain
);
5170 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
5171 op1
= decay_conversion (op1
, complain
);
5175 if (!really_overloaded_fn (op0
) && !VOID_TYPE_P (TREE_TYPE (op0
)))
5176 op0
= cp_default_conversion (op0
, complain
);
5177 if (!really_overloaded_fn (op1
) && !VOID_TYPE_P (TREE_TYPE (op1
)))
5178 op1
= cp_default_conversion (op1
, complain
);
5181 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
5182 STRIP_TYPE_NOPS (op0
);
5183 STRIP_TYPE_NOPS (op1
);
5185 /* DTRT if one side is an overloaded function, but complain about it. */
5186 if (type_unknown_p (op0
))
5188 tree t
= instantiate_type (TREE_TYPE (op1
), op0
, tf_none
);
5189 if (t
!= error_mark_node
)
5191 if (complain
& tf_error
)
5192 permerror (location
,
5193 "assuming cast to type %qT from overloaded function",
5198 if (type_unknown_p (op1
))
5200 tree t
= instantiate_type (TREE_TYPE (op0
), op1
, tf_none
);
5201 if (t
!= error_mark_node
)
5203 if (complain
& tf_error
)
5204 permerror (location
,
5205 "assuming cast to type %qT from overloaded function",
5211 orig_type0
= type0
= TREE_TYPE (op0
);
5212 orig_type1
= type1
= TREE_TYPE (op1
);
5213 tree non_ep_op0
= op0
;
5214 tree non_ep_op1
= op1
;
5216 /* The expression codes of the data types of the arguments tell us
5217 whether the arguments are integers, floating, pointers, etc. */
5218 code0
= TREE_CODE (type0
);
5219 code1
= TREE_CODE (type1
);
5221 /* If an error was already reported for one of the arguments,
5222 avoid reporting another error. */
5223 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
5224 return error_mark_node
;
5226 if ((invalid_op_diag
5227 = targetm
.invalid_binary_op (code
, type0
, type1
)))
5229 if (complain
& tf_error
)
5231 if (code0
== REAL_TYPE
5232 && code1
== REAL_TYPE
5233 && (extended_float_type_p (type0
)
5234 || extended_float_type_p (type1
))
5235 && cp_compare_floating_point_conversion_ranks (type0
,
5238 rich_location
richloc (line_table
, location
);
5239 binary_op_error (&richloc
, code
, type0
, type1
);
5242 error (invalid_op_diag
);
5244 return error_mark_node
;
5252 case TRUNC_DIV_EXPR
:
5254 case FLOOR_DIV_EXPR
:
5255 case ROUND_DIV_EXPR
:
5256 case EXACT_DIV_EXPR
:
5257 may_need_excess_precision
= true;
5265 case SPACESHIP_EXPR
:
5266 /* Excess precision for implicit conversions of integers to
5268 may_need_excess_precision
= (ANY_INTEGRAL_TYPE_P (type0
)
5269 || ANY_INTEGRAL_TYPE_P (type1
));
5272 may_need_excess_precision
= false;
5275 if (TREE_CODE (op0
) == EXCESS_PRECISION_EXPR
)
5277 op0
= TREE_OPERAND (op0
, 0);
5278 type0
= TREE_TYPE (op0
);
5280 else if (may_need_excess_precision
5281 && (code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
))
5282 if (tree eptype
= excess_precision_type (type0
))
5285 op0
= convert (eptype
, op0
);
5287 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
5289 op1
= TREE_OPERAND (op1
, 0);
5290 type1
= TREE_TYPE (op1
);
5292 else if (may_need_excess_precision
5293 && (code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
))
5294 if (tree eptype
= excess_precision_type (type1
))
5297 op1
= convert (eptype
, op1
);
5300 /* Issue warnings about peculiar, but valid, uses of NULL. */
5301 if ((null_node_p (orig_op0
) || null_node_p (orig_op1
))
5302 /* It's reasonable to use pointer values as operands of &&
5303 and ||, so NULL is no exception. */
5304 && code
!= TRUTH_ANDIF_EXPR
&& code
!= TRUTH_ORIF_EXPR
5305 && ( /* Both are NULL (or 0) and the operation was not a
5306 comparison or a pointer subtraction. */
5307 (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)
5308 && code
!= EQ_EXPR
&& code
!= NE_EXPR
&& code
!= MINUS_EXPR
)
5309 /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */
5310 || (!null_ptr_cst_p (orig_op0
)
5311 && !TYPE_PTR_OR_PTRMEM_P (type0
))
5312 || (!null_ptr_cst_p (orig_op1
)
5313 && !TYPE_PTR_OR_PTRMEM_P (type1
)))
5314 && (complain
& tf_warning
))
5317 expansion_point_location_if_in_system_header (input_location
);
5319 warning_at (loc
, OPT_Wpointer_arith
, "NULL used in arithmetic");
5322 /* In case when one of the operands of the binary operation is
5323 a vector and another is a scalar -- convert scalar to vector. */
5324 if ((gnu_vector_type_p (type0
) && code1
!= VECTOR_TYPE
)
5325 || (gnu_vector_type_p (type1
) && code0
!= VECTOR_TYPE
))
5327 enum stv_conv convert_flag
5328 = scalar_to_vector (location
, code
, non_ep_op0
, non_ep_op1
,
5329 complain
& tf_error
);
5331 switch (convert_flag
)
5334 return error_mark_node
;
5337 op0
= convert (TREE_TYPE (type1
), op0
);
5338 op0
= save_expr (op0
);
5339 op0
= build_vector_from_val (type1
, op0
);
5340 orig_type0
= type0
= TREE_TYPE (op0
);
5341 code0
= TREE_CODE (type0
);
5347 op1
= convert (TREE_TYPE (type0
), op1
);
5348 op1
= save_expr (op1
);
5349 op1
= build_vector_from_val (type0
, op1
);
5350 orig_type1
= type1
= TREE_TYPE (op1
);
5351 code1
= TREE_CODE (type1
);
5363 /* Subtraction of two similar pointers.
5364 We must subtract them as integers, then divide by object size. */
5365 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
5366 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
5369 result
= pointer_diff (location
, op0
, op1
,
5370 common_pointer_type (type0
, type1
), complain
,
5372 if (instrument_expr
!= NULL
)
5373 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
5374 instrument_expr
, result
);
5378 /* In all other cases except pointer - int, the usual arithmetic
5380 else if (!(code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
))
5385 /* The pointer - int case is just like pointer + int; fall
5389 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
5390 && (code0
== INTEGER_TYPE
|| code1
== INTEGER_TYPE
))
5394 ptr_operand
= ((code0
== POINTER_TYPE
) ? op0
: op1
);
5395 int_operand
= ((code0
== INTEGER_TYPE
) ? op0
: op1
);
5396 if (processing_template_decl
)
5398 result_type
= TREE_TYPE (ptr_operand
);
5401 return cp_pointer_int_sum (location
, code
,
5413 case TRUNC_DIV_EXPR
:
5415 case FLOOR_DIV_EXPR
:
5416 case ROUND_DIV_EXPR
:
5417 case EXACT_DIV_EXPR
:
5418 if (TREE_CODE (op0
) == SIZEOF_EXPR
&& TREE_CODE (op1
) == SIZEOF_EXPR
)
5420 tree type0
= TREE_OPERAND (op0
, 0);
5421 tree type1
= TREE_OPERAND (op1
, 0);
5422 tree first_arg
= tree_strip_any_location_wrapper (type0
);
5423 if (!TYPE_P (type0
))
5424 type0
= TREE_TYPE (type0
);
5425 if (!TYPE_P (type1
))
5426 type1
= TREE_TYPE (type1
);
5428 && INDIRECT_TYPE_P (type0
)
5429 && same_type_p (TREE_TYPE (type0
), type1
))
5431 if (!(TREE_CODE (first_arg
) == PARM_DECL
5432 && DECL_ARRAY_PARAMETER_P (first_arg
)
5433 && warn_sizeof_array_argument
)
5434 && (complain
& tf_warning
))
5436 auto_diagnostic_group d
;
5437 if (warning_at (location
, OPT_Wsizeof_pointer_div
,
5438 "division %<sizeof (%T) / sizeof (%T)%> does "
5439 "not compute the number of array elements",
5441 if (DECL_P (first_arg
))
5442 inform (DECL_SOURCE_LOCATION (first_arg
),
5443 "first %<sizeof%> operand was declared here");
5446 else if (!dependent_type_p (type0
)
5447 && !dependent_type_p (type1
)
5448 && TREE_CODE (type0
) == ARRAY_TYPE
5449 && !char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type0
)))
5450 /* Set by finish_parenthesized_expr. */
5451 && !warning_suppressed_p (op1
, OPT_Wsizeof_array_div
)
5452 && (complain
& tf_warning
))
5453 maybe_warn_sizeof_array_div (location
, first_arg
, type0
,
5454 op1
, non_reference (type1
));
5457 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
5458 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
5459 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5460 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
5462 enum tree_code tcode0
= code0
, tcode1
= code1
;
5463 doing_div_or_mod
= true;
5464 warn_for_div_by_zero (location
, fold_for_warn (op1
));
5466 if (tcode0
== COMPLEX_TYPE
|| tcode0
== VECTOR_TYPE
)
5467 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
5468 if (tcode1
== COMPLEX_TYPE
|| tcode1
== VECTOR_TYPE
)
5469 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
5471 if (!(tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
))
5472 resultcode
= RDIV_EXPR
;
5475 /* When dividing two signed integers, we have to promote to int.
5476 unless we divide by a constant != -1. Note that default
5477 conversion will have been performed on the operands at this
5478 point, so we have to dig out the original type to find out if
5480 tree stripped_op1
= tree_strip_any_location_wrapper (op1
);
5481 shorten
= may_shorten_divmod (op0
, stripped_op1
);
5491 if ((code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5492 || (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
5493 && !VECTOR_FLOAT_TYPE_P (type0
)
5494 && !VECTOR_FLOAT_TYPE_P (type1
)))
5498 case TRUNC_MOD_EXPR
:
5499 case FLOOR_MOD_EXPR
:
5500 doing_div_or_mod
= true;
5501 warn_for_div_by_zero (location
, fold_for_warn (op1
));
5503 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
5504 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5505 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
5507 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5509 /* Although it would be tempting to shorten always here, that loses
5510 on some targets, since the modulo instruction is undefined if the
5511 quotient can't be represented in the computation mode. We shorten
5512 only if unsigned or if dividing by something we know != -1. */
5513 tree stripped_op1
= tree_strip_any_location_wrapper (op1
);
5514 shorten
= may_shorten_divmod (op0
, stripped_op1
);
5519 case TRUTH_ANDIF_EXPR
:
5520 case TRUTH_ORIF_EXPR
:
5521 case TRUTH_AND_EXPR
:
5523 if (!VECTOR_TYPE_P (type0
) && gnu_vector_type_p (type1
))
5525 if (!COMPARISON_CLASS_P (op1
))
5526 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
5527 build_zero_cst (type1
), complain
);
5528 if (code
== TRUTH_ANDIF_EXPR
)
5530 tree z
= build_zero_cst (TREE_TYPE (op1
));
5531 return build_conditional_expr (location
, op0
, op1
, z
, complain
);
5533 else if (code
== TRUTH_ORIF_EXPR
)
5535 tree m1
= build_all_ones_cst (TREE_TYPE (op1
));
5536 return build_conditional_expr (location
, op0
, m1
, op1
, complain
);
5541 if (gnu_vector_type_p (type0
)
5542 && (!VECTOR_TYPE_P (type1
) || gnu_vector_type_p (type1
)))
5544 if (!COMPARISON_CLASS_P (op0
))
5545 op0
= cp_build_binary_op (EXPR_LOCATION (op0
), NE_EXPR
, op0
,
5546 build_zero_cst (type0
), complain
);
5547 if (!VECTOR_TYPE_P (type1
))
5549 tree m1
= build_all_ones_cst (TREE_TYPE (op0
));
5550 tree z
= build_zero_cst (TREE_TYPE (op0
));
5551 op1
= build_conditional_expr (location
, op1
, m1
, z
, complain
);
5553 else if (!COMPARISON_CLASS_P (op1
))
5554 op1
= cp_build_binary_op (EXPR_LOCATION (op1
), NE_EXPR
, op1
,
5555 build_zero_cst (type1
), complain
);
5557 if (code
== TRUTH_ANDIF_EXPR
)
5558 code
= BIT_AND_EXPR
;
5559 else if (code
== TRUTH_ORIF_EXPR
)
5560 code
= BIT_IOR_EXPR
;
5564 return cp_build_binary_op (location
, code
, op0
, op1
, complain
);
5567 result_type
= boolean_type_node
;
5570 /* Shift operations: result has same type as first operand;
5571 always convert second operand to int.
5572 Also set SHORT_SHIFT if shifting rightward. */
5575 if (gnu_vector_type_p (type0
)
5576 && code1
== INTEGER_TYPE
5577 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
5579 result_type
= type0
;
5582 else if (gnu_vector_type_p (type0
)
5583 && gnu_vector_type_p (type1
)
5584 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5585 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
5586 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
5587 TYPE_VECTOR_SUBPARTS (type1
)))
5589 result_type
= type0
;
5592 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5594 tree const_op1
= fold_for_warn (op1
);
5595 if (TREE_CODE (const_op1
) != INTEGER_CST
)
5597 result_type
= type0
;
5599 if (TREE_CODE (const_op1
) == INTEGER_CST
)
5601 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
5603 if ((complain
& tf_warning
)
5604 && c_inhibit_evaluation_warnings
== 0)
5605 warning_at (location
, OPT_Wshift_count_negative
,
5606 "right shift count is negative");
5610 if (!integer_zerop (const_op1
))
5613 if (compare_tree_int (const_op1
, TYPE_PRECISION (type0
)) >= 0
5614 && (complain
& tf_warning
)
5615 && c_inhibit_evaluation_warnings
== 0)
5616 warning_at (location
, OPT_Wshift_count_overflow
,
5617 "right shift count >= width of type");
5620 /* Avoid converting op1 to result_type later. */
5626 if (gnu_vector_type_p (type0
)
5627 && code1
== INTEGER_TYPE
5628 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
5630 result_type
= type0
;
5633 else if (gnu_vector_type_p (type0
)
5634 && gnu_vector_type_p (type1
)
5635 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
5636 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
5637 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
5638 TYPE_VECTOR_SUBPARTS (type1
)))
5640 result_type
= type0
;
5643 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
5645 tree const_op0
= fold_for_warn (op0
);
5646 if (TREE_CODE (const_op0
) != INTEGER_CST
)
5648 tree const_op1
= fold_for_warn (op1
);
5649 if (TREE_CODE (const_op1
) != INTEGER_CST
)
5651 result_type
= type0
;
5653 if (TREE_CODE (const_op0
) == INTEGER_CST
5654 && tree_int_cst_sgn (const_op0
) < 0
5655 && !TYPE_OVERFLOW_WRAPS (type0
)
5656 && (complain
& tf_warning
)
5657 && c_inhibit_evaluation_warnings
== 0)
5658 warning_at (location
, OPT_Wshift_negative_value
,
5659 "left shift of negative value");
5660 if (TREE_CODE (const_op1
) == INTEGER_CST
)
5662 if (tree_int_cst_lt (const_op1
, integer_zero_node
))
5664 if ((complain
& tf_warning
)
5665 && c_inhibit_evaluation_warnings
== 0)
5666 warning_at (location
, OPT_Wshift_count_negative
,
5667 "left shift count is negative");
5669 else if (compare_tree_int (const_op1
,
5670 TYPE_PRECISION (type0
)) >= 0)
5672 if ((complain
& tf_warning
)
5673 && c_inhibit_evaluation_warnings
== 0)
5674 warning_at (location
, OPT_Wshift_count_overflow
,
5675 "left shift count >= width of type");
5677 else if (TREE_CODE (const_op0
) == INTEGER_CST
5678 && (complain
& tf_warning
))
5679 maybe_warn_shift_overflow (location
, const_op0
, const_op1
);
5681 /* Avoid converting op1 to result_type later. */
5688 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
5689 goto vector_compare
;
5690 if ((complain
& tf_warning
)
5691 && c_inhibit_evaluation_warnings
== 0
5692 && (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
)))
5693 warning_at (location
, OPT_Wfloat_equal
,
5694 "comparing floating-point with %<==%> "
5695 "or %<!=%> is unsafe");
5696 if (complain
& tf_warning
)
5698 tree stripped_orig_op0
= tree_strip_any_location_wrapper (orig_op0
);
5699 tree stripped_orig_op1
= tree_strip_any_location_wrapper (orig_op1
);
5700 if ((TREE_CODE (stripped_orig_op0
) == STRING_CST
5701 && !integer_zerop (cp_fully_fold (op1
)))
5702 || (TREE_CODE (stripped_orig_op1
) == STRING_CST
5703 && !integer_zerop (cp_fully_fold (op0
))))
5704 warning_at (location
, OPT_Waddress
,
5705 "comparison with string literal results in "
5706 "unspecified behavior");
5707 else if (warn_array_compare
5708 && TREE_CODE (TREE_TYPE (orig_op0
)) == ARRAY_TYPE
5709 && TREE_CODE (TREE_TYPE (orig_op1
)) == ARRAY_TYPE
)
5710 do_warn_array_compare (location
, code
, stripped_orig_op0
,
5714 build_type
= boolean_type_node
;
5715 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
5716 || code0
== COMPLEX_TYPE
|| code0
== ENUMERAL_TYPE
)
5717 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5718 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
))
5720 else if (((code0
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type0
))
5721 && null_ptr_cst_p (orig_op1
))
5722 /* Handle, eg, (void*)0 (c++/43906), and more. */
5723 || (code0
== POINTER_TYPE
5724 && TYPE_PTR_P (type1
) && integer_zerop (op1
)))
5726 if (TYPE_PTR_P (type1
))
5727 result_type
= composite_pointer_type (location
,
5728 type0
, type1
, op0
, op1
,
5729 CPO_COMPARISON
, complain
);
5731 result_type
= type0
;
5733 if (char_type_p (TREE_TYPE (orig_op1
)))
5735 auto_diagnostic_group d
;
5736 if (warning_at (location
, OPT_Wpointer_compare
,
5737 "comparison between pointer and zero character "
5740 "did you mean to dereference the pointer?");
5742 warn_for_null_address (location
, op0
, complain
);
5744 else if (((code1
== POINTER_TYPE
|| TYPE_PTRDATAMEM_P (type1
))
5745 && null_ptr_cst_p (orig_op0
))
5746 /* Handle, eg, (void*)0 (c++/43906), and more. */
5747 || (code1
== POINTER_TYPE
5748 && TYPE_PTR_P (type0
) && integer_zerop (op0
)))
5750 if (TYPE_PTR_P (type0
))
5751 result_type
= composite_pointer_type (location
,
5752 type0
, type1
, op0
, op1
,
5753 CPO_COMPARISON
, complain
);
5755 result_type
= type1
;
5757 if (char_type_p (TREE_TYPE (orig_op0
)))
5759 auto_diagnostic_group d
;
5760 if (warning_at (location
, OPT_Wpointer_compare
,
5761 "comparison between pointer and zero character "
5764 "did you mean to dereference the pointer?");
5766 warn_for_null_address (location
, op1
, complain
);
5768 else if ((code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
5769 || (TYPE_PTRDATAMEM_P (type0
) && TYPE_PTRDATAMEM_P (type1
)))
5770 result_type
= composite_pointer_type (location
,
5771 type0
, type1
, op0
, op1
,
5772 CPO_COMPARISON
, complain
);
5773 else if (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
))
5774 /* One of the operands must be of nullptr_t type. */
5775 result_type
= TREE_TYPE (nullptr_node
);
5776 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5778 result_type
= type0
;
5779 if (complain
& tf_error
)
5780 permerror (location
, "ISO C++ forbids comparison between "
5781 "pointer and integer");
5783 return error_mark_node
;
5785 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
5787 result_type
= type1
;
5788 if (complain
& tf_error
)
5789 permerror (location
, "ISO C++ forbids comparison between "
5790 "pointer and integer");
5792 return error_mark_node
;
5794 else if (TYPE_PTRMEMFUNC_P (type0
) && null_ptr_cst_p (orig_op1
))
5796 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
5797 == ptrmemfunc_vbit_in_delta
)
5799 tree pfn0
, delta0
, e1
, e2
;
5801 if (TREE_SIDE_EFFECTS (op0
))
5802 op0
= cp_save_expr (op0
);
5804 pfn0
= pfn_from_ptrmemfunc (op0
);
5805 delta0
= delta_from_ptrmemfunc (op0
);
5807 /* If we will warn below about a null-address compare
5808 involving the orig_op0 ptrmemfunc, we'd likely also
5809 warn about the pfn0's null-address compare, and
5810 that would be redundant, so suppress it. */
5811 warning_sentinel
ws (warn_address
);
5812 e1
= cp_build_binary_op (location
,
5815 build_zero_cst (TREE_TYPE (pfn0
)),
5818 e2
= cp_build_binary_op (location
,
5824 if (complain
& tf_warning
)
5825 maybe_warn_zero_as_null_pointer_constant (op1
, input_location
);
5827 e2
= cp_build_binary_op (location
,
5828 EQ_EXPR
, e2
, integer_zero_node
,
5830 op0
= cp_build_binary_op (location
,
5831 TRUTH_ANDIF_EXPR
, e1
, e2
,
5833 op1
= cp_convert (TREE_TYPE (op0
), integer_one_node
, complain
);
5837 op0
= build_ptrmemfunc_access_expr (op0
, pfn_identifier
);
5838 op1
= cp_convert (TREE_TYPE (op0
), op1
, complain
);
5840 result_type
= TREE_TYPE (op0
);
5842 warn_for_null_address (location
, orig_op0
, complain
);
5844 else if (TYPE_PTRMEMFUNC_P (type1
) && null_ptr_cst_p (orig_op0
))
5845 return cp_build_binary_op (location
, code
, op1
, op0
, complain
);
5846 else if (TYPE_PTRMEMFUNC_P (type0
) && TYPE_PTRMEMFUNC_P (type1
))
5849 /* E will be the final comparison. */
5851 /* E1 and E2 are for scratch. */
5859 type
= composite_pointer_type (location
, type0
, type1
, op0
, op1
,
5860 CPO_COMPARISON
, complain
);
5862 if (!same_type_p (TREE_TYPE (op0
), type
))
5863 op0
= cp_convert_and_check (type
, op0
, complain
);
5864 if (!same_type_p (TREE_TYPE (op1
), type
))
5865 op1
= cp_convert_and_check (type
, op1
, complain
);
5867 if (op0
== error_mark_node
|| op1
== error_mark_node
)
5868 return error_mark_node
;
5870 if (TREE_SIDE_EFFECTS (op0
))
5871 op0
= save_expr (op0
);
5872 if (TREE_SIDE_EFFECTS (op1
))
5873 op1
= save_expr (op1
);
5875 pfn0
= pfn_from_ptrmemfunc (op0
);
5876 pfn0
= cp_fully_fold (pfn0
);
5877 /* Avoid -Waddress warnings (c++/64877). */
5878 if (TREE_CODE (pfn0
) == ADDR_EXPR
)
5879 suppress_warning (pfn0
, OPT_Waddress
);
5880 pfn1
= pfn_from_ptrmemfunc (op1
);
5881 pfn1
= cp_fully_fold (pfn1
);
5882 delta0
= delta_from_ptrmemfunc (op0
);
5883 delta1
= delta_from_ptrmemfunc (op1
);
5884 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
5885 == ptrmemfunc_vbit_in_delta
)
5890 && ((op0.delta == op1.delta)
5891 || (!op0.pfn && op0.delta & 1 == 0
5892 && op1.delta & 1 == 0))
5894 The reason for the `!op0.pfn' bit is that a NULL
5895 pointer-to-member is any member with a zero PFN and
5896 LSB of the DELTA field is 0. */
5898 e1
= cp_build_binary_op (location
, BIT_AND_EXPR
,
5902 e1
= cp_build_binary_op (location
,
5903 EQ_EXPR
, e1
, integer_zero_node
,
5905 e2
= cp_build_binary_op (location
, BIT_AND_EXPR
,
5909 e2
= cp_build_binary_op (location
,
5910 EQ_EXPR
, e2
, integer_zero_node
,
5912 e1
= cp_build_binary_op (location
,
5913 TRUTH_ANDIF_EXPR
, e2
, e1
,
5915 e2
= cp_build_binary_op (location
, EQ_EXPR
,
5917 build_zero_cst (TREE_TYPE (pfn0
)),
5919 e2
= cp_build_binary_op (location
,
5920 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
5921 e1
= cp_build_binary_op (location
,
5922 EQ_EXPR
, delta0
, delta1
, complain
);
5923 e1
= cp_build_binary_op (location
,
5924 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
5931 && (!op0.pfn || op0.delta == op1.delta))
5933 The reason for the `!op0.pfn' bit is that a NULL
5934 pointer-to-member is any member with a zero PFN; the
5935 DELTA field is unspecified. */
5937 e1
= cp_build_binary_op (location
,
5938 EQ_EXPR
, delta0
, delta1
, complain
);
5939 e2
= cp_build_binary_op (location
,
5942 build_zero_cst (TREE_TYPE (pfn0
)),
5944 e1
= cp_build_binary_op (location
,
5945 TRUTH_ORIF_EXPR
, e1
, e2
, complain
);
5947 e2
= build2 (EQ_EXPR
, boolean_type_node
, pfn0
, pfn1
);
5948 e
= cp_build_binary_op (location
,
5949 TRUTH_ANDIF_EXPR
, e2
, e1
, complain
);
5950 if (code
== EQ_EXPR
)
5952 return cp_build_binary_op (location
,
5953 EQ_EXPR
, e
, integer_zero_node
, complain
);
5957 gcc_assert (!TYPE_PTRMEMFUNC_P (type0
)
5958 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0
),
5960 gcc_assert (!TYPE_PTRMEMFUNC_P (type1
)
5961 || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1
),
5969 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
5970 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
5972 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
5973 result_type
= composite_pointer_type (location
,
5974 type0
, type1
, op0
, op1
,
5975 CPO_COMPARISON
, complain
);
5982 case SPACESHIP_EXPR
:
5983 if (TREE_CODE (orig_op0
) == STRING_CST
5984 || TREE_CODE (orig_op1
) == STRING_CST
)
5986 if (complain
& tf_warning
)
5987 warning_at (location
, OPT_Waddress
,
5988 "comparison with string literal results "
5989 "in unspecified behavior");
5991 else if (warn_array_compare
5992 && TREE_CODE (TREE_TYPE (orig_op0
)) == ARRAY_TYPE
5993 && TREE_CODE (TREE_TYPE (orig_op1
)) == ARRAY_TYPE
5994 && code
!= SPACESHIP_EXPR
5995 && (complain
& tf_warning
))
5996 do_warn_array_compare (location
, code
,
5997 tree_strip_any_location_wrapper (orig_op0
),
5998 tree_strip_any_location_wrapper (orig_op1
));
6000 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
6004 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0
),
6006 && !vector_types_compatible_elements_p (type0
, type1
))
6008 if (complain
& tf_error
)
6010 error_at (location
, "comparing vectors with different "
6012 inform (location
, "operand types are %qT and %qT",
6015 return error_mark_node
;
6018 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0
),
6019 TYPE_VECTOR_SUBPARTS (type1
)))
6021 if (complain
& tf_error
)
6023 error_at (location
, "comparing vectors with different "
6024 "number of elements");
6025 inform (location
, "operand types are %qT and %qT",
6028 return error_mark_node
;
6031 /* It's not precisely specified how the usual arithmetic
6032 conversions apply to the vector types. Here, we use
6033 the unsigned type if one of the operands is signed and
6034 the other one is unsigned. */
6035 if (TYPE_UNSIGNED (type0
) != TYPE_UNSIGNED (type1
))
6037 if (!TYPE_UNSIGNED (type0
))
6038 op0
= build1 (VIEW_CONVERT_EXPR
, type1
, op0
);
6040 op1
= build1 (VIEW_CONVERT_EXPR
, type0
, op1
);
6041 warning_at (location
, OPT_Wsign_compare
, "comparison between "
6042 "types %qT and %qT", type0
, type1
);
6045 if (resultcode
== SPACESHIP_EXPR
)
6047 if (complain
& tf_error
)
6048 sorry_at (location
, "three-way comparison of vectors");
6049 return error_mark_node
;
6052 /* Always construct signed integer vector type. */
6053 intt
= c_common_type_for_size
6054 (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (type0
))), 0);
6057 if (complain
& tf_error
)
6058 error_at (location
, "could not find an integer type "
6059 "of the same size as %qT", TREE_TYPE (type0
));
6060 return error_mark_node
;
6062 result_type
= build_opaque_vector_type (intt
,
6063 TYPE_VECTOR_SUBPARTS (type0
));
6064 return build_vec_cmp (resultcode
, result_type
, op0
, op1
);
6066 build_type
= boolean_type_node
;
6067 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
6068 || code0
== ENUMERAL_TYPE
)
6069 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
6070 || code1
== ENUMERAL_TYPE
))
6072 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
6073 result_type
= composite_pointer_type (location
,
6074 type0
, type1
, op0
, op1
,
6075 CPO_COMPARISON
, complain
);
6076 else if ((code0
== POINTER_TYPE
&& null_ptr_cst_p (orig_op1
))
6077 || (code1
== POINTER_TYPE
&& null_ptr_cst_p (orig_op0
))
6078 || (null_ptr_cst_p (orig_op0
) && null_ptr_cst_p (orig_op1
)))
6080 /* Core Issue 1512 made this ill-formed. */
6081 if (complain
& tf_error
)
6082 error_at (location
, "ordered comparison of pointer with "
6083 "integer zero (%qT and %qT)", type0
, type1
);
6084 return error_mark_node
;
6086 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
6088 result_type
= type0
;
6089 if (complain
& tf_error
)
6090 permerror (location
, "ISO C++ forbids comparison between "
6091 "pointer and integer");
6093 return error_mark_node
;
6095 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
6097 result_type
= type1
;
6098 if (complain
& tf_error
)
6099 permerror (location
, "ISO C++ forbids comparison between "
6100 "pointer and integer");
6102 return error_mark_node
;
6105 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
6106 && !processing_template_decl
6107 && sanitize_flags_p (SANITIZE_POINTER_COMPARE
))
6109 op0
= save_expr (op0
);
6110 op1
= save_expr (op1
);
6112 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_COMPARE
);
6113 instrument_expr
= build_call_expr_loc (location
, tt
, 2, op0
, op1
);
6118 case UNORDERED_EXPR
:
6125 build_type
= integer_type_node
;
6126 if (code0
!= REAL_TYPE
|| code1
!= REAL_TYPE
)
6128 if (complain
& tf_error
)
6129 error ("unordered comparison on non-floating-point argument");
6130 return error_mark_node
;
6139 if (((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
6140 || code0
== ENUMERAL_TYPE
)
6141 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
6142 || code1
== COMPLEX_TYPE
|| code1
== ENUMERAL_TYPE
)))
6143 arithmetic_types_p
= 1;
6146 arithmetic_types_p
= 0;
6147 /* Vector arithmetic is only allowed when both sides are vectors. */
6148 if (gnu_vector_type_p (type0
) && gnu_vector_type_p (type1
))
6150 if (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
6151 || !vector_types_compatible_elements_p (type0
, type1
))
6153 if (complain
& tf_error
)
6155 /* "location" already embeds the locations of the
6156 operands, so we don't need to add them separately
6158 rich_location
richloc (line_table
, location
);
6159 binary_op_error (&richloc
, code
, type0
, type1
);
6161 return error_mark_node
;
6163 arithmetic_types_p
= 1;
6166 /* Determine the RESULT_TYPE, if it is not already known. */
6168 && arithmetic_types_p
6169 && (shorten
|| common
|| short_compare
))
6171 result_type
= cp_common_type (type0
, type1
);
6172 if (result_type
== error_mark_node
)
6176 if (TREE_CODE (t1
) == COMPLEX_TYPE
)
6177 t1
= TREE_TYPE (t1
);
6178 if (TREE_CODE (t2
) == COMPLEX_TYPE
)
6179 t2
= TREE_TYPE (t2
);
6180 gcc_checking_assert (TREE_CODE (t1
) == REAL_TYPE
6181 && TREE_CODE (t2
) == REAL_TYPE
6182 && (extended_float_type_p (t1
)
6183 || extended_float_type_p (t2
))
6184 && cp_compare_floating_point_conversion_ranks
6186 if (complain
& tf_error
)
6188 rich_location
richloc (line_table
, location
);
6189 binary_op_error (&richloc
, code
, type0
, type1
);
6191 return error_mark_node
;
6193 if (complain
& tf_warning
)
6194 do_warn_double_promotion (result_type
, type0
, type1
,
6195 "implicit conversion from %qH to %qI "
6196 "to match other operand of binary "
6197 "expression", location
);
6198 if (do_warn_enum_conversions (location
, code
, TREE_TYPE (orig_op0
),
6199 TREE_TYPE (orig_op1
), complain
))
6200 return error_mark_node
;
6202 if (may_need_excess_precision
6203 && (orig_type0
!= type0
|| orig_type1
!= type1
)
6204 && build_type
== NULL_TREE
6207 gcc_assert (common
);
6208 semantic_result_type
= cp_common_type (orig_type0
, orig_type1
);
6209 if (semantic_result_type
== error_mark_node
)
6211 tree t1
= orig_type0
;
6212 tree t2
= orig_type1
;
6213 if (TREE_CODE (t1
) == COMPLEX_TYPE
)
6214 t1
= TREE_TYPE (t1
);
6215 if (TREE_CODE (t2
) == COMPLEX_TYPE
)
6216 t2
= TREE_TYPE (t2
);
6217 gcc_checking_assert (TREE_CODE (t1
) == REAL_TYPE
6218 && TREE_CODE (t2
) == REAL_TYPE
6219 && (extended_float_type_p (t1
)
6220 || extended_float_type_p (t2
))
6221 && cp_compare_floating_point_conversion_ranks
6223 if (complain
& tf_error
)
6225 rich_location
richloc (line_table
, location
);
6226 binary_op_error (&richloc
, code
, type0
, type1
);
6228 return error_mark_node
;
6232 if (code
== SPACESHIP_EXPR
)
6234 iloc_sentinel
s (location
);
6236 tree orig_type0
= TREE_TYPE (orig_op0
);
6237 tree_code orig_code0
= TREE_CODE (orig_type0
);
6238 tree orig_type1
= TREE_TYPE (orig_op1
);
6239 tree_code orig_code1
= TREE_CODE (orig_type1
);
6240 if (!result_type
|| result_type
== error_mark_node
)
6242 result_type
= NULL_TREE
;
6243 else if ((orig_code0
== BOOLEAN_TYPE
) != (orig_code1
== BOOLEAN_TYPE
))
6244 /* "If one of the operands is of type bool and the other is not, the
6245 program is ill-formed." */
6246 result_type
= NULL_TREE
;
6247 else if (code0
== POINTER_TYPE
&& orig_code0
!= POINTER_TYPE
6248 && code1
== POINTER_TYPE
&& orig_code1
!= POINTER_TYPE
)
6249 /* We only do array/function-to-pointer conversion if "at least one of
6250 the operands is of pointer type". */
6251 result_type
= NULL_TREE
;
6252 else if (TYPE_PTRFN_P (result_type
) || NULLPTR_TYPE_P (result_type
))
6253 /* <=> no longer supports equality relations. */
6254 result_type
= NULL_TREE
;
6255 else if (orig_code0
== ENUMERAL_TYPE
&& orig_code1
== ENUMERAL_TYPE
6256 && !(same_type_ignoring_top_level_qualifiers_p
6257 (orig_type0
, orig_type1
)))
6258 /* "If both operands have arithmetic types, or one operand has integral
6259 type and the other operand has unscoped enumeration type, the usual
6260 arithmetic conversions are applied to the operands." So we don't do
6261 arithmetic conversions if the operands both have enumeral type. */
6262 result_type
= NULL_TREE
;
6263 else if ((orig_code0
== ENUMERAL_TYPE
&& orig_code1
== REAL_TYPE
)
6264 || (orig_code0
== REAL_TYPE
&& orig_code1
== ENUMERAL_TYPE
))
6265 /* [depr.arith.conv.enum]: Three-way comparisons between such operands
6266 [where one is of enumeration type and the other is of a different
6267 enumeration type or a floating-point type] are ill-formed. */
6268 result_type
= NULL_TREE
;
6272 build_type
= spaceship_type (result_type
, complain
);
6273 if (build_type
== error_mark_node
)
6274 return error_mark_node
;
6277 if (result_type
&& arithmetic_types_p
)
6279 /* If a narrowing conversion is required, other than from an integral
6280 type to a floating point type, the program is ill-formed. */
6282 if (TREE_CODE (result_type
) == REAL_TYPE
6283 && CP_INTEGRAL_TYPE_P (orig_type0
))
6285 else if (!check_narrowing (result_type
, orig_op0
, complain
))
6287 if (TREE_CODE (result_type
) == REAL_TYPE
6288 && CP_INTEGRAL_TYPE_P (orig_type1
))
6290 else if (!check_narrowing (result_type
, orig_op1
, complain
))
6292 if (!ok
&& !(complain
& tf_error
))
6293 return error_mark_node
;
6299 if (complain
& tf_error
)
6301 binary_op_rich_location
richloc (location
,
6302 orig_op0
, orig_op1
, true);
6304 "invalid operands of types %qT and %qT to binary %qO",
6305 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
), code
);
6307 return error_mark_node
;
6310 /* If we're in a template, the only thing we need to know is the
6312 if (processing_template_decl
)
6314 /* Since the middle-end checks the type when doing a build2, we
6315 need to build the tree in pieces. This built tree will never
6316 get out of the front-end as we replace it when instantiating
6318 tree tmp
= build2 (resultcode
,
6319 build_type
? build_type
: result_type
,
6321 TREE_OPERAND (tmp
, 0) = op0
;
6322 if (semantic_result_type
)
6323 tmp
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, tmp
);
6327 /* Remember the original type; RESULT_TYPE might be changed later on
6328 by shorten_binary_op. */
6329 tree orig_type
= result_type
;
6331 if (arithmetic_types_p
)
6333 bool first_complex
= (code0
== COMPLEX_TYPE
);
6334 bool second_complex
= (code1
== COMPLEX_TYPE
);
6335 int none_complex
= (!first_complex
&& !second_complex
);
6337 /* Adapted from patch for c/24581. */
6338 if (first_complex
!= second_complex
6339 && (code
== PLUS_EXPR
6340 || code
== MINUS_EXPR
6341 || code
== MULT_EXPR
6342 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
6343 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
6344 && flag_signed_zeros
)
6346 /* An operation on mixed real/complex operands must be
6347 handled specially, but the language-independent code can
6348 more easily optimize the plain complex arithmetic if
6349 -fno-signed-zeros. */
6350 tree real_type
= TREE_TYPE (result_type
);
6354 if (TREE_TYPE (op0
) != result_type
)
6355 op0
= cp_convert_and_check (result_type
, op0
, complain
);
6356 if (TREE_TYPE (op1
) != real_type
)
6357 op1
= cp_convert_and_check (real_type
, op1
, complain
);
6361 if (TREE_TYPE (op0
) != real_type
)
6362 op0
= cp_convert_and_check (real_type
, op0
, complain
);
6363 if (TREE_TYPE (op1
) != result_type
)
6364 op1
= cp_convert_and_check (result_type
, op1
, complain
);
6366 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
6367 return error_mark_node
;
6370 op0
= save_expr (op0
);
6371 real
= cp_build_unary_op (REALPART_EXPR
, op0
, true, complain
);
6372 imag
= cp_build_unary_op (IMAGPART_EXPR
, op0
, true, complain
);
6376 case TRUNC_DIV_EXPR
:
6377 op1
= save_expr (op1
);
6378 imag
= build2 (resultcode
, real_type
, imag
, op1
);
6382 real
= build2 (resultcode
, real_type
, real
, op1
);
6390 op1
= save_expr (op1
);
6391 real
= cp_build_unary_op (REALPART_EXPR
, op1
, true, complain
);
6392 imag
= cp_build_unary_op (IMAGPART_EXPR
, op1
, true, complain
);
6396 op0
= save_expr (op0
);
6397 imag
= build2 (resultcode
, real_type
, op0
, imag
);
6400 real
= build2 (resultcode
, real_type
, op0
, real
);
6403 real
= build2 (resultcode
, real_type
, op0
, real
);
6404 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
6410 result
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
6411 if (semantic_result_type
)
6412 result
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
,
6417 /* For certain operations (which identify themselves by shorten != 0)
6418 if both args were extended from the same smaller type,
6419 do the arithmetic in that type and then extend.
6421 shorten !=0 and !=1 indicates a bitwise operation.
6422 For them, this optimization is safe only if
6423 both args are zero-extended or both are sign-extended.
6424 Otherwise, we might change the result.
6425 E.g., (short)-1 | (unsigned short)-1 is (int)-1
6426 but calculated in (unsigned short) it would be (unsigned short)-1. */
6428 if (shorten
&& none_complex
)
6430 final_type
= result_type
;
6431 result_type
= shorten_binary_op (result_type
, op0
, op1
,
6435 /* Shifts can be shortened if shifting right. */
6440 tree arg0
= get_narrower (op0
, &unsigned_arg
);
6441 /* We're not really warning here but when we set short_shift we
6442 used fold_for_warn to fold the operand. */
6443 tree const_op1
= fold_for_warn (op1
);
6445 final_type
= result_type
;
6447 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
6448 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
6450 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
6451 && tree_int_cst_sgn (const_op1
) > 0
6452 /* We can shorten only if the shift count is less than the
6453 number of bits in the smaller type size. */
6454 && compare_tree_int (const_op1
,
6455 TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
6456 /* We cannot drop an unsigned shift after sign-extension. */
6457 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
6459 /* Do an unsigned shift if the operand was zero-extended. */
6461 = c_common_signed_or_unsigned_type (unsigned_arg
,
6463 /* Convert value-to-be-shifted to that type. */
6464 if (TREE_TYPE (op0
) != result_type
)
6465 op0
= convert (result_type
, op0
);
6470 /* Comparison operations are shortened too but differently.
6471 They identify themselves by setting short_compare = 1. */
6475 /* We call shorten_compare only for diagnostics. */
6476 tree xop0
= fold_simple (op0
);
6477 tree xop1
= fold_simple (op1
);
6478 tree xresult_type
= result_type
;
6479 enum tree_code xresultcode
= resultcode
;
6480 shorten_compare (location
, &xop0
, &xop1
, &xresult_type
,
6484 if ((short_compare
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
6485 && warn_sign_compare
6486 /* Do not warn until the template is instantiated; we cannot
6487 bound the ranges of the arguments until that point. */
6488 && !processing_template_decl
6489 && (complain
& tf_warning
)
6490 && c_inhibit_evaluation_warnings
== 0
6491 /* Even unsigned enum types promote to signed int. We don't
6492 want to issue -Wsign-compare warnings for this case. */
6493 && !enum_cast_to_int (orig_op0
)
6494 && !enum_cast_to_int (orig_op1
))
6496 warn_for_sign_compare (location
, orig_op0
, orig_op1
, op0
, op1
,
6497 result_type
, resultcode
);
6501 /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
6502 Then the expression will be built.
6503 It will be given type FINAL_TYPE if that is nonzero;
6504 otherwise, it will be given type RESULT_TYPE. */
6507 warning_sentinel
w (warn_sign_conversion
, short_compare
);
6508 if (!same_type_p (TREE_TYPE (op0
), result_type
))
6509 op0
= cp_convert_and_check (result_type
, op0
, complain
);
6510 if (!same_type_p (TREE_TYPE (op1
), result_type
))
6511 op1
= cp_convert_and_check (result_type
, op1
, complain
);
6513 if (op0
== error_mark_node
|| op1
== error_mark_node
)
6514 return error_mark_node
;
6517 if (build_type
== NULL_TREE
)
6518 build_type
= result_type
;
6521 && flag_strong_eval_order
== 2
6522 && TREE_SIDE_EFFECTS (op1
)
6523 && !processing_template_decl
)
6525 /* In C++17, in both op0 << op1 and op0 >> op1 op0 is sequenced before
6526 op1, so if op1 has side-effects, use SAVE_EXPR around op0. */
6527 op0
= cp_save_expr (op0
);
6528 instrument_expr
= op0
;
6531 if (sanitize_flags_p ((SANITIZE_SHIFT
6533 | SANITIZE_FLOAT_DIVIDE
6534 | SANITIZE_SI_OVERFLOW
))
6535 && current_function_decl
!= NULL_TREE
6536 && !processing_template_decl
6537 && (doing_div_or_mod
|| doing_shift
))
6539 /* OP0 and/or OP1 might have side-effects. */
6540 op0
= cp_save_expr (op0
);
6541 op1
= cp_save_expr (op1
);
6542 op0
= fold_non_dependent_expr (op0
, complain
);
6543 op1
= fold_non_dependent_expr (op1
, complain
);
6544 tree instrument_expr1
= NULL_TREE
;
6545 if (doing_div_or_mod
6546 && sanitize_flags_p (SANITIZE_DIVIDE
6547 | SANITIZE_FLOAT_DIVIDE
6548 | SANITIZE_SI_OVERFLOW
))
6550 /* For diagnostics we want to use the promoted types without
6551 shorten_binary_op. So convert the arguments to the
6552 original result_type. */
6555 if (TREE_TYPE (cop0
) != orig_type
)
6556 cop0
= cp_convert (orig_type
, op0
, complain
);
6557 if (TREE_TYPE (cop1
) != orig_type
)
6558 cop1
= cp_convert (orig_type
, op1
, complain
);
6559 instrument_expr1
= ubsan_instrument_division (location
, cop0
, cop1
);
6561 else if (doing_shift
&& sanitize_flags_p (SANITIZE_SHIFT
))
6562 instrument_expr1
= ubsan_instrument_shift (location
, code
, op0
, op1
);
6563 if (instrument_expr
!= NULL
)
6564 instrument_expr
= add_stmt_to_compound (instrument_expr
,
6567 instrument_expr
= instrument_expr1
;
6570 result
= build2_loc (location
, resultcode
, build_type
, op0
, op1
);
6571 if (final_type
!= 0)
6572 result
= cp_convert (final_type
, result
, complain
);
6574 if (instrument_expr
!= NULL
)
6575 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
),
6576 instrument_expr
, result
);
6578 if (resultcode
== SPACESHIP_EXPR
&& !processing_template_decl
)
6579 result
= get_target_expr (result
, complain
);
6581 if (semantic_result_type
)
6582 result
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, result
);
6584 if (!c_inhibit_evaluation_warnings
)
6586 if (!processing_template_decl
)
6588 op0
= cp_fully_fold (op0
);
6589 /* Only consider the second argument if the first isn't overflowed. */
6590 if (!CONSTANT_CLASS_P (op0
) || TREE_OVERFLOW_P (op0
))
6592 op1
= cp_fully_fold (op1
);
6593 if (!CONSTANT_CLASS_P (op1
) || TREE_OVERFLOW_P (op1
))
6596 else if (!CONSTANT_CLASS_P (op0
) || !CONSTANT_CLASS_P (op1
)
6597 || TREE_OVERFLOW_P (op0
) || TREE_OVERFLOW_P (op1
))
6600 tree result_ovl
= fold_build2 (resultcode
, build_type
, op0
, op1
);
6601 if (TREE_OVERFLOW_P (result_ovl
))
6602 overflow_warning (location
, result_ovl
);
6608 /* Build a VEC_PERM_EXPR.
6609 This is a simple wrapper for c_build_vec_perm_expr. */
6611 build_x_vec_perm_expr (location_t loc
,
6612 tree arg0
, tree arg1
, tree arg2
,
6613 tsubst_flags_t complain
)
6615 tree orig_arg0
= arg0
;
6616 tree orig_arg1
= arg1
;
6617 tree orig_arg2
= arg2
;
6618 if (processing_template_decl
)
6620 if (type_dependent_expression_p (arg0
)
6621 || type_dependent_expression_p (arg1
)
6622 || type_dependent_expression_p (arg2
))
6623 return build_min_nt_loc (loc
, VEC_PERM_EXPR
, arg0
, arg1
, arg2
);
6625 tree exp
= c_build_vec_perm_expr (loc
, arg0
, arg1
, arg2
, complain
& tf_error
);
6626 if (processing_template_decl
&& exp
!= error_mark_node
)
6627 return build_min_non_dep (VEC_PERM_EXPR
, exp
, orig_arg0
,
6628 orig_arg1
, orig_arg2
);
6632 /* Build a VEC_PERM_EXPR.
6633 This is a simple wrapper for c_build_shufflevector. */
6635 build_x_shufflevector (location_t loc
, vec
<tree
, va_gc
> *args
,
6636 tsubst_flags_t complain
)
6638 tree arg0
= (*args
)[0];
6639 tree arg1
= (*args
)[1];
6640 if (processing_template_decl
)
6642 for (unsigned i
= 0; i
< args
->length (); ++i
)
6644 ? type_dependent_expression_p ((*args
)[i
])
6645 : instantiation_dependent_expression_p ((*args
)[i
]))
6647 tree exp
= build_min_nt_call_vec (NULL
, args
);
6648 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6652 auto_vec
<tree
, 16> mask
;
6653 for (unsigned i
= 2; i
< args
->length (); ++i
)
6655 tree idx
= fold_non_dependent_expr ((*args
)[i
], complain
);
6656 mask
.safe_push (idx
);
6658 tree exp
= c_build_shufflevector (loc
, arg0
, arg1
, mask
, complain
& tf_error
);
6659 if (processing_template_decl
&& exp
!= error_mark_node
)
6661 exp
= build_min_non_dep_call_vec (exp
, NULL
, args
);
6662 CALL_EXPR_IFN (exp
) = IFN_SHUFFLEVECTOR
;
6667 /* Return a tree for the sum or difference (RESULTCODE says which)
6668 of pointer PTROP and integer INTOP. */
6671 cp_pointer_int_sum (location_t loc
, enum tree_code resultcode
, tree ptrop
,
6672 tree intop
, tsubst_flags_t complain
)
6674 tree res_type
= TREE_TYPE (ptrop
);
6676 /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
6677 in certain circumstance (when it's valid to do so). So we need
6678 to make sure it's complete. We don't need to check here, if we
6679 can actually complete it at all, as those checks will be done in
6680 pointer_int_sum() anyway. */
6681 complete_type (TREE_TYPE (res_type
));
6683 return pointer_int_sum (loc
, resultcode
, ptrop
,
6684 intop
, complain
& tf_warning_or_error
);
6687 /* Return a tree for the difference of pointers OP0 and OP1.
6688 The resulting tree has type int. If POINTER_SUBTRACT sanitization is
6689 enabled, assign to INSTRUMENT_EXPR call to libsanitizer. */
6692 pointer_diff (location_t loc
, tree op0
, tree op1
, tree ptrtype
,
6693 tsubst_flags_t complain
, tree
*instrument_expr
)
6695 tree result
, inttype
;
6696 tree restype
= ptrdiff_type_node
;
6697 tree target_type
= TREE_TYPE (ptrtype
);
6699 if (!complete_type_or_maybe_complain (target_type
, NULL_TREE
, complain
))
6700 return error_mark_node
;
6702 if (VOID_TYPE_P (target_type
))
6704 if (complain
& tf_error
)
6705 permerror (loc
, "ISO C++ forbids using pointer of "
6706 "type %<void *%> in subtraction");
6708 return error_mark_node
;
6710 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
6712 if (complain
& tf_error
)
6713 permerror (loc
, "ISO C++ forbids using pointer to "
6714 "a function in subtraction");
6716 return error_mark_node
;
6718 if (TREE_CODE (target_type
) == METHOD_TYPE
)
6720 if (complain
& tf_error
)
6721 permerror (loc
, "ISO C++ forbids using pointer to "
6722 "a method in subtraction");
6724 return error_mark_node
;
6726 else if (!verify_type_context (loc
, TCTX_POINTER_ARITH
,
6727 TREE_TYPE (TREE_TYPE (op0
)),
6728 !(complain
& tf_error
))
6729 || !verify_type_context (loc
, TCTX_POINTER_ARITH
,
6730 TREE_TYPE (TREE_TYPE (op1
)),
6731 !(complain
& tf_error
)))
6732 return error_mark_node
;
6734 /* Determine integer type result of the subtraction. This will usually
6735 be the same as the result type (ptrdiff_t), but may need to be a wider
6736 type if pointers for the address space are wider than ptrdiff_t. */
6737 if (TYPE_PRECISION (restype
) < TYPE_PRECISION (TREE_TYPE (op0
)))
6738 inttype
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0
)), 0);
6742 if (!processing_template_decl
6743 && sanitize_flags_p (SANITIZE_POINTER_SUBTRACT
))
6745 op0
= save_expr (op0
);
6746 op1
= save_expr (op1
);
6748 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT
);
6749 *instrument_expr
= build_call_expr_loc (loc
, tt
, 2, op0
, op1
);
6752 /* First do the subtraction, then build the divide operator
6753 and only convert at the very end.
6754 Do not do default conversions in case restype is a short type. */
6756 /* POINTER_DIFF_EXPR requires a signed integer type of the same size as
6757 pointers. If some platform cannot provide that, or has a larger
6758 ptrdiff_type to support differences larger than half the address
6759 space, cast the pointers to some larger integer type and do the
6760 computations in that type. */
6761 if (TYPE_PRECISION (inttype
) > TYPE_PRECISION (TREE_TYPE (op0
)))
6762 op0
= cp_build_binary_op (loc
,
6764 cp_convert (inttype
, op0
, complain
),
6765 cp_convert (inttype
, op1
, complain
),
6768 op0
= build2_loc (loc
, POINTER_DIFF_EXPR
, inttype
, op0
, op1
);
6770 /* This generates an error if op1 is a pointer to an incomplete type. */
6771 if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1
))))
6773 if (complain
& tf_error
)
6774 error_at (loc
, "invalid use of a pointer to an incomplete type in "
6775 "pointer arithmetic");
6777 return error_mark_node
;
6780 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (op1
)))
6782 if (complain
& tf_error
)
6783 error_at (loc
, "arithmetic on pointer to an empty aggregate");
6785 return error_mark_node
;
6788 op1
= (TYPE_PTROB_P (ptrtype
)
6789 ? size_in_bytes_loc (loc
, target_type
)
6790 : integer_one_node
);
6792 /* Do the division. */
6794 result
= build2_loc (loc
, EXACT_DIV_EXPR
, inttype
, op0
,
6795 cp_convert (inttype
, op1
, complain
));
6796 return cp_convert (restype
, result
, complain
);
6799 /* Construct and perhaps optimize a tree representation
6800 for a unary operation. CODE, a tree_code, specifies the operation
6801 and XARG is the operand. */
6804 build_x_unary_op (location_t loc
, enum tree_code code
, cp_expr xarg
,
6805 tree lookups
, tsubst_flags_t complain
)
6807 tree orig_expr
= xarg
;
6810 tree overload
= NULL_TREE
;
6812 if (processing_template_decl
)
6814 if (type_dependent_expression_p (xarg
))
6816 tree e
= build_min_nt_loc (loc
, code
, xarg
.get_value (), NULL_TREE
);
6817 TREE_TYPE (e
) = build_dependent_operator_type (lookups
, code
, false);
6824 /* [expr.unary.op] says:
6826 The address of an object of incomplete type can be taken.
6828 (And is just the ordinary address operator, not an overloaded
6829 "operator &".) However, if the type is a template
6830 specialization, we must complete the type at this point so that
6831 an overloaded "operator &" will be available if required. */
6832 if (code
== ADDR_EXPR
6833 && TREE_CODE (xarg
) != TEMPLATE_ID_EXPR
6834 && ((CLASS_TYPE_P (TREE_TYPE (xarg
))
6835 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg
))))
6836 || (TREE_CODE (xarg
) == OFFSET_REF
)))
6837 /* Don't look for a function. */;
6839 exp
= build_new_op (loc
, code
, LOOKUP_NORMAL
, xarg
, NULL_TREE
,
6840 NULL_TREE
, lookups
, &overload
, complain
);
6842 if (!exp
&& code
== ADDR_EXPR
)
6844 if (is_overloaded_fn (xarg
))
6846 tree fn
= get_first_fn (xarg
);
6847 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
6849 if (complain
& tf_error
)
6850 error_at (loc
, DECL_CONSTRUCTOR_P (fn
)
6851 ? G_("taking address of constructor %qD")
6852 : G_("taking address of destructor %qD"),
6854 return error_mark_node
;
6858 /* A pointer to member-function can be formed only by saying
6860 if (!flag_ms_extensions
&& TREE_CODE (TREE_TYPE (xarg
)) == METHOD_TYPE
6861 && (TREE_CODE (xarg
) != OFFSET_REF
|| !PTRMEM_OK_P (xarg
)))
6863 if (TREE_CODE (xarg
) != OFFSET_REF
6864 || !TYPE_P (TREE_OPERAND (xarg
, 0)))
6866 if (complain
& tf_error
)
6868 error_at (loc
, "invalid use of %qE to form a "
6869 "pointer-to-member-function", xarg
.get_value ());
6870 if (TREE_CODE (xarg
) != OFFSET_REF
)
6871 inform (loc
, " a qualified-id is required");
6873 return error_mark_node
;
6877 if (complain
& tf_error
)
6878 error_at (loc
, "parentheses around %qE cannot be used to "
6879 "form a pointer-to-member-function",
6882 return error_mark_node
;
6883 PTRMEM_OK_P (xarg
) = 1;
6887 if (TREE_CODE (xarg
) == OFFSET_REF
)
6889 ptrmem
= PTRMEM_OK_P (xarg
);
6891 if (!ptrmem
&& !flag_ms_extensions
6892 && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg
, 1))) == METHOD_TYPE
)
6894 /* A single non-static member, make sure we don't allow a
6895 pointer-to-member. */
6896 xarg
= build2 (OFFSET_REF
, TREE_TYPE (xarg
),
6897 TREE_OPERAND (xarg
, 0),
6898 ovl_make (TREE_OPERAND (xarg
, 1)));
6899 PTRMEM_OK_P (xarg
) = ptrmem
;
6903 exp
= cp_build_addr_expr_strict (xarg
, complain
);
6905 if (TREE_CODE (exp
) == PTRMEM_CST
)
6906 PTRMEM_CST_LOCATION (exp
) = loc
;
6908 protected_set_expr_location (exp
, loc
);
6911 if (processing_template_decl
&& exp
!= error_mark_node
)
6913 if (overload
!= NULL_TREE
)
6914 return (build_min_non_dep_op_overload
6915 (code
, exp
, overload
, orig_expr
, integer_zero_node
));
6917 exp
= build_min_non_dep (code
, exp
, orig_expr
,
6918 /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE
);
6920 if (TREE_CODE (exp
) == ADDR_EXPR
)
6921 PTRMEM_OK_P (exp
) = ptrmem
;
6925 /* Construct and perhaps optimize a tree representation
6926 for __builtin_addressof operation. ARG specifies the operand. */
6929 cp_build_addressof (location_t loc
, tree arg
, tsubst_flags_t complain
)
6931 tree orig_expr
= arg
;
6933 if (processing_template_decl
)
6935 if (type_dependent_expression_p (arg
))
6936 return build_min_nt_loc (loc
, ADDRESSOF_EXPR
, arg
, NULL_TREE
);
6939 tree exp
= cp_build_addr_expr_strict (arg
, complain
);
6941 if (processing_template_decl
&& exp
!= error_mark_node
)
6942 exp
= build_min_non_dep (ADDRESSOF_EXPR
, exp
, orig_expr
, NULL_TREE
);
6946 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
6947 constants, where a null value is represented by an INTEGER_CST of
6951 cp_truthvalue_conversion (tree expr
, tsubst_flags_t complain
)
6953 tree type
= TREE_TYPE (expr
);
6954 location_t loc
= cp_expr_loc_or_input_loc (expr
);
6955 if (TYPE_PTR_OR_PTRMEM_P (type
)
6956 /* Avoid ICE on invalid use of non-static member function. */
6957 || TREE_CODE (expr
) == FUNCTION_DECL
)
6958 return cp_build_binary_op (loc
, NE_EXPR
, expr
, nullptr_node
, complain
);
6960 return c_common_truthvalue_conversion (loc
, expr
);
6963 /* Returns EXPR contextually converted to bool. */
6966 contextual_conv_bool (tree expr
, tsubst_flags_t complain
)
6968 return perform_implicit_conversion_flags (boolean_type_node
, expr
,
6969 complain
, LOOKUP_NORMAL
);
6972 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. This
6973 is a low-level function; most callers should use maybe_convert_cond. */
6976 condition_conversion (tree expr
)
6978 tree t
= contextual_conv_bool (expr
, tf_warning_or_error
);
6979 if (!processing_template_decl
)
6980 t
= fold_build_cleanup_point_expr (boolean_type_node
, t
);
6984 /* Returns the address of T. This function will fold away
6985 ADDR_EXPR of INDIRECT_REF. This is only for low-level usage;
6986 most places should use cp_build_addr_expr instead. */
6989 build_address (tree t
)
6991 if (error_operand_p (t
) || !cxx_mark_addressable (t
))
6992 return error_mark_node
;
6993 gcc_checking_assert (TREE_CODE (t
) != CONSTRUCTOR
6994 || processing_template_decl
);
6995 t
= build_fold_addr_expr_loc (EXPR_LOCATION (t
), t
);
6996 if (TREE_CODE (t
) != ADDR_EXPR
)
7001 /* Return a NOP_EXPR converting EXPR to TYPE. */
7004 build_nop (tree type
, tree expr
)
7006 if (type
== error_mark_node
|| error_operand_p (expr
))
7008 return build1_loc (EXPR_LOCATION (expr
), NOP_EXPR
, type
, expr
);
7011 /* Take the address of ARG, whatever that means under C++ semantics.
7012 If STRICT_LVALUE is true, require an lvalue; otherwise, allow xvalues
7013 and class rvalues as well.
7015 Nothing should call this function directly; instead, callers should use
7016 cp_build_addr_expr or cp_build_addr_expr_strict. */
7019 cp_build_addr_expr_1 (tree arg
, bool strict_lvalue
, tsubst_flags_t complain
)
7024 if (!arg
|| error_operand_p (arg
))
7025 return error_mark_node
;
7027 arg
= mark_lvalue_use (arg
);
7028 if (error_operand_p (arg
))
7029 return error_mark_node
;
7031 argtype
= lvalue_type (arg
);
7032 location_t loc
= cp_expr_loc_or_input_loc (arg
);
7034 gcc_assert (!(identifier_p (arg
) && IDENTIFIER_ANY_OP_P (arg
)));
7036 if (TREE_CODE (arg
) == COMPONENT_REF
&& type_unknown_p (arg
)
7037 && !really_overloaded_fn (arg
))
7039 /* They're trying to take the address of a unique non-static
7040 member function. This is ill-formed (except in MS-land),
7041 but let's try to DTRT.
7042 Note: We only handle unique functions here because we don't
7043 want to complain if there's a static overload; non-unique
7044 cases will be handled by instantiate_type. But we need to
7045 handle this case here to allow casts on the resulting PMF.
7046 We could defer this in non-MS mode, but it's easier to give
7047 a useful error here. */
7049 /* Inside constant member functions, the `this' pointer
7050 contains an extra const qualifier. TYPE_MAIN_VARIANT
7051 is used here to remove this const from the diagnostics
7052 and the created OFFSET_REF. */
7053 tree base
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg
, 0)));
7054 tree fn
= get_first_fn (TREE_OPERAND (arg
, 1));
7055 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7056 return error_mark_node
;
7058 if (! flag_ms_extensions
)
7060 tree name
= DECL_NAME (fn
);
7061 if (!(complain
& tf_error
))
7062 return error_mark_node
;
7063 else if (current_class_type
7064 && TREE_OPERAND (arg
, 0) == current_class_ref
)
7065 /* An expression like &memfn. */
7067 "ISO C++ forbids taking the address of an unqualified"
7068 " or parenthesized non-static member function to form"
7069 " a pointer to member function. Say %<&%T::%D%>",
7073 "ISO C++ forbids taking the address of a bound member"
7074 " function to form a pointer to member function."
7078 arg
= build_offset_ref (base
, fn
, /*address_p=*/true, complain
);
7081 /* Uninstantiated types are all functions. Taking the
7082 address of a function is a no-op, so just return the
7084 if (type_unknown_p (arg
))
7085 return build1 (ADDR_EXPR
, unknown_type_node
, arg
);
7087 if (TREE_CODE (arg
) == OFFSET_REF
)
7088 /* We want a pointer to member; bypass all the code for actually taking
7089 the address of something. */
7092 /* Anything not already handled and not a true memory reference
7094 if (!FUNC_OR_METHOD_TYPE_P (argtype
))
7096 cp_lvalue_kind kind
= lvalue_kind (arg
);
7097 if (kind
== clk_none
)
7099 if (complain
& tf_error
)
7100 lvalue_error (loc
, lv_addressof
);
7101 return error_mark_node
;
7103 if (strict_lvalue
&& (kind
& (clk_rvalueref
|clk_class
)))
7105 if (!(complain
& tf_error
))
7106 return error_mark_node
;
7107 /* Make this a permerror because we used to accept it. */
7108 permerror (loc
, "taking address of rvalue");
7112 if (TYPE_REF_P (argtype
))
7114 tree type
= build_pointer_type (TREE_TYPE (argtype
));
7115 arg
= build1 (CONVERT_EXPR
, type
, arg
);
7118 else if (pedantic
&& DECL_MAIN_P (tree_strip_any_location_wrapper (arg
)))
7121 /* Apparently a lot of autoconf scripts for C++ packages do this,
7122 so only complain if -Wpedantic. */
7123 if (complain
& (flag_pedantic_errors
? tf_error
: tf_warning
))
7124 pedwarn (loc
, OPT_Wpedantic
,
7125 "ISO C++ forbids taking address of function %<::main%>");
7126 else if (flag_pedantic_errors
)
7127 return error_mark_node
;
7130 /* Let &* cancel out to simplify resulting code. */
7131 if (INDIRECT_REF_P (arg
))
7133 arg
= TREE_OPERAND (arg
, 0);
7134 if (TYPE_REF_P (TREE_TYPE (arg
)))
7136 tree type
= build_pointer_type (TREE_TYPE (TREE_TYPE (arg
)));
7137 arg
= build1 (CONVERT_EXPR
, type
, arg
);
7140 /* Don't let this be an lvalue. */
7145 /* Handle complex lvalues (when permitted)
7146 by reduction to simpler cases. */
7147 val
= unary_complex_lvalue (ADDR_EXPR
, arg
);
7151 switch (TREE_CODE (arg
))
7155 case FIX_TRUNC_EXPR
:
7156 /* We should have handled this above in the lvalue_kind check. */
7161 arg
= BASELINK_FUNCTIONS (arg
);
7165 arg
= OVL_FIRST (arg
);
7170 /* Turn a reference to a non-static data member into a
7171 pointer-to-member. */
7176 gcc_assert (PTRMEM_OK_P (arg
));
7178 t
= TREE_OPERAND (arg
, 1);
7179 if (TYPE_REF_P (TREE_TYPE (t
)))
7181 if (complain
& tf_error
)
7183 "cannot create pointer to reference member %qD", t
);
7184 return error_mark_node
;
7187 /* Forming a pointer-to-member is a use of non-pure-virtual fns. */
7188 if (TREE_CODE (t
) == FUNCTION_DECL
7189 && !DECL_PURE_VIRTUAL_P (t
)
7190 && !mark_used (t
, complain
) && !(complain
& tf_error
))
7191 return error_mark_node
;
7193 type
= build_ptrmem_type (context_for_name_lookup (t
),
7195 t
= make_ptrmem_cst (type
, t
);
7203 if (argtype
!= error_mark_node
)
7204 argtype
= build_pointer_type (argtype
);
7206 if (bitfield_p (arg
))
7208 if (complain
& tf_error
)
7209 error_at (loc
, "attempt to take address of bit-field");
7210 return error_mark_node
;
7213 /* In a template, we are processing a non-dependent expression
7214 so we can just form an ADDR_EXPR with the correct type. */
7215 if (processing_template_decl
|| TREE_CODE (arg
) != COMPONENT_REF
)
7217 if (!mark_single_function (arg
, complain
))
7218 return error_mark_node
;
7219 val
= build_address (arg
);
7220 if (TREE_CODE (arg
) == OFFSET_REF
)
7221 PTRMEM_OK_P (val
) = PTRMEM_OK_P (arg
);
7223 else if (BASELINK_P (TREE_OPERAND (arg
, 1)))
7225 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (arg
, 1));
7227 /* We can only get here with a single static member
7229 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
7230 && DECL_STATIC_FUNCTION_P (fn
));
7231 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7232 return error_mark_node
;
7233 val
= build_address (fn
);
7234 if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
7235 /* Do not lose object's side effects. */
7236 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (val
),
7237 TREE_OPERAND (arg
, 0), val
);
7241 tree object
= TREE_OPERAND (arg
, 0);
7242 tree field
= TREE_OPERAND (arg
, 1);
7243 gcc_assert (same_type_ignoring_top_level_qualifiers_p
7244 (TREE_TYPE (object
), decl_type_context (field
)));
7245 val
= build_address (arg
);
7248 if (TYPE_PTR_P (argtype
)
7249 && TREE_CODE (TREE_TYPE (argtype
)) == METHOD_TYPE
)
7251 build_ptrmemfunc_type (argtype
);
7252 val
= build_ptrmemfunc (argtype
, val
, 0,
7257 /* For addresses of immediate functions ensure we have EXPR_LOCATION
7258 set for possible later diagnostics. */
7259 if (TREE_CODE (val
) == ADDR_EXPR
7260 && TREE_CODE (TREE_OPERAND (val
, 0)) == FUNCTION_DECL
7261 && DECL_IMMEDIATE_FUNCTION_P (TREE_OPERAND (val
, 0)))
7262 SET_EXPR_LOCATION (val
, input_location
);
7267 /* Take the address of ARG if it has one, even if it's an rvalue. */
7270 cp_build_addr_expr (tree arg
, tsubst_flags_t complain
)
7272 return cp_build_addr_expr_1 (arg
, 0, complain
);
7275 /* Take the address of ARG, but only if it's an lvalue. */
7278 cp_build_addr_expr_strict (tree arg
, tsubst_flags_t complain
)
7280 return cp_build_addr_expr_1 (arg
, 1, complain
);
7283 /* C++: Must handle pointers to members.
7285 Perhaps type instantiation should be extended to handle conversion
7286 from aggregates to types we don't yet know we want? (Or are those
7287 cases typically errors which should be reported?)
7289 NOCONVERT suppresses the default promotions (such as from short to int). */
7292 cp_build_unary_op (enum tree_code code
, tree xarg
, bool noconvert
,
7293 tsubst_flags_t complain
)
7295 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
7297 location_t location
= cp_expr_loc_or_input_loc (arg
);
7299 tree eptype
= NULL_TREE
;
7300 const char *errstring
= NULL
;
7302 const char *invalid_op_diag
;
7304 if (!arg
|| error_operand_p (arg
))
7305 return error_mark_node
;
7307 arg
= resolve_nondeduced_context (arg
, complain
);
7309 if ((invalid_op_diag
7310 = targetm
.invalid_unary_op ((code
== UNARY_PLUS_EXPR
7315 if (complain
& tf_error
)
7316 error (invalid_op_diag
);
7317 return error_mark_node
;
7320 if (TREE_CODE (arg
) == EXCESS_PRECISION_EXPR
)
7322 eptype
= TREE_TYPE (arg
);
7323 arg
= TREE_OPERAND (arg
, 0);
7328 case UNARY_PLUS_EXPR
:
7331 int flags
= WANT_ARITH
| WANT_ENUM
;
7332 /* Unary plus (but not unary minus) is allowed on pointers. */
7333 if (code
== UNARY_PLUS_EXPR
)
7334 flags
|= WANT_POINTER
;
7335 arg
= build_expr_type_conversion (flags
, arg
, true);
7337 errstring
= (code
== NEGATE_EXPR
7338 ? _("wrong type argument to unary minus")
7339 : _("wrong type argument to unary plus"));
7342 if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7343 arg
= cp_perform_integral_promotions (arg
, complain
);
7345 /* Make sure the result is not an lvalue: a unary plus or minus
7346 expression is always a rvalue. */
7353 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7358 arg
= cp_default_conversion (arg
, complain
);
7359 if (arg
== error_mark_node
)
7360 return error_mark_node
;
7363 else if (!(arg
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
7364 | WANT_VECTOR_OR_COMPLEX
,
7366 errstring
= _("wrong type argument to bit-complement");
7367 else if (!noconvert
&& INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg
)))
7369 /* Warn if the expression has boolean value. */
7370 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
7371 && (complain
& tf_warning
)
7372 && warning_at (location
, OPT_Wbool_operation
,
7373 "%<~%> on an expression of type %<bool%>"))
7374 inform (location
, "did you mean to use logical not (%<!%>)?");
7375 arg
= cp_perform_integral_promotions (arg
, complain
);
7377 else if (!noconvert
&& VECTOR_TYPE_P (TREE_TYPE (arg
)))
7378 arg
= mark_rvalue_use (arg
);
7382 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7383 errstring
= _("wrong type argument to abs");
7384 else if (!noconvert
)
7386 arg
= cp_default_conversion (arg
, complain
);
7387 if (arg
== error_mark_node
)
7388 return error_mark_node
;
7393 /* Conjugating a real value is a no-op, but allow it anyway. */
7394 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_ENUM
, arg
, true)))
7395 errstring
= _("wrong type argument to conjugation");
7396 else if (!noconvert
)
7398 arg
= cp_default_conversion (arg
, complain
);
7399 if (arg
== error_mark_node
)
7400 return error_mark_node
;
7404 case TRUTH_NOT_EXPR
:
7405 if (gnu_vector_type_p (TREE_TYPE (arg
)))
7406 return cp_build_binary_op (input_location
, EQ_EXPR
, arg
,
7407 build_zero_cst (TREE_TYPE (arg
)), complain
);
7408 arg
= perform_implicit_conversion (boolean_type_node
, arg
,
7410 if (arg
!= error_mark_node
)
7412 if (processing_template_decl
)
7413 return build1_loc (location
, TRUTH_NOT_EXPR
, boolean_type_node
, arg
);
7414 val
= invert_truthvalue_loc (location
, arg
);
7415 if (obvalue_p (val
))
7416 val
= non_lvalue_loc (location
, val
);
7419 errstring
= _("in argument to unary !");
7427 val
= build_real_imag_expr (input_location
, code
, arg
);
7428 if (eptype
&& TREE_CODE (eptype
) == COMPLEX_EXPR
)
7429 val
= build1_loc (input_location
, EXCESS_PRECISION_EXPR
,
7430 TREE_TYPE (eptype
), val
);
7433 case PREINCREMENT_EXPR
:
7434 case POSTINCREMENT_EXPR
:
7435 case PREDECREMENT_EXPR
:
7436 case POSTDECREMENT_EXPR
:
7437 /* Handle complex lvalues (when permitted)
7438 by reduction to simpler cases. */
7440 val
= unary_complex_lvalue (code
, arg
);
7442 goto return_build_unary_op
;
7444 arg
= mark_lvalue_use (arg
);
7446 /* Increment or decrement the real part of the value,
7447 and don't change the imaginary part. */
7448 if (TREE_CODE (TREE_TYPE (arg
)) == COMPLEX_TYPE
)
7452 arg
= cp_stabilize_reference (arg
);
7453 real
= cp_build_unary_op (REALPART_EXPR
, arg
, true, complain
);
7454 imag
= cp_build_unary_op (IMAGPART_EXPR
, arg
, true, complain
);
7455 real
= cp_build_unary_op (code
, real
, true, complain
);
7456 if (real
== error_mark_node
|| imag
== error_mark_node
)
7457 return error_mark_node
;
7458 val
= build2 (COMPLEX_EXPR
, TREE_TYPE (arg
), real
, imag
);
7459 goto return_build_unary_op
;
7462 /* Report invalid types. */
7464 if (!(arg
= build_expr_type_conversion (WANT_ARITH
| WANT_POINTER
,
7467 if (code
== PREINCREMENT_EXPR
)
7468 errstring
= _("no pre-increment operator for type");
7469 else if (code
== POSTINCREMENT_EXPR
)
7470 errstring
= _("no post-increment operator for type");
7471 else if (code
== PREDECREMENT_EXPR
)
7472 errstring
= _("no pre-decrement operator for type");
7474 errstring
= _("no post-decrement operator for type");
7477 else if (arg
== error_mark_node
)
7478 return error_mark_node
;
7480 /* Report something read-only. */
7482 if (CP_TYPE_CONST_P (TREE_TYPE (arg
))
7483 || TREE_READONLY (arg
))
7485 if (complain
& tf_error
)
7486 cxx_readonly_error (location
, arg
,
7487 ((code
== PREINCREMENT_EXPR
7488 || code
== POSTINCREMENT_EXPR
)
7489 ? lv_increment
: lv_decrement
));
7491 return error_mark_node
;
7496 tree declared_type
= unlowered_expr_type (arg
);
7498 argtype
= TREE_TYPE (arg
);
7500 /* ARM $5.2.5 last annotation says this should be forbidden. */
7501 if (TREE_CODE (argtype
) == ENUMERAL_TYPE
)
7503 if (complain
& tf_error
)
7504 permerror (location
, (code
== PREINCREMENT_EXPR
7505 || code
== POSTINCREMENT_EXPR
)
7506 ? G_("ISO C++ forbids incrementing an enum")
7507 : G_("ISO C++ forbids decrementing an enum"));
7509 return error_mark_node
;
7512 /* Compute the increment. */
7514 if (TYPE_PTR_P (argtype
))
7516 tree type
= complete_type (TREE_TYPE (argtype
));
7518 if (!COMPLETE_OR_VOID_TYPE_P (type
))
7520 if (complain
& tf_error
)
7521 error_at (location
, ((code
== PREINCREMENT_EXPR
7522 || code
== POSTINCREMENT_EXPR
))
7523 ? G_("cannot increment a pointer to incomplete "
7525 : G_("cannot decrement a pointer to incomplete "
7527 TREE_TYPE (argtype
));
7529 return error_mark_node
;
7531 else if (!TYPE_PTROB_P (argtype
))
7533 if (complain
& tf_error
)
7534 pedwarn (location
, OPT_Wpointer_arith
,
7535 (code
== PREINCREMENT_EXPR
7536 || code
== POSTINCREMENT_EXPR
)
7537 ? G_("ISO C++ forbids incrementing a pointer "
7539 : G_("ISO C++ forbids decrementing a pointer "
7543 return error_mark_node
;
7545 else if (!verify_type_context (location
, TCTX_POINTER_ARITH
,
7546 TREE_TYPE (argtype
),
7547 !(complain
& tf_error
)))
7548 return error_mark_node
;
7550 inc
= cxx_sizeof_nowarn (TREE_TYPE (argtype
));
7553 inc
= VECTOR_TYPE_P (argtype
)
7554 ? build_one_cst (argtype
)
7557 inc
= cp_convert (argtype
, inc
, complain
);
7559 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
7560 need to ask Objective-C to build the increment or decrement
7561 expression for it. */
7562 if (objc_is_property_ref (arg
))
7563 return objc_build_incr_expr_for_property_ref (input_location
, code
,
7566 /* Complain about anything else that is not a true lvalue. */
7567 if (!lvalue_or_else (arg
, ((code
== PREINCREMENT_EXPR
7568 || code
== POSTINCREMENT_EXPR
)
7569 ? lv_increment
: lv_decrement
),
7571 return error_mark_node
;
7573 /* [depr.volatile.type] "Postfix ++ and -- expressions and
7574 prefix ++ and -- expressions of volatile-qualified arithmetic
7575 and pointer types are deprecated." */
7576 if ((TREE_THIS_VOLATILE (arg
) || CP_TYPE_VOLATILE_P (TREE_TYPE (arg
)))
7577 && (complain
& tf_warning
))
7578 warning_at (location
, OPT_Wvolatile
,
7579 "%qs expression of %<volatile%>-qualified type is "
7581 ((code
== PREINCREMENT_EXPR
7582 || code
== POSTINCREMENT_EXPR
)
7585 /* Forbid using -- or ++ in C++17 on `bool'. */
7586 if (TREE_CODE (declared_type
) == BOOLEAN_TYPE
)
7588 if (code
== POSTDECREMENT_EXPR
|| code
== PREDECREMENT_EXPR
)
7590 if (complain
& tf_error
)
7592 "use of an operand of type %qT in %<operator--%> "
7593 "is forbidden", boolean_type_node
);
7594 return error_mark_node
;
7598 if (cxx_dialect
>= cxx17
)
7600 if (complain
& tf_error
)
7602 "use of an operand of type %qT in "
7603 "%<operator++%> is forbidden in C++17",
7605 return error_mark_node
;
7607 /* Otherwise, [depr.incr.bool] says this is deprecated. */
7608 else if (complain
& tf_warning
)
7609 warning_at (location
, OPT_Wdeprecated
,
7610 "use of an operand of type %qT "
7611 "in %<operator++%> is deprecated",
7614 val
= boolean_increment (code
, arg
);
7616 else if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
7617 /* An rvalue has no cv-qualifiers. */
7618 val
= build2 (code
, cv_unqualified (TREE_TYPE (arg
)), arg
, inc
);
7620 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
7622 TREE_SIDE_EFFECTS (val
) = 1;
7623 goto return_build_unary_op
;
7627 /* Note that this operation never does default_conversion
7628 regardless of NOCONVERT. */
7629 return cp_build_addr_expr (arg
, complain
);
7638 argtype
= TREE_TYPE (arg
);
7639 val
= build1 (code
, argtype
, arg
);
7640 return_build_unary_op
:
7642 val
= build1 (EXCESS_PRECISION_EXPR
, eptype
, val
);
7646 if (complain
& tf_error
)
7647 error_at (location
, "%s", errstring
);
7648 return error_mark_node
;
7651 /* Hook for the c-common bits that build a unary op. */
7653 build_unary_op (location_t
/*location*/,
7654 enum tree_code code
, tree xarg
, bool noconvert
)
7656 return cp_build_unary_op (code
, xarg
, noconvert
, tf_warning_or_error
);
7659 /* Adjust LVALUE, an MODIFY_EXPR, PREINCREMENT_EXPR or PREDECREMENT_EXPR,
7660 so that it is a valid lvalue even for GENERIC by replacing
7661 (lhs = rhs) with ((lhs = rhs), lhs)
7662 (--lhs) with ((--lhs), lhs)
7663 (++lhs) with ((++lhs), lhs)
7664 and if lhs has side-effects, calling cp_stabilize_reference on it, so
7665 that it can be evaluated multiple times. */
7668 genericize_compound_lvalue (tree lvalue
)
7670 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lvalue
, 0)))
7671 lvalue
= build2 (TREE_CODE (lvalue
), TREE_TYPE (lvalue
),
7672 cp_stabilize_reference (TREE_OPERAND (lvalue
, 0)),
7673 TREE_OPERAND (lvalue
, 1));
7674 return build2 (COMPOUND_EXPR
, TREE_TYPE (TREE_OPERAND (lvalue
, 0)),
7675 lvalue
, TREE_OPERAND (lvalue
, 0));
7678 /* Apply unary lvalue-demanding operator CODE to the expression ARG
7679 for certain kinds of expressions which are not really lvalues
7680 but which we can accept as lvalues.
7682 If ARG is not a kind of expression we can handle, return
7686 unary_complex_lvalue (enum tree_code code
, tree arg
)
7688 /* Inside a template, making these kinds of adjustments is
7689 pointless; we are only concerned with the type of the
7691 if (processing_template_decl
)
7694 /* Handle (a, b) used as an "lvalue". */
7695 if (TREE_CODE (arg
) == COMPOUND_EXPR
)
7697 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 1), false,
7698 tf_warning_or_error
);
7699 return build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7700 TREE_OPERAND (arg
, 0), real_result
);
7703 /* Handle (a ? b : c) used as an "lvalue". */
7704 if (TREE_CODE (arg
) == COND_EXPR
7705 || TREE_CODE (arg
) == MIN_EXPR
|| TREE_CODE (arg
) == MAX_EXPR
)
7706 return rationalize_conditional_expr (code
, arg
, tf_warning_or_error
);
7708 /* Handle (a = b), (++a), and (--a) used as an "lvalue". */
7709 if (TREE_CODE (arg
) == MODIFY_EXPR
7710 || TREE_CODE (arg
) == PREINCREMENT_EXPR
7711 || TREE_CODE (arg
) == PREDECREMENT_EXPR
)
7712 return unary_complex_lvalue (code
, genericize_compound_lvalue (arg
));
7714 if (code
!= ADDR_EXPR
)
7717 /* Handle (a = b) used as an "lvalue" for `&'. */
7718 if (TREE_CODE (arg
) == MODIFY_EXPR
7719 || TREE_CODE (arg
) == INIT_EXPR
)
7721 tree real_result
= cp_build_unary_op (code
, TREE_OPERAND (arg
, 0), false,
7722 tf_warning_or_error
);
7723 arg
= build2 (COMPOUND_EXPR
, TREE_TYPE (real_result
),
7725 suppress_warning (arg
/* What warning? */);
7729 if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (arg
))
7730 || TREE_CODE (arg
) == OFFSET_REF
)
7733 /* We permit compiler to make function calls returning
7734 objects of aggregate type look like lvalues. */
7738 if (TREE_CODE (targ
) == SAVE_EXPR
)
7739 targ
= TREE_OPERAND (targ
, 0);
7741 if (TREE_CODE (targ
) == CALL_EXPR
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (targ
)))
7743 if (TREE_CODE (arg
) == SAVE_EXPR
)
7746 targ
= build_cplus_new (TREE_TYPE (arg
), arg
, tf_warning_or_error
);
7747 return build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (arg
)), targ
);
7750 if (TREE_CODE (arg
) == SAVE_EXPR
&& INDIRECT_REF_P (targ
))
7751 return build3 (SAVE_EXPR
, build_pointer_type (TREE_TYPE (arg
)),
7752 TREE_OPERAND (targ
, 0), current_function_decl
, NULL
);
7755 /* Don't let anything else be handled specially. */
7759 /* Mark EXP saying that we need to be able to take the
7760 address of it; it should not be allocated in a register.
7761 Value is true if successful. ARRAY_REF_P is true if this
7762 is for ARRAY_REF construction - in that case we don't want
7763 to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
7764 it is fine to use ARRAY_REFs for vector subscripts on vector
7767 C++: we do not allow `current_class_ptr' to be addressable. */
7770 cxx_mark_addressable (tree exp
, bool array_ref_p
)
7775 switch (TREE_CODE (x
))
7777 case VIEW_CONVERT_EXPR
:
7779 && TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
7780 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x
, 0))))
7782 x
= TREE_OPERAND (x
, 0);
7787 error ("attempt to take address of bit-field");
7793 x
= TREE_OPERAND (x
, 0);
7797 if (x
== current_class_ptr
)
7799 error ("cannot take the address of %<this%>, which is an rvalue expression");
7800 TREE_ADDRESSABLE (x
) = 1; /* so compiler doesn't die later. */
7806 /* Caller should not be trying to mark initialized
7807 constant fields addressable. */
7808 gcc_assert (DECL_LANG_SPECIFIC (x
) == 0
7809 || DECL_IN_AGGR_P (x
) == 0
7811 || DECL_EXTERNAL (x
));
7815 if (DECL_REGISTER (x
) && !TREE_ADDRESSABLE (x
)
7816 && !DECL_ARTIFICIAL (x
))
7818 if (VAR_P (x
) && DECL_HARD_REGISTER (x
))
7821 ("address of explicit register variable %qD requested", x
);
7824 else if (extra_warnings
)
7826 (OPT_Wextra
, "address requested for %qD, which is declared %<register%>", x
);
7828 TREE_ADDRESSABLE (x
) = 1;
7833 TREE_ADDRESSABLE (x
) = 1;
7837 TREE_ADDRESSABLE (x
) = 1;
7841 TREE_ADDRESSABLE (x
) = 1;
7842 cxx_mark_addressable (TREE_OPERAND (x
, 0));
7850 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
7853 build_x_conditional_expr (location_t loc
, tree ifexp
, tree op1
, tree op2
,
7854 tsubst_flags_t complain
)
7856 tree orig_ifexp
= ifexp
;
7857 tree orig_op1
= op1
;
7858 tree orig_op2
= op2
;
7861 if (processing_template_decl
)
7863 /* The standard says that the expression is type-dependent if
7864 IFEXP is type-dependent, even though the eventual type of the
7865 expression doesn't dependent on IFEXP. */
7866 if (type_dependent_expression_p (ifexp
)
7867 /* As a GNU extension, the middle operand may be omitted. */
7868 || (op1
&& type_dependent_expression_p (op1
))
7869 || type_dependent_expression_p (op2
))
7870 return build_min_nt_loc (loc
, COND_EXPR
, ifexp
, op1
, op2
);
7873 expr
= build_conditional_expr (loc
, ifexp
, op1
, op2
, complain
);
7874 if (processing_template_decl
&& expr
!= error_mark_node
)
7876 tree min
= build_min_non_dep (COND_EXPR
, expr
,
7877 orig_ifexp
, orig_op1
, orig_op2
);
7878 expr
= convert_from_reference (min
);
7883 /* Given a list of expressions, return a compound expression
7884 that performs them all and returns the value of the last of them. */
7887 build_x_compound_expr_from_list (tree list
, expr_list_kind exp
,
7888 tsubst_flags_t complain
)
7890 tree expr
= TREE_VALUE (list
);
7892 if (BRACE_ENCLOSED_INITIALIZER_P (expr
)
7893 && !CONSTRUCTOR_IS_DIRECT_INIT (expr
))
7895 if (complain
& tf_error
)
7896 pedwarn (cp_expr_loc_or_input_loc (expr
), 0,
7897 "list-initializer for non-class type must not "
7898 "be parenthesized");
7900 return error_mark_node
;
7903 if (TREE_CHAIN (list
))
7905 if (complain
& tf_error
)
7909 permerror (input_location
, "expression list treated as compound "
7910 "expression in initializer");
7913 permerror (input_location
, "expression list treated as compound "
7914 "expression in mem-initializer");
7917 permerror (input_location
, "expression list treated as compound "
7918 "expression in functional cast");
7924 return error_mark_node
;
7926 for (list
= TREE_CHAIN (list
); list
; list
= TREE_CHAIN (list
))
7927 expr
= build_x_compound_expr (EXPR_LOCATION (TREE_VALUE (list
)),
7928 expr
, TREE_VALUE (list
), NULL_TREE
,
7935 /* Like build_x_compound_expr_from_list, but using a VEC. */
7938 build_x_compound_expr_from_vec (vec
<tree
, va_gc
> *vec
, const char *msg
,
7939 tsubst_flags_t complain
)
7941 if (vec_safe_is_empty (vec
))
7943 else if (vec
->length () == 1)
7953 if (complain
& tf_error
)
7954 permerror (input_location
,
7955 "%s expression list treated as compound expression",
7958 return error_mark_node
;
7962 for (ix
= 1; vec
->iterate (ix
, &t
); ++ix
)
7963 expr
= build_x_compound_expr (EXPR_LOCATION (t
), expr
,
7964 t
, NULL_TREE
, complain
);
7970 /* Handle overloading of the ',' operator when needed. */
7973 build_x_compound_expr (location_t loc
, tree op1
, tree op2
,
7974 tree lookups
, tsubst_flags_t complain
)
7977 tree orig_op1
= op1
;
7978 tree orig_op2
= op2
;
7979 tree overload
= NULL_TREE
;
7981 if (processing_template_decl
)
7983 if (type_dependent_expression_p (op1
)
7984 || type_dependent_expression_p (op2
))
7986 result
= build_min_nt_loc (loc
, COMPOUND_EXPR
, op1
, op2
);
7988 = build_dependent_operator_type (lookups
, COMPOUND_EXPR
, false);
7993 result
= build_new_op (loc
, COMPOUND_EXPR
, LOOKUP_NORMAL
, op1
, op2
,
7994 NULL_TREE
, lookups
, &overload
, complain
);
7996 result
= cp_build_compound_expr (op1
, op2
, complain
);
7998 if (processing_template_decl
&& result
!= error_mark_node
)
8000 if (overload
!= NULL_TREE
)
8001 return (build_min_non_dep_op_overload
8002 (COMPOUND_EXPR
, result
, overload
, orig_op1
, orig_op2
));
8004 return build_min_non_dep (COMPOUND_EXPR
, result
, orig_op1
, orig_op2
);
8010 /* Like cp_build_compound_expr, but for the c-common bits. */
8013 build_compound_expr (location_t
/*loc*/, tree lhs
, tree rhs
)
8015 return cp_build_compound_expr (lhs
, rhs
, tf_warning_or_error
);
8018 /* Build a compound expression. */
8021 cp_build_compound_expr (tree lhs
, tree rhs
, tsubst_flags_t complain
)
8023 lhs
= convert_to_void (lhs
, ICV_LEFT_OF_COMMA
, complain
);
8025 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
8026 return error_mark_node
;
8028 if (TREE_CODE (lhs
) == EXCESS_PRECISION_EXPR
)
8029 lhs
= TREE_OPERAND (lhs
, 0);
8030 tree eptype
= NULL_TREE
;
8031 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
8033 eptype
= TREE_TYPE (rhs
);
8034 rhs
= TREE_OPERAND (rhs
, 0);
8037 if (TREE_CODE (rhs
) == TARGET_EXPR
)
8039 /* If the rhs is a TARGET_EXPR, then build the compound
8040 expression inside the target_expr's initializer. This
8041 helps the compiler to eliminate unnecessary temporaries. */
8042 tree init
= TREE_OPERAND (rhs
, 1);
8044 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), lhs
, init
);
8045 TREE_OPERAND (rhs
, 1) = init
;
8048 rhs
= build1 (EXCESS_PRECISION_EXPR
, eptype
, rhs
);
8052 if (type_unknown_p (rhs
))
8054 if (complain
& tf_error
)
8055 error_at (cp_expr_loc_or_input_loc (rhs
),
8056 "no context to resolve type of %qE", rhs
);
8057 return error_mark_node
;
8060 tree ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (rhs
), lhs
, rhs
);
8062 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
8066 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
8067 casts away constness. CAST gives the type of cast. Returns true
8068 if the cast is ill-formed, false if it is well-formed.
8070 ??? This function warns for casting away any qualifier not just
8071 const. We would like to specify exactly what qualifiers are casted
8076 check_for_casting_away_constness (location_t loc
, tree src_type
,
8077 tree dest_type
, enum tree_code cast
,
8078 tsubst_flags_t complain
)
8080 /* C-style casts are allowed to cast away constness. With
8081 WARN_CAST_QUAL, we still want to issue a warning. */
8082 if (cast
== CAST_EXPR
&& !warn_cast_qual
)
8085 if (!casts_away_constness (src_type
, dest_type
, complain
))
8091 if (complain
& tf_warning
)
8092 warning_at (loc
, OPT_Wcast_qual
,
8093 "cast from type %qT to type %qT casts away qualifiers",
8094 src_type
, dest_type
);
8097 case STATIC_CAST_EXPR
:
8098 if (complain
& tf_error
)
8099 error_at (loc
, "%<static_cast%> from type %qT to type %qT casts "
8101 src_type
, dest_type
);
8104 case REINTERPRET_CAST_EXPR
:
8105 if (complain
& tf_error
)
8106 error_at (loc
, "%<reinterpret_cast%> from type %qT to type %qT "
8107 "casts away qualifiers",
8108 src_type
, dest_type
);
8116 /* Warns if the cast from expression EXPR to type TYPE is useless. */
8118 maybe_warn_about_useless_cast (location_t loc
, tree type
, tree expr
,
8119 tsubst_flags_t complain
)
8121 if (warn_useless_cast
8122 && complain
& tf_warning
)
8124 if (TYPE_REF_P (type
)
8125 ? ((TYPE_REF_IS_RVALUE (type
)
8126 ? xvalue_p (expr
) : lvalue_p (expr
))
8127 && same_type_p (TREE_TYPE (expr
), TREE_TYPE (type
)))
8128 /* Don't warn when converting a class object to a non-reference type,
8129 because that's a common way to create a temporary. */
8130 : (!glvalue_p (expr
) && same_type_p (TREE_TYPE (expr
), type
)))
8131 warning_at (loc
, OPT_Wuseless_cast
,
8132 "useless cast to type %q#T", type
);
8136 /* Warns if the cast ignores cv-qualifiers on TYPE. */
8138 maybe_warn_about_cast_ignoring_quals (location_t loc
, tree type
,
8139 tsubst_flags_t complain
)
8141 if (warn_ignored_qualifiers
8142 && complain
& tf_warning
8143 && !CLASS_TYPE_P (type
)
8144 && (cp_type_quals (type
) & (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)))
8145 warning_at (loc
, OPT_Wignored_qualifiers
,
8146 "type qualifiers ignored on cast result type");
8149 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
8150 (another pointer-to-member type in the same hierarchy) and return
8151 the converted expression. If ALLOW_INVERSE_P is permitted, a
8152 pointer-to-derived may be converted to pointer-to-base; otherwise,
8153 only the other direction is permitted. If C_CAST_P is true, this
8154 conversion is taking place as part of a C-style cast. */
8157 convert_ptrmem (tree type
, tree expr
, bool allow_inverse_p
,
8158 bool c_cast_p
, tsubst_flags_t complain
)
8160 if (same_type_p (type
, TREE_TYPE (expr
)))
8163 if (TYPE_PTRDATAMEM_P (type
))
8165 tree obase
= TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr
));
8166 tree nbase
= TYPE_PTRMEM_CLASS_TYPE (type
);
8167 tree delta
= (get_delta_difference
8169 allow_inverse_p
, c_cast_p
, complain
));
8171 if (delta
== error_mark_node
)
8172 return error_mark_node
;
8174 if (!same_type_p (obase
, nbase
))
8176 if (TREE_CODE (expr
) == PTRMEM_CST
)
8177 expr
= cplus_expand_constant (expr
);
8179 tree cond
= cp_build_binary_op (input_location
, EQ_EXPR
, expr
,
8180 build_int_cst (TREE_TYPE (expr
), -1),
8182 tree op1
= build_nop (ptrdiff_type_node
, expr
);
8183 tree op2
= cp_build_binary_op (input_location
, PLUS_EXPR
, op1
, delta
,
8186 expr
= fold_build3_loc (input_location
,
8187 COND_EXPR
, ptrdiff_type_node
, cond
, op1
, op2
);
8190 return build_nop (type
, expr
);
8193 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
,
8194 allow_inverse_p
, c_cast_p
, complain
);
8197 /* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true,
8198 this static_cast is being attempted as one of the possible casts
8199 allowed by a C-style cast. (In that case, accessibility of base
8200 classes is not considered, and it is OK to cast away
8201 constness.) Return the result of the cast. *VALID_P is set to
8202 indicate whether or not the cast was valid. */
8205 build_static_cast_1 (location_t loc
, tree type
, tree expr
, bool c_cast_p
,
8206 bool *valid_p
, tsubst_flags_t complain
)
8212 /* Assume the cast is valid. */
8215 intype
= unlowered_expr_type (expr
);
8217 /* Save casted types in the function's used types hash table. */
8218 used_types_insert (type
);
8220 /* A prvalue of non-class type is cv-unqualified. */
8221 if (!CLASS_TYPE_P (type
))
8222 type
= cv_unqualified (type
);
8224 /* [expr.static.cast]
8226 An lvalue of type "cv1 B", where B is a class type, can be cast
8227 to type "reference to cv2 D", where D is a class derived (clause
8228 _class.derived_) from B, if a valid standard conversion from
8229 "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
8230 same cv-qualification as, or greater cv-qualification than, cv1,
8231 and B is not a virtual base class of D. */
8232 /* We check this case before checking the validity of "TYPE t =
8233 EXPR;" below because for this case:
8236 struct D : public B { D(const B&); };
8238 void f() { static_cast<const D&>(b); }
8240 we want to avoid constructing a new D. The standard is not
8241 completely clear about this issue, but our interpretation is
8242 consistent with other compilers. */
8243 if (TYPE_REF_P (type
)
8244 && CLASS_TYPE_P (TREE_TYPE (type
))
8245 && CLASS_TYPE_P (intype
)
8246 && (TYPE_REF_IS_RVALUE (type
) || lvalue_p (expr
))
8247 && DERIVED_FROM_P (intype
, TREE_TYPE (type
))
8248 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype
)),
8249 build_pointer_type (TYPE_MAIN_VARIANT
8250 (TREE_TYPE (type
))),
8253 || at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
8257 if (processing_template_decl
)
8260 /* There is a standard conversion from "D*" to "B*" even if "B"
8261 is ambiguous or inaccessible. If this is really a
8262 static_cast, then we check both for inaccessibility and
8263 ambiguity. However, if this is a static_cast being performed
8264 because the user wrote a C-style cast, then accessibility is
8266 base
= lookup_base (TREE_TYPE (type
), intype
,
8267 c_cast_p
? ba_unique
: ba_check
,
8269 expr
= cp_build_addr_expr (expr
, complain
);
8271 if (sanitize_flags_p (SANITIZE_VPTR
))
8274 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
8280 /* Convert from "B*" to "D*". This function will check that "B"
8281 is not a virtual base of "D". Even if we don't have a guarantee
8282 that expr is NULL, if the static_cast is to a reference type,
8283 it is UB if it would be NULL, so omit the non-NULL check. */
8284 expr
= build_base_path (MINUS_EXPR
, expr
, base
,
8285 /*nonnull=*/flag_delete_null_pointer_checks
,
8288 /* Convert the pointer to a reference -- but then remember that
8289 there are no expressions with reference type in C++.
8291 We call rvalue so that there's an actual tree code
8292 (NON_LVALUE_EXPR) for the static_cast; otherwise, if the operand
8293 is a variable with the same type, the conversion would get folded
8294 away, leaving just the variable and causing lvalue_kind to give
8295 the wrong answer. */
8296 expr
= cp_fold_convert (type
, expr
);
8298 /* When -fsanitize=null, make sure to diagnose reference binding to
8299 NULL even when the reference is converted to pointer later on. */
8300 if (sanitize_flags_p (SANITIZE_NULL
)
8301 && TREE_CODE (expr
) == COND_EXPR
8302 && TREE_OPERAND (expr
, 2)
8303 && TREE_CODE (TREE_OPERAND (expr
, 2)) == INTEGER_CST
8304 && TREE_TYPE (TREE_OPERAND (expr
, 2)) == type
)
8305 ubsan_maybe_instrument_reference (&TREE_OPERAND (expr
, 2));
8307 return convert_from_reference (rvalue (expr
));
8310 /* "A glvalue of type cv1 T1 can be cast to type rvalue reference to
8311 cv2 T2 if cv2 T2 is reference-compatible with cv1 T1 (8.5.3)." */
8312 if (TYPE_REF_P (type
)
8313 && TYPE_REF_IS_RVALUE (type
)
8314 && (clk
= real_lvalue_p (expr
))
8315 && reference_compatible_p (TREE_TYPE (type
), intype
)
8316 && (c_cast_p
|| at_least_as_qualified_p (TREE_TYPE (type
), intype
)))
8318 if (processing_template_decl
)
8320 if (clk
== clk_ordinary
)
8322 /* Handle the (non-bit-field) lvalue case here by casting to
8323 lvalue reference and then changing it to an rvalue reference.
8324 Casting an xvalue to rvalue reference will be handled by the
8326 tree lref
= cp_build_reference_type (TREE_TYPE (type
), false);
8327 result
= (perform_direct_initialization_if_possible
8328 (lref
, expr
, c_cast_p
, complain
));
8329 result
= build1 (NON_LVALUE_EXPR
, type
, result
);
8330 return convert_from_reference (result
);
8333 /* For a bit-field or packed field, bind to a temporary. */
8334 expr
= rvalue (expr
);
8337 /* Resolve overloaded address here rather than once in
8338 implicit_conversion and again in the inverse code below. */
8339 if (TYPE_PTRMEMFUNC_P (type
) && type_unknown_p (expr
))
8341 expr
= instantiate_type (type
, expr
, complain
);
8342 intype
= TREE_TYPE (expr
);
8345 /* [expr.static.cast]
8347 Any expression can be explicitly converted to type cv void. */
8348 if (VOID_TYPE_P (type
))
8350 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
8351 expr
= TREE_OPERAND (expr
, 0);
8352 return convert_to_void (expr
, ICV_CAST
, complain
);
8356 An abstract class shall not be used ... as the type of an explicit
8358 if (abstract_virtuals_error (ACU_CAST
, type
, complain
))
8359 return error_mark_node
;
8361 /* [expr.static.cast]
8363 An expression e can be explicitly converted to a type T using a
8364 static_cast of the form static_cast<T>(e) if the declaration T
8365 t(e);" is well-formed, for some invented temporary variable
8367 result
= perform_direct_initialization_if_possible (type
, expr
,
8368 c_cast_p
, complain
);
8369 /* P1975 allows static_cast<Aggr>(42), as well as static_cast<T[5]>(42),
8370 which initialize the first element of the aggregate. We need to handle
8371 the array case specifically. */
8372 if (result
== NULL_TREE
8373 && cxx_dialect
>= cxx20
8374 && TREE_CODE (type
) == ARRAY_TYPE
)
8376 /* Create { EXPR } and perform direct-initialization from it. */
8377 tree e
= build_constructor_single (init_list_type_node
, NULL_TREE
, expr
);
8378 CONSTRUCTOR_IS_DIRECT_INIT (e
) = true;
8379 CONSTRUCTOR_IS_PAREN_INIT (e
) = true;
8380 result
= perform_direct_initialization_if_possible (type
, e
, c_cast_p
,
8385 if (processing_template_decl
)
8388 result
= convert_from_reference (result
);
8390 /* [expr.static.cast]
8392 If T is a reference type, the result is an lvalue; otherwise,
8393 the result is an rvalue. */
8394 if (!TYPE_REF_P (type
))
8396 result
= rvalue (result
);
8398 if (result
== expr
&& SCALAR_TYPE_P (type
))
8399 /* Leave some record of the cast. */
8400 result
= build_nop (type
, expr
);
8405 /* [expr.static.cast]
8407 The inverse of any standard conversion sequence (clause _conv_),
8408 other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
8409 (_conv.array_), function-to-pointer (_conv.func_), and boolean
8410 (_conv.bool_) conversions, can be performed explicitly using
8411 static_cast subject to the restriction that the explicit
8412 conversion does not cast away constness (_expr.const.cast_), and
8413 the following additional rules for specific cases: */
8414 /* For reference, the conversions not excluded are: integral
8415 promotions, floating-point promotion, integral conversions,
8416 floating-point conversions, floating-integral conversions,
8417 pointer conversions, and pointer to member conversions. */
8420 A value of integral _or enumeration_ type can be explicitly
8421 converted to an enumeration type. */
8422 /* The effect of all that is that any conversion between any two
8423 types which are integral, floating, or enumeration types can be
8425 if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8426 || SCALAR_FLOAT_TYPE_P (type
))
8427 && (INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
8428 || SCALAR_FLOAT_TYPE_P (intype
)))
8430 if (processing_template_decl
)
8432 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
8433 expr
= TREE_OPERAND (expr
, 0);
8434 /* [expr.static.cast]: "If the value is not a bit-field, the result
8435 refers to the object or the specified base class subobject thereof;
8436 otherwise, the lvalue-to-rvalue conversion is applied to the
8437 bit-field and the resulting prvalue is used as the operand of the
8438 static_cast." There are no prvalue bit-fields; the l-to-r conversion
8439 will give us an object of the underlying type of the bit-field. */
8440 expr
= decay_conversion (expr
, complain
);
8441 return ocp_convert (type
, expr
, CONV_C_CAST
, LOOKUP_NORMAL
, complain
);
8444 if (TYPE_PTR_P (type
) && TYPE_PTR_P (intype
)
8445 && CLASS_TYPE_P (TREE_TYPE (type
))
8446 && CLASS_TYPE_P (TREE_TYPE (intype
))
8447 && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
8448 (TREE_TYPE (intype
))),
8449 build_pointer_type (TYPE_MAIN_VARIANT
8450 (TREE_TYPE (type
))),
8455 if (processing_template_decl
)
8459 && check_for_casting_away_constness (loc
, intype
, type
,
8462 return error_mark_node
;
8463 base
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
8464 c_cast_p
? ba_unique
: ba_check
,
8466 expr
= build_base_path (MINUS_EXPR
, expr
, base
, /*nonnull=*/false,
8469 if (sanitize_flags_p (SANITIZE_VPTR
))
8472 = cp_ubsan_maybe_instrument_downcast (loc
, type
,
8478 return cp_fold_convert (type
, expr
);
8481 if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8482 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
8489 c1
= TYPE_PTRMEM_CLASS_TYPE (intype
);
8490 c2
= TYPE_PTRMEM_CLASS_TYPE (type
);
8492 if (TYPE_PTRDATAMEM_P (type
))
8494 t1
= (build_ptrmem_type
8496 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype
))));
8497 t2
= (build_ptrmem_type
8499 TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
8506 if (can_convert (t1
, t2
, complain
) || can_convert (t2
, t1
, complain
))
8509 && check_for_casting_away_constness (loc
, intype
, type
,
8512 return error_mark_node
;
8513 if (processing_template_decl
)
8515 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/1,
8516 c_cast_p
, complain
);
8520 /* [expr.static.cast]
8522 An rvalue of type "pointer to cv void" can be explicitly
8523 converted to a pointer to object type. A value of type pointer
8524 to object converted to "pointer to cv void" and back to the
8525 original pointer type will have its original value. */
8526 if (TYPE_PTR_P (intype
)
8527 && VOID_TYPE_P (TREE_TYPE (intype
))
8528 && TYPE_PTROB_P (type
))
8531 && check_for_casting_away_constness (loc
, intype
, type
,
8534 return error_mark_node
;
8535 if (processing_template_decl
)
8537 return build_nop (type
, expr
);
8541 return error_mark_node
;
8544 /* Return an expression representing static_cast<TYPE>(EXPR). */
8547 build_static_cast (location_t loc
, tree type
, tree oexpr
,
8548 tsubst_flags_t complain
)
8554 if (type
== error_mark_node
|| expr
== error_mark_node
)
8555 return error_mark_node
;
8557 bool dependent
= (dependent_type_p (type
)
8558 || type_dependent_expression_p (expr
));
8562 expr
= build_min (STATIC_CAST_EXPR
, type
, oexpr
);
8563 /* We don't know if it will or will not have side effects. */
8564 TREE_SIDE_EFFECTS (expr
) = 1;
8565 result
= convert_from_reference (expr
);
8566 protected_set_expr_location (result
, loc
);
8570 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8571 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8572 if (!TYPE_REF_P (type
)
8573 && TREE_CODE (expr
) == NOP_EXPR
8574 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8575 expr
= TREE_OPERAND (expr
, 0);
8577 result
= build_static_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8578 &valid_p
, complain
);
8581 if (result
!= error_mark_node
)
8583 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8584 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8586 if (processing_template_decl
)
8588 protected_set_expr_location (result
, loc
);
8592 if (complain
& tf_error
)
8594 error_at (loc
, "invalid %<static_cast%> from type %qT to type %qT",
8595 TREE_TYPE (expr
), type
);
8596 if ((TYPE_PTR_P (type
) || TYPE_REF_P (type
))
8597 && CLASS_TYPE_P (TREE_TYPE (type
))
8598 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
8599 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (TREE_TYPE (type
))),
8600 "class type %qT is incomplete", TREE_TYPE (type
));
8601 tree expr_type
= TREE_TYPE (expr
);
8602 if (TYPE_PTR_P (expr_type
))
8603 expr_type
= TREE_TYPE (expr_type
);
8604 if (CLASS_TYPE_P (expr_type
) && !COMPLETE_TYPE_P (expr_type
))
8605 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (expr_type
)),
8606 "class type %qT is incomplete", expr_type
);
8608 return error_mark_node
;
8611 /* EXPR is an expression with member function or pointer-to-member
8612 function type. TYPE is a pointer type. Converting EXPR to TYPE is
8613 not permitted by ISO C++, but we accept it in some modes. If we
8614 are not in one of those modes, issue a diagnostic. Return the
8615 converted expression. */
8618 convert_member_func_to_ptr (tree type
, tree expr
, tsubst_flags_t complain
)
8623 intype
= TREE_TYPE (expr
);
8624 gcc_assert (TYPE_PTRMEMFUNC_P (intype
)
8625 || TREE_CODE (intype
) == METHOD_TYPE
);
8627 if (!(complain
& tf_warning_or_error
))
8628 return error_mark_node
;
8630 location_t loc
= cp_expr_loc_or_input_loc (expr
);
8632 if (pedantic
|| warn_pmf2ptr
)
8633 pedwarn (loc
, pedantic
? OPT_Wpedantic
: OPT_Wpmf_conversions
,
8634 "converting from %qH to %qI", intype
, type
);
8636 STRIP_ANY_LOCATION_WRAPPER (expr
);
8638 if (TREE_CODE (intype
) == METHOD_TYPE
)
8639 expr
= build_addr_func (expr
, complain
);
8640 else if (TREE_CODE (expr
) == PTRMEM_CST
)
8641 expr
= build_address (PTRMEM_CST_MEMBER (expr
));
8644 decl
= maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype
), 0);
8645 decl
= build_address (decl
);
8646 expr
= get_member_function_from_ptrfunc (&decl
, expr
, complain
);
8649 if (expr
== error_mark_node
)
8650 return error_mark_node
;
8652 expr
= build_nop (type
, expr
);
8653 SET_EXPR_LOCATION (expr
, loc
);
8657 /* Build a NOP_EXPR to TYPE, but mark it as a reinterpret_cast so that
8658 constexpr evaluation knows to reject it. */
8661 build_nop_reinterpret (tree type
, tree expr
)
8663 tree ret
= build_nop (type
, expr
);
8665 REINTERPRET_CAST_P (ret
) = true;
8669 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
8670 If C_CAST_P is true, this reinterpret cast is being done as part of
8671 a C-style cast. If VALID_P is non-NULL, *VALID_P is set to
8672 indicate whether or not reinterpret_cast was valid. */
8675 build_reinterpret_cast_1 (location_t loc
, tree type
, tree expr
,
8676 bool c_cast_p
, bool *valid_p
,
8677 tsubst_flags_t complain
)
8681 /* Assume the cast is invalid. */
8685 if (type
== error_mark_node
|| error_operand_p (expr
))
8686 return error_mark_node
;
8688 intype
= TREE_TYPE (expr
);
8690 /* Save casted types in the function's used types hash table. */
8691 used_types_insert (type
);
8693 /* A prvalue of non-class type is cv-unqualified. */
8694 if (!CLASS_TYPE_P (type
))
8695 type
= cv_unqualified (type
);
8697 /* [expr.reinterpret.cast]
8698 A glvalue of type T1, designating an object x, can be cast to the type
8699 "reference to T2" if an expression of type "pointer to T1" can be
8700 explicitly converted to the type "pointer to T2" using a reinterpret_cast.
8701 The result is that of *reinterpret_cast<T2 *>(p) where p is a pointer to x
8702 of type "pointer to T1". No temporary is created, no copy is made, and no
8703 constructors (11.4.4) or conversion functions (11.4.7) are called. */
8704 if (TYPE_REF_P (type
))
8706 if (!glvalue_p (expr
))
8708 if (complain
& tf_error
)
8709 error_at (loc
, "invalid cast of a prvalue expression of type "
8712 return error_mark_node
;
8715 /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
8716 "B" are related class types; the reinterpret_cast does not
8717 adjust the pointer. */
8718 if (TYPE_PTR_P (intype
)
8719 && (complain
& tf_warning
)
8720 && (comptypes (TREE_TYPE (intype
), TREE_TYPE (type
),
8721 COMPARE_BASE
| COMPARE_DERIVED
)))
8722 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
8725 expr
= cp_build_addr_expr (expr
, complain
);
8727 if (warn_strict_aliasing
> 2)
8728 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8730 if (expr
!= error_mark_node
)
8731 expr
= build_reinterpret_cast_1
8732 (loc
, build_pointer_type (TREE_TYPE (type
)), expr
, c_cast_p
,
8734 if (expr
!= error_mark_node
)
8735 /* cp_build_indirect_ref isn't right for rvalue refs. */
8736 expr
= convert_from_reference (fold_convert (type
, expr
));
8740 /* As a G++ extension, we consider conversions from member
8741 functions, and pointers to member functions to
8742 pointer-to-function and pointer-to-void types. If
8743 -Wno-pmf-conversions has not been specified,
8744 convert_member_func_to_ptr will issue an error message. */
8745 if ((TYPE_PTRMEMFUNC_P (intype
)
8746 || TREE_CODE (intype
) == METHOD_TYPE
)
8747 && TYPE_PTR_P (type
)
8748 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
8749 || VOID_TYPE_P (TREE_TYPE (type
))))
8750 return convert_member_func_to_ptr (type
, expr
, complain
);
8752 /* If the cast is not to a reference type, the lvalue-to-rvalue,
8753 array-to-pointer, and function-to-pointer conversions are
8755 expr
= decay_conversion (expr
, complain
);
8757 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
8758 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
8759 if (TREE_CODE (expr
) == NOP_EXPR
8760 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
8761 expr
= TREE_OPERAND (expr
, 0);
8763 if (error_operand_p (expr
))
8764 return error_mark_node
;
8766 intype
= TREE_TYPE (expr
);
8768 /* [expr.reinterpret.cast]
8769 A pointer can be converted to any integral type large enough to
8770 hold it. ... A value of type std::nullptr_t can be converted to
8771 an integral type; the conversion has the same meaning and
8772 validity as a conversion of (void*)0 to the integral type. */
8773 if (CP_INTEGRAL_TYPE_P (type
)
8774 && (TYPE_PTR_P (intype
) || NULLPTR_TYPE_P (intype
)))
8776 if (TYPE_PRECISION (type
) < TYPE_PRECISION (intype
))
8778 if (complain
& tf_error
)
8779 permerror (loc
, "cast from %qH to %qI loses precision",
8782 return error_mark_node
;
8784 if (NULLPTR_TYPE_P (intype
))
8785 return build_int_cst (type
, 0);
8787 /* [expr.reinterpret.cast]
8788 A value of integral or enumeration type can be explicitly
8789 converted to a pointer. */
8790 else if (TYPE_PTR_P (type
) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype
))
8793 else if ((INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
8794 || TYPE_PTR_OR_PTRMEM_P (type
))
8795 && same_type_p (type
, intype
))
8797 return rvalue (expr
);
8798 else if (TYPE_PTRFN_P (type
) && TYPE_PTRFN_P (intype
))
8800 if ((complain
& tf_warning
)
8801 && !cxx_safe_function_type_cast_p (TREE_TYPE (type
),
8802 TREE_TYPE (intype
)))
8803 warning_at (loc
, OPT_Wcast_function_type
,
8804 "cast between incompatible function types"
8805 " from %qH to %qI", intype
, type
);
8806 return build_nop_reinterpret (type
, expr
);
8808 else if (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
))
8810 if ((complain
& tf_warning
)
8811 && !cxx_safe_function_type_cast_p
8812 (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (type
)),
8813 TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (intype
))))
8814 warning_at (loc
, OPT_Wcast_function_type
,
8815 "cast between incompatible pointer to member types"
8816 " from %qH to %qI", intype
, type
);
8817 return build_nop_reinterpret (type
, expr
);
8819 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
8820 || (TYPE_PTROBV_P (type
) && TYPE_PTROBV_P (intype
)))
8823 && check_for_casting_away_constness (loc
, intype
, type
,
8824 REINTERPRET_CAST_EXPR
,
8826 return error_mark_node
;
8827 /* Warn about possible alignment problems. */
8828 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
8829 && (complain
& tf_warning
)
8830 && !VOID_TYPE_P (type
)
8831 && TREE_CODE (TREE_TYPE (intype
)) != FUNCTION_TYPE
8832 && COMPLETE_TYPE_P (TREE_TYPE (type
))
8833 && COMPLETE_TYPE_P (TREE_TYPE (intype
))
8834 && min_align_of_type (TREE_TYPE (type
))
8835 > min_align_of_type (TREE_TYPE (intype
)))
8836 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
8837 "increases required alignment of target type",
8840 if (warn_strict_aliasing
<= 2)
8841 /* strict_aliasing_warning STRIP_NOPs its expr. */
8842 cp_strict_aliasing_warning (EXPR_LOCATION (expr
), type
, expr
);
8844 return build_nop_reinterpret (type
, expr
);
8846 else if ((TYPE_PTRFN_P (type
) && TYPE_PTROBV_P (intype
))
8847 || (TYPE_PTRFN_P (intype
) && TYPE_PTROBV_P (type
)))
8849 if (complain
& tf_warning
)
8850 /* C++11 5.2.10 p8 says that "Converting a function pointer to an
8851 object pointer type or vice versa is conditionally-supported." */
8852 warning_at (loc
, OPT_Wconditionally_supported
,
8853 "casting between pointer-to-function and "
8854 "pointer-to-object is conditionally-supported");
8855 return build_nop_reinterpret (type
, expr
);
8857 else if (gnu_vector_type_p (type
) && scalarish_type_p (intype
))
8858 return convert_to_vector (type
, rvalue (expr
));
8859 else if (gnu_vector_type_p (intype
)
8860 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8861 return convert_to_integer_nofold (type
, expr
);
8866 if (complain
& tf_error
)
8867 error_at (loc
, "invalid cast from type %qT to type %qT",
8869 return error_mark_node
;
8872 expr
= cp_convert (type
, expr
, complain
);
8873 if (TREE_CODE (expr
) == NOP_EXPR
)
8874 /* Mark any nop_expr that created as a reintepret_cast. */
8875 REINTERPRET_CAST_P (expr
) = true;
8880 build_reinterpret_cast (location_t loc
, tree type
, tree expr
,
8881 tsubst_flags_t complain
)
8885 if (type
== error_mark_node
|| expr
== error_mark_node
)
8886 return error_mark_node
;
8888 if (processing_template_decl
)
8890 tree t
= build_min (REINTERPRET_CAST_EXPR
, type
, expr
);
8892 if (!TREE_SIDE_EFFECTS (t
)
8893 && type_dependent_expression_p (expr
))
8894 /* There might turn out to be side effects inside expr. */
8895 TREE_SIDE_EFFECTS (t
) = 1;
8896 r
= convert_from_reference (t
);
8897 protected_set_expr_location (r
, loc
);
8901 r
= build_reinterpret_cast_1 (loc
, type
, expr
, /*c_cast_p=*/false,
8902 /*valid_p=*/NULL
, complain
);
8903 if (r
!= error_mark_node
)
8905 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
8906 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
8908 protected_set_expr_location (r
, loc
);
8912 /* Perform a const_cast from EXPR to TYPE. If the cast is valid,
8913 return an appropriate expression. Otherwise, return
8914 error_mark_node. If the cast is not valid, and COMPLAIN is true,
8915 then a diagnostic will be issued. If VALID_P is non-NULL, we are
8916 performing a C-style cast, its value upon return will indicate
8917 whether or not the conversion succeeded. */
8920 build_const_cast_1 (location_t loc
, tree dst_type
, tree expr
,
8921 tsubst_flags_t complain
, bool *valid_p
)
8924 tree reference_type
;
8926 /* Callers are responsible for handling error_mark_node as a
8927 destination type. */
8928 gcc_assert (dst_type
!= error_mark_node
);
8929 /* In a template, callers should be building syntactic
8930 representations of casts, not using this machinery. */
8931 gcc_assert (!processing_template_decl
);
8933 /* Assume the conversion is invalid. */
8937 if (!INDIRECT_TYPE_P (dst_type
) && !TYPE_PTRDATAMEM_P (dst_type
))
8939 if (complain
& tf_error
)
8940 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8941 "which is not a pointer, reference, "
8942 "nor a pointer-to-data-member type", dst_type
);
8943 return error_mark_node
;
8946 if (TREE_CODE (TREE_TYPE (dst_type
)) == FUNCTION_TYPE
)
8948 if (complain
& tf_error
)
8949 error_at (loc
, "invalid use of %<const_cast%> with type %qT, "
8950 "which is a pointer or reference to a function type",
8952 return error_mark_node
;
8955 /* A prvalue of non-class type is cv-unqualified. */
8956 dst_type
= cv_unqualified (dst_type
);
8958 /* Save casted types in the function's used types hash table. */
8959 used_types_insert (dst_type
);
8961 src_type
= TREE_TYPE (expr
);
8962 /* Expressions do not really have reference types. */
8963 if (TYPE_REF_P (src_type
))
8964 src_type
= TREE_TYPE (src_type
);
8966 /* [expr.const.cast]
8968 For two object types T1 and T2, if a pointer to T1 can be explicitly
8969 converted to the type "pointer to T2" using a const_cast, then the
8970 following conversions can also be made:
8972 -- an lvalue of type T1 can be explicitly converted to an lvalue of
8973 type T2 using the cast const_cast<T2&>;
8975 -- a glvalue of type T1 can be explicitly converted to an xvalue of
8976 type T2 using the cast const_cast<T2&&>; and
8978 -- if T1 is a class type, a prvalue of type T1 can be explicitly
8979 converted to an xvalue of type T2 using the cast const_cast<T2&&>. */
8981 if (TYPE_REF_P (dst_type
))
8983 reference_type
= dst_type
;
8984 if (!TYPE_REF_IS_RVALUE (dst_type
)
8990 if (complain
& tf_error
)
8991 error_at (loc
, "invalid %<const_cast%> of an rvalue of type %qT "
8993 src_type
, dst_type
);
8994 return error_mark_node
;
8996 dst_type
= build_pointer_type (TREE_TYPE (dst_type
));
8997 src_type
= build_pointer_type (src_type
);
9001 reference_type
= NULL_TREE
;
9002 /* If the destination type is not a reference type, the
9003 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
9004 conversions are performed. */
9005 src_type
= type_decays_to (src_type
);
9006 if (src_type
== error_mark_node
)
9007 return error_mark_node
;
9010 if (TYPE_PTR_P (src_type
) || TYPE_PTRDATAMEM_P (src_type
))
9012 if (comp_ptr_ttypes_const (dst_type
, src_type
, bounds_none
))
9017 /* This cast is actually a C-style cast. Issue a warning if
9018 the user is making a potentially unsafe cast. */
9019 check_for_casting_away_constness (loc
, src_type
, dst_type
,
9020 CAST_EXPR
, complain
);
9021 /* ??? comp_ptr_ttypes_const ignores TYPE_ALIGN. */
9022 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
9023 && (complain
& tf_warning
)
9024 && min_align_of_type (TREE_TYPE (dst_type
))
9025 > min_align_of_type (TREE_TYPE (src_type
)))
9026 warning_at (loc
, OPT_Wcast_align
, "cast from %qH to %qI "
9027 "increases required alignment of target type",
9028 src_type
, dst_type
);
9032 expr
= cp_build_addr_expr (expr
, complain
);
9033 if (expr
== error_mark_node
)
9034 return error_mark_node
;
9035 expr
= build_nop (reference_type
, expr
);
9036 return convert_from_reference (expr
);
9040 expr
= decay_conversion (expr
, complain
);
9041 if (expr
== error_mark_node
)
9042 return error_mark_node
;
9044 /* build_c_cast puts on a NOP_EXPR to make the result not an
9045 lvalue. Strip such NOP_EXPRs if VALUE is being used in
9046 non-lvalue context. */
9047 if (TREE_CODE (expr
) == NOP_EXPR
9048 && TREE_TYPE (expr
) == TREE_TYPE (TREE_OPERAND (expr
, 0)))
9049 expr
= TREE_OPERAND (expr
, 0);
9050 return build_nop (dst_type
, expr
);
9054 && !at_least_as_qualified_p (TREE_TYPE (dst_type
),
9055 TREE_TYPE (src_type
)))
9056 check_for_casting_away_constness (loc
, src_type
, dst_type
,
9057 CAST_EXPR
, complain
);
9060 if (complain
& tf_error
)
9061 error_at (loc
, "invalid %<const_cast%> from type %qT to type %qT",
9062 src_type
, dst_type
);
9063 return error_mark_node
;
9067 build_const_cast (location_t loc
, tree type
, tree expr
,
9068 tsubst_flags_t complain
)
9072 if (type
== error_mark_node
|| error_operand_p (expr
))
9073 return error_mark_node
;
9075 if (processing_template_decl
)
9077 tree t
= build_min (CONST_CAST_EXPR
, type
, expr
);
9079 if (!TREE_SIDE_EFFECTS (t
)
9080 && type_dependent_expression_p (expr
))
9081 /* There might turn out to be side effects inside expr. */
9082 TREE_SIDE_EFFECTS (t
) = 1;
9083 r
= convert_from_reference (t
);
9084 protected_set_expr_location (r
, loc
);
9088 r
= build_const_cast_1 (loc
, type
, expr
, complain
, /*valid_p=*/NULL
);
9089 if (r
!= error_mark_node
)
9091 maybe_warn_about_useless_cast (loc
, type
, expr
, complain
);
9092 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
9094 protected_set_expr_location (r
, loc
);
9098 /* Like cp_build_c_cast, but for the c-common bits. */
9101 build_c_cast (location_t loc
, tree type
, tree expr
)
9103 return cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
9106 /* Like the "build_c_cast" used for c-common, but using cp_expr to
9107 preserve location information even for tree nodes that don't
9111 build_c_cast (location_t loc
, tree type
, cp_expr expr
)
9113 cp_expr result
= cp_build_c_cast (loc
, type
, expr
, tf_warning_or_error
);
9114 result
.set_location (loc
);
9118 /* Build an expression representing an explicit C-style cast to type
9119 TYPE of expression EXPR. */
9122 cp_build_c_cast (location_t loc
, tree type
, tree expr
,
9123 tsubst_flags_t complain
)
9129 if (type
== error_mark_node
|| error_operand_p (expr
))
9130 return error_mark_node
;
9132 if (processing_template_decl
)
9134 tree t
= build_min (CAST_EXPR
, type
,
9135 tree_cons (NULL_TREE
, value
, NULL_TREE
));
9136 /* We don't know if it will or will not have side effects. */
9137 TREE_SIDE_EFFECTS (t
) = 1;
9138 return convert_from_reference (t
);
9141 /* Casts to a (pointer to a) specific ObjC class (or 'id' or
9142 'Class') should always be retained, because this information aids
9143 in method lookup. */
9144 if (objc_is_object_ptr (type
)
9145 && objc_is_object_ptr (TREE_TYPE (expr
)))
9146 return build_nop (type
, expr
);
9148 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
9149 Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */
9150 if (!TYPE_REF_P (type
)
9151 && TREE_CODE (value
) == NOP_EXPR
9152 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
9153 value
= TREE_OPERAND (value
, 0);
9155 if (TREE_CODE (type
) == ARRAY_TYPE
)
9157 /* Allow casting from T1* to T2[] because Cfront allows it.
9158 NIHCL uses it. It is not valid ISO C++ however. */
9159 if (TYPE_PTR_P (TREE_TYPE (expr
)))
9161 if (complain
& tf_error
)
9162 permerror (loc
, "ISO C++ forbids casting to an array type %qT",
9165 return error_mark_node
;
9166 type
= build_pointer_type (TREE_TYPE (type
));
9170 if (complain
& tf_error
)
9171 error_at (loc
, "ISO C++ forbids casting to an array type %qT",
9173 return error_mark_node
;
9177 if (FUNC_OR_METHOD_TYPE_P (type
))
9179 if (complain
& tf_error
)
9180 error_at (loc
, "invalid cast to function type %qT", type
);
9181 return error_mark_node
;
9184 if (TYPE_PTR_P (type
)
9185 && TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
9186 /* Casting to an integer of smaller size is an error detected elsewhere. */
9187 && TYPE_PRECISION (type
) > TYPE_PRECISION (TREE_TYPE (value
))
9188 /* Don't warn about converting any constant. */
9189 && !TREE_CONSTANT (value
))
9190 warning_at (loc
, OPT_Wint_to_pointer_cast
,
9191 "cast to pointer from integer of different size");
9193 /* A C-style cast can be a const_cast. */
9194 result
= build_const_cast_1 (loc
, type
, value
, complain
& tf_warning
,
9198 if (result
!= error_mark_node
)
9200 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
9201 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
9206 /* Or a static cast. */
9207 result
= build_static_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
9208 &valid_p
, complain
);
9209 /* Or a reinterpret_cast. */
9211 result
= build_reinterpret_cast_1 (loc
, type
, value
, /*c_cast_p=*/true,
9212 &valid_p
, complain
);
9213 /* The static_cast or reinterpret_cast may be followed by a
9216 /* A valid cast may result in errors if, for example, a
9217 conversion to an ambiguous base class is required. */
9218 && !error_operand_p (result
))
9222 maybe_warn_about_useless_cast (loc
, type
, value
, complain
);
9223 maybe_warn_about_cast_ignoring_quals (loc
, type
, complain
);
9225 /* Non-class rvalues always have cv-unqualified type. */
9226 if (!CLASS_TYPE_P (type
))
9227 type
= TYPE_MAIN_VARIANT (type
);
9228 result_type
= TREE_TYPE (result
);
9229 if (!CLASS_TYPE_P (result_type
) && !TYPE_REF_P (type
))
9230 result_type
= TYPE_MAIN_VARIANT (result_type
);
9231 /* If the type of RESULT does not match TYPE, perform a
9232 const_cast to make it match. If the static_cast or
9233 reinterpret_cast succeeded, we will differ by at most
9234 cv-qualification, so the follow-on const_cast is guaranteed
9236 if (!same_type_p (non_reference (type
), non_reference (result_type
)))
9238 result
= build_const_cast_1 (loc
, type
, result
, false, &valid_p
);
9239 gcc_assert (valid_p
);
9244 return error_mark_node
;
9247 /* Warn when a value is moved to itself with std::move. LHS is the target,
9248 RHS may be the std::move call, and LOC is the location of the whole
9252 maybe_warn_self_move (location_t loc
, tree lhs
, tree rhs
)
9254 if (!warn_self_move
)
9257 /* C++98 doesn't know move. */
9258 if (cxx_dialect
< cxx11
)
9261 if (processing_template_decl
)
9264 if (!REFERENCE_REF_P (rhs
)
9265 || TREE_CODE (TREE_OPERAND (rhs
, 0)) != CALL_EXPR
)
9267 tree fn
= TREE_OPERAND (rhs
, 0);
9268 if (!is_std_move_p (fn
))
9271 /* Just a little helper to strip * and various NOPs. */
9272 auto extract_op
= [] (tree
&op
) {
9274 while (INDIRECT_REF_P (op
))
9275 op
= TREE_OPERAND (op
, 0);
9276 op
= maybe_undo_parenthesized_ref (op
);
9277 STRIP_ANY_LOCATION_WRAPPER (op
);
9280 tree arg
= CALL_EXPR_ARG (fn
, 0);
9282 if (TREE_CODE (arg
) == ADDR_EXPR
)
9283 arg
= TREE_OPERAND (arg
, 0);
9284 tree type
= TREE_TYPE (lhs
);
9285 tree orig_lhs
= lhs
;
9287 if (cp_tree_equal (lhs
, arg
))
9289 auto_diagnostic_group d
;
9290 if (warning_at (loc
, OPT_Wself_move
,
9291 "moving %qE of type %qT to itself", orig_lhs
, type
))
9292 inform (loc
, "remove %<std::move%> call");
9296 /* For use from the C common bits. */
9298 build_modify_expr (location_t location
,
9299 tree lhs
, tree
/*lhs_origtype*/,
9300 enum tree_code modifycode
,
9301 location_t
/*rhs_location*/, tree rhs
,
9302 tree
/*rhs_origtype*/)
9304 return cp_build_modify_expr (location
, lhs
, modifycode
, rhs
,
9305 tf_warning_or_error
);
9308 /* Build an assignment expression of lvalue LHS from value RHS.
9309 MODIFYCODE is the code for a binary operator that we use
9310 to combine the old value of LHS with RHS to get the new value.
9311 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
9313 C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */
9316 cp_build_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
9317 tree rhs
, tsubst_flags_t complain
)
9319 lhs
= mark_lvalue_use_nonread (lhs
);
9321 tree result
= NULL_TREE
;
9323 tree lhstype
= TREE_TYPE (lhs
);
9325 tree olhstype
= lhstype
;
9326 bool plain_assign
= (modifycode
== NOP_EXPR
);
9327 bool compound_side_effects_p
= false;
9328 tree preeval
= NULL_TREE
;
9330 /* Avoid duplicate error messages from operands that had errors. */
9331 if (error_operand_p (lhs
) || error_operand_p (rhs
))
9332 return error_mark_node
;
9334 while (TREE_CODE (lhs
) == COMPOUND_EXPR
)
9336 if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0)))
9337 compound_side_effects_p
= true;
9338 lhs
= TREE_OPERAND (lhs
, 1);
9341 /* Handle control structure constructs used as "lvalues". Note that we
9342 leave COMPOUND_EXPR on the LHS because it is sequenced after the RHS. */
9343 switch (TREE_CODE (lhs
))
9345 /* Handle --foo = 5; as these are valid constructs in C++. */
9346 case PREDECREMENT_EXPR
:
9347 case PREINCREMENT_EXPR
:
9348 if (compound_side_effects_p
)
9349 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
9350 lhs
= genericize_compound_lvalue (lhs
);
9352 /* If we had (bar, --foo) = 5; or (bar, (baz, --foo)) = 5;
9353 and looked through the COMPOUND_EXPRs, readd them now around
9354 the resulting lhs. */
9355 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
9357 lhs
= build2 (COMPOUND_EXPR
, lhstype
, TREE_OPERAND (olhs
, 0), lhs
);
9358 tree
*ptr
= &TREE_OPERAND (lhs
, 1);
9359 for (olhs
= TREE_OPERAND (olhs
, 1);
9360 TREE_CODE (olhs
) == COMPOUND_EXPR
;
9361 olhs
= TREE_OPERAND (olhs
, 1))
9363 *ptr
= build2 (COMPOUND_EXPR
, lhstype
,
9364 TREE_OPERAND (olhs
, 0), *ptr
);
9365 ptr
= &TREE_OPERAND (*ptr
, 1);
9371 if (compound_side_effects_p
)
9372 newrhs
= rhs
= stabilize_expr (rhs
, &preeval
);
9373 lhs
= genericize_compound_lvalue (lhs
);
9374 goto maybe_add_compound
;
9378 /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
9379 when neither operand has side-effects. */
9380 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9381 return error_mark_node
;
9383 gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 0))
9384 && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs
, 1)));
9386 lhs
= build3 (COND_EXPR
, TREE_TYPE (lhs
),
9387 build2 (TREE_CODE (lhs
) == MIN_EXPR
? LE_EXPR
: GE_EXPR
,
9389 TREE_OPERAND (lhs
, 0),
9390 TREE_OPERAND (lhs
, 1)),
9391 TREE_OPERAND (lhs
, 0),
9392 TREE_OPERAND (lhs
, 1));
9395 /* Handle (a ? b : c) used as an "lvalue". */
9398 /* Produce (a ? (b = rhs) : (c = rhs))
9399 except that the RHS goes through a save-expr
9400 so the code to compute it is only emitted once. */
9401 if (VOID_TYPE_P (TREE_TYPE (rhs
)))
9403 if (complain
& tf_error
)
9404 error_at (cp_expr_loc_or_loc (rhs
, loc
),
9405 "void value not ignored as it ought to be");
9406 return error_mark_node
;
9409 rhs
= stabilize_expr (rhs
, &preeval
);
9411 /* Check this here to avoid odd errors when trying to convert
9412 a throw to the type of the COND_EXPR. */
9413 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9414 return error_mark_node
;
9416 tree op1
= TREE_OPERAND (lhs
, 1);
9417 if (TREE_CODE (op1
) != THROW_EXPR
)
9418 op1
= cp_build_modify_expr (loc
, op1
, modifycode
, rhs
, complain
);
9419 /* When sanitizing undefined behavior, even when rhs doesn't need
9420 stabilization at this point, the sanitization might add extra
9421 SAVE_EXPRs in there and so make sure there is no tree sharing
9422 in the rhs, otherwise those SAVE_EXPRs will have initialization
9423 only in one of the two branches. */
9424 if (sanitize_flags_p (SANITIZE_UNDEFINED
9425 | SANITIZE_UNDEFINED_NONDEFAULT
))
9426 rhs
= unshare_expr (rhs
);
9427 tree op2
= TREE_OPERAND (lhs
, 2);
9428 if (TREE_CODE (op2
) != THROW_EXPR
)
9429 op2
= cp_build_modify_expr (loc
, op2
, modifycode
, rhs
, complain
);
9430 tree cond
= build_conditional_expr (input_location
,
9431 TREE_OPERAND (lhs
, 0), op1
, op2
,
9434 if (cond
== error_mark_node
)
9436 /* If we had (e, (a ? b : c)) = d; or (e, (f, (a ? b : c))) = d;
9437 and looked through the COMPOUND_EXPRs, readd them now around
9438 the resulting cond before adding the preevaluated rhs. */
9439 if (TREE_CODE (olhs
) == COMPOUND_EXPR
)
9441 cond
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9442 TREE_OPERAND (olhs
, 0), cond
);
9443 tree
*ptr
= &TREE_OPERAND (cond
, 1);
9444 for (olhs
= TREE_OPERAND (olhs
, 1);
9445 TREE_CODE (olhs
) == COMPOUND_EXPR
;
9446 olhs
= TREE_OPERAND (olhs
, 1))
9448 *ptr
= build2 (COMPOUND_EXPR
, TREE_TYPE (cond
),
9449 TREE_OPERAND (olhs
, 0), *ptr
);
9450 ptr
= &TREE_OPERAND (*ptr
, 1);
9453 /* Make sure the code to compute the rhs comes out
9454 before the split. */
9464 if (modifycode
== INIT_EXPR
)
9466 if (BRACE_ENCLOSED_INITIALIZER_P (rhs
))
9467 /* Do the default thing. */;
9468 else if (TREE_CODE (rhs
) == CONSTRUCTOR
)
9470 /* Compound literal. */
9471 if (! same_type_p (TREE_TYPE (rhs
), lhstype
))
9472 /* Call convert to generate an error; see PR 11063. */
9473 rhs
= convert (lhstype
, rhs
);
9474 result
= cp_build_init_expr (lhs
, rhs
);
9475 TREE_SIDE_EFFECTS (result
) = 1;
9478 else if (! MAYBE_CLASS_TYPE_P (lhstype
))
9479 /* Do the default thing. */;
9482 releasing_vec rhs_vec
= make_tree_vector_single (rhs
);
9483 result
= build_special_member_call (lhs
, complete_ctor_identifier
,
9484 &rhs_vec
, lhstype
, LOOKUP_NORMAL
,
9486 if (result
== NULL_TREE
)
9487 return error_mark_node
;
9493 lhs
= require_complete_type (lhs
, complain
);
9494 if (lhs
== error_mark_node
)
9495 return error_mark_node
;
9497 if (modifycode
== NOP_EXPR
)
9499 maybe_warn_self_move (loc
, lhs
, rhs
);
9501 if (c_dialect_objc ())
9503 result
= objc_maybe_build_modify_expr (lhs
, rhs
);
9508 /* `operator=' is not an inheritable operator. */
9509 if (! MAYBE_CLASS_TYPE_P (lhstype
))
9510 /* Do the default thing. */;
9513 result
= build_new_op (input_location
, MODIFY_EXPR
,
9514 LOOKUP_NORMAL
, lhs
, rhs
,
9515 make_node (NOP_EXPR
), NULL_TREE
,
9516 /*overload=*/NULL
, complain
);
9517 if (result
== NULL_TREE
)
9518 return error_mark_node
;
9525 tree init
= NULL_TREE
;
9527 /* A binary op has been requested. Combine the old LHS
9528 value with the RHS producing the value we should actually
9529 store into the LHS. */
9530 gcc_assert (!((TYPE_REF_P (lhstype
)
9531 && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype
)))
9532 || MAYBE_CLASS_TYPE_P (lhstype
)));
9534 /* Preevaluate the RHS to make sure its evaluation is complete
9535 before the lvalue-to-rvalue conversion of the LHS:
9537 [expr.ass] With respect to an indeterminately-sequenced
9538 function call, the operation of a compound assignment is a
9539 single evaluation. [ Note: Therefore, a function call shall
9540 not intervene between the lvalue-to-rvalue conversion and the
9541 side effect associated with any single compound assignment
9542 operator. -- end note ] */
9543 lhs
= cp_stabilize_reference (lhs
);
9544 rhs
= decay_conversion (rhs
, complain
);
9545 if (rhs
== error_mark_node
)
9546 return error_mark_node
;
9547 rhs
= stabilize_expr (rhs
, &init
);
9548 newrhs
= cp_build_binary_op (loc
, modifycode
, lhs
, rhs
, complain
);
9549 if (newrhs
== error_mark_node
)
9551 if (complain
& tf_error
)
9552 inform (loc
, " in evaluation of %<%Q(%#T, %#T)%>",
9553 modifycode
, TREE_TYPE (lhs
), TREE_TYPE (rhs
));
9554 return error_mark_node
;
9558 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), init
, newrhs
);
9560 /* Now it looks like a plain assignment. */
9561 modifycode
= NOP_EXPR
;
9562 if (c_dialect_objc ())
9564 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
9569 gcc_assert (!TYPE_REF_P (lhstype
));
9570 gcc_assert (!TYPE_REF_P (TREE_TYPE (newrhs
)));
9573 /* The left-hand side must be an lvalue. */
9574 if (!lvalue_or_else (lhs
, lv_assign
, complain
))
9575 return error_mark_node
;
9577 /* Warn about modifying something that is `const'. Don't warn if
9578 this is initialization. */
9579 if (modifycode
!= INIT_EXPR
9580 && (TREE_READONLY (lhs
) || CP_TYPE_CONST_P (lhstype
)
9581 /* Functions are not modifiable, even though they are
9583 || FUNC_OR_METHOD_TYPE_P (TREE_TYPE (lhs
))
9584 /* If it's an aggregate and any field is const, then it is
9585 effectively const. */
9586 || (CLASS_TYPE_P (lhstype
)
9587 && C_TYPE_FIELDS_READONLY (lhstype
))))
9589 if (complain
& tf_error
)
9590 cxx_readonly_error (loc
, lhs
, lv_assign
);
9591 return error_mark_node
;
9594 /* If storing into a structure or union member, it may have been given a
9595 lowered bitfield type. We need to convert to the declared type first,
9596 so retrieve it now. */
9598 olhstype
= unlowered_expr_type (lhs
);
9600 /* Convert new value to destination type. */
9602 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
9606 if (BRACE_ENCLOSED_INITIALIZER_P (newrhs
))
9608 if (modifycode
!= INIT_EXPR
)
9610 if (complain
& tf_error
)
9612 "assigning to an array from an initializer list");
9613 return error_mark_node
;
9615 if (check_array_initializer (lhs
, lhstype
, newrhs
))
9616 return error_mark_node
;
9617 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9618 if (newrhs
== error_mark_node
)
9619 return error_mark_node
;
9622 /* C++11 8.5/17: "If the destination type is an array of characters,
9623 an array of char16_t, an array of char32_t, or an array of wchar_t,
9624 and the initializer is a string literal...". */
9625 else if ((TREE_CODE (tree_strip_any_location_wrapper (newrhs
))
9627 && char_type_p (TREE_TYPE (TYPE_MAIN_VARIANT (lhstype
)))
9628 && modifycode
== INIT_EXPR
)
9630 newrhs
= digest_init (lhstype
, newrhs
, complain
);
9631 if (newrhs
== error_mark_node
)
9632 return error_mark_node
;
9635 else if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype
),
9636 TYPE_MAIN_VARIANT (TREE_TYPE (newrhs
))))
9638 if (complain
& tf_error
)
9639 error_at (loc
, "incompatible types in assignment of %qT to %qT",
9640 TREE_TYPE (rhs
), lhstype
);
9641 return error_mark_node
;
9644 /* Allow array assignment in compiler-generated code. */
9645 else if (DECL_P (lhs
) && DECL_ARTIFICIAL (lhs
))
9646 /* OK, used by coroutines (co-await-initlist1.C). */;
9647 else if (!current_function_decl
9648 || !DECL_DEFAULTED_FN (current_function_decl
))
9650 /* This routine is used for both initialization and assignment.
9651 Make sure the diagnostic message differentiates the context. */
9652 if (complain
& tf_error
)
9654 if (modifycode
== INIT_EXPR
)
9655 error_at (loc
, "array used as initializer");
9657 error_at (loc
, "invalid array assignment");
9659 return error_mark_node
;
9662 from_array
= TREE_CODE (TREE_TYPE (newrhs
)) == ARRAY_TYPE
9663 ? 1 + (modifycode
!= INIT_EXPR
): 0;
9664 result
= build_vec_init (lhs
, NULL_TREE
, newrhs
,
9665 /*explicit_value_init_p=*/false,
9666 from_array
, complain
);
9670 if (modifycode
== INIT_EXPR
)
9671 /* Calls with INIT_EXPR are all direct-initialization, so don't set
9672 LOOKUP_ONLYCONVERTING. */
9673 newrhs
= convert_for_initialization (lhs
, olhstype
, newrhs
, LOOKUP_NORMAL
,
9674 ICR_INIT
, NULL_TREE
, 0,
9675 complain
| tf_no_cleanup
);
9677 newrhs
= convert_for_assignment (olhstype
, newrhs
, ICR_ASSIGN
,
9678 NULL_TREE
, 0, complain
, LOOKUP_IMPLICIT
);
9680 if (!same_type_p (lhstype
, olhstype
))
9681 newrhs
= cp_convert_and_check (lhstype
, newrhs
, complain
);
9683 if (modifycode
!= INIT_EXPR
)
9685 if (TREE_CODE (newrhs
) == CALL_EXPR
9686 && TYPE_NEEDS_CONSTRUCTING (lhstype
))
9687 newrhs
= build_cplus_new (lhstype
, newrhs
, complain
);
9689 /* Can't initialize directly from a TARGET_EXPR, since that would
9690 cause the lhs to be constructed twice, and possibly result in
9691 accidental self-initialization. So we force the TARGET_EXPR to be
9692 expanded without a target. */
9693 if (TREE_CODE (newrhs
) == TARGET_EXPR
)
9694 newrhs
= build2 (COMPOUND_EXPR
, TREE_TYPE (newrhs
), newrhs
,
9695 TREE_OPERAND (newrhs
, 0));
9698 if (newrhs
== error_mark_node
)
9699 return error_mark_node
;
9701 if (c_dialect_objc () && flag_objc_gc
)
9703 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
9709 result
= build2_loc (loc
, modifycode
== NOP_EXPR
? MODIFY_EXPR
: INIT_EXPR
,
9710 lhstype
, lhs
, newrhs
);
9711 if (modifycode
== INIT_EXPR
)
9712 set_target_expr_eliding (newrhs
);
9714 TREE_SIDE_EFFECTS (result
) = 1;
9716 suppress_warning (result
, OPT_Wparentheses
);
9720 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), preeval
, result
);
9725 build_x_modify_expr (location_t loc
, tree lhs
, enum tree_code modifycode
,
9726 tree rhs
, tree lookups
, tsubst_flags_t complain
)
9728 tree orig_lhs
= lhs
;
9729 tree orig_rhs
= rhs
;
9730 tree overload
= NULL_TREE
;
9732 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
9733 return cp_expr (error_mark_node
, loc
);
9735 tree op
= build_min (modifycode
, void_type_node
, NULL_TREE
, NULL_TREE
);
9737 if (processing_template_decl
)
9739 if (type_dependent_expression_p (lhs
)
9740 || type_dependent_expression_p (rhs
))
9742 tree rval
= build_min_nt_loc (loc
, MODOP_EXPR
, lhs
, op
, rhs
);
9743 if (modifycode
!= NOP_EXPR
)
9745 = build_dependent_operator_type (lookups
, modifycode
, true);
9751 if (modifycode
== NOP_EXPR
)
9752 rval
= cp_build_modify_expr (loc
, lhs
, modifycode
, rhs
, complain
);
9754 rval
= build_new_op (loc
, MODIFY_EXPR
, LOOKUP_NORMAL
,
9755 lhs
, rhs
, op
, lookups
, &overload
, complain
);
9756 if (rval
== error_mark_node
)
9757 return error_mark_node
;
9758 if (processing_template_decl
)
9760 if (overload
!= NULL_TREE
)
9761 return (build_min_non_dep_op_overload
9762 (MODIFY_EXPR
, rval
, overload
, orig_lhs
, orig_rhs
));
9764 return (build_min_non_dep
9765 (MODOP_EXPR
, rval
, orig_lhs
, op
, orig_rhs
));
9770 /* Helper function for get_delta_difference which assumes FROM is a base
9771 class of TO. Returns a delta for the conversion of pointer-to-member
9772 of FROM to pointer-to-member of TO. If the conversion is invalid and
9773 tf_error is not set in COMPLAIN returns error_mark_node, otherwise
9774 returns zero. If FROM is not a base class of TO, returns NULL_TREE.
9775 If C_CAST_P is true, this conversion is taking place as part of a
9779 get_delta_difference_1 (tree from
, tree to
, bool c_cast_p
,
9780 tsubst_flags_t complain
)
9785 binfo
= lookup_base (to
, from
, c_cast_p
? ba_unique
: ba_check
,
9788 if (binfo
== error_mark_node
)
9790 if (!(complain
& tf_error
))
9791 return error_mark_node
;
9793 inform (input_location
, " in pointer to member function conversion");
9794 return size_zero_node
;
9798 if (kind
!= bk_via_virtual
)
9799 return BINFO_OFFSET (binfo
);
9801 /* FROM is a virtual base class of TO. Issue an error or warning
9802 depending on whether or not this is a reinterpret cast. */
9804 if (!(complain
& tf_error
))
9805 return error_mark_node
;
9807 error ("pointer to member conversion via virtual base %qT",
9808 BINFO_TYPE (binfo_from_vbase (binfo
)));
9810 return size_zero_node
;
9817 /* Get difference in deltas for different pointer to member function
9818 types. If the conversion is invalid and tf_error is not set in
9819 COMPLAIN, returns error_mark_node, otherwise returns an integer
9820 constant of type PTRDIFF_TYPE_NODE and its value is zero if the
9821 conversion is invalid. If ALLOW_INVERSE_P is true, then allow reverse
9822 conversions as well. If C_CAST_P is true this conversion is taking
9823 place as part of a C-style cast.
9825 Note that the naming of FROM and TO is kind of backwards; the return
9826 value is what we add to a TO in order to get a FROM. They are named
9827 this way because we call this function to find out how to convert from
9828 a pointer to member of FROM to a pointer to member of TO. */
9831 get_delta_difference (tree from
, tree to
,
9832 bool allow_inverse_p
,
9833 bool c_cast_p
, tsubst_flags_t complain
)
9837 if (same_type_ignoring_top_level_qualifiers_p (from
, to
))
9838 /* Pointer to member of incomplete class is permitted*/
9839 result
= size_zero_node
;
9841 result
= get_delta_difference_1 (from
, to
, c_cast_p
, complain
);
9843 if (result
== error_mark_node
)
9844 return error_mark_node
;
9848 if (!allow_inverse_p
)
9850 if (!(complain
& tf_error
))
9851 return error_mark_node
;
9853 error_not_base_type (from
, to
);
9854 inform (input_location
, " in pointer to member conversion");
9855 result
= size_zero_node
;
9859 result
= get_delta_difference_1 (to
, from
, c_cast_p
, complain
);
9861 if (result
== error_mark_node
)
9862 return error_mark_node
;
9865 result
= size_diffop_loc (input_location
,
9866 size_zero_node
, result
);
9869 if (!(complain
& tf_error
))
9870 return error_mark_node
;
9872 error_not_base_type (from
, to
);
9873 inform (input_location
, " in pointer to member conversion");
9874 result
= size_zero_node
;
9879 return convert_to_integer (ptrdiff_type_node
, result
);
9882 /* Return a constructor for the pointer-to-member-function TYPE using
9883 the other components as specified. */
9886 build_ptrmemfunc1 (tree type
, tree delta
, tree pfn
)
9891 vec
<constructor_elt
, va_gc
> *v
;
9893 /* Pull the FIELD_DECLs out of the type. */
9894 pfn_field
= TYPE_FIELDS (type
);
9895 delta_field
= DECL_CHAIN (pfn_field
);
9897 /* Make sure DELTA has the type we want. */
9898 delta
= convert_and_check (input_location
, delta_type_node
, delta
);
9900 /* Convert to the correct target type if necessary. */
9901 pfn
= fold_convert (TREE_TYPE (pfn_field
), pfn
);
9903 /* Finish creating the initializer. */
9905 CONSTRUCTOR_APPEND_ELT(v
, pfn_field
, pfn
);
9906 CONSTRUCTOR_APPEND_ELT(v
, delta_field
, delta
);
9907 u
= build_constructor (type
, v
);
9908 TREE_CONSTANT (u
) = TREE_CONSTANT (pfn
) & TREE_CONSTANT (delta
);
9909 TREE_STATIC (u
) = (TREE_CONSTANT (u
)
9910 && (initializer_constant_valid_p (pfn
, TREE_TYPE (pfn
))
9912 && (initializer_constant_valid_p (delta
, TREE_TYPE (delta
))
9917 /* Build a constructor for a pointer to member function. It can be
9918 used to initialize global variables, local variable, or used
9919 as a value in expressions. TYPE is the POINTER to METHOD_TYPE we
9922 If FORCE is nonzero, then force this conversion, even if
9923 we would rather not do it. Usually set when using an explicit
9924 cast. A C-style cast is being processed iff C_CAST_P is true.
9926 Return error_mark_node, if something goes wrong. */
9929 build_ptrmemfunc (tree type
, tree pfn
, int force
, bool c_cast_p
,
9930 tsubst_flags_t complain
)
9936 if (error_operand_p (pfn
))
9937 return error_mark_node
;
9939 pfn_type
= TREE_TYPE (pfn
);
9940 to_type
= build_ptrmemfunc_type (type
);
9942 /* Handle multiple conversions of pointer to member functions. */
9943 if (TYPE_PTRMEMFUNC_P (pfn_type
))
9945 tree delta
= NULL_TREE
;
9946 tree npfn
= NULL_TREE
;
9950 && !can_convert_arg (to_type
, TREE_TYPE (pfn
), pfn
,
9951 LOOKUP_NORMAL
, complain
))
9953 if (complain
& tf_error
)
9954 error ("invalid conversion to type %qT from type %qT",
9957 return error_mark_node
;
9960 n
= get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type
),
9961 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type
),
9963 c_cast_p
, complain
);
9964 if (n
== error_mark_node
)
9965 return error_mark_node
;
9967 STRIP_ANY_LOCATION_WRAPPER (pfn
);
9969 /* We don't have to do any conversion to convert a
9970 pointer-to-member to its own type. But, we don't want to
9971 just return a PTRMEM_CST if there's an explicit cast; that
9972 cast should make the expression an invalid template argument. */
9973 if (TREE_CODE (pfn
) != PTRMEM_CST
9974 && same_type_p (to_type
, pfn_type
))
9977 if (TREE_SIDE_EFFECTS (pfn
))
9978 pfn
= save_expr (pfn
);
9980 /* Obtain the function pointer and the current DELTA. */
9981 if (TREE_CODE (pfn
) == PTRMEM_CST
)
9982 expand_ptrmemfunc_cst (pfn
, &delta
, &npfn
);
9985 npfn
= build_ptrmemfunc_access_expr (pfn
, pfn_identifier
);
9986 delta
= build_ptrmemfunc_access_expr (pfn
, delta_identifier
);
9989 /* Just adjust the DELTA field. */
9990 gcc_assert (same_type_ignoring_top_level_qualifiers_p
9991 (TREE_TYPE (delta
), ptrdiff_type_node
));
9992 if (!integer_zerop (n
))
9994 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_delta
)
9995 n
= cp_build_binary_op (input_location
,
9996 LSHIFT_EXPR
, n
, integer_one_node
,
9998 delta
= cp_build_binary_op (input_location
,
9999 PLUS_EXPR
, delta
, n
, complain
);
10001 return build_ptrmemfunc1 (to_type
, delta
, npfn
);
10004 /* Handle null pointer to member function conversions. */
10005 if (null_ptr_cst_p (pfn
))
10007 pfn
= cp_build_c_cast (input_location
,
10008 TYPE_PTRMEMFUNC_FN_TYPE_RAW (to_type
),
10010 return build_ptrmemfunc1 (to_type
,
10015 if (type_unknown_p (pfn
))
10016 return instantiate_type (type
, pfn
, complain
);
10018 fn
= TREE_OPERAND (pfn
, 0);
10019 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
10020 /* In a template, we will have preserved the
10022 || (processing_template_decl
&& TREE_CODE (fn
) == OFFSET_REF
));
10023 return make_ptrmem_cst (to_type
, fn
);
10026 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
10029 ??? There is no consistency as to the types returned for the above
10030 values. Some code acts as if it were a sizetype and some as if it were
10031 integer_type_node. */
10034 expand_ptrmemfunc_cst (tree cst
, tree
*delta
, tree
*pfn
)
10036 tree type
= TREE_TYPE (cst
);
10037 tree fn
= PTRMEM_CST_MEMBER (cst
);
10038 tree ptr_class
, fn_class
;
10040 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
10042 /* The class that the function belongs to. */
10043 fn_class
= DECL_CONTEXT (fn
);
10045 /* The class that we're creating a pointer to member of. */
10046 ptr_class
= TYPE_PTRMEMFUNC_OBJECT_TYPE (type
);
10048 /* First, calculate the adjustment to the function's class. */
10049 *delta
= get_delta_difference (fn_class
, ptr_class
, /*force=*/0,
10050 /*c_cast_p=*/0, tf_warning_or_error
);
10052 if (!DECL_VIRTUAL_P (fn
))
10054 tree t
= build_addr_func (fn
, tf_warning_or_error
);
10055 if (TREE_CODE (t
) == ADDR_EXPR
)
10056 SET_EXPR_LOCATION (t
, PTRMEM_CST_LOCATION (cst
));
10057 *pfn
= convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), t
);
10061 /* If we're dealing with a virtual function, we have to adjust 'this'
10062 again, to point to the base which provides the vtable entry for
10063 fn; the call will do the opposite adjustment. */
10064 tree orig_class
= DECL_CONTEXT (fn
);
10065 tree binfo
= binfo_or_else (orig_class
, fn_class
);
10066 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
10067 *delta
, BINFO_OFFSET (binfo
));
10069 /* We set PFN to the vtable offset at which the function can be
10070 found, plus one (unless ptrmemfunc_vbit_in_delta, in which
10071 case delta is shifted left, and then incremented). */
10072 *pfn
= DECL_VINDEX (fn
);
10073 *pfn
= fold_build2 (MULT_EXPR
, integer_type_node
, *pfn
,
10074 TYPE_SIZE_UNIT (vtable_entry_type
));
10076 switch (TARGET_PTRMEMFUNC_VBIT_LOCATION
)
10078 case ptrmemfunc_vbit_in_pfn
:
10079 *pfn
= fold_build2 (PLUS_EXPR
, integer_type_node
, *pfn
,
10083 case ptrmemfunc_vbit_in_delta
:
10084 *delta
= fold_build2 (LSHIFT_EXPR
, TREE_TYPE (*delta
),
10085 *delta
, integer_one_node
);
10086 *delta
= fold_build2 (PLUS_EXPR
, TREE_TYPE (*delta
),
10087 *delta
, integer_one_node
);
10091 gcc_unreachable ();
10094 *pfn
= fold_convert (TYPE_PTRMEMFUNC_FN_TYPE (type
), *pfn
);
10098 /* Return an expression for PFN from the pointer-to-member function
10102 pfn_from_ptrmemfunc (tree t
)
10104 if (TREE_CODE (t
) == PTRMEM_CST
)
10109 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
10114 return build_ptrmemfunc_access_expr (t
, pfn_identifier
);
10117 /* Return an expression for DELTA from the pointer-to-member function
10121 delta_from_ptrmemfunc (tree t
)
10123 if (TREE_CODE (t
) == PTRMEM_CST
)
10128 expand_ptrmemfunc_cst (t
, &delta
, &pfn
);
10133 return build_ptrmemfunc_access_expr (t
, delta_identifier
);
10136 /* Convert value RHS to type TYPE as preparation for an assignment to
10137 an lvalue of type TYPE. ERRTYPE indicates what kind of error the
10138 implicit conversion is. If FNDECL is non-NULL, we are doing the
10139 conversion in order to pass the PARMNUMth argument of FNDECL.
10140 If FNDECL is NULL, we are doing the conversion in function pointer
10141 argument passing, conversion in initialization, etc. */
10144 convert_for_assignment (tree type
, tree rhs
,
10145 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
10146 tsubst_flags_t complain
, int flags
)
10149 enum tree_code coder
;
10151 location_t rhs_loc
= cp_expr_loc_or_input_loc (rhs
);
10152 bool has_loc
= EXPR_LOCATION (rhs
) != UNKNOWN_LOCATION
;
10153 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue,
10154 but preserve location wrappers. */
10155 if (TREE_CODE (rhs
) == NON_LVALUE_EXPR
10156 && !location_wrapper_p (rhs
))
10157 rhs
= TREE_OPERAND (rhs
, 0);
10159 /* Handle [dcl.init.list] direct-list-initialization from
10160 single element of enumeration with a fixed underlying type. */
10161 if (is_direct_enum_init (type
, rhs
))
10163 tree elt
= CONSTRUCTOR_ELT (rhs
, 0)->value
;
10164 if (check_narrowing (ENUM_UNDERLYING_TYPE (type
), elt
, complain
))
10166 warning_sentinel
w (warn_useless_cast
);
10167 warning_sentinel
w2 (warn_ignored_qualifiers
);
10168 rhs
= cp_build_c_cast (rhs_loc
, type
, elt
, complain
);
10171 rhs
= error_mark_node
;
10174 rhstype
= TREE_TYPE (rhs
);
10175 coder
= TREE_CODE (rhstype
);
10177 if (VECTOR_TYPE_P (type
) && coder
== VECTOR_TYPE
10178 && vector_types_convertible_p (type
, rhstype
, true))
10180 rhs
= mark_rvalue_use (rhs
);
10181 return convert (type
, rhs
);
10184 if (rhs
== error_mark_node
|| rhstype
== error_mark_node
)
10185 return error_mark_node
;
10186 if (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
)
10187 return error_mark_node
;
10189 /* The RHS of an assignment cannot have void type. */
10190 if (coder
== VOID_TYPE
)
10192 if (complain
& tf_error
)
10193 error_at (rhs_loc
, "void value not ignored as it ought to be");
10194 return error_mark_node
;
10197 if (c_dialect_objc ())
10201 tree rname
= fndecl
;
10212 selector
= objc_message_selector ();
10214 if (selector
&& parmno
> 1)
10221 if (objc_compare_types (type
, rhstype
, parmno
, rname
))
10223 rhs
= mark_rvalue_use (rhs
);
10224 return convert (type
, rhs
);
10230 The expression is implicitly converted (clause _conv_) to the
10231 cv-unqualified type of the left operand.
10233 We allow bad conversions here because by the time we get to this point
10234 we are committed to doing the conversion. If we end up doing a bad
10235 conversion, convert_like will complain. */
10236 if (!can_convert_arg_bad (type
, rhstype
, rhs
, flags
, complain
))
10238 /* When -Wno-pmf-conversions is use, we just silently allow
10239 conversions from pointers-to-members to plain pointers. If
10240 the conversion doesn't work, cp_convert will complain. */
10242 && TYPE_PTR_P (type
)
10243 && TYPE_PTRMEMFUNC_P (rhstype
))
10244 rhs
= cp_convert (strip_top_quals (type
), rhs
, complain
);
10247 if (complain
& tf_error
)
10249 /* If the right-hand side has unknown type, then it is an
10250 overloaded function. Call instantiate_type to get error
10252 if (rhstype
== unknown_type_node
)
10254 tree r
= instantiate_type (type
, rhs
, tf_warning_or_error
);
10255 /* -fpermissive might allow this; recurse. */
10256 if (!seen_error ())
10257 return convert_for_assignment (type
, r
, errtype
, fndecl
,
10258 parmnum
, complain
, flags
);
10261 complain_about_bad_argument (rhs_loc
,
10266 range_label_for_type_mismatch
label (rhstype
, type
);
10267 gcc_rich_location
richloc (rhs_loc
, has_loc
? &label
: NULL
);
10268 auto_diagnostic_group d
;
10272 case ICR_DEFAULT_ARGUMENT
:
10273 error_at (&richloc
,
10274 "cannot convert %qH to %qI in default argument",
10278 error_at (&richloc
,
10279 "cannot convert %qH to %qI in argument passing",
10282 case ICR_CONVERTING
:
10283 error_at (&richloc
, "cannot convert %qH to %qI",
10287 error_at (&richloc
,
10288 "cannot convert %qH to %qI in initialization",
10292 error_at (&richloc
, "cannot convert %qH to %qI in return",
10296 error_at (&richloc
,
10297 "cannot convert %qH to %qI in assignment",
10305 /* See if we can be more helpful. */
10306 maybe_show_nonconverting_candidate (type
, rhstype
, rhs
, flags
);
10308 if (TYPE_PTR_P (rhstype
)
10309 && TYPE_PTR_P (type
)
10310 && CLASS_TYPE_P (TREE_TYPE (rhstype
))
10311 && CLASS_TYPE_P (TREE_TYPE (type
))
10312 && !COMPLETE_TYPE_P (TREE_TYPE (rhstype
)))
10313 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL
10314 (TREE_TYPE (rhstype
))),
10315 "class type %qT is incomplete", TREE_TYPE (rhstype
));
10317 return error_mark_node
;
10320 if (warn_suggest_attribute_format
)
10322 const enum tree_code codel
= TREE_CODE (type
);
10323 if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
10325 && check_missing_format_attribute (type
, rhstype
)
10326 && (complain
& tf_warning
))
10330 case ICR_DEFAULT_ARGUMENT
:
10332 warning (OPT_Wsuggest_attribute_format
,
10333 "parameter %qP of %qD might be a candidate "
10334 "for a format attribute", parmnum
, fndecl
);
10336 warning (OPT_Wsuggest_attribute_format
,
10337 "parameter might be a candidate "
10338 "for a format attribute");
10340 case ICR_CONVERTING
:
10341 warning (OPT_Wsuggest_attribute_format
,
10342 "target of conversion might be a candidate "
10343 "for a format attribute");
10346 warning (OPT_Wsuggest_attribute_format
,
10347 "target of initialization might be a candidate "
10348 "for a format attribute");
10351 warning (OPT_Wsuggest_attribute_format
,
10352 "return type might be a candidate "
10353 "for a format attribute");
10356 warning (OPT_Wsuggest_attribute_format
,
10357 "left-hand side of assignment might be a candidate "
10358 "for a format attribute");
10365 /* If -Wparentheses, warn about a = b = c when a has type bool and b
10367 if (TREE_CODE (type
) == BOOLEAN_TYPE
10368 && TREE_CODE (TREE_TYPE (rhs
)) != BOOLEAN_TYPE
)
10369 maybe_warn_unparenthesized_assignment (rhs
, complain
);
10371 if (complain
& tf_warning
)
10372 warn_for_address_or_pointer_of_packed_member (type
, rhs
);
10374 return perform_implicit_conversion_flags (strip_top_quals (type
), rhs
,
10378 /* Convert RHS to be of type TYPE.
10379 If EXP is nonzero, it is the target of the initialization.
10380 ERRTYPE indicates what kind of error the implicit conversion is.
10382 Two major differences between the behavior of
10383 `convert_for_assignment' and `convert_for_initialization'
10384 are that references are bashed in the former, while
10385 copied in the latter, and aggregates are assigned in
10386 the former (operator=) while initialized in the
10389 If using constructor make sure no conversion operator exists, if one does
10390 exist, an ambiguity exists. */
10393 convert_for_initialization (tree exp
, tree type
, tree rhs
, int flags
,
10394 impl_conv_rhs errtype
, tree fndecl
, int parmnum
,
10395 tsubst_flags_t complain
)
10397 enum tree_code codel
= TREE_CODE (type
);
10399 enum tree_code coder
;
10401 /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
10402 Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */
10403 if (TREE_CODE (rhs
) == NOP_EXPR
10404 && TREE_TYPE (rhs
) == TREE_TYPE (TREE_OPERAND (rhs
, 0))
10405 && codel
!= REFERENCE_TYPE
)
10406 rhs
= TREE_OPERAND (rhs
, 0);
10408 if (type
== error_mark_node
10409 || rhs
== error_mark_node
10410 || (TREE_CODE (rhs
) == TREE_LIST
&& TREE_VALUE (rhs
) == error_mark_node
))
10411 return error_mark_node
;
10413 if (MAYBE_CLASS_TYPE_P (non_reference (type
)))
10415 else if ((TREE_CODE (TREE_TYPE (rhs
)) == ARRAY_TYPE
10416 && TREE_CODE (type
) != ARRAY_TYPE
10417 && (!TYPE_REF_P (type
)
10418 || TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
))
10419 || (TREE_CODE (TREE_TYPE (rhs
)) == FUNCTION_TYPE
10420 && !TYPE_REFFN_P (type
))
10421 || TREE_CODE (TREE_TYPE (rhs
)) == METHOD_TYPE
)
10422 rhs
= decay_conversion (rhs
, complain
);
10424 rhstype
= TREE_TYPE (rhs
);
10425 coder
= TREE_CODE (rhstype
);
10427 if (coder
== ERROR_MARK
)
10428 return error_mark_node
;
10430 /* We accept references to incomplete types, so we can
10431 return here before checking if RHS is of complete type. */
10433 if (codel
== REFERENCE_TYPE
)
10435 auto_diagnostic_group d
;
10436 /* This should eventually happen in convert_arguments. */
10437 int savew
= 0, savee
= 0;
10440 savew
= warningcount
+ werrorcount
, savee
= errorcount
;
10441 rhs
= initialize_reference (type
, rhs
, flags
, complain
);
10444 && (warningcount
+ werrorcount
> savew
|| errorcount
> savee
))
10445 inform (get_fndecl_argument_location (fndecl
, parmnum
),
10446 "in passing argument %P of %qD", parmnum
, fndecl
);
10451 exp
= require_complete_type (exp
, complain
);
10452 if (exp
== error_mark_node
)
10453 return error_mark_node
;
10455 type
= complete_type (type
);
10457 if (DIRECT_INIT_EXPR_P (type
, rhs
))
10458 /* Don't try to do copy-initialization if we already have
10459 direct-initialization. */
10462 if (MAYBE_CLASS_TYPE_P (type
))
10463 return perform_implicit_conversion_flags (type
, rhs
, complain
, flags
);
10465 return convert_for_assignment (type
, rhs
, errtype
, fndecl
, parmnum
,
10469 /* If RETVAL is the address of, or a reference to, a local variable or
10470 temporary give an appropriate warning and return true. */
10473 maybe_warn_about_returning_address_of_local (tree retval
, location_t loc
)
10475 tree valtype
= TREE_TYPE (DECL_RESULT (current_function_decl
));
10476 tree whats_returned
= fold_for_warn (retval
);
10478 loc
= cp_expr_loc_or_input_loc (retval
);
10482 if (TREE_CODE (whats_returned
) == COMPOUND_EXPR
)
10483 whats_returned
= TREE_OPERAND (whats_returned
, 1);
10484 else if (CONVERT_EXPR_P (whats_returned
)
10485 || TREE_CODE (whats_returned
) == NON_LVALUE_EXPR
)
10486 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10491 if (TREE_CODE (whats_returned
) == TARGET_EXPR
10492 && is_std_init_list (TREE_TYPE (whats_returned
)))
10494 tree init
= TARGET_EXPR_INITIAL (whats_returned
);
10495 if (TREE_CODE (init
) == CONSTRUCTOR
)
10496 /* Pull out the array address. */
10497 whats_returned
= CONSTRUCTOR_ELT (init
, 0)->value
;
10498 else if (TREE_CODE (init
) == INDIRECT_REF
)
10499 /* The source of a trivial copy looks like *(T*)&var. */
10500 whats_returned
= TREE_OPERAND (init
, 0);
10503 STRIP_NOPS (whats_returned
);
10506 /* As a special case, we handle a call to std::move or std::forward. */
10507 if (TREE_CODE (whats_returned
) == CALL_EXPR
10508 && (is_std_move_p (whats_returned
)
10509 || is_std_forward_p (whats_returned
)))
10511 tree arg
= CALL_EXPR_ARG (whats_returned
, 0);
10512 return maybe_warn_about_returning_address_of_local (arg
, loc
);
10515 if (TREE_CODE (whats_returned
) != ADDR_EXPR
)
10517 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10519 while (TREE_CODE (whats_returned
) == COMPONENT_REF
10520 || TREE_CODE (whats_returned
) == ARRAY_REF
)
10521 whats_returned
= TREE_OPERAND (whats_returned
, 0);
10523 if (TREE_CODE (whats_returned
) == AGGR_INIT_EXPR
10524 || TREE_CODE (whats_returned
) == TARGET_EXPR
)
10526 if (TYPE_REF_P (valtype
))
10527 warning_at (loc
, OPT_Wreturn_local_addr
,
10528 "returning reference to temporary");
10529 else if (TYPE_PTR_P (valtype
))
10530 warning_at (loc
, OPT_Wreturn_local_addr
,
10531 "returning pointer to temporary");
10532 else if (is_std_init_list (valtype
))
10533 warning_at (loc
, OPT_Winit_list_lifetime
,
10534 "returning temporary %<initializer_list%> does not extend "
10535 "the lifetime of the underlying array");
10539 STRIP_ANY_LOCATION_WRAPPER (whats_returned
);
10541 if (DECL_P (whats_returned
)
10542 && DECL_NAME (whats_returned
)
10543 && DECL_FUNCTION_SCOPE_P (whats_returned
)
10544 && !is_capture_proxy (whats_returned
)
10545 && !(TREE_STATIC (whats_returned
)
10546 || TREE_PUBLIC (whats_returned
)))
10548 if (VAR_P (whats_returned
)
10549 && DECL_DECOMPOSITION_P (whats_returned
)
10550 && DECL_DECOMP_BASE (whats_returned
)
10551 && DECL_HAS_VALUE_EXPR_P (whats_returned
))
10553 /* When returning address of a structured binding, if the structured
10554 binding is not a reference, continue normally, if it is a
10555 reference, recurse on the initializer of the structured
10557 tree base
= DECL_DECOMP_BASE (whats_returned
);
10558 if (TYPE_REF_P (TREE_TYPE (base
)))
10560 if (tree init
= DECL_INITIAL (base
))
10561 return maybe_warn_about_returning_address_of_local (init
, loc
);
10567 auto_diagnostic_group d
;
10568 if (TYPE_REF_P (valtype
))
10569 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10570 "reference to local variable %qD returned",
10572 else if (is_std_init_list (valtype
))
10573 w
= warning_at (loc
, OPT_Winit_list_lifetime
,
10574 "returning local %<initializer_list%> variable %qD "
10575 "does not extend the lifetime of the underlying array",
10577 else if (POINTER_TYPE_P (valtype
)
10578 && TREE_CODE (whats_returned
) == LABEL_DECL
)
10579 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10580 "address of label %qD returned",
10582 else if (POINTER_TYPE_P (valtype
))
10583 w
= warning_at (loc
, OPT_Wreturn_local_addr
,
10584 "address of local variable %qD returned",
10587 inform (DECL_SOURCE_LOCATION (whats_returned
),
10595 /* Returns true if DECL is in the std namespace. */
10598 decl_in_std_namespace_p (tree decl
)
10602 decl
= decl_namespace_context (decl
);
10603 if (DECL_NAMESPACE_STD_P (decl
))
10605 /* Allow inline namespaces inside of std namespace, e.g. with
10606 --enable-symvers=gnu-versioned-namespace std::forward would be
10607 actually std::_8::forward. */
10608 if (!DECL_NAMESPACE_INLINE_P (decl
))
10610 decl
= CP_DECL_CONTEXT (decl
);
10615 /* Returns true if FN, a CALL_EXPR, is a call to std::forward. */
10618 is_std_forward_p (tree fn
)
10620 /* std::forward only takes one argument. */
10621 if (call_expr_nargs (fn
) != 1)
10624 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10625 if (!decl_in_std_namespace_p (fndecl
))
10628 tree name
= DECL_NAME (fndecl
);
10629 return name
&& id_equal (name
, "forward");
10632 /* Returns true if FN, a CALL_EXPR, is a call to std::move. */
10635 is_std_move_p (tree fn
)
10637 /* std::move only takes one argument. */
10638 if (call_expr_nargs (fn
) != 1)
10641 tree fndecl
= cp_get_callee_fndecl_nofold (fn
);
10642 if (!decl_in_std_namespace_p (fndecl
))
10645 tree name
= DECL_NAME (fndecl
);
10646 return name
&& id_equal (name
, "move");
10649 /* Returns true if RETVAL is a good candidate for the NRVO as per
10650 [class.copy.elision]. FUNCTYPE is the type the function is declared
10654 can_do_nrvo_p (tree retval
, tree functype
)
10656 if (functype
== error_mark_node
)
10659 STRIP_ANY_LOCATION_WRAPPER (retval
);
10660 tree result
= DECL_RESULT (current_function_decl
);
10661 return (retval
!= NULL_TREE
10662 && !processing_template_decl
10663 /* Must be a local, automatic variable. */
10665 && DECL_CONTEXT (retval
) == current_function_decl
10666 && !TREE_STATIC (retval
)
10667 /* And not a lambda or anonymous union proxy. */
10668 && !DECL_HAS_VALUE_EXPR_P (retval
)
10669 && (DECL_ALIGN (retval
) <= DECL_ALIGN (result
))
10670 /* The cv-unqualified type of the returned value must be the
10671 same as the cv-unqualified return type of the
10673 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (retval
)),
10674 TYPE_MAIN_VARIANT (functype
))
10675 /* And the returned value must be non-volatile. */
10676 && !TYPE_VOLATILE (TREE_TYPE (retval
)));
10679 /* True if we would like to perform NRVO, i.e. can_do_nrvo_p is true and we
10680 would otherwise return in memory. */
10683 want_nrvo_p (tree retval
, tree functype
)
10685 return (can_do_nrvo_p (retval
, functype
)
10686 && aggregate_value_p (functype
, current_function_decl
));
10689 /* Like can_do_nrvo_p, but we check if we're trying to move a class
10693 can_elide_copy_prvalue_p (tree retval
, tree functype
)
10695 if (functype
== error_mark_node
)
10698 STRIP_ANY_LOCATION_WRAPPER (retval
);
10699 return (retval
!= NULL_TREE
10700 && !glvalue_p (retval
)
10701 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (retval
)),
10702 TYPE_MAIN_VARIANT (functype
))
10703 && !TYPE_VOLATILE (TREE_TYPE (retval
)));
10706 /* If we should treat RETVAL, an expression being returned, as if it were
10707 designated by an rvalue, returns it adjusted accordingly; otherwise, returns
10708 NULL_TREE. See [class.copy.elision]. RETURN_P is true if this is a return
10709 context (rather than throw). */
10712 treat_lvalue_as_rvalue_p (tree expr
, bool return_p
)
10714 if (cxx_dialect
== cxx98
)
10717 tree retval
= expr
;
10718 STRIP_ANY_LOCATION_WRAPPER (retval
);
10719 if (REFERENCE_REF_P (retval
))
10720 retval
= TREE_OPERAND (retval
, 0);
10722 /* An implicitly movable entity is a variable of automatic storage duration
10723 that is either a non-volatile object or (C++20) an rvalue reference to a
10724 non-volatile object type. */
10725 if (!(((VAR_P (retval
) && !DECL_HAS_VALUE_EXPR_P (retval
))
10726 || TREE_CODE (retval
) == PARM_DECL
)
10727 && !TREE_STATIC (retval
)
10728 && !CP_TYPE_VOLATILE_P (non_reference (TREE_TYPE (retval
)))
10729 && (TREE_CODE (TREE_TYPE (retval
)) != REFERENCE_TYPE
10730 || (cxx_dialect
>= cxx20
10731 && TYPE_REF_IS_RVALUE (TREE_TYPE (retval
))))))
10734 /* If the expression in a return or co_return statement is a (possibly
10735 parenthesized) id-expression that names an implicitly movable entity
10736 declared in the body or parameter-declaration-clause of the innermost
10737 enclosing function or lambda-expression, */
10738 if (DECL_CONTEXT (retval
) != current_function_decl
)
10742 expr
= move (expr
);
10743 if (expr
== error_mark_node
)
10745 return set_implicit_rvalue_p (expr
);
10748 /* if the operand of a throw-expression is a (possibly parenthesized)
10749 id-expression that names an implicitly movable entity whose scope does not
10750 extend beyond the compound-statement of the innermost try-block or
10751 function-try-block (if any) whose compound-statement or ctor-initializer
10752 encloses the throw-expression, */
10754 /* C++20 added move on throw of parms. */
10755 if (TREE_CODE (retval
) == PARM_DECL
&& cxx_dialect
< cxx20
)
10758 for (cp_binding_level
*b
= current_binding_level
;
10759 ; b
= b
->level_chain
)
10761 for (tree decl
= b
->names
; decl
; decl
= TREE_CHAIN (decl
))
10762 if (decl
== retval
)
10763 return set_implicit_rvalue_p (move (expr
));
10764 if (b
->kind
== sk_function_parms
|| b
->kind
== sk_try
)
10769 /* Warn about dubious usage of std::move (in a return statement, if RETURN_P
10770 is true). EXPR is the std::move expression; TYPE is the type of the object
10771 being initialized. */
10774 maybe_warn_pessimizing_move (tree expr
, tree type
, bool return_p
)
10776 if (!(warn_pessimizing_move
|| warn_redundant_move
))
10779 const location_t loc
= cp_expr_loc_or_input_loc (expr
);
10781 /* C++98 doesn't know move. */
10782 if (cxx_dialect
< cxx11
)
10785 /* Wait until instantiation time, since we can't gauge if we should do
10786 the NRVO until then. */
10787 if (processing_template_decl
)
10790 /* This is only interesting for class types. */
10791 if (!CLASS_TYPE_P (type
))
10794 bool wrapped_p
= false;
10795 /* A a = std::move (A()); */
10796 if (TREE_CODE (expr
) == TREE_LIST
)
10798 if (list_length (expr
) == 1)
10800 expr
= TREE_VALUE (expr
);
10806 /* A a = {std::move (A())};
10807 A a{std::move (A())}; */
10808 else if (TREE_CODE (expr
) == CONSTRUCTOR
)
10810 if (CONSTRUCTOR_NELTS (expr
) == 1)
10812 expr
= CONSTRUCTOR_ELT (expr
, 0)->value
;
10819 /* First, check if this is a call to std::move. */
10820 if (!REFERENCE_REF_P (expr
)
10821 || TREE_CODE (TREE_OPERAND (expr
, 0)) != CALL_EXPR
)
10823 tree fn
= TREE_OPERAND (expr
, 0);
10824 if (!is_std_move_p (fn
))
10826 tree arg
= CALL_EXPR_ARG (fn
, 0);
10827 if (TREE_CODE (arg
) != NOP_EXPR
)
10829 /* If we're looking at *std::move<T&> ((T &) &arg), do the pessimizing N/RVO
10830 and implicitly-movable warnings. */
10831 if (TREE_CODE (TREE_OPERAND (arg
, 0)) == ADDR_EXPR
)
10833 arg
= TREE_OPERAND (arg
, 0);
10834 arg
= TREE_OPERAND (arg
, 0);
10835 arg
= convert_from_reference (arg
);
10836 if (can_elide_copy_prvalue_p (arg
, type
))
10838 auto_diagnostic_group d
;
10839 if (warning_at (loc
, OPT_Wpessimizing_move
,
10840 "moving a temporary object prevents copy elision"))
10841 inform (loc
, "remove %<std::move%> call");
10843 /* The rest of the warnings is only relevant for when we are returning
10844 from a function. */
10849 /* Warn if we could do copy elision were it not for the move. */
10850 if (can_do_nrvo_p (arg
, type
))
10852 auto_diagnostic_group d
;
10853 if (!warning_suppressed_p (expr
, OPT_Wpessimizing_move
)
10854 && warning_at (loc
, OPT_Wpessimizing_move
,
10855 "moving a local object in a return statement "
10856 "prevents copy elision"))
10857 inform (loc
, "remove %<std::move%> call");
10859 /* Warn if the move is redundant. It is redundant when we would
10860 do maybe-rvalue overload resolution even without std::move. */
10861 else if (warn_redundant_move
10862 /* This doesn't apply for return {std::move (t)};. */
10864 && !warning_suppressed_p (expr
, OPT_Wredundant_move
)
10865 && (moved
= treat_lvalue_as_rvalue_p (arg
, /*return*/true)))
10867 /* Make sure that overload resolution would actually succeed
10868 if we removed the std::move call. */
10869 tree t
= convert_for_initialization (NULL_TREE
, type
,
10872 | LOOKUP_ONLYCONVERTING
),
10873 ICR_RETURN
, NULL_TREE
, 0,
10875 /* If this worked, implicit rvalue would work, so the call to
10876 std::move is redundant. */
10877 if (t
!= error_mark_node
)
10879 auto_diagnostic_group d
;
10880 if (warning_at (loc
, OPT_Wredundant_move
,
10881 "redundant move in return statement"))
10882 inform (loc
, "remove %<std::move%> call");
10886 /* Also try to warn about redundant std::move in code such as
10889 return std::move(t);
10891 for which EXPR will be something like
10892 *std::move<const T&> ((const struct T &) (const struct T *) t)
10893 and where the std::move does nothing if T does not have a T(const T&&)
10894 constructor, because the argument is const. It will not use T(T&&)
10895 because that would mean losing the const. */
10896 else if (warn_redundant_move
10897 && !warning_suppressed_p (expr
, OPT_Wredundant_move
)
10898 && TYPE_REF_P (TREE_TYPE (arg
))
10899 && CP_TYPE_CONST_P (TREE_TYPE (TREE_TYPE (arg
))))
10901 tree rtype
= TREE_TYPE (TREE_TYPE (arg
));
10902 if (!same_type_ignoring_top_level_qualifiers_p (rtype
, type
))
10904 /* Check for the unlikely case there's T(const T&&) (we don't care if
10906 for (tree fn
: ovl_range (CLASSTYPE_CONSTRUCTORS (rtype
)))
10907 if (move_fn_p (fn
))
10909 tree t
= TREE_VALUE (FUNCTION_FIRST_USER_PARMTYPE (fn
));
10910 if (UNLIKELY (CP_TYPE_CONST_P (TREE_TYPE (t
))))
10913 auto_diagnostic_group d
;
10915 ? warning_at (loc
, OPT_Wredundant_move
,
10916 "redundant move in return statement")
10917 : warning_at (loc
, OPT_Wredundant_move
,
10918 "redundant move in initialization"))
10919 inform (loc
, "remove %<std::move%> call");
10923 /* Check that returning RETVAL from the current function is valid.
10924 Return an expression explicitly showing all conversions required to
10925 change RETVAL into the function return type, and to assign it to
10926 the DECL_RESULT for the function. Set *NO_WARNING to true if
10927 code reaches end of non-void function warning shouldn't be issued
10928 on this RETURN_EXPR. Set *DANGLING to true if code returns the
10929 address of a local variable. */
10932 check_return_expr (tree retval
, bool *no_warning
, bool *dangling
)
10935 /* The type actually returned by the function. */
10937 /* The type the function is declared to return, or void if
10938 the declared type is incomplete. */
10940 int fn_returns_value_p
;
10941 location_t loc
= cp_expr_loc_or_input_loc (retval
);
10943 *no_warning
= false;
10946 /* A `volatile' function is one that isn't supposed to return, ever.
10947 (This is a G++ extension, used to get better code for functions
10948 that call the `volatile' function.) */
10949 if (TREE_THIS_VOLATILE (current_function_decl
))
10950 warning (0, "function declared %<noreturn%> has a %<return%> statement");
10952 /* Check for various simple errors. */
10953 if (DECL_DESTRUCTOR_P (current_function_decl
))
10956 error_at (loc
, "returning a value from a destructor");
10958 if (targetm
.cxx
.cdtor_returns_this () && !processing_template_decl
)
10959 retval
= current_class_ptr
;
10963 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10965 if (in_function_try_handler
)
10966 /* If a return statement appears in a handler of the
10967 function-try-block of a constructor, the program is ill-formed. */
10968 error ("cannot return from a handler of a function-try-block of a constructor");
10970 /* You can't return a value from a constructor. */
10971 error_at (loc
, "returning a value from a constructor");
10973 if (targetm
.cxx
.cdtor_returns_this () && !processing_template_decl
)
10974 retval
= current_class_ptr
;
10979 const tree saved_retval
= retval
;
10981 if (processing_template_decl
)
10983 current_function_returns_value
= 1;
10985 if (check_for_bare_parameter_packs (retval
))
10986 return error_mark_node
;
10988 /* If one of the types might be void, we can't tell whether we're
10989 returning a value. */
10990 if ((WILDCARD_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl
)))
10991 && !FNDECL_USED_AUTO (current_function_decl
))
10992 || (retval
!= NULL_TREE
10993 && (TREE_TYPE (retval
) == NULL_TREE
10994 || WILDCARD_TYPE_P (TREE_TYPE (retval
)))))
10998 functype
= TREE_TYPE (TREE_TYPE (current_function_decl
));
11000 /* Deduce auto return type from a return statement. */
11001 if (FNDECL_USED_AUTO (current_function_decl
))
11003 tree pattern
= DECL_SAVED_AUTO_RETURN_TYPE (current_function_decl
);
11007 if (!retval
&& !is_auto (pattern
))
11009 /* Give a helpful error message. */
11010 error ("return-statement with no value, in function returning %qT",
11012 inform (input_location
, "only plain %<auto%> return type can be "
11013 "deduced to %<void%>");
11014 type
= error_mark_node
;
11016 else if (retval
&& BRACE_ENCLOSED_INITIALIZER_P (retval
))
11018 error ("returning initializer list");
11019 type
= error_mark_node
;
11024 retval
= void_node
;
11025 auto_node
= type_uses_auto (pattern
);
11026 type
= do_auto_deduction (pattern
, retval
, auto_node
,
11027 tf_warning_or_error
, adc_return_type
);
11030 if (type
== error_mark_node
)
11032 else if (functype
== pattern
)
11033 apply_deduced_return_type (current_function_decl
, type
);
11034 else if (!same_type_p (type
, functype
))
11036 if (LAMBDA_FUNCTION_P (current_function_decl
))
11037 error_at (loc
, "inconsistent types %qT and %qT deduced for "
11038 "lambda return type", functype
, type
);
11040 error_at (loc
, "inconsistent deduction for auto return type: "
11041 "%qT and then %qT", functype
, type
);
11046 result
= DECL_RESULT (current_function_decl
);
11047 valtype
= TREE_TYPE (result
);
11048 gcc_assert (valtype
!= NULL_TREE
);
11049 fn_returns_value_p
= !VOID_TYPE_P (valtype
);
11051 /* Check for a return statement with no return value in a function
11052 that's supposed to return a value. */
11053 if (!retval
&& fn_returns_value_p
)
11055 if (functype
!= error_mark_node
)
11056 permerror (input_location
, "return-statement with no value, in "
11057 "function returning %qT", valtype
);
11058 /* Remember that this function did return. */
11059 current_function_returns_value
= 1;
11060 /* And signal caller that TREE_NO_WARNING should be set on the
11061 RETURN_EXPR to avoid control reaches end of non-void function
11062 warnings in tree-cfg.cc. */
11063 *no_warning
= true;
11065 /* Check for a return statement with a value in a function that
11066 isn't supposed to return a value. */
11067 else if (retval
&& !fn_returns_value_p
)
11069 if (VOID_TYPE_P (TREE_TYPE (retval
)))
11070 /* You can return a `void' value from a function of `void'
11071 type. In that case, we have to evaluate the expression for
11072 its side-effects. */
11073 finish_expr_stmt (retval
);
11074 else if (retval
!= error_mark_node
)
11075 permerror (loc
, "return-statement with a value, in function "
11076 "returning %qT", valtype
);
11077 current_function_returns_null
= 1;
11079 /* There's really no value to return, after all. */
11083 /* Remember that this function can sometimes return without a
11085 current_function_returns_null
= 1;
11087 /* Remember that this function did return a value. */
11088 current_function_returns_value
= 1;
11090 /* Check for erroneous operands -- but after giving ourselves a
11091 chance to provide an error about returning a value from a void
11093 if (error_operand_p (retval
))
11095 current_function_return_value
= error_mark_node
;
11096 return error_mark_node
;
11099 /* Only operator new(...) throw(), can return NULL [expr.new/13]. */
11100 if (IDENTIFIER_NEW_OP_P (DECL_NAME (current_function_decl
))
11101 && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl
))
11102 && ! flag_check_new
11103 && retval
&& null_ptr_cst_p (retval
))
11104 warning (0, "%<operator new%> must not return NULL unless it is "
11105 "declared %<throw()%> (or %<-fcheck-new%> is in effect)");
11107 /* Effective C++ rule 15. See also start_function. */
11109 && DECL_NAME (current_function_decl
) == assign_op_identifier
11110 && !type_dependent_expression_p (retval
))
11114 /* The function return type must be a reference to the current
11116 if (TYPE_REF_P (valtype
)
11117 && same_type_ignoring_top_level_qualifiers_p
11118 (TREE_TYPE (valtype
), TREE_TYPE (current_class_ref
)))
11120 /* Returning '*this' is obviously OK. */
11121 if (retval
== current_class_ref
)
11123 /* If we are calling a function whose return type is the same of
11124 the current class reference, it is ok. */
11125 else if (INDIRECT_REF_P (retval
)
11126 && TREE_CODE (TREE_OPERAND (retval
, 0)) == CALL_EXPR
)
11131 warning_at (loc
, OPT_Weffc__
,
11132 "%<operator=%> should return a reference to %<*this%>");
11135 if (dependent_type_p (functype
)
11136 || type_dependent_expression_p (retval
))
11139 /* We should not have changed the return value. */
11140 gcc_assert (retval
== saved_retval
);
11141 /* We don't know if this is an lvalue or rvalue use, but
11142 either way we can mark it as read. */
11143 mark_exp_read (retval
);
11147 /* The fabled Named Return Value optimization, as per [class.copy]/15:
11149 [...] For a function with a class return type, if the expression
11150 in the return statement is the name of a local object, and the cv-
11151 unqualified type of the local object is the same as the function
11152 return type, an implementation is permitted to omit creating the tem-
11153 porary object to hold the function return value [...]
11155 So, if this is a value-returning function that always returns the same
11156 local variable, remember it.
11158 We choose the first suitable variable even if the function sometimes
11159 returns something else, but only if the variable is out of scope at the
11160 other return sites, or else we run the risk of clobbering the variable we
11161 chose if the other returned expression uses the chosen variable somehow.
11163 We don't currently do this if the first return is a non-variable, as it
11164 would be complicated to determine whether an NRV selected later was in
11165 scope at the point of the earlier return. We also don't currently support
11166 multiple variables with non-overlapping scopes (53637).
11168 See finish_function and finalize_nrv for the rest of this optimization. */
11169 tree bare_retval
= NULL_TREE
;
11172 retval
= maybe_undo_parenthesized_ref (retval
);
11173 bare_retval
= tree_strip_any_location_wrapper (retval
);
11176 bool named_return_value_okay_p
= want_nrvo_p (bare_retval
, functype
);
11177 if (fn_returns_value_p
&& flag_elide_constructors
11178 && current_function_return_value
!= bare_retval
)
11180 if (named_return_value_okay_p
11181 && current_function_return_value
== NULL_TREE
)
11182 current_function_return_value
= bare_retval
;
11183 else if (current_function_return_value
11184 && VAR_P (current_function_return_value
)
11185 && DECL_NAME (current_function_return_value
)
11186 && !decl_in_scope_p (current_function_return_value
))
11188 /* The earlier NRV is out of scope at this point, so it's safe to
11189 leave it alone; the current return can't refer to it. */;
11190 if (named_return_value_okay_p
11191 && !warning_suppressed_p (current_function_decl
, OPT_Wnrvo
))
11193 warning (OPT_Wnrvo
, "not eliding copy on return from %qD",
11195 suppress_warning (current_function_decl
, OPT_Wnrvo
);
11200 if ((named_return_value_okay_p
11201 || (current_function_return_value
11202 && current_function_return_value
!= error_mark_node
))
11203 && !warning_suppressed_p (current_function_decl
, OPT_Wnrvo
))
11205 warning (OPT_Wnrvo
, "not eliding copy on return in %qD",
11206 current_function_decl
);
11207 suppress_warning (current_function_decl
, OPT_Wnrvo
);
11209 current_function_return_value
= error_mark_node
;
11213 /* We don't need to do any conversions when there's nothing being
11218 if (!named_return_value_okay_p
)
11219 maybe_warn_pessimizing_move (retval
, functype
, /*return_p*/true);
11221 /* Do any required conversions. */
11222 if (bare_retval
== result
|| DECL_CONSTRUCTOR_P (current_function_decl
))
11223 /* No conversions are required. */
11227 int flags
= LOOKUP_NORMAL
| LOOKUP_ONLYCONVERTING
;
11229 /* The functype's return type will have been set to void, if it
11230 was an incomplete type. Just treat this as 'return;' */
11231 if (VOID_TYPE_P (functype
))
11232 return error_mark_node
;
11234 /* Under C++11 [12.8/32 class.copy], a returned lvalue is sometimes
11235 treated as an rvalue for the purposes of overload resolution to
11236 favor move constructors over copy constructors.
11238 Note that these conditions are similar to, but not as strict as,
11239 the conditions for the named return value optimization. */
11240 bool converted
= false;
11242 /* Until C++23, this was only interesting for class type, but in C++23,
11243 we should do the below when we're converting rom/to a class/reference
11244 (a non-scalar type). */
11245 if ((cxx_dialect
< cxx23
11246 ? CLASS_TYPE_P (functype
)
11247 : !SCALAR_TYPE_P (functype
) || !SCALAR_TYPE_P (TREE_TYPE (retval
)))
11248 && (moved
= treat_lvalue_as_rvalue_p (retval
, /*return*/true)))
11249 /* In C++20 and earlier we treat the return value as an rvalue
11250 that can bind to lvalue refs. In C++23, such an expression is just
11251 an xvalue (see reference_binding). */
11254 /* The call in a (lambda) thunk needs no conversions. */
11255 if (TREE_CODE (retval
) == CALL_EXPR
11256 && call_from_lambda_thunk_p (retval
))
11259 /* First convert the value to the function's return type, then
11260 to the type of return value's location to handle the
11261 case that functype is smaller than the valtype. */
11263 retval
= convert_for_initialization
11264 (NULL_TREE
, functype
, retval
, flags
, ICR_RETURN
, NULL_TREE
, 0,
11265 tf_warning_or_error
);
11266 retval
= convert (valtype
, retval
);
11268 /* If the conversion failed, treat this just like `return;'. */
11269 if (retval
== error_mark_node
)
11271 /* We can't initialize a register from a AGGR_INIT_EXPR. */
11272 else if (! cfun
->returns_struct
11273 && TREE_CODE (retval
) == TARGET_EXPR
11274 && TREE_CODE (TREE_OPERAND (retval
, 1)) == AGGR_INIT_EXPR
)
11275 retval
= build2 (COMPOUND_EXPR
, TREE_TYPE (retval
), retval
,
11276 TREE_OPERAND (retval
, 0));
11277 else if (!processing_template_decl
11278 && maybe_warn_about_returning_address_of_local (retval
, loc
)
11279 && INDIRECT_TYPE_P (valtype
))
11283 /* A naive attempt to reduce the number of -Wdangling-reference false
11284 positives: if we know that this function can return a variable with
11285 static storage duration rather than one of its parameters, suppress
11287 if (warn_dangling_reference
11288 && TYPE_REF_P (functype
)
11290 && VAR_P (bare_retval
)
11291 && TREE_STATIC (bare_retval
))
11292 suppress_warning (current_function_decl
, OPT_Wdangling_reference
);
11294 if (processing_template_decl
)
11295 return saved_retval
;
11297 /* Actually copy the value returned into the appropriate location. */
11298 if (retval
&& retval
!= result
)
11300 /* If there's a postcondition for a scalar return value, wrap
11301 retval in a call to the postcondition function. */
11302 if (tree post
= apply_postcondition_to_return (retval
))
11304 retval
= cp_build_init_expr (result
, retval
);
11307 if (current_function_return_value
== bare_retval
)
11308 INIT_EXPR_NRV_P (retval
) = true;
11310 if (tree set
= maybe_set_retval_sentinel ())
11311 retval
= build2 (COMPOUND_EXPR
, void_type_node
, retval
, set
);
11313 /* If there's a postcondition for an aggregate return value, call the
11314 postcondition function after the return object is initialized. */
11315 if (tree post
= apply_postcondition_to_return (result
))
11316 retval
= build2 (COMPOUND_EXPR
, void_type_node
, retval
, post
);
11322 /* Returns nonzero if the pointer-type FROM can be converted to the
11323 pointer-type TO via a qualification conversion. If CONSTP is -1,
11324 then we return nonzero if the pointers are similar, and the
11325 cv-qualification signature of FROM is a proper subset of that of TO.
11327 If CONSTP is positive, then all outer pointers have been
11328 const-qualified. */
11331 comp_ptr_ttypes_real (tree to
, tree from
, int constp
)
11333 bool to_more_cv_qualified
= false;
11334 bool is_opaque_pointer
= false;
11336 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
11338 if (TREE_CODE (to
) != TREE_CODE (from
))
11341 if (TREE_CODE (from
) == OFFSET_TYPE
11342 && !same_type_p (TYPE_OFFSET_BASETYPE (from
),
11343 TYPE_OFFSET_BASETYPE (to
)))
11346 /* Const and volatile mean something different for function and
11347 array types, so the usual checks are not appropriate. We'll
11348 check the array type elements in further iterations. */
11349 if (!FUNC_OR_METHOD_TYPE_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
11351 if (!at_least_as_qualified_p (to
, from
))
11354 if (!at_least_as_qualified_p (from
, to
))
11358 to_more_cv_qualified
= true;
11362 constp
&= TYPE_READONLY (to
);
11365 if (VECTOR_TYPE_P (to
))
11366 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
11368 /* P0388R4 allows a conversion from int[N] to int[] but not the
11369 other way round. When both arrays have bounds but they do
11370 not match, then no conversion is possible. */
11371 if (TREE_CODE (to
) == ARRAY_TYPE
11372 && !comp_array_types (to
, from
, bounds_first
, /*strict=*/false))
11375 if (!TYPE_PTR_P (to
)
11376 && !TYPE_PTRDATAMEM_P (to
)
11377 /* CWG 330 says we need to look through arrays. */
11378 && TREE_CODE (to
) != ARRAY_TYPE
)
11379 return ((constp
>= 0 || to_more_cv_qualified
)
11380 && (is_opaque_pointer
11381 || same_type_ignoring_top_level_qualifiers_p (to
, from
)));
11385 /* When comparing, say, char ** to char const **, this function takes
11386 the 'char *' and 'char const *'. Do not pass non-pointer/reference
11387 types to this function. */
11390 comp_ptr_ttypes (tree to
, tree from
)
11392 return comp_ptr_ttypes_real (to
, from
, 1);
11395 /* Returns true iff FNTYPE is a non-class type that involves
11396 error_mark_node. We can get FUNCTION_TYPE with buried error_mark_node
11397 if a parameter type is ill-formed. */
11400 error_type_p (const_tree type
)
11404 switch (TREE_CODE (type
))
11410 case REFERENCE_TYPE
:
11412 return error_type_p (TREE_TYPE (type
));
11414 case FUNCTION_TYPE
:
11416 if (error_type_p (TREE_TYPE (type
)))
11418 for (t
= TYPE_ARG_TYPES (type
); t
; t
= TREE_CHAIN (t
))
11419 if (error_type_p (TREE_VALUE (t
)))
11424 if (TYPE_PTRMEMFUNC_P (type
))
11425 return error_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type
));
11433 /* Returns true if to and from are (possibly multi-level) pointers to the same
11434 type or inheritance-related types, regardless of cv-quals. */
11437 ptr_reasonably_similar (const_tree to
, const_tree from
)
11439 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
11441 /* Any target type is similar enough to void. */
11442 if (VOID_TYPE_P (to
))
11443 return !error_type_p (from
);
11444 if (VOID_TYPE_P (from
))
11445 return !error_type_p (to
);
11447 if (TREE_CODE (to
) != TREE_CODE (from
))
11450 if (TREE_CODE (from
) == OFFSET_TYPE
11451 && comptypes (TYPE_OFFSET_BASETYPE (to
),
11452 TYPE_OFFSET_BASETYPE (from
),
11453 COMPARE_BASE
| COMPARE_DERIVED
))
11456 if (VECTOR_TYPE_P (to
)
11457 && vector_types_convertible_p (to
, from
, false))
11460 if (TREE_CODE (to
) == INTEGER_TYPE
11461 && TYPE_PRECISION (to
) == TYPE_PRECISION (from
))
11464 if (TREE_CODE (to
) == FUNCTION_TYPE
)
11465 return !error_type_p (to
) && !error_type_p (from
);
11467 if (!TYPE_PTR_P (to
))
11469 /* When either type is incomplete avoid DERIVED_FROM_P,
11470 which may call complete_type (c++/57942). */
11471 bool b
= !COMPLETE_TYPE_P (to
) || !COMPLETE_TYPE_P (from
);
11473 (TYPE_MAIN_VARIANT (to
), TYPE_MAIN_VARIANT (from
),
11474 b
? COMPARE_STRICT
: COMPARE_BASE
| COMPARE_DERIVED
);
11479 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
11480 pointer-to-member types) are the same, ignoring cv-qualification at
11481 all levels. CB says how we should behave when comparing array bounds. */
11484 comp_ptr_ttypes_const (tree to
, tree from
, compare_bounds_t cb
)
11486 bool is_opaque_pointer
= false;
11488 for (; ; to
= TREE_TYPE (to
), from
= TREE_TYPE (from
))
11490 if (TREE_CODE (to
) != TREE_CODE (from
))
11493 if (TREE_CODE (from
) == OFFSET_TYPE
11494 && same_type_p (TYPE_OFFSET_BASETYPE (from
),
11495 TYPE_OFFSET_BASETYPE (to
)))
11498 if (VECTOR_TYPE_P (to
))
11499 is_opaque_pointer
= vector_targets_convertible_p (to
, from
);
11501 if (TREE_CODE (to
) == ARRAY_TYPE
11502 /* Ignore cv-qualification, but if we see e.g. int[3] and int[4],
11504 && !comp_array_types (to
, from
, cb
, /*strict=*/false))
11507 /* CWG 330 says we need to look through arrays. */
11508 if (!TYPE_PTR_P (to
) && TREE_CODE (to
) != ARRAY_TYPE
)
11509 return (is_opaque_pointer
11510 || same_type_ignoring_top_level_qualifiers_p (to
, from
));
11514 /* Returns the type qualifiers for this type, including the qualifiers on the
11515 elements for an array type. */
11518 cp_type_quals (const_tree type
)
11521 /* This CONST_CAST is okay because strip_array_types returns its
11522 argument unmodified and we assign it to a const_tree. */
11523 type
= strip_array_types (CONST_CAST_TREE (type
));
11524 if (type
== error_mark_node
11525 /* Quals on a FUNCTION_TYPE are memfn quals. */
11526 || TREE_CODE (type
) == FUNCTION_TYPE
)
11527 return TYPE_UNQUALIFIED
;
11528 quals
= TYPE_QUALS (type
);
11529 /* METHOD and REFERENCE_TYPEs should never have quals. */
11530 gcc_assert ((TREE_CODE (type
) != METHOD_TYPE
11531 && !TYPE_REF_P (type
))
11532 || ((quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
))
11533 == TYPE_UNQUALIFIED
));
11537 /* Returns the function-ref-qualifier for TYPE */
11540 type_memfn_rqual (const_tree type
)
11542 gcc_assert (FUNC_OR_METHOD_TYPE_P (type
));
11544 if (!FUNCTION_REF_QUALIFIED (type
))
11545 return REF_QUAL_NONE
;
11546 else if (FUNCTION_RVALUE_QUALIFIED (type
))
11547 return REF_QUAL_RVALUE
;
11549 return REF_QUAL_LVALUE
;
11552 /* Returns the function-cv-quals for TYPE, which must be a FUNCTION_TYPE or
11556 type_memfn_quals (const_tree type
)
11558 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11559 return TYPE_QUALS (type
);
11560 else if (TREE_CODE (type
) == METHOD_TYPE
)
11561 return cp_type_quals (class_of_this_parm (type
));
11563 gcc_unreachable ();
11566 /* Returns the FUNCTION_TYPE TYPE with its function-cv-quals changed to
11567 MEMFN_QUALS and its ref-qualifier to RQUAL. */
11570 apply_memfn_quals (tree type
, cp_cv_quals memfn_quals
, cp_ref_qualifier rqual
)
11572 /* Could handle METHOD_TYPE here if necessary. */
11573 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
11574 if (TYPE_QUALS (type
) == memfn_quals
11575 && type_memfn_rqual (type
) == rqual
)
11578 /* This should really have a different TYPE_MAIN_VARIANT, but that gets
11580 tree result
= build_qualified_type (type
, memfn_quals
);
11581 return build_ref_qualified_type (result
, rqual
);
11584 /* Returns nonzero if TYPE is const or volatile. */
11587 cv_qualified_p (const_tree type
)
11589 int quals
= cp_type_quals (type
);
11590 return (quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
)) != 0;
11593 /* Returns nonzero if the TYPE contains a mutable member. */
11596 cp_has_mutable_p (const_tree type
)
11598 /* This CONST_CAST is okay because strip_array_types returns its
11599 argument unmodified and we assign it to a const_tree. */
11600 type
= strip_array_types (CONST_CAST_TREE(type
));
11602 return CLASS_TYPE_P (type
) && CLASSTYPE_HAS_MUTABLE (type
);
11605 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
11606 TYPE_QUALS. For a VAR_DECL, this may be an optimistic
11607 approximation. In particular, consider:
11610 struct S { int i; };
11611 const S s = { f(); }
11613 Here, we will make "s" as TREE_READONLY (because it is declared
11614 "const") -- only to reverse ourselves upon seeing that the
11615 initializer is non-constant. */
11618 cp_apply_type_quals_to_decl (int type_quals
, tree decl
)
11620 tree type
= TREE_TYPE (decl
);
11622 if (type
== error_mark_node
)
11625 if (TREE_CODE (decl
) == TYPE_DECL
)
11628 gcc_assert (!(TREE_CODE (type
) == FUNCTION_TYPE
11629 && type_quals
!= TYPE_UNQUALIFIED
));
11631 /* Avoid setting TREE_READONLY incorrectly. */
11632 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
11633 constructor can produce constant init, so rely on cp_finish_decl to
11634 clear TREE_READONLY if the variable has non-constant init. */
11636 /* If the type has (or might have) a mutable component, that component
11637 might be modified. */
11638 if (TYPE_HAS_MUTABLE_P (type
) || !COMPLETE_TYPE_P (type
))
11639 type_quals
&= ~TYPE_QUAL_CONST
;
11641 c_apply_type_quals_to_decl (type_quals
, decl
);
11644 /* Subroutine of casts_away_constness. Make T1 and T2 point at
11645 exemplar types such that casting T1 to T2 is casting away constness
11646 if and only if there is no implicit conversion from T1 to T2. */
11649 casts_away_constness_r (tree
*t1
, tree
*t2
, tsubst_flags_t complain
)
11654 /* [expr.const.cast]
11656 For multi-level pointer to members and multi-level mixed pointers
11657 and pointers to members (conv.qual), the "member" aspect of a
11658 pointer to member level is ignored when determining if a const
11659 cv-qualifier has been cast away. */
11660 /* [expr.const.cast]
11662 For two pointer types:
11664 X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type
11665 X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type
11668 casting from X1 to X2 casts away constness if, for a non-pointer
11669 type T there does not exist an implicit conversion (clause
11672 Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
11676 Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */
11677 if ((!TYPE_PTR_P (*t1
) && !TYPE_PTRDATAMEM_P (*t1
))
11678 || (!TYPE_PTR_P (*t2
) && !TYPE_PTRDATAMEM_P (*t2
)))
11680 *t1
= cp_build_qualified_type (void_type_node
,
11681 cp_type_quals (*t1
));
11682 *t2
= cp_build_qualified_type (void_type_node
,
11683 cp_type_quals (*t2
));
11687 quals1
= cp_type_quals (*t1
);
11688 quals2
= cp_type_quals (*t2
);
11690 if (TYPE_PTRDATAMEM_P (*t1
))
11691 *t1
= TYPE_PTRMEM_POINTED_TO_TYPE (*t1
);
11693 *t1
= TREE_TYPE (*t1
);
11694 if (TYPE_PTRDATAMEM_P (*t2
))
11695 *t2
= TYPE_PTRMEM_POINTED_TO_TYPE (*t2
);
11697 *t2
= TREE_TYPE (*t2
);
11699 casts_away_constness_r (t1
, t2
, complain
);
11700 *t1
= build_pointer_type (*t1
);
11701 *t2
= build_pointer_type (*t2
);
11702 *t1
= cp_build_qualified_type (*t1
, quals1
);
11703 *t2
= cp_build_qualified_type (*t2
, quals2
);
11706 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
11709 ??? This function returns non-zero if casting away qualifiers not
11710 just const. We would like to return to the caller exactly which
11711 qualifiers are casted away to give more accurate diagnostics.
11715 casts_away_constness (tree t1
, tree t2
, tsubst_flags_t complain
)
11717 if (TYPE_REF_P (t2
))
11719 /* [expr.const.cast]
11721 Casting from an lvalue of type T1 to an lvalue of type T2
11722 using a reference cast casts away constness if a cast from an
11723 rvalue of type "pointer to T1" to the type "pointer to T2"
11724 casts away constness. */
11725 t1
= (TYPE_REF_P (t1
) ? TREE_TYPE (t1
) : t1
);
11726 return casts_away_constness (build_pointer_type (t1
),
11727 build_pointer_type (TREE_TYPE (t2
)),
11731 if (TYPE_PTRDATAMEM_P (t1
) && TYPE_PTRDATAMEM_P (t2
))
11732 /* [expr.const.cast]
11734 Casting from an rvalue of type "pointer to data member of X
11735 of type T1" to the type "pointer to data member of Y of type
11736 T2" casts away constness if a cast from an rvalue of type
11737 "pointer to T1" to the type "pointer to T2" casts away
11739 return casts_away_constness
11740 (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1
)),
11741 build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2
)),
11744 /* Casting away constness is only something that makes sense for
11745 pointer or reference types. */
11746 if (!TYPE_PTR_P (t1
) || !TYPE_PTR_P (t2
))
11749 /* Top-level qualifiers don't matter. */
11750 t1
= TYPE_MAIN_VARIANT (t1
);
11751 t2
= TYPE_MAIN_VARIANT (t2
);
11752 casts_away_constness_r (&t1
, &t2
, complain
);
11753 if (!can_convert (t2
, t1
, complain
))
11759 /* If T is a REFERENCE_TYPE return the type to which T refers.
11760 Otherwise, return T itself. */
11763 non_reference (tree t
)
11765 if (t
&& TYPE_REF_P (t
))
11771 /* Return nonzero if REF is an lvalue valid for this language;
11772 otherwise, print an error message and return zero. USE says
11773 how the lvalue is being used and so selects the error message. */
11776 lvalue_or_else (tree ref
, enum lvalue_use use
, tsubst_flags_t complain
)
11778 cp_lvalue_kind kind
= lvalue_kind (ref
);
11780 if (kind
== clk_none
)
11782 if (complain
& tf_error
)
11783 lvalue_error (cp_expr_loc_or_input_loc (ref
), use
);
11786 else if (kind
& (clk_rvalueref
|clk_class
))
11788 if (!(complain
& tf_error
))
11790 /* Make this a permerror because we used to accept it. */
11791 permerror (cp_expr_loc_or_input_loc (ref
),
11792 "using rvalue as lvalue");
11797 /* Return true if a user-defined literal operator is a raw operator. */
11800 check_raw_literal_operator (const_tree decl
)
11802 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11805 bool maybe_raw_p
= false;
11807 /* Count the number and type of arguments and check for ellipsis. */
11808 for (argtype
= argtypes
, arity
= 0;
11809 argtype
&& argtype
!= void_list_node
;
11810 ++arity
, argtype
= TREE_CHAIN (argtype
))
11812 tree t
= TREE_VALUE (argtype
);
11814 if (same_type_p (t
, const_string_type_node
))
11815 maybe_raw_p
= true;
11818 return false; /* Found ellipsis. */
11820 if (!maybe_raw_p
|| arity
!= 1)
11827 /* Return true if a user-defined literal operator has one of the allowed
11831 check_literal_operator_args (const_tree decl
,
11832 bool *long_long_unsigned_p
, bool *long_double_p
)
11834 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11836 *long_long_unsigned_p
= false;
11837 *long_double_p
= false;
11838 if (processing_template_decl
|| processing_specialization
)
11839 return argtypes
== void_list_node
;
11846 /* Count the number and type of arguments and check for ellipsis. */
11847 for (argtype
= argtypes
, arity
= 0;
11848 argtype
&& argtype
!= void_list_node
;
11849 argtype
= TREE_CHAIN (argtype
))
11851 tree t
= TREE_VALUE (argtype
);
11854 if (TYPE_PTR_P (t
))
11856 bool maybe_raw_p
= false;
11858 if (cp_type_quals (t
) != TYPE_QUAL_CONST
)
11860 t
= TYPE_MAIN_VARIANT (t
);
11861 if ((maybe_raw_p
= same_type_p (t
, char_type_node
))
11862 || same_type_p (t
, wchar_type_node
)
11863 || same_type_p (t
, char8_type_node
)
11864 || same_type_p (t
, char16_type_node
)
11865 || same_type_p (t
, char32_type_node
))
11867 argtype
= TREE_CHAIN (argtype
);
11870 t
= TREE_VALUE (argtype
);
11871 if (maybe_raw_p
&& argtype
== void_list_node
)
11873 else if (same_type_p (t
, size_type_node
))
11882 else if (same_type_p (t
, long_long_unsigned_type_node
))
11885 *long_long_unsigned_p
= true;
11887 else if (same_type_p (t
, long_double_type_node
))
11890 *long_double_p
= true;
11892 else if (same_type_p (t
, char_type_node
))
11894 else if (same_type_p (t
, wchar_type_node
))
11896 else if (same_type_p (t
, char8_type_node
))
11898 else if (same_type_p (t
, char16_type_node
))
11900 else if (same_type_p (t
, char32_type_node
))
11906 return false; /* Found ellipsis. */
11908 if (arity
!= max_arity
)
11915 /* Always returns false since unlike C90, C++ has no concept of implicit
11916 function declarations. */
11919 c_decl_implicit (const_tree
)