1 /* Language-level data type conversion for GNU C++.
2 Copyright (C) 1987-2020 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 (POINTER_SIZE, 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. */
603
604 tree
cp_fold_convert(tree type,tree expr)605 cp_fold_convert (tree type, tree expr)
606 {
607 tree conv;
608 if (TREE_TYPE (expr) == type)
609 conv = expr;
610 else if (TREE_CODE (expr) == PTRMEM_CST
611 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
612 PTRMEM_CST_CLASS (expr)))
613 {
614 /* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
615 conv = copy_node (expr);
616 TREE_TYPE (conv) = type;
617 }
618 else if (TYPE_PTRMEM_P (type))
619 {
620 conv = convert_ptrmem (type, expr, true, false,
621 tf_warning_or_error);
622 conv = cp_fully_fold (conv);
623 }
624 else
625 {
626 conv = fold_convert (type, expr);
627 conv = ignore_overflows (conv, expr);
628 }
629 return conv;
630 }
631
632 /* C++ conversions, preference to static cast conversions. */
633
634 tree
cp_convert(tree type,tree expr,tsubst_flags_t complain)635 cp_convert (tree type, tree expr, tsubst_flags_t complain)
636 {
637 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL, complain);
638 }
639
640 /* C++ equivalent of convert_and_check but using cp_convert as the
641 conversion function.
642
643 Convert EXPR to TYPE, warning about conversion problems with constants.
644 Invoke this function on every expression that is converted implicitly,
645 i.e. because of language rules and not because of an explicit cast. */
646
647 tree
cp_convert_and_check(tree type,tree expr,tsubst_flags_t complain)648 cp_convert_and_check (tree type, tree expr, tsubst_flags_t complain)
649 {
650 tree result;
651
652 if (TREE_TYPE (expr) == type)
653 return expr;
654 if (expr == error_mark_node)
655 return expr;
656 result = cp_convert (type, expr, complain);
657
658 if ((complain & tf_warning)
659 && c_inhibit_evaluation_warnings == 0)
660 {
661 tree folded = cp_fully_fold (expr);
662 tree folded_result;
663 if (folded == expr)
664 folded_result = result;
665 else
666 {
667 /* Avoid bogus -Wparentheses warnings. */
668 warning_sentinel w (warn_parentheses);
669 warning_sentinel c (warn_int_in_bool_context);
670 folded_result = cp_convert (type, folded, tf_none);
671 }
672 folded_result = fold_simple (folded_result);
673 if (!TREE_OVERFLOW_P (folded)
674 && folded_result != error_mark_node)
675 warnings_for_convert_and_check (cp_expr_loc_or_input_loc (expr),
676 type, folded, folded_result);
677 }
678
679 return result;
680 }
681
682 /* Conversion...
683
684 FLAGS indicates how we should behave. */
685
686 tree
ocp_convert(tree type,tree expr,int convtype,int flags,tsubst_flags_t complain)687 ocp_convert (tree type, tree expr, int convtype, int flags,
688 tsubst_flags_t complain)
689 {
690 tree e = expr;
691 enum tree_code code = TREE_CODE (type);
692 const char *invalid_conv_diag;
693 tree e1;
694 location_t loc = cp_expr_loc_or_input_loc (expr);
695 bool dofold = (convtype & CONV_FOLD);
696
697 if (error_operand_p (e) || type == error_mark_node)
698 return error_mark_node;
699
700 if (TREE_CODE (e) == COMPOUND_EXPR)
701 {
702 e = ocp_convert (type, TREE_OPERAND (e, 1), convtype, flags, complain);
703 if (e == error_mark_node)
704 return error_mark_node;
705 if (e == TREE_OPERAND (expr, 1))
706 return expr;
707 return build2_loc (EXPR_LOCATION (expr), COMPOUND_EXPR, TREE_TYPE (e),
708 TREE_OPERAND (expr, 0), e);
709 }
710
711 complete_type (type);
712 complete_type (TREE_TYPE (expr));
713
714 if ((invalid_conv_diag
715 = targetm.invalid_conversion (TREE_TYPE (expr), type)))
716 {
717 if (complain & tf_error)
718 error (invalid_conv_diag);
719 return error_mark_node;
720 }
721
722 /* FIXME remove when moving to c_fully_fold model. */
723 if (!CLASS_TYPE_P (type))
724 {
725 e = mark_rvalue_use (e);
726 tree v = scalar_constant_value (e);
727 if (!error_operand_p (v))
728 e = v;
729 }
730 if (error_operand_p (e))
731 return error_mark_node;
732
733 if (NULLPTR_TYPE_P (type) && null_ptr_cst_p (e))
734 {
735 if (complain & tf_warning)
736 maybe_warn_zero_as_null_pointer_constant (e, loc);
737
738 if (!TREE_SIDE_EFFECTS (e))
739 return nullptr_node;
740 }
741
742 if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
743 /* We need a new temporary; don't take this shortcut. */;
744 else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
745 {
746 tree etype = TREE_TYPE (e);
747 if (same_type_p (type, etype))
748 /* The call to fold will not always remove the NOP_EXPR as
749 might be expected, since if one of the types is a typedef;
750 the comparison in fold is just equality of pointers, not a
751 call to comptypes. We don't call fold in this case because
752 that can result in infinite recursion; fold will call
753 convert, which will call ocp_convert, etc. */
754 return e;
755 /* For complex data types, we need to perform componentwise
756 conversion. */
757 else if (TREE_CODE (type) == COMPLEX_TYPE)
758 return convert_to_complex_maybe_fold (type, e, dofold);
759 else if (VECTOR_TYPE_P (type))
760 return convert_to_vector (type, rvalue (e));
761 else if (TREE_CODE (e) == TARGET_EXPR)
762 {
763 /* Don't build a NOP_EXPR of class type. Instead, change the
764 type of the temporary. */
765 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
766 TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
767 return e;
768 }
769 else if (TREE_CODE (e) == CONSTRUCTOR)
770 {
771 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
772 TREE_TYPE (e) = type;
773 return e;
774 }
775 else
776 {
777 /* We shouldn't be treating objects of ADDRESSABLE type as
778 rvalues. */
779 gcc_assert (!TREE_ADDRESSABLE (type));
780 return build_nop (type, e);
781 }
782 }
783
784 e1 = targetm.convert_to_type (type, e);
785 if (e1)
786 return e1;
787
788 if (code == VOID_TYPE && (convtype & CONV_STATIC))
789 {
790 e = convert_to_void (e, ICV_CAST, complain);
791 return e;
792 }
793
794 if (INTEGRAL_CODE_P (code))
795 {
796 tree intype = TREE_TYPE (e);
797 tree converted;
798
799 if (TREE_CODE (type) == ENUMERAL_TYPE)
800 {
801 /* enum = enum, enum = int, enum = float, (enum)pointer are all
802 errors. */
803 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
804 || TREE_CODE (intype) == REAL_TYPE)
805 && ! (convtype & CONV_STATIC))
806 || TYPE_PTR_P (intype))
807 {
808 if (complain & tf_error)
809 permerror (loc, "conversion from %q#T to %q#T", intype, type);
810 else
811 return error_mark_node;
812 }
813
814 /* [expr.static.cast]
815
816 8. A value of integral or enumeration type can be explicitly
817 converted to an enumeration type. The value is unchanged if
818 the original value is within the range of the enumeration
819 values. Otherwise, the resulting enumeration value is
820 unspecified. */
821 tree val = fold_for_warn (e);
822 if ((complain & tf_warning)
823 && TREE_CODE (val) == INTEGER_CST
824 && ENUM_UNDERLYING_TYPE (type)
825 && !int_fits_type_p (val, ENUM_UNDERLYING_TYPE (type)))
826 warning_at (loc, OPT_Wconversion,
827 "the result of the conversion is unspecified because "
828 "%qE is outside the range of type %qT",
829 expr, type);
830 }
831 if (MAYBE_CLASS_TYPE_P (intype))
832 {
833 tree rval;
834 rval = build_type_conversion (type, e);
835 if (rval)
836 return rval;
837 if (complain & tf_error)
838 error_at (loc, "%q#T used where a %qT was expected", intype, type);
839 return error_mark_node;
840 }
841 if (code == BOOLEAN_TYPE)
842 {
843 if (VOID_TYPE_P (intype))
844 {
845 if (complain & tf_error)
846 error_at (loc,
847 "could not convert %qE from %<void%> to %<bool%>",
848 expr);
849 return error_mark_node;
850 }
851
852 if (VECTOR_TYPE_P (intype) && !gnu_vector_type_p (intype))
853 {
854 if (complain & tf_error)
855 error_at (loc, "could not convert %qE from %qH to %qI", expr,
856 TREE_TYPE (expr), type);
857 return error_mark_node;
858 }
859
860 /* We can't implicitly convert a scoped enum to bool, so convert
861 to the underlying type first. */
862 if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC))
863 e = build_nop (ENUM_UNDERLYING_TYPE (intype), e);
864 if (complain & tf_warning)
865 return cp_truthvalue_conversion (e, complain);
866 else
867 {
868 /* Prevent bogus -Wint-in-bool-context warnings coming
869 from c_common_truthvalue_conversion down the line. */
870 warning_sentinel w (warn_int_in_bool_context);
871 warning_sentinel c (warn_sign_compare);
872 return cp_truthvalue_conversion (e, complain);
873 }
874 }
875
876 converted = convert_to_integer_maybe_fold (type, e, dofold);
877
878 /* Ignore any integer overflow caused by the conversion. */
879 return ignore_overflows (converted, e);
880 }
881 if (INDIRECT_TYPE_P (type) || TYPE_PTRMEM_P (type))
882 return cp_convert_to_pointer (type, e, dofold, complain);
883 if (code == VECTOR_TYPE)
884 {
885 tree in_vtype = TREE_TYPE (e);
886 if (MAYBE_CLASS_TYPE_P (in_vtype))
887 {
888 tree ret_val;
889 ret_val = build_type_conversion (type, e);
890 if (ret_val)
891 return ret_val;
892 if (complain & tf_error)
893 error_at (loc, "%q#T used where a %qT was expected",
894 in_vtype, type);
895 return error_mark_node;
896 }
897 return convert_to_vector (type, rvalue (e));
898 }
899 if (code == REAL_TYPE || code == COMPLEX_TYPE)
900 {
901 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
902 {
903 tree rval;
904 rval = build_type_conversion (type, e);
905 if (rval)
906 return rval;
907 else if (complain & tf_error)
908 error_at (loc,
909 "%q#T used where a floating-point value was expected",
910 TREE_TYPE (e));
911 }
912 if (code == REAL_TYPE)
913 return convert_to_real_maybe_fold (type, e, dofold);
914 else if (code == COMPLEX_TYPE)
915 return convert_to_complex_maybe_fold (type, e, dofold);
916 }
917
918 /* New C++ semantics: since assignment is now based on
919 memberwise copying, if the rhs type is derived from the
920 lhs type, then we may still do a conversion. */
921 if (RECORD_OR_UNION_CODE_P (code))
922 {
923 tree dtype = TREE_TYPE (e);
924 tree ctor = NULL_TREE;
925
926 dtype = TYPE_MAIN_VARIANT (dtype);
927
928 /* Conversion between aggregate types. New C++ semantics allow
929 objects of derived type to be cast to objects of base type.
930 Old semantics only allowed this between pointers.
931
932 There may be some ambiguity between using a constructor
933 vs. using a type conversion operator when both apply. */
934
935 ctor = e;
936
937 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
938 return error_mark_node;
939
940 if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
941 ctor = perform_implicit_conversion (type, ctor, complain);
942 else if ((flags & LOOKUP_ONLYCONVERTING)
943 && ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
944 /* For copy-initialization, first we create a temp of the proper type
945 with a user-defined conversion sequence, then we direct-initialize
946 the target with the temp (see [dcl.init]). */
947 ctor = build_user_type_conversion (type, ctor, flags, complain);
948 else
949 {
950 releasing_vec ctor_vec (make_tree_vector_single (ctor));
951 ctor = build_special_member_call (NULL_TREE,
952 complete_ctor_identifier,
953 &ctor_vec,
954 type, flags, complain);
955 }
956 if (ctor)
957 return build_cplus_new (type, ctor, complain);
958 }
959
960 if (complain & tf_error)
961 {
962 /* If the conversion failed and expr was an invalid use of pointer to
963 member function, try to report a meaningful error. */
964 if (invalid_nonstatic_memfn_p (loc, expr, complain))
965 /* We displayed the error message. */;
966 else
967 error_at (loc, "conversion from %qH to non-scalar type %qI requested",
968 TREE_TYPE (expr), type);
969 }
970 return error_mark_node;
971 }
972
973 /* If CALL is a call, return the callee; otherwise null. */
974
975 tree
cp_get_callee(tree call)976 cp_get_callee (tree call)
977 {
978 if (call == NULL_TREE)
979 return call;
980 else if (TREE_CODE (call) == CALL_EXPR)
981 return CALL_EXPR_FN (call);
982 else if (TREE_CODE (call) == AGGR_INIT_EXPR)
983 return AGGR_INIT_EXPR_FN (call);
984 return NULL_TREE;
985 }
986
987 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
988 if we can. */
989
990 tree
cp_get_fndecl_from_callee(tree fn,bool fold)991 cp_get_fndecl_from_callee (tree fn, bool fold /* = true */)
992 {
993 if (fn == NULL_TREE)
994 return fn;
995 if (TREE_CODE (fn) == FUNCTION_DECL)
996 return fn;
997 tree type = TREE_TYPE (fn);
998 if (type == NULL_TREE || !INDIRECT_TYPE_P (type))
999 return NULL_TREE;
1000 if (fold)
1001 fn = maybe_constant_init (fn);
1002 STRIP_NOPS (fn);
1003 if (TREE_CODE (fn) == ADDR_EXPR)
1004 {
1005 fn = TREE_OPERAND (fn, 0);
1006 if (TREE_CODE (fn) == FUNCTION_DECL)
1007 return fn;
1008 }
1009 return NULL_TREE;
1010 }
1011
1012 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
1013 constexpr machinery. */
1014
1015 tree
cp_get_callee_fndecl(tree call)1016 cp_get_callee_fndecl (tree call)
1017 {
1018 return cp_get_fndecl_from_callee (cp_get_callee (call));
1019 }
1020
1021 /* As above, but not using the constexpr machinery. */
1022
1023 tree
cp_get_callee_fndecl_nofold(tree call)1024 cp_get_callee_fndecl_nofold (tree call)
1025 {
1026 return cp_get_fndecl_from_callee (cp_get_callee (call), false);
1027 }
1028
1029 /* Subroutine of convert_to_void. Warn if we're discarding something with
1030 attribute [[nodiscard]]. */
1031
1032 static void
maybe_warn_nodiscard(tree expr,impl_conv_void implicit)1033 maybe_warn_nodiscard (tree expr, impl_conv_void implicit)
1034 {
1035 tree call = expr;
1036 if (TREE_CODE (expr) == TARGET_EXPR)
1037 call = TARGET_EXPR_INITIAL (expr);
1038 location_t loc = cp_expr_loc_or_input_loc (call);
1039 tree callee = cp_get_callee (call);
1040 if (!callee)
1041 return;
1042
1043 tree type = TREE_TYPE (callee);
1044 if (TYPE_PTRMEMFUNC_P (type))
1045 type = TYPE_PTRMEMFUNC_FN_TYPE (type);
1046 if (INDIRECT_TYPE_P (type))
1047 type = TREE_TYPE (type);
1048
1049 tree rettype = TREE_TYPE (type);
1050 tree fn = cp_get_fndecl_from_callee (callee);
1051 tree attr;
1052 if (implicit != ICV_CAST && fn
1053 && (attr = lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn))))
1054 {
1055 escaped_string msg;
1056 tree args = TREE_VALUE (attr);
1057 if (args)
1058 msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
1059 const char *format
1060 = (msg
1061 ? G_("ignoring return value of %qD, "
1062 "declared with attribute %<nodiscard%>: %<%s%>")
1063 : G_("ignoring return value of %qD, "
1064 "declared with attribute %<nodiscard%>%s"));
1065 const char *raw_msg = msg ? (const char *) msg : "";
1066 auto_diagnostic_group d;
1067 if (warning_at (loc, OPT_Wunused_result, format, fn, raw_msg))
1068 inform (DECL_SOURCE_LOCATION (fn), "declared here");
1069 }
1070 else if (implicit != ICV_CAST
1071 && (attr = lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype))))
1072 {
1073 escaped_string msg;
1074 tree args = TREE_VALUE (attr);
1075 if (args)
1076 msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
1077 const char *format
1078 = (msg
1079 ? G_("ignoring returned value of type %qT, "
1080 "declared with attribute %<nodiscard%>: %<%s%>")
1081 : G_("ignoring returned value of type %qT, "
1082 "declared with attribute %<nodiscard%>%s"));
1083 const char *raw_msg = msg ? (const char *) msg : "";
1084 auto_diagnostic_group d;
1085 if (warning_at (loc, OPT_Wunused_result, format, rettype, raw_msg))
1086 {
1087 if (fn)
1088 inform (DECL_SOURCE_LOCATION (fn),
1089 "in call to %qD, declared here", fn);
1090 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype)),
1091 "%qT declared here", rettype);
1092 }
1093 }
1094 else if (TREE_CODE (expr) == TARGET_EXPR
1095 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type)))
1096 {
1097 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1098 result is used, so handle that case here. */
1099 if (fn)
1100 {
1101 auto_diagnostic_group d;
1102 if (warning_at (loc, OPT_Wunused_result,
1103 "ignoring return value of %qD, "
1104 "declared with attribute %<warn_unused_result%>",
1105 fn))
1106 inform (DECL_SOURCE_LOCATION (fn), "declared here");
1107 }
1108 else
1109 warning_at (loc, OPT_Wunused_result,
1110 "ignoring return value of function "
1111 "declared with attribute %<warn_unused_result%>");
1112 }
1113 }
1114
1115 /* When an expression is used in a void context, its value is discarded and
1116 no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1117 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1118 in a void context. The C++ standard does not define what an `access' to an
1119 object is, but there is reason to believe that it is the lvalue to rvalue
1120 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1121 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1122 indicates that volatile semantics should be the same between C and C++
1123 where ever possible. C leaves it implementation defined as to what
1124 constitutes an access to a volatile. So, we interpret `*vp' as a read of
1125 the volatile object `vp' points to, unless that is an incomplete type. For
1126 volatile references we do not do this interpretation, because that would
1127 make it impossible to ignore the reference return value from functions. We
1128 issue warnings in the confusing cases.
1129
1130 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1131 to void via a cast. If an expression is being implicitly converted, IMPLICIT
1132 indicates the context of the implicit conversion. */
1133
1134 tree
convert_to_void(tree expr,impl_conv_void implicit,tsubst_flags_t complain)1135 convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
1136 {
1137 location_t loc = cp_expr_loc_or_input_loc (expr);
1138
1139 if (expr == error_mark_node
1140 || TREE_TYPE (expr) == error_mark_node)
1141 return error_mark_node;
1142
1143 expr = maybe_undo_parenthesized_ref (expr);
1144
1145 expr = mark_discarded_use (expr);
1146 if (implicit == ICV_CAST)
1147 /* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1148 mark_exp_read (expr);
1149
1150 if (!TREE_TYPE (expr))
1151 return expr;
1152 if (invalid_nonstatic_memfn_p (loc, expr, complain))
1153 return error_mark_node;
1154 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
1155 {
1156 if (complain & tf_error)
1157 error_at (loc, "pseudo-destructor is not called");
1158 return error_mark_node;
1159 }
1160
1161 /* Explicitly evaluate void-converted concept checks since their
1162 satisfaction may produce ill-formed programs. */
1163 if (concept_check_p (expr))
1164 expr = evaluate_concept_check (expr, tf_warning_or_error);
1165
1166 if (VOID_TYPE_P (TREE_TYPE (expr)))
1167 return expr;
1168 switch (TREE_CODE (expr))
1169 {
1170 case COND_EXPR:
1171 {
1172 /* The two parts of a cond expr might be separate lvalues. */
1173 tree op1 = TREE_OPERAND (expr,1);
1174 tree op2 = TREE_OPERAND (expr,2);
1175 bool side_effects = ((op1 && TREE_SIDE_EFFECTS (op1))
1176 || TREE_SIDE_EFFECTS (op2));
1177 tree new_op1, new_op2;
1178 new_op1 = NULL_TREE;
1179 if (implicit != ICV_CAST && !side_effects)
1180 {
1181 if (op1)
1182 new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain);
1183 new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain);
1184 }
1185 else
1186 {
1187 if (op1)
1188 new_op1 = convert_to_void (op1, ICV_CAST, complain);
1189 new_op2 = convert_to_void (op2, ICV_CAST, complain);
1190 }
1191
1192 expr = build3 (COND_EXPR, TREE_TYPE (new_op2),
1193 TREE_OPERAND (expr, 0), new_op1, new_op2);
1194 break;
1195 }
1196
1197 case COMPOUND_EXPR:
1198 {
1199 /* The second part of a compound expr contains the value. */
1200 tree op1 = TREE_OPERAND (expr,1);
1201 tree new_op1;
1202 if (implicit != ICV_CAST && !TREE_NO_WARNING (expr))
1203 new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain);
1204 else
1205 new_op1 = convert_to_void (op1, ICV_CAST, complain);
1206
1207 if (new_op1 != op1)
1208 {
1209 tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1),
1210 TREE_OPERAND (expr, 0), new_op1);
1211 expr = t;
1212 }
1213
1214 break;
1215 }
1216
1217 case NON_LVALUE_EXPR:
1218 case NOP_EXPR:
1219 /* These have already decayed to rvalue. */
1220 break;
1221
1222 case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
1223 /* cdtors may return this or void, depending on
1224 targetm.cxx.cdtor_returns_this, but this shouldn't affect our
1225 decisions here: neither nodiscard warnings (nodiscard dtors
1226 are nonsensical and ctors have a different behavior with that
1227 attribute that is handled in the TARGET_EXPR case), nor should
1228 any constexpr or template instantiations be affected by an ABI
1229 property that is, or at least ought to be transparent to the
1230 language. */
1231 if (tree fn = cp_get_callee_fndecl_nofold (expr))
1232 if (DECL_CONSTRUCTOR_P (fn) || DECL_DESTRUCTOR_P (fn))
1233 return expr;
1234
1235 if (complain & tf_warning)
1236 maybe_warn_nodiscard (expr, implicit);
1237 break;
1238
1239 case INDIRECT_REF:
1240 {
1241 tree type = TREE_TYPE (expr);
1242 int is_reference = TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0)));
1243 int is_volatile = TYPE_VOLATILE (type);
1244 int is_complete = COMPLETE_TYPE_P (complete_type (type));
1245
1246 /* Can't load the value if we don't know the type. */
1247 if (is_volatile && !is_complete)
1248 {
1249 if (complain & tf_warning)
1250 switch (implicit)
1251 {
1252 case ICV_CAST:
1253 warning_at (loc, 0, "conversion to void will not access "
1254 "object of incomplete type %qT", type);
1255 break;
1256 case ICV_SECOND_OF_COND:
1257 warning_at (loc, 0, "indirection will not access object of "
1258 "incomplete type %qT in second operand "
1259 "of conditional expression", type);
1260 break;
1261 case ICV_THIRD_OF_COND:
1262 warning_at (loc, 0, "indirection will not access object of "
1263 "incomplete type %qT in third operand "
1264 "of conditional expression", type);
1265 break;
1266 case ICV_RIGHT_OF_COMMA:
1267 warning_at (loc, 0, "indirection will not access object of "
1268 "incomplete type %qT in right operand of "
1269 "comma operator", type);
1270 break;
1271 case ICV_LEFT_OF_COMMA:
1272 warning_at (loc, 0, "indirection will not access object of "
1273 "incomplete type %qT in left operand of "
1274 "comma operator", type);
1275 break;
1276 case ICV_STATEMENT:
1277 warning_at (loc, 0, "indirection will not access object of "
1278 "incomplete type %qT in statement", type);
1279 break;
1280 case ICV_THIRD_IN_FOR:
1281 warning_at (loc, 0, "indirection will not access object of "
1282 "incomplete type %qT in for increment "
1283 "expression", type);
1284 break;
1285 default:
1286 gcc_unreachable ();
1287 }
1288 }
1289 /* Don't load the value if this is an implicit dereference, or if
1290 the type needs to be handled by ctors/dtors. */
1291 else if (is_volatile && is_reference)
1292 {
1293 if (complain & tf_warning)
1294 switch (implicit)
1295 {
1296 case ICV_CAST:
1297 warning_at (loc, 0, "conversion to void will not access "
1298 "object of type %qT", type);
1299 break;
1300 case ICV_SECOND_OF_COND:
1301 warning_at (loc, 0, "implicit dereference will not access "
1302 "object of type %qT in second operand of "
1303 "conditional expression", type);
1304 break;
1305 case ICV_THIRD_OF_COND:
1306 warning_at (loc, 0, "implicit dereference will not access "
1307 "object of type %qT in third operand of "
1308 "conditional expression", type);
1309 break;
1310 case ICV_RIGHT_OF_COMMA:
1311 warning_at (loc, 0, "implicit dereference will not access "
1312 "object of type %qT in right operand of "
1313 "comma operator", type);
1314 break;
1315 case ICV_LEFT_OF_COMMA:
1316 warning_at (loc, 0, "implicit dereference will not access "
1317 "object of type %qT in left operand of comma "
1318 "operator", type);
1319 break;
1320 case ICV_STATEMENT:
1321 warning_at (loc, 0, "implicit dereference will not access "
1322 "object of type %qT in statement", type);
1323 break;
1324 case ICV_THIRD_IN_FOR:
1325 warning_at (loc, 0, "implicit dereference will not access "
1326 "object of type %qT in for increment expression",
1327 type);
1328 break;
1329 default:
1330 gcc_unreachable ();
1331 }
1332 }
1333 else if (is_volatile && TREE_ADDRESSABLE (type))
1334 {
1335 if (complain & tf_warning)
1336 switch (implicit)
1337 {
1338 case ICV_CAST:
1339 warning_at (loc, 0, "conversion to void will not access "
1340 "object of non-trivially-copyable type %qT",
1341 type);
1342 break;
1343 case ICV_SECOND_OF_COND:
1344 warning_at (loc, 0, "indirection will not access object of "
1345 "non-trivially-copyable type %qT in second "
1346 "operand of conditional expression", type);
1347 break;
1348 case ICV_THIRD_OF_COND:
1349 warning_at (loc, 0, "indirection will not access object of "
1350 "non-trivially-copyable type %qT in third "
1351 "operand of conditional expression", type);
1352 break;
1353 case ICV_RIGHT_OF_COMMA:
1354 warning_at (loc, 0, "indirection will not access object of "
1355 "non-trivially-copyable type %qT in right "
1356 "operand of comma operator", type);
1357 break;
1358 case ICV_LEFT_OF_COMMA:
1359 warning_at (loc, 0, "indirection will not access object of "
1360 "non-trivially-copyable type %qT in left "
1361 "operand of comma operator", type);
1362 break;
1363 case ICV_STATEMENT:
1364 warning_at (loc, 0, "indirection will not access object of "
1365 "non-trivially-copyable type %qT in statement",
1366 type);
1367 break;
1368 case ICV_THIRD_IN_FOR:
1369 warning_at (loc, 0, "indirection will not access object of "
1370 "non-trivially-copyable type %qT in for "
1371 "increment expression", type);
1372 break;
1373 default:
1374 gcc_unreachable ();
1375 }
1376 }
1377 if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
1378 {
1379 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1380 operation is stripped off. Note that we don't warn about
1381 - an expression with TREE_NO_WARNING set. (For an example of
1382 such expressions, see build_over_call in call.c.)
1383 - automatic dereferencing of references, since the user cannot
1384 control it. (See also warn_if_unused_value() in c-common.c.) */
1385 if (warn_unused_value
1386 && implicit != ICV_CAST
1387 && (complain & tf_warning)
1388 && !TREE_NO_WARNING (expr)
1389 && !is_reference)
1390 warning_at (loc, OPT_Wunused_value, "value computed is not used");
1391 expr = TREE_OPERAND (expr, 0);
1392 if (TREE_CODE (expr) == CALL_EXPR
1393 && (complain & tf_warning))
1394 maybe_warn_nodiscard (expr, implicit);
1395 }
1396
1397 break;
1398 }
1399
1400 case VAR_DECL:
1401 {
1402 /* External variables might be incomplete. */
1403 tree type = TREE_TYPE (expr);
1404 int is_complete = COMPLETE_TYPE_P (complete_type (type));
1405
1406 if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
1407 switch (implicit)
1408 {
1409 case ICV_CAST:
1410 warning_at (loc, 0, "conversion to void will not access "
1411 "object %qE of incomplete type %qT", expr, type);
1412 break;
1413 case ICV_SECOND_OF_COND:
1414 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1415 "not be accessed in second operand of "
1416 "conditional expression", expr, type);
1417 break;
1418 case ICV_THIRD_OF_COND:
1419 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1420 "not be accessed in third operand of "
1421 "conditional expression", expr, type);
1422 break;
1423 case ICV_RIGHT_OF_COMMA:
1424 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1425 "not be accessed in right operand of comma operator",
1426 expr, type);
1427 break;
1428 case ICV_LEFT_OF_COMMA:
1429 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1430 "not be accessed in left operand of comma operator",
1431 expr, type);
1432 break;
1433 case ICV_STATEMENT:
1434 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1435 "not be accessed in statement", expr, type);
1436 break;
1437 case ICV_THIRD_IN_FOR:
1438 warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1439 "not be accessed in for increment expression",
1440 expr, type);
1441 break;
1442 default:
1443 gcc_unreachable ();
1444 }
1445
1446 break;
1447 }
1448
1449 case TARGET_EXPR:
1450 /* Don't bother with the temporary object returned from a function if
1451 we don't use it, don't need to destroy it, and won't abort in
1452 assign_temp. We'll still
1453 allocate space for it in expand_call or declare_return_variable,
1454 but we don't need to track it through all the tree phases. */
1455 if (TARGET_EXPR_IMPLICIT_P (expr)
1456 && !TREE_ADDRESSABLE (TREE_TYPE (expr)))
1457 {
1458 tree init = TARGET_EXPR_INITIAL (expr);
1459 if (TREE_CODE (init) == AGGR_INIT_EXPR
1460 && !AGGR_INIT_VIA_CTOR_P (init))
1461 {
1462 tree fn = AGGR_INIT_EXPR_FN (init);
1463 expr = build_call_array_loc (input_location,
1464 TREE_TYPE (TREE_TYPE
1465 (TREE_TYPE (fn))),
1466 fn,
1467 aggr_init_expr_nargs (init),
1468 AGGR_INIT_EXPR_ARGP (init));
1469 }
1470 }
1471 if (complain & tf_warning)
1472 maybe_warn_nodiscard (expr, implicit);
1473 break;
1474
1475 default:;
1476 }
1477 expr = resolve_nondeduced_context (expr, complain);
1478 {
1479 tree probe = expr;
1480
1481 if (TREE_CODE (probe) == ADDR_EXPR)
1482 probe = TREE_OPERAND (expr, 0);
1483 if (type_unknown_p (probe))
1484 {
1485 /* [over.over] enumerates the places where we can take the address
1486 of an overloaded function, and this is not one of them. */
1487 if (complain & tf_error)
1488 switch (implicit)
1489 {
1490 case ICV_CAST:
1491 error_at (loc, "conversion to void "
1492 "cannot resolve address of overloaded function");
1493 break;
1494 case ICV_SECOND_OF_COND:
1495 error_at (loc, "second operand of conditional expression "
1496 "cannot resolve address of overloaded function");
1497 break;
1498 case ICV_THIRD_OF_COND:
1499 error_at (loc, "third operand of conditional expression "
1500 "cannot resolve address of overloaded function");
1501 break;
1502 case ICV_RIGHT_OF_COMMA:
1503 error_at (loc, "right operand of comma operator "
1504 "cannot resolve address of overloaded function");
1505 break;
1506 case ICV_LEFT_OF_COMMA:
1507 error_at (loc, "left operand of comma operator "
1508 "cannot resolve address of overloaded function");
1509 break;
1510 case ICV_STATEMENT:
1511 error_at (loc, "statement "
1512 "cannot resolve address of overloaded function");
1513 break;
1514 case ICV_THIRD_IN_FOR:
1515 error_at (loc, "for increment expression "
1516 "cannot resolve address of overloaded function");
1517 break;
1518 }
1519 else
1520 return error_mark_node;
1521 expr = void_node;
1522 }
1523 else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
1524 {
1525 /* Only warn when there is no &. */
1526 if (complain & tf_warning)
1527 switch (implicit)
1528 {
1529 case ICV_SECOND_OF_COND:
1530 warning_at (loc, OPT_Waddress,
1531 "second operand of conditional expression "
1532 "is a reference, not call, to function %qE", expr);
1533 break;
1534 case ICV_THIRD_OF_COND:
1535 warning_at (loc, OPT_Waddress,
1536 "third operand of conditional expression "
1537 "is a reference, not call, to function %qE", expr);
1538 break;
1539 case ICV_RIGHT_OF_COMMA:
1540 warning_at (loc, OPT_Waddress,
1541 "right operand of comma operator "
1542 "is a reference, not call, to function %qE", expr);
1543 break;
1544 case ICV_LEFT_OF_COMMA:
1545 warning_at (loc, OPT_Waddress,
1546 "left operand of comma operator "
1547 "is a reference, not call, to function %qE", expr);
1548 break;
1549 case ICV_STATEMENT:
1550 warning_at (loc, OPT_Waddress,
1551 "statement is a reference, not call, to function %qE",
1552 expr);
1553 break;
1554 case ICV_THIRD_IN_FOR:
1555 warning_at (loc, OPT_Waddress,
1556 "for increment expression "
1557 "is a reference, not call, to function %qE", expr);
1558 break;
1559 default:
1560 gcc_unreachable ();
1561 }
1562
1563 if (TREE_CODE (expr) == COMPONENT_REF)
1564 expr = TREE_OPERAND (expr, 0);
1565 }
1566 }
1567
1568 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
1569 {
1570 if (implicit != ICV_CAST
1571 && warn_unused_value
1572 && !TREE_NO_WARNING (expr)
1573 && !processing_template_decl
1574 && !cp_unevaluated_operand
1575 && (complain & tf_warning))
1576 {
1577 /* The middle end does not warn about expressions that have
1578 been explicitly cast to void, so we must do so here. */
1579 if (!TREE_SIDE_EFFECTS (expr))
1580 {
1581 switch (implicit)
1582 {
1583 case ICV_SECOND_OF_COND:
1584 warning_at (loc, OPT_Wunused_value,
1585 "second operand of conditional expression "
1586 "has no effect");
1587 break;
1588 case ICV_THIRD_OF_COND:
1589 warning_at (loc, OPT_Wunused_value,
1590 "third operand of conditional expression "
1591 "has no effect");
1592 break;
1593 case ICV_RIGHT_OF_COMMA:
1594 warning_at (loc, OPT_Wunused_value,
1595 "right operand of comma operator has no effect");
1596 break;
1597 case ICV_LEFT_OF_COMMA:
1598 warning_at (loc, OPT_Wunused_value,
1599 "left operand of comma operator has no effect");
1600 break;
1601 case ICV_STATEMENT:
1602 warning_at (loc, OPT_Wunused_value,
1603 "statement has no effect");
1604 break;
1605 case ICV_THIRD_IN_FOR:
1606 warning_at (loc, OPT_Wunused_value,
1607 "for increment expression has no effect");
1608 break;
1609 default:
1610 gcc_unreachable ();
1611 }
1612 }
1613 else
1614 {
1615 tree e = expr;
1616 /* We might like to warn about (say) "(int) f()", as the
1617 cast has no effect, but the compiler itself will
1618 generate implicit conversions under some
1619 circumstances. (For example a block copy will be
1620 turned into a call to "__builtin_memcpy", with a
1621 conversion of the return value to an appropriate
1622 type.) So, to avoid false positives, we strip
1623 conversions. Do not use STRIP_NOPs because it will
1624 not strip conversions to "void", as that is not a
1625 mode-preserving conversion. */
1626 while (TREE_CODE (e) == NOP_EXPR)
1627 e = TREE_OPERAND (e, 0);
1628
1629 enum tree_code code = TREE_CODE (e);
1630 enum tree_code_class tclass = TREE_CODE_CLASS (code);
1631 if (tclass == tcc_comparison
1632 || tclass == tcc_unary
1633 || tclass == tcc_binary
1634 || code == VEC_PERM_EXPR
1635 || code == VEC_COND_EXPR)
1636 warn_if_unused_value (e, loc);
1637 }
1638 }
1639 expr = build1 (CONVERT_EXPR, void_type_node, expr);
1640 }
1641 if (! TREE_SIDE_EFFECTS (expr))
1642 expr = void_node;
1643 return expr;
1644 }
1645
1646 /* Create an expression whose value is that of EXPR,
1647 converted to type TYPE. The TREE_TYPE of the value
1648 is always TYPE. This function implements all reasonable
1649 conversions; callers should filter out those that are
1650 not permitted by the language being compiled.
1651
1652 Most of this routine is from build_reinterpret_cast.
1653
1654 The back end cannot call cp_convert (what was convert) because
1655 conversions to/from basetypes may involve memory references
1656 (vbases) and adding or subtracting small values (multiple
1657 inheritance), but it calls convert from the constant folding code
1658 on subtrees of already built trees after it has ripped them apart.
1659
1660 Also, if we ever support range variables, we'll probably also have to
1661 do a little bit more work. */
1662
1663 tree
convert(tree type,tree expr)1664 convert (tree type, tree expr)
1665 {
1666 tree intype;
1667
1668 if (type == error_mark_node || expr == error_mark_node)
1669 return error_mark_node;
1670
1671 intype = TREE_TYPE (expr);
1672
1673 if (INDIRECT_TYPE_P (type) && INDIRECT_TYPE_P (intype))
1674 return build_nop (type, expr);
1675
1676 return ocp_convert (type, expr, CONV_BACKEND_CONVERT,
1677 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION,
1678 tf_warning_or_error);
1679 }
1680
1681 /* Like cp_convert, except permit conversions to take place which
1682 are not normally allowed due to access restrictions
1683 (such as conversion from sub-type to private super-type). */
1684
1685 tree
convert_force(tree type,tree expr,int convtype,tsubst_flags_t complain)1686 convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain)
1687 {
1688 tree e = expr;
1689 enum tree_code code = TREE_CODE (type);
1690
1691 if (code == REFERENCE_TYPE)
1692 return convert_to_reference (type, e, CONV_C_CAST, 0,
1693 NULL_TREE, complain);
1694
1695 if (code == POINTER_TYPE)
1696 return convert_to_pointer_force (type, e, complain);
1697
1698 /* From typeck.c convert_for_assignment */
1699 if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR
1700 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1701 || integer_zerop (e)
1702 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1703 && TYPE_PTRMEMFUNC_P (type))
1704 /* compatible pointer to member functions. */
1705 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
1706 /*c_cast_p=*/1, complain);
1707
1708 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL, complain);
1709 }
1710
1711 /* Convert an aggregate EXPR to type XTYPE. If a conversion
1712 exists, return the attempted conversion. This may
1713 return ERROR_MARK_NODE if the conversion is not
1714 allowed (references private members, etc).
1715 If no conversion exists, NULL_TREE is returned.
1716
1717 FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1718 object parameter, or by the second standard conversion sequence if
1719 that doesn't do it. This will probably wait for an overloading rewrite.
1720 (jason 8/9/95) */
1721
1722 static tree
build_type_conversion(tree xtype,tree expr)1723 build_type_conversion (tree xtype, tree expr)
1724 {
1725 /* C++: check to see if we can convert this aggregate type
1726 into the required type. */
1727 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL,
1728 tf_warning_or_error);
1729 }
1730
1731 /* Convert the given EXPR to one of a group of types suitable for use in an
1732 expression. DESIRES is a combination of various WANT_* flags (q.v.)
1733 which indicates which types are suitable. If COMPLAIN is true, complain
1734 about ambiguity; otherwise, the caller will deal with it. */
1735
1736 tree
build_expr_type_conversion(int desires,tree expr,bool complain)1737 build_expr_type_conversion (int desires, tree expr, bool complain)
1738 {
1739 tree basetype = TREE_TYPE (expr);
1740 tree conv = NULL_TREE;
1741 tree winner = NULL_TREE;
1742
1743 if (null_node_p (expr)
1744 && (desires & WANT_INT)
1745 && !(desires & WANT_NULL))
1746 {
1747 location_t loc =
1748 expansion_point_location_if_in_system_header (input_location);
1749
1750 warning_at (loc, OPT_Wconversion_null,
1751 "converting NULL to non-pointer type");
1752 }
1753
1754 if (basetype == error_mark_node)
1755 return error_mark_node;
1756
1757 if (! MAYBE_CLASS_TYPE_P (basetype))
1758 switch (TREE_CODE (basetype))
1759 {
1760 case INTEGER_TYPE:
1761 if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1762 return expr;
1763 /* fall through. */
1764
1765 case BOOLEAN_TYPE:
1766 return (desires & WANT_INT) ? expr : NULL_TREE;
1767 case ENUMERAL_TYPE:
1768 return (desires & WANT_ENUM) ? expr : NULL_TREE;
1769 case REAL_TYPE:
1770 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1771 case POINTER_TYPE:
1772 return (desires & WANT_POINTER) ? expr : NULL_TREE;
1773
1774 case FUNCTION_TYPE:
1775 case ARRAY_TYPE:
1776 return (desires & WANT_POINTER) ? decay_conversion (expr,
1777 tf_warning_or_error)
1778 : NULL_TREE;
1779
1780 case VECTOR_TYPE:
1781 if (!gnu_vector_type_p (basetype))
1782 return NULL_TREE;
1783 /* FALLTHROUGH */
1784 case COMPLEX_TYPE:
1785 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1786 return NULL_TREE;
1787 switch (TREE_CODE (TREE_TYPE (basetype)))
1788 {
1789 case INTEGER_TYPE:
1790 case BOOLEAN_TYPE:
1791 return (desires & WANT_INT) ? expr : NULL_TREE;
1792 case ENUMERAL_TYPE:
1793 return (desires & WANT_ENUM) ? expr : NULL_TREE;
1794 case REAL_TYPE:
1795 return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1796 default:
1797 return NULL_TREE;
1798 }
1799
1800 default:
1801 return NULL_TREE;
1802 }
1803
1804 /* The code for conversions from class type is currently only used for
1805 delete expressions. Other expressions are handled by build_new_op. */
1806 if (!complete_type_or_maybe_complain (basetype, expr, complain))
1807 return error_mark_node;
1808 if (!TYPE_HAS_CONVERSION (basetype))
1809 return NULL_TREE;
1810
1811 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1812 {
1813 int win = 0;
1814 tree candidate;
1815 tree cand = TREE_VALUE (conv);
1816 cand = OVL_FIRST (cand);
1817
1818 if (winner && winner == cand)
1819 continue;
1820
1821 if (DECL_NONCONVERTING_P (cand))
1822 continue;
1823
1824 candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
1825
1826 switch (TREE_CODE (candidate))
1827 {
1828 case BOOLEAN_TYPE:
1829 case INTEGER_TYPE:
1830 win = (desires & WANT_INT); break;
1831 case ENUMERAL_TYPE:
1832 win = (desires & WANT_ENUM); break;
1833 case REAL_TYPE:
1834 win = (desires & WANT_FLOAT); break;
1835 case POINTER_TYPE:
1836 win = (desires & WANT_POINTER); break;
1837
1838 case COMPLEX_TYPE:
1839 case VECTOR_TYPE:
1840 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1841 break;
1842 switch (TREE_CODE (TREE_TYPE (candidate)))
1843 {
1844 case BOOLEAN_TYPE:
1845 case INTEGER_TYPE:
1846 win = (desires & WANT_INT); break;
1847 case ENUMERAL_TYPE:
1848 win = (desires & WANT_ENUM); break;
1849 case REAL_TYPE:
1850 win = (desires & WANT_FLOAT); break;
1851 default:
1852 break;
1853 }
1854 break;
1855
1856 default:
1857 /* A wildcard could be instantiated to match any desired
1858 type, but we can't deduce the template argument. */
1859 if (WILDCARD_TYPE_P (candidate))
1860 win = true;
1861 break;
1862 }
1863
1864 if (win)
1865 {
1866 if (TREE_CODE (cand) == TEMPLATE_DECL)
1867 {
1868 if (complain)
1869 error ("default type conversion cannot deduce template"
1870 " argument for %qD", cand);
1871 return error_mark_node;
1872 }
1873
1874 if (winner)
1875 {
1876 tree winner_type
1877 = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1878
1879 if (!same_type_ignoring_top_level_qualifiers_p (winner_type,
1880 candidate))
1881 {
1882 if (complain)
1883 {
1884 error ("ambiguous default type conversion from %qT",
1885 basetype);
1886 inform (input_location,
1887 " candidate conversions include %qD and %qD",
1888 winner, cand);
1889 }
1890 return error_mark_node;
1891 }
1892 }
1893
1894 winner = cand;
1895 }
1896 }
1897
1898 if (winner)
1899 {
1900 tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1901 return build_user_type_conversion (type, expr, LOOKUP_NORMAL,
1902 tf_warning_or_error);
1903 }
1904
1905 return NULL_TREE;
1906 }
1907
1908 /* Implements integral promotion (4.1) and float->double promotion. */
1909
1910 tree
type_promotes_to(tree type)1911 type_promotes_to (tree type)
1912 {
1913 tree promoted_type;
1914
1915 if (type == error_mark_node)
1916 return error_mark_node;
1917
1918 type = TYPE_MAIN_VARIANT (type);
1919
1920 /* Check for promotions of target-defined types first. */
1921 promoted_type = targetm.promoted_type (type);
1922 if (promoted_type)
1923 return promoted_type;
1924
1925 /* bool always promotes to int (not unsigned), even if it's the same
1926 size. */
1927 if (TREE_CODE (type) == BOOLEAN_TYPE)
1928 type = integer_type_node;
1929
1930 /* Normally convert enums to int, but convert wide enums to something
1931 wider. Scoped enums don't promote, but pretend they do for backward
1932 ABI bug compatibility wrt varargs. */
1933 else if (TREE_CODE (type) == ENUMERAL_TYPE
1934 || type == char8_type_node
1935 || type == char16_type_node
1936 || type == char32_type_node
1937 || type == wchar_type_node)
1938 {
1939 tree prom = type;
1940
1941 if (TREE_CODE (type) == ENUMERAL_TYPE)
1942 {
1943 prom = ENUM_UNDERLYING_TYPE (prom);
1944 if (!ENUM_IS_SCOPED (type)
1945 && ENUM_FIXED_UNDERLYING_TYPE_P (type))
1946 {
1947 /* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1948 whose underlying type is fixed (10.2) can be converted to a
1949 prvalue of its underlying type. Moreover, if integral promotion
1950 can be applied to its underlying type, a prvalue of an unscoped
1951 enumeration type whose underlying type is fixed can also be
1952 converted to a prvalue of the promoted underlying type. */
1953 return type_promotes_to (prom);
1954 }
1955 }
1956
1957 int precision = MAX (TYPE_PRECISION (type),
1958 TYPE_PRECISION (integer_type_node));
1959 tree totype = c_common_type_for_size (precision, 0);
1960 if (TYPE_UNSIGNED (prom)
1961 && ! int_fits_type_p (TYPE_MAX_VALUE (prom), totype))
1962 prom = c_common_type_for_size (precision, 1);
1963 else
1964 prom = totype;
1965 if (SCOPED_ENUM_P (type))
1966 {
1967 if (abi_version_crosses (6)
1968 && TYPE_MODE (prom) != TYPE_MODE (type))
1969 warning (OPT_Wabi, "scoped enum %qT passed through %<...%> as "
1970 "%qT before %<-fabi-version=6%>, %qT after",
1971 type, prom, ENUM_UNDERLYING_TYPE (type));
1972 if (!abi_version_at_least (6))
1973 type = prom;
1974 }
1975 else
1976 type = prom;
1977 }
1978 else if (c_promoting_integer_type_p (type))
1979 {
1980 /* Retain unsignedness if really not getting bigger. */
1981 if (TYPE_UNSIGNED (type)
1982 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1983 type = unsigned_type_node;
1984 else
1985 type = integer_type_node;
1986 }
1987 else if (type == float_type_node)
1988 type = double_type_node;
1989
1990 return type;
1991 }
1992
1993 /* The routines below this point are carefully written to conform to
1994 the standard. They use the same terminology, and follow the rules
1995 closely. Although they are used only in pt.c at the moment, they
1996 should presumably be used everywhere in the future. */
1997
1998 /* True iff EXPR can be converted to TYPE via a qualification conversion.
1999 Callers should check for identical types before calling this function. */
2000
2001 bool
can_convert_qual(tree type,tree expr)2002 can_convert_qual (tree type, tree expr)
2003 {
2004 tree expr_type = TREE_TYPE (expr);
2005 gcc_assert (!same_type_p (type, expr_type));
2006
2007 /* A function pointer conversion also counts as a Qualification Adjustment
2008 under [over.ics.scs]. */
2009 if (fnptr_conv_p (type, expr_type))
2010 return true;
2011
2012 if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type))
2013 return comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type));
2014 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (expr_type))
2015 return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
2016 TYPE_PTRMEM_CLASS_TYPE (expr_type))
2017 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
2018 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)));
2019 else
2020 return false;
2021 }
2022
2023 /* Attempt to perform qualification conversions on EXPR to convert it
2024 to TYPE. Return the resulting expression, or error_mark_node if
2025 the conversion was impossible. Since this is only used by
2026 convert_nontype_argument, we fold the conversion. */
2027
2028 tree
perform_qualification_conversions(tree type,tree expr)2029 perform_qualification_conversions (tree type, tree expr)
2030 {
2031 tree expr_type;
2032
2033 expr_type = TREE_TYPE (expr);
2034
2035 if (same_type_p (type, expr_type))
2036 return expr;
2037 else if (can_convert_qual (type, expr))
2038 return cp_fold_convert (type, expr);
2039 else
2040 return error_mark_node;
2041 }
2042
2043 /* True iff T is a transaction-safe function type. */
2044
2045 bool
tx_safe_fn_type_p(tree t)2046 tx_safe_fn_type_p (tree t)
2047 {
2048 if (!FUNC_OR_METHOD_TYPE_P (t))
2049 return false;
2050 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t));
2051 }
2052
2053 /* Return the transaction-unsafe variant of transaction-safe function type
2054 T. */
2055
2056 tree
tx_unsafe_fn_variant(tree t)2057 tx_unsafe_fn_variant (tree t)
2058 {
2059 gcc_assert (tx_safe_fn_type_p (t));
2060 tree attrs = remove_attribute ("transaction_safe",
2061 TYPE_ATTRIBUTES (t));
2062 return cp_build_type_attribute_variant (t, attrs);
2063 }
2064
2065 /* Return true iff FROM can convert to TO by a transaction-safety
2066 conversion. */
2067
2068 static bool
can_convert_tx_safety(tree to,tree from)2069 can_convert_tx_safety (tree to, tree from)
2070 {
2071 return (flag_tm && tx_safe_fn_type_p (from)
2072 && same_type_p (to, tx_unsafe_fn_variant (from)));
2073 }
2074
2075 /* Return true iff FROM can convert to TO by dropping noexcept. */
2076
2077 static bool
noexcept_conv_p(tree to,tree from)2078 noexcept_conv_p (tree to, tree from)
2079 {
2080 if (!flag_noexcept_type)
2081 return false;
2082
2083 tree t = non_reference (to);
2084 tree f = from;
2085 if (TYPE_PTRMEMFUNC_P (t)
2086 && TYPE_PTRMEMFUNC_P (f))
2087 {
2088 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
2089 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
2090 }
2091 if (TYPE_PTR_P (t)
2092 && TYPE_PTR_P (f))
2093 {
2094 t = TREE_TYPE (t);
2095 f = TREE_TYPE (f);
2096 }
2097 tree_code code = TREE_CODE (f);
2098 if (TREE_CODE (t) != code)
2099 return false;
2100 if (code != FUNCTION_TYPE && code != METHOD_TYPE)
2101 return false;
2102 if (!type_throw_all_p (t)
2103 || type_throw_all_p (f))
2104 return false;
2105 tree v = build_exception_variant (f, NULL_TREE);
2106 return same_type_p (t, v);
2107 }
2108
2109 /* Return true iff FROM can convert to TO by a function pointer conversion. */
2110
2111 bool
fnptr_conv_p(tree to,tree from)2112 fnptr_conv_p (tree to, tree from)
2113 {
2114 tree t = non_reference (to);
2115 tree f = from;
2116 if (TYPE_PTRMEMFUNC_P (t)
2117 && TYPE_PTRMEMFUNC_P (f))
2118 {
2119 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
2120 f = TYPE_PTRMEMFUNC_FN_TYPE (f);
2121 }
2122 if (TYPE_PTR_P (t)
2123 && TYPE_PTR_P (f))
2124 {
2125 t = TREE_TYPE (t);
2126 f = TREE_TYPE (f);
2127 }
2128
2129 return (noexcept_conv_p (t, f)
2130 || can_convert_tx_safety (t, f));
2131 }
2132
2133 /* Return FN with any NOP_EXPRs stripped that represent function pointer
2134 conversions or conversions to the same type. */
2135
2136 tree
strip_fnptr_conv(tree fn)2137 strip_fnptr_conv (tree fn)
2138 {
2139 while (TREE_CODE (fn) == NOP_EXPR)
2140 {
2141 tree op = TREE_OPERAND (fn, 0);
2142 tree ft = TREE_TYPE (fn);
2143 tree ot = TREE_TYPE (op);
2144 if (same_type_p (ft, ot)
2145 || fnptr_conv_p (ft, ot))
2146 fn = op;
2147 else
2148 break;
2149 }
2150 return fn;
2151 }
2152