1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2017 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
= 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 (POINTER_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 return convert_to_pointer_maybe_fold (type
, expr
, dofold
);
245 if (type_unknown_p (expr
))
246 return instantiate_type (type
, expr
, complain
);
248 if (complain
& tf_error
)
249 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
251 return error_mark_node
;
254 /* Like convert, except permit conversions to take place which
255 are not normally allowed due to access restrictions
256 (such as conversion from sub-type to private super-type). */
259 convert_to_pointer_force (tree type
, tree expr
, tsubst_flags_t complain
)
261 tree intype
= TREE_TYPE (expr
);
262 enum tree_code form
= TREE_CODE (intype
);
264 if (form
== POINTER_TYPE
)
266 intype
= TYPE_MAIN_VARIANT (intype
);
268 if (TYPE_MAIN_VARIANT (type
) != intype
269 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
270 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type
))
271 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype
))
272 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
274 enum tree_code code
= PLUS_EXPR
;
277 binfo
= lookup_base (TREE_TYPE (intype
), TREE_TYPE (type
),
278 ba_unique
, NULL
, complain
);
281 binfo
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
282 ba_unique
, NULL
, complain
);
285 if (binfo
== error_mark_node
)
286 return error_mark_node
;
289 expr
= build_base_path (code
, expr
, binfo
, 0, complain
);
290 if (expr
== error_mark_node
)
291 return error_mark_node
;
292 /* Add any qualifier conversions. */
293 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr
)),
295 expr
= build_nop (type
, expr
);
301 return cp_convert_to_pointer (type
, expr
, /*fold*/false, complain
);
304 /* We are passing something to a function which requires a reference.
305 The type we are interested in is in TYPE. The initial
306 value we have to begin with is in ARG.
308 FLAGS controls how we manage access checking.
309 DIRECT_BIND in FLAGS controls how any temporaries are generated.
310 If DIRECT_BIND is set, DECL is the reference we're binding to. */
313 build_up_reference (tree type
, tree arg
, int flags
, tree decl
,
314 tsubst_flags_t complain
)
317 tree argtype
= TREE_TYPE (arg
);
318 tree target_type
= TREE_TYPE (type
);
320 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
322 if ((flags
& DIRECT_BIND
) && ! lvalue_p (arg
))
324 /* Create a new temporary variable. We can't just use a TARGET_EXPR
325 here because it needs to live as long as DECL. */
328 arg
= make_temporary_var_for_ref_to_temp (decl
, target_type
);
330 /* Process the initializer for the declaration. */
331 DECL_INITIAL (arg
) = targ
;
332 cp_finish_decl (arg
, targ
, /*init_const_expr_p=*/false, NULL_TREE
,
333 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
335 else if (!(flags
& DIRECT_BIND
) && ! obvalue_p (arg
))
336 return get_target_expr_sfinae (arg
, complain
);
338 /* If we had a way to wrap this up, and say, if we ever needed its
339 address, transform all occurrences of the register, into a memory
340 reference we could win better. */
341 rval
= cp_build_addr_expr (arg
, complain
);
342 if (rval
== error_mark_node
)
343 return error_mark_node
;
345 if ((flags
& LOOKUP_PROTECT
)
346 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
347 && MAYBE_CLASS_TYPE_P (argtype
)
348 && MAYBE_CLASS_TYPE_P (target_type
))
350 /* We go through lookup_base for the access control. */
351 tree binfo
= lookup_base (argtype
, target_type
, ba_check
,
353 if (binfo
== error_mark_node
)
354 return error_mark_node
;
355 if (binfo
== NULL_TREE
)
356 return error_not_base_type (target_type
, argtype
);
357 rval
= build_base_path (PLUS_EXPR
, rval
, binfo
, 1, complain
);
361 = convert_to_pointer_force (build_pointer_type (target_type
),
363 return build_nop (type
, rval
);
366 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
367 INTYPE is the original rvalue type and DECL is an optional _DECL node
370 [dcl.init.ref] says that if an rvalue is used to
371 initialize a reference, then the reference must be to a
372 non-volatile const type. */
375 diagnose_ref_binding (location_t loc
, tree reftype
, tree intype
, tree decl
)
377 tree ttl
= TREE_TYPE (reftype
);
379 if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl
))
383 if (CP_TYPE_VOLATILE_P (ttl
) && decl
)
384 msg
= G_("initialization of volatile reference type %q#T from "
385 "rvalue of type %qT");
386 else if (CP_TYPE_VOLATILE_P (ttl
))
387 msg
= G_("conversion to volatile reference type %q#T "
388 "from rvalue of type %qT");
390 msg
= G_("initialization of non-const reference type %q#T from "
391 "rvalue of type %qT");
393 msg
= G_("conversion to non-const reference type %q#T from "
394 "rvalue of type %qT");
396 permerror (loc
, msg
, reftype
, intype
);
400 /* For C++: Only need to do one-level references, but cannot
401 get tripped up on signed/unsigned differences.
403 DECL is either NULL_TREE or the _DECL node for a reference that is being
404 initialized. It can be error_mark_node if we don't know the _DECL but
405 we know it's an initialization. */
408 convert_to_reference (tree reftype
, tree expr
, int convtype
,
409 int flags
, tree decl
, tsubst_flags_t complain
)
411 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
413 tree rval
= NULL_TREE
;
414 tree rval_as_conversion
= NULL_TREE
;
415 bool can_convert_intype_to_type
;
416 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
418 if (TREE_CODE (type
) == FUNCTION_TYPE
419 && TREE_TYPE (expr
) == unknown_type_node
)
420 expr
= instantiate_type (type
, expr
, complain
);
422 if (expr
== error_mark_node
)
423 return error_mark_node
;
425 intype
= TREE_TYPE (expr
);
427 gcc_assert (TREE_CODE (intype
) != REFERENCE_TYPE
);
428 gcc_assert (TREE_CODE (reftype
) == REFERENCE_TYPE
);
430 intype
= TYPE_MAIN_VARIANT (intype
);
432 can_convert_intype_to_type
= can_convert_standard (type
, intype
, complain
);
434 if (!can_convert_intype_to_type
435 && (convtype
& CONV_IMPLICIT
) && MAYBE_CLASS_TYPE_P (intype
)
436 && ! (flags
& LOOKUP_NO_CONVERSION
))
438 /* Look for a user-defined conversion to lvalue that we can use. */
441 = build_type_conversion (reftype
, expr
);
443 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
444 && lvalue_p (rval_as_conversion
))
446 expr
= rval_as_conversion
;
447 rval_as_conversion
= NULL_TREE
;
449 can_convert_intype_to_type
= 1;
453 if (((convtype
& CONV_STATIC
)
454 && can_convert_standard (intype
, type
, complain
))
455 || ((convtype
& CONV_IMPLICIT
) && can_convert_intype_to_type
))
458 tree ttl
= TREE_TYPE (reftype
);
459 tree ttr
= lvalue_type (expr
);
461 if ((complain
& tf_error
)
462 && ! lvalue_p (expr
))
463 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
465 if (! (convtype
& CONV_CONST
)
466 && !at_least_as_qualified_p (ttl
, ttr
))
468 if (complain
& tf_error
)
469 permerror (loc
, "conversion from %qH to %qI discards qualifiers",
472 return error_mark_node
;
476 return build_up_reference (reftype
, expr
, flags
, decl
, complain
);
478 else if ((convtype
& CONV_REINTERPRET
) && obvalue_p (expr
))
480 /* When casting an lvalue to a reference type, just convert into
481 a pointer to the new type and deference it. This is allowed
482 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
483 should be done directly (jason). (int &)ri ---> *(int*)&ri */
485 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
487 if ((complain
& tf_warning
)
488 && TYPE_PTR_P (intype
)
489 && (comptypes (TREE_TYPE (intype
), type
,
490 COMPARE_BASE
| COMPARE_DERIVED
)))
491 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
494 rval
= cp_build_addr_expr (expr
, complain
);
495 if (rval
!= error_mark_node
)
496 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)),
498 if (rval
!= error_mark_node
)
499 rval
= build1 (NOP_EXPR
, reftype
, rval
);
503 rval
= convert_for_initialization (NULL_TREE
, type
, expr
, flags
,
504 ICR_CONVERTING
, 0, 0, complain
);
505 if (rval
== NULL_TREE
|| rval
== error_mark_node
)
507 if (complain
& tf_error
)
508 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
509 rval
= build_up_reference (reftype
, rval
, flags
, decl
, complain
);
514 /* If we found a way to convert earlier, then use it. */
518 if (complain
& tf_error
)
519 error_at (loc
, "cannot convert type %qH to type %qI", intype
, reftype
);
521 return error_mark_node
;
524 /* We are using a reference VAL for its value. Bash that reference all the
525 way down to its lowest form. */
528 convert_from_reference (tree val
)
531 && TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
533 tree t
= TREE_TYPE (TREE_TYPE (val
));
534 tree ref
= build1 (INDIRECT_REF
, t
, val
);
537 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
538 so that we get the proper error message if the result is used
539 to assign to. Also, &* is supposed to be a no-op. */
540 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
541 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
542 TREE_SIDE_EFFECTS (ref
)
543 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (val
));
550 /* Really perform an lvalue-to-rvalue conversion, including copying an
551 argument of class type into a temporary. */
554 force_rvalue (tree expr
, tsubst_flags_t complain
)
556 tree type
= TREE_TYPE (expr
);
557 if (MAYBE_CLASS_TYPE_P (type
) && TREE_CODE (expr
) != TARGET_EXPR
)
559 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
560 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
561 &args
, type
, LOOKUP_NORMAL
, complain
);
562 release_tree_vector (args
);
563 expr
= build_cplus_new (type
, expr
, complain
);
566 expr
= decay_conversion (expr
, complain
);
572 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
573 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
577 ignore_overflows (tree expr
, tree orig
)
579 if (TREE_CODE (expr
) == INTEGER_CST
580 && TREE_CODE (orig
) == INTEGER_CST
581 && TREE_OVERFLOW (expr
) != TREE_OVERFLOW (orig
))
583 gcc_assert (!TREE_OVERFLOW (orig
));
584 /* Ensure constant sharing. */
585 expr
= wide_int_to_tree (TREE_TYPE (expr
), wi::to_wide (expr
));
590 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
594 cp_fold_convert (tree type
, tree expr
)
597 if (TREE_TYPE (expr
) == type
)
599 else if (TREE_CODE (expr
) == PTRMEM_CST
)
601 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
602 conv
= copy_node (expr
);
603 TREE_TYPE (conv
) = type
;
607 conv
= fold_convert (type
, expr
);
608 conv
= ignore_overflows (conv
, expr
);
613 /* C++ conversions, preference to static cast conversions. */
616 cp_convert (tree type
, tree expr
, tsubst_flags_t complain
)
618 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
, complain
);
621 /* C++ equivalent of convert_and_check but using cp_convert as the
624 Convert EXPR to TYPE, warning about conversion problems with constants.
625 Invoke this function on every expression that is converted implicitly,
626 i.e. because of language rules and not because of an explicit cast. */
629 cp_convert_and_check (tree type
, tree expr
, tsubst_flags_t complain
)
633 if (TREE_TYPE (expr
) == type
)
635 if (expr
== error_mark_node
)
637 result
= cp_convert (type
, expr
, complain
);
639 if ((complain
& tf_warning
)
640 && c_inhibit_evaluation_warnings
== 0)
642 tree folded
= cp_fully_fold (expr
);
645 folded_result
= result
;
648 /* Avoid bogus -Wparentheses warnings. */
649 warning_sentinel
w (warn_parentheses
);
650 warning_sentinel
c (warn_int_in_bool_context
);
651 folded_result
= cp_convert (type
, folded
, tf_none
);
653 folded_result
= fold_simple (folded_result
);
654 if (!TREE_OVERFLOW_P (folded
)
655 && folded_result
!= error_mark_node
)
656 warnings_for_convert_and_check (EXPR_LOC_OR_LOC (expr
, input_location
),
657 type
, folded
, folded_result
);
665 FLAGS indicates how we should behave. */
668 ocp_convert (tree type
, tree expr
, int convtype
, int flags
,
669 tsubst_flags_t complain
)
672 enum tree_code code
= TREE_CODE (type
);
673 const char *invalid_conv_diag
;
675 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
676 bool dofold
= (convtype
& CONV_FOLD
);
678 if (error_operand_p (e
) || type
== error_mark_node
)
679 return error_mark_node
;
681 complete_type (type
);
682 complete_type (TREE_TYPE (expr
));
684 if ((invalid_conv_diag
685 = targetm
.invalid_conversion (TREE_TYPE (expr
), type
)))
687 if (complain
& tf_error
)
688 error (invalid_conv_diag
);
689 return error_mark_node
;
692 /* FIXME remove when moving to c_fully_fold model. */
693 if (!CLASS_TYPE_P (type
))
694 e
= scalar_constant_value (e
);
695 if (error_operand_p (e
))
696 return error_mark_node
;
698 if (MAYBE_CLASS_TYPE_P (type
) && (convtype
& CONV_FORCE_TEMP
))
699 /* We need a new temporary; don't take this shortcut. */;
700 else if (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (e
)))
702 if (same_type_p (type
, TREE_TYPE (e
)))
703 /* The call to fold will not always remove the NOP_EXPR as
704 might be expected, since if one of the types is a typedef;
705 the comparison in fold is just equality of pointers, not a
706 call to comptypes. We don't call fold in this case because
707 that can result in infinite recursion; fold will call
708 convert, which will call ocp_convert, etc. */
710 /* For complex data types, we need to perform componentwise
712 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
713 return convert_to_complex_maybe_fold (type
, e
, dofold
);
714 else if (VECTOR_TYPE_P (type
))
715 return convert_to_vector (type
, e
);
716 else if (TREE_CODE (e
) == TARGET_EXPR
)
718 /* Don't build a NOP_EXPR of class type. Instead, change the
719 type of the temporary. */
720 TREE_TYPE (e
) = TREE_TYPE (TARGET_EXPR_SLOT (e
)) = type
;
725 /* We shouldn't be treating objects of ADDRESSABLE type as
727 gcc_assert (!TREE_ADDRESSABLE (type
));
728 return build_nop (type
, e
);
732 e1
= targetm
.convert_to_type (type
, e
);
736 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
738 e
= convert_to_void (e
, ICV_CAST
, complain
);
742 if (INTEGRAL_CODE_P (code
))
744 tree intype
= TREE_TYPE (e
);
747 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
749 /* enum = enum, enum = int, enum = float, (enum)pointer are all
751 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
752 || TREE_CODE (intype
) == REAL_TYPE
)
753 && ! (convtype
& CONV_STATIC
))
754 || TYPE_PTR_P (intype
))
756 if (complain
& tf_error
)
757 permerror (loc
, "conversion from %q#T to %q#T", intype
, type
);
759 return error_mark_node
;
762 /* [expr.static.cast]
764 8. A value of integral or enumeration type can be explicitly
765 converted to an enumeration type. The value is unchanged if
766 the original value is within the range of the enumeration
767 values. Otherwise, the resulting enumeration value is
769 if ((complain
& tf_warning
)
770 && TREE_CODE (e
) == INTEGER_CST
771 && ENUM_UNDERLYING_TYPE (type
)
772 && !int_fits_type_p (e
, ENUM_UNDERLYING_TYPE (type
)))
773 warning_at (loc
, OPT_Wconversion
,
774 "the result of the conversion is unspecified because "
775 "%qE is outside the range of type %qT",
778 if (MAYBE_CLASS_TYPE_P (intype
))
781 rval
= build_type_conversion (type
, e
);
784 if (complain
& tf_error
)
785 error_at (loc
, "%q#T used where a %qT was expected", intype
, type
);
786 return error_mark_node
;
788 if (code
== BOOLEAN_TYPE
)
790 if (VOID_TYPE_P (intype
))
792 if (complain
& tf_error
)
794 "could not convert %qE from %<void%> to %<bool%>",
796 return error_mark_node
;
799 /* We can't implicitly convert a scoped enum to bool, so convert
800 to the underlying type first. */
801 if (SCOPED_ENUM_P (intype
) && (convtype
& CONV_STATIC
))
802 e
= build_nop (ENUM_UNDERLYING_TYPE (intype
), e
);
803 if (complain
& tf_warning
)
804 return cp_truthvalue_conversion (e
);
807 /* Prevent bogus -Wint-in-bool-context warnings coming
808 from c_common_truthvalue_conversion down the line. */
809 warning_sentinel
w (warn_int_in_bool_context
);
810 return cp_truthvalue_conversion (e
);
814 converted
= convert_to_integer_maybe_fold (type
, e
, dofold
);
816 /* Ignore any integer overflow caused by the conversion. */
817 return ignore_overflows (converted
, e
);
819 if (NULLPTR_TYPE_P (type
) && e
&& null_ptr_cst_p (e
))
821 if (complain
& tf_warning
)
822 maybe_warn_zero_as_null_pointer_constant (e
, loc
);
825 if (POINTER_TYPE_P (type
) || TYPE_PTRMEM_P (type
))
826 return cp_convert_to_pointer (type
, e
, dofold
, complain
);
827 if (code
== VECTOR_TYPE
)
829 tree in_vtype
= TREE_TYPE (e
);
830 if (MAYBE_CLASS_TYPE_P (in_vtype
))
833 ret_val
= build_type_conversion (type
, e
);
836 if (complain
& tf_error
)
837 error_at (loc
, "%q#T used where a %qT was expected",
839 return error_mark_node
;
841 return convert_to_vector (type
, e
);
843 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
845 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e
)))
848 rval
= build_type_conversion (type
, e
);
851 else if (complain
& tf_error
)
853 "%q#T used where a floating point value was expected",
856 if (code
== REAL_TYPE
)
857 return convert_to_real_maybe_fold (type
, e
, dofold
);
858 else if (code
== COMPLEX_TYPE
)
859 return convert_to_complex_maybe_fold (type
, e
, dofold
);
862 /* New C++ semantics: since assignment is now based on
863 memberwise copying, if the rhs type is derived from the
864 lhs type, then we may still do a conversion. */
865 if (RECORD_OR_UNION_CODE_P (code
))
867 tree dtype
= TREE_TYPE (e
);
868 tree ctor
= NULL_TREE
;
870 dtype
= TYPE_MAIN_VARIANT (dtype
);
872 /* Conversion between aggregate types. New C++ semantics allow
873 objects of derived type to be cast to objects of base type.
874 Old semantics only allowed this between pointers.
876 There may be some ambiguity between using a constructor
877 vs. using a type conversion operator when both apply. */
881 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
882 return error_mark_node
;
884 if (BRACE_ENCLOSED_INITIALIZER_P (ctor
))
885 ctor
= perform_implicit_conversion (type
, ctor
, complain
);
886 else if ((flags
& LOOKUP_ONLYCONVERTING
)
887 && ! (CLASS_TYPE_P (dtype
) && DERIVED_FROM_P (type
, dtype
)))
888 /* For copy-initialization, first we create a temp of the proper type
889 with a user-defined conversion sequence, then we direct-initialize
890 the target with the temp (see [dcl.init]). */
891 ctor
= build_user_type_conversion (type
, ctor
, flags
, complain
);
894 vec
<tree
, va_gc
> *ctor_vec
= make_tree_vector_single (ctor
);
895 ctor
= build_special_member_call (NULL_TREE
,
896 complete_ctor_identifier
,
898 type
, flags
, complain
);
899 release_tree_vector (ctor_vec
);
902 return build_cplus_new (type
, ctor
, complain
);
905 if (complain
& tf_error
)
907 /* If the conversion failed and expr was an invalid use of pointer to
908 member function, try to report a meaningful error. */
909 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
910 /* We displayed the error message. */;
912 error_at (loc
, "conversion from %qH to non-scalar type %qI requested",
913 TREE_TYPE (expr
), type
);
915 return error_mark_node
;
918 /* If CALL is a call, return the callee; otherwise null. */
921 cp_get_callee (tree call
)
923 if (call
== NULL_TREE
)
925 else if (TREE_CODE (call
) == CALL_EXPR
)
926 return CALL_EXPR_FN (call
);
927 else if (TREE_CODE (call
) == AGGR_INIT_EXPR
)
928 return AGGR_INIT_EXPR_FN (call
);
932 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
936 cp_get_fndecl_from_callee (tree fn
)
940 if (TREE_CODE (fn
) == FUNCTION_DECL
)
942 tree type
= TREE_TYPE (fn
);
943 if (type
== unknown_type_node
)
945 gcc_assert (POINTER_TYPE_P (type
));
946 fn
= maybe_constant_init (fn
);
948 if (TREE_CODE (fn
) == ADDR_EXPR
)
950 fn
= TREE_OPERAND (fn
, 0);
951 if (TREE_CODE (fn
) == FUNCTION_DECL
)
957 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
958 constexpr machinery. */
961 cp_get_callee_fndecl (tree call
)
963 return cp_get_fndecl_from_callee (cp_get_callee (call
));
966 /* Subroutine of convert_to_void. Warn if we're discarding something with
967 attribute [[nodiscard]]. */
970 maybe_warn_nodiscard (tree expr
, impl_conv_void implicit
)
973 if (TREE_CODE (expr
) == TARGET_EXPR
)
974 call
= TARGET_EXPR_INITIAL (expr
);
975 location_t loc
= EXPR_LOC_OR_LOC (call
, input_location
);
976 tree callee
= cp_get_callee (call
);
980 tree type
= TREE_TYPE (callee
);
981 if (TYPE_PTRMEMFUNC_P (type
))
982 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
983 if (POINTER_TYPE_P (type
))
984 type
= TREE_TYPE (type
);
986 tree rettype
= TREE_TYPE (type
);
987 tree fn
= cp_get_fndecl_from_callee (callee
);
988 if (implicit
!= ICV_CAST
&& fn
989 && lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn
)))
991 if (warning_at (loc
, OPT_Wunused_result
,
992 "ignoring return value of %qD, "
993 "declared with attribute nodiscard", fn
))
994 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
996 else if (implicit
!= ICV_CAST
997 && lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype
)))
999 if (warning_at (loc
, OPT_Wunused_result
,
1000 "ignoring returned value of type %qT, "
1001 "declared with attribute nodiscard", rettype
))
1004 inform (DECL_SOURCE_LOCATION (fn
),
1005 "in call to %qD, declared here", fn
);
1006 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype
)),
1007 "%qT declared here", rettype
);
1010 else if (TREE_CODE (expr
) == TARGET_EXPR
1011 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type
)))
1013 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1014 result is used, so handle that case here. */
1017 if (warning_at (loc
, OPT_Wunused_result
,
1018 "ignoring return value of %qD, "
1019 "declared with attribute warn_unused_result",
1021 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1024 warning_at (loc
, OPT_Wunused_result
,
1025 "ignoring return value of function "
1026 "declared with attribute warn_unused_result");
1030 /* When an expression is used in a void context, its value is discarded and
1031 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1032 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1033 in a void context. The C++ standard does not define what an `access' to an
1034 object is, but there is reason to believe that it is the lvalue to rvalue
1035 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1036 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1037 indicates that volatile semantics should be the same between C and C++
1038 where ever possible. C leaves it implementation defined as to what
1039 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1040 the volatile object `vp' points to, unless that is an incomplete type. For
1041 volatile references we do not do this interpretation, because that would
1042 make it impossible to ignore the reference return value from functions. We
1043 issue warnings in the confusing cases.
1045 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1046 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1047 indicates the context of the implicit conversion. */
1050 convert_to_void (tree expr
, impl_conv_void implicit
, tsubst_flags_t complain
)
1052 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
1054 if (expr
== error_mark_node
1055 || TREE_TYPE (expr
) == error_mark_node
)
1056 return error_mark_node
;
1058 if (implicit
== ICV_CAST
)
1059 mark_exp_read (expr
);
1064 while (TREE_CODE (exprv
) == COMPOUND_EXPR
)
1065 exprv
= TREE_OPERAND (exprv
, 1);
1067 || handled_component_p (exprv
)
1068 || INDIRECT_REF_P (exprv
))
1069 /* Expr is not being 'used' here, otherwise we whould have
1070 called mark_{rl}value_use use here, which would have in turn
1071 called mark_exp_read. Rather, we call mark_exp_read directly
1072 to avoid some warnings when
1073 -Wunused-but-set-{variable,parameter} is in effect. */
1074 mark_exp_read (exprv
);
1077 if (!TREE_TYPE (expr
))
1079 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
1080 return error_mark_node
;
1081 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
1083 if (complain
& tf_error
)
1084 error_at (loc
, "pseudo-destructor is not called");
1085 return error_mark_node
;
1087 if (VOID_TYPE_P (TREE_TYPE (expr
)))
1089 switch (TREE_CODE (expr
))
1093 /* The two parts of a cond expr might be separate lvalues. */
1094 tree op1
= TREE_OPERAND (expr
,1);
1095 tree op2
= TREE_OPERAND (expr
,2);
1096 bool side_effects
= ((op1
&& TREE_SIDE_EFFECTS (op1
))
1097 || TREE_SIDE_EFFECTS (op2
));
1098 tree new_op1
, new_op2
;
1099 new_op1
= NULL_TREE
;
1100 if (implicit
!= ICV_CAST
&& !side_effects
)
1103 new_op1
= convert_to_void (op1
, ICV_SECOND_OF_COND
, complain
);
1104 new_op2
= convert_to_void (op2
, ICV_THIRD_OF_COND
, complain
);
1109 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1110 new_op2
= convert_to_void (op2
, ICV_CAST
, complain
);
1113 expr
= build3 (COND_EXPR
, TREE_TYPE (new_op2
),
1114 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
1120 /* The second part of a compound expr contains the value. */
1121 tree op1
= TREE_OPERAND (expr
,1);
1123 if (implicit
!= ICV_CAST
&& !TREE_NO_WARNING (expr
))
1124 new_op1
= convert_to_void (op1
, ICV_RIGHT_OF_COMMA
, complain
);
1126 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1130 tree t
= build2 (COMPOUND_EXPR
, TREE_TYPE (new_op1
),
1131 TREE_OPERAND (expr
, 0), new_op1
);
1138 case NON_LVALUE_EXPR
:
1140 /* These have already decayed to rvalue. */
1143 case CALL_EXPR
: /* We have a special meaning for volatile void fn(). */
1144 maybe_warn_nodiscard (expr
, implicit
);
1149 tree type
= TREE_TYPE (expr
);
1150 int is_reference
= TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))
1152 int is_volatile
= TYPE_VOLATILE (type
);
1153 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1155 /* Can't load the value if we don't know the type. */
1156 if (is_volatile
&& !is_complete
)
1158 if (complain
& tf_warning
)
1162 warning_at (loc
, 0, "conversion to void will not access "
1163 "object of incomplete type %qT", type
);
1165 case ICV_SECOND_OF_COND
:
1166 warning_at (loc
, 0, "indirection will not access object of "
1167 "incomplete type %qT in second operand "
1168 "of conditional expression", type
);
1170 case ICV_THIRD_OF_COND
:
1171 warning_at (loc
, 0, "indirection will not access object of "
1172 "incomplete type %qT in third operand "
1173 "of conditional expression", type
);
1175 case ICV_RIGHT_OF_COMMA
:
1176 warning_at (loc
, 0, "indirection will not access object of "
1177 "incomplete type %qT in right operand of "
1178 "comma operator", type
);
1180 case ICV_LEFT_OF_COMMA
:
1181 warning_at (loc
, 0, "indirection will not access object of "
1182 "incomplete type %qT in left operand of "
1183 "comma operator", type
);
1186 warning_at (loc
, 0, "indirection will not access object of "
1187 "incomplete type %qT in statement", type
);
1189 case ICV_THIRD_IN_FOR
:
1190 warning_at (loc
, 0, "indirection will not access object of "
1191 "incomplete type %qT in for increment "
1192 "expression", type
);
1198 /* Don't load the value if this is an implicit dereference, or if
1199 the type needs to be handled by ctors/dtors. */
1200 else if (is_volatile
&& is_reference
)
1202 if (complain
& tf_warning
)
1206 warning_at (loc
, 0, "conversion to void will not access "
1207 "object of type %qT", type
);
1209 case ICV_SECOND_OF_COND
:
1210 warning_at (loc
, 0, "implicit dereference will not access "
1211 "object of type %qT in second operand of "
1212 "conditional expression", type
);
1214 case ICV_THIRD_OF_COND
:
1215 warning_at (loc
, 0, "implicit dereference will not access "
1216 "object of type %qT in third operand of "
1217 "conditional expression", type
);
1219 case ICV_RIGHT_OF_COMMA
:
1220 warning_at (loc
, 0, "implicit dereference will not access "
1221 "object of type %qT in right operand of "
1222 "comma operator", type
);
1224 case ICV_LEFT_OF_COMMA
:
1225 warning_at (loc
, 0, "implicit dereference will not access "
1226 "object of type %qT in left operand of comma "
1230 warning_at (loc
, 0, "implicit dereference will not access "
1231 "object of type %qT in statement", type
);
1233 case ICV_THIRD_IN_FOR
:
1234 warning_at (loc
, 0, "implicit dereference will not access "
1235 "object of type %qT in for increment expression",
1242 else if (is_volatile
&& TREE_ADDRESSABLE (type
))
1244 if (complain
& tf_warning
)
1248 warning_at (loc
, 0, "conversion to void will not access "
1249 "object of non-trivially-copyable type %qT",
1252 case ICV_SECOND_OF_COND
:
1253 warning_at (loc
, 0, "indirection will not access object of "
1254 "non-trivially-copyable type %qT in second "
1255 "operand of conditional expression", type
);
1257 case ICV_THIRD_OF_COND
:
1258 warning_at (loc
, 0, "indirection will not access object of "
1259 "non-trivially-copyable type %qT in third "
1260 "operand of conditional expression", type
);
1262 case ICV_RIGHT_OF_COMMA
:
1263 warning_at (loc
, 0, "indirection will not access object of "
1264 "non-trivially-copyable type %qT in right "
1265 "operand of comma operator", type
);
1267 case ICV_LEFT_OF_COMMA
:
1268 warning_at (loc
, 0, "indirection will not access object of "
1269 "non-trivially-copyable type %qT in left "
1270 "operand of comma operator", type
);
1273 warning_at (loc
, 0, "indirection will not access object of "
1274 "non-trivially-copyable type %qT in statement",
1277 case ICV_THIRD_IN_FOR
:
1278 warning_at (loc
, 0, "indirection will not access object of "
1279 "non-trivially-copyable type %qT in for "
1280 "increment expression", type
);
1286 if (is_reference
|| !is_volatile
|| !is_complete
|| TREE_ADDRESSABLE (type
))
1288 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1289 operation is stripped off. Note that we don't warn about
1290 - an expression with TREE_NO_WARNING set. (For an example of
1291 such expressions, see build_over_call in call.c.)
1292 - automatic dereferencing of references, since the user cannot
1293 control it. (See also warn_if_unused_value() in c-common.c.) */
1294 if (warn_unused_value
1295 && implicit
!= ICV_CAST
1296 && (complain
& tf_warning
)
1297 && !TREE_NO_WARNING (expr
)
1299 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1300 expr
= TREE_OPERAND (expr
, 0);
1301 if (TREE_CODE (expr
) == CALL_EXPR
)
1302 maybe_warn_nodiscard (expr
, implicit
);
1310 /* External variables might be incomplete. */
1311 tree type
= TREE_TYPE (expr
);
1312 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1314 if (TYPE_VOLATILE (type
) && !is_complete
&& (complain
& tf_warning
))
1318 warning_at (loc
, 0, "conversion to void will not access "
1319 "object %qE of incomplete type %qT", expr
, type
);
1321 case ICV_SECOND_OF_COND
:
1322 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1323 "not be accessed in second operand of "
1324 "conditional expression", expr
, type
);
1326 case ICV_THIRD_OF_COND
:
1327 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1328 "not be accessed in third operand of "
1329 "conditional expression", expr
, type
);
1331 case ICV_RIGHT_OF_COMMA
:
1332 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1333 "not be accessed in right operand of comma operator",
1336 case ICV_LEFT_OF_COMMA
:
1337 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1338 "not be accessed in left operand of comma operator",
1342 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1343 "not be accessed in statement", expr
, type
);
1345 case ICV_THIRD_IN_FOR
:
1346 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1347 "not be accessed in for increment expression",
1358 /* Don't bother with the temporary object returned from a function if
1359 we don't use it, don't need to destroy it, and won't abort in
1360 assign_temp. We'll still
1361 allocate space for it in expand_call or declare_return_variable,
1362 but we don't need to track it through all the tree phases. */
1363 if (TARGET_EXPR_IMPLICIT_P (expr
)
1364 && !TREE_ADDRESSABLE (TREE_TYPE (expr
)))
1366 tree init
= TARGET_EXPR_INITIAL (expr
);
1367 if (TREE_CODE (init
) == AGGR_INIT_EXPR
1368 && !AGGR_INIT_VIA_CTOR_P (init
))
1370 tree fn
= AGGR_INIT_EXPR_FN (init
);
1371 expr
= build_call_array_loc (input_location
,
1372 TREE_TYPE (TREE_TYPE
1375 aggr_init_expr_nargs (init
),
1376 AGGR_INIT_EXPR_ARGP (init
));
1379 maybe_warn_nodiscard (expr
, implicit
);
1384 expr
= resolve_nondeduced_context (expr
, complain
);
1388 if (TREE_CODE (probe
) == ADDR_EXPR
)
1389 probe
= TREE_OPERAND (expr
, 0);
1390 if (type_unknown_p (probe
))
1392 /* [over.over] enumerates the places where we can take the address
1393 of an overloaded function, and this is not one of them. */
1394 if (complain
& tf_error
)
1398 error_at (loc
, "conversion to void "
1399 "cannot resolve address of overloaded function");
1401 case ICV_SECOND_OF_COND
:
1402 error_at (loc
, "second operand of conditional expression "
1403 "cannot resolve address of overloaded function");
1405 case ICV_THIRD_OF_COND
:
1406 error_at (loc
, "third operand of conditional expression "
1407 "cannot resolve address of overloaded function");
1409 case ICV_RIGHT_OF_COMMA
:
1410 error_at (loc
, "right operand of comma operator "
1411 "cannot resolve address of overloaded function");
1413 case ICV_LEFT_OF_COMMA
:
1414 error_at (loc
, "left operand of comma operator "
1415 "cannot resolve address of overloaded function");
1418 error_at (loc
, "statement "
1419 "cannot resolve address of overloaded function");
1421 case ICV_THIRD_IN_FOR
:
1422 error_at (loc
, "for increment expression "
1423 "cannot resolve address of overloaded function");
1427 return error_mark_node
;
1430 else if (implicit
!= ICV_CAST
&& probe
== expr
&& is_overloaded_fn (probe
))
1432 /* Only warn when there is no &. */
1433 if (complain
& tf_warning
)
1436 case ICV_SECOND_OF_COND
:
1437 warning_at (loc
, OPT_Waddress
,
1438 "second operand of conditional expression "
1439 "is a reference, not call, to function %qE", expr
);
1441 case ICV_THIRD_OF_COND
:
1442 warning_at (loc
, OPT_Waddress
,
1443 "third operand of conditional expression "
1444 "is a reference, not call, to function %qE", expr
);
1446 case ICV_RIGHT_OF_COMMA
:
1447 warning_at (loc
, OPT_Waddress
,
1448 "right operand of comma operator "
1449 "is a reference, not call, to function %qE", expr
);
1451 case ICV_LEFT_OF_COMMA
:
1452 warning_at (loc
, OPT_Waddress
,
1453 "left operand of comma operator "
1454 "is a reference, not call, to function %qE", expr
);
1457 warning_at (loc
, OPT_Waddress
,
1458 "statement is a reference, not call, to function %qE",
1461 case ICV_THIRD_IN_FOR
:
1462 warning_at (loc
, OPT_Waddress
,
1463 "for increment expression "
1464 "is a reference, not call, to function %qE", expr
);
1470 if (TREE_CODE (expr
) == COMPONENT_REF
)
1471 expr
= TREE_OPERAND (expr
, 0);
1475 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1477 if (implicit
!= ICV_CAST
1478 && warn_unused_value
1479 && !TREE_NO_WARNING (expr
)
1480 && !processing_template_decl
)
1482 /* The middle end does not warn about expressions that have
1483 been explicitly cast to void, so we must do so here. */
1484 if (!TREE_SIDE_EFFECTS (expr
)) {
1485 if (complain
& tf_warning
)
1488 case ICV_SECOND_OF_COND
:
1489 warning_at (loc
, OPT_Wunused_value
,
1490 "second operand of conditional expression "
1493 case ICV_THIRD_OF_COND
:
1494 warning_at (loc
, OPT_Wunused_value
,
1495 "third operand of conditional expression "
1498 case ICV_RIGHT_OF_COMMA
:
1499 warning_at (loc
, OPT_Wunused_value
,
1500 "right operand of comma operator has no effect");
1502 case ICV_LEFT_OF_COMMA
:
1503 warning_at (loc
, OPT_Wunused_value
,
1504 "left operand of comma operator has no effect");
1507 warning_at (loc
, OPT_Wunused_value
,
1508 "statement has no effect");
1510 case ICV_THIRD_IN_FOR
:
1511 warning_at (loc
, OPT_Wunused_value
,
1512 "for increment expression has no effect");
1521 enum tree_code code
;
1522 enum tree_code_class tclass
;
1525 /* We might like to warn about (say) "(int) f()", as the
1526 cast has no effect, but the compiler itself will
1527 generate implicit conversions under some
1528 circumstances. (For example a block copy will be
1529 turned into a call to "__builtin_memcpy", with a
1530 conversion of the return value to an appropriate
1531 type.) So, to avoid false positives, we strip
1532 conversions. Do not use STRIP_NOPs because it will
1533 not strip conversions to "void", as that is not a
1534 mode-preserving conversion. */
1535 while (TREE_CODE (e
) == NOP_EXPR
)
1536 e
= TREE_OPERAND (e
, 0);
1538 code
= TREE_CODE (e
);
1539 tclass
= TREE_CODE_CLASS (code
);
1540 if ((tclass
== tcc_comparison
1541 || tclass
== tcc_unary
1542 || (tclass
== tcc_binary
1543 && !(code
== MODIFY_EXPR
1544 || code
== INIT_EXPR
1545 || code
== PREDECREMENT_EXPR
1546 || code
== PREINCREMENT_EXPR
1547 || code
== POSTDECREMENT_EXPR
1548 || code
== POSTINCREMENT_EXPR
))
1549 || code
== VEC_PERM_EXPR
1550 || code
== VEC_COND_EXPR
)
1551 && (complain
& tf_warning
))
1552 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1555 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
1557 if (! TREE_SIDE_EFFECTS (expr
))
1562 /* Create an expression whose value is that of EXPR,
1563 converted to type TYPE. The TREE_TYPE of the value
1564 is always TYPE. This function implements all reasonable
1565 conversions; callers should filter out those that are
1566 not permitted by the language being compiled.
1568 Most of this routine is from build_reinterpret_cast.
1570 The back end cannot call cp_convert (what was convert) because
1571 conversions to/from basetypes may involve memory references
1572 (vbases) and adding or subtracting small values (multiple
1573 inheritance), but it calls convert from the constant folding code
1574 on subtrees of already built trees after it has ripped them apart.
1576 Also, if we ever support range variables, we'll probably also have to
1577 do a little bit more work. */
1580 convert (tree type
, tree expr
)
1584 if (type
== error_mark_node
|| expr
== error_mark_node
)
1585 return error_mark_node
;
1587 intype
= TREE_TYPE (expr
);
1589 if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (intype
))
1590 return build_nop (type
, expr
);
1592 return ocp_convert (type
, expr
, CONV_BACKEND_CONVERT
,
1593 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
1594 tf_warning_or_error
);
1597 /* Like cp_convert, except permit conversions to take place which
1598 are not normally allowed due to access restrictions
1599 (such as conversion from sub-type to private super-type). */
1602 convert_force (tree type
, tree expr
, int convtype
, tsubst_flags_t complain
)
1605 enum tree_code code
= TREE_CODE (type
);
1607 if (code
== REFERENCE_TYPE
)
1608 return convert_to_reference (type
, e
, CONV_C_CAST
, 0,
1609 NULL_TREE
, complain
);
1611 if (code
== POINTER_TYPE
)
1612 return convert_to_pointer_force (type
, e
, complain
);
1614 /* From typeck.c convert_for_assignment */
1615 if (((TYPE_PTR_P (TREE_TYPE (e
)) && TREE_CODE (e
) == ADDR_EXPR
1616 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1617 || integer_zerop (e
)
1618 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1619 && TYPE_PTRMEMFUNC_P (type
))
1620 /* compatible pointer to member functions. */
1621 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1,
1622 /*c_cast_p=*/1, complain
);
1624 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
, complain
);
1627 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1628 exists, return the attempted conversion. This may
1629 return ERROR_MARK_NODE if the conversion is not
1630 allowed (references private members, etc).
1631 If no conversion exists, NULL_TREE is returned.
1633 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1634 object parameter, or by the second standard conversion sequence if
1635 that doesn't do it. This will probably wait for an overloading rewrite.
1639 build_type_conversion (tree xtype
, tree expr
)
1641 /* C++: check to see if we can convert this aggregate type
1642 into the required type. */
1643 return build_user_type_conversion (xtype
, expr
, LOOKUP_NORMAL
,
1644 tf_warning_or_error
);
1647 /* Convert the given EXPR to one of a group of types suitable for use in an
1648 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1649 which indicates which types are suitable. If COMPLAIN is true, complain
1650 about ambiguity; otherwise, the caller will deal with it. */
1653 build_expr_type_conversion (int desires
, tree expr
, bool complain
)
1655 tree basetype
= TREE_TYPE (expr
);
1656 tree conv
= NULL_TREE
;
1657 tree winner
= NULL_TREE
;
1659 if (expr
== null_node
1660 && (desires
& WANT_INT
)
1661 && !(desires
& WANT_NULL
))
1663 source_location loc
=
1664 expansion_point_location_if_in_system_header (input_location
);
1666 warning_at (loc
, OPT_Wconversion_null
,
1667 "converting NULL to non-pointer type");
1670 if (basetype
== error_mark_node
)
1671 return error_mark_node
;
1673 if (! MAYBE_CLASS_TYPE_P (basetype
))
1674 switch (TREE_CODE (basetype
))
1677 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1682 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1684 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1686 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1688 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1692 return (desires
& WANT_POINTER
) ? decay_conversion (expr
,
1693 tf_warning_or_error
)
1698 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1700 switch (TREE_CODE (TREE_TYPE (basetype
)))
1704 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1706 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1708 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1717 /* The code for conversions from class type is currently only used for
1718 delete expressions. Other expressions are handled by build_new_op. */
1719 if (!complete_type_or_maybe_complain (basetype
, expr
, complain
))
1720 return error_mark_node
;
1721 if (!TYPE_HAS_CONVERSION (basetype
))
1724 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1728 tree cand
= TREE_VALUE (conv
);
1729 cand
= OVL_FIRST (cand
);
1731 if (winner
&& winner
== cand
)
1734 if (DECL_NONCONVERTING_P (cand
))
1737 candidate
= non_reference (TREE_TYPE (TREE_TYPE (cand
)));
1739 switch (TREE_CODE (candidate
))
1743 win
= (desires
& WANT_INT
); break;
1745 win
= (desires
& WANT_ENUM
); break;
1747 win
= (desires
& WANT_FLOAT
); break;
1749 win
= (desires
& WANT_POINTER
); break;
1753 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1755 switch (TREE_CODE (TREE_TYPE (candidate
)))
1759 win
= (desires
& WANT_INT
); break;
1761 win
= (desires
& WANT_ENUM
); break;
1763 win
= (desires
& WANT_FLOAT
); break;
1770 /* A wildcard could be instantiated to match any desired
1771 type, but we can't deduce the template argument. */
1772 if (WILDCARD_TYPE_P (candidate
))
1779 if (TREE_CODE (cand
) == TEMPLATE_DECL
)
1782 error ("default type conversion can't deduce template"
1783 " argument for %qD", cand
);
1784 return error_mark_node
;
1790 = non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1792 if (!same_type_ignoring_top_level_qualifiers_p (winner_type
,
1797 error ("ambiguous default type conversion from %qT",
1799 inform (input_location
,
1800 " candidate conversions include %qD and %qD",
1803 return error_mark_node
;
1813 tree type
= non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1814 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
,
1815 tf_warning_or_error
);
1821 /* Implements integral promotion (4.1) and float->double promotion. */
1824 type_promotes_to (tree type
)
1828 if (type
== error_mark_node
)
1829 return error_mark_node
;
1831 type
= TYPE_MAIN_VARIANT (type
);
1833 /* Check for promotions of target-defined types first. */
1834 promoted_type
= targetm
.promoted_type (type
);
1836 return promoted_type
;
1838 /* bool always promotes to int (not unsigned), even if it's the same
1840 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1841 type
= integer_type_node
;
1843 /* Normally convert enums to int, but convert wide enums to something
1844 wider. Scoped enums don't promote, but pretend they do for backward
1845 ABI bug compatibility wrt varargs. */
1846 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1847 || type
== char16_type_node
1848 || type
== char32_type_node
1849 || type
== wchar_type_node
)
1851 int precision
= MAX (TYPE_PRECISION (type
),
1852 TYPE_PRECISION (integer_type_node
));
1853 tree totype
= c_common_type_for_size (precision
, 0);
1855 if (TREE_CODE (prom
) == ENUMERAL_TYPE
)
1856 prom
= ENUM_UNDERLYING_TYPE (prom
);
1857 if (TYPE_UNSIGNED (prom
)
1858 && ! int_fits_type_p (TYPE_MAX_VALUE (prom
), totype
))
1859 prom
= c_common_type_for_size (precision
, 1);
1862 if (SCOPED_ENUM_P (type
))
1864 if (abi_version_crosses (6)
1865 && TYPE_MODE (prom
) != TYPE_MODE (type
))
1866 warning (OPT_Wabi
, "scoped enum %qT passed through ... as "
1867 "%qT before -fabi-version=6, %qT after",
1868 type
, prom
, ENUM_UNDERLYING_TYPE (type
));
1869 if (!abi_version_at_least (6))
1875 else if (c_promoting_integer_type_p (type
))
1877 /* Retain unsignedness if really not getting bigger. */
1878 if (TYPE_UNSIGNED (type
)
1879 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1880 type
= unsigned_type_node
;
1882 type
= integer_type_node
;
1884 else if (type
== float_type_node
)
1885 type
= double_type_node
;
1890 /* The routines below this point are carefully written to conform to
1891 the standard. They use the same terminology, and follow the rules
1892 closely. Although they are used only in pt.c at the moment, they
1893 should presumably be used everywhere in the future. */
1895 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1896 Callers should check for identical types before calling this function. */
1899 can_convert_qual (tree type
, tree expr
)
1901 tree expr_type
= TREE_TYPE (expr
);
1902 gcc_assert (!same_type_p (type
, expr_type
));
1904 if (TYPE_PTR_P (type
) && TYPE_PTR_P (expr_type
))
1905 return comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (expr_type
));
1906 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (expr_type
))
1907 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
1908 TYPE_PTRMEM_CLASS_TYPE (expr_type
))
1909 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type
),
1910 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type
)));
1915 /* Attempt to perform qualification conversions on EXPR to convert it
1916 to TYPE. Return the resulting expression, or error_mark_node if
1917 the conversion was impossible. */
1920 perform_qualification_conversions (tree type
, tree expr
)
1924 expr_type
= TREE_TYPE (expr
);
1926 if (same_type_p (type
, expr_type
))
1928 else if (can_convert_qual (type
, expr
))
1929 return build_nop (type
, expr
);
1931 return error_mark_node
;
1934 /* True iff T is a transaction-safe function type. */
1937 tx_safe_fn_type_p (tree t
)
1939 if (TREE_CODE (t
) != FUNCTION_TYPE
1940 && TREE_CODE (t
) != METHOD_TYPE
)
1942 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t
));
1945 /* Return the transaction-unsafe variant of transaction-safe function type
1949 tx_unsafe_fn_variant (tree t
)
1951 gcc_assert (tx_safe_fn_type_p (t
));
1952 tree attrs
= remove_attribute ("transaction_safe",
1953 TYPE_ATTRIBUTES (t
));
1954 return cp_build_type_attribute_variant (t
, attrs
);
1957 /* Return true iff FROM can convert to TO by a transaction-safety
1961 can_convert_tx_safety (tree to
, tree from
)
1963 return (flag_tm
&& tx_safe_fn_type_p (from
)
1964 && same_type_p (to
, tx_unsafe_fn_variant (from
)));
1967 /* Return true iff FROM can convert to TO by dropping noexcept. */
1970 noexcept_conv_p (tree to
, tree from
)
1972 if (!flag_noexcept_type
)
1975 tree t
= non_reference (to
);
1977 if (TYPE_PTRMEMFUNC_P (t
)
1978 && TYPE_PTRMEMFUNC_P (f
))
1980 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
1981 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
1983 if (TREE_CODE (t
) == POINTER_TYPE
1984 && TREE_CODE (f
) == POINTER_TYPE
)
1989 tree_code code
= TREE_CODE (f
);
1990 if (TREE_CODE (t
) != code
)
1992 if (code
!= FUNCTION_TYPE
&& code
!= METHOD_TYPE
)
1994 if (!type_throw_all_p (t
)
1995 || type_throw_all_p (f
))
1997 tree v
= build_exception_variant (f
, NULL_TREE
);
1998 return same_type_p (t
, v
);
2001 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2004 fnptr_conv_p (tree to
, tree from
)
2006 tree t
= non_reference (to
);
2008 if (TYPE_PTRMEMFUNC_P (t
)
2009 && TYPE_PTRMEMFUNC_P (f
))
2011 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2012 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2014 if (TREE_CODE (t
) == POINTER_TYPE
2015 && TREE_CODE (f
) == POINTER_TYPE
)
2021 return (noexcept_conv_p (t
, f
)
2022 || can_convert_tx_safety (t
, f
));
2025 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2026 conversions or conversions to the same type. */
2029 strip_fnptr_conv (tree fn
)
2031 while (TREE_CODE (fn
) == NOP_EXPR
)
2033 tree op
= TREE_OPERAND (fn
, 0);
2034 tree ft
= TREE_TYPE (fn
);
2035 tree ot
= TREE_TYPE (op
);
2036 if (same_type_p (ft
, ot
)
2037 || fnptr_conv_p (ft
, ot
))