1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file 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"
38 #include "escaped_string.h"
40 static tree
convert_to_pointer_force (tree
, tree
, tsubst_flags_t
);
41 static tree
build_type_conversion (tree
, tree
);
42 static tree
build_up_reference (tree
, tree
, int, tree
, tsubst_flags_t
);
43 static void diagnose_ref_binding (location_t
, tree
, tree
, tree
);
45 /* Change of width--truncation and extension of integers or reals--
46 is represented with NOP_EXPR. Proper functioning of many things
47 assumes that no other conversions can be NOP_EXPRs.
49 Conversion between integer and pointer is represented with CONVERT_EXPR.
50 Converting integer to real uses FLOAT_EXPR
51 and real to integer uses FIX_TRUNC_EXPR.
53 Here is a list of all the functions that assume that widening and
54 narrowing is always done with a NOP_EXPR:
55 In convert.cc, convert_to_integer[_maybe_fold].
56 In c-typeck.cc, build_binary_op_nodefault (boolean ops),
57 and c_common_truthvalue_conversion.
58 In expr.cc: expand_expr, for operands of a MULT_EXPR.
59 In fold-const.cc: fold.
60 In tree.cc: get_narrower and get_unwidened.
62 C++: in multiple-inheritance, converting between pointers may involve
63 adjusting them by a delta stored within the class definition. */
65 /* Subroutines of `convert'. */
67 /* if converting pointer to pointer
68 if dealing with classes, check for derived->base or vice versa
69 else if dealing with method pointers, delegate
71 else if converting class, pass off to build_type_conversion
72 else try C-style pointer conversion. */
75 cp_convert_to_pointer (tree type
, tree expr
, bool dofold
,
76 tsubst_flags_t complain
)
78 tree intype
= TREE_TYPE (expr
);
81 location_t loc
= cp_expr_loc_or_input_loc (expr
);
83 if (intype
== error_mark_node
)
84 return error_mark_node
;
86 if (MAYBE_CLASS_TYPE_P (intype
))
88 intype
= complete_type (intype
);
89 if (!COMPLETE_TYPE_P (intype
))
91 if (complain
& tf_error
)
92 error_at (loc
, "cannot convert from incomplete type %qH to %qI",
94 return error_mark_node
;
97 rval
= build_type_conversion (type
, expr
);
100 if ((complain
& tf_error
)
101 && rval
== error_mark_node
)
102 error_at (loc
, "conversion of %qE from %qH to %qI is ambiguous",
108 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
109 if (TYPE_PTR_P (type
)
110 && (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
111 || VOID_TYPE_P (TREE_TYPE (type
))))
113 if (TYPE_PTRMEMFUNC_P (intype
)
114 || TREE_CODE (intype
) == METHOD_TYPE
)
115 return convert_member_func_to_ptr (type
, expr
, complain
);
116 if (TYPE_PTR_P (TREE_TYPE (expr
)))
117 return build_nop (type
, expr
);
118 intype
= TREE_TYPE (expr
);
121 if (expr
== error_mark_node
)
122 return error_mark_node
;
124 form
= TREE_CODE (intype
);
126 if (INDIRECT_TYPE_P (intype
))
128 intype
= TYPE_MAIN_VARIANT (intype
);
130 if (TYPE_MAIN_VARIANT (type
) != intype
132 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
133 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type
))
134 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype
))
135 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
137 enum tree_code code
= PLUS_EXPR
;
143 intype_class
= TREE_TYPE (intype
);
144 type_class
= TREE_TYPE (type
);
146 same_p
= same_type_p (TYPE_MAIN_VARIANT (intype_class
),
147 TYPE_MAIN_VARIANT (type_class
));
149 /* Try derived to base conversion. */
151 binfo
= lookup_base (intype_class
, type_class
, ba_check
,
153 if (!same_p
&& !binfo
)
155 /* Try base to derived conversion. */
156 binfo
= lookup_base (type_class
, intype_class
, ba_check
,
160 if (binfo
== error_mark_node
)
161 return error_mark_node
;
165 expr
= build_base_path (code
, expr
, binfo
, 0, complain
);
166 /* Add any qualifier conversions. */
167 return build_nop (type
, expr
);
171 if (TYPE_PTRMEMFUNC_P (type
))
173 if (complain
& tf_error
)
174 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
176 return error_mark_node
;
179 return build_nop (type
, expr
);
181 else if ((TYPE_PTRDATAMEM_P (type
) && TYPE_PTRDATAMEM_P (intype
))
182 || (TYPE_PTRMEMFUNC_P (type
) && TYPE_PTRMEMFUNC_P (intype
)))
183 return convert_ptrmem (type
, expr
, /*allow_inverse_p=*/false,
184 /*c_cast_p=*/false, complain
);
185 else if (TYPE_PTRMEMFUNC_P (intype
))
189 if (TREE_CODE (expr
) == PTRMEM_CST
)
190 return cp_convert_to_pointer (type
, PTRMEM_CST_MEMBER (expr
),
192 else if (TREE_CODE (expr
) == OFFSET_REF
)
194 tree object
= TREE_OPERAND (expr
, 0);
195 return get_member_function_from_ptrfunc (&object
,
196 TREE_OPERAND (expr
, 1),
200 if (complain
& tf_error
)
201 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
203 return error_mark_node
;
206 if (null_ptr_cst_p (expr
))
208 if (TYPE_PTRMEMFUNC_P (type
))
209 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), expr
, 0,
210 /*c_cast_p=*/false, complain
);
212 if (complain
& tf_warning
)
213 maybe_warn_zero_as_null_pointer_constant (expr
, loc
);
215 /* A NULL pointer-to-data-member is represented by -1, not by
217 tree val
= (TYPE_PTRDATAMEM_P (type
)
218 ? build_int_cst_type (type
, -1)
219 : build_int_cst (type
, 0));
221 return (TREE_SIDE_EFFECTS (expr
)
222 ? build2 (COMPOUND_EXPR
, type
, expr
, val
) : val
);
224 else if (TYPE_PTRMEM_P (type
) && INTEGRAL_CODE_P (form
))
226 if (complain
& tf_error
)
227 error_at (loc
, "invalid conversion from %qH to %qI", intype
, type
);
228 return error_mark_node
;
231 if (INTEGRAL_CODE_P (form
))
233 if (TYPE_PRECISION (intype
) == POINTER_SIZE
)
234 return build1 (CONVERT_EXPR
, type
, expr
);
235 expr
= cp_convert (c_common_type_for_size (TYPE_PRECISION (type
), 0), expr
,
237 /* Modes may be different but sizes should be the same. There
238 is supposed to be some integral type that is the same width
240 gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr
)))
241 == GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
)));
243 /* FIXME needed because convert_to_pointer_maybe_fold still folds
244 conversion of constants. */
246 return build1 (CONVERT_EXPR
, type
, expr
);
248 return convert_to_pointer_maybe_fold (type
, expr
, dofold
);
251 if (type_unknown_p (expr
))
252 return instantiate_type (type
, expr
, complain
);
254 if (complain
& tf_error
)
255 error_at (loc
, "cannot convert %qE from type %qH to type %qI",
257 return error_mark_node
;
260 /* Like convert, except permit conversions to take place which
261 are not normally allowed due to access restrictions
262 (such as conversion from sub-type to private super-type). */
265 convert_to_pointer_force (tree type
, tree expr
, tsubst_flags_t complain
)
267 tree intype
= TREE_TYPE (expr
);
268 enum tree_code form
= TREE_CODE (intype
);
270 if (form
== POINTER_TYPE
)
272 intype
= TYPE_MAIN_VARIANT (intype
);
274 if (TYPE_MAIN_VARIANT (type
) != intype
275 && TREE_CODE (TREE_TYPE (type
)) == RECORD_TYPE
276 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type
))
277 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype
))
278 && TREE_CODE (TREE_TYPE (intype
)) == RECORD_TYPE
)
280 enum tree_code code
= PLUS_EXPR
;
283 binfo
= lookup_base (TREE_TYPE (intype
), TREE_TYPE (type
),
284 ba_unique
, NULL
, complain
);
287 binfo
= lookup_base (TREE_TYPE (type
), TREE_TYPE (intype
),
288 ba_unique
, NULL
, complain
);
291 if (binfo
== error_mark_node
)
292 return error_mark_node
;
295 expr
= build_base_path (code
, expr
, binfo
, 0, complain
);
296 if (expr
== error_mark_node
)
297 return error_mark_node
;
298 /* Add any qualifier conversions. */
299 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr
)),
301 expr
= build_nop (type
, expr
);
307 return cp_convert_to_pointer (type
, expr
, /*fold*/false, complain
);
310 /* We are passing something to a function which requires a reference.
311 The type we are interested in is in TYPE. The initial
312 value we have to begin with is in ARG.
314 FLAGS controls how we manage access checking.
315 DIRECT_BIND in FLAGS controls how any temporaries are generated.
316 If DIRECT_BIND is set, DECL is the reference we're binding to. */
319 build_up_reference (tree type
, tree arg
, int flags
, tree decl
,
320 tsubst_flags_t complain
)
323 tree argtype
= TREE_TYPE (arg
);
324 tree target_type
= TREE_TYPE (type
);
326 gcc_assert (TYPE_REF_P (type
));
328 if ((flags
& DIRECT_BIND
) && ! lvalue_p (arg
))
330 /* Create a new temporary variable. We can't just use a TARGET_EXPR
331 here because it needs to live as long as DECL. */
334 arg
= make_temporary_var_for_ref_to_temp (decl
, target_type
);
336 /* Process the initializer for the declaration. */
337 DECL_INITIAL (arg
) = targ
;
338 cp_finish_decl (arg
, targ
, /*init_const_expr_p=*/false, NULL_TREE
,
339 LOOKUP_ONLYCONVERTING
|DIRECT_BIND
);
341 else if (!(flags
& DIRECT_BIND
) && ! obvalue_p (arg
))
342 return get_target_expr (arg
, complain
);
344 /* If we had a way to wrap this up, and say, if we ever needed its
345 address, transform all occurrences of the register, into a memory
346 reference we could win better. */
347 rval
= cp_build_addr_expr (arg
, complain
);
348 if (rval
== error_mark_node
)
349 return error_mark_node
;
351 if ((flags
& LOOKUP_PROTECT
)
352 && TYPE_MAIN_VARIANT (argtype
) != TYPE_MAIN_VARIANT (target_type
)
353 && MAYBE_CLASS_TYPE_P (argtype
)
354 && MAYBE_CLASS_TYPE_P (target_type
))
356 /* We go through lookup_base for the access control. */
357 tree binfo
= lookup_base (argtype
, target_type
, ba_check
,
359 if (binfo
== error_mark_node
)
360 return error_mark_node
;
361 if (binfo
== NULL_TREE
)
362 return error_not_base_type (target_type
, argtype
);
363 rval
= build_base_path (PLUS_EXPR
, rval
, binfo
, 1, complain
);
367 = convert_to_pointer_force (build_pointer_type (target_type
),
369 return build_nop (type
, rval
);
372 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
373 INTYPE is the original rvalue type and DECL is an optional _DECL node
376 [dcl.init.ref] says that if an rvalue is used to
377 initialize a reference, then the reference must be to a
378 non-volatile const type. */
381 diagnose_ref_binding (location_t loc
, tree reftype
, tree intype
, tree decl
)
383 tree ttl
= TREE_TYPE (reftype
);
385 if (!TYPE_REF_IS_RVALUE (reftype
)
386 && !CP_TYPE_CONST_NON_VOLATILE_P (ttl
))
390 if (CP_TYPE_VOLATILE_P (ttl
) && decl
)
391 msg
= G_("initialization of volatile reference type %q#T from "
392 "rvalue of type %qT");
393 else if (CP_TYPE_VOLATILE_P (ttl
))
394 msg
= G_("conversion to volatile reference type %q#T "
395 "from rvalue of type %qT");
397 msg
= G_("initialization of non-const reference type %q#T from "
398 "rvalue of type %qT");
400 msg
= G_("conversion to non-const reference type %q#T from "
401 "rvalue of type %qT");
403 permerror (loc
, msg
, reftype
, intype
);
407 /* For C++: Only need to do one-level references, but cannot
408 get tripped up on signed/unsigned differences.
410 DECL is either NULL_TREE or the _DECL node for a reference that is being
411 initialized. It can be error_mark_node if we don't know the _DECL but
412 we know it's an initialization. */
415 convert_to_reference (tree reftype
, tree expr
, int convtype
,
416 int flags
, tree decl
, tsubst_flags_t complain
)
418 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (reftype
));
420 tree rval
= NULL_TREE
;
421 tree rval_as_conversion
= NULL_TREE
;
422 bool can_convert_intype_to_type
;
423 location_t loc
= cp_expr_loc_or_input_loc (expr
);
425 if (TREE_CODE (type
) == FUNCTION_TYPE
426 && TREE_TYPE (expr
) == unknown_type_node
)
427 expr
= instantiate_type (type
, expr
, complain
);
429 if (expr
== error_mark_node
)
430 return error_mark_node
;
432 intype
= TREE_TYPE (expr
);
434 gcc_assert (!TYPE_REF_P (intype
));
435 gcc_assert (TYPE_REF_P (reftype
));
437 intype
= TYPE_MAIN_VARIANT (intype
);
439 can_convert_intype_to_type
= can_convert_standard (type
, intype
, complain
);
441 if (!can_convert_intype_to_type
442 && (convtype
& CONV_IMPLICIT
) && MAYBE_CLASS_TYPE_P (intype
)
443 && ! (flags
& LOOKUP_NO_CONVERSION
))
445 /* Look for a user-defined conversion to lvalue that we can use. */
448 = build_type_conversion (reftype
, expr
);
450 if (rval_as_conversion
&& rval_as_conversion
!= error_mark_node
451 && lvalue_p (rval_as_conversion
))
453 expr
= rval_as_conversion
;
454 rval_as_conversion
= NULL_TREE
;
456 can_convert_intype_to_type
= 1;
460 if (((convtype
& CONV_STATIC
)
461 && can_convert_standard (intype
, type
, complain
))
462 || ((convtype
& CONV_IMPLICIT
) && can_convert_intype_to_type
))
465 tree ttl
= TREE_TYPE (reftype
);
466 tree ttr
= lvalue_type (expr
);
468 if ((complain
& tf_error
)
469 && ! lvalue_p (expr
))
470 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
472 if (! (convtype
& CONV_CONST
)
473 && !at_least_as_qualified_p (ttl
, ttr
))
475 if (complain
& tf_error
)
476 permerror (loc
, "conversion from %qH to %qI discards qualifiers",
479 return error_mark_node
;
483 return build_up_reference (reftype
, expr
, flags
, decl
, complain
);
485 else if ((convtype
& CONV_REINTERPRET
) && obvalue_p (expr
))
487 /* When casting an lvalue to a reference type, just convert into
488 a pointer to the new type and deference it. This is allowed
489 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
490 should be done directly (jason). (int &)ri ---> *(int*)&ri */
492 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
494 if ((complain
& tf_warning
)
495 && TYPE_PTR_P (intype
)
496 && (comptypes (TREE_TYPE (intype
), type
,
497 COMPARE_BASE
| COMPARE_DERIVED
)))
498 warning_at (loc
, 0, "casting %qT to %qT does not dereference pointer",
501 rval
= cp_build_addr_expr (expr
, complain
);
502 if (rval
!= error_mark_node
)
503 rval
= convert_force (build_pointer_type (TREE_TYPE (reftype
)),
505 if (rval
!= error_mark_node
)
506 rval
= build1 (NOP_EXPR
, reftype
, rval
);
510 rval
= convert_for_initialization (NULL_TREE
, type
, expr
, flags
,
511 ICR_CONVERTING
, 0, 0, complain
);
512 if (rval
== NULL_TREE
|| rval
== error_mark_node
)
514 if (complain
& tf_error
)
515 diagnose_ref_binding (loc
, reftype
, intype
, decl
);
516 rval
= build_up_reference (reftype
, rval
, flags
, decl
, complain
);
521 /* If we found a way to convert earlier, then use it. */
525 if (complain
& tf_error
)
526 error_at (loc
, "cannot convert type %qH to type %qI", intype
, reftype
);
528 return error_mark_node
;
531 /* We are using a reference VAL for its value. Bash that reference all the
532 way down to its lowest form. */
535 convert_from_reference (tree val
)
538 && TYPE_REF_P (TREE_TYPE (val
)))
540 tree t
= TREE_TYPE (TREE_TYPE (val
));
541 tree ref
= build1 (INDIRECT_REF
, t
, val
);
544 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
545 so that we get the proper error message if the result is used
546 to assign to. Also, &* is supposed to be a no-op. */
547 TREE_READONLY (ref
) = CP_TYPE_CONST_P (t
);
548 TREE_THIS_VOLATILE (ref
) = CP_TYPE_VOLATILE_P (t
);
549 TREE_SIDE_EFFECTS (ref
)
550 = (TREE_THIS_VOLATILE (ref
) || TREE_SIDE_EFFECTS (val
));
557 /* Really perform an lvalue-to-rvalue conversion, including copying an
558 argument of class type into a temporary. */
561 force_rvalue (tree expr
, tsubst_flags_t complain
)
563 tree type
= TREE_TYPE (expr
);
564 if (MAYBE_CLASS_TYPE_P (type
) && TREE_CODE (expr
) != TARGET_EXPR
)
566 releasing_vec
args (make_tree_vector_single (expr
));
567 expr
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
568 &args
, type
, LOOKUP_NORMAL
, complain
);
569 expr
= build_cplus_new (type
, expr
, complain
);
572 expr
= decay_conversion (expr
, complain
);
578 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
579 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
583 ignore_overflows (tree expr
, tree orig
)
585 tree stripped_expr
= tree_strip_any_location_wrapper (expr
);
586 tree stripped_orig
= tree_strip_any_location_wrapper (orig
);
588 if (TREE_CODE (stripped_expr
) == INTEGER_CST
589 && TREE_CODE (stripped_orig
) == INTEGER_CST
590 && TREE_OVERFLOW (stripped_expr
) != TREE_OVERFLOW (stripped_orig
))
592 gcc_assert (!TREE_OVERFLOW (stripped_orig
));
593 /* Ensure constant sharing. */
594 stripped_expr
= wide_int_to_tree (TREE_TYPE (stripped_expr
),
595 wi::to_wide (stripped_expr
));
598 return preserve_any_location_wrapper (stripped_expr
, expr
);
601 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
602 properly and propagate TREE_NO_WARNING if folding EXPR results
603 in the same expression code. */
606 cp_fold_convert (tree type
, tree expr
)
609 if (TREE_TYPE (expr
) == type
)
611 else if (TREE_CODE (expr
) == PTRMEM_CST
612 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
613 PTRMEM_CST_CLASS (expr
)))
615 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
616 conv
= copy_node (expr
);
617 TREE_TYPE (conv
) = type
;
619 else if (TYPE_PTRMEM_P (type
))
621 conv
= convert_ptrmem (type
, expr
, true, false,
622 tf_warning_or_error
);
623 conv
= cp_fully_fold (conv
);
627 conv
= fold_convert (type
, expr
);
628 conv
= ignore_overflows (conv
, expr
);
631 if (TREE_CODE (expr
) == TREE_CODE (conv
))
632 copy_warning (conv
, expr
);
637 /* C++ conversions, preference to static cast conversions. */
640 cp_convert (tree type
, tree expr
, tsubst_flags_t complain
)
642 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
, complain
);
645 /* C++ equivalent of convert_and_check but using cp_convert as the
648 Convert EXPR to TYPE, warning about conversion problems with constants.
649 Invoke this function on every expression that is converted implicitly,
650 i.e. because of language rules and not because of an explicit cast. */
653 cp_convert_and_check (tree type
, tree expr
, tsubst_flags_t complain
)
655 tree result
, expr_for_warning
= expr
;
657 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
658 expr
= TREE_OPERAND (expr
, 0);
659 if (TREE_TYPE (expr
) == type
)
661 if (expr
== error_mark_node
)
663 result
= cp_convert (type
, expr
, complain
);
665 if ((complain
& tf_warning
)
666 && c_inhibit_evaluation_warnings
== 0)
668 tree folded
= cp_fully_fold (expr_for_warning
);
671 folded_result
= result
;
674 /* Avoid bogus -Wparentheses warnings. */
675 warning_sentinel
w (warn_parentheses
);
676 warning_sentinel
c (warn_int_in_bool_context
);
677 folded_result
= cp_convert (type
, folded
, tf_none
);
679 folded_result
= fold_simple (folded_result
);
680 if (!TREE_OVERFLOW_P (folded
)
681 && folded_result
!= error_mark_node
)
682 warnings_for_convert_and_check (cp_expr_loc_or_input_loc (expr
),
683 type
, folded
, folded_result
);
691 FLAGS indicates how we should behave. */
694 ocp_convert (tree type
, tree expr
, int convtype
, int flags
,
695 tsubst_flags_t complain
)
698 enum tree_code code
= TREE_CODE (type
);
699 const char *invalid_conv_diag
;
701 location_t loc
= cp_expr_loc_or_input_loc (expr
);
702 bool dofold
= (convtype
& CONV_FOLD
);
704 if (error_operand_p (e
) || type
== error_mark_node
)
705 return error_mark_node
;
707 if (TREE_CODE (e
) == COMPOUND_EXPR
)
709 e
= ocp_convert (type
, TREE_OPERAND (e
, 1), convtype
, flags
, complain
);
710 if (e
== error_mark_node
)
711 return error_mark_node
;
712 if (e
== TREE_OPERAND (expr
, 1))
714 e
= build2_loc (EXPR_LOCATION (expr
), COMPOUND_EXPR
, TREE_TYPE (e
),
715 TREE_OPERAND (expr
, 0), e
);
716 copy_warning (e
, expr
);
720 complete_type (type
);
721 complete_type (TREE_TYPE (expr
));
723 if ((invalid_conv_diag
724 = targetm
.invalid_conversion (TREE_TYPE (expr
), type
)))
726 if (complain
& tf_error
)
727 error (invalid_conv_diag
);
728 return error_mark_node
;
731 /* FIXME remove when moving to c_fully_fold model. */
732 if (!CLASS_TYPE_P (type
))
734 e
= mark_rvalue_use (e
);
735 tree v
= scalar_constant_value (e
);
736 if (!error_operand_p (v
))
739 if (error_operand_p (e
))
740 return error_mark_node
;
742 if (NULLPTR_TYPE_P (type
) && null_ptr_cst_p (e
))
744 if (complain
& tf_warning
)
745 maybe_warn_zero_as_null_pointer_constant (e
, loc
);
747 if (!TREE_SIDE_EFFECTS (e
))
751 if (MAYBE_CLASS_TYPE_P (type
) && (convtype
& CONV_FORCE_TEMP
))
752 /* We need a new temporary; don't take this shortcut. */;
753 else if (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (e
)))
755 tree etype
= TREE_TYPE (e
);
756 if (same_type_p (type
, etype
))
757 /* The call to fold will not always remove the NOP_EXPR as
758 might be expected, since if one of the types is a typedef;
759 the comparison in fold is just equality of pointers, not a
760 call to comptypes. We don't call fold in this case because
761 that can result in infinite recursion; fold will call
762 convert, which will call ocp_convert, etc. */
764 /* For complex data types, we need to perform componentwise
766 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
767 return convert_to_complex_maybe_fold (type
, e
, dofold
);
768 else if (VECTOR_TYPE_P (type
))
769 return convert_to_vector (type
, rvalue (e
));
770 else if (TREE_CODE (e
) == TARGET_EXPR
)
772 /* Don't build a NOP_EXPR of class type. Instead, change the
773 type of the temporary. */
774 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
775 TREE_TYPE (e
) = TREE_TYPE (TARGET_EXPR_SLOT (e
)) = type
;
778 else if (TREE_CODE (e
) == CONSTRUCTOR
)
780 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
781 TREE_TYPE (e
) = type
;
786 /* We shouldn't be treating objects of ADDRESSABLE type as
788 gcc_assert (!TREE_ADDRESSABLE (type
));
789 return build_nop (type
, e
);
793 e1
= targetm
.convert_to_type (type
, e
);
797 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
799 e
= convert_to_void (e
, ICV_CAST
, complain
);
803 if (INTEGRAL_CODE_P (code
))
805 tree intype
= TREE_TYPE (e
);
808 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
810 /* enum = enum, enum = int, enum = float, (enum)pointer are all
812 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
813 || SCALAR_FLOAT_TYPE_P (intype
))
814 && ! (convtype
& CONV_STATIC
))
815 || TYPE_PTR_P (intype
))
817 if (complain
& tf_error
)
818 permerror (loc
, "conversion from %q#T to %q#T", intype
, type
);
820 return error_mark_node
;
823 /* [expr.static.cast]
825 8. A value of integral or enumeration type can be explicitly
826 converted to an enumeration type. The value is unchanged if
827 the original value is within the range of the enumeration
828 values. Otherwise, the resulting enumeration value is
830 tree val
= fold_for_warn (e
);
831 if ((complain
& tf_warning
)
832 && TREE_CODE (val
) == INTEGER_CST
833 && ENUM_UNDERLYING_TYPE (type
)
834 && !int_fits_type_p (val
, ENUM_UNDERLYING_TYPE (type
)))
835 warning_at (loc
, OPT_Wconversion
,
836 "the result of the conversion is unspecified because "
837 "%qE is outside the range of type %qT",
840 if (MAYBE_CLASS_TYPE_P (intype
))
843 rval
= build_type_conversion (type
, e
);
846 if (complain
& tf_error
)
847 error_at (loc
, "%q#T used where a %qT was expected", intype
, type
);
848 return error_mark_node
;
850 if (code
== BOOLEAN_TYPE
)
852 if (VOID_TYPE_P (intype
))
854 if (complain
& tf_error
)
856 "could not convert %qE from %<void%> to %<bool%>",
858 return error_mark_node
;
861 if (VECTOR_TYPE_P (intype
) && !gnu_vector_type_p (intype
))
863 if (complain
& tf_error
)
864 error_at (loc
, "could not convert %qE from %qH to %qI", expr
,
865 TREE_TYPE (expr
), type
);
866 return error_mark_node
;
869 /* We can't implicitly convert a scoped enum to bool, so convert
870 to the underlying type first. */
871 if (SCOPED_ENUM_P (intype
) && (convtype
& CONV_STATIC
))
872 e
= build_nop (ENUM_UNDERLYING_TYPE (intype
), e
);
873 if (complain
& tf_warning
)
874 return cp_truthvalue_conversion (e
, complain
);
877 /* Prevent bogus -Wint-in-bool-context warnings coming
878 from c_common_truthvalue_conversion down the line. */
879 warning_sentinel
w (warn_int_in_bool_context
);
880 warning_sentinel
c (warn_sign_compare
);
881 return cp_truthvalue_conversion (e
, complain
);
885 converted
= convert_to_integer_maybe_fold (type
, e
, dofold
);
887 /* Ignore any integer overflow caused by the conversion. */
888 return ignore_overflows (converted
, e
);
890 if (INDIRECT_TYPE_P (type
) || TYPE_PTRMEM_P (type
))
891 return cp_convert_to_pointer (type
, e
, dofold
, complain
);
892 if (code
== VECTOR_TYPE
)
894 tree in_vtype
= TREE_TYPE (e
);
895 if (MAYBE_CLASS_TYPE_P (in_vtype
))
898 ret_val
= build_type_conversion (type
, e
);
901 if (complain
& tf_error
)
902 error_at (loc
, "%q#T used where a %qT was expected",
904 return error_mark_node
;
906 return convert_to_vector (type
, rvalue (e
));
908 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
910 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e
)))
913 rval
= build_type_conversion (type
, e
);
916 else if (complain
& tf_error
)
918 "%q#T used where a floating-point value was expected",
921 if (code
== REAL_TYPE
)
922 return convert_to_real_maybe_fold (type
, e
, dofold
);
923 else if (code
== COMPLEX_TYPE
)
924 return convert_to_complex_maybe_fold (type
, e
, dofold
);
927 /* New C++ semantics: since assignment is now based on
928 memberwise copying, if the rhs type is derived from the
929 lhs type, then we may still do a conversion. */
930 if (RECORD_OR_UNION_CODE_P (code
))
932 tree dtype
= TREE_TYPE (e
);
933 tree ctor
= NULL_TREE
;
935 dtype
= TYPE_MAIN_VARIANT (dtype
);
937 /* Conversion between aggregate types. New C++ semantics allow
938 objects of derived type to be cast to objects of base type.
939 Old semantics only allowed this between pointers.
941 There may be some ambiguity between using a constructor
942 vs. using a type conversion operator when both apply. */
946 if (abstract_virtuals_error (NULL_TREE
, type
, complain
))
947 return error_mark_node
;
949 if (BRACE_ENCLOSED_INITIALIZER_P (ctor
))
950 ctor
= perform_implicit_conversion (type
, ctor
, complain
);
951 else if ((flags
& LOOKUP_ONLYCONVERTING
)
952 && ! (CLASS_TYPE_P (dtype
) && DERIVED_FROM_P (type
, dtype
)))
953 /* For copy-initialization, first we create a temp of the proper type
954 with a user-defined conversion sequence, then we direct-initialize
955 the target with the temp (see [dcl.init]). */
956 ctor
= build_user_type_conversion (type
, ctor
, flags
, complain
);
959 releasing_vec
ctor_vec (make_tree_vector_single (ctor
));
960 ctor
= build_special_member_call (NULL_TREE
,
961 complete_ctor_identifier
,
963 type
, flags
, complain
);
966 return build_cplus_new (type
, ctor
, complain
);
969 if (complain
& tf_error
)
971 /* If the conversion failed and expr was an invalid use of pointer to
972 member function, try to report a meaningful error. */
973 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
974 /* We displayed the error message. */;
976 error_at (loc
, "conversion from %qH to non-scalar type %qI requested",
977 TREE_TYPE (expr
), type
);
979 return error_mark_node
;
982 /* If CALL is a call, return the callee; otherwise null. */
985 cp_get_callee (tree call
)
987 if (call
== NULL_TREE
)
989 else if (TREE_CODE (call
) == CALL_EXPR
)
990 return CALL_EXPR_FN (call
);
991 else if (TREE_CODE (call
) == AGGR_INIT_EXPR
)
992 return AGGR_INIT_EXPR_FN (call
);
996 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
1000 cp_get_fndecl_from_callee (tree fn
, bool fold
/* = true */)
1002 if (fn
== NULL_TREE
)
1004 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1006 tree type
= TREE_TYPE (fn
);
1007 if (type
== NULL_TREE
|| !INDIRECT_TYPE_P (type
))
1010 fn
= maybe_constant_init (fn
);
1012 if (TREE_CODE (fn
) == ADDR_EXPR
1013 || TREE_CODE (fn
) == FDESC_EXPR
)
1014 fn
= TREE_OPERAND (fn
, 0);
1015 if (TREE_CODE (fn
) == FUNCTION_DECL
)
1020 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
1021 constexpr machinery. */
1024 cp_get_callee_fndecl (tree call
)
1026 return cp_get_fndecl_from_callee (cp_get_callee (call
));
1029 /* As above, but not using the constexpr machinery. */
1032 cp_get_callee_fndecl_nofold (tree call
)
1034 return cp_get_fndecl_from_callee (cp_get_callee (call
), false);
1037 /* Subroutine of convert_to_void. Warn if we're discarding something with
1038 attribute [[nodiscard]]. */
1041 maybe_warn_nodiscard (tree expr
, impl_conv_void implicit
)
1043 if (!warn_unused_result
|| c_inhibit_evaluation_warnings
)
1047 if (TREE_CODE (expr
) == TARGET_EXPR
)
1048 call
= TARGET_EXPR_INITIAL (expr
);
1049 location_t loc
= cp_expr_loc_or_input_loc (call
);
1050 tree callee
= cp_get_callee (call
);
1054 tree type
= TREE_TYPE (callee
);
1055 if (TYPE_PTRMEMFUNC_P (type
))
1056 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
1057 if (INDIRECT_TYPE_P (type
))
1058 type
= TREE_TYPE (type
);
1060 tree rettype
= TREE_TYPE (type
);
1061 tree fn
= cp_get_fndecl_from_callee (callee
);
1063 if (implicit
!= ICV_CAST
&& fn
1064 && (attr
= lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn
))))
1067 tree args
= TREE_VALUE (attr
);
1069 msg
.escape (TREE_STRING_POINTER (TREE_VALUE (args
)));
1072 ? G_("ignoring return value of %qD, "
1073 "declared with attribute %<nodiscard%>: %<%s%>")
1074 : G_("ignoring return value of %qD, "
1075 "declared with attribute %<nodiscard%>%s"));
1076 const char *raw_msg
= msg
? (const char *) msg
: "";
1077 auto_diagnostic_group d
;
1078 if (warning_at (loc
, OPT_Wunused_result
, format
, fn
, raw_msg
))
1079 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1081 else if (implicit
!= ICV_CAST
1082 && (attr
= lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype
))))
1085 tree args
= TREE_VALUE (attr
);
1087 msg
.escape (TREE_STRING_POINTER (TREE_VALUE (args
)));
1090 ? G_("ignoring returned value of type %qT, "
1091 "declared with attribute %<nodiscard%>: %<%s%>")
1092 : G_("ignoring returned value of type %qT, "
1093 "declared with attribute %<nodiscard%>%s"));
1094 const char *raw_msg
= msg
? (const char *) msg
: "";
1095 auto_diagnostic_group d
;
1096 if (warning_at (loc
, OPT_Wunused_result
, format
, rettype
, raw_msg
))
1099 inform (DECL_SOURCE_LOCATION (fn
),
1100 "in call to %qD, declared here", fn
);
1101 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype
)),
1102 "%qT declared here", rettype
);
1105 else if (TREE_CODE (expr
) == TARGET_EXPR
1106 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type
)))
1108 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1109 result is used, so handle that case here. */
1112 auto_diagnostic_group d
;
1113 if (warning_at (loc
, OPT_Wunused_result
,
1114 "ignoring return value of %qD, "
1115 "declared with attribute %<warn_unused_result%>",
1117 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1120 warning_at (loc
, OPT_Wunused_result
,
1121 "ignoring return value of function "
1122 "declared with attribute %<warn_unused_result%>");
1126 /* When an expression is used in a void context, its value is discarded and
1127 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1128 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1129 in a void context. The C++ standard does not define what an `access' to an
1130 object is, but there is reason to believe that it is the lvalue to rvalue
1131 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1132 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1133 indicates that volatile semantics should be the same between C and C++
1134 where ever possible. C leaves it implementation defined as to what
1135 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1136 the volatile object `vp' points to, unless that is an incomplete type. For
1137 volatile references we do not do this interpretation, because that would
1138 make it impossible to ignore the reference return value from functions. We
1139 issue warnings in the confusing cases.
1141 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1142 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1143 indicates the context of the implicit conversion. */
1146 convert_to_void (tree expr
, impl_conv_void implicit
, tsubst_flags_t complain
)
1148 location_t loc
= cp_expr_loc_or_input_loc (expr
);
1150 if (expr
== error_mark_node
1151 || TREE_TYPE (expr
) == error_mark_node
)
1152 return error_mark_node
;
1154 expr
= maybe_undo_parenthesized_ref (expr
);
1156 expr
= mark_discarded_use (expr
);
1157 if (implicit
== ICV_CAST
)
1158 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1159 mark_exp_read (expr
);
1161 if (!TREE_TYPE (expr
))
1163 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
1164 return error_mark_node
;
1165 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
1167 if (complain
& tf_error
)
1168 error_at (loc
, "pseudo-destructor is not called");
1169 return error_mark_node
;
1172 /* Explicitly evaluate void-converted concept checks since their
1173 satisfaction may produce ill-formed programs. */
1174 if (concept_check_p (expr
))
1175 expr
= evaluate_concept_check (expr
);
1177 if (VOID_TYPE_P (TREE_TYPE (expr
)))
1179 switch (TREE_CODE (expr
))
1183 /* The two parts of a cond expr might be separate lvalues. */
1184 tree op1
= TREE_OPERAND (expr
,1);
1185 tree op2
= TREE_OPERAND (expr
,2);
1186 bool side_effects
= ((op1
&& TREE_SIDE_EFFECTS (op1
))
1187 || TREE_SIDE_EFFECTS (op2
));
1188 tree new_op1
, new_op2
;
1189 new_op1
= NULL_TREE
;
1190 if (implicit
!= ICV_CAST
&& !side_effects
)
1193 new_op1
= convert_to_void (op1
, ICV_SECOND_OF_COND
, complain
);
1194 new_op2
= convert_to_void (op2
, ICV_THIRD_OF_COND
, complain
);
1199 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1200 new_op2
= convert_to_void (op2
, ICV_CAST
, complain
);
1203 expr
= build3_loc (loc
, COND_EXPR
, TREE_TYPE (new_op2
),
1204 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
1210 /* The second part of a compound expr contains the value. */
1211 tree op1
= TREE_OPERAND (expr
,1);
1213 if (implicit
!= ICV_CAST
&& !warning_suppressed_p (expr
/* What warning? */))
1214 new_op1
= convert_to_void (op1
, ICV_RIGHT_OF_COMMA
, complain
);
1216 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1220 tree t
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (new_op1
),
1221 TREE_OPERAND (expr
, 0), new_op1
);
1228 case NON_LVALUE_EXPR
:
1230 /* These have already decayed to rvalue. */
1233 case CALL_EXPR
: /* We have a special meaning for volatile void fn(). */
1234 /* cdtors may return this or void, depending on
1235 targetm.cxx.cdtor_returns_this, but this shouldn't affect our
1236 decisions here: neither nodiscard warnings (nodiscard dtors
1237 are nonsensical and ctors have a different behavior with that
1238 attribute that is handled in the TARGET_EXPR case), nor should
1239 any constexpr or template instantiations be affected by an ABI
1240 property that is, or at least ought to be transparent to the
1242 if (tree fn
= cp_get_callee_fndecl_nofold (expr
))
1243 if (DECL_CONSTRUCTOR_P (fn
) || DECL_DESTRUCTOR_P (fn
))
1246 if (complain
& tf_warning
)
1247 maybe_warn_nodiscard (expr
, implicit
);
1252 tree type
= TREE_TYPE (expr
);
1253 int is_reference
= TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1254 int is_volatile
= TYPE_VOLATILE (type
);
1256 complete_type (type
);
1257 int is_complete
= COMPLETE_TYPE_P (type
);
1259 /* Can't load the value if we don't know the type. */
1260 if (is_volatile
&& !is_complete
)
1262 if (complain
& tf_warning
)
1266 warning_at (loc
, 0, "conversion to void will not access "
1267 "object of incomplete type %qT", type
);
1269 case ICV_SECOND_OF_COND
:
1270 warning_at (loc
, 0, "indirection will not access object of "
1271 "incomplete type %qT in second operand "
1272 "of conditional expression", type
);
1274 case ICV_THIRD_OF_COND
:
1275 warning_at (loc
, 0, "indirection will not access object of "
1276 "incomplete type %qT in third operand "
1277 "of conditional expression", type
);
1279 case ICV_RIGHT_OF_COMMA
:
1280 warning_at (loc
, 0, "indirection will not access object of "
1281 "incomplete type %qT in right operand of "
1282 "comma operator", type
);
1284 case ICV_LEFT_OF_COMMA
:
1285 warning_at (loc
, 0, "indirection will not access object of "
1286 "incomplete type %qT in left operand of "
1287 "comma operator", type
);
1290 warning_at (loc
, 0, "indirection will not access object of "
1291 "incomplete type %qT in statement", type
);
1293 case ICV_THIRD_IN_FOR
:
1294 warning_at (loc
, 0, "indirection will not access object of "
1295 "incomplete type %qT in for increment "
1296 "expression", type
);
1302 /* Don't load the value if this is an implicit dereference, or if
1303 the type needs to be handled by ctors/dtors. */
1304 else if (is_volatile
&& is_reference
)
1306 if (complain
& tf_warning
)
1310 warning_at (loc
, 0, "conversion to void will not access "
1311 "object of type %qT", type
);
1313 case ICV_SECOND_OF_COND
:
1314 warning_at (loc
, 0, "implicit dereference will not access "
1315 "object of type %qT in second operand of "
1316 "conditional expression", type
);
1318 case ICV_THIRD_OF_COND
:
1319 warning_at (loc
, 0, "implicit dereference will not access "
1320 "object of type %qT in third operand of "
1321 "conditional expression", type
);
1323 case ICV_RIGHT_OF_COMMA
:
1324 warning_at (loc
, 0, "implicit dereference will not access "
1325 "object of type %qT in right operand of "
1326 "comma operator", type
);
1328 case ICV_LEFT_OF_COMMA
:
1329 warning_at (loc
, 0, "implicit dereference will not access "
1330 "object of type %qT in left operand of comma "
1334 warning_at (loc
, 0, "implicit dereference will not access "
1335 "object of type %qT in statement", type
);
1337 case ICV_THIRD_IN_FOR
:
1338 warning_at (loc
, 0, "implicit dereference will not access "
1339 "object of type %qT in for increment expression",
1346 else if (is_volatile
&& TREE_ADDRESSABLE (type
))
1348 if (complain
& tf_warning
)
1352 warning_at (loc
, 0, "conversion to void will not access "
1353 "object of non-trivially-copyable type %qT",
1356 case ICV_SECOND_OF_COND
:
1357 warning_at (loc
, 0, "indirection will not access object of "
1358 "non-trivially-copyable type %qT in second "
1359 "operand of conditional expression", type
);
1361 case ICV_THIRD_OF_COND
:
1362 warning_at (loc
, 0, "indirection will not access object of "
1363 "non-trivially-copyable type %qT in third "
1364 "operand of conditional expression", type
);
1366 case ICV_RIGHT_OF_COMMA
:
1367 warning_at (loc
, 0, "indirection will not access object of "
1368 "non-trivially-copyable type %qT in right "
1369 "operand of comma operator", type
);
1371 case ICV_LEFT_OF_COMMA
:
1372 warning_at (loc
, 0, "indirection will not access object of "
1373 "non-trivially-copyable type %qT in left "
1374 "operand of comma operator", type
);
1377 warning_at (loc
, 0, "indirection will not access object of "
1378 "non-trivially-copyable type %qT in statement",
1381 case ICV_THIRD_IN_FOR
:
1382 warning_at (loc
, 0, "indirection will not access object of "
1383 "non-trivially-copyable type %qT in for "
1384 "increment expression", type
);
1390 if (is_reference
|| !is_volatile
|| !is_complete
|| TREE_ADDRESSABLE (type
))
1392 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1393 operation is stripped off. Note that we don't warn about
1394 - an expression with TREE_NO_WARNING set. (For an example of
1395 such expressions, see build_over_call in call.cc.)
1396 - automatic dereferencing of references, since the user cannot
1397 control it. (See also warn_if_unused_value() in c-common.cc.) */
1398 if (warn_unused_value
1399 && implicit
!= ICV_CAST
1400 && (complain
& tf_warning
)
1401 && !warning_suppressed_p (expr
, OPT_Wunused_value
)
1403 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1404 expr
= TREE_OPERAND (expr
, 0);
1405 if (TREE_CODE (expr
) == CALL_EXPR
1406 && (complain
& tf_warning
))
1407 maybe_warn_nodiscard (expr
, implicit
);
1415 /* External variables might be incomplete. */
1416 tree type
= TREE_TYPE (expr
);
1418 if (TYPE_VOLATILE (type
)
1419 && !COMPLETE_TYPE_P (complete_type (type
))
1420 && (complain
& tf_warning
))
1424 warning_at (loc
, 0, "conversion to void will not access "
1425 "object %qE of incomplete type %qT", expr
, type
);
1427 case ICV_SECOND_OF_COND
:
1428 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1429 "not be accessed in second operand of "
1430 "conditional expression", expr
, type
);
1432 case ICV_THIRD_OF_COND
:
1433 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1434 "not be accessed in third operand of "
1435 "conditional expression", expr
, type
);
1437 case ICV_RIGHT_OF_COMMA
:
1438 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1439 "not be accessed in right operand of comma operator",
1442 case ICV_LEFT_OF_COMMA
:
1443 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1444 "not be accessed in left operand of comma operator",
1448 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1449 "not be accessed in statement", expr
, type
);
1451 case ICV_THIRD_IN_FOR
:
1452 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1453 "not be accessed in for increment expression",
1464 /* Don't bother with the temporary object returned from a function if
1465 we don't use it, don't need to destroy it, and won't abort in
1466 assign_temp. We'll still
1467 allocate space for it in expand_call or declare_return_variable,
1468 but we don't need to track it through all the tree phases. */
1469 if (TARGET_EXPR_IMPLICIT_P (expr
)
1470 && !TREE_ADDRESSABLE (TREE_TYPE (expr
)))
1472 tree init
= TARGET_EXPR_INITIAL (expr
);
1473 if (TREE_CODE (init
) == AGGR_INIT_EXPR
1474 && !AGGR_INIT_VIA_CTOR_P (init
))
1476 tree fn
= AGGR_INIT_EXPR_FN (init
);
1477 expr
= build_call_array_loc (input_location
,
1478 TREE_TYPE (TREE_TYPE
1481 aggr_init_expr_nargs (init
),
1482 AGGR_INIT_EXPR_ARGP (init
));
1485 if (complain
& tf_warning
)
1486 maybe_warn_nodiscard (expr
, implicit
);
1491 expr
= resolve_nondeduced_context (expr
, complain
);
1492 if (!mark_single_function (expr
, complain
))
1493 return error_mark_node
;
1498 if (TREE_CODE (probe
) == ADDR_EXPR
)
1499 probe
= TREE_OPERAND (expr
, 0);
1500 if (type_unknown_p (probe
))
1502 /* [over.over] enumerates the places where we can take the address
1503 of an overloaded function, and this is not one of them. */
1504 if (complain
& tf_error
)
1508 error_at (loc
, "conversion to void "
1509 "cannot resolve address of overloaded function");
1511 case ICV_SECOND_OF_COND
:
1512 error_at (loc
, "second operand of conditional expression "
1513 "cannot resolve address of overloaded function");
1515 case ICV_THIRD_OF_COND
:
1516 error_at (loc
, "third operand of conditional expression "
1517 "cannot resolve address of overloaded function");
1519 case ICV_RIGHT_OF_COMMA
:
1520 error_at (loc
, "right operand of comma operator "
1521 "cannot resolve address of overloaded function");
1523 case ICV_LEFT_OF_COMMA
:
1524 error_at (loc
, "left operand of comma operator "
1525 "cannot resolve address of overloaded function");
1528 error_at (loc
, "statement "
1529 "cannot resolve address of overloaded function");
1531 case ICV_THIRD_IN_FOR
:
1532 error_at (loc
, "for increment expression "
1533 "cannot resolve address of overloaded function");
1537 return error_mark_node
;
1540 else if (implicit
!= ICV_CAST
&& probe
== expr
&& is_overloaded_fn (probe
))
1542 /* Only warn when there is no &. */
1543 if (complain
& tf_warning
)
1546 case ICV_SECOND_OF_COND
:
1547 warning_at (loc
, OPT_Waddress
,
1548 "second operand of conditional expression "
1549 "is a reference, not call, to function %qE", expr
);
1551 case ICV_THIRD_OF_COND
:
1552 warning_at (loc
, OPT_Waddress
,
1553 "third operand of conditional expression "
1554 "is a reference, not call, to function %qE", expr
);
1556 case ICV_RIGHT_OF_COMMA
:
1557 warning_at (loc
, OPT_Waddress
,
1558 "right operand of comma operator "
1559 "is a reference, not call, to function %qE", expr
);
1561 case ICV_LEFT_OF_COMMA
:
1562 warning_at (loc
, OPT_Waddress
,
1563 "left operand of comma operator "
1564 "is a reference, not call, to function %qE", expr
);
1567 warning_at (loc
, OPT_Waddress
,
1568 "statement is a reference, not call, to function %qE",
1571 case ICV_THIRD_IN_FOR
:
1572 warning_at (loc
, OPT_Waddress
,
1573 "for increment expression "
1574 "is a reference, not call, to function %qE", expr
);
1580 if (TREE_CODE (expr
) == COMPONENT_REF
)
1581 expr
= TREE_OPERAND (expr
, 0);
1585 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1587 if (implicit
!= ICV_CAST
1588 && warn_unused_value
1589 && !warning_suppressed_p (expr
, OPT_Wunused_value
)
1590 && !processing_template_decl
1591 && !cp_unevaluated_operand
1592 && (complain
& tf_warning
))
1594 /* The middle end does not warn about expressions that have
1595 been explicitly cast to void, so we must do so here. */
1596 if (!TREE_SIDE_EFFECTS (expr
))
1600 case ICV_SECOND_OF_COND
:
1601 warning_at (loc
, OPT_Wunused_value
,
1602 "second operand of conditional expression "
1605 case ICV_THIRD_OF_COND
:
1606 warning_at (loc
, OPT_Wunused_value
,
1607 "third operand of conditional expression "
1610 case ICV_RIGHT_OF_COMMA
:
1611 warning_at (loc
, OPT_Wunused_value
,
1612 "right operand of comma operator has no effect");
1614 case ICV_LEFT_OF_COMMA
:
1615 warning_at (loc
, OPT_Wunused_value
,
1616 "left operand of comma operator has no effect");
1619 warning_at (loc
, OPT_Wunused_value
,
1620 "statement has no effect");
1622 case ICV_THIRD_IN_FOR
:
1623 warning_at (loc
, OPT_Wunused_value
,
1624 "for increment expression has no effect");
1633 /* We might like to warn about (say) "(int) f()", as the
1634 cast has no effect, but the compiler itself will
1635 generate implicit conversions under some
1636 circumstances. (For example a block copy will be
1637 turned into a call to "__builtin_memcpy", with a
1638 conversion of the return value to an appropriate
1639 type.) So, to avoid false positives, we strip
1640 conversions. Do not use STRIP_NOPs because it will
1641 not strip conversions to "void", as that is not a
1642 mode-preserving conversion. */
1643 while (TREE_CODE (e
) == NOP_EXPR
)
1644 e
= TREE_OPERAND (e
, 0);
1646 enum tree_code code
= TREE_CODE (e
);
1647 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
1648 if (tclass
== tcc_comparison
1649 || tclass
== tcc_unary
1650 || tclass
== tcc_binary
1651 || code
== VEC_PERM_EXPR
1652 || code
== VEC_COND_EXPR
)
1653 warn_if_unused_value (e
, loc
);
1656 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
1658 if (! TREE_SIDE_EFFECTS (expr
))
1663 /* Create an expression whose value is that of EXPR,
1664 converted to type TYPE. The TREE_TYPE of the value
1665 is always TYPE. This function implements all reasonable
1666 conversions; callers should filter out those that are
1667 not permitted by the language being compiled.
1669 Most of this routine is from build_reinterpret_cast.
1671 The back end cannot call cp_convert (what was convert) because
1672 conversions to/from basetypes may involve memory references
1673 (vbases) and adding or subtracting small values (multiple
1674 inheritance), but it calls convert from the constant folding code
1675 on subtrees of already built trees after it has ripped them apart.
1677 Also, if we ever support range variables, we'll probably also have to
1678 do a little bit more work. */
1681 convert (tree type
, tree expr
)
1685 if (type
== error_mark_node
|| expr
== error_mark_node
)
1686 return error_mark_node
;
1688 intype
= TREE_TYPE (expr
);
1690 if (INDIRECT_TYPE_P (type
) && INDIRECT_TYPE_P (intype
))
1691 return build_nop (type
, expr
);
1693 return ocp_convert (type
, expr
, CONV_BACKEND_CONVERT
,
1694 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
1695 tf_warning_or_error
);
1698 /* Like convert, but in a static initializer (called from
1699 convert_and_check). */
1702 convert_init (tree type
, tree expr
)
1704 return convert (type
, expr
);
1707 /* Like cp_convert, except permit conversions to take place which
1708 are not normally allowed due to access restrictions
1709 (such as conversion from sub-type to private super-type). */
1712 convert_force (tree type
, tree expr
, int convtype
, tsubst_flags_t complain
)
1715 enum tree_code code
= TREE_CODE (type
);
1717 if (code
== REFERENCE_TYPE
)
1718 return convert_to_reference (type
, e
, CONV_C_CAST
, 0,
1719 NULL_TREE
, complain
);
1721 if (code
== POINTER_TYPE
)
1722 return convert_to_pointer_force (type
, e
, complain
);
1724 /* From typeck.cc convert_for_assignment */
1725 if (((TYPE_PTR_P (TREE_TYPE (e
)) && TREE_CODE (e
) == ADDR_EXPR
1726 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1727 || integer_zerop (e
)
1728 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1729 && TYPE_PTRMEMFUNC_P (type
))
1730 /* compatible pointer to member functions. */
1731 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1,
1732 /*c_cast_p=*/1, complain
);
1734 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
, complain
);
1737 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1738 exists, return the attempted conversion. This may
1739 return ERROR_MARK_NODE if the conversion is not
1740 allowed (references private members, etc).
1741 If no conversion exists, NULL_TREE is returned.
1743 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1744 object parameter, or by the second standard conversion sequence if
1745 that doesn't do it. This will probably wait for an overloading rewrite.
1749 build_type_conversion (tree xtype
, tree expr
)
1751 /* C++: check to see if we can convert this aggregate type
1752 into the required type. */
1753 return build_user_type_conversion (xtype
, expr
, LOOKUP_NORMAL
,
1754 tf_warning_or_error
);
1757 /* Convert the given EXPR to one of a group of types suitable for use in an
1758 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1759 which indicates which types are suitable. If COMPLAIN is true, complain
1760 about ambiguity; otherwise, the caller will deal with it. */
1763 build_expr_type_conversion (int desires
, tree expr
, bool complain
)
1765 tree basetype
= TREE_TYPE (expr
);
1766 tree conv
= NULL_TREE
;
1767 tree winner
= NULL_TREE
;
1769 if (null_node_p (expr
)
1770 && (desires
& WANT_INT
)
1771 && !(desires
& WANT_NULL
))
1774 expansion_point_location_if_in_system_header (input_location
);
1776 warning_at (loc
, OPT_Wconversion_null
,
1777 "converting NULL to non-pointer type");
1780 if (basetype
== error_mark_node
)
1781 return error_mark_node
;
1783 if (! MAYBE_CLASS_TYPE_P (basetype
))
1784 switch (TREE_CODE (basetype
))
1787 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1792 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1794 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1796 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1798 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1802 return (desires
& WANT_POINTER
) ? decay_conversion (expr
,
1803 tf_warning_or_error
)
1807 if (!gnu_vector_type_p (basetype
))
1811 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1813 switch (TREE_CODE (TREE_TYPE (basetype
)))
1817 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1819 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1821 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1830 /* The code for conversions from class type is currently only used for
1831 delete expressions. Other expressions are handled by build_new_op. */
1832 if (!complete_type_or_maybe_complain (basetype
, expr
, complain
))
1833 return error_mark_node
;
1834 if (!TYPE_HAS_CONVERSION (basetype
))
1837 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1841 tree cand
= TREE_VALUE (conv
);
1842 cand
= OVL_FIRST (cand
);
1844 if (winner
&& winner
== cand
)
1847 if (DECL_NONCONVERTING_P (cand
))
1850 candidate
= non_reference (TREE_TYPE (TREE_TYPE (cand
)));
1852 switch (TREE_CODE (candidate
))
1856 win
= (desires
& WANT_INT
); break;
1858 win
= (desires
& WANT_ENUM
); break;
1860 win
= (desires
& WANT_FLOAT
); break;
1862 win
= (desires
& WANT_POINTER
); break;
1866 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1868 switch (TREE_CODE (TREE_TYPE (candidate
)))
1872 win
= (desires
& WANT_INT
); break;
1874 win
= (desires
& WANT_ENUM
); break;
1876 win
= (desires
& WANT_FLOAT
); break;
1883 /* A wildcard could be instantiated to match any desired
1884 type, but we can't deduce the template argument. */
1885 if (WILDCARD_TYPE_P (candidate
))
1892 if (TREE_CODE (cand
) == TEMPLATE_DECL
)
1895 error ("default type conversion cannot deduce template"
1896 " argument for %qD", cand
);
1897 return error_mark_node
;
1903 = non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1905 if (!same_type_ignoring_top_level_qualifiers_p (winner_type
,
1910 error ("ambiguous default type conversion from %qT",
1912 inform (input_location
,
1913 " candidate conversions include %qD and %qD",
1916 return error_mark_node
;
1926 tree type
= non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1927 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
,
1928 tf_warning_or_error
);
1934 /* Implements integral promotion (4.1) and float->double promotion. */
1937 type_promotes_to (tree type
)
1941 if (type
== error_mark_node
)
1942 return error_mark_node
;
1944 type
= TYPE_MAIN_VARIANT (type
);
1946 /* Check for promotions of target-defined types first. */
1947 promoted_type
= targetm
.promoted_type (type
);
1949 return promoted_type
;
1951 /* bool always promotes to int (not unsigned), even if it's the same
1953 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1954 type
= integer_type_node
;
1956 /* Normally convert enums to int, but convert wide enums to something
1957 wider. Scoped enums don't promote, but pretend they do for backward
1958 ABI bug compatibility wrt varargs. */
1959 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1960 || type
== char8_type_node
1961 || type
== char16_type_node
1962 || type
== char32_type_node
1963 || type
== wchar_type_node
)
1967 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1969 prom
= ENUM_UNDERLYING_TYPE (prom
);
1970 if (!ENUM_IS_SCOPED (type
)
1971 && ENUM_FIXED_UNDERLYING_TYPE_P (type
))
1973 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1974 whose underlying type is fixed (10.2) can be converted to a
1975 prvalue of its underlying type. Moreover, if integral promotion
1976 can be applied to its underlying type, a prvalue of an unscoped
1977 enumeration type whose underlying type is fixed can also be
1978 converted to a prvalue of the promoted underlying type. */
1979 return type_promotes_to (prom
);
1983 int precision
= MAX (TYPE_PRECISION (type
),
1984 TYPE_PRECISION (integer_type_node
));
1985 tree totype
= c_common_type_for_size (precision
, 0);
1986 if (TYPE_UNSIGNED (prom
)
1987 && ! int_fits_type_p (TYPE_MAX_VALUE (prom
), totype
))
1988 prom
= c_common_type_for_size (precision
, 1);
1991 if (SCOPED_ENUM_P (type
))
1993 if (abi_version_crosses (6)
1994 && TYPE_MODE (prom
) != TYPE_MODE (type
))
1995 warning (OPT_Wabi
, "scoped enum %qT passed through %<...%> as "
1996 "%qT before %<-fabi-version=6%>, %qT after",
1997 type
, prom
, ENUM_UNDERLYING_TYPE (type
));
1998 if (!abi_version_at_least (6))
2004 else if (c_promoting_integer_type_p (type
))
2006 /* Retain unsignedness if really not getting bigger. */
2007 if (TYPE_UNSIGNED (type
)
2008 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2009 type
= unsigned_type_node
;
2011 type
= integer_type_node
;
2013 else if (type
== float_type_node
)
2014 type
= double_type_node
;
2019 /* The routines below this point are carefully written to conform to
2020 the standard. They use the same terminology, and follow the rules
2021 closely. Although they are used only in pt.cc at the moment, they
2022 should presumably be used everywhere in the future. */
2024 /* True iff EXPR can be converted to TYPE via a qualification conversion.
2025 Callers should check for identical types before calling this function. */
2028 can_convert_qual (tree type
, tree expr
)
2030 tree expr_type
= TREE_TYPE (expr
);
2031 gcc_assert (!same_type_p (type
, expr_type
));
2033 /* A function pointer conversion also counts as a Qualification Adjustment
2034 under [over.ics.scs]. */
2035 if (fnptr_conv_p (type
, expr_type
))
2038 if (TYPE_PTR_P (type
) && TYPE_PTR_P (expr_type
))
2039 return comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (expr_type
));
2040 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (expr_type
))
2041 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
2042 TYPE_PTRMEM_CLASS_TYPE (expr_type
))
2043 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type
),
2044 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type
)));
2049 /* Attempt to perform qualification conversions on EXPR to convert it
2050 to TYPE. Return the resulting expression, or error_mark_node if
2051 the conversion was impossible. Since this is only used by
2052 convert_nontype_argument, we fold the conversion. */
2055 perform_qualification_conversions (tree type
, tree expr
)
2059 expr_type
= TREE_TYPE (expr
);
2061 if (same_type_p (type
, expr_type
))
2063 else if (can_convert_qual (type
, expr
))
2064 return cp_fold_convert (type
, expr
);
2066 return error_mark_node
;
2069 /* True iff T is a transaction-safe function type. */
2072 tx_safe_fn_type_p (tree t
)
2074 if (!FUNC_OR_METHOD_TYPE_P (t
))
2076 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t
));
2079 /* Return the transaction-unsafe variant of transaction-safe function type
2083 tx_unsafe_fn_variant (tree t
)
2085 gcc_assert (tx_safe_fn_type_p (t
));
2086 tree attrs
= remove_attribute ("transaction_safe",
2087 TYPE_ATTRIBUTES (t
));
2088 return cp_build_type_attribute_variant (t
, attrs
);
2091 /* Return true iff FROM can convert to TO by a transaction-safety
2095 can_convert_tx_safety (tree to
, tree from
)
2097 return (flag_tm
&& tx_safe_fn_type_p (from
)
2098 && same_type_p (to
, tx_unsafe_fn_variant (from
)));
2101 /* Return true iff FROM can convert to TO by dropping noexcept.
2102 This is just a subroutine of fnptr_conv_p. */
2105 noexcept_conv_p (tree to
, tree from
)
2107 if (!flag_noexcept_type
)
2110 if (TREE_CODE (to
) != TREE_CODE (from
))
2112 if (!FUNC_OR_METHOD_TYPE_P (from
))
2114 if (!type_throw_all_p (to
)
2115 || type_throw_all_p (from
))
2117 tree v
= build_exception_variant (from
, NULL_TREE
);
2118 return same_type_p (to
, v
);
2121 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2124 fnptr_conv_p (tree to
, tree from
)
2128 if (TYPE_PTRMEMFUNC_P (t
)
2129 && TYPE_PTRMEMFUNC_P (f
))
2131 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2132 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2134 if (INDIRECT_TYPE_P (t
)
2135 && INDIRECT_TYPE_P (f
))
2141 return (noexcept_conv_p (t
, f
)
2142 || can_convert_tx_safety (t
, f
));
2145 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2146 conversions or conversions to the same type. */
2149 strip_fnptr_conv (tree fn
)
2151 while (TREE_CODE (fn
) == NOP_EXPR
)
2153 tree op
= TREE_OPERAND (fn
, 0);
2154 tree ft
= TREE_TYPE (fn
);
2155 tree ot
= TREE_TYPE (op
);
2156 if (same_type_p (ft
, ot
)
2157 || fnptr_conv_p (ft
, ot
))