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