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
= 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 /* 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 (TREE_CODE (type
) == REFERENCE_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 (!CP_TYPE_CONST_NON_VOLATILE_P (ttl
))
388 if (CP_TYPE_VOLATILE_P (ttl
) && decl
)
389 msg
= G_("initialization of volatile reference type %q#T from "
390 "rvalue of type %qT");
391 else if (CP_TYPE_VOLATILE_P (ttl
))
392 msg
= G_("conversion to volatile reference type %q#T "
393 "from rvalue of type %qT");
395 msg
= G_("initialization of non-const reference type %q#T from "
396 "rvalue of type %qT");
398 msg
= G_("conversion to non-const reference type %q#T from "
399 "rvalue of type %qT");
401 permerror (loc
, msg
, reftype
, intype
);
405 /* For C++: Only need to do one-level references, but cannot
406 get tripped up on signed/unsigned differences.
408 DECL is either NULL_TREE or the _DECL node for a reference that is being
409 initialized. It can be error_mark_node if we don't know the _DECL but
410 we know it's an initialization. */
413 convert_to_reference (tree reftype
, tree expr
, int convtype
,
414 int flags
, tree decl
, tsubst_flags_t complain
)
416 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
418 tree rval
= NULL_TREE
;
419 tree rval_as_conversion
= NULL_TREE
;
420 bool can_convert_intype_to_type
;
421 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
423 if (TREE_CODE (type
) == FUNCTION_TYPE
424 && TREE_TYPE (expr
) == unknown_type_node
)
425 expr
= instantiate_type (type
, expr
, complain
);
427 if (expr
== error_mark_node
)
428 return error_mark_node
;
430 intype
= TREE_TYPE (expr
);
432 gcc_assert (TREE_CODE (intype
) != REFERENCE_TYPE
);
433 gcc_assert (TREE_CODE (reftype
) == REFERENCE_TYPE
);
435 intype
= TYPE_MAIN_VARIANT (intype
);
437 can_convert_intype_to_type
= can_convert_standard (type
, intype
, complain
);
439 if (!can_convert_intype_to_type
440 && (convtype
& CONV_IMPLICIT
) && MAYBE_CLASS_TYPE_P (intype
)
441 && ! (flags
& LOOKUP_NO_CONVERSION
))
443 /* Look for a user-defined conversion to lvalue that we can use. */
446 = build_type_conversion (reftype
, expr
);
448 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
449 && lvalue_p (rval_as_conversion
))
451 expr
= rval_as_conversion
;
452 rval_as_conversion
= NULL_TREE
;
454 can_convert_intype_to_type
= 1;
458 if (((convtype
& CONV_STATIC
)
459 && can_convert_standard (intype
, type
, complain
))
460 || ((convtype
& CONV_IMPLICIT
) && can_convert_intype_to_type
))
463 tree ttl
= TREE_TYPE (reftype
);
464 tree ttr
= lvalue_type (expr
);
466 if ((complain
& tf_error
)
467 && ! lvalue_p (expr
))
468 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
470 if (! (convtype
& CONV_CONST
)
471 && !at_least_as_qualified_p (ttl
, ttr
))
473 if (complain
& tf_error
)
474 permerror (loc
, "conversion from %qH to %qI discards qualifiers",
477 return error_mark_node
;
481 return build_up_reference (reftype
, expr
, flags
, decl
, complain
);
483 else if ((convtype
& CONV_REINTERPRET
) && obvalue_p (expr
))
485 /* When casting an lvalue to a reference type, just convert into
486 a pointer to the new type and deference it. This is allowed
487 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
488 should be done directly (jason). (int &)ri ---> *(int*)&ri */
490 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
492 if ((complain
& tf_warning
)
493 && TYPE_PTR_P (intype
)
494 && (comptypes (TREE_TYPE (intype
), type
,
495 COMPARE_BASE
| COMPARE_DERIVED
)))
496 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
499 rval
= cp_build_addr_expr (expr
, complain
);
500 if (rval
!= error_mark_node
)
501 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)),
503 if (rval
!= error_mark_node
)
504 rval
= build1 (NOP_EXPR
, reftype
, rval
);
508 rval
= convert_for_initialization (NULL_TREE
, type
, expr
, flags
,
509 ICR_CONVERTING
, 0, 0, complain
);
510 if (rval
== NULL_TREE
|| rval
== error_mark_node
)
512 if (complain
& tf_error
)
513 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
514 rval
= build_up_reference (reftype
, rval
, flags
, decl
, complain
);
519 /* If we found a way to convert earlier, then use it. */
523 if (complain
& tf_error
)
524 error_at (loc
, "cannot convert type %qH to type %qI", intype
, reftype
);
526 return error_mark_node
;
529 /* We are using a reference VAL for its value. Bash that reference all the
530 way down to its lowest form. */
533 convert_from_reference (tree val
)
536 && TREE_CODE (TREE_TYPE (val
)) == REFERENCE_TYPE
)
538 tree t
= TREE_TYPE (TREE_TYPE (val
));
539 tree ref
= build1 (INDIRECT_REF
, t
, val
);
542 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
543 so that we get the proper error message if the result is used
544 to assign to. Also, &* is supposed to be a no-op. */
545 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
546 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
547 TREE_SIDE_EFFECTS (ref
)
548 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (val
));
555 /* Really perform an lvalue-to-rvalue conversion, including copying an
556 argument of class type into a temporary. */
559 force_rvalue (tree expr
, tsubst_flags_t complain
)
561 tree type
= TREE_TYPE (expr
);
562 if (MAYBE_CLASS_TYPE_P (type
) && TREE_CODE (expr
) != TARGET_EXPR
)
564 vec
<tree
, va_gc
> *args
= make_tree_vector_single (expr
);
565 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
566 &args
, type
, LOOKUP_NORMAL
, complain
);
567 release_tree_vector (args
);
568 expr
= build_cplus_new (type
, expr
, complain
);
571 expr
= decay_conversion (expr
, complain
);
577 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
578 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
582 ignore_overflows (tree expr
, tree orig
)
584 if (TREE_CODE (expr
) == INTEGER_CST
585 && TREE_CODE (orig
) == INTEGER_CST
586 && TREE_OVERFLOW (expr
) != TREE_OVERFLOW (orig
))
588 gcc_assert (!TREE_OVERFLOW (orig
));
589 /* Ensure constant sharing. */
590 expr
= wide_int_to_tree (TREE_TYPE (expr
), wi::to_wide (expr
));
595 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
599 cp_fold_convert (tree type
, tree expr
)
602 if (TREE_TYPE (expr
) == type
)
604 else if (TREE_CODE (expr
) == PTRMEM_CST
)
606 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
607 conv
= copy_node (expr
);
608 TREE_TYPE (conv
) = type
;
612 conv
= fold_convert (type
, expr
);
613 conv
= ignore_overflows (conv
, expr
);
618 /* C++ conversions, preference to static cast conversions. */
621 cp_convert (tree type
, tree expr
, tsubst_flags_t complain
)
623 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
, complain
);
626 /* C++ equivalent of convert_and_check but using cp_convert as the
629 Convert EXPR to TYPE, warning about conversion problems with constants.
630 Invoke this function on every expression that is converted implicitly,
631 i.e. because of language rules and not because of an explicit cast. */
634 cp_convert_and_check (tree type
, tree expr
, tsubst_flags_t complain
)
638 if (TREE_TYPE (expr
) == type
)
640 if (expr
== error_mark_node
)
642 result
= cp_convert (type
, expr
, complain
);
644 if ((complain
& tf_warning
)
645 && c_inhibit_evaluation_warnings
== 0)
647 tree folded
= cp_fully_fold (expr
);
650 folded_result
= result
;
653 /* Avoid bogus -Wparentheses warnings. */
654 warning_sentinel
w (warn_parentheses
);
655 warning_sentinel
c (warn_int_in_bool_context
);
656 folded_result
= cp_convert (type
, folded
, tf_none
);
658 folded_result
= fold_simple (folded_result
);
659 if (!TREE_OVERFLOW_P (folded
)
660 && folded_result
!= error_mark_node
)
661 warnings_for_convert_and_check (EXPR_LOC_OR_LOC (expr
, input_location
),
662 type
, folded
, folded_result
);
670 FLAGS indicates how we should behave. */
673 ocp_convert (tree type
, tree expr
, int convtype
, int flags
,
674 tsubst_flags_t complain
)
677 enum tree_code code
= TREE_CODE (type
);
678 const char *invalid_conv_diag
;
680 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
681 bool dofold
= (convtype
& CONV_FOLD
);
683 if (error_operand_p (e
) || type
== error_mark_node
)
684 return error_mark_node
;
686 complete_type (type
);
687 complete_type (TREE_TYPE (expr
));
689 if ((invalid_conv_diag
690 = targetm
.invalid_conversion (TREE_TYPE (expr
), type
)))
692 if (complain
& tf_error
)
693 error (invalid_conv_diag
);
694 return error_mark_node
;
697 /* FIXME remove when moving to c_fully_fold model. */
698 if (!CLASS_TYPE_P (type
))
700 e
= mark_rvalue_use (e
);
701 e
= scalar_constant_value (e
);
703 if (error_operand_p (e
))
704 return error_mark_node
;
706 if (MAYBE_CLASS_TYPE_P (type
) && (convtype
& CONV_FORCE_TEMP
))
707 /* We need a new temporary; don't take this shortcut. */;
708 else if (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (e
)))
710 if (same_type_p (type
, TREE_TYPE (e
)))
711 /* The call to fold will not always remove the NOP_EXPR as
712 might be expected, since if one of the types is a typedef;
713 the comparison in fold is just equality of pointers, not a
714 call to comptypes. We don't call fold in this case because
715 that can result in infinite recursion; fold will call
716 convert, which will call ocp_convert, etc. */
718 /* For complex data types, we need to perform componentwise
720 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
721 return convert_to_complex_maybe_fold (type
, e
, dofold
);
722 else if (VECTOR_TYPE_P (type
))
723 return convert_to_vector (type
, e
);
724 else if (TREE_CODE (e
) == TARGET_EXPR
)
726 /* Don't build a NOP_EXPR of class type. Instead, change the
727 type of the temporary. */
728 TREE_TYPE (e
) = TREE_TYPE (TARGET_EXPR_SLOT (e
)) = type
;
733 /* We shouldn't be treating objects of ADDRESSABLE type as
735 gcc_assert (!TREE_ADDRESSABLE (type
));
736 return build_nop (type
, e
);
740 e1
= targetm
.convert_to_type (type
, e
);
744 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
746 e
= convert_to_void (e
, ICV_CAST
, complain
);
750 if (INTEGRAL_CODE_P (code
))
752 tree intype
= TREE_TYPE (e
);
755 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
757 /* enum = enum, enum = int, enum = float, (enum)pointer are all
759 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
760 || TREE_CODE (intype
) == REAL_TYPE
)
761 && ! (convtype
& CONV_STATIC
))
762 || TYPE_PTR_P (intype
))
764 if (complain
& tf_error
)
765 permerror (loc
, "conversion from %q#T to %q#T", intype
, type
);
767 return error_mark_node
;
770 /* [expr.static.cast]
772 8. A value of integral or enumeration type can be explicitly
773 converted to an enumeration type. The value is unchanged if
774 the original value is within the range of the enumeration
775 values. Otherwise, the resulting enumeration value is
777 if ((complain
& tf_warning
)
778 && TREE_CODE (e
) == INTEGER_CST
779 && ENUM_UNDERLYING_TYPE (type
)
780 && !int_fits_type_p (e
, ENUM_UNDERLYING_TYPE (type
)))
781 warning_at (loc
, OPT_Wconversion
,
782 "the result of the conversion is unspecified because "
783 "%qE is outside the range of type %qT",
786 if (MAYBE_CLASS_TYPE_P (intype
))
789 rval
= build_type_conversion (type
, e
);
792 if (complain
& tf_error
)
793 error_at (loc
, "%q#T used where a %qT was expected", intype
, type
);
794 return error_mark_node
;
796 if (code
== BOOLEAN_TYPE
)
798 if (VOID_TYPE_P (intype
))
800 if (complain
& tf_error
)
802 "could not convert %qE from %<void%> to %<bool%>",
804 return error_mark_node
;
807 /* We can't implicitly convert a scoped enum to bool, so convert
808 to the underlying type first. */
809 if (SCOPED_ENUM_P (intype
) && (convtype
& CONV_STATIC
))
810 e
= build_nop (ENUM_UNDERLYING_TYPE (intype
), e
);
811 if (complain
& tf_warning
)
812 return cp_truthvalue_conversion (e
);
815 /* Prevent bogus -Wint-in-bool-context warnings coming
816 from c_common_truthvalue_conversion down the line. */
817 warning_sentinel
w (warn_int_in_bool_context
);
818 return cp_truthvalue_conversion (e
);
822 converted
= convert_to_integer_maybe_fold (type
, e
, dofold
);
824 /* Ignore any integer overflow caused by the conversion. */
825 return ignore_overflows (converted
, e
);
827 if (NULLPTR_TYPE_P (type
) && e
&& null_ptr_cst_p (e
))
829 if (complain
& tf_warning
)
830 maybe_warn_zero_as_null_pointer_constant (e
, loc
);
833 if (POINTER_TYPE_P (type
) || TYPE_PTRMEM_P (type
))
834 return cp_convert_to_pointer (type
, e
, dofold
, complain
);
835 if (code
== VECTOR_TYPE
)
837 tree in_vtype
= TREE_TYPE (e
);
838 if (MAYBE_CLASS_TYPE_P (in_vtype
))
841 ret_val
= build_type_conversion (type
, e
);
844 if (complain
& tf_error
)
845 error_at (loc
, "%q#T used where a %qT was expected",
847 return error_mark_node
;
849 return convert_to_vector (type
, e
);
851 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
853 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e
)))
856 rval
= build_type_conversion (type
, e
);
859 else if (complain
& tf_error
)
861 "%q#T used where a floating point value was expected",
864 if (code
== REAL_TYPE
)
865 return convert_to_real_maybe_fold (type
, e
, dofold
);
866 else if (code
== COMPLEX_TYPE
)
867 return convert_to_complex_maybe_fold (type
, e
, dofold
);
870 /* New C++ semantics: since assignment is now based on
871 memberwise copying, if the rhs type is derived from the
872 lhs type, then we may still do a conversion. */
873 if (RECORD_OR_UNION_CODE_P (code
))
875 tree dtype
= TREE_TYPE (e
);
876 tree ctor
= NULL_TREE
;
878 dtype
= TYPE_MAIN_VARIANT (dtype
);
880 /* Conversion between aggregate types. New C++ semantics allow
881 objects of derived type to be cast to objects of base type.
882 Old semantics only allowed this between pointers.
884 There may be some ambiguity between using a constructor
885 vs. using a type conversion operator when both apply. */
889 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
890 return error_mark_node
;
892 if (BRACE_ENCLOSED_INITIALIZER_P (ctor
))
893 ctor
= perform_implicit_conversion (type
, ctor
, complain
);
894 else if ((flags
& LOOKUP_ONLYCONVERTING
)
895 && ! (CLASS_TYPE_P (dtype
) && DERIVED_FROM_P (type
, dtype
)))
896 /* For copy-initialization, first we create a temp of the proper type
897 with a user-defined conversion sequence, then we direct-initialize
898 the target with the temp (see [dcl.init]). */
899 ctor
= build_user_type_conversion (type
, ctor
, flags
, complain
);
902 vec
<tree
, va_gc
> *ctor_vec
= make_tree_vector_single (ctor
);
903 ctor
= build_special_member_call (NULL_TREE
,
904 complete_ctor_identifier
,
906 type
, flags
, complain
);
907 release_tree_vector (ctor_vec
);
910 return build_cplus_new (type
, ctor
, complain
);
913 if (complain
& tf_error
)
915 /* If the conversion failed and expr was an invalid use of pointer to
916 member function, try to report a meaningful error. */
917 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
918 /* We displayed the error message. */;
920 error_at (loc
, "conversion from %qH to non-scalar type %qI requested",
921 TREE_TYPE (expr
), type
);
923 return error_mark_node
;
926 /* If CALL is a call, return the callee; otherwise null. */
929 cp_get_callee (tree call
)
931 if (call
== NULL_TREE
)
933 else if (TREE_CODE (call
) == CALL_EXPR
)
934 return CALL_EXPR_FN (call
);
935 else if (TREE_CODE (call
) == AGGR_INIT_EXPR
)
936 return AGGR_INIT_EXPR_FN (call
);
940 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
944 cp_get_fndecl_from_callee (tree fn
, bool fold
/* = true */)
948 if (TREE_CODE (fn
) == FUNCTION_DECL
)
950 tree type
= TREE_TYPE (fn
);
951 if (type
== unknown_type_node
)
953 gcc_assert (POINTER_TYPE_P (type
));
955 fn
= maybe_constant_init (fn
);
957 if (TREE_CODE (fn
) == ADDR_EXPR
)
959 fn
= TREE_OPERAND (fn
, 0);
960 if (TREE_CODE (fn
) == FUNCTION_DECL
)
966 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
967 constexpr machinery. */
970 cp_get_callee_fndecl (tree call
)
972 return cp_get_fndecl_from_callee (cp_get_callee (call
));
975 /* As above, but not using the constexpr machinery. */
978 cp_get_callee_fndecl_nofold (tree call
)
980 return cp_get_fndecl_from_callee (cp_get_callee (call
), false);
983 /* Subroutine of convert_to_void. Warn if we're discarding something with
984 attribute [[nodiscard]]. */
987 maybe_warn_nodiscard (tree expr
, impl_conv_void implicit
)
990 if (TREE_CODE (expr
) == TARGET_EXPR
)
991 call
= TARGET_EXPR_INITIAL (expr
);
992 location_t loc
= EXPR_LOC_OR_LOC (call
, input_location
);
993 tree callee
= cp_get_callee (call
);
997 tree type
= TREE_TYPE (callee
);
998 if (TYPE_PTRMEMFUNC_P (type
))
999 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
1000 if (POINTER_TYPE_P (type
))
1001 type
= TREE_TYPE (type
);
1003 tree rettype
= TREE_TYPE (type
);
1004 tree fn
= cp_get_fndecl_from_callee (callee
);
1005 if (implicit
!= ICV_CAST
&& fn
1006 && lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn
)))
1008 if (warning_at (loc
, OPT_Wunused_result
,
1009 "ignoring return value of %qD, "
1010 "declared with attribute nodiscard", fn
))
1011 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1013 else if (implicit
!= ICV_CAST
1014 && lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype
)))
1016 if (warning_at (loc
, OPT_Wunused_result
,
1017 "ignoring returned value of type %qT, "
1018 "declared with attribute nodiscard", rettype
))
1021 inform (DECL_SOURCE_LOCATION (fn
),
1022 "in call to %qD, declared here", fn
);
1023 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype
)),
1024 "%qT declared here", rettype
);
1027 else if (TREE_CODE (expr
) == TARGET_EXPR
1028 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type
)))
1030 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1031 result is used, so handle that case here. */
1034 if (warning_at (loc
, OPT_Wunused_result
,
1035 "ignoring return value of %qD, "
1036 "declared with attribute warn_unused_result",
1038 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1041 warning_at (loc
, OPT_Wunused_result
,
1042 "ignoring return value of function "
1043 "declared with attribute warn_unused_result");
1047 /* When an expression is used in a void context, its value is discarded and
1048 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1049 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1050 in a void context. The C++ standard does not define what an `access' to an
1051 object is, but there is reason to believe that it is the lvalue to rvalue
1052 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1053 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1054 indicates that volatile semantics should be the same between C and C++
1055 where ever possible. C leaves it implementation defined as to what
1056 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1057 the volatile object `vp' points to, unless that is an incomplete type. For
1058 volatile references we do not do this interpretation, because that would
1059 make it impossible to ignore the reference return value from functions. We
1060 issue warnings in the confusing cases.
1062 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1063 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1064 indicates the context of the implicit conversion. */
1067 convert_to_void (tree expr
, impl_conv_void implicit
, tsubst_flags_t complain
)
1069 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
1071 if (expr
== error_mark_node
1072 || TREE_TYPE (expr
) == error_mark_node
)
1073 return error_mark_node
;
1075 expr
= maybe_undo_parenthesized_ref (expr
);
1077 expr
= mark_discarded_use (expr
);
1078 if (implicit
== ICV_CAST
)
1079 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1080 mark_exp_read (expr
);
1082 if (!TREE_TYPE (expr
))
1084 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
1085 return error_mark_node
;
1086 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
1088 if (complain
& tf_error
)
1089 error_at (loc
, "pseudo-destructor is not called");
1090 return error_mark_node
;
1092 if (VOID_TYPE_P (TREE_TYPE (expr
)))
1094 switch (TREE_CODE (expr
))
1098 /* The two parts of a cond expr might be separate lvalues. */
1099 tree op1
= TREE_OPERAND (expr
,1);
1100 tree op2
= TREE_OPERAND (expr
,2);
1101 bool side_effects
= ((op1
&& TREE_SIDE_EFFECTS (op1
))
1102 || TREE_SIDE_EFFECTS (op2
));
1103 tree new_op1
, new_op2
;
1104 new_op1
= NULL_TREE
;
1105 if (implicit
!= ICV_CAST
&& !side_effects
)
1108 new_op1
= convert_to_void (op1
, ICV_SECOND_OF_COND
, complain
);
1109 new_op2
= convert_to_void (op2
, ICV_THIRD_OF_COND
, complain
);
1114 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1115 new_op2
= convert_to_void (op2
, ICV_CAST
, complain
);
1118 expr
= build3 (COND_EXPR
, TREE_TYPE (new_op2
),
1119 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
1125 /* The second part of a compound expr contains the value. */
1126 tree op1
= TREE_OPERAND (expr
,1);
1128 if (implicit
!= ICV_CAST
&& !TREE_NO_WARNING (expr
))
1129 new_op1
= convert_to_void (op1
, ICV_RIGHT_OF_COMMA
, complain
);
1131 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1135 tree t
= build2 (COMPOUND_EXPR
, TREE_TYPE (new_op1
),
1136 TREE_OPERAND (expr
, 0), new_op1
);
1143 case NON_LVALUE_EXPR
:
1145 /* These have already decayed to rvalue. */
1148 case CALL_EXPR
: /* We have a special meaning for volatile void fn(). */
1149 maybe_warn_nodiscard (expr
, implicit
);
1154 tree type
= TREE_TYPE (expr
);
1155 int is_reference
= TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))
1157 int is_volatile
= TYPE_VOLATILE (type
);
1158 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1160 /* Can't load the value if we don't know the type. */
1161 if (is_volatile
&& !is_complete
)
1163 if (complain
& tf_warning
)
1167 warning_at (loc
, 0, "conversion to void will not access "
1168 "object of incomplete type %qT", type
);
1170 case ICV_SECOND_OF_COND
:
1171 warning_at (loc
, 0, "indirection will not access object of "
1172 "incomplete type %qT in second operand "
1173 "of conditional expression", type
);
1175 case ICV_THIRD_OF_COND
:
1176 warning_at (loc
, 0, "indirection will not access object of "
1177 "incomplete type %qT in third operand "
1178 "of conditional expression", type
);
1180 case ICV_RIGHT_OF_COMMA
:
1181 warning_at (loc
, 0, "indirection will not access object of "
1182 "incomplete type %qT in right operand of "
1183 "comma operator", type
);
1185 case ICV_LEFT_OF_COMMA
:
1186 warning_at (loc
, 0, "indirection will not access object of "
1187 "incomplete type %qT in left operand of "
1188 "comma operator", type
);
1191 warning_at (loc
, 0, "indirection will not access object of "
1192 "incomplete type %qT in statement", type
);
1194 case ICV_THIRD_IN_FOR
:
1195 warning_at (loc
, 0, "indirection will not access object of "
1196 "incomplete type %qT in for increment "
1197 "expression", type
);
1203 /* Don't load the value if this is an implicit dereference, or if
1204 the type needs to be handled by ctors/dtors. */
1205 else if (is_volatile
&& is_reference
)
1207 if (complain
& tf_warning
)
1211 warning_at (loc
, 0, "conversion to void will not access "
1212 "object of type %qT", type
);
1214 case ICV_SECOND_OF_COND
:
1215 warning_at (loc
, 0, "implicit dereference will not access "
1216 "object of type %qT in second operand of "
1217 "conditional expression", type
);
1219 case ICV_THIRD_OF_COND
:
1220 warning_at (loc
, 0, "implicit dereference will not access "
1221 "object of type %qT in third operand of "
1222 "conditional expression", type
);
1224 case ICV_RIGHT_OF_COMMA
:
1225 warning_at (loc
, 0, "implicit dereference will not access "
1226 "object of type %qT in right operand of "
1227 "comma operator", type
);
1229 case ICV_LEFT_OF_COMMA
:
1230 warning_at (loc
, 0, "implicit dereference will not access "
1231 "object of type %qT in left operand of comma "
1235 warning_at (loc
, 0, "implicit dereference will not access "
1236 "object of type %qT in statement", type
);
1238 case ICV_THIRD_IN_FOR
:
1239 warning_at (loc
, 0, "implicit dereference will not access "
1240 "object of type %qT in for increment expression",
1247 else if (is_volatile
&& TREE_ADDRESSABLE (type
))
1249 if (complain
& tf_warning
)
1253 warning_at (loc
, 0, "conversion to void will not access "
1254 "object of non-trivially-copyable type %qT",
1257 case ICV_SECOND_OF_COND
:
1258 warning_at (loc
, 0, "indirection will not access object of "
1259 "non-trivially-copyable type %qT in second "
1260 "operand of conditional expression", type
);
1262 case ICV_THIRD_OF_COND
:
1263 warning_at (loc
, 0, "indirection will not access object of "
1264 "non-trivially-copyable type %qT in third "
1265 "operand of conditional expression", type
);
1267 case ICV_RIGHT_OF_COMMA
:
1268 warning_at (loc
, 0, "indirection will not access object of "
1269 "non-trivially-copyable type %qT in right "
1270 "operand of comma operator", type
);
1272 case ICV_LEFT_OF_COMMA
:
1273 warning_at (loc
, 0, "indirection will not access object of "
1274 "non-trivially-copyable type %qT in left "
1275 "operand of comma operator", type
);
1278 warning_at (loc
, 0, "indirection will not access object of "
1279 "non-trivially-copyable type %qT in statement",
1282 case ICV_THIRD_IN_FOR
:
1283 warning_at (loc
, 0, "indirection will not access object of "
1284 "non-trivially-copyable type %qT in for "
1285 "increment expression", type
);
1291 if (is_reference
|| !is_volatile
|| !is_complete
|| TREE_ADDRESSABLE (type
))
1293 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1294 operation is stripped off. Note that we don't warn about
1295 - an expression with TREE_NO_WARNING set. (For an example of
1296 such expressions, see build_over_call in call.c.)
1297 - automatic dereferencing of references, since the user cannot
1298 control it. (See also warn_if_unused_value() in c-common.c.) */
1299 if (warn_unused_value
1300 && implicit
!= ICV_CAST
1301 && (complain
& tf_warning
)
1302 && !TREE_NO_WARNING (expr
)
1304 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1305 expr
= TREE_OPERAND (expr
, 0);
1306 if (TREE_CODE (expr
) == CALL_EXPR
)
1307 maybe_warn_nodiscard (expr
, implicit
);
1315 /* External variables might be incomplete. */
1316 tree type
= TREE_TYPE (expr
);
1317 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1319 if (TYPE_VOLATILE (type
) && !is_complete
&& (complain
& tf_warning
))
1323 warning_at (loc
, 0, "conversion to void will not access "
1324 "object %qE of incomplete type %qT", expr
, type
);
1326 case ICV_SECOND_OF_COND
:
1327 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1328 "not be accessed in second operand of "
1329 "conditional expression", expr
, type
);
1331 case ICV_THIRD_OF_COND
:
1332 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1333 "not be accessed in third operand of "
1334 "conditional expression", expr
, type
);
1336 case ICV_RIGHT_OF_COMMA
:
1337 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1338 "not be accessed in right operand of comma operator",
1341 case ICV_LEFT_OF_COMMA
:
1342 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1343 "not be accessed in left operand of comma operator",
1347 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1348 "not be accessed in statement", expr
, type
);
1350 case ICV_THIRD_IN_FOR
:
1351 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1352 "not be accessed in for increment expression",
1363 /* Don't bother with the temporary object returned from a function if
1364 we don't use it, don't need to destroy it, and won't abort in
1365 assign_temp. We'll still
1366 allocate space for it in expand_call or declare_return_variable,
1367 but we don't need to track it through all the tree phases. */
1368 if (TARGET_EXPR_IMPLICIT_P (expr
)
1369 && !TREE_ADDRESSABLE (TREE_TYPE (expr
)))
1371 tree init
= TARGET_EXPR_INITIAL (expr
);
1372 if (TREE_CODE (init
) == AGGR_INIT_EXPR
1373 && !AGGR_INIT_VIA_CTOR_P (init
))
1375 tree fn
= AGGR_INIT_EXPR_FN (init
);
1376 expr
= build_call_array_loc (input_location
,
1377 TREE_TYPE (TREE_TYPE
1380 aggr_init_expr_nargs (init
),
1381 AGGR_INIT_EXPR_ARGP (init
));
1384 maybe_warn_nodiscard (expr
, implicit
);
1389 expr
= resolve_nondeduced_context (expr
, complain
);
1393 if (TREE_CODE (probe
) == ADDR_EXPR
)
1394 probe
= TREE_OPERAND (expr
, 0);
1395 if (type_unknown_p (probe
))
1397 /* [over.over] enumerates the places where we can take the address
1398 of an overloaded function, and this is not one of them. */
1399 if (complain
& tf_error
)
1403 error_at (loc
, "conversion to void "
1404 "cannot resolve address of overloaded function");
1406 case ICV_SECOND_OF_COND
:
1407 error_at (loc
, "second operand of conditional expression "
1408 "cannot resolve address of overloaded function");
1410 case ICV_THIRD_OF_COND
:
1411 error_at (loc
, "third operand of conditional expression "
1412 "cannot resolve address of overloaded function");
1414 case ICV_RIGHT_OF_COMMA
:
1415 error_at (loc
, "right operand of comma operator "
1416 "cannot resolve address of overloaded function");
1418 case ICV_LEFT_OF_COMMA
:
1419 error_at (loc
, "left operand of comma operator "
1420 "cannot resolve address of overloaded function");
1423 error_at (loc
, "statement "
1424 "cannot resolve address of overloaded function");
1426 case ICV_THIRD_IN_FOR
:
1427 error_at (loc
, "for increment expression "
1428 "cannot resolve address of overloaded function");
1432 return error_mark_node
;
1435 else if (implicit
!= ICV_CAST
&& probe
== expr
&& is_overloaded_fn (probe
))
1437 /* Only warn when there is no &. */
1438 if (complain
& tf_warning
)
1441 case ICV_SECOND_OF_COND
:
1442 warning_at (loc
, OPT_Waddress
,
1443 "second operand of conditional expression "
1444 "is a reference, not call, to function %qE", expr
);
1446 case ICV_THIRD_OF_COND
:
1447 warning_at (loc
, OPT_Waddress
,
1448 "third operand of conditional expression "
1449 "is a reference, not call, to function %qE", expr
);
1451 case ICV_RIGHT_OF_COMMA
:
1452 warning_at (loc
, OPT_Waddress
,
1453 "right operand of comma operator "
1454 "is a reference, not call, to function %qE", expr
);
1456 case ICV_LEFT_OF_COMMA
:
1457 warning_at (loc
, OPT_Waddress
,
1458 "left operand of comma operator "
1459 "is a reference, not call, to function %qE", expr
);
1462 warning_at (loc
, OPT_Waddress
,
1463 "statement is a reference, not call, to function %qE",
1466 case ICV_THIRD_IN_FOR
:
1467 warning_at (loc
, OPT_Waddress
,
1468 "for increment expression "
1469 "is a reference, not call, to function %qE", expr
);
1475 if (TREE_CODE (expr
) == COMPONENT_REF
)
1476 expr
= TREE_OPERAND (expr
, 0);
1480 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1482 if (implicit
!= ICV_CAST
1483 && warn_unused_value
1484 && !TREE_NO_WARNING (expr
)
1485 && !processing_template_decl
)
1487 /* The middle end does not warn about expressions that have
1488 been explicitly cast to void, so we must do so here. */
1489 if (!TREE_SIDE_EFFECTS (expr
)) {
1490 if (complain
& tf_warning
)
1493 case ICV_SECOND_OF_COND
:
1494 warning_at (loc
, OPT_Wunused_value
,
1495 "second operand of conditional expression "
1498 case ICV_THIRD_OF_COND
:
1499 warning_at (loc
, OPT_Wunused_value
,
1500 "third operand of conditional expression "
1503 case ICV_RIGHT_OF_COMMA
:
1504 warning_at (loc
, OPT_Wunused_value
,
1505 "right operand of comma operator has no effect");
1507 case ICV_LEFT_OF_COMMA
:
1508 warning_at (loc
, OPT_Wunused_value
,
1509 "left operand of comma operator has no effect");
1512 warning_at (loc
, OPT_Wunused_value
,
1513 "statement has no effect");
1515 case ICV_THIRD_IN_FOR
:
1516 warning_at (loc
, OPT_Wunused_value
,
1517 "for increment expression has no effect");
1526 enum tree_code code
;
1527 enum tree_code_class tclass
;
1530 /* We might like to warn about (say) "(int) f()", as the
1531 cast has no effect, but the compiler itself will
1532 generate implicit conversions under some
1533 circumstances. (For example a block copy will be
1534 turned into a call to "__builtin_memcpy", with a
1535 conversion of the return value to an appropriate
1536 type.) So, to avoid false positives, we strip
1537 conversions. Do not use STRIP_NOPs because it will
1538 not strip conversions to "void", as that is not a
1539 mode-preserving conversion. */
1540 while (TREE_CODE (e
) == NOP_EXPR
)
1541 e
= TREE_OPERAND (e
, 0);
1543 code
= TREE_CODE (e
);
1544 tclass
= TREE_CODE_CLASS (code
);
1545 if ((tclass
== tcc_comparison
1546 || tclass
== tcc_unary
1547 || (tclass
== tcc_binary
1548 && !(code
== MODIFY_EXPR
1549 || code
== INIT_EXPR
1550 || code
== PREDECREMENT_EXPR
1551 || code
== PREINCREMENT_EXPR
1552 || code
== POSTDECREMENT_EXPR
1553 || code
== POSTINCREMENT_EXPR
))
1554 || code
== VEC_PERM_EXPR
1555 || code
== VEC_COND_EXPR
)
1556 && (complain
& tf_warning
))
1557 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1560 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
1562 if (! TREE_SIDE_EFFECTS (expr
))
1567 /* Create an expression whose value is that of EXPR,
1568 converted to type TYPE. The TREE_TYPE of the value
1569 is always TYPE. This function implements all reasonable
1570 conversions; callers should filter out those that are
1571 not permitted by the language being compiled.
1573 Most of this routine is from build_reinterpret_cast.
1575 The back end cannot call cp_convert (what was convert) because
1576 conversions to/from basetypes may involve memory references
1577 (vbases) and adding or subtracting small values (multiple
1578 inheritance), but it calls convert from the constant folding code
1579 on subtrees of already built trees after it has ripped them apart.
1581 Also, if we ever support range variables, we'll probably also have to
1582 do a little bit more work. */
1585 convert (tree type
, tree expr
)
1589 if (type
== error_mark_node
|| expr
== error_mark_node
)
1590 return error_mark_node
;
1592 intype
= TREE_TYPE (expr
);
1594 if (POINTER_TYPE_P (type
) && POINTER_TYPE_P (intype
))
1595 return build_nop (type
, expr
);
1597 return ocp_convert (type
, expr
, CONV_BACKEND_CONVERT
,
1598 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
1599 tf_warning_or_error
);
1602 /* Like cp_convert, except permit conversions to take place which
1603 are not normally allowed due to access restrictions
1604 (such as conversion from sub-type to private super-type). */
1607 convert_force (tree type
, tree expr
, int convtype
, tsubst_flags_t complain
)
1610 enum tree_code code
= TREE_CODE (type
);
1612 if (code
== REFERENCE_TYPE
)
1613 return convert_to_reference (type
, e
, CONV_C_CAST
, 0,
1614 NULL_TREE
, complain
);
1616 if (code
== POINTER_TYPE
)
1617 return convert_to_pointer_force (type
, e
, complain
);
1619 /* From typeck.c convert_for_assignment */
1620 if (((TYPE_PTR_P (TREE_TYPE (e
)) && TREE_CODE (e
) == ADDR_EXPR
1621 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1622 || integer_zerop (e
)
1623 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1624 && TYPE_PTRMEMFUNC_P (type
))
1625 /* compatible pointer to member functions. */
1626 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1,
1627 /*c_cast_p=*/1, complain
);
1629 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
, complain
);
1632 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1633 exists, return the attempted conversion. This may
1634 return ERROR_MARK_NODE if the conversion is not
1635 allowed (references private members, etc).
1636 If no conversion exists, NULL_TREE is returned.
1638 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1639 object parameter, or by the second standard conversion sequence if
1640 that doesn't do it. This will probably wait for an overloading rewrite.
1644 build_type_conversion (tree xtype
, tree expr
)
1646 /* C++: check to see if we can convert this aggregate type
1647 into the required type. */
1648 return build_user_type_conversion (xtype
, expr
, LOOKUP_NORMAL
,
1649 tf_warning_or_error
);
1652 /* Convert the given EXPR to one of a group of types suitable for use in an
1653 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1654 which indicates which types are suitable. If COMPLAIN is true, complain
1655 about ambiguity; otherwise, the caller will deal with it. */
1658 build_expr_type_conversion (int desires
, tree expr
, bool complain
)
1660 tree basetype
= TREE_TYPE (expr
);
1661 tree conv
= NULL_TREE
;
1662 tree winner
= NULL_TREE
;
1664 if (null_node_p (expr
)
1665 && (desires
& WANT_INT
)
1666 && !(desires
& WANT_NULL
))
1668 source_location loc
=
1669 expansion_point_location_if_in_system_header (input_location
);
1671 warning_at (loc
, OPT_Wconversion_null
,
1672 "converting NULL to non-pointer type");
1675 if (basetype
== error_mark_node
)
1676 return error_mark_node
;
1678 if (! MAYBE_CLASS_TYPE_P (basetype
))
1679 switch (TREE_CODE (basetype
))
1682 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1687 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1689 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1691 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1693 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1697 return (desires
& WANT_POINTER
) ? decay_conversion (expr
,
1698 tf_warning_or_error
)
1703 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1705 switch (TREE_CODE (TREE_TYPE (basetype
)))
1709 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1711 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1713 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1722 /* The code for conversions from class type is currently only used for
1723 delete expressions. Other expressions are handled by build_new_op. */
1724 if (!complete_type_or_maybe_complain (basetype
, expr
, complain
))
1725 return error_mark_node
;
1726 if (!TYPE_HAS_CONVERSION (basetype
))
1729 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1733 tree cand
= TREE_VALUE (conv
);
1734 cand
= OVL_FIRST (cand
);
1736 if (winner
&& winner
== cand
)
1739 if (DECL_NONCONVERTING_P (cand
))
1742 candidate
= non_reference (TREE_TYPE (TREE_TYPE (cand
)));
1744 switch (TREE_CODE (candidate
))
1748 win
= (desires
& WANT_INT
); break;
1750 win
= (desires
& WANT_ENUM
); break;
1752 win
= (desires
& WANT_FLOAT
); break;
1754 win
= (desires
& WANT_POINTER
); break;
1758 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1760 switch (TREE_CODE (TREE_TYPE (candidate
)))
1764 win
= (desires
& WANT_INT
); break;
1766 win
= (desires
& WANT_ENUM
); break;
1768 win
= (desires
& WANT_FLOAT
); break;
1775 /* A wildcard could be instantiated to match any desired
1776 type, but we can't deduce the template argument. */
1777 if (WILDCARD_TYPE_P (candidate
))
1784 if (TREE_CODE (cand
) == TEMPLATE_DECL
)
1787 error ("default type conversion can't deduce template"
1788 " argument for %qD", cand
);
1789 return error_mark_node
;
1795 = non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1797 if (!same_type_ignoring_top_level_qualifiers_p (winner_type
,
1802 error ("ambiguous default type conversion from %qT",
1804 inform (input_location
,
1805 " candidate conversions include %qD and %qD",
1808 return error_mark_node
;
1818 tree type
= non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1819 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
,
1820 tf_warning_or_error
);
1826 /* Implements integral promotion (4.1) and float->double promotion. */
1829 type_promotes_to (tree type
)
1833 if (type
== error_mark_node
)
1834 return error_mark_node
;
1836 type
= TYPE_MAIN_VARIANT (type
);
1838 /* Check for promotions of target-defined types first. */
1839 promoted_type
= targetm
.promoted_type (type
);
1841 return promoted_type
;
1843 /* bool always promotes to int (not unsigned), even if it's the same
1845 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1846 type
= integer_type_node
;
1848 /* Normally convert enums to int, but convert wide enums to something
1849 wider. Scoped enums don't promote, but pretend they do for backward
1850 ABI bug compatibility wrt varargs. */
1851 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1852 || type
== char16_type_node
1853 || type
== char32_type_node
1854 || type
== wchar_type_node
)
1858 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1860 prom
= ENUM_UNDERLYING_TYPE (prom
);
1861 if (!ENUM_IS_SCOPED (type
)
1862 && ENUM_FIXED_UNDERLYING_TYPE_P (type
))
1864 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1865 whose underlying type is fixed (10.2) can be converted to a
1866 prvalue of its underlying type. Moreover, if integral promotion
1867 can be applied to its underlying type, a prvalue of an unscoped
1868 enumeration type whose underlying type is fixed can also be
1869 converted to a prvalue of the promoted underlying type. */
1870 return type_promotes_to (prom
);
1874 int precision
= MAX (TYPE_PRECISION (type
),
1875 TYPE_PRECISION (integer_type_node
));
1876 tree totype
= c_common_type_for_size (precision
, 0);
1877 if (TYPE_UNSIGNED (prom
)
1878 && ! int_fits_type_p (TYPE_MAX_VALUE (prom
), totype
))
1879 prom
= c_common_type_for_size (precision
, 1);
1882 if (SCOPED_ENUM_P (type
))
1884 if (abi_version_crosses (6)
1885 && TYPE_MODE (prom
) != TYPE_MODE (type
))
1886 warning (OPT_Wabi
, "scoped enum %qT passed through ... as "
1887 "%qT before -fabi-version=6, %qT after",
1888 type
, prom
, ENUM_UNDERLYING_TYPE (type
));
1889 if (!abi_version_at_least (6))
1895 else if (c_promoting_integer_type_p (type
))
1897 /* Retain unsignedness if really not getting bigger. */
1898 if (TYPE_UNSIGNED (type
)
1899 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1900 type
= unsigned_type_node
;
1902 type
= integer_type_node
;
1904 else if (type
== float_type_node
)
1905 type
= double_type_node
;
1910 /* The routines below this point are carefully written to conform to
1911 the standard. They use the same terminology, and follow the rules
1912 closely. Although they are used only in pt.c at the moment, they
1913 should presumably be used everywhere in the future. */
1915 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1916 Callers should check for identical types before calling this function. */
1919 can_convert_qual (tree type
, tree expr
)
1921 tree expr_type
= TREE_TYPE (expr
);
1922 gcc_assert (!same_type_p (type
, expr_type
));
1924 if (TYPE_PTR_P (type
) && TYPE_PTR_P (expr_type
))
1925 return comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (expr_type
));
1926 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (expr_type
))
1927 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
1928 TYPE_PTRMEM_CLASS_TYPE (expr_type
))
1929 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type
),
1930 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type
)));
1935 /* Attempt to perform qualification conversions on EXPR to convert it
1936 to TYPE. Return the resulting expression, or error_mark_node if
1937 the conversion was impossible. */
1940 perform_qualification_conversions (tree type
, tree expr
)
1944 expr_type
= TREE_TYPE (expr
);
1946 if (same_type_p (type
, expr_type
))
1948 else if (can_convert_qual (type
, expr
))
1949 return build_nop (type
, expr
);
1951 return error_mark_node
;
1954 /* True iff T is a transaction-safe function type. */
1957 tx_safe_fn_type_p (tree t
)
1959 if (TREE_CODE (t
) != FUNCTION_TYPE
1960 && TREE_CODE (t
) != METHOD_TYPE
)
1962 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t
));
1965 /* Return the transaction-unsafe variant of transaction-safe function type
1969 tx_unsafe_fn_variant (tree t
)
1971 gcc_assert (tx_safe_fn_type_p (t
));
1972 tree attrs
= remove_attribute ("transaction_safe",
1973 TYPE_ATTRIBUTES (t
));
1974 return cp_build_type_attribute_variant (t
, attrs
);
1977 /* Return true iff FROM can convert to TO by a transaction-safety
1981 can_convert_tx_safety (tree to
, tree from
)
1983 return (flag_tm
&& tx_safe_fn_type_p (from
)
1984 && same_type_p (to
, tx_unsafe_fn_variant (from
)));
1987 /* Return true iff FROM can convert to TO by dropping noexcept. */
1990 noexcept_conv_p (tree to
, tree from
)
1992 if (!flag_noexcept_type
)
1995 tree t
= non_reference (to
);
1997 if (TYPE_PTRMEMFUNC_P (t
)
1998 && TYPE_PTRMEMFUNC_P (f
))
2000 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2001 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2003 if (TREE_CODE (t
) == POINTER_TYPE
2004 && TREE_CODE (f
) == POINTER_TYPE
)
2009 tree_code code
= TREE_CODE (f
);
2010 if (TREE_CODE (t
) != code
)
2012 if (code
!= FUNCTION_TYPE
&& code
!= METHOD_TYPE
)
2014 if (!type_throw_all_p (t
)
2015 || type_throw_all_p (f
))
2017 tree v
= build_exception_variant (f
, NULL_TREE
);
2018 return same_type_p (t
, v
);
2021 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2024 fnptr_conv_p (tree to
, tree from
)
2026 tree t
= non_reference (to
);
2028 if (TYPE_PTRMEMFUNC_P (t
)
2029 && TYPE_PTRMEMFUNC_P (f
))
2031 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2032 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2034 if (TREE_CODE (t
) == POINTER_TYPE
2035 && TREE_CODE (f
) == POINTER_TYPE
)
2041 return (noexcept_conv_p (t
, f
)
2042 || can_convert_tx_safety (t
, f
));
2045 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2046 conversions or conversions to the same type. */
2049 strip_fnptr_conv (tree fn
)
2051 while (TREE_CODE (fn
) == NOP_EXPR
)
2053 tree op
= TREE_OPERAND (fn
, 0);
2054 tree ft
= TREE_TYPE (fn
);
2055 tree ot
= TREE_TYPE (op
);
2056 if (same_type_p (ft
, ot
)
2057 || fnptr_conv_p (ft
, ot
))