Mercurial > hg > CbC > CbC_gcc

comparison gcc/cp/cvt.c @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5 This file is part of GCC.
6
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)
10 any later version.
11
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.
16
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/>. */
20
21
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. */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "target.h"
31 #include "cp-tree.h"
32 #include "stor-layout.h"
33 #include "flags.h"
34 #include "intl.h"
35 #include "convert.h"
36 #include "stringpool.h"
37 #include "attribs.h"
38
39 static tree convert_to_pointer_force (tree, tree, tsubst_flags_t);
40 static tree build_type_conversion (tree, tree);
41 static tree build_up_reference (tree, tree, int, tree, tsubst_flags_t);
42 static void diagnose_ref_binding (location_t, tree, tree, tree);
43
44 /* Change of width--truncation and extension of integers or reals--
45 is represented with NOP_EXPR. Proper functioning of many things
46 assumes that no other conversions can be NOP_EXPRs.
47
48 Conversion between integer and pointer is represented with CONVERT_EXPR.
49 Converting integer to real uses FLOAT_EXPR
50 and real to integer uses FIX_TRUNC_EXPR.
51
52 Here is a list of all the functions that assume that widening and
53 narrowing is always done with a NOP_EXPR:
54 In convert.c, convert_to_integer[_maybe_fold].
55 In c-typeck.c, build_binary_op_nodefault (boolean ops),
56 and c_common_truthvalue_conversion.
57 In expr.c: expand_expr, for operands of a MULT_EXPR.
58 In fold-const.c: fold.
59 In tree.c: get_narrower and get_unwidened.
60
61 C++: in multiple-inheritance, converting between pointers may involve
62 adjusting them by a delta stored within the class definition. */
63
64 /* Subroutines of `convert'. */
65
66 /* if converting pointer to pointer
67 if dealing with classes, check for derived->base or vice versa
68 else if dealing with method pointers, delegate
69 else convert blindly
70 else if converting class, pass off to build_type_conversion
71 else try C-style pointer conversion. */
72
73 static tree
74 cp_convert_to_pointer (tree type, tree expr, bool dofold,
75 tsubst_flags_t complain)
76 {
77 tree intype = TREE_TYPE (expr);
78 enum tree_code form;
79 tree rval;
80 location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
81
82 if (intype == error_mark_node)
83 return error_mark_node;
84
85 if (MAYBE_CLASS_TYPE_P (intype))
86 {
87 intype = complete_type (intype);
88 if (!COMPLETE_TYPE_P (intype))
89 {
90 if (complain & tf_error)
91 error_at (loc, "can%'t convert from incomplete type %qH to %qI",
92 intype, type);
93 return error_mark_node;
94 }
95
96 rval = build_type_conversion (type, expr);
97 if (rval)
98 {
99 if ((complain & tf_error)
100 && rval == error_mark_node)
101 error_at (loc, "conversion of %qE from %qH to %qI is ambiguous",
102 expr, intype, type);
103 return rval;
104 }
105 }
106
107 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
108 if (TYPE_PTR_P (type)
109 && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
110 || VOID_TYPE_P (TREE_TYPE (type))))
111 {
112 if (TYPE_PTRMEMFUNC_P (intype)
113 || TREE_CODE (intype) == METHOD_TYPE)
114 return convert_member_func_to_ptr (type, expr, complain);
115 if (TYPE_PTR_P (TREE_TYPE (expr)))
116 return build_nop (type, expr);
117 intype = TREE_TYPE (expr);
118 }
119
120 if (expr == error_mark_node)
121 return error_mark_node;
122
123 form = TREE_CODE (intype);
124
125 if (POINTER_TYPE_P (intype))
126 {
127 intype = TYPE_MAIN_VARIANT (intype);
128
129 if (TYPE_MAIN_VARIANT (type) != intype
130 && TYPE_PTR_P (type)
131 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
132 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
133 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
134 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
135 {
136 enum tree_code code = PLUS_EXPR;
137 tree binfo;
138 tree intype_class;
139 tree type_class;
140 bool same_p;
141
142 intype_class = TREE_TYPE (intype);
143 type_class = TREE_TYPE (type);
144
145 same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
146 TYPE_MAIN_VARIANT (type_class));
147 binfo = NULL_TREE;
148 /* Try derived to base conversion. */
149 if (!same_p)
150 binfo = lookup_base (intype_class, type_class, ba_check,
151 NULL, complain);
152 if (!same_p && !binfo)
153 {
154 /* Try base to derived conversion. */
155 binfo = lookup_base (type_class, intype_class, ba_check,
156 NULL, complain);
157 code = MINUS_EXPR;
158 }
159 if (binfo == error_mark_node)
160 return error_mark_node;
161 if (binfo || same_p)
162 {
163 if (binfo)
164 expr = build_base_path (code, expr, binfo, 0, complain);
165 /* Add any qualifier conversions. */
166 return build_nop (type, expr);
167 }
168 }
169
170 if (TYPE_PTRMEMFUNC_P (type))
171 {
172 if (complain & tf_error)
173 error_at (loc, "cannot convert %qE from type %qH to type %qI",
174 expr, intype, type);
175 return error_mark_node;
176 }
177
178 return build_nop (type, expr);
179 }
180 else if ((TYPE_PTRDATAMEM_P (type) && TYPE_PTRDATAMEM_P (intype))
181 || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
182 return convert_ptrmem (type, expr, /*allow_inverse_p=*/false,
183 /*c_cast_p=*/false, complain);
184 else if (TYPE_PTRMEMFUNC_P (intype))
185 {
186 if (!warn_pmf2ptr)
187 {
188 if (TREE_CODE (expr) == PTRMEM_CST)
189 return cp_convert_to_pointer (type, PTRMEM_CST_MEMBER (expr),
190 dofold, complain);
191 else if (TREE_CODE (expr) == OFFSET_REF)
192 {
193 tree object = TREE_OPERAND (expr, 0);
194 return get_member_function_from_ptrfunc (&object,
195 TREE_OPERAND (expr, 1),
196 complain);
197 }
198 }
199 if (complain & tf_error)
200 error_at (loc, "cannot convert %qE from type %qH to type %qI",
201 expr, intype, type);
202 return error_mark_node;
203 }
204
205 if (null_ptr_cst_p (expr))
206 {
207 if (TYPE_PTRMEMFUNC_P (type))
208 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0,
209 /*c_cast_p=*/false, complain);
210
211 if (complain & tf_warning)
212 maybe_warn_zero_as_null_pointer_constant (expr, loc);
213
214 /* A NULL pointer-to-data-member is represented by -1, not by
215 zero. */
216 tree val = (TYPE_PTRDATAMEM_P (type)
217 ? build_int_cst_type (type, -1)
218 : build_int_cst (type, 0));
219
220 return (TREE_SIDE_EFFECTS (expr)
221 ? build2 (COMPOUND_EXPR, type, expr, val) : val);
222 }
223 else if (TYPE_PTRMEM_P (type) && INTEGRAL_CODE_P (form))
224 {
225 if (complain & tf_error)
226 error_at (loc, "invalid conversion from %qH to %qI", intype, type);
227 return error_mark_node;
228 }
229
230 if (INTEGRAL_CODE_P (form))
231 {
232 if (TYPE_PRECISION (intype) == POINTER_SIZE)
233 return build1 (CONVERT_EXPR, type, expr);
234 expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr,
235 complain);
236 /* Modes may be different but sizes should be the same. There
237 is supposed to be some integral type that is the same width
238 as a pointer. */
239 gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr)))
240 == GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)));
241
242 return convert_to_pointer_maybe_fold (type, expr, dofold);
243 }
244
245 if (type_unknown_p (expr))
246 return instantiate_type (type, expr, complain);
247
248 if (complain & tf_error)
249 error_at (loc, "cannot convert %qE from type %qH to type %qI",
250 expr, intype, type);
251 return error_mark_node;
252 }
253
254 /* Like convert, except permit conversions to take place which
255 are not normally allowed due to access restrictions
256 (such as conversion from sub-type to private super-type). */
257
258 static tree
259 convert_to_pointer_force (tree type, tree expr, tsubst_flags_t complain)
260 {
261 tree intype = TREE_TYPE (expr);
262 enum tree_code form = TREE_CODE (intype);
263
264 if (form == POINTER_TYPE)
265 {
266 intype = TYPE_MAIN_VARIANT (intype);
267
268 if (TYPE_MAIN_VARIANT (type) != intype
269 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
270 && MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
271 && MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
272 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
273 {
274 enum tree_code code = PLUS_EXPR;
275 tree binfo;
276
277 binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type),
278 ba_unique, NULL, complain);
279 if (!binfo)
280 {
281 binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
282 ba_unique, NULL, complain);
283 code = MINUS_EXPR;
284 }
285 if (binfo == error_mark_node)
286 return error_mark_node;
287 if (binfo)
288 {
289 expr = build_base_path (code, expr, binfo, 0, complain);
290 if (expr == error_mark_node)
291 return error_mark_node;
292 /* Add any qualifier conversions. */
293 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
294 TREE_TYPE (type)))
295 expr = build_nop (type, expr);
296 return expr;
297 }
298 }
299 }
300
301 return cp_convert_to_pointer (type, expr, /*fold*/false, complain);
302 }
303
304 /* We are passing something to a function which requires a reference.
305 The type we are interested in is in TYPE. The initial
306 value we have to begin with is in ARG.
307
308 FLAGS controls how we manage access checking.
309 DIRECT_BIND in FLAGS controls how any temporaries are generated.
310 If DIRECT_BIND is set, DECL is the reference we're binding to. */
311
312 static tree
313 build_up_reference (tree type, tree arg, int flags, tree decl,
314 tsubst_flags_t complain)
315 {
316 tree rval;
317 tree argtype = TREE_TYPE (arg);
318 tree target_type = TREE_TYPE (type);
319
320 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
321
322 if ((flags & DIRECT_BIND) && ! lvalue_p (arg))
323 {
324 /* Create a new temporary variable. We can't just use a TARGET_EXPR
325 here because it needs to live as long as DECL. */
326 tree targ = arg;
327
328 arg = make_temporary_var_for_ref_to_temp (decl, target_type);
329
330 /* Process the initializer for the declaration. */
331 DECL_INITIAL (arg) = targ;
332 cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE,
333 LOOKUP_ONLYCONVERTING|DIRECT_BIND);
334 }
335 else if (!(flags & DIRECT_BIND) && ! obvalue_p (arg))
336 return get_target_expr_sfinae (arg, complain);
337
338 /* If we had a way to wrap this up, and say, if we ever needed its
339 address, transform all occurrences of the register, into a memory
340 reference we could win better. */
341 rval = cp_build_addr_expr (arg, complain);
342 if (rval == error_mark_node)
343 return error_mark_node;
344
345 if ((flags & LOOKUP_PROTECT)
346 && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
347 && MAYBE_CLASS_TYPE_P (argtype)
348 && MAYBE_CLASS_TYPE_P (target_type))
349 {
350 /* We go through lookup_base for the access control. */
351 tree binfo = lookup_base (argtype, target_type, ba_check,
352 NULL, complain);
353 if (binfo == error_mark_node)
354 return error_mark_node;
355 if (binfo == NULL_TREE)
356 return error_not_base_type (target_type, argtype);
357 rval = build_base_path (PLUS_EXPR, rval, binfo, 1, complain);
358 }
359 else
360 rval
361 = convert_to_pointer_force (build_pointer_type (target_type),
362 rval, complain);
363 return build_nop (type, rval);
364 }
365
366 /* Subroutine of convert_to_reference. REFTYPE is the target reference type.
367 INTYPE is the original rvalue type and DECL is an optional _DECL node
368 for diagnostics.
369
370 [dcl.init.ref] says that if an rvalue is used to
371 initialize a reference, then the reference must be to a
372 non-volatile const type. */
373
374 static void
375 diagnose_ref_binding (location_t loc, tree reftype, tree intype, tree decl)
376 {
377 tree ttl = TREE_TYPE (reftype);
378
379 if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl))
380 {
381 const char *msg;
382
383 if (CP_TYPE_VOLATILE_P (ttl) && decl)
384 msg = G_("initialization of volatile reference type %q#T from "
385 "rvalue of type %qT");
386 else if (CP_TYPE_VOLATILE_P (ttl))
387 msg = G_("conversion to volatile reference type %q#T "
388 "from rvalue of type %qT");
389 else if (decl)
390 msg = G_("initialization of non-const reference type %q#T from "
391 "rvalue of type %qT");
392 else
393 msg = G_("conversion to non-const reference type %q#T from "
394 "rvalue of type %qT");
395
396 permerror (loc, msg, reftype, intype);
397 }
398 }
399
400 /* For C++: Only need to do one-level references, but cannot
401 get tripped up on signed/unsigned differences.
402
403 DECL is either NULL_TREE or the _DECL node for a reference that is being
404 initialized. It can be error_mark_node if we don't know the _DECL but
405 we know it's an initialization. */
406
407 tree
408 convert_to_reference (tree reftype, tree expr, int convtype,
409 int flags, tree decl, tsubst_flags_t complain)
410 {
411 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
412 tree intype;
413 tree rval = NULL_TREE;
414 tree rval_as_conversion = NULL_TREE;
415 bool can_convert_intype_to_type;
416 location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
417
418 if (TREE_CODE (type) == FUNCTION_TYPE
419 && TREE_TYPE (expr) == unknown_type_node)
420 expr = instantiate_type (type, expr, complain);
421
422 if (expr == error_mark_node)
423 return error_mark_node;
424
425 intype = TREE_TYPE (expr);
426
427 gcc_assert (TREE_CODE (intype) != REFERENCE_TYPE);
428 gcc_assert (TREE_CODE (reftype) == REFERENCE_TYPE);
429
430 intype = TYPE_MAIN_VARIANT (intype);
431
432 can_convert_intype_to_type = can_convert_standard (type, intype, complain);
433
434 if (!can_convert_intype_to_type
435 && (convtype & CONV_IMPLICIT) && MAYBE_CLASS_TYPE_P (intype)
436 && ! (flags & LOOKUP_NO_CONVERSION))
437 {
438 /* Look for a user-defined conversion to lvalue that we can use. */
439
440 rval_as_conversion
441 = build_type_conversion (reftype, expr);
442
443 if (rval_as_conversion && rval_as_conversion != error_mark_node
444 && lvalue_p (rval_as_conversion))
445 {
446 expr = rval_as_conversion;
447 rval_as_conversion = NULL_TREE;
448 intype = type;
449 can_convert_intype_to_type = 1;
450 }
451 }
452
453 if (((convtype & CONV_STATIC)
454 && can_convert_standard (intype, type, complain))
455 || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type))
456 {
457 {
458 tree ttl = TREE_TYPE (reftype);
459 tree ttr = lvalue_type (expr);
460
461 if ((complain & tf_error)
462 && ! lvalue_p (expr))
463 diagnose_ref_binding (loc, reftype, intype, decl);
464
465 if (! (convtype & CONV_CONST)
466 && !at_least_as_qualified_p (ttl, ttr))
467 {
468 if (complain & tf_error)
469 permerror (loc, "conversion from %qH to %qI discards qualifiers",
470 ttr, reftype);
471 else
472 return error_mark_node;
473 }
474 }
475
476 return build_up_reference (reftype, expr, flags, decl, complain);
477 }
478 else if ((convtype & CONV_REINTERPRET) && obvalue_p (expr))
479 {
480 /* When casting an lvalue to a reference type, just convert into
481 a pointer to the new type and deference it. This is allowed
482 by San Diego WP section 5.2.9 paragraph 12, though perhaps it
483 should be done directly (jason). (int &)ri ---> *(int*)&ri */
484
485 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
486 meant. */
487 if ((complain & tf_warning)
488 && TYPE_PTR_P (intype)
489 && (comptypes (TREE_TYPE (intype), type,
490 COMPARE_BASE | COMPARE_DERIVED)))
491 warning_at (loc, 0, "casting %qT to %qT does not dereference pointer",
492 intype, reftype);
493
494 rval = cp_build_addr_expr (expr, complain);
495 if (rval != error_mark_node)
496 rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
497 rval, 0, complain);
498 if (rval != error_mark_node)
499 rval = build1 (NOP_EXPR, reftype, rval);
500 }
501 else
502 {
503 rval = convert_for_initialization (NULL_TREE, type, expr, flags,
504 ICR_CONVERTING, 0, 0, complain);
505 if (rval == NULL_TREE || rval == error_mark_node)
506 return rval;
507 if (complain & tf_error)
508 diagnose_ref_binding (loc, reftype, intype, decl);
509 rval = build_up_reference (reftype, rval, flags, decl, complain);
510 }
511
512 if (rval)
513 {
514 /* If we found a way to convert earlier, then use it. */
515 return rval;
516 }
517
518 if (complain & tf_error)
519 error_at (loc, "cannot convert type %qH to type %qI", intype, reftype);
520
521 return error_mark_node;
522 }
523
524 /* We are using a reference VAL for its value. Bash that reference all the
525 way down to its lowest form. */
526
527 tree
528 convert_from_reference (tree val)
529 {
530 if (TREE_TYPE (val)
531 && TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
532 {
533 tree t = TREE_TYPE (TREE_TYPE (val));
534 tree ref = build1 (INDIRECT_REF, t, val);
535
536 mark_exp_read (val);
537 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
538 so that we get the proper error message if the result is used
539 to assign to. Also, &* is supposed to be a no-op. */
540 TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
541 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
542 TREE_SIDE_EFFECTS (ref)
543 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val));
544 val = ref;
545 }
546
547 return val;
548 }
549
550 /* Really perform an lvalue-to-rvalue conversion, including copying an
551 argument of class type into a temporary. */
552
553 tree
554 force_rvalue (tree expr, tsubst_flags_t complain)
555 {
556 tree type = TREE_TYPE (expr);
557 if (MAYBE_CLASS_TYPE_P (type) && TREE_CODE (expr) != TARGET_EXPR)
558 {
559 vec<tree, va_gc> *args = make_tree_vector_single (expr);
560 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
561 &args, type, LOOKUP_NORMAL, complain);
562 release_tree_vector (args);
563 expr = build_cplus_new (type, expr, complain);
564 }
565 else
566 expr = decay_conversion (expr, complain);
567
568 return expr;
569 }
570
571
572 /* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
573 TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
574 unchanged. */
575
576 static tree
577 ignore_overflows (tree expr, tree orig)
578 {
579 if (TREE_CODE (expr) == INTEGER_CST
580 && TREE_CODE (orig) == INTEGER_CST
581 && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
582 {
583 gcc_assert (!TREE_OVERFLOW (orig));
584 /* Ensure constant sharing. */
585 expr = wide_int_to_tree (TREE_TYPE (expr), wi::to_wide (expr));
586 }
587 return expr;
588 }
589
590 /* Fold away simple conversions, but make sure TREE_OVERFLOW is set
591 properly. */
592
593 tree
594 cp_fold_convert (tree type, tree expr)
595 {
596 tree conv;
597 if (TREE_TYPE (expr) == type)
598 conv = expr;
599 else if (TREE_CODE (expr) == PTRMEM_CST)
600 {
601 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
602 conv = copy_node (expr);
603 TREE_TYPE (conv) = type;
604 }
605 else
606 {
607 conv = fold_convert (type, expr);
608 conv = ignore_overflows (conv, expr);
609 }
610 return conv;
611 }
612
613 /* C++ conversions, preference to static cast conversions. */
614
615 tree
616 cp_convert (tree type, tree expr, tsubst_flags_t complain)
617 {
618 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL, complain);
619 }
620
621 /* C++ equivalent of convert_and_check but using cp_convert as the
622 conversion function.
623
624 Convert EXPR to TYPE, warning about conversion problems with constants.
625 Invoke this function on every expression that is converted implicitly,
626 i.e. because of language rules and not because of an explicit cast. */
627
628 tree
629 cp_convert_and_check (tree type, tree expr, tsubst_flags_t complain)
630 {
631 tree result;
632
633 if (TREE_TYPE (expr) == type)
634 return expr;
635 if (expr == error_mark_node)
636 return expr;
637 result = cp_convert (type, expr, complain);
638
639 if ((complain & tf_warning)
640 && c_inhibit_evaluation_warnings == 0)
641 {
642 tree folded = cp_fully_fold (expr);
643 tree folded_result;
644 if (folded == expr)
645 folded_result = result;
646 else
647 {
648 /* Avoid bogus -Wparentheses warnings. */
649 warning_sentinel w (warn_parentheses);
650 warning_sentinel c (warn_int_in_bool_context);
651 folded_result = cp_convert (type, folded, tf_none);
652 }
653 folded_result = fold_simple (folded_result);
654 if (!TREE_OVERFLOW_P (folded)
655 && folded_result != error_mark_node)
656 warnings_for_convert_and_check (EXPR_LOC_OR_LOC (expr, input_location),
657 type, folded, folded_result);
658 }
659
660 return result;
661 }
662
663 /* Conversion...
664
665 FLAGS indicates how we should behave. */
666
667 tree
668 ocp_convert (tree type, tree expr, int convtype, int flags,
669 tsubst_flags_t complain)
670 {
671 tree e = expr;
672 enum tree_code code = TREE_CODE (type);
673 const char *invalid_conv_diag;
674 tree e1;
675 location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
676 bool dofold = (convtype & CONV_FOLD);
677
678 if (error_operand_p (e) || type == error_mark_node)
679 return error_mark_node;
680
681 complete_type (type);
682 complete_type (TREE_TYPE (expr));
683
684 if ((invalid_conv_diag
685 = targetm.invalid_conversion (TREE_TYPE (expr), type)))
686 {
687 if (complain & tf_error)
688 error (invalid_conv_diag);
689 return error_mark_node;
690 }
691
692 /* FIXME remove when moving to c_fully_fold model. */
693 if (!CLASS_TYPE_P (type))
694 e = scalar_constant_value (e);
695 if (error_operand_p (e))
696 return error_mark_node;
697
698 if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
699 /* We need a new temporary; don't take this shortcut. */;
700 else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
701 {
702 if (same_type_p (type, TREE_TYPE (e)))
703 /* The call to fold will not always remove the NOP_EXPR as
704 might be expected, since if one of the types is a typedef;
705 the comparison in fold is just equality of pointers, not a
706 call to comptypes. We don't call fold in this case because
707 that can result in infinite recursion; fold will call
708 convert, which will call ocp_convert, etc. */
709 return e;
710 /* For complex data types, we need to perform componentwise
711 conversion. */
712 else if (TREE_CODE (type) == COMPLEX_TYPE)
713 return convert_to_complex_maybe_fold (type, e, dofold);
714 else if (VECTOR_TYPE_P (type))
715 return convert_to_vector (type, e);
716 else if (TREE_CODE (e) == TARGET_EXPR)
717 {
718 /* Don't build a NOP_EXPR of class type. Instead, change the
719 type of the temporary. */
720 TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
721 return e;
722 }
723 else
724 {
725 /* We shouldn't be treating objects of ADDRESSABLE type as
726 rvalues. */
727 gcc_assert (!TREE_ADDRESSABLE (type));
728 return build_nop (type, e);
729 }
730 }
731
732 e1 = targetm.convert_to_type (type, e);
733 if (e1)
734 return e1;
735
736 if (code == VOID_TYPE && (convtype & CONV_STATIC))
737 {
738 e = convert_to_void (e, ICV_CAST, complain);
739 return e;
740 }
741
742 if (INTEGRAL_CODE_P (code))
743 {
744 tree intype = TREE_TYPE (e);
745 tree converted;
746
747 if (TREE_CODE (type) == ENUMERAL_TYPE)
748 {
749 /* enum = enum, enum = int, enum = float, (enum)pointer are all
750 errors. */
751 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
752 || TREE_CODE (intype) == REAL_TYPE)
753 && ! (convtype & CONV_STATIC))
754 || TYPE_PTR_P (intype))
755 {
756 if (complain & tf_error)
757 permerror (loc, "conversion from %q#T to %q#T", intype, type);
758 else
759 return error_mark_node;
760 }
761
762 /* [expr.static.cast]
763
764 8. A value of integral or enumeration type can be explicitly
765 converted to an enumeration type. The value is unchanged if
766 the original value is within the range of the enumeration
767 values. Otherwise, the resulting enumeration value is
768 unspecified. */
769 if ((complain & tf_warning)
770 && TREE_CODE (e) == INTEGER_CST
771 && ENUM_UNDERLYING_TYPE (type)
772 && !int_fits_type_p (e, ENUM_UNDERLYING_TYPE (type)))
773 warning_at (loc, OPT_Wconversion,
774 "the result of the conversion is unspecified because "
775 "%qE is outside the range of type %qT",
776 expr, type);
777 }
778 if (MAYBE_CLASS_TYPE_P (intype))
779 {
780 tree rval;
781 rval = build_type_conversion (type, e);
782 if (rval)
783 return rval;
784 if (complain & tf_error)
785 error_at (loc, "%q#T used where a %qT was expected", intype, type);
786 return error_mark_node;
787 }
788 if (code == BOOLEAN_TYPE)
789 {
790 if (VOID_TYPE_P (intype))
791 {
792 if (complain & tf_error)
793 error_at (loc,
794 "could not convert %qE from %<void%> to %<bool%>",
795 expr);
796 return error_mark_node;
797 }
798
799 /* We can't implicitly convert a scoped enum to bool, so convert
800 to the underlying type first. */
801 if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC))
802 e = build_nop (ENUM_UNDERLYING_TYPE (intype), e);
803 if (complain & tf_warning)
804 return cp_truthvalue_conversion (e);
805 else
806 {
807 /* Prevent bogus -Wint-in-bool-context warnings coming
808 from c_common_truthvalue_conversion down the line. */
809 warning_sentinel w (warn_int_in_bool_context);
810 return cp_truthvalue_conversion (e);
811 }
812 }
813
814 converted = convert_to_integer_maybe_fold (type, e, dofold);
815
816 /* Ignore any integer overflow caused by the conversion. */
817 return ignore_overflows (converted, e);
818 }
819 if (NULLPTR_TYPE_P (type) && e && null_ptr_cst_p (e))
820 {
821 if (complain & tf_warning)
822 maybe_warn_zero_as_null_pointer_constant (e, loc);
823 return nullptr_node;
824 }
825 if (POINTER_TYPE_P (type) || TYPE_PTRMEM_P (type))
826 return cp_convert_to_pointer (type, e, dofold, complain);
827 if (code == VECTOR_TYPE)
828 {
829 tree in_vtype = TREE_TYPE (e);
830 if (MAYBE_CLASS_TYPE_P (in_vtype))
831 {
832 tree ret_val;
833 ret_val = build_type_conversion (type, e);
834 if (ret_val)
835 return ret_val;
836 if (complain & tf_error)
837 error_at (loc, "%q#T used where a %qT was expected",
838 in_vtype, type);
839 return error_mark_node;
840 }
841 return convert_to_vector (type, e);
842 }
843 if (code == REAL_TYPE || code == COMPLEX_TYPE)
844 {
845 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
846 {
847 tree rval;
848 rval = build_type_conversion (type, e);
849 if (rval)
850 return rval;
851 else if (complain & tf_error)
852 error_at (loc,
853 "%q#T used where a floating point value was expected",
854 TREE_TYPE (e));
855 }
856 if (code == REAL_TYPE)
857 return convert_to_real_maybe_fold (type, e, dofold);
858 else if (code == COMPLEX_TYPE)
859 return convert_to_complex_maybe_fold (type, e, dofold);
860 }
861
862 /* New C++ semantics: since assignment is now based on
863 memberwise copying, if the rhs type is derived from the
864 lhs type, then we may still do a conversion. */
865 if (RECORD_OR_UNION_CODE_P (code))
866 {
867 tree dtype = TREE_TYPE (e);
868 tree ctor = NULL_TREE;
869
870 dtype = TYPE_MAIN_VARIANT (dtype);
871
872 /* Conversion between aggregate types. New C++ semantics allow
873 objects of derived type to be cast to objects of base type.
874 Old semantics only allowed this between pointers.
875
876 There may be some ambiguity between using a constructor
877 vs. using a type conversion operator when both apply. */
878
879 ctor = e;
880
881 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
882 return error_mark_node;
883
884 if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
885 ctor = perform_implicit_conversion (type, ctor, complain);
886 else if ((flags & LOOKUP_ONLYCONVERTING)
887 && ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
888 /* For copy-initialization, first we create a temp of the proper type
889 with a user-defined conversion sequence, then we direct-initialize
890 the target with the temp (see [dcl.init]). */
891 ctor = build_user_type_conversion (type, ctor, flags, complain);
892 else
893 {
894 vec<tree, va_gc> *ctor_vec = make_tree_vector_single (ctor);
895 ctor = build_special_member_call (NULL_TREE,
896 complete_ctor_identifier,
897 &ctor_vec,
898 type, flags, complain);
899 release_tree_vector (ctor_vec);
900 }
901 if (ctor)
902 return build_cplus_new (type, ctor, complain);
903 }
904
905 if (complain & tf_error)
906 {
907 /* If the conversion failed and expr was an invalid use of pointer to
908 member function, try to report a meaningful error. */
909 if (invalid_nonstatic_memfn_p (loc, expr, complain))
910 /* We displayed the error message. */;
911 else
912 error_at (loc, "conversion from %qH to non-scalar type %qI requested",
913 TREE_TYPE (expr), type);
914 }
915 return error_mark_node;
916 }
917
918 /* If CALL is a call, return the callee; otherwise null. */
919
920 tree
921 cp_get_callee (tree call)
922 {
923 if (call == NULL_TREE)
924 return call;
925 else if (TREE_CODE (call) == CALL_EXPR)
926 return CALL_EXPR_FN (call);
927 else if (TREE_CODE (call) == AGGR_INIT_EXPR)
928 return AGGR_INIT_EXPR_FN (call);
929 return NULL_TREE;
930 }
931
932 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
933 if we can. */
934
935 tree
936 cp_get_fndecl_from_callee (tree fn)
937 {
938 if (fn == NULL_TREE)
939 return fn;
940 if (TREE_CODE (fn) == FUNCTION_DECL)
941 return fn;
942 tree type = TREE_TYPE (fn);
943 if (type == unknown_type_node)
944 return NULL_TREE;
945 gcc_assert (POINTER_TYPE_P (type));
946 fn = maybe_constant_init (fn);
947 STRIP_NOPS (fn);
948 if (TREE_CODE (fn) == ADDR_EXPR)
949 {
950 fn = TREE_OPERAND (fn, 0);
951 if (TREE_CODE (fn) == FUNCTION_DECL)
952 return fn;
953 }
954 return NULL_TREE;
955 }
956
957 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
958 constexpr machinery. */
959
960 tree
961 cp_get_callee_fndecl (tree call)
962 {
963 return cp_get_fndecl_from_callee (cp_get_callee (call));
964 }
965
966 /* Subroutine of convert_to_void. Warn if we're discarding something with
967 attribute [[nodiscard]]. */
968
969 static void
970 maybe_warn_nodiscard (tree expr, impl_conv_void implicit)
971 {
972 tree call = expr;
973 if (TREE_CODE (expr) == TARGET_EXPR)
974 call = TARGET_EXPR_INITIAL (expr);
975 location_t loc = EXPR_LOC_OR_LOC (call, input_location);
976 tree callee = cp_get_callee (call);
977 if (!callee)
978 return;
979
980 tree type = TREE_TYPE (callee);
981 if (TYPE_PTRMEMFUNC_P (type))
982 type = TYPE_PTRMEMFUNC_FN_TYPE (type);
983 if (POINTER_TYPE_P (type))
984 type = TREE_TYPE (type);
985
986 tree rettype = TREE_TYPE (type);
987 tree fn = cp_get_fndecl_from_callee (callee);
988 if (implicit != ICV_CAST && fn
989 && lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn)))
990 {
991 if (warning_at (loc, OPT_Wunused_result,
992 "ignoring return value of %qD, "
993 "declared with attribute nodiscard", fn))
994 inform (DECL_SOURCE_LOCATION (fn), "declared here");
995 }
996 else if (implicit != ICV_CAST
997 && lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype)))
998 {
999 if (warning_at (loc, OPT_Wunused_result,
1000 "ignoring returned value of type %qT, "
1001 "declared with attribute nodiscard", rettype))
1002 {
1003 if (fn)
1004 inform (DECL_SOURCE_LOCATION (fn),
1005 "in call to %qD, declared here", fn);
1006 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype)),
1007 "%qT declared here", rettype);
1008 }
1009 }
1010 else if (TREE_CODE (expr) == TARGET_EXPR
1011 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type)))
1012 {
1013 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1014 result is used, so handle that case here. */
1015 if (fn)
1016 {
1017 if (warning_at (loc, OPT_Wunused_result,
1018 "ignoring return value of %qD, "
1019 "declared with attribute warn_unused_result",
1020 fn))
1021 inform (DECL_SOURCE_LOCATION (fn), "declared here");
1022 }
1023 else
1024 warning_at (loc, OPT_Wunused_result,
1025 "ignoring return value of function "
1026 "declared with attribute warn_unused_result");
1027 }
1028 }
1029
1030 /* When an expression is used in a void context, its value is discarded and
1031 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1032 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1033 in a void context. The C++ standard does not define what an `access' to an
1034 object is, but there is reason to believe that it is the lvalue to rvalue
1035 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1036 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1037 indicates that volatile semantics should be the same between C and C++
1038 where ever possible. C leaves it implementation defined as to what
1039 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1040 the volatile object `vp' points to, unless that is an incomplete type. For
1041 volatile references we do not do this interpretation, because that would
1042 make it impossible to ignore the reference return value from functions. We
1043 issue warnings in the confusing cases.
1044
1045 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1046 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1047 indicates the context of the implicit conversion. */
1048
1049 tree
1050 convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
1051 {
1052 location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
1053
1054 if (expr == error_mark_node
1055 || TREE_TYPE (expr) == error_mark_node)
1056 return error_mark_node;
1057
1058 expr = mark_discarded_use (expr);
1059 if (implicit == ICV_CAST)
1060 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1061 mark_exp_read (expr);
1062
1063 if (!TREE_TYPE (expr))
1064 return expr;
1065 if (invalid_nonstatic_memfn_p (loc, expr, complain))
1066 return error_mark_node;
1067 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
1068 {
1069 if (complain & tf_error)
1070 error_at (loc, "pseudo-destructor is not called");
1071 return error_mark_node;
1072 }
1073 if (VOID_TYPE_P (TREE_TYPE (expr)))
1074 return expr;
1075 switch (TREE_CODE (expr))
1076 {
1077 case COND_EXPR:
1078 {
1079 /* The two parts of a cond expr might be separate lvalues. */
1080 tree op1 = TREE_OPERAND (expr,1);
1081 tree op2 = TREE_OPERAND (expr,2);
1082 bool side_effects = ((op1 && TREE_SIDE_EFFECTS (op1))
1083 || TREE_SIDE_EFFECTS (op2));
1084 tree new_op1, new_op2;
1085 new_op1 = NULL_TREE;
1086 if (implicit != ICV_CAST && !side_effects)
1087 {
1088 if (op1)
1089 new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
1090 new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
1091 }
1092 else
1093 {
1094 if (op1)
1095 new_op1 = convert_to_void (op1, ICV_CAST, complain);
1096 new_op2 = convert_to_void (op2, ICV_CAST, complain);
1097 }
1098
1099 expr = build3 (COND_EXPR, TREE_TYPE (new_op2),
1100 TREE_OPERAND (expr, 0), new_op1, new_op2);
1101 break;
1102 }
1103
1104 case COMPOUND_EXPR:
1105 {
1106 /* The second part of a compound expr contains the value. */
1107 tree op1 = TREE_OPERAND (expr,1);
1108 tree new_op1;
1109 if (implicit != ICV_CAST && !TREE_NO_WARNING (expr))
1110 new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
1111 else
1112 new_op1 = convert_to_void (op1, ICV_CAST, complain);
1113
1114 if (new_op1 != op1)
1115 {
1116 tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
1117 TREE_OPERAND (expr, 0), new_op1);
1118 expr = t;
1119 }
1120
1121 break;
1122 }
1123
1124 case NON_LVALUE_EXPR:
1125 case NOP_EXPR:
1126 /* These have already decayed to rvalue. */
1127 break;
1128
1129 case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
1130 maybe_warn_nodiscard (expr, implicit);
1131 break;
1132
1133 case INDIRECT_REF:
1134 {
1135 tree type = TREE_TYPE (expr);
1136 int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
1137 == REFERENCE_TYPE;
1138 int is_volatile = TYPE_VOLATILE (type);
1139 int is_complete = COMPLETE_TYPE_P (complete_type (type));
1140
1141 /* Can't load the value if we don't know the type. */
1142 if (is_volatile && !is_complete)
1143 {
1144 if (complain & tf_warning)
1145 switch (implicit)
1146 {
1147 case ICV_CAST:
1148 warning_at (loc, 0, "conversion to void will not access "
1149 "object of incomplete type %qT", type);
1150 break;
1151 case ICV_SECOND_OF_COND:
1152 warning_at (loc, 0, "indirection will not access object of "
1153 "incomplete type %qT in second operand "
1154 "of conditional expression", type);
1155 break;
1156 case ICV_THIRD_OF_COND:
1157 warning_at (loc, 0, "indirection will not access object of "
1158 "incomplete type %qT in third operand "
1159 "of conditional expression", type);
1160 break;
1161 case ICV_RIGHT_OF_COMMA:
1162 warning_at (loc, 0, "indirection will not access object of "
1163 "incomplete type %qT in right operand of "
1164 "comma operator", type);
1165 break;
1166 case ICV_LEFT_OF_COMMA:
1167 warning_at (loc, 0, "indirection will not access object of "
1168 "incomplete type %qT in left operand of "
1169 "comma operator", type);
1170 break;
1171 case ICV_STATEMENT:
1172 warning_at (loc, 0, "indirection will not access object of "
1173 "incomplete type %qT in statement", type);
1174 break;
1175 case ICV_THIRD_IN_FOR:
1176 warning_at (loc, 0, "indirection will not access object of "
1177 "incomplete type %qT in for increment "
1178 "expression", type);
1179 break;
1180 default:
1181 gcc_unreachable ();
1182 }
1183 }
1184 /* Don't load the value if this is an implicit dereference, or if
1185 the type needs to be handled by ctors/dtors. */
1186 else if (is_volatile && is_reference)
1187 {
1188 if (complain & tf_warning)
1189 switch (implicit)
1190 {
1191 case ICV_CAST:
1192 warning_at (loc, 0, "conversion to void will not access "
1193 "object of type %qT", type);
1194 break;
1195 case ICV_SECOND_OF_COND:
1196 warning_at (loc, 0, "implicit dereference will not access "
1197 "object of type %qT in second operand of "
1198 "conditional expression", type);
1199 break;
1200 case ICV_THIRD_OF_COND:
1201 warning_at (loc, 0, "implicit dereference will not access "
1202 "object of type %qT in third operand of "
1203 "conditional expression", type);
1204 break;
1205 case ICV_RIGHT_OF_COMMA:
1206 warning_at (loc, 0, "implicit dereference will not access "
1207 "object of type %qT in right operand of "
1208 "comma operator", type);
1209 break;
1210 case ICV_LEFT_OF_COMMA:
1211 warning_at (loc, 0, "implicit dereference will not access "
1212 "object of type %qT in left operand of comma "
1213 "operator", type);
1214 break;
1215 case ICV_STATEMENT:
1216 warning_at (loc, 0, "implicit dereference will not access "
1217 "object of type %qT in statement", type);
1218 break;
1219 case ICV_THIRD_IN_FOR:
1220 warning_at (loc, 0, "implicit dereference will not access "
1221 "object of type %qT in for increment expression",
1222 type);
1223 break;
1224 default:
1225 gcc_unreachable ();
1226 }
1227 }
1228 else if (is_volatile && TREE_ADDRESSABLE (type))
1229 {
1230 if (complain & tf_warning)
1231 switch (implicit)
1232 {
1233 case ICV_CAST:
1234 warning_at (loc, 0, "conversion to void will not access "
1235 "object of non-trivially-copyable type %qT",
1236 type);
1237 break;
1238 case ICV_SECOND_OF_COND:
1239 warning_at (loc, 0, "indirection will not access object of "
1240 "non-trivially-copyable type %qT in second "
1241 "operand of conditional expression", type);
1242 break;
1243 case ICV_THIRD_OF_COND:
1244 warning_at (loc, 0, "indirection will not access object of "
1245 "non-trivially-copyable type %qT in third "
1246 "operand of conditional expression", type);
1247 break;
1248 case ICV_RIGHT_OF_COMMA:
1249 warning_at (loc, 0, "indirection will not access object of "
1250 "non-trivially-copyable type %qT in right "
1251 "operand of comma operator", type);
1252 break;
1253 case ICV_LEFT_OF_COMMA:
1254 warning_at (loc, 0, "indirection will not access object of "
1255 "non-trivially-copyable type %qT in left "
1256 "operand of comma operator", type);
1257 break;
1258 case ICV_STATEMENT:
1259 warning_at (loc, 0, "indirection will not access object of "
1260 "non-trivially-copyable type %qT in statement",
1261 type);
1262 break;
1263 case ICV_THIRD_IN_FOR:
1264 warning_at (loc, 0, "indirection will not access object of "
1265 "non-trivially-copyable type %qT in for "
1266 "increment expression", type);
1267 break;
1268 default:
1269 gcc_unreachable ();
1270 }
1271 }
1272 if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
1273 {
1274 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1275 operation is stripped off. Note that we don't warn about
1276 - an expression with TREE_NO_WARNING set. (For an example of
1277 such expressions, see build_over_call in call.c.)
1278 - automatic dereferencing of references, since the user cannot
1279 control it. (See also warn_if_unused_value() in c-common.c.) */
1280 if (warn_unused_value
1281 && implicit != ICV_CAST
1282 && (complain & tf_warning)
1283 && !TREE_NO_WARNING (expr)
1284 && !is_reference)
1285 warning_at (loc, OPT_Wunused_value, "value computed is not used");
1286 expr = TREE_OPERAND (expr, 0);
1287 if (TREE_CODE (expr) == CALL_EXPR)
1288 maybe_warn_nodiscard (expr, implicit);
1289 }
1290
1291 break;
1292 }
1293
1294 case VAR_DECL:
1295 {
1296 /* External variables might be incomplete. */
1297 tree type = TREE_TYPE (expr);
1298 int is_complete = COMPLETE_TYPE_P (complete_type (type));
1299
1300 if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
1301 switch (implicit)
1302 {
1303 case ICV_CAST:
1304 warning_at (loc, 0, "conversion to void will not access "
1305 "object %qE of incomplete type %qT", expr, type);
1306 break;
1307 case ICV_SECOND_OF_COND:
1308 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1309 "not be accessed in second operand of "
1310 "conditional expression", expr, type);
1311 break;
1312 case ICV_THIRD_OF_COND:
1313 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1314 "not be accessed in third operand of "
1315 "conditional expression", expr, type);
1316 break;
1317 case ICV_RIGHT_OF_COMMA:
1318 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1319 "not be accessed in right operand of comma operator",
1320 expr, type);
1321 break;
1322 case ICV_LEFT_OF_COMMA:
1323 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1324 "not be accessed in left operand of comma operator",
1325 expr, type);
1326 break;
1327 case ICV_STATEMENT:
1328 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1329 "not be accessed in statement", expr, type);
1330 break;
1331 case ICV_THIRD_IN_FOR:
1332 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1333 "not be accessed in for increment expression",
1334 expr, type);
1335 break;
1336 default:
1337 gcc_unreachable ();
1338 }
1339
1340 break;
1341 }
1342
1343 case TARGET_EXPR:
1344 /* Don't bother with the temporary object returned from a function if
1345 we don't use it, don't need to destroy it, and won't abort in
1346 assign_temp. We'll still
1347 allocate space for it in expand_call or declare_return_variable,
1348 but we don't need to track it through all the tree phases. */
1349 if (TARGET_EXPR_IMPLICIT_P (expr)
1350 && !TREE_ADDRESSABLE (TREE_TYPE (expr)))
1351 {
1352 tree init = TARGET_EXPR_INITIAL (expr);
1353 if (TREE_CODE (init) == AGGR_INIT_EXPR
1354 && !AGGR_INIT_VIA_CTOR_P (init))
1355 {
1356 tree fn = AGGR_INIT_EXPR_FN (init);
1357 expr = build_call_array_loc (input_location,
1358 TREE_TYPE (TREE_TYPE
1359 (TREE_TYPE (fn))),
1360 fn,
1361 aggr_init_expr_nargs (init),
1362 AGGR_INIT_EXPR_ARGP (init));
1363 }
1364 }
1365 maybe_warn_nodiscard (expr, implicit);
1366 break;
1367
1368 default:;
1369 }
1370 expr = resolve_nondeduced_context (expr, complain);
1371 {
1372 tree probe = expr;
1373
1374 if (TREE_CODE (probe) == ADDR_EXPR)
1375 probe = TREE_OPERAND (expr, 0);
1376 if (type_unknown_p (probe))
1377 {
1378 /* [over.over] enumerates the places where we can take the address
1379 of an overloaded function, and this is not one of them. */
1380 if (complain & tf_error)
1381 switch (implicit)
1382 {
1383 case ICV_CAST:
1384 error_at (loc, "conversion to void "
1385 "cannot resolve address of overloaded function");
1386 break;
1387 case ICV_SECOND_OF_COND:
1388 error_at (loc, "second operand of conditional expression "
1389 "cannot resolve address of overloaded function");
1390 break;
1391 case ICV_THIRD_OF_COND:
1392 error_at (loc, "third operand of conditional expression "
1393 "cannot resolve address of overloaded function");
1394 break;
1395 case ICV_RIGHT_OF_COMMA:
1396 error_at (loc, "right operand of comma operator "
1397 "cannot resolve address of overloaded function");
1398 break;
1399 case ICV_LEFT_OF_COMMA:
1400 error_at (loc, "left operand of comma operator "
1401 "cannot resolve address of overloaded function");
1402 break;
1403 case ICV_STATEMENT:
1404 error_at (loc, "statement "
1405 "cannot resolve address of overloaded function");
1406 break;
1407 case ICV_THIRD_IN_FOR:
1408 error_at (loc, "for increment expression "
1409 "cannot resolve address of overloaded function");
1410 break;
1411 }
1412 else
1413 return error_mark_node;
1414 expr = void_node;
1415 }
1416 else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
1417 {
1418 /* Only warn when there is no &. */
1419 if (complain & tf_warning)
1420 switch (implicit)
1421 {
1422 case ICV_SECOND_OF_COND:
1423 warning_at (loc, OPT_Waddress,
1424 "second operand of conditional expression "
1425 "is a reference, not call, to function %qE", expr);
1426 break;
1427 case ICV_THIRD_OF_COND:
1428 warning_at (loc, OPT_Waddress,
1429 "third operand of conditional expression "
1430 "is a reference, not call, to function %qE", expr);
1431 break;
1432 case ICV_RIGHT_OF_COMMA:
1433 warning_at (loc, OPT_Waddress,
1434 "right operand of comma operator "
1435 "is a reference, not call, to function %qE", expr);
1436 break;
1437 case ICV_LEFT_OF_COMMA:
1438 warning_at (loc, OPT_Waddress,
1439 "left operand of comma operator "
1440 "is a reference, not call, to function %qE", expr);
1441 break;
1442 case ICV_STATEMENT:
1443 warning_at (loc, OPT_Waddress,
1444 "statement is a reference, not call, to function %qE",
1445 expr);
1446 break;
1447 case ICV_THIRD_IN_FOR:
1448 warning_at (loc, OPT_Waddress,
1449 "for increment expression "
1450 "is a reference, not call, to function %qE", expr);
1451 break;
1452 default:
1453 gcc_unreachable ();
1454 }
1455
1456 if (TREE_CODE (expr) == COMPONENT_REF)
1457 expr = TREE_OPERAND (expr, 0);
1458 }
1459 }
1460
1461 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
1462 {
1463 if (implicit != ICV_CAST
1464 && warn_unused_value
1465 && !TREE_NO_WARNING (expr)
1466 && !processing_template_decl)
1467 {
1468 /* The middle end does not warn about expressions that have
1469 been explicitly cast to void, so we must do so here. */
1470 if (!TREE_SIDE_EFFECTS (expr)) {
1471 if (complain & tf_warning)
1472 switch (implicit)
1473 {
1474 case ICV_SECOND_OF_COND:
1475 warning_at (loc, OPT_Wunused_value,
1476 "second operand of conditional expression "
1477 "has no effect");
1478 break;
1479 case ICV_THIRD_OF_COND:
1480 warning_at (loc, OPT_Wunused_value,
1481 "third operand of conditional expression "
1482 "has no effect");
1483 break;
1484 case ICV_RIGHT_OF_COMMA:
1485 warning_at (loc, OPT_Wunused_value,
1486 "right operand of comma operator has no effect");
1487 break;
1488 case ICV_LEFT_OF_COMMA:
1489 warning_at (loc, OPT_Wunused_value,
1490 "left operand of comma operator has no effect");
1491 break;
1492 case ICV_STATEMENT:
1493 warning_at (loc, OPT_Wunused_value,
1494 "statement has no effect");
1495 break;
1496 case ICV_THIRD_IN_FOR:
1497 warning_at (loc, OPT_Wunused_value,
1498 "for increment expression has no effect");
1499 break;
1500 default:
1501 gcc_unreachable ();
1502 }
1503 }
1504 else
1505 {
1506 tree e;
1507 enum tree_code code;
1508 enum tree_code_class tclass;
1509
1510 e = expr;
1511 /* We might like to warn about (say) "(int) f()", as the
1512 cast has no effect, but the compiler itself will
1513 generate implicit conversions under some
1514 circumstances. (For example a block copy will be
1515 turned into a call to "__builtin_memcpy", with a
1516 conversion of the return value to an appropriate
1517 type.) So, to avoid false positives, we strip
1518 conversions. Do not use STRIP_NOPs because it will
1519 not strip conversions to "void", as that is not a
1520 mode-preserving conversion. */
1521 while (TREE_CODE (e) == NOP_EXPR)
1522 e = TREE_OPERAND (e, 0);
1523
1524 code = TREE_CODE (e);
1525 tclass = TREE_CODE_CLASS (code);
1526 if ((tclass == tcc_comparison
1527 || tclass == tcc_unary
1528 || (tclass == tcc_binary
1529 && !(code == MODIFY_EXPR
1530 || code == INIT_EXPR
1531 || code == PREDECREMENT_EXPR
1532 || code == PREINCREMENT_EXPR
1533 || code == POSTDECREMENT_EXPR
1534 || code == POSTINCREMENT_EXPR))
1535 || code == VEC_PERM_EXPR
1536 || code == VEC_COND_EXPR)
1537 && (complain & tf_warning))
1538 warning_at (loc, OPT_Wunused_value, "value computed is not used");
1539 }
1540 }
1541 expr = build1 (CONVERT_EXPR, void_type_node, expr);
1542 }
1543 if (! TREE_SIDE_EFFECTS (expr))
1544 expr = void_node;
1545 return expr;
1546 }
1547
1548 /* Create an expression whose value is that of EXPR,
1549 converted to type TYPE. The TREE_TYPE of the value
1550 is always TYPE. This function implements all reasonable
1551 conversions; callers should filter out those that are
1552 not permitted by the language being compiled.
1553
1554 Most of this routine is from build_reinterpret_cast.
1555
1556 The back end cannot call cp_convert (what was convert) because
1557 conversions to/from basetypes may involve memory references
1558 (vbases) and adding or subtracting small values (multiple
1559 inheritance), but it calls convert from the constant folding code
1560 on subtrees of already built trees after it has ripped them apart.
1561
1562 Also, if we ever support range variables, we'll probably also have to
1563 do a little bit more work. */
1564
1565 tree
1566 convert (tree type, tree expr)
1567 {
1568 tree intype;
1569
1570 if (type == error_mark_node || expr == error_mark_node)
1571 return error_mark_node;
1572
1573 intype = TREE_TYPE (expr);
1574
1575 if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
1576 return build_nop (type, expr);
1577
1578 return ocp_convert (type, expr, CONV_BACKEND_CONVERT,
1579 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION,
1580 tf_warning_or_error);
1581 }
1582
1583 /* Like cp_convert, except permit conversions to take place which
1584 are not normally allowed due to access restrictions
1585 (such as conversion from sub-type to private super-type). */
1586
1587 tree
1588 convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain)
1589 {
1590 tree e = expr;
1591 enum tree_code code = TREE_CODE (type);
1592
1593 if (code == REFERENCE_TYPE)
1594 return convert_to_reference (type, e, CONV_C_CAST, 0,
1595 NULL_TREE, complain);
1596
1597 if (code == POINTER_TYPE)
1598 return convert_to_pointer_force (type, e, complain);
1599
1600 /* From typeck.c convert_for_assignment */
1601 if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR
1602 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1603 || integer_zerop (e)
1604 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1605 && TYPE_PTRMEMFUNC_P (type))
1606 /* compatible pointer to member functions. */
1607 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
1608 /*c_cast_p=*/1, complain);
1609
1610 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL, complain);
1611 }
1612
1613 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1614 exists, return the attempted conversion. This may
1615 return ERROR_MARK_NODE if the conversion is not
1616 allowed (references private members, etc).
1617 If no conversion exists, NULL_TREE is returned.
1618
1619 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1620 object parameter, or by the second standard conversion sequence if
1621 that doesn't do it. This will probably wait for an overloading rewrite.
1622 (jason 8/9/95) */
1623
1624 static tree
1625 build_type_conversion (tree xtype, tree expr)
1626 {
1627 /* C++: check to see if we can convert this aggregate type
1628 into the required type. */
1629 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL,
1630 tf_warning_or_error);
1631 }
1632
1633 /* Convert the given EXPR to one of a group of types suitable for use in an
1634 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1635 which indicates which types are suitable. If COMPLAIN is true, complain
1636 about ambiguity; otherwise, the caller will deal with it. */
1637
1638 tree
1639 build_expr_type_conversion (int desires, tree expr, bool complain)
1640 {
1641 tree basetype = TREE_TYPE (expr);
1642 tree conv = NULL_TREE;
1643 tree winner = NULL_TREE;
1644
1645 if (expr == null_node
1646 && (desires & WANT_INT)
1647 && !(desires & WANT_NULL))
1648 {
1649 source_location loc =
1650 expansion_point_location_if_in_system_header (input_location);
1651
1652 warning_at (loc, OPT_Wconversion_null,
1653 "converting NULL to non-pointer type");
1654 }
1655
1656 if (basetype == error_mark_node)
1657 return error_mark_node;
1658
1659 if (! MAYBE_CLASS_TYPE_P (basetype))
1660 switch (TREE_CODE (basetype))
1661 {
1662 case INTEGER_TYPE:
1663 if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1664 return expr;
1665 /* fall through. */
1666
1667 case BOOLEAN_TYPE:
1668 return (desires & WANT_INT) ? expr : NULL_TREE;
1669 case ENUMERAL_TYPE:
1670 return (desires & WANT_ENUM) ? expr : NULL_TREE;
1671 case REAL_TYPE:
1672 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1673 case POINTER_TYPE:
1674 return (desires & WANT_POINTER) ? expr : NULL_TREE;
1675
1676 case FUNCTION_TYPE:
1677 case ARRAY_TYPE:
1678 return (desires & WANT_POINTER) ? decay_conversion (expr,
1679 tf_warning_or_error)
1680 : NULL_TREE;
1681
1682 case COMPLEX_TYPE:
1683 case VECTOR_TYPE:
1684 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1685 return NULL_TREE;
1686 switch (TREE_CODE (TREE_TYPE (basetype)))
1687 {
1688 case INTEGER_TYPE:
1689 case BOOLEAN_TYPE:
1690 return (desires & WANT_INT) ? expr : NULL_TREE;
1691 case ENUMERAL_TYPE:
1692 return (desires & WANT_ENUM) ? expr : NULL_TREE;
1693 case REAL_TYPE:
1694 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1695 default:
1696 return NULL_TREE;
1697 }
1698
1699 default:
1700 return NULL_TREE;
1701 }
1702
1703 /* The code for conversions from class type is currently only used for
1704 delete expressions. Other expressions are handled by build_new_op. */
1705 if (!complete_type_or_maybe_complain (basetype, expr, complain))
1706 return error_mark_node;
1707 if (!TYPE_HAS_CONVERSION (basetype))
1708 return NULL_TREE;
1709
1710 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1711 {
1712 int win = 0;
1713 tree candidate;
1714 tree cand = TREE_VALUE (conv);
1715 cand = OVL_FIRST (cand);
1716
1717 if (winner && winner == cand)
1718 continue;
1719
1720 if (DECL_NONCONVERTING_P (cand))
1721 continue;
1722
1723 candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
1724
1725 switch (TREE_CODE (candidate))
1726 {
1727 case BOOLEAN_TYPE:
1728 case INTEGER_TYPE:
1729 win = (desires & WANT_INT); break;
1730 case ENUMERAL_TYPE:
1731 win = (desires & WANT_ENUM); break;
1732 case REAL_TYPE:
1733 win = (desires & WANT_FLOAT); break;
1734 case POINTER_TYPE:
1735 win = (desires & WANT_POINTER); break;
1736
1737 case COMPLEX_TYPE:
1738 case VECTOR_TYPE:
1739 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1740 break;
1741 switch (TREE_CODE (TREE_TYPE (candidate)))
1742 {
1743 case BOOLEAN_TYPE:
1744 case INTEGER_TYPE:
1745 win = (desires & WANT_INT); break;
1746 case ENUMERAL_TYPE:
1747 win = (desires & WANT_ENUM); break;
1748 case REAL_TYPE:
1749 win = (desires & WANT_FLOAT); break;
1750 default:
1751 break;
1752 }
1753 break;
1754
1755 default:
1756 /* A wildcard could be instantiated to match any desired
1757 type, but we can't deduce the template argument. */
1758 if (WILDCARD_TYPE_P (candidate))
1759 win = true;
1760 break;
1761 }
1762
1763 if (win)
1764 {
1765 if (TREE_CODE (cand) == TEMPLATE_DECL)
1766 {
1767 if (complain)
1768 error ("default type conversion can't deduce template"
1769 " argument for %qD", cand);
1770 return error_mark_node;
1771 }
1772
1773 if (winner)
1774 {
1775 tree winner_type
1776 = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1777
1778 if (!same_type_ignoring_top_level_qualifiers_p (winner_type,
1779 candidate))
1780 {
1781 if (complain)
1782 {
1783 error ("ambiguous default type conversion from %qT",
1784 basetype);
1785 inform (input_location,
1786 " candidate conversions include %qD and %qD",
1787 winner, cand);
1788 }
1789 return error_mark_node;
1790 }
1791 }
1792
1793 winner = cand;
1794 }
1795 }
1796
1797 if (winner)
1798 {
1799 tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1800 return build_user_type_conversion (type, expr, LOOKUP_NORMAL,
1801 tf_warning_or_error);
1802 }
1803
1804 return NULL_TREE;
1805 }
1806
1807 /* Implements integral promotion (4.1) and float->double promotion. */
1808
1809 tree
1810 type_promotes_to (tree type)
1811 {
1812 tree promoted_type;
1813
1814 if (type == error_mark_node)
1815 return error_mark_node;
1816
1817 type = TYPE_MAIN_VARIANT (type);
1818
1819 /* Check for promotions of target-defined types first. */
1820 promoted_type = targetm.promoted_type (type);
1821 if (promoted_type)
1822 return promoted_type;
1823
1824 /* bool always promotes to int (not unsigned), even if it's the same
1825 size. */
1826 if (TREE_CODE (type) == BOOLEAN_TYPE)
1827 type = integer_type_node;
1828
1829 /* Normally convert enums to int, but convert wide enums to something
1830 wider. Scoped enums don't promote, but pretend they do for backward
1831 ABI bug compatibility wrt varargs. */
1832 else if (TREE_CODE (type) == ENUMERAL_TYPE
1833 || type == char16_type_node
1834 || type == char32_type_node
1835 || type == wchar_type_node)
1836 {
1837 tree prom = type;
1838
1839 if (TREE_CODE (type) == ENUMERAL_TYPE)
1840 {
1841 prom = ENUM_UNDERLYING_TYPE (prom);
1842 if (!ENUM_IS_SCOPED (type)
1843 && ENUM_FIXED_UNDERLYING_TYPE_P (type))
1844 {
1845 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1846 whose underlying type is fixed (10.2) can be converted to a
1847 prvalue of its underlying type. Moreover, if integral promotion
1848 can be applied to its underlying type, a prvalue of an unscoped
1849 enumeration type whose underlying type is fixed can also be
1850 converted to a prvalue of the promoted underlying type. */
1851 return type_promotes_to (prom);
1852 }
1853 }
1854
1855 int precision = MAX (TYPE_PRECISION (type),
1856 TYPE_PRECISION (integer_type_node));
1857 tree totype = c_common_type_for_size (precision, 0);
1858 if (TYPE_UNSIGNED (prom)
1859 && ! int_fits_type_p (TYPE_MAX_VALUE (prom), totype))
1860 prom = c_common_type_for_size (precision, 1);
1861 else
1862 prom = totype;
1863 if (SCOPED_ENUM_P (type))
1864 {
1865 if (abi_version_crosses (6)
1866 && TYPE_MODE (prom) != TYPE_MODE (type))
1867 warning (OPT_Wabi, "scoped enum %qT passed through ... as "
1868 "%qT before -fabi-version=6, %qT after",
1869 type, prom, ENUM_UNDERLYING_TYPE (type));
1870 if (!abi_version_at_least (6))
1871 type = prom;
1872 }
1873 else
1874 type = prom;
1875 }
1876 else if (c_promoting_integer_type_p (type))
1877 {
1878 /* Retain unsignedness if really not getting bigger. */
1879 if (TYPE_UNSIGNED (type)
1880 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1881 type = unsigned_type_node;
1882 else
1883 type = integer_type_node;
1884 }
1885 else if (type == float_type_node)
1886 type = double_type_node;
1887
1888 return type;
1889 }
1890
1891 /* The routines below this point are carefully written to conform to
1892 the standard. They use the same terminology, and follow the rules
1893 closely. Although they are used only in pt.c at the moment, they
1894 should presumably be used everywhere in the future. */
1895
1896 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1897 Callers should check for identical types before calling this function. */
1898
1899 bool
1900 can_convert_qual (tree type, tree expr)
1901 {
1902 tree expr_type = TREE_TYPE (expr);
1903 gcc_assert (!same_type_p (type, expr_type));
1904
1905 if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type))
1906 return comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type));
1907 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (expr_type))
1908 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
1909 TYPE_PTRMEM_CLASS_TYPE (expr_type))
1910 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
1911 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)));
1912 else
1913 return false;
1914 }
1915
1916 /* Attempt to perform qualification conversions on EXPR to convert it
1917 to TYPE. Return the resulting expression, or error_mark_node if
1918 the conversion was impossible. */
1919
1920 tree
1921 perform_qualification_conversions (tree type, tree expr)
1922 {
1923 tree expr_type;
1924
1925 expr_type = TREE_TYPE (expr);
1926
1927 if (same_type_p (type, expr_type))
1928 return expr;
1929 else if (can_convert_qual (type, expr))
1930 return build_nop (type, expr);
1931 else
1932 return error_mark_node;
1933 }
1934
1935 /* True iff T is a transaction-safe function type. */
1936
1937 bool
1938 tx_safe_fn_type_p (tree t)
1939 {
1940 if (TREE_CODE (t) != FUNCTION_TYPE
1941 && TREE_CODE (t) != METHOD_TYPE)
1942 return false;
1943 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t));
1944 }
1945
1946 /* Return the transaction-unsafe variant of transaction-safe function type
1947 T. */
1948
1949 tree
1950 tx_unsafe_fn_variant (tree t)
1951 {
1952 gcc_assert (tx_safe_fn_type_p (t));
1953 tree attrs = remove_attribute ("transaction_safe",
1954 TYPE_ATTRIBUTES (t));
1955 return cp_build_type_attribute_variant (t, attrs);
1956 }
1957
1958 /* Return true iff FROM can convert to TO by a transaction-safety
1959 conversion. */
1960
1961 static bool
1962 can_convert_tx_safety (tree to, tree from)
1963 {
1964 return (flag_tm && tx_safe_fn_type_p (from)
1965 && same_type_p (to, tx_unsafe_fn_variant (from)));
1966 }
1967
1968 /* Return true iff FROM can convert to TO by dropping noexcept. */
1969
1970 static bool
1971 noexcept_conv_p (tree to, tree from)
1972 {
1973 if (!flag_noexcept_type)
1974 return false;
1975
1976 tree t = non_reference (to);
1977 tree f = from;
1978 if (TYPE_PTRMEMFUNC_P (t)
1979 && TYPE_PTRMEMFUNC_P (f))
1980 {
1981 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
1982 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
1983 }
1984 if (TREE_CODE (t) == POINTER_TYPE
1985 && TREE_CODE (f) == POINTER_TYPE)
1986 {
1987 t = TREE_TYPE (t);
1988 f = TREE_TYPE (f);
1989 }
1990 tree_code code = TREE_CODE (f);
1991 if (TREE_CODE (t) != code)
1992 return false;
1993 if (code != FUNCTION_TYPE && code != METHOD_TYPE)
1994 return false;
1995 if (!type_throw_all_p (t)
1996 || type_throw_all_p (f))
1997 return false;
1998 tree v = build_exception_variant (f, NULL_TREE);
1999 return same_type_p (t, v);
2000 }
2001
2002 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2003
2004 bool
2005 fnptr_conv_p (tree to, tree from)
2006 {
2007 tree t = non_reference (to);
2008 tree f = from;
2009 if (TYPE_PTRMEMFUNC_P (t)
2010 && TYPE_PTRMEMFUNC_P (f))
2011 {
2012 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
2013 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
2014 }
2015 if (TREE_CODE (t) == POINTER_TYPE
2016 && TREE_CODE (f) == POINTER_TYPE)
2017 {
2018 t = TREE_TYPE (t);
2019 f = TREE_TYPE (f);
2020 }
2021
2022 return (noexcept_conv_p (t, f)
2023 || can_convert_tx_safety (t, f));
2024 }
2025
2026 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2027 conversions or conversions to the same type. */
2028
2029 tree
2030 strip_fnptr_conv (tree fn)
2031 {
2032 while (TREE_CODE (fn) == NOP_EXPR)
2033 {
2034 tree op = TREE_OPERAND (fn, 0);
2035 tree ft = TREE_TYPE (fn);
2036 tree ot = TREE_TYPE (op);
2037 if (same_type_p (ft, ot)
2038 || fnptr_conv_p (ft, ot))
2039 fn = op;
2040 else
2041 break;
2042 }
2043 return fn;
2044 }