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