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