1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2019 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.c, convert_to_integer[_maybe_fold].
56 In c-typeck.c, build_binary_op_nodefault (boolean ops),
57 and c_common_truthvalue_conversion.
58 In expr.c: expand_expr, for operands of a MULT_EXPR.
59 In fold-const.c: fold.
60 In tree.c: 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 (POINTER_SIZE
, 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_sfinae (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
605 cp_fold_convert (tree type
, tree expr
)
608 if (TREE_TYPE (expr
) == type
)
610 else if (TREE_CODE (expr
) == PTRMEM_CST
611 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
612 PTRMEM_CST_CLASS (expr
)))
614 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
615 conv
= copy_node (expr
);
616 TREE_TYPE (conv
) = type
;
618 else if (TYPE_PTRMEM_P (type
))
620 conv
= convert_ptrmem (type
, expr
, true, false,
621 tf_warning_or_error
);
622 conv
= cp_fully_fold (conv
);
626 conv
= fold_convert (type
, expr
);
627 conv
= ignore_overflows (conv
, expr
);
632 /* C++ conversions, preference to static cast conversions. */
635 cp_convert (tree type
, tree expr
, tsubst_flags_t complain
)
637 return ocp_convert (type
, expr
, CONV_OLD_CONVERT
, LOOKUP_NORMAL
, complain
);
640 /* C++ equivalent of convert_and_check but using cp_convert as the
643 Convert EXPR to TYPE, warning about conversion problems with constants.
644 Invoke this function on every expression that is converted implicitly,
645 i.e. because of language rules and not because of an explicit cast. */
648 cp_convert_and_check (tree type
, tree expr
, tsubst_flags_t complain
)
652 if (TREE_TYPE (expr
) == type
)
654 if (expr
== error_mark_node
)
656 result
= cp_convert (type
, expr
, complain
);
658 if ((complain
& tf_warning
)
659 && c_inhibit_evaluation_warnings
== 0)
661 tree folded
= cp_fully_fold (expr
);
664 folded_result
= result
;
667 /* Avoid bogus -Wparentheses warnings. */
668 warning_sentinel
w (warn_parentheses
);
669 warning_sentinel
c (warn_int_in_bool_context
);
670 folded_result
= cp_convert (type
, folded
, tf_none
);
672 folded_result
= fold_simple (folded_result
);
673 if (!TREE_OVERFLOW_P (folded
)
674 && folded_result
!= error_mark_node
)
675 warnings_for_convert_and_check (cp_expr_loc_or_input_loc (expr
),
676 type
, folded
, folded_result
);
684 FLAGS indicates how we should behave. */
687 ocp_convert (tree type
, tree expr
, int convtype
, int flags
,
688 tsubst_flags_t complain
)
691 enum tree_code code
= TREE_CODE (type
);
692 const char *invalid_conv_diag
;
694 location_t loc
= cp_expr_loc_or_input_loc (expr
);
695 bool dofold
= (convtype
& CONV_FOLD
);
697 if (error_operand_p (e
) || type
== error_mark_node
)
698 return error_mark_node
;
700 complete_type (type
);
701 complete_type (TREE_TYPE (expr
));
703 if ((invalid_conv_diag
704 = targetm
.invalid_conversion (TREE_TYPE (expr
), type
)))
706 if (complain
& tf_error
)
707 error (invalid_conv_diag
);
708 return error_mark_node
;
711 /* FIXME remove when moving to c_fully_fold model. */
712 if (!CLASS_TYPE_P (type
))
714 e
= mark_rvalue_use (e
);
715 e
= scalar_constant_value (e
);
717 if (error_operand_p (e
))
718 return error_mark_node
;
720 if (NULLPTR_TYPE_P (type
) && null_ptr_cst_p (e
))
722 if (complain
& tf_warning
)
723 maybe_warn_zero_as_null_pointer_constant (e
, loc
);
725 if (!TREE_SIDE_EFFECTS (e
))
729 if (MAYBE_CLASS_TYPE_P (type
) && (convtype
& CONV_FORCE_TEMP
))
730 /* We need a new temporary; don't take this shortcut. */;
731 else if (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (e
)))
733 tree etype
= TREE_TYPE (e
);
734 if (same_type_p (type
, etype
))
735 /* The call to fold will not always remove the NOP_EXPR as
736 might be expected, since if one of the types is a typedef;
737 the comparison in fold is just equality of pointers, not a
738 call to comptypes. We don't call fold in this case because
739 that can result in infinite recursion; fold will call
740 convert, which will call ocp_convert, etc. */
742 /* For complex data types, we need to perform componentwise
744 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
745 return convert_to_complex_maybe_fold (type
, e
, dofold
);
746 else if (VECTOR_TYPE_P (type
))
747 return convert_to_vector (type
, e
);
748 else if (TREE_CODE (e
) == TARGET_EXPR
)
750 /* Don't build a NOP_EXPR of class type. Instead, change the
751 type of the temporary. */
752 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
753 TREE_TYPE (e
) = TREE_TYPE (TARGET_EXPR_SLOT (e
)) = type
;
756 else if (TREE_CODE (e
) == CONSTRUCTOR
)
758 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, etype
));
759 TREE_TYPE (e
) = type
;
764 /* We shouldn't be treating objects of ADDRESSABLE type as
766 gcc_assert (!TREE_ADDRESSABLE (type
));
767 return build_nop (type
, e
);
771 e1
= targetm
.convert_to_type (type
, e
);
775 if (code
== VOID_TYPE
&& (convtype
& CONV_STATIC
))
777 e
= convert_to_void (e
, ICV_CAST
, complain
);
781 if (INTEGRAL_CODE_P (code
))
783 tree intype
= TREE_TYPE (e
);
786 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
788 /* enum = enum, enum = int, enum = float, (enum)pointer are all
790 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype
)
791 || TREE_CODE (intype
) == REAL_TYPE
)
792 && ! (convtype
& CONV_STATIC
))
793 || TYPE_PTR_P (intype
))
795 if (complain
& tf_error
)
796 permerror (loc
, "conversion from %q#T to %q#T", intype
, type
);
798 return error_mark_node
;
801 /* [expr.static.cast]
803 8. A value of integral or enumeration type can be explicitly
804 converted to an enumeration type. The value is unchanged if
805 the original value is within the range of the enumeration
806 values. Otherwise, the resulting enumeration value is
808 tree val
= fold_for_warn (e
);
809 if ((complain
& tf_warning
)
810 && TREE_CODE (val
) == INTEGER_CST
811 && ENUM_UNDERLYING_TYPE (type
)
812 && !int_fits_type_p (val
, ENUM_UNDERLYING_TYPE (type
)))
813 warning_at (loc
, OPT_Wconversion
,
814 "the result of the conversion is unspecified because "
815 "%qE is outside the range of type %qT",
818 if (MAYBE_CLASS_TYPE_P (intype
))
821 rval
= build_type_conversion (type
, e
);
824 if (complain
& tf_error
)
825 error_at (loc
, "%q#T used where a %qT was expected", intype
, type
);
826 return error_mark_node
;
828 if (code
== BOOLEAN_TYPE
)
830 if (VOID_TYPE_P (intype
))
832 if (complain
& tf_error
)
834 "could not convert %qE from %<void%> to %<bool%>",
836 return error_mark_node
;
839 /* We can't implicitly convert a scoped enum to bool, so convert
840 to the underlying type first. */
841 if (SCOPED_ENUM_P (intype
) && (convtype
& CONV_STATIC
))
842 e
= build_nop (ENUM_UNDERLYING_TYPE (intype
), e
);
843 if (complain
& tf_warning
)
844 return cp_truthvalue_conversion (e
, complain
);
847 /* Prevent bogus -Wint-in-bool-context warnings coming
848 from c_common_truthvalue_conversion down the line. */
849 warning_sentinel
w (warn_int_in_bool_context
);
850 warning_sentinel
c (warn_sign_compare
);
851 return cp_truthvalue_conversion (e
, complain
);
855 converted
= convert_to_integer_maybe_fold (type
, e
, dofold
);
857 /* Ignore any integer overflow caused by the conversion. */
858 return ignore_overflows (converted
, e
);
860 if (INDIRECT_TYPE_P (type
) || TYPE_PTRMEM_P (type
))
861 return cp_convert_to_pointer (type
, e
, dofold
, complain
);
862 if (code
== VECTOR_TYPE
)
864 tree in_vtype
= TREE_TYPE (e
);
865 if (MAYBE_CLASS_TYPE_P (in_vtype
))
868 ret_val
= build_type_conversion (type
, e
);
871 if (complain
& tf_error
)
872 error_at (loc
, "%q#T used where a %qT was expected",
874 return error_mark_node
;
876 return convert_to_vector (type
, e
);
878 if (code
== REAL_TYPE
|| code
== COMPLEX_TYPE
)
880 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e
)))
883 rval
= build_type_conversion (type
, e
);
886 else if (complain
& tf_error
)
888 "%q#T used where a floating-point value was expected",
891 if (code
== REAL_TYPE
)
892 return convert_to_real_maybe_fold (type
, e
, dofold
);
893 else if (code
== COMPLEX_TYPE
)
894 return convert_to_complex_maybe_fold (type
, e
, dofold
);
897 /* New C++ semantics: since assignment is now based on
898 memberwise copying, if the rhs type is derived from the
899 lhs type, then we may still do a conversion. */
900 if (RECORD_OR_UNION_CODE_P (code
))
902 tree dtype
= TREE_TYPE (e
);
903 tree ctor
= NULL_TREE
;
905 dtype
= TYPE_MAIN_VARIANT (dtype
);
907 /* Conversion between aggregate types. New C++ semantics allow
908 objects of derived type to be cast to objects of base type.
909 Old semantics only allowed this between pointers.
911 There may be some ambiguity between using a constructor
912 vs. using a type conversion operator when both apply. */
916 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
917 return error_mark_node
;
919 if (BRACE_ENCLOSED_INITIALIZER_P (ctor
))
920 ctor
= perform_implicit_conversion (type
, ctor
, complain
);
921 else if ((flags
& LOOKUP_ONLYCONVERTING
)
922 && ! (CLASS_TYPE_P (dtype
) && DERIVED_FROM_P (type
, dtype
)))
923 /* For copy-initialization, first we create a temp of the proper type
924 with a user-defined conversion sequence, then we direct-initialize
925 the target with the temp (see [dcl.init]). */
926 ctor
= build_user_type_conversion (type
, ctor
, flags
, complain
);
929 releasing_vec
ctor_vec (make_tree_vector_single (ctor
));
930 ctor
= build_special_member_call (NULL_TREE
,
931 complete_ctor_identifier
,
933 type
, flags
, complain
);
936 return build_cplus_new (type
, ctor
, complain
);
939 if (complain
& tf_error
)
941 /* If the conversion failed and expr was an invalid use of pointer to
942 member function, try to report a meaningful error. */
943 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
944 /* We displayed the error message. */;
946 error_at (loc
, "conversion from %qH to non-scalar type %qI requested",
947 TREE_TYPE (expr
), type
);
949 return error_mark_node
;
952 /* If CALL is a call, return the callee; otherwise null. */
955 cp_get_callee (tree call
)
957 if (call
== NULL_TREE
)
959 else if (TREE_CODE (call
) == CALL_EXPR
)
960 return CALL_EXPR_FN (call
);
961 else if (TREE_CODE (call
) == AGGR_INIT_EXPR
)
962 return AGGR_INIT_EXPR_FN (call
);
966 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
970 cp_get_fndecl_from_callee (tree fn
, bool fold
/* = true */)
974 if (TREE_CODE (fn
) == FUNCTION_DECL
)
976 tree type
= TREE_TYPE (fn
);
977 if (type
== unknown_type_node
)
979 gcc_assert (INDIRECT_TYPE_P (type
));
981 fn
= maybe_constant_init (fn
);
983 if (TREE_CODE (fn
) == ADDR_EXPR
)
985 fn
= TREE_OPERAND (fn
, 0);
986 if (TREE_CODE (fn
) == FUNCTION_DECL
)
992 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
993 constexpr machinery. */
996 cp_get_callee_fndecl (tree call
)
998 return cp_get_fndecl_from_callee (cp_get_callee (call
));
1001 /* As above, but not using the constexpr machinery. */
1004 cp_get_callee_fndecl_nofold (tree call
)
1006 return cp_get_fndecl_from_callee (cp_get_callee (call
), false);
1009 /* Subroutine of convert_to_void. Warn if we're discarding something with
1010 attribute [[nodiscard]]. */
1013 maybe_warn_nodiscard (tree expr
, impl_conv_void implicit
)
1016 if (TREE_CODE (expr
) == TARGET_EXPR
)
1017 call
= TARGET_EXPR_INITIAL (expr
);
1018 location_t loc
= cp_expr_loc_or_input_loc (call
);
1019 tree callee
= cp_get_callee (call
);
1023 tree type
= TREE_TYPE (callee
);
1024 if (TYPE_PTRMEMFUNC_P (type
))
1025 type
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
1026 if (INDIRECT_TYPE_P (type
))
1027 type
= TREE_TYPE (type
);
1029 tree rettype
= TREE_TYPE (type
);
1030 tree fn
= cp_get_fndecl_from_callee (callee
);
1032 if (implicit
!= ICV_CAST
&& fn
1033 && (attr
= lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn
))))
1036 tree args
= TREE_VALUE (attr
);
1038 msg
.escape (TREE_STRING_POINTER (TREE_VALUE (args
)));
1039 const char* format
= (msg
?
1040 G_("ignoring return value of %qD, "
1041 "declared with attribute %<nodiscard%>: %<%s%>") :
1042 G_("ignoring return value of %qD, "
1043 "declared with attribute %<nodiscard%>%s"));
1044 const char* raw_msg
= msg
? msg
: "";
1045 auto_diagnostic_group d
;
1046 if (warning_at (loc
, OPT_Wunused_result
, format
, fn
, raw_msg
))
1047 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1049 else if (implicit
!= ICV_CAST
1050 && (attr
= lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype
))))
1053 tree args
= TREE_VALUE (attr
);
1055 msg
.escape (TREE_STRING_POINTER (TREE_VALUE (args
)));
1056 const char* format
= msg
?
1057 G_("ignoring returned value of type %qT, "
1058 "declared with attribute %<nodiscard%>: %<%s%>") :
1059 G_("ignoring returned value of type %qT, "
1060 "declared with attribute %<nodiscard%>%s");
1061 const char* raw_msg
= msg
? msg
: "";
1062 auto_diagnostic_group d
;
1063 if (warning_at (loc
, OPT_Wunused_result
, format
, rettype
, raw_msg
))
1066 inform (DECL_SOURCE_LOCATION (fn
),
1067 "in call to %qD, declared here", fn
);
1068 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype
)),
1069 "%qT declared here", rettype
);
1072 else if (TREE_CODE (expr
) == TARGET_EXPR
1073 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type
)))
1075 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1076 result is used, so handle that case here. */
1079 auto_diagnostic_group d
;
1080 if (warning_at (loc
, OPT_Wunused_result
,
1081 "ignoring return value of %qD, "
1082 "declared with attribute %<warn_unused_result%>",
1084 inform (DECL_SOURCE_LOCATION (fn
), "declared here");
1087 warning_at (loc
, OPT_Wunused_result
,
1088 "ignoring return value of function "
1089 "declared with attribute %<warn_unused_result%>");
1093 /* When an expression is used in a void context, its value is discarded and
1094 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1095 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1096 in a void context. The C++ standard does not define what an `access' to an
1097 object is, but there is reason to believe that it is the lvalue to rvalue
1098 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1099 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1100 indicates that volatile semantics should be the same between C and C++
1101 where ever possible. C leaves it implementation defined as to what
1102 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1103 the volatile object `vp' points to, unless that is an incomplete type. For
1104 volatile references we do not do this interpretation, because that would
1105 make it impossible to ignore the reference return value from functions. We
1106 issue warnings in the confusing cases.
1108 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1109 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1110 indicates the context of the implicit conversion. */
1113 convert_to_void (tree expr
, impl_conv_void implicit
, tsubst_flags_t complain
)
1115 location_t loc
= cp_expr_loc_or_input_loc (expr
);
1117 if (expr
== error_mark_node
1118 || TREE_TYPE (expr
) == error_mark_node
)
1119 return error_mark_node
;
1121 expr
= maybe_undo_parenthesized_ref (expr
);
1123 expr
= mark_discarded_use (expr
);
1124 if (implicit
== ICV_CAST
)
1125 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1126 mark_exp_read (expr
);
1128 if (!TREE_TYPE (expr
))
1130 if (invalid_nonstatic_memfn_p (loc
, expr
, complain
))
1131 return error_mark_node
;
1132 if (TREE_CODE (expr
) == PSEUDO_DTOR_EXPR
)
1134 if (complain
& tf_error
)
1135 error_at (loc
, "pseudo-destructor is not called");
1136 return error_mark_node
;
1139 /* Explicitly evaluate void-converted concept checks since their
1140 satisfaction may produce ill-formed programs. */
1141 if (concept_check_p (expr
))
1142 expr
= evaluate_concept_check (expr
, tf_warning_or_error
);
1144 if (VOID_TYPE_P (TREE_TYPE (expr
)))
1146 switch (TREE_CODE (expr
))
1150 /* The two parts of a cond expr might be separate lvalues. */
1151 tree op1
= TREE_OPERAND (expr
,1);
1152 tree op2
= TREE_OPERAND (expr
,2);
1153 bool side_effects
= ((op1
&& TREE_SIDE_EFFECTS (op1
))
1154 || TREE_SIDE_EFFECTS (op2
));
1155 tree new_op1
, new_op2
;
1156 new_op1
= NULL_TREE
;
1157 if (implicit
!= ICV_CAST
&& !side_effects
)
1160 new_op1
= convert_to_void (op1
, ICV_SECOND_OF_COND
, complain
);
1161 new_op2
= convert_to_void (op2
, ICV_THIRD_OF_COND
, complain
);
1166 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1167 new_op2
= convert_to_void (op2
, ICV_CAST
, complain
);
1170 expr
= build3 (COND_EXPR
, TREE_TYPE (new_op2
),
1171 TREE_OPERAND (expr
, 0), new_op1
, new_op2
);
1177 /* The second part of a compound expr contains the value. */
1178 tree op1
= TREE_OPERAND (expr
,1);
1180 if (implicit
!= ICV_CAST
&& !TREE_NO_WARNING (expr
))
1181 new_op1
= convert_to_void (op1
, ICV_RIGHT_OF_COMMA
, complain
);
1183 new_op1
= convert_to_void (op1
, ICV_CAST
, complain
);
1187 tree t
= build2 (COMPOUND_EXPR
, TREE_TYPE (new_op1
),
1188 TREE_OPERAND (expr
, 0), new_op1
);
1195 case NON_LVALUE_EXPR
:
1197 /* These have already decayed to rvalue. */
1200 case CALL_EXPR
: /* We have a special meaning for volatile void fn(). */
1201 /* cdtors may return this or void, depending on
1202 targetm.cxx.cdtor_returns_this, but this shouldn't affect our
1203 decisions here: neither nodiscard warnings (nodiscard cdtors
1204 are nonsensical), nor should any constexpr or template
1205 instantiations be affected by an ABI property that is, or at
1206 least ought to be transparent to the language. */
1207 if (tree fn
= cp_get_callee_fndecl_nofold (expr
))
1208 if (DECL_DESTRUCTOR_P (fn
))
1211 if (complain
& tf_warning
)
1212 maybe_warn_nodiscard (expr
, implicit
);
1217 tree type
= TREE_TYPE (expr
);
1218 int is_reference
= TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1219 int is_volatile
= TYPE_VOLATILE (type
);
1220 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1222 /* Can't load the value if we don't know the type. */
1223 if (is_volatile
&& !is_complete
)
1225 if (complain
& tf_warning
)
1229 warning_at (loc
, 0, "conversion to void will not access "
1230 "object of incomplete type %qT", type
);
1232 case ICV_SECOND_OF_COND
:
1233 warning_at (loc
, 0, "indirection will not access object of "
1234 "incomplete type %qT in second operand "
1235 "of conditional expression", type
);
1237 case ICV_THIRD_OF_COND
:
1238 warning_at (loc
, 0, "indirection will not access object of "
1239 "incomplete type %qT in third operand "
1240 "of conditional expression", type
);
1242 case ICV_RIGHT_OF_COMMA
:
1243 warning_at (loc
, 0, "indirection will not access object of "
1244 "incomplete type %qT in right operand of "
1245 "comma operator", type
);
1247 case ICV_LEFT_OF_COMMA
:
1248 warning_at (loc
, 0, "indirection will not access object of "
1249 "incomplete type %qT in left operand of "
1250 "comma operator", type
);
1253 warning_at (loc
, 0, "indirection will not access object of "
1254 "incomplete type %qT in statement", type
);
1256 case ICV_THIRD_IN_FOR
:
1257 warning_at (loc
, 0, "indirection will not access object of "
1258 "incomplete type %qT in for increment "
1259 "expression", type
);
1265 /* Don't load the value if this is an implicit dereference, or if
1266 the type needs to be handled by ctors/dtors. */
1267 else if (is_volatile
&& is_reference
)
1269 if (complain
& tf_warning
)
1273 warning_at (loc
, 0, "conversion to void will not access "
1274 "object of type %qT", type
);
1276 case ICV_SECOND_OF_COND
:
1277 warning_at (loc
, 0, "implicit dereference will not access "
1278 "object of type %qT in second operand of "
1279 "conditional expression", type
);
1281 case ICV_THIRD_OF_COND
:
1282 warning_at (loc
, 0, "implicit dereference will not access "
1283 "object of type %qT in third operand of "
1284 "conditional expression", type
);
1286 case ICV_RIGHT_OF_COMMA
:
1287 warning_at (loc
, 0, "implicit dereference will not access "
1288 "object of type %qT in right operand of "
1289 "comma operator", type
);
1291 case ICV_LEFT_OF_COMMA
:
1292 warning_at (loc
, 0, "implicit dereference will not access "
1293 "object of type %qT in left operand of comma "
1297 warning_at (loc
, 0, "implicit dereference will not access "
1298 "object of type %qT in statement", type
);
1300 case ICV_THIRD_IN_FOR
:
1301 warning_at (loc
, 0, "implicit dereference will not access "
1302 "object of type %qT in for increment expression",
1309 else if (is_volatile
&& TREE_ADDRESSABLE (type
))
1311 if (complain
& tf_warning
)
1315 warning_at (loc
, 0, "conversion to void will not access "
1316 "object of non-trivially-copyable type %qT",
1319 case ICV_SECOND_OF_COND
:
1320 warning_at (loc
, 0, "indirection will not access object of "
1321 "non-trivially-copyable type %qT in second "
1322 "operand of conditional expression", type
);
1324 case ICV_THIRD_OF_COND
:
1325 warning_at (loc
, 0, "indirection will not access object of "
1326 "non-trivially-copyable type %qT in third "
1327 "operand of conditional expression", type
);
1329 case ICV_RIGHT_OF_COMMA
:
1330 warning_at (loc
, 0, "indirection will not access object of "
1331 "non-trivially-copyable type %qT in right "
1332 "operand of comma operator", type
);
1334 case ICV_LEFT_OF_COMMA
:
1335 warning_at (loc
, 0, "indirection will not access object of "
1336 "non-trivially-copyable type %qT in left "
1337 "operand of comma operator", type
);
1340 warning_at (loc
, 0, "indirection will not access object of "
1341 "non-trivially-copyable type %qT in statement",
1344 case ICV_THIRD_IN_FOR
:
1345 warning_at (loc
, 0, "indirection will not access object of "
1346 "non-trivially-copyable type %qT in for "
1347 "increment expression", type
);
1353 if (is_reference
|| !is_volatile
|| !is_complete
|| TREE_ADDRESSABLE (type
))
1355 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1356 operation is stripped off. Note that we don't warn about
1357 - an expression with TREE_NO_WARNING set. (For an example of
1358 such expressions, see build_over_call in call.c.)
1359 - automatic dereferencing of references, since the user cannot
1360 control it. (See also warn_if_unused_value() in c-common.c.) */
1361 if (warn_unused_value
1362 && implicit
!= ICV_CAST
1363 && (complain
& tf_warning
)
1364 && !TREE_NO_WARNING (expr
)
1366 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1367 expr
= TREE_OPERAND (expr
, 0);
1368 if (TREE_CODE (expr
) == CALL_EXPR
1369 && (complain
& tf_warning
))
1370 maybe_warn_nodiscard (expr
, implicit
);
1378 /* External variables might be incomplete. */
1379 tree type
= TREE_TYPE (expr
);
1380 int is_complete
= COMPLETE_TYPE_P (complete_type (type
));
1382 if (TYPE_VOLATILE (type
) && !is_complete
&& (complain
& tf_warning
))
1386 warning_at (loc
, 0, "conversion to void will not access "
1387 "object %qE of incomplete type %qT", expr
, type
);
1389 case ICV_SECOND_OF_COND
:
1390 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1391 "not be accessed in second operand of "
1392 "conditional expression", expr
, type
);
1394 case ICV_THIRD_OF_COND
:
1395 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1396 "not be accessed in third operand of "
1397 "conditional expression", expr
, type
);
1399 case ICV_RIGHT_OF_COMMA
:
1400 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1401 "not be accessed in right operand of comma operator",
1404 case ICV_LEFT_OF_COMMA
:
1405 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1406 "not be accessed in left operand of comma operator",
1410 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1411 "not be accessed in statement", expr
, type
);
1413 case ICV_THIRD_IN_FOR
:
1414 warning_at (loc
, 0, "variable %qE of incomplete type %qT will "
1415 "not be accessed in for increment expression",
1426 /* Don't bother with the temporary object returned from a function if
1427 we don't use it, don't need to destroy it, and won't abort in
1428 assign_temp. We'll still
1429 allocate space for it in expand_call or declare_return_variable,
1430 but we don't need to track it through all the tree phases. */
1431 if (TARGET_EXPR_IMPLICIT_P (expr
)
1432 && !TREE_ADDRESSABLE (TREE_TYPE (expr
)))
1434 tree init
= TARGET_EXPR_INITIAL (expr
);
1435 if (TREE_CODE (init
) == AGGR_INIT_EXPR
1436 && !AGGR_INIT_VIA_CTOR_P (init
))
1438 tree fn
= AGGR_INIT_EXPR_FN (init
);
1439 expr
= build_call_array_loc (input_location
,
1440 TREE_TYPE (TREE_TYPE
1443 aggr_init_expr_nargs (init
),
1444 AGGR_INIT_EXPR_ARGP (init
));
1447 if (complain
& tf_warning
)
1448 maybe_warn_nodiscard (expr
, implicit
);
1453 expr
= resolve_nondeduced_context (expr
, complain
);
1457 if (TREE_CODE (probe
) == ADDR_EXPR
)
1458 probe
= TREE_OPERAND (expr
, 0);
1459 if (type_unknown_p (probe
))
1461 /* [over.over] enumerates the places where we can take the address
1462 of an overloaded function, and this is not one of them. */
1463 if (complain
& tf_error
)
1467 error_at (loc
, "conversion to void "
1468 "cannot resolve address of overloaded function");
1470 case ICV_SECOND_OF_COND
:
1471 error_at (loc
, "second operand of conditional expression "
1472 "cannot resolve address of overloaded function");
1474 case ICV_THIRD_OF_COND
:
1475 error_at (loc
, "third operand of conditional expression "
1476 "cannot resolve address of overloaded function");
1478 case ICV_RIGHT_OF_COMMA
:
1479 error_at (loc
, "right operand of comma operator "
1480 "cannot resolve address of overloaded function");
1482 case ICV_LEFT_OF_COMMA
:
1483 error_at (loc
, "left operand of comma operator "
1484 "cannot resolve address of overloaded function");
1487 error_at (loc
, "statement "
1488 "cannot resolve address of overloaded function");
1490 case ICV_THIRD_IN_FOR
:
1491 error_at (loc
, "for increment expression "
1492 "cannot resolve address of overloaded function");
1496 return error_mark_node
;
1499 else if (implicit
!= ICV_CAST
&& probe
== expr
&& is_overloaded_fn (probe
))
1501 /* Only warn when there is no &. */
1502 if (complain
& tf_warning
)
1505 case ICV_SECOND_OF_COND
:
1506 warning_at (loc
, OPT_Waddress
,
1507 "second operand of conditional expression "
1508 "is a reference, not call, to function %qE", expr
);
1510 case ICV_THIRD_OF_COND
:
1511 warning_at (loc
, OPT_Waddress
,
1512 "third operand of conditional expression "
1513 "is a reference, not call, to function %qE", expr
);
1515 case ICV_RIGHT_OF_COMMA
:
1516 warning_at (loc
, OPT_Waddress
,
1517 "right operand of comma operator "
1518 "is a reference, not call, to function %qE", expr
);
1520 case ICV_LEFT_OF_COMMA
:
1521 warning_at (loc
, OPT_Waddress
,
1522 "left operand of comma operator "
1523 "is a reference, not call, to function %qE", expr
);
1526 warning_at (loc
, OPT_Waddress
,
1527 "statement is a reference, not call, to function %qE",
1530 case ICV_THIRD_IN_FOR
:
1531 warning_at (loc
, OPT_Waddress
,
1532 "for increment expression "
1533 "is a reference, not call, to function %qE", expr
);
1539 if (TREE_CODE (expr
) == COMPONENT_REF
)
1540 expr
= TREE_OPERAND (expr
, 0);
1544 if (expr
!= error_mark_node
&& !VOID_TYPE_P (TREE_TYPE (expr
)))
1546 if (implicit
!= ICV_CAST
1547 && warn_unused_value
1548 && !TREE_NO_WARNING (expr
)
1549 && !processing_template_decl
1550 && !cp_unevaluated_operand
)
1552 /* The middle end does not warn about expressions that have
1553 been explicitly cast to void, so we must do so here. */
1554 if (!TREE_SIDE_EFFECTS (expr
)) {
1555 if (complain
& tf_warning
)
1558 case ICV_SECOND_OF_COND
:
1559 warning_at (loc
, OPT_Wunused_value
,
1560 "second operand of conditional expression "
1563 case ICV_THIRD_OF_COND
:
1564 warning_at (loc
, OPT_Wunused_value
,
1565 "third operand of conditional expression "
1568 case ICV_RIGHT_OF_COMMA
:
1569 warning_at (loc
, OPT_Wunused_value
,
1570 "right operand of comma operator has no effect");
1572 case ICV_LEFT_OF_COMMA
:
1573 warning_at (loc
, OPT_Wunused_value
,
1574 "left operand of comma operator has no effect");
1577 warning_at (loc
, OPT_Wunused_value
,
1578 "statement has no effect");
1580 case ICV_THIRD_IN_FOR
:
1581 warning_at (loc
, OPT_Wunused_value
,
1582 "for increment expression has no effect");
1591 enum tree_code code
;
1592 enum tree_code_class tclass
;
1595 /* We might like to warn about (say) "(int) f()", as the
1596 cast has no effect, but the compiler itself will
1597 generate implicit conversions under some
1598 circumstances. (For example a block copy will be
1599 turned into a call to "__builtin_memcpy", with a
1600 conversion of the return value to an appropriate
1601 type.) So, to avoid false positives, we strip
1602 conversions. Do not use STRIP_NOPs because it will
1603 not strip conversions to "void", as that is not a
1604 mode-preserving conversion. */
1605 while (TREE_CODE (e
) == NOP_EXPR
)
1606 e
= TREE_OPERAND (e
, 0);
1608 code
= TREE_CODE (e
);
1609 tclass
= TREE_CODE_CLASS (code
);
1610 if ((tclass
== tcc_comparison
1611 || tclass
== tcc_unary
1612 || (tclass
== tcc_binary
1613 && !(code
== MODIFY_EXPR
1614 || code
== INIT_EXPR
1615 || code
== PREDECREMENT_EXPR
1616 || code
== PREINCREMENT_EXPR
1617 || code
== POSTDECREMENT_EXPR
1618 || code
== POSTINCREMENT_EXPR
))
1619 || code
== VEC_PERM_EXPR
1620 || code
== VEC_COND_EXPR
)
1621 && (complain
& tf_warning
))
1622 warning_at (loc
, OPT_Wunused_value
, "value computed is not used");
1625 expr
= build1 (CONVERT_EXPR
, void_type_node
, expr
);
1627 if (! TREE_SIDE_EFFECTS (expr
))
1632 /* Create an expression whose value is that of EXPR,
1633 converted to type TYPE. The TREE_TYPE of the value
1634 is always TYPE. This function implements all reasonable
1635 conversions; callers should filter out those that are
1636 not permitted by the language being compiled.
1638 Most of this routine is from build_reinterpret_cast.
1640 The back end cannot call cp_convert (what was convert) because
1641 conversions to/from basetypes may involve memory references
1642 (vbases) and adding or subtracting small values (multiple
1643 inheritance), but it calls convert from the constant folding code
1644 on subtrees of already built trees after it has ripped them apart.
1646 Also, if we ever support range variables, we'll probably also have to
1647 do a little bit more work. */
1650 convert (tree type
, tree expr
)
1654 if (type
== error_mark_node
|| expr
== error_mark_node
)
1655 return error_mark_node
;
1657 intype
= TREE_TYPE (expr
);
1659 if (INDIRECT_TYPE_P (type
) && INDIRECT_TYPE_P (intype
))
1660 return build_nop (type
, expr
);
1662 return ocp_convert (type
, expr
, CONV_BACKEND_CONVERT
,
1663 LOOKUP_NORMAL
|LOOKUP_NO_CONVERSION
,
1664 tf_warning_or_error
);
1667 /* Like cp_convert, except permit conversions to take place which
1668 are not normally allowed due to access restrictions
1669 (such as conversion from sub-type to private super-type). */
1672 convert_force (tree type
, tree expr
, int convtype
, tsubst_flags_t complain
)
1675 enum tree_code code
= TREE_CODE (type
);
1677 if (code
== REFERENCE_TYPE
)
1678 return convert_to_reference (type
, e
, CONV_C_CAST
, 0,
1679 NULL_TREE
, complain
);
1681 if (code
== POINTER_TYPE
)
1682 return convert_to_pointer_force (type
, e
, complain
);
1684 /* From typeck.c convert_for_assignment */
1685 if (((TYPE_PTR_P (TREE_TYPE (e
)) && TREE_CODE (e
) == ADDR_EXPR
1686 && TREE_CODE (TREE_TYPE (TREE_TYPE (e
))) == METHOD_TYPE
)
1687 || integer_zerop (e
)
1688 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e
)))
1689 && TYPE_PTRMEMFUNC_P (type
))
1690 /* compatible pointer to member functions. */
1691 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type
), e
, 1,
1692 /*c_cast_p=*/1, complain
);
1694 return ocp_convert (type
, e
, CONV_C_CAST
|convtype
, LOOKUP_NORMAL
, complain
);
1697 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1698 exists, return the attempted conversion. This may
1699 return ERROR_MARK_NODE if the conversion is not
1700 allowed (references private members, etc).
1701 If no conversion exists, NULL_TREE is returned.
1703 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1704 object parameter, or by the second standard conversion sequence if
1705 that doesn't do it. This will probably wait for an overloading rewrite.
1709 build_type_conversion (tree xtype
, tree expr
)
1711 /* C++: check to see if we can convert this aggregate type
1712 into the required type. */
1713 return build_user_type_conversion (xtype
, expr
, LOOKUP_NORMAL
,
1714 tf_warning_or_error
);
1717 /* Convert the given EXPR to one of a group of types suitable for use in an
1718 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1719 which indicates which types are suitable. If COMPLAIN is true, complain
1720 about ambiguity; otherwise, the caller will deal with it. */
1723 build_expr_type_conversion (int desires
, tree expr
, bool complain
)
1725 tree basetype
= TREE_TYPE (expr
);
1726 tree conv
= NULL_TREE
;
1727 tree winner
= NULL_TREE
;
1729 if (null_node_p (expr
)
1730 && (desires
& WANT_INT
)
1731 && !(desires
& WANT_NULL
))
1734 expansion_point_location_if_in_system_header (input_location
);
1736 warning_at (loc
, OPT_Wconversion_null
,
1737 "converting NULL to non-pointer type");
1740 if (basetype
== error_mark_node
)
1741 return error_mark_node
;
1743 if (! MAYBE_CLASS_TYPE_P (basetype
))
1744 switch (TREE_CODE (basetype
))
1747 if ((desires
& WANT_NULL
) && null_ptr_cst_p (expr
))
1752 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1754 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1756 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1758 return (desires
& WANT_POINTER
) ? expr
: NULL_TREE
;
1762 return (desires
& WANT_POINTER
) ? decay_conversion (expr
,
1763 tf_warning_or_error
)
1768 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1770 switch (TREE_CODE (TREE_TYPE (basetype
)))
1774 return (desires
& WANT_INT
) ? expr
: NULL_TREE
;
1776 return (desires
& WANT_ENUM
) ? expr
: NULL_TREE
;
1778 return (desires
& WANT_FLOAT
) ? expr
: NULL_TREE
;
1787 /* The code for conversions from class type is currently only used for
1788 delete expressions. Other expressions are handled by build_new_op. */
1789 if (!complete_type_or_maybe_complain (basetype
, expr
, complain
))
1790 return error_mark_node
;
1791 if (!TYPE_HAS_CONVERSION (basetype
))
1794 for (conv
= lookup_conversions (basetype
); conv
; conv
= TREE_CHAIN (conv
))
1798 tree cand
= TREE_VALUE (conv
);
1799 cand
= OVL_FIRST (cand
);
1801 if (winner
&& winner
== cand
)
1804 if (DECL_NONCONVERTING_P (cand
))
1807 candidate
= non_reference (TREE_TYPE (TREE_TYPE (cand
)));
1809 switch (TREE_CODE (candidate
))
1813 win
= (desires
& WANT_INT
); break;
1815 win
= (desires
& WANT_ENUM
); break;
1817 win
= (desires
& WANT_FLOAT
); break;
1819 win
= (desires
& WANT_POINTER
); break;
1823 if ((desires
& WANT_VECTOR_OR_COMPLEX
) == 0)
1825 switch (TREE_CODE (TREE_TYPE (candidate
)))
1829 win
= (desires
& WANT_INT
); break;
1831 win
= (desires
& WANT_ENUM
); break;
1833 win
= (desires
& WANT_FLOAT
); break;
1840 /* A wildcard could be instantiated to match any desired
1841 type, but we can't deduce the template argument. */
1842 if (WILDCARD_TYPE_P (candidate
))
1849 if (TREE_CODE (cand
) == TEMPLATE_DECL
)
1852 error ("default type conversion cannot deduce template"
1853 " argument for %qD", cand
);
1854 return error_mark_node
;
1860 = non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1862 if (!same_type_ignoring_top_level_qualifiers_p (winner_type
,
1867 error ("ambiguous default type conversion from %qT",
1869 inform (input_location
,
1870 " candidate conversions include %qD and %qD",
1873 return error_mark_node
;
1883 tree type
= non_reference (TREE_TYPE (TREE_TYPE (winner
)));
1884 return build_user_type_conversion (type
, expr
, LOOKUP_NORMAL
,
1885 tf_warning_or_error
);
1891 /* Implements integral promotion (4.1) and float->double promotion. */
1894 type_promotes_to (tree type
)
1898 if (type
== error_mark_node
)
1899 return error_mark_node
;
1901 type
= TYPE_MAIN_VARIANT (type
);
1903 /* Check for promotions of target-defined types first. */
1904 promoted_type
= targetm
.promoted_type (type
);
1906 return promoted_type
;
1908 /* bool always promotes to int (not unsigned), even if it's the same
1910 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
1911 type
= integer_type_node
;
1913 /* Normally convert enums to int, but convert wide enums to something
1914 wider. Scoped enums don't promote, but pretend they do for backward
1915 ABI bug compatibility wrt varargs. */
1916 else if (TREE_CODE (type
) == ENUMERAL_TYPE
1917 || type
== char8_type_node
1918 || type
== char16_type_node
1919 || type
== char32_type_node
1920 || type
== wchar_type_node
)
1924 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1926 prom
= ENUM_UNDERLYING_TYPE (prom
);
1927 if (!ENUM_IS_SCOPED (type
)
1928 && ENUM_FIXED_UNDERLYING_TYPE_P (type
))
1930 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1931 whose underlying type is fixed (10.2) can be converted to a
1932 prvalue of its underlying type. Moreover, if integral promotion
1933 can be applied to its underlying type, a prvalue of an unscoped
1934 enumeration type whose underlying type is fixed can also be
1935 converted to a prvalue of the promoted underlying type. */
1936 return type_promotes_to (prom
);
1940 int precision
= MAX (TYPE_PRECISION (type
),
1941 TYPE_PRECISION (integer_type_node
));
1942 tree totype
= c_common_type_for_size (precision
, 0);
1943 if (TYPE_UNSIGNED (prom
)
1944 && ! int_fits_type_p (TYPE_MAX_VALUE (prom
), totype
))
1945 prom
= c_common_type_for_size (precision
, 1);
1948 if (SCOPED_ENUM_P (type
))
1950 if (abi_version_crosses (6)
1951 && TYPE_MODE (prom
) != TYPE_MODE (type
))
1952 warning (OPT_Wabi
, "scoped enum %qT passed through %<...%> as "
1953 "%qT before %<-fabi-version=6%>, %qT after",
1954 type
, prom
, ENUM_UNDERLYING_TYPE (type
));
1955 if (!abi_version_at_least (6))
1961 else if (c_promoting_integer_type_p (type
))
1963 /* Retain unsignedness if really not getting bigger. */
1964 if (TYPE_UNSIGNED (type
)
1965 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1966 type
= unsigned_type_node
;
1968 type
= integer_type_node
;
1970 else if (type
== float_type_node
)
1971 type
= double_type_node
;
1976 /* The routines below this point are carefully written to conform to
1977 the standard. They use the same terminology, and follow the rules
1978 closely. Although they are used only in pt.c at the moment, they
1979 should presumably be used everywhere in the future. */
1981 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1982 Callers should check for identical types before calling this function. */
1985 can_convert_qual (tree type
, tree expr
)
1987 tree expr_type
= TREE_TYPE (expr
);
1988 gcc_assert (!same_type_p (type
, expr_type
));
1990 if (TYPE_PTR_P (type
) && TYPE_PTR_P (expr_type
))
1991 return comp_ptr_ttypes (TREE_TYPE (type
), TREE_TYPE (expr_type
));
1992 else if (TYPE_PTRMEM_P (type
) && TYPE_PTRMEM_P (expr_type
))
1993 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
1994 TYPE_PTRMEM_CLASS_TYPE (expr_type
))
1995 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type
),
1996 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type
)));
2001 /* Attempt to perform qualification conversions on EXPR to convert it
2002 to TYPE. Return the resulting expression, or error_mark_node if
2003 the conversion was impossible. Since this is only used by
2004 convert_nontype_argument, we fold the conversion. */
2007 perform_qualification_conversions (tree type
, tree expr
)
2011 expr_type
= TREE_TYPE (expr
);
2013 if (same_type_p (type
, expr_type
))
2015 else if (can_convert_qual (type
, expr
))
2016 return cp_fold_convert (type
, expr
);
2018 return error_mark_node
;
2021 /* True iff T is a transaction-safe function type. */
2024 tx_safe_fn_type_p (tree t
)
2026 if (!FUNC_OR_METHOD_TYPE_P (t
))
2028 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t
));
2031 /* Return the transaction-unsafe variant of transaction-safe function type
2035 tx_unsafe_fn_variant (tree t
)
2037 gcc_assert (tx_safe_fn_type_p (t
));
2038 tree attrs
= remove_attribute ("transaction_safe",
2039 TYPE_ATTRIBUTES (t
));
2040 return cp_build_type_attribute_variant (t
, attrs
);
2043 /* Return true iff FROM can convert to TO by a transaction-safety
2047 can_convert_tx_safety (tree to
, tree from
)
2049 return (flag_tm
&& tx_safe_fn_type_p (from
)
2050 && same_type_p (to
, tx_unsafe_fn_variant (from
)));
2053 /* Return true iff FROM can convert to TO by dropping noexcept. */
2056 noexcept_conv_p (tree to
, tree from
)
2058 if (!flag_noexcept_type
)
2061 tree t
= non_reference (to
);
2063 if (TYPE_PTRMEMFUNC_P (t
)
2064 && TYPE_PTRMEMFUNC_P (f
))
2066 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2067 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2075 tree_code code
= TREE_CODE (f
);
2076 if (TREE_CODE (t
) != code
)
2078 if (code
!= FUNCTION_TYPE
&& code
!= METHOD_TYPE
)
2080 if (!type_throw_all_p (t
)
2081 || type_throw_all_p (f
))
2083 tree v
= build_exception_variant (f
, NULL_TREE
);
2084 return same_type_p (t
, v
);
2087 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2090 fnptr_conv_p (tree to
, tree from
)
2092 tree t
= non_reference (to
);
2094 if (TYPE_PTRMEMFUNC_P (t
)
2095 && TYPE_PTRMEMFUNC_P (f
))
2097 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
2098 f
= TYPE_PTRMEMFUNC_FN_TYPE (f
);
2107 return (noexcept_conv_p (t
, f
)
2108 || can_convert_tx_safety (t
, f
));
2111 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2112 conversions or conversions to the same type. */
2115 strip_fnptr_conv (tree fn
)
2117 while (TREE_CODE (fn
) == NOP_EXPR
)
2119 tree op
= TREE_OPERAND (fn
, 0);
2120 tree ft
= TREE_TYPE (fn
);
2121 tree ot
= TREE_TYPE (op
);
2122 if (same_type_p (ft
, ot
)
2123 || fnptr_conv_p (ft
, ot
))