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