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