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