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