1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2018 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 contains the functions for converting C++ expressions
23 to different data types. The only entry point is `convert'.
24 Every language front end must have a `convert' function
25 but what kind of conversions it does will depend on the language. */
29 #include "coretypes.h"
32 #include "stor-layout.h"
36 #include "stringpool.h"
39 static tree
convert_to_pointer_force (tree
, tree
, tsubst_flags_t
);
40 static tree
build_type_conversion (tree
, tree
);
41 static tree
build_up_reference (tree
, tree
, int, tree
, tsubst_flags_t
);
42 static void diagnose_ref_binding (location_t
, tree
, tree
, tree
);
44 /* Change of width--truncation and extension of integers or reals--
45 is represented with NOP_EXPR. Proper functioning of many things
46 assumes that no other conversions can be NOP_EXPRs.
48 Conversion between integer and pointer is represented with CONVERT_EXPR.
49 Converting integer to real uses FLOAT_EXPR
50 and real to integer uses FIX_TRUNC_EXPR.
52 Here is a list of all the functions that assume that widening and
53 narrowing is always done with a NOP_EXPR:
54 In convert.c, convert_to_integer[_maybe_fold].
55 In c-typeck.c, build_binary_op_nodefault (boolean ops),
56 and c_common_truthvalue_conversion.
57 In expr.c: expand_expr, for operands of a MULT_EXPR.
58 In fold-const.c: fold.
59 In tree.c: get_narrower and get_unwidened.
61 C++: in multiple-inheritance, converting between pointers may involve
62 adjusting them by a delta stored within the class definition. */
64 /* Subroutines of `convert'. */
66 /* if converting pointer to pointer
67 if dealing with classes, check for derived->base or vice versa
68 else if dealing with method pointers, delegate
70 else if converting class, pass off to build_type_conversion
71 else try C-style pointer conversion. */
74 cp_convert_to_pointer (tree type
, tree expr
, bool dofold
,
75 tsubst_flags_t complain
)
77 tree intype
= TREE_TYPE (expr
);
80 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
82 if (intype
== error_mark_node
)
83 return error_mark_node
;
85 if (MAYBE_CLASS_TYPE_P (intype
))
87 intype
= complete_type (intype
);
88 if (!COMPLETE_TYPE_P (intype
))
90 if (complain
& tf_error
)
91 error_at (loc
, "can%'t convert from incomplete type %qH to %qI",
93 return error_mark_node
;
96 rval
= build_type_conversion (type
, expr
);
99 if ((complain
& tf_error
)
100 && rval
== error_mark_node
)
101 error_at (loc
, "conversion of %qE from %qH to %qI is ambiguous",
107 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
108 if (TYPE_PTR_P (type
)
109 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
110 || VOID_TYPE_P (TREE_TYPE (type
))))
112 if (TYPE_PTRMEMFUNC_P (intype
)
113 || TREE_CODE (intype
) == METHOD_TYPE
)
114 return convert_member_func_to_ptr (type
, expr
, complain
);
115 if (TYPE_PTR_P (TREE_TYPE (expr
)))
116 return build_nop (type
, expr
);
117 intype
= TREE_TYPE (expr
);
120 if (expr
== error_mark_node
)
121 return error_mark_node
;
123 form
= TREE_CODE (intype
);
125 if (INDIRECT_TYPE_P (intype
))
127 intype
= TYPE_MAIN_VARIANT (intype
);
129 if (TYPE_MAIN_VARIANT (type
) != intype
131 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
132 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type
))
133 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype
))
134 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
136 enum tree_code code
= PLUS_EXPR
;
142 intype_class
= TREE_TYPE (intype
);
143 type_class
= TREE_TYPE (type
);
145 same_p
= same_type_p (TYPE_MAIN_VARIANT (intype_class
),
146 TYPE_MAIN_VARIANT (type_class
));
148 /* Try derived to base conversion. */
150 binfo
= lookup_base (intype_class
, type_class
, ba_check
,
152 if (!same_p
&& !binfo
)
154 /* Try base to derived conversion. */
155 binfo
= lookup_base (type_class
, intype_class
, ba_check
,
159 if (binfo
== error_mark_node
)
160 return error_mark_node
;
164 expr
= build_base_path (code
, expr
, binfo
, 0, complain
);
165 /* Add any qualifier conversions. */
166 return build_nop (type
, expr
);
170 if (TYPE_PTRMEMFUNC_P (type
))
172 if (complain
& tf_error
)
173 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
175 return error_mark_node
;
178 return build_nop (type
, expr
);
180 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
181 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
182 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/false,
183 /*c_cast_p=*/false, complain
);
184 else if (TYPE_PTRMEMFUNC_P (intype
))
188 if (TREE_CODE (expr
) == PTRMEM_CST
)
189 return cp_convert_to_pointer (type
, PTRMEM_CST_MEMBER (expr
),
191 else if (TREE_CODE (expr
) == OFFSET_REF
)
193 tree object
= TREE_OPERAND (expr
, 0);
194 return get_member_function_from_ptrfunc (&object
,
195 TREE_OPERAND (expr
, 1),
199 if (complain
& tf_error
)
200 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
202 return error_mark_node
;
205 if (null_ptr_cst_p (expr
))
207 if (TYPE_PTRMEMFUNC_P (type
))
208 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
, 0,
209 /*c_cast_p=*/false, complain
);
211 if (complain
& tf_warning
)
212 maybe_warn_zero_as_null_pointer_constant (expr
, loc
);
214 /* A NULL pointer-to-data-member is represented by -1, not by
216 tree val
= (TYPE_PTRDATAMEM_P (type
)
217 ? build_int_cst_type (type
, -1)
218 : build_int_cst (type
, 0));
220 return (TREE_SIDE_EFFECTS (expr
)
221 ? build2 (COMPOUND_EXPR
, type
, expr
, val
) : val
);
223 else if (TYPE_PTRMEM_P (type
) && INTEGRAL_CODE_P (form
))
225 if (complain
& tf_error
)
226 error_at (loc
, "invalid conversion from %qH to %qI", intype
, type
);
227 return error_mark_node
;
230 if (INTEGRAL_CODE_P (form
))
232 if (TYPE_PRECISION (intype
) == POINTER_SIZE
)
233 return build1 (CONVERT_EXPR
, type
, expr
);
234 expr
= cp_convert (c_common_type_for_size (POINTER_SIZE
, 0), expr
,
236 /* Modes may be different but sizes should be the same. There
237 is supposed to be some integral type that is the same width
239 gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr
)))
240 == GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
)));
242 /* FIXME needed because convert_to_pointer_maybe_fold still folds
243 conversion of constants. */
245 return build1 (CONVERT_EXPR
, type
, expr
);
247 return convert_to_pointer_maybe_fold (type
, expr
, dofold
);
250 if (type_unknown_p (expr
))
251 return instantiate_type (type
, expr
, complain
);
253 if (complain
& tf_error
)
254 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
256 return error_mark_node
;
259 /* Like convert, except permit conversions to take place which
260 are not normally allowed due to access restrictions
261 (such as conversion from sub-type to private super-type). */
264 convert_to_pointer_force (tree type
, tree expr
, tsubst_flags_t complain
)
266 tree intype
= TREE_TYPE (expr
);
267 enum tree_code form
= TREE_CODE (intype
);
269 if (form
== POINTER_TYPE
)
271 intype
= TYPE_MAIN_VARIANT (intype
);
273 if (TYPE_MAIN_VARIANT (type
) != intype
274 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
275 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type
))
276 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype
))
277 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
279 enum tree_code code
= PLUS_EXPR
;
282 binfo
= lookup_base (TREE_TYPE (intype
), TREE_TYPE (type
),
283 ba_unique
, NULL
, complain
);
286 binfo
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
287 ba_unique
, NULL
, complain
);
290 if (binfo
== error_mark_node
)
291 return error_mark_node
;
294 expr
= build_base_path (code
, expr
, binfo
, 0, complain
);
295 if (expr
== error_mark_node
)
296 return error_mark_node
;
297 /* Add any qualifier conversions. */
298 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr
)),
300 expr
= build_nop (type
, expr
);
306 return cp_convert_to_pointer (type
, expr
, /*fold*/false, complain
);
309 /* We are passing something to a function which requires a reference.
310 The type we are interested in is in TYPE. The initial
311 value we have to begin with is in ARG.
313 FLAGS controls how we manage access checking.
314 DIRECT_BIND in FLAGS controls how any temporaries are generated.
315 If DIRECT_BIND is set, DECL is the reference we're binding to. */
318 build_up_reference (tree type
, tree arg
, int flags
, tree decl
,
319 tsubst_flags_t complain
)
322 tree argtype
= TREE_TYPE (arg
);
323 tree target_type
= TREE_TYPE (type
);
325 gcc_assert (TYPE_REF_P (type
));
327 if ((flags
& DIRECT_BIND
) && ! lvalue_p (arg
))
329 /* Create a new temporary variable. We can't just use a TARGET_EXPR
330 here because it needs to live as long as DECL. */
333 arg
= make_temporary_var_for_ref_to_temp (decl
, target_type
);
335 /* Process the initializer for the declaration. */
336 DECL_INITIAL (arg
) = targ
;
337 cp_finish_decl (arg
, targ
, /*init_const_expr_p=*/false, NULL_TREE
,
338 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
340 else if (!(flags
& DIRECT_BIND
) && ! obvalue_p (arg
))
341 return get_target_expr_sfinae (arg
, complain
);
343 /* If we had a way to wrap this up, and say, if we ever needed its
344 address, transform all occurrences of the register, into a memory
345 reference we could win better. */
346 rval
= cp_build_addr_expr (arg
, complain
);
347 if (rval
== error_mark_node
)
348 return error_mark_node
;
350 if ((flags
& LOOKUP_PROTECT
)
351 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
352 && MAYBE_CLASS_TYPE_P (argtype
)
353 && MAYBE_CLASS_TYPE_P (target_type
))
355 /* We go through lookup_base for the access control. */
356 tree binfo
= lookup_base (argtype
, target_type
, ba_check
,
358 if (binfo
== error_mark_node
)
359 return error_mark_node
;
360 if (binfo
== NULL_TREE
)
361 return error_not_base_type (target_type
, argtype
);
362 rval
= build_base_path (PLUS_EXPR
, rval
, binfo
, 1, complain
);
366 = convert_to_pointer_force (build_pointer_type (target_type
),
368 return build_nop (type
, rval
);
371 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
372 INTYPE is the original rvalue type and DECL is an optional _DECL node
375 [dcl.init.ref] says that if an rvalue is used to
376 initialize a reference, then the reference must be to a
377 non-volatile const type. */
380 diagnose_ref_binding (location_t loc
, tree reftype
, tree intype
, tree decl
)
382 tree ttl
= TREE_TYPE (reftype
);
384 if (!TYPE_REF_IS_RVALUE (reftype
)
385 && !CP_TYPE_CONST_NON_VOLATILE_P (ttl
))
389 if (CP_TYPE_VOLATILE_P (ttl
) && decl
)
390 msg
= G_("initialization of volatile reference type %q#T from "
391 "rvalue of type %qT");
392 else if (CP_TYPE_VOLATILE_P (ttl
))
393 msg
= G_("conversion to volatile reference type %q#T "
394 "from rvalue of type %qT");
396 msg
= G_("initialization of non-const reference type %q#T from "
397 "rvalue of type %qT");
399 msg
= G_("conversion to non-const reference type %q#T from "
400 "rvalue of type %qT");
402 permerror (loc
, msg
, reftype
, intype
);
406 /* For C++: Only need to do one-level references, but cannot
407 get tripped up on signed/unsigned differences.
409 DECL is either NULL_TREE or the _DECL node for a reference that is being
410 initialized. It can be error_mark_node if we don't know the _DECL but
411 we know it's an initialization. */
414 convert_to_reference (tree reftype
, tree expr
, int convtype
,
415 int flags
, tree decl
, tsubst_flags_t complain
)
417 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
419 tree rval
= NULL_TREE
;
420 tree rval_as_conversion
= NULL_TREE
;
421 bool can_convert_intype_to_type
;
422 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
424 if (TREE_CODE (type
) == FUNCTION_TYPE
425 && TREE_TYPE (expr
) == unknown_type_node
)
426 expr
= instantiate_type (type
, expr
, complain
);
428 if (expr
== error_mark_node
)
429 return error_mark_node
;
431 intype
= TREE_TYPE (expr
);
433 gcc_assert (!TYPE_REF_P (intype
));
434 gcc_assert (TYPE_REF_P (reftype
));
436 intype
= TYPE_MAIN_VARIANT (intype
);
438 can_convert_intype_to_type
= can_convert_standard (type
, intype
, complain
);
440 if (!can_convert_intype_to_type
441 && (convtype
& CONV_IMPLICIT
) && MAYBE_CLASS_TYPE_P (intype
)
442 && ! (flags
& LOOKUP_NO_CONVERSION
))
444 /* Look for a user-defined conversion to lvalue that we can use. */
447 = build_type_conversion (reftype
, expr
);
449 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
450 && lvalue_p (rval_as_conversion
))
452 expr
= rval_as_conversion
;
453 rval_as_conversion
= NULL_TREE
;
455 can_convert_intype_to_type
= 1;
459 if (((convtype
& CONV_STATIC
)
460 && can_convert_standard (intype
, type
, complain
))
461 || ((convtype
& CONV_IMPLICIT
) && can_convert_intype_to_type
))
464 tree ttl
= TREE_TYPE (reftype
);
465 tree ttr
= lvalue_type (expr
);
467 if ((complain
& tf_error
)
468 && ! lvalue_p (expr
))
469 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
471 if (! (convtype
& CONV_CONST
)
472 && !at_least_as_qualified_p (ttl
, ttr
))
474 if (complain
& tf_error
)
475 permerror (loc
, "conversion from %qH to %qI discards qualifiers",
478 return error_mark_node
;
482 return build_up_reference (reftype
, expr
, flags
, decl
, complain
);
484 else if ((convtype
& CONV_REINTERPRET
) && obvalue_p (expr
))
486 /* When casting an lvalue to a reference type, just convert into
487 a pointer to the new type and deference it. This is allowed
488 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
489 should be done directly (jason). (int &)ri ---> *(int*)&ri */
491 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
493 if ((complain
& tf_warning
)
494 && TYPE_PTR_P (intype
)
495 && (comptypes (TREE_TYPE (intype
), type
,
496 COMPARE_BASE
| COMPARE_DERIVED
)))
497 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
500 rval
= cp_build_addr_expr (expr
, complain
);
501 if (rval
!= error_mark_node
)
502 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)),
504 if (rval
!= error_mark_node
)
505 rval
= build1 (NOP_EXPR
, reftype
, rval
);
509 rval
= convert_for_initialization (NULL_TREE
, type
, expr
, flags
,
510 ICR_CONVERTING
, 0, 0, complain
);
511 if (rval
== NULL_TREE
|| rval
== error_mark_node
)
513 if (complain
& tf_error
)
514 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
515 rval
= build_up_reference (reftype
, rval
, flags
, decl
, complain
);
520 /* If we found a way to convert earlier, then use it. */
524 if (complain
& tf_error
)
525 error_at (loc
, "cannot convert type %qH to type %qI", intype
, reftype
);
527 return error_mark_node
;
530 /* We are using a reference VAL for its value. Bash that reference all the
531 way down to its lowest form. */
534 convert_from_reference (tree val
)
537 && TYPE_REF_P (TREE_TYPE (val
)))
539 tree t
= TREE_TYPE (TREE_TYPE (val
));
540 tree ref
= build1 (INDIRECT_REF
, t
, val
);
543 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
544 so that we get the proper error message if the result is used
545 to assign to. Also, &* is supposed to be a no-op. */
546 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
547 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
548 TREE_SIDE_EFFECTS (ref
)
549 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (val
));
556 /* Really perform an lvalue-to-rvalue conversion, including copying an
557 argument of class type into a temporary. */
560 force_rvalue (tree expr
, tsubst_flags_t complain
)
562 tree type
= TREE_TYPE (expr
);
563 if (MAYBE_CLASS_TYPE_P (type
) && TREE_CODE (expr
) != TARGET_EXPR
)
565 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
566 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
567 &args
, type
, LOOKUP_NORMAL
, complain
);
568 release_tree_vector (args
);
569 expr
= build_cplus_new (type
, expr
, complain
);
572 expr
= decay_conversion (expr
, complain
);
578 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
579 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
583 ignore_overflows (tree expr
, tree orig
)
585 tree stripped_expr
= tree_strip_any_location_wrapper (expr
);
586 tree stripped_orig
= tree_strip_any_location_wrapper (orig
);
588 if (TREE_CODE (stripped_expr
) == INTEGER_CST
589 && TREE_CODE (stripped_orig
) == INTEGER_CST
590 && TREE_OVERFLOW (stripped_expr
) != TREE_OVERFLOW (stripped_orig
))
592 gcc_assert (!TREE_OVERFLOW (stripped_orig
));
593 /* Ensure constant sharing. */
594 stripped_expr
= wide_int_to_tree (TREE_TYPE (stripped_expr
),
595 wi::to_wide (stripped_expr
));
598 return preserve_any_location_wrapper (stripped_expr
, expr
);
601 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
605 cp_fold_convert (tree type
, tree expr
)
608 if (TREE_TYPE (expr
) == type
)
610 else if (TREE_CODE (expr
) == PTRMEM_CST
611 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
612 PTRMEM_CST_CLASS (expr
)))
614 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
615 conv
= copy_node (expr
);
616 TREE_TYPE (conv
) = type
;
618 else if (TYPE_PTRMEM_P (type
))
620 conv
= convert_ptrmem (type
, expr
, true, false,
621 tf_warning_or_error
);
622 conv
= cp_fully_fold (conv
);
626 conv
= fold_convert (type
, expr
);
627 conv
= ignore_overflows (conv
, expr
);
632 /* C++ conversions, preference to static cast conversions. */
635 cp_convert (tree type
, tree expr
, tsubst_flags_t complain
)
637 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
, complain
);
640 /* C++ equivalent of convert_and_check but using cp_convert as the
643 Convert EXPR to TYPE, warning about conversion problems with constants.
644 Invoke this function on every expression that is converted implicitly,
645 i.e. because of language rules and not because of an explicit cast. */
648 cp_convert_and_check (tree type
, tree expr
, tsubst_flags_t complain
)
652 if (TREE_TYPE (expr
) == type
)
654 if (expr
== error_mark_node
)
656 result
= cp_convert (type
, expr
, complain
);
658 if ((complain
& tf_warning
)
659 && c_inhibit_evaluation_warnings
== 0)
661 tree folded
= cp_fully_fold (expr
);
664 folded_result
= result
;
667 /* Avoid bogus -Wparentheses warnings. */
668 warning_sentinel
w (warn_parentheses
);
669 warning_sentinel
c (warn_int_in_bool_context
);
670 folded_result
= cp_convert (type
, folded
, tf_none
);
672 folded_result
= fold_simple (folded_result
);
673 if (!TREE_OVERFLOW_P (folded
)
674 && folded_result
!= error_mark_node
)
675 warnings_for_convert_and_check (cp_expr_loc_or_loc (expr
, input_location
),
676 type
, folded
, folded_result
);
684 FLAGS indicates how we should behave. */
687 ocp_convert (tree type
, tree expr
, int convtype
, int flags
,
688 tsubst_flags_t complain
)
691 enum tree_code code
= TREE_CODE (type
);
692 const char *invalid_conv_diag
;
694 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
695 bool dofold
= (convtype
& CONV_FOLD
);
697 if (error_operand_p (e
) || type
== error_mark_node
)
698 return error_mark_node
;
700 complete_type (type
);
701 complete_type (TREE_TYPE (expr
));
703 if ((invalid_conv_diag
704 = targetm
.invalid_conversion (TREE_TYPE (expr
), type
)))
706 if (complain
& tf_error
)
707 error (invalid_conv_diag
);
708 return error_mark_node
;
711 /* FIXME remove when moving to c_fully_fold model. */
712 if (!CLASS_TYPE_P (type
))
714 e
= mark_rvalue_use (e
);
715 e
= scalar_constant_value (e
);
717 if (error_operand_p (e
))
718 return error_mark_node
;
720 if (NULLPTR_TYPE_P (type
) && null_ptr_cst_p (e
))
722 if (complain
& tf_warning
)
723 maybe_warn_zero_as_null_pointer_constant (e
, loc
);
725 if (!TREE_SIDE_EFFECTS (e
))
729 if (MAYBE_CLASS_TYPE_P (type
) && (convtype
& CONV_FORCE_TEMP
))
730 /* We need a new temporary; don't take this shortcut. */;
731 else if (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (e
)))
733 tree etype
= TREE_TYPE (e
);
734 if (same_type_p (type
, etype
))
735 /* The call to fold will not always remove the NOP_EXPR as
736 might be expected, since if one of the types is a typedef;
737 the comparison in fold is just equality of pointers, not a
738 call to comptypes. We don't call fold in this case because
739 that can result in infinite recursion; fold will call
740 convert, which will call ocp_convert, etc. */
742 /* For complex data types, we need to perform componentwise
744 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
745 return convert_to_complex_maybe_fold (type
, e
, dofold
);
746 else if (VECTOR_TYPE_P (type
))
747 return convert_to_vector (type
, e
);
748 else if (TREE_CODE (e
) == TARGET_EXPR
)
750 /* Don't build a NOP_EXPR of class type. Instead, change the
751 type of the temporary. */
752 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
753 TREE_TYPE (e
) = TREE_TYPE (TARGET_EXPR_SLOT (e
)) = type
;
756 else if (TREE_CODE (e
) == CONSTRUCTOR
)
758 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
759 TREE_TYPE (e
) = type
;
764 /* We shouldn't be treating objects of ADDRESSABLE type as
766 gcc_assert (!TREE_ADDRESSABLE (type
));
767 return build_nop (type
, e
);
771 e1
= targetm
.convert_to_type (type
, e
);
775 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
777 e
= convert_to_void (e
, ICV_CAST
, complain
);
781 if (INTEGRAL_CODE_P (code
))
783 tree intype
= TREE_TYPE (e
);
786 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
788 /* enum = enum, enum = int, enum = float, (enum)pointer are all
790 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
791 || TREE_CODE (intype
) == REAL_TYPE
)
792 && ! (convtype
& CONV_STATIC
))
793 || TYPE_PTR_P (intype
))
795 if (complain
& tf_error
)
796 permerror (loc
, "conversion from %q#T to %q#T", intype
, type
);
798 return error_mark_node
;
801 /* [expr.static.cast]
803 8. A value of integral or enumeration type can be explicitly
804 converted to an enumeration type. The value is unchanged if
805 the original value is within the range of the enumeration
806 values. Otherwise, the resulting enumeration value is
808 tree val
= fold_for_warn (e
);
809 if ((complain
& tf_warning
)
810 && TREE_CODE (val
) == INTEGER_CST
811 && ENUM_UNDERLYING_TYPE (type
)
812 && !int_fits_type_p (val
, ENUM_UNDERLYING_TYPE (type
)))
813 warning_at (loc
, OPT_Wconversion
,
814 "the result of the conversion is unspecified because "
815 "%qE is outside the range of type %qT",
818 if (MAYBE_CLASS_TYPE_P (intype
))
821 rval
= build_type_conversion (type
, e
);
824 if (complain
& tf_error
)
825 error_at (loc
, "%q#T used where a %qT was expected", intype
, type
);
826 return error_mark_node
;
828 if (code
== BOOLEAN_TYPE
)
830 if (VOID_TYPE_P (intype
))
832 if (complain
& tf_error
)
834 "could not convert %qE from %<void%> to %<bool%>",
836 return error_mark_node
;
839 /* We can't implicitly convert a scoped enum to bool, so convert
840 to the underlying type first. */
841 if (SCOPED_ENUM_P (intype
) && (convtype
& CONV_STATIC
))
842 e
= build_nop (ENUM_UNDERLYING_TYPE (intype
), e
);
843 if (complain
& tf_warning
)
844 return cp_truthvalue_conversion (e
);
847 /* Prevent bogus -Wint-in-bool-context warnings coming
848 from c_common_truthvalue_conversion down the line. */
849 warning_sentinel
w (warn_int_in_bool_context
);
850 return cp_truthvalue_conversion (e
);
854 converted
= convert_to_integer_maybe_fold (type
, e
, dofold
);
856 /* Ignore any integer overflow caused by the conversion. */
857 return ignore_overflows (converted
, e
);
859 if (INDIRECT_TYPE_P (type
) || TYPE_PTRMEM_P (type
))
860 return cp_convert_to_pointer (type
, e
, dofold
, complain
);
861 if (code
== VECTOR_TYPE
)
863 tree in_vtype
= TREE_TYPE (e
);
864 if (MAYBE_CLASS_TYPE_P (in_vtype
))
867 ret_val
= build_type_conversion (type
, e
);
870 if (complain
& tf_error
)
871 error_at (loc
, "%q#T used where a %qT was expected",
873 return error_mark_node
;
875 return convert_to_vector (type
, e
);
877 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
879 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e
)))
882 rval
= build_type_conversion (type
, e
);
885 else if (complain
& tf_error
)
887 "%q#T used where a floating point value was expected",
890 if (code
== REAL_TYPE
)
891 return convert_to_real_maybe_fold (type
, e
, dofold
);
892 else if (code
== COMPLEX_TYPE
)
893 return convert_to_complex_maybe_fold (type
, e
, dofold
);
896 /* New C++ semantics: since assignment is now based on
897 memberwise copying, if the rhs type is derived from the
898 lhs type, then we may still do a conversion. */
899 if (RECORD_OR_UNION_CODE_P (code
))
901 tree dtype
= TREE_TYPE (e
);
902 tree ctor
= NULL_TREE
;
904 dtype
= TYPE_MAIN_VARIANT (dtype
);
906 /* Conversion between aggregate types. New C++ semantics allow
907 objects of derived type to be cast to objects of base type.
908 Old semantics only allowed this between pointers.
910 There may be some ambiguity between using a constructor
911 vs. using a type conversion operator when both apply. */
915 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
916 return error_mark_node
;
918 if (BRACE_ENCLOSED_INITIALIZER_P (ctor
))
919 ctor
= perform_implicit_conversion (type
, ctor
, complain
);
920 else if ((flags
& LOOKUP_ONLYCONVERTING
)
921 && ! (CLASS_TYPE_P (dtype
) && DERIVED_FROM_P (type
, dtype
)))
922 /* For copy-initialization, first we create a temp of the proper type
923 with a user-defined conversion sequence, then we direct-initialize
924 the target with the temp (see [dcl.init]). */
925 ctor
= build_user_type_conversion (type
, ctor
, flags
, complain
);
928 vec
<tree
, va_gc
> *ctor_vec
= make_tree_vector_single (ctor
);
929 ctor
= build_special_member_call (NULL_TREE
,
930 complete_ctor_identifier
,
932 type
, flags
, complain
);
933 release_tree_vector (ctor_vec
);
936 return build_cplus_new (type
, ctor
, complain
);
939 if (complain
& tf_error
)
941 /* If the conversion failed and expr was an invalid use of pointer to
942 member function, try to report a meaningful error. */
943 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
944 /* We displayed the error message. */;
946 error_at (loc
, "conversion from %qH to non-scalar type %qI requested",
947 TREE_TYPE (expr
), type
);
949 return error_mark_node
;
952 /* If CALL is a call, return the callee; otherwise null. */
955 cp_get_callee (tree call
)
957 if (call
== NULL_TREE
)
959 else if (TREE_CODE (call
) == CALL_EXPR
)
960 return CALL_EXPR_FN (call
);
961 else if (TREE_CODE (call
) == AGGR_INIT_EXPR
)
962 return AGGR_INIT_EXPR_FN (call
);
966 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
970 cp_get_fndecl_from_callee (tree fn
, bool fold
/* = true */)
974 if (TREE_CODE (fn
) == FUNCTION_DECL
)
976 tree type
= TREE_TYPE (fn
);
977 if (type
== unknown_type_node
)
979 gcc_assert (INDIRECT_TYPE_P (type
));
981 fn
= maybe_constant_init (fn
);
983 if (TREE_CODE (fn
) == ADDR_EXPR
)
985 fn
= TREE_OPERAND (fn
, 0);
986 if (TREE_CODE (fn
) == FUNCTION_DECL
)
992 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
993 constexpr machinery. */
996 cp_get_callee_fndecl (tree call
)
998 return cp_get_fndecl_from_callee (cp_get_callee (call
));
1001 /* As above, but not using the constexpr machinery. */
1004 cp_get_callee_fndecl_nofold (tree call
)
1006 return cp_get_fndecl_from_callee (cp_get_callee (call
), false);
1009 /* Subroutine of convert_to_void. Warn if we're discarding something with
1010 attribute [[nodiscard]]. */
1013 maybe_warn_nodiscard (tree expr
, impl_conv_void implicit
)
1016 if (TREE_CODE (expr
) == TARGET_EXPR
)
1017 call
= TARGET_EXPR_INITIAL (expr
);
1018 location_t loc
= cp_expr_loc_or_loc (call
, input_location
);
1019 tree callee
= cp_get_callee (call
);
1023 tree type
= TREE_TYPE (callee
);
1024 if (TYPE_PTRMEMFUNC_P (type
))
1025 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
1026 if (INDIRECT_TYPE_P (type
))
1027 type
= TREE_TYPE (type
);
1029 tree rettype
= TREE_TYPE (type
);
1030 tree fn
= cp_get_fndecl_from_callee (callee
);
1031 if (implicit
!= ICV_CAST
&& fn
1032 && lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn
)))
1034 auto_diagnostic_group d
;
1035 if (warning_at (loc
, OPT_Wunused_result
,
1036 "ignoring return value of %qD, "
1037 "declared with attribute nodiscard", fn
))
1038 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1040 else if (implicit
!= ICV_CAST
1041 && lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype
)))
1043 auto_diagnostic_group d
;
1044 if (warning_at (loc
, OPT_Wunused_result
,
1045 "ignoring returned value of type %qT, "
1046 "declared with attribute nodiscard", rettype
))
1049 inform (DECL_SOURCE_LOCATION (fn
),
1050 "in call to %qD, declared here", fn
);
1051 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype
)),
1052 "%qT declared here", rettype
);
1055 else if (TREE_CODE (expr
) == TARGET_EXPR
1056 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type
)))
1058 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1059 result is used, so handle that case here. */
1062 auto_diagnostic_group d
;
1063 if (warning_at (loc
, OPT_Wunused_result
,
1064 "ignoring return value of %qD, "
1065 "declared with attribute warn_unused_result",
1067 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1070 warning_at (loc
, OPT_Wunused_result
,
1071 "ignoring return value of function "
1072 "declared with attribute warn_unused_result");
1076 /* When an expression is used in a void context, its value is discarded and
1077 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1078 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1079 in a void context. The C++ standard does not define what an `access' to an
1080 object is, but there is reason to believe that it is the lvalue to rvalue
1081 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1082 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1083 indicates that volatile semantics should be the same between C and C++
1084 where ever possible. C leaves it implementation defined as to what
1085 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1086 the volatile object `vp' points to, unless that is an incomplete type. For
1087 volatile references we do not do this interpretation, because that would
1088 make it impossible to ignore the reference return value from functions. We
1089 issue warnings in the confusing cases.
1091 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1092 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1093 indicates the context of the implicit conversion. */
1096 convert_to_void (tree expr
, impl_conv_void implicit
, tsubst_flags_t complain
)
1098 location_t loc
= cp_expr_loc_or_loc (expr
, input_location
);
1100 if (expr
== error_mark_node
1101 || TREE_TYPE (expr
) == error_mark_node
)
1102 return error_mark_node
;
1104 expr
= maybe_undo_parenthesized_ref (expr
);
1106 expr
= mark_discarded_use (expr
);
1107 if (implicit
== ICV_CAST
)
1108 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1109 mark_exp_read (expr
);
1111 if (!TREE_TYPE (expr
))
1113 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
1114 return error_mark_node
;
1115 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
1117 if (complain
& tf_error
)
1118 error_at (loc
, "pseudo-destructor is not called");
1119 return error_mark_node
;
1121 if (VOID_TYPE_P (TREE_TYPE (expr
)))
1123 switch (TREE_CODE (expr
))
1127 /* The two parts of a cond expr might be separate lvalues. */
1128 tree op1
= TREE_OPERAND (expr
,1);
1129 tree op2
= TREE_OPERAND (expr
,2);
1130 bool side_effects
= ((op1
&& TREE_SIDE_EFFECTS (op1
))
1131 || TREE_SIDE_EFFECTS (op2
));
1132 tree new_op1
, new_op2
;
1133 new_op1
= NULL_TREE
;
1134 if (implicit
!= ICV_CAST
&& !side_effects
)
1137 new_op1
= convert_to_void (op1
, ICV_SECOND_OF_COND
, complain
);
1138 new_op2
= convert_to_void (op2
, ICV_THIRD_OF_COND
, complain
);
1143 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1144 new_op2
= convert_to_void (op2
, ICV_CAST
, complain
);
1147 expr
= build3 (COND_EXPR
, TREE_TYPE (new_op2
),
1148 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
1154 /* The second part of a compound expr contains the value. */
1155 tree op1
= TREE_OPERAND (expr
,1);
1157 if (implicit
!= ICV_CAST
&& !TREE_NO_WARNING (expr
))
1158 new_op1
= convert_to_void (op1
, ICV_RIGHT_OF_COMMA
, complain
);
1160 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1164 tree t
= build2 (COMPOUND_EXPR
, TREE_TYPE (new_op1
),
1165 TREE_OPERAND (expr
, 0), new_op1
);
1172 case NON_LVALUE_EXPR
:
1174 /* These have already decayed to rvalue. */
1177 case CALL_EXPR
: /* We have a special meaning for volatile void fn(). */
1178 maybe_warn_nodiscard (expr
, implicit
);
1183 tree type
= TREE_TYPE (expr
);
1184 int is_reference
= TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1185 int is_volatile
= TYPE_VOLATILE (type
);
1186 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1188 /* Can't load the value if we don't know the type. */
1189 if (is_volatile
&& !is_complete
)
1191 if (complain
& tf_warning
)
1195 warning_at (loc
, 0, "conversion to void will not access "
1196 "object of incomplete type %qT", type
);
1198 case ICV_SECOND_OF_COND
:
1199 warning_at (loc
, 0, "indirection will not access object of "
1200 "incomplete type %qT in second operand "
1201 "of conditional expression", type
);
1203 case ICV_THIRD_OF_COND
:
1204 warning_at (loc
, 0, "indirection will not access object of "
1205 "incomplete type %qT in third operand "
1206 "of conditional expression", type
);
1208 case ICV_RIGHT_OF_COMMA
:
1209 warning_at (loc
, 0, "indirection will not access object of "
1210 "incomplete type %qT in right operand of "
1211 "comma operator", type
);
1213 case ICV_LEFT_OF_COMMA
:
1214 warning_at (loc
, 0, "indirection will not access object of "
1215 "incomplete type %qT in left operand of "
1216 "comma operator", type
);
1219 warning_at (loc
, 0, "indirection will not access object of "
1220 "incomplete type %qT in statement", type
);
1222 case ICV_THIRD_IN_FOR
:
1223 warning_at (loc
, 0, "indirection will not access object of "
1224 "incomplete type %qT in for increment "
1225 "expression", type
);
1231 /* Don't load the value if this is an implicit dereference, or if
1232 the type needs to be handled by ctors/dtors. */
1233 else if (is_volatile
&& is_reference
)
1235 if (complain
& tf_warning
)
1239 warning_at (loc
, 0, "conversion to void will not access "
1240 "object of type %qT", type
);
1242 case ICV_SECOND_OF_COND
:
1243 warning_at (loc
, 0, "implicit dereference will not access "
1244 "object of type %qT in second operand of "
1245 "conditional expression", type
);
1247 case ICV_THIRD_OF_COND
:
1248 warning_at (loc
, 0, "implicit dereference will not access "
1249 "object of type %qT in third operand of "
1250 "conditional expression", type
);
1252 case ICV_RIGHT_OF_COMMA
:
1253 warning_at (loc
, 0, "implicit dereference will not access "
1254 "object of type %qT in right operand of "
1255 "comma operator", type
);
1257 case ICV_LEFT_OF_COMMA
:
1258 warning_at (loc
, 0, "implicit dereference will not access "
1259 "object of type %qT in left operand of comma "
1263 warning_at (loc
, 0, "implicit dereference will not access "
1264 "object of type %qT in statement", type
);
1266 case ICV_THIRD_IN_FOR
:
1267 warning_at (loc
, 0, "implicit dereference will not access "
1268 "object of type %qT in for increment expression",
1275 else if (is_volatile
&& TREE_ADDRESSABLE (type
))
1277 if (complain
& tf_warning
)
1281 warning_at (loc
, 0, "conversion to void will not access "
1282 "object of non-trivially-copyable type %qT",
1285 case ICV_SECOND_OF_COND
:
1286 warning_at (loc
, 0, "indirection will not access object of "
1287 "non-trivially-copyable type %qT in second "
1288 "operand of conditional expression", type
);
1290 case ICV_THIRD_OF_COND
:
1291 warning_at (loc
, 0, "indirection will not access object of "
1292 "non-trivially-copyable type %qT in third "
1293 "operand of conditional expression", type
);
1295 case ICV_RIGHT_OF_COMMA
:
1296 warning_at (loc
, 0, "indirection will not access object of "
1297 "non-trivially-copyable type %qT in right "
1298 "operand of comma operator", type
);
1300 case ICV_LEFT_OF_COMMA
:
1301 warning_at (loc
, 0, "indirection will not access object of "
1302 "non-trivially-copyable type %qT in left "
1303 "operand of comma operator", type
);
1306 warning_at (loc
, 0, "indirection will not access object of "
1307 "non-trivially-copyable type %qT in statement",
1310 case ICV_THIRD_IN_FOR
:
1311 warning_at (loc
, 0, "indirection will not access object of "
1312 "non-trivially-copyable type %qT in for "
1313 "increment expression", type
);
1319 if (is_reference
|| !is_volatile
|| !is_complete
|| TREE_ADDRESSABLE (type
))
1321 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1322 operation is stripped off. Note that we don't warn about
1323 - an expression with TREE_NO_WARNING set. (For an example of
1324 such expressions, see build_over_call in call.c.)
1325 - automatic dereferencing of references, since the user cannot
1326 control it. (See also warn_if_unused_value() in c-common.c.) */
1327 if (warn_unused_value
1328 && implicit
!= ICV_CAST
1329 && (complain
& tf_warning
)
1330 && !TREE_NO_WARNING (expr
)
1332 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1333 expr
= TREE_OPERAND (expr
, 0);
1334 if (TREE_CODE (expr
) == CALL_EXPR
)
1335 maybe_warn_nodiscard (expr
, implicit
);
1343 /* External variables might be incomplete. */
1344 tree type
= TREE_TYPE (expr
);
1345 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1347 if (TYPE_VOLATILE (type
) && !is_complete
&& (complain
& tf_warning
))
1351 warning_at (loc
, 0, "conversion to void will not access "
1352 "object %qE of incomplete type %qT", expr
, type
);
1354 case ICV_SECOND_OF_COND
:
1355 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1356 "not be accessed in second operand of "
1357 "conditional expression", expr
, type
);
1359 case ICV_THIRD_OF_COND
:
1360 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1361 "not be accessed in third operand of "
1362 "conditional expression", expr
, type
);
1364 case ICV_RIGHT_OF_COMMA
:
1365 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1366 "not be accessed in right operand of comma operator",
1369 case ICV_LEFT_OF_COMMA
:
1370 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1371 "not be accessed in left operand of comma operator",
1375 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1376 "not be accessed in statement", expr
, type
);
1378 case ICV_THIRD_IN_FOR
:
1379 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1380 "not be accessed in for increment expression",
1391 /* Don't bother with the temporary object returned from a function if
1392 we don't use it, don't need to destroy it, and won't abort in
1393 assign_temp. We'll still
1394 allocate space for it in expand_call or declare_return_variable,
1395 but we don't need to track it through all the tree phases. */
1396 if (TARGET_EXPR_IMPLICIT_P (expr
)
1397 && !TREE_ADDRESSABLE (TREE_TYPE (expr
)))
1399 tree init
= TARGET_EXPR_INITIAL (expr
);
1400 if (TREE_CODE (init
) == AGGR_INIT_EXPR
1401 && !AGGR_INIT_VIA_CTOR_P (init
))
1403 tree fn
= AGGR_INIT_EXPR_FN (init
);
1404 expr
= build_call_array_loc (input_location
,
1405 TREE_TYPE (TREE_TYPE
1408 aggr_init_expr_nargs (init
),
1409 AGGR_INIT_EXPR_ARGP (init
));
1412 maybe_warn_nodiscard (expr
, implicit
);
1417 expr
= resolve_nondeduced_context (expr
, complain
);
1421 if (TREE_CODE (probe
) == ADDR_EXPR
)
1422 probe
= TREE_OPERAND (expr
, 0);
1423 if (type_unknown_p (probe
))
1425 /* [over.over] enumerates the places where we can take the address
1426 of an overloaded function, and this is not one of them. */
1427 if (complain
& tf_error
)
1431 error_at (loc
, "conversion to void "
1432 "cannot resolve address of overloaded function");
1434 case ICV_SECOND_OF_COND
:
1435 error_at (loc
, "second operand of conditional expression "
1436 "cannot resolve address of overloaded function");
1438 case ICV_THIRD_OF_COND
:
1439 error_at (loc
, "third operand of conditional expression "
1440 "cannot resolve address of overloaded function");
1442 case ICV_RIGHT_OF_COMMA
:
1443 error_at (loc
, "right operand of comma operator "
1444 "cannot resolve address of overloaded function");
1446 case ICV_LEFT_OF_COMMA
:
1447 error_at (loc
, "left operand of comma operator "
1448 "cannot resolve address of overloaded function");
1451 error_at (loc
, "statement "
1452 "cannot resolve address of overloaded function");
1454 case ICV_THIRD_IN_FOR
:
1455 error_at (loc
, "for increment expression "
1456 "cannot resolve address of overloaded function");
1460 return error_mark_node
;
1463 else if (implicit
!= ICV_CAST
&& probe
== expr
&& is_overloaded_fn (probe
))
1465 /* Only warn when there is no &. */
1466 if (complain
& tf_warning
)
1469 case ICV_SECOND_OF_COND
:
1470 warning_at (loc
, OPT_Waddress
,
1471 "second operand of conditional expression "
1472 "is a reference, not call, to function %qE", expr
);
1474 case ICV_THIRD_OF_COND
:
1475 warning_at (loc
, OPT_Waddress
,
1476 "third operand of conditional expression "
1477 "is a reference, not call, to function %qE", expr
);
1479 case ICV_RIGHT_OF_COMMA
:
1480 warning_at (loc
, OPT_Waddress
,
1481 "right operand of comma operator "
1482 "is a reference, not call, to function %qE", expr
);
1484 case ICV_LEFT_OF_COMMA
:
1485 warning_at (loc
, OPT_Waddress
,
1486 "left operand of comma operator "
1487 "is a reference, not call, to function %qE", expr
);
1490 warning_at (loc
, OPT_Waddress
,
1491 "statement is a reference, not call, to function %qE",
1494 case ICV_THIRD_IN_FOR
:
1495 warning_at (loc
, OPT_Waddress
,
1496 "for increment expression "
1497 "is a reference, not call, to function %qE", expr
);
1503 if (TREE_CODE (expr
) == COMPONENT_REF
)
1504 expr
= TREE_OPERAND (expr
, 0);
1508 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1510 if (implicit
!= ICV_CAST
1511 && warn_unused_value
1512 && !TREE_NO_WARNING (expr
)
1513 && !processing_template_decl
)
1515 /* The middle end does not warn about expressions that have
1516 been explicitly cast to void, so we must do so here. */
1517 if (!TREE_SIDE_EFFECTS (expr
)) {
1518 if (complain
& tf_warning
)
1521 case ICV_SECOND_OF_COND
:
1522 warning_at (loc
, OPT_Wunused_value
,
1523 "second operand of conditional expression "
1526 case ICV_THIRD_OF_COND
:
1527 warning_at (loc
, OPT_Wunused_value
,
1528 "third operand of conditional expression "
1531 case ICV_RIGHT_OF_COMMA
:
1532 warning_at (loc
, OPT_Wunused_value
,
1533 "right operand of comma operator has no effect");
1535 case ICV_LEFT_OF_COMMA
:
1536 warning_at (loc
, OPT_Wunused_value
,
1537 "left operand of comma operator has no effect");
1540 warning_at (loc
, OPT_Wunused_value
,
1541 "statement has no effect");
1543 case ICV_THIRD_IN_FOR
:
1544 warning_at (loc
, OPT_Wunused_value
,
1545 "for increment expression has no effect");
1554 enum tree_code code
;
1555 enum tree_code_class tclass
;
1558 /* We might like to warn about (say) "(int) f()", as the
1559 cast has no effect, but the compiler itself will
1560 generate implicit conversions under some
1561 circumstances. (For example a block copy will be
1562 turned into a call to "__builtin_memcpy", with a
1563 conversion of the return value to an appropriate
1564 type.) So, to avoid false positives, we strip
1565 conversions. Do not use STRIP_NOPs because it will
1566 not strip conversions to "void", as that is not a
1567 mode-preserving conversion. */
1568 while (TREE_CODE (e
) == NOP_EXPR
)
1569 e
= TREE_OPERAND (e
, 0);
1571 code
= TREE_CODE (e
);
1572 tclass
= TREE_CODE_CLASS (code
);
1573 if ((tclass
== tcc_comparison
1574 || tclass
== tcc_unary
1575 || (tclass
== tcc_binary
1576 && !(code
== MODIFY_EXPR
1577 || code
== INIT_EXPR
1578 || code
== PREDECREMENT_EXPR
1579 || code
== PREINCREMENT_EXPR
1580 || code
== POSTDECREMENT_EXPR
1581 || code
== POSTINCREMENT_EXPR
))
1582 || code
== VEC_PERM_EXPR
1583 || code
== VEC_COND_EXPR
)
1584 && (complain
& tf_warning
))
1585 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1588 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
1590 if (! TREE_SIDE_EFFECTS (expr
))
1595 /* Create an expression whose value is that of EXPR,
1596 converted to type TYPE. The TREE_TYPE of the value
1597 is always TYPE. This function implements all reasonable
1598 conversions; callers should filter out those that are
1599 not permitted by the language being compiled.
1601 Most of this routine is from build_reinterpret_cast.
1603 The back end cannot call cp_convert (what was convert) because
1604 conversions to/from basetypes may involve memory references
1605 (vbases) and adding or subtracting small values (multiple
1606 inheritance), but it calls convert from the constant folding code
1607 on subtrees of already built trees after it has ripped them apart.
1609 Also, if we ever support range variables, we'll probably also have to
1610 do a little bit more work. */
1613 convert (tree type
, tree expr
)
1617 if (type
== error_mark_node
|| expr
== error_mark_node
)
1618 return error_mark_node
;
1620 intype
= TREE_TYPE (expr
);
1622 if (INDIRECT_TYPE_P (type
) && INDIRECT_TYPE_P (intype
))
1623 return build_nop (type
, expr
);
1625 return ocp_convert (type
, expr
, CONV_BACKEND_CONVERT
,
1626 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
1627 tf_warning_or_error
);
1630 /* Like cp_convert, except permit conversions to take place which
1631 are not normally allowed due to access restrictions
1632 (such as conversion from sub-type to private super-type). */
1635 convert_force (tree type
, tree expr
, int convtype
, tsubst_flags_t complain
)
1638 enum tree_code code
= TREE_CODE (type
);
1640 if (code
== REFERENCE_TYPE
)
1641 return convert_to_reference (type
, e
, CONV_C_CAST
, 0,
1642 NULL_TREE
, complain
);
1644 if (code
== POINTER_TYPE
)
1645 return convert_to_pointer_force (type
, e
, complain
);
1647 /* From typeck.c convert_for_assignment */
1648 if (((TYPE_PTR_P (TREE_TYPE (e
)) && TREE_CODE (e
) == ADDR_EXPR
1649 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1650 || integer_zerop (e
)
1651 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1652 && TYPE_PTRMEMFUNC_P (type
))
1653 /* compatible pointer to member functions. */
1654 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1,
1655 /*c_cast_p=*/1, complain
);
1657 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
, complain
);
1660 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1661 exists, return the attempted conversion. This may
1662 return ERROR_MARK_NODE if the conversion is not
1663 allowed (references private members, etc).
1664 If no conversion exists, NULL_TREE is returned.
1666 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1667 object parameter, or by the second standard conversion sequence if
1668 that doesn't do it. This will probably wait for an overloading rewrite.
1672 build_type_conversion (tree xtype
, tree expr
)
1674 /* C++: check to see if we can convert this aggregate type
1675 into the required type. */
1676 return build_user_type_conversion (xtype
, expr
, LOOKUP_NORMAL
,
1677 tf_warning_or_error
);
1680 /* Convert the given EXPR to one of a group of types suitable for use in an
1681 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1682 which indicates which types are suitable. If COMPLAIN is true, complain
1683 about ambiguity; otherwise, the caller will deal with it. */
1686 build_expr_type_conversion (int desires
, tree expr
, bool complain
)
1688 tree basetype
= TREE_TYPE (expr
);
1689 tree conv
= NULL_TREE
;
1690 tree winner
= NULL_TREE
;
1692 if (null_node_p (expr
)
1693 && (desires
& WANT_INT
)
1694 && !(desires
& WANT_NULL
))
1697 expansion_point_location_if_in_system_header (input_location
);
1699 warning_at (loc
, OPT_Wconversion_null
,
1700 "converting NULL to non-pointer type");
1703 if (basetype
== error_mark_node
)
1704 return error_mark_node
;
1706 if (! MAYBE_CLASS_TYPE_P (basetype
))
1707 switch (TREE_CODE (basetype
))
1710 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1715 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1717 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1719 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1721 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1725 return (desires
& WANT_POINTER
) ? decay_conversion (expr
,
1726 tf_warning_or_error
)
1731 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1733 switch (TREE_CODE (TREE_TYPE (basetype
)))
1737 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1739 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1741 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1750 /* The code for conversions from class type is currently only used for
1751 delete expressions. Other expressions are handled by build_new_op. */
1752 if (!complete_type_or_maybe_complain (basetype
, expr
, complain
))
1753 return error_mark_node
;
1754 if (!TYPE_HAS_CONVERSION (basetype
))
1757 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1761 tree cand
= TREE_VALUE (conv
);
1762 cand
= OVL_FIRST (cand
);
1764 if (winner
&& winner
== cand
)
1767 if (DECL_NONCONVERTING_P (cand
))
1770 candidate
= non_reference (TREE_TYPE (TREE_TYPE (cand
)));
1772 switch (TREE_CODE (candidate
))
1776 win
= (desires
& WANT_INT
); break;
1778 win
= (desires
& WANT_ENUM
); break;
1780 win
= (desires
& WANT_FLOAT
); break;
1782 win
= (desires
& WANT_POINTER
); break;
1786 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1788 switch (TREE_CODE (TREE_TYPE (candidate
)))
1792 win
= (desires
& WANT_INT
); break;
1794 win
= (desires
& WANT_ENUM
); break;
1796 win
= (desires
& WANT_FLOAT
); break;
1803 /* A wildcard could be instantiated to match any desired
1804 type, but we can't deduce the template argument. */
1805 if (WILDCARD_TYPE_P (candidate
))
1812 if (TREE_CODE (cand
) == TEMPLATE_DECL
)
1815 error ("default type conversion can't deduce template"
1816 " argument for %qD", cand
);
1817 return error_mark_node
;
1823 = non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1825 if (!same_type_ignoring_top_level_qualifiers_p (winner_type
,
1830 error ("ambiguous default type conversion from %qT",
1832 inform (input_location
,
1833 " candidate conversions include %qD and %qD",
1836 return error_mark_node
;
1846 tree type
= non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1847 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
,
1848 tf_warning_or_error
);
1854 /* Implements integral promotion (4.1) and float->double promotion. */
1857 type_promotes_to (tree type
)
1861 if (type
== error_mark_node
)
1862 return error_mark_node
;
1864 type
= TYPE_MAIN_VARIANT (type
);
1866 /* Check for promotions of target-defined types first. */
1867 promoted_type
= targetm
.promoted_type (type
);
1869 return promoted_type
;
1871 /* bool always promotes to int (not unsigned), even if it's the same
1873 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1874 type
= integer_type_node
;
1876 /* Normally convert enums to int, but convert wide enums to something
1877 wider. Scoped enums don't promote, but pretend they do for backward
1878 ABI bug compatibility wrt varargs. */
1879 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1880 || type
== char16_type_node
1881 || type
== char32_type_node
1882 || type
== wchar_type_node
)
1886 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1888 prom
= ENUM_UNDERLYING_TYPE (prom
);
1889 if (!ENUM_IS_SCOPED (type
)
1890 && ENUM_FIXED_UNDERLYING_TYPE_P (type
))
1892 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1893 whose underlying type is fixed (10.2) can be converted to a
1894 prvalue of its underlying type. Moreover, if integral promotion
1895 can be applied to its underlying type, a prvalue of an unscoped
1896 enumeration type whose underlying type is fixed can also be
1897 converted to a prvalue of the promoted underlying type. */
1898 return type_promotes_to (prom
);
1902 int precision
= MAX (TYPE_PRECISION (type
),
1903 TYPE_PRECISION (integer_type_node
));
1904 tree totype
= c_common_type_for_size (precision
, 0);
1905 if (TYPE_UNSIGNED (prom
)
1906 && ! int_fits_type_p (TYPE_MAX_VALUE (prom
), totype
))
1907 prom
= c_common_type_for_size (precision
, 1);
1910 if (SCOPED_ENUM_P (type
))
1912 if (abi_version_crosses (6)
1913 && TYPE_MODE (prom
) != TYPE_MODE (type
))
1914 warning (OPT_Wabi
, "scoped enum %qT passed through ... as "
1915 "%qT before -fabi-version=6, %qT after",
1916 type
, prom
, ENUM_UNDERLYING_TYPE (type
));
1917 if (!abi_version_at_least (6))
1923 else if (c_promoting_integer_type_p (type
))
1925 /* Retain unsignedness if really not getting bigger. */
1926 if (TYPE_UNSIGNED (type
)
1927 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1928 type
= unsigned_type_node
;
1930 type
= integer_type_node
;
1932 else if (type
== float_type_node
)
1933 type
= double_type_node
;
1938 /* The routines below this point are carefully written to conform to
1939 the standard. They use the same terminology, and follow the rules
1940 closely. Although they are used only in pt.c at the moment, they
1941 should presumably be used everywhere in the future. */
1943 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1944 Callers should check for identical types before calling this function. */
1947 can_convert_qual (tree type
, tree expr
)
1949 tree expr_type
= TREE_TYPE (expr
);
1950 gcc_assert (!same_type_p (type
, expr_type
));
1952 if (TYPE_PTR_P (type
) && TYPE_PTR_P (expr_type
))
1953 return comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (expr_type
));
1954 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (expr_type
))
1955 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
1956 TYPE_PTRMEM_CLASS_TYPE (expr_type
))
1957 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type
),
1958 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type
)));
1963 /* Attempt to perform qualification conversions on EXPR to convert it
1964 to TYPE. Return the resulting expression, or error_mark_node if
1965 the conversion was impossible. Since this is only used by
1966 convert_nontype_argument, we fold the conversion. */
1969 perform_qualification_conversions (tree type
, tree expr
)
1973 expr_type
= TREE_TYPE (expr
);
1975 if (same_type_p (type
, expr_type
))
1977 else if (can_convert_qual (type
, expr
))
1978 return cp_fold_convert (type
, expr
);
1980 return error_mark_node
;
1983 /* True iff T is a transaction-safe function type. */
1986 tx_safe_fn_type_p (tree t
)
1988 if (TREE_CODE (t
) != FUNCTION_TYPE
1989 && TREE_CODE (t
) != METHOD_TYPE
)
1991 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t
));
1994 /* Return the transaction-unsafe variant of transaction-safe function type
1998 tx_unsafe_fn_variant (tree t
)
2000 gcc_assert (tx_safe_fn_type_p (t
));
2001 tree attrs
= remove_attribute ("transaction_safe",
2002 TYPE_ATTRIBUTES (t
));
2003 return cp_build_type_attribute_variant (t
, attrs
);
2006 /* Return true iff FROM can convert to TO by a transaction-safety
2010 can_convert_tx_safety (tree to
, tree from
)
2012 return (flag_tm
&& tx_safe_fn_type_p (from
)
2013 && same_type_p (to
, tx_unsafe_fn_variant (from
)));
2016 /* Return true iff FROM can convert to TO by dropping noexcept. */
2019 noexcept_conv_p (tree to
, tree from
)
2021 if (!flag_noexcept_type
)
2024 tree t
= non_reference (to
);
2026 if (TYPE_PTRMEMFUNC_P (t
)
2027 && TYPE_PTRMEMFUNC_P (f
))
2029 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2030 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2038 tree_code code
= TREE_CODE (f
);
2039 if (TREE_CODE (t
) != code
)
2041 if (code
!= FUNCTION_TYPE
&& code
!= METHOD_TYPE
)
2043 if (!type_throw_all_p (t
)
2044 || type_throw_all_p (f
))
2046 tree v
= build_exception_variant (f
, NULL_TREE
);
2047 return same_type_p (t
, v
);
2050 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2053 fnptr_conv_p (tree to
, tree from
)
2055 tree t
= non_reference (to
);
2057 if (TYPE_PTRMEMFUNC_P (t
)
2058 && TYPE_PTRMEMFUNC_P (f
))
2060 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2061 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2070 return (noexcept_conv_p (t
, f
)
2071 || can_convert_tx_safety (t
, f
));
2074 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2075 conversions or conversions to the same type. */
2078 strip_fnptr_conv (tree fn
)
2080 while (TREE_CODE (fn
) == NOP_EXPR
)
2082 tree op
= TREE_OPERAND (fn
, 0);
2083 tree ft
= TREE_TYPE (fn
);
2084 tree ot
= TREE_TYPE (op
);
2085 if (same_type_p (ft
, ot
)
2086 || fnptr_conv_p (ft
, ot
))