1 /* Language-level data type conversion for GNU C++. 2 Copyright (C) 1987-2017 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 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 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 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) && ! 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) && ! obvalue_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 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 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 && 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 && ! 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) && obvalue_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 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 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 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 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 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 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 warning_sentinel c (warn_int_in_bool_context); 649 folded_result = cp_convert (type, folded, tf_none); 650 } 651 folded_result = fold_simple (folded_result); 652 if (!TREE_OVERFLOW_P (folded) 653 && folded_result != error_mark_node) 654 warnings_for_convert_and_check (EXPR_LOC_OR_LOC (expr, input_location), 655 type, folded, folded_result); 656 } 657 658 return result; 659 } 660 661 /* Conversion... 662 663 FLAGS indicates how we should behave. */ 664 665 tree 666 ocp_convert (tree type, tree expr, int convtype, int flags, 667 tsubst_flags_t complain) 668 { 669 tree e = expr; 670 enum tree_code code = TREE_CODE (type); 671 const char *invalid_conv_diag; 672 tree e1; 673 location_t loc = EXPR_LOC_OR_LOC (expr, input_location); 674 bool dofold = (convtype & CONV_FOLD); 675 676 if (error_operand_p (e) || type == error_mark_node) 677 return error_mark_node; 678 679 complete_type (type); 680 complete_type (TREE_TYPE (expr)); 681 682 if ((invalid_conv_diag 683 = targetm.invalid_conversion (TREE_TYPE (expr), type))) 684 { 685 if (complain & tf_error) 686 error (invalid_conv_diag); 687 return error_mark_node; 688 } 689 690 /* FIXME remove when moving to c_fully_fold model. */ 691 if (!CLASS_TYPE_P (type)) 692 e = scalar_constant_value (e); 693 if (error_operand_p (e)) 694 return error_mark_node; 695 696 if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP)) 697 /* We need a new temporary; don't take this shortcut. */; 698 else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e))) 699 { 700 if (same_type_p (type, TREE_TYPE (e))) 701 /* The call to fold will not always remove the NOP_EXPR as 702 might be expected, since if one of the types is a typedef; 703 the comparison in fold is just equality of pointers, not a 704 call to comptypes. We don't call fold in this case because 705 that can result in infinite recursion; fold will call 706 convert, which will call ocp_convert, etc. */ 707 return e; 708 /* For complex data types, we need to perform componentwise 709 conversion. */ 710 else if (TREE_CODE (type) == COMPLEX_TYPE) 711 return convert_to_complex_maybe_fold (type, e, dofold); 712 else if (VECTOR_TYPE_P (type)) 713 return convert_to_vector (type, e); 714 else if (TREE_CODE (e) == TARGET_EXPR) 715 { 716 /* Don't build a NOP_EXPR of class type. Instead, change the 717 type of the temporary. */ 718 TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type; 719 return e; 720 } 721 else 722 { 723 /* We shouldn't be treating objects of ADDRESSABLE type as 724 rvalues. */ 725 gcc_assert (!TREE_ADDRESSABLE (type)); 726 return build_nop (type, e); 727 } 728 } 729 730 e1 = targetm.convert_to_type (type, e); 731 if (e1) 732 return e1; 733 734 if (code == VOID_TYPE && (convtype & CONV_STATIC)) 735 { 736 e = convert_to_void (e, ICV_CAST, complain); 737 return e; 738 } 739 740 if (INTEGRAL_CODE_P (code)) 741 { 742 tree intype = TREE_TYPE (e); 743 tree converted; 744 745 if (TREE_CODE (type) == ENUMERAL_TYPE) 746 { 747 /* enum = enum, enum = int, enum = float, (enum)pointer are all 748 errors. */ 749 if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype) 750 || TREE_CODE (intype) == REAL_TYPE) 751 && ! (convtype & CONV_STATIC)) 752 || TYPE_PTR_P (intype)) 753 { 754 if (complain & tf_error) 755 permerror (loc, "conversion from %q#T to %q#T", intype, type); 756 else 757 return error_mark_node; 758 } 759 760 /* [expr.static.cast] 761 762 8. A value of integral or enumeration type can be explicitly 763 converted to an enumeration type. The value is unchanged if 764 the original value is within the range of the enumeration 765 values. Otherwise, the resulting enumeration value is 766 unspecified. */ 767 if ((complain & tf_warning) 768 && TREE_CODE (e) == INTEGER_CST 769 && ENUM_UNDERLYING_TYPE (type) 770 && !int_fits_type_p (e, ENUM_UNDERLYING_TYPE (type))) 771 warning_at (loc, OPT_Wconversion, 772 "the result of the conversion is unspecified because " 773 "%qE is outside the range of type %qT", 774 expr, type); 775 } 776 if (MAYBE_CLASS_TYPE_P (intype)) 777 { 778 tree rval; 779 rval = build_type_conversion (type, e); 780 if (rval) 781 return rval; 782 if (complain & tf_error) 783 error_at (loc, "%q#T used where a %qT was expected", intype, type); 784 return error_mark_node; 785 } 786 if (code == BOOLEAN_TYPE) 787 { 788 if (VOID_TYPE_P (intype)) 789 { 790 if (complain & tf_error) 791 error_at (loc, 792 "could not convert %qE from %<void%> to %<bool%>", 793 expr); 794 return error_mark_node; 795 } 796 797 /* We can't implicitly convert a scoped enum to bool, so convert 798 to the underlying type first. */ 799 if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC)) 800 e = build_nop (ENUM_UNDERLYING_TYPE (intype), e); 801 if (complain & tf_warning) 802 return cp_truthvalue_conversion (e); 803 else 804 { 805 /* Prevent bogus -Wint-in-bool-context warnings coming 806 from c_common_truthvalue_conversion down the line. */ 807 warning_sentinel w (warn_int_in_bool_context); 808 return cp_truthvalue_conversion (e); 809 } 810 } 811 812 converted = convert_to_integer_maybe_fold (type, e, dofold); 813 814 /* Ignore any integer overflow caused by the conversion. */ 815 return ignore_overflows (converted, e); 816 } 817 if (NULLPTR_TYPE_P (type) && e && null_ptr_cst_p (e)) 818 { 819 if (complain & tf_warning) 820 maybe_warn_zero_as_null_pointer_constant (e, loc); 821 return nullptr_node; 822 } 823 if (POINTER_TYPE_P (type) || TYPE_PTRMEM_P (type)) 824 return cp_convert_to_pointer (type, e, dofold, complain); 825 if (code == VECTOR_TYPE) 826 { 827 tree in_vtype = TREE_TYPE (e); 828 if (MAYBE_CLASS_TYPE_P (in_vtype)) 829 { 830 tree ret_val; 831 ret_val = build_type_conversion (type, e); 832 if (ret_val) 833 return ret_val; 834 if (complain & tf_error) 835 error_at (loc, "%q#T used where a %qT was expected", 836 in_vtype, type); 837 return error_mark_node; 838 } 839 return convert_to_vector (type, e); 840 } 841 if (code == REAL_TYPE || code == COMPLEX_TYPE) 842 { 843 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e))) 844 { 845 tree rval; 846 rval = build_type_conversion (type, e); 847 if (rval) 848 return rval; 849 else if (complain & tf_error) 850 error_at (loc, 851 "%q#T used where a floating point value was expected", 852 TREE_TYPE (e)); 853 } 854 if (code == REAL_TYPE) 855 return convert_to_real_maybe_fold (type, e, dofold); 856 else if (code == COMPLEX_TYPE) 857 return convert_to_complex_maybe_fold (type, e, dofold); 858 } 859 860 /* New C++ semantics: since assignment is now based on 861 memberwise copying, if the rhs type is derived from the 862 lhs type, then we may still do a conversion. */ 863 if (RECORD_OR_UNION_CODE_P (code)) 864 { 865 tree dtype = TREE_TYPE (e); 866 tree ctor = NULL_TREE; 867 868 dtype = TYPE_MAIN_VARIANT (dtype); 869 870 /* Conversion between aggregate types. New C++ semantics allow 871 objects of derived type to be cast to objects of base type. 872 Old semantics only allowed this between pointers. 873 874 There may be some ambiguity between using a constructor 875 vs. using a type conversion operator when both apply. */ 876 877 ctor = e; 878 879 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain)) 880 return error_mark_node; 881 882 if (BRACE_ENCLOSED_INITIALIZER_P (ctor)) 883 ctor = perform_implicit_conversion (type, ctor, complain); 884 else if ((flags & LOOKUP_ONLYCONVERTING) 885 && ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype))) 886 /* For copy-initialization, first we create a temp of the proper type 887 with a user-defined conversion sequence, then we direct-initialize 888 the target with the temp (see [dcl.init]). */ 889 ctor = build_user_type_conversion (type, ctor, flags, complain); 890 else 891 { 892 vec<tree, va_gc> *ctor_vec = make_tree_vector_single (ctor); 893 ctor = build_special_member_call (NULL_TREE, 894 complete_ctor_identifier, 895 &ctor_vec, 896 type, flags, complain); 897 release_tree_vector (ctor_vec); 898 } 899 if (ctor) 900 return build_cplus_new (type, ctor, complain); 901 } 902 903 if (complain & tf_error) 904 { 905 /* If the conversion failed and expr was an invalid use of pointer to 906 member function, try to report a meaningful error. */ 907 if (invalid_nonstatic_memfn_p (loc, expr, complain)) 908 /* We displayed the error message. */; 909 else 910 error_at (loc, "conversion from %qT to non-scalar type %qT requested", 911 TREE_TYPE (expr), type); 912 } 913 return error_mark_node; 914 } 915 916 /* If CALL is a call, return the callee; otherwise null. */ 917 918 tree 919 cp_get_callee (tree call) 920 { 921 if (call == NULL_TREE) 922 return call; 923 else if (TREE_CODE (call) == CALL_EXPR) 924 return CALL_EXPR_FN (call); 925 else if (TREE_CODE (call) == AGGR_INIT_EXPR) 926 return AGGR_INIT_EXPR_FN (call); 927 return NULL_TREE; 928 } 929 930 /* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL 931 if we can. */ 932 933 tree 934 cp_get_fndecl_from_callee (tree fn) 935 { 936 if (fn == NULL_TREE) 937 return fn; 938 if (TREE_CODE (fn) == FUNCTION_DECL) 939 return fn; 940 tree type = TREE_TYPE (fn); 941 if (type == unknown_type_node) 942 return NULL_TREE; 943 gcc_assert (POINTER_TYPE_P (type)); 944 fn = maybe_constant_init (fn); 945 STRIP_NOPS (fn); 946 if (TREE_CODE (fn) == ADDR_EXPR) 947 { 948 fn = TREE_OPERAND (fn, 0); 949 if (TREE_CODE (fn) == FUNCTION_DECL) 950 return fn; 951 } 952 return NULL_TREE; 953 } 954 955 /* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the 956 constexpr machinery. */ 957 958 tree 959 cp_get_callee_fndecl (tree call) 960 { 961 return cp_get_fndecl_from_callee (cp_get_callee (call)); 962 } 963 964 /* Subroutine of convert_to_void. Warn if we're discarding something with 965 attribute [[nodiscard]]. */ 966 967 static void 968 maybe_warn_nodiscard (tree expr, impl_conv_void implicit) 969 { 970 tree call = expr; 971 if (TREE_CODE (expr) == TARGET_EXPR) 972 call = TARGET_EXPR_INITIAL (expr); 973 location_t loc = EXPR_LOC_OR_LOC (call, input_location); 974 tree callee = cp_get_callee (call); 975 if (!callee) 976 return; 977 978 tree type = TREE_TYPE (callee); 979 if (TYPE_PTRMEMFUNC_P (type)) 980 type = TYPE_PTRMEMFUNC_FN_TYPE (type); 981 if (POINTER_TYPE_P (type)) 982 type = TREE_TYPE (type); 983 984 tree rettype = TREE_TYPE (type); 985 tree fn = cp_get_fndecl_from_callee (callee); 986 if (implicit != ICV_CAST && fn 987 && lookup_attribute ("nodiscard", DECL_ATTRIBUTES (fn))) 988 { 989 if (warning_at (loc, OPT_Wunused_result, 990 "ignoring return value of %qD, " 991 "declared with attribute nodiscard", fn)) 992 inform (DECL_SOURCE_LOCATION (fn), "declared here"); 993 } 994 else if (implicit != ICV_CAST 995 && lookup_attribute ("nodiscard", TYPE_ATTRIBUTES (rettype))) 996 { 997 if (warning_at (loc, OPT_Wunused_result, 998 "ignoring returned value of type %qT, " 999 "declared with attribute nodiscard", rettype)) 1000 { 1001 if (fn) 1002 inform (DECL_SOURCE_LOCATION (fn), 1003 "in call to %qD, declared here", fn); 1004 inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype)), 1005 "%qT declared here", rettype); 1006 } 1007 } 1008 else if (TREE_CODE (expr) == TARGET_EXPR 1009 && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (type))) 1010 { 1011 /* The TARGET_EXPR confuses do_warn_unused_result into thinking that the 1012 result is used, so handle that case here. */ 1013 if (fn) 1014 { 1015 if (warning_at (loc, OPT_Wunused_result, 1016 "ignoring return value of %qD, " 1017 "declared with attribute warn_unused_result", 1018 fn)) 1019 inform (DECL_SOURCE_LOCATION (fn), "declared here"); 1020 } 1021 else 1022 warning_at (loc, OPT_Wunused_result, 1023 "ignoring return value of function " 1024 "declared with attribute warn_unused_result"); 1025 } 1026 } 1027 1028 /* When an expression is used in a void context, its value is discarded and 1029 no lvalue-rvalue and similar conversions happen [expr.static.cast/4, 1030 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type 1031 in a void context. The C++ standard does not define what an `access' to an 1032 object is, but there is reason to believe that it is the lvalue to rvalue 1033 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it 1034 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8 1035 indicates that volatile semantics should be the same between C and C++ 1036 where ever possible. C leaves it implementation defined as to what 1037 constitutes an access to a volatile. So, we interpret `*vp' as a read of 1038 the volatile object `vp' points to, unless that is an incomplete type. For 1039 volatile references we do not do this interpretation, because that would 1040 make it impossible to ignore the reference return value from functions. We 1041 issue warnings in the confusing cases. 1042 1043 The IMPLICIT is ICV_CAST when the user is explicitly converting an expression 1044 to void via a cast. If an expression is being implicitly converted, IMPLICIT 1045 indicates the context of the implicit conversion. */ 1046 1047 tree 1048 convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) 1049 { 1050 location_t loc = EXPR_LOC_OR_LOC (expr, input_location); 1051 1052 if (expr == error_mark_node 1053 || TREE_TYPE (expr) == error_mark_node) 1054 return error_mark_node; 1055 1056 expr = maybe_undo_parenthesized_ref (expr); 1057 1058 if (implicit == ICV_CAST) 1059 mark_exp_read (expr); 1060 else 1061 { 1062 tree exprv = expr; 1063 1064 while (TREE_CODE (exprv) == COMPOUND_EXPR) 1065 exprv = TREE_OPERAND (exprv, 1); 1066 if (DECL_P (exprv) 1067 || handled_component_p (exprv) 1068 || INDIRECT_REF_P (exprv)) 1069 /* Expr is not being 'used' here, otherwise we whould have 1070 called mark_{rl}value_use use here, which would have in turn 1071 called mark_exp_read. Rather, we call mark_exp_read directly 1072 to avoid some warnings when 1073 -Wunused-but-set-{variable,parameter} is in effect. */ 1074 mark_exp_read (exprv); 1075 } 1076 1077 if (!TREE_TYPE (expr)) 1078 return expr; 1079 if (invalid_nonstatic_memfn_p (loc, expr, complain)) 1080 return error_mark_node; 1081 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) 1082 { 1083 if (complain & tf_error) 1084 error_at (loc, "pseudo-destructor is not called"); 1085 return error_mark_node; 1086 } 1087 if (VOID_TYPE_P (TREE_TYPE (expr))) 1088 return expr; 1089 switch (TREE_CODE (expr)) 1090 { 1091 case COND_EXPR: 1092 { 1093 /* The two parts of a cond expr might be separate lvalues. */ 1094 tree op1 = TREE_OPERAND (expr,1); 1095 tree op2 = TREE_OPERAND (expr,2); 1096 bool side_effects = ((op1 && TREE_SIDE_EFFECTS (op1)) 1097 || TREE_SIDE_EFFECTS (op2)); 1098 tree new_op1, new_op2; 1099 new_op1 = NULL_TREE; 1100 if (implicit != ICV_CAST && !side_effects) 1101 { 1102 if (op1) 1103 new_op1 = convert_to_void (op1, ICV_SECOND_OF_COND, complain); 1104 new_op2 = convert_to_void (op2, ICV_THIRD_OF_COND, complain); 1105 } 1106 else 1107 { 1108 if (op1) 1109 new_op1 = convert_to_void (op1, ICV_CAST, complain); 1110 new_op2 = convert_to_void (op2, ICV_CAST, complain); 1111 } 1112 1113 expr = build3 (COND_EXPR, TREE_TYPE (new_op2), 1114 TREE_OPERAND (expr, 0), new_op1, new_op2); 1115 break; 1116 } 1117 1118 case COMPOUND_EXPR: 1119 { 1120 /* The second part of a compound expr contains the value. */ 1121 tree op1 = TREE_OPERAND (expr,1); 1122 tree new_op1; 1123 if (implicit != ICV_CAST && !TREE_NO_WARNING (expr)) 1124 new_op1 = convert_to_void (op1, ICV_RIGHT_OF_COMMA, complain); 1125 else 1126 new_op1 = convert_to_void (op1, ICV_CAST, complain); 1127 1128 if (new_op1 != op1) 1129 { 1130 tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1), 1131 TREE_OPERAND (expr, 0), new_op1); 1132 expr = t; 1133 } 1134 1135 break; 1136 } 1137 1138 case NON_LVALUE_EXPR: 1139 case NOP_EXPR: 1140 /* These have already decayed to rvalue. */ 1141 break; 1142 1143 case CALL_EXPR: /* We have a special meaning for volatile void fn(). */ 1144 maybe_warn_nodiscard (expr, implicit); 1145 break; 1146 1147 case INDIRECT_REF: 1148 { 1149 tree type = TREE_TYPE (expr); 1150 int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) 1151 == REFERENCE_TYPE; 1152 int is_volatile = TYPE_VOLATILE (type); 1153 int is_complete = COMPLETE_TYPE_P (complete_type (type)); 1154 1155 /* Can't load the value if we don't know the type. */ 1156 if (is_volatile && !is_complete) 1157 { 1158 if (complain & tf_warning) 1159 switch (implicit) 1160 { 1161 case ICV_CAST: 1162 warning_at (loc, 0, "conversion to void will not access " 1163 "object of incomplete type %qT", type); 1164 break; 1165 case ICV_SECOND_OF_COND: 1166 warning_at (loc, 0, "indirection will not access object of " 1167 "incomplete type %qT in second operand " 1168 "of conditional expression", type); 1169 break; 1170 case ICV_THIRD_OF_COND: 1171 warning_at (loc, 0, "indirection will not access object of " 1172 "incomplete type %qT in third operand " 1173 "of conditional expression", type); 1174 break; 1175 case ICV_RIGHT_OF_COMMA: 1176 warning_at (loc, 0, "indirection will not access object of " 1177 "incomplete type %qT in right operand of " 1178 "comma operator", type); 1179 break; 1180 case ICV_LEFT_OF_COMMA: 1181 warning_at (loc, 0, "indirection will not access object of " 1182 "incomplete type %qT in left operand of " 1183 "comma operator", type); 1184 break; 1185 case ICV_STATEMENT: 1186 warning_at (loc, 0, "indirection will not access object of " 1187 "incomplete type %qT in statement", type); 1188 break; 1189 case ICV_THIRD_IN_FOR: 1190 warning_at (loc, 0, "indirection will not access object of " 1191 "incomplete type %qT in for increment " 1192 "expression", type); 1193 break; 1194 default: 1195 gcc_unreachable (); 1196 } 1197 } 1198 /* Don't load the value if this is an implicit dereference, or if 1199 the type needs to be handled by ctors/dtors. */ 1200 else if (is_volatile && is_reference) 1201 { 1202 if (complain & tf_warning) 1203 switch (implicit) 1204 { 1205 case ICV_CAST: 1206 warning_at (loc, 0, "conversion to void will not access " 1207 "object of type %qT", type); 1208 break; 1209 case ICV_SECOND_OF_COND: 1210 warning_at (loc, 0, "implicit dereference will not access " 1211 "object of type %qT in second operand of " 1212 "conditional expression", type); 1213 break; 1214 case ICV_THIRD_OF_COND: 1215 warning_at (loc, 0, "implicit dereference will not access " 1216 "object of type %qT in third operand of " 1217 "conditional expression", type); 1218 break; 1219 case ICV_RIGHT_OF_COMMA: 1220 warning_at (loc, 0, "implicit dereference will not access " 1221 "object of type %qT in right operand of " 1222 "comma operator", type); 1223 break; 1224 case ICV_LEFT_OF_COMMA: 1225 warning_at (loc, 0, "implicit dereference will not access " 1226 "object of type %qT in left operand of comma " 1227 "operator", type); 1228 break; 1229 case ICV_STATEMENT: 1230 warning_at (loc, 0, "implicit dereference will not access " 1231 "object of type %qT in statement", type); 1232 break; 1233 case ICV_THIRD_IN_FOR: 1234 warning_at (loc, 0, "implicit dereference will not access " 1235 "object of type %qT in for increment expression", 1236 type); 1237 break; 1238 default: 1239 gcc_unreachable (); 1240 } 1241 } 1242 else if (is_volatile && TREE_ADDRESSABLE (type)) 1243 { 1244 if (complain & tf_warning) 1245 switch (implicit) 1246 { 1247 case ICV_CAST: 1248 warning_at (loc, 0, "conversion to void will not access " 1249 "object of non-trivially-copyable type %qT", 1250 type); 1251 break; 1252 case ICV_SECOND_OF_COND: 1253 warning_at (loc, 0, "indirection will not access object of " 1254 "non-trivially-copyable type %qT in second " 1255 "operand of conditional expression", type); 1256 break; 1257 case ICV_THIRD_OF_COND: 1258 warning_at (loc, 0, "indirection will not access object of " 1259 "non-trivially-copyable type %qT in third " 1260 "operand of conditional expression", type); 1261 break; 1262 case ICV_RIGHT_OF_COMMA: 1263 warning_at (loc, 0, "indirection will not access object of " 1264 "non-trivially-copyable type %qT in right " 1265 "operand of comma operator", type); 1266 break; 1267 case ICV_LEFT_OF_COMMA: 1268 warning_at (loc, 0, "indirection will not access object of " 1269 "non-trivially-copyable type %qT in left " 1270 "operand of comma operator", type); 1271 break; 1272 case ICV_STATEMENT: 1273 warning_at (loc, 0, "indirection will not access object of " 1274 "non-trivially-copyable type %qT in statement", 1275 type); 1276 break; 1277 case ICV_THIRD_IN_FOR: 1278 warning_at (loc, 0, "indirection will not access object of " 1279 "non-trivially-copyable type %qT in for " 1280 "increment expression", type); 1281 break; 1282 default: 1283 gcc_unreachable (); 1284 } 1285 } 1286 if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type)) 1287 { 1288 /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF 1289 operation is stripped off. Note that we don't warn about 1290 - an expression with TREE_NO_WARNING set. (For an example of 1291 such expressions, see build_over_call in call.c.) 1292 - automatic dereferencing of references, since the user cannot 1293 control it. (See also warn_if_unused_value() in c-common.c.) */ 1294 if (warn_unused_value 1295 && implicit != ICV_CAST 1296 && (complain & tf_warning) 1297 && !TREE_NO_WARNING (expr) 1298 && !is_reference) 1299 warning_at (loc, OPT_Wunused_value, "value computed is not used"); 1300 expr = TREE_OPERAND (expr, 0); 1301 } 1302 1303 break; 1304 } 1305 1306 case VAR_DECL: 1307 { 1308 /* External variables might be incomplete. */ 1309 tree type = TREE_TYPE (expr); 1310 int is_complete = COMPLETE_TYPE_P (complete_type (type)); 1311 1312 if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning)) 1313 switch (implicit) 1314 { 1315 case ICV_CAST: 1316 warning_at (loc, 0, "conversion to void will not access " 1317 "object %qE of incomplete type %qT", expr, type); 1318 break; 1319 case ICV_SECOND_OF_COND: 1320 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1321 "not be accessed in second operand of " 1322 "conditional expression", expr, type); 1323 break; 1324 case ICV_THIRD_OF_COND: 1325 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1326 "not be accessed in third operand of " 1327 "conditional expression", expr, type); 1328 break; 1329 case ICV_RIGHT_OF_COMMA: 1330 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1331 "not be accessed in right operand of comma operator", 1332 expr, type); 1333 break; 1334 case ICV_LEFT_OF_COMMA: 1335 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1336 "not be accessed in left operand of comma operator", 1337 expr, type); 1338 break; 1339 case ICV_STATEMENT: 1340 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1341 "not be accessed in statement", expr, type); 1342 break; 1343 case ICV_THIRD_IN_FOR: 1344 warning_at (loc, 0, "variable %qE of incomplete type %qT will " 1345 "not be accessed in for increment expression", 1346 expr, type); 1347 break; 1348 default: 1349 gcc_unreachable (); 1350 } 1351 1352 break; 1353 } 1354 1355 case TARGET_EXPR: 1356 /* Don't bother with the temporary object returned from a function if 1357 we don't use it, don't need to destroy it, and won't abort in 1358 assign_temp. We'll still 1359 allocate space for it in expand_call or declare_return_variable, 1360 but we don't need to track it through all the tree phases. */ 1361 if (TARGET_EXPR_IMPLICIT_P (expr) 1362 && !TREE_ADDRESSABLE (TREE_TYPE (expr))) 1363 { 1364 tree init = TARGET_EXPR_INITIAL (expr); 1365 if (TREE_CODE (init) == AGGR_INIT_EXPR 1366 && !AGGR_INIT_VIA_CTOR_P (init)) 1367 { 1368 tree fn = AGGR_INIT_EXPR_FN (init); 1369 expr = build_call_array_loc (input_location, 1370 TREE_TYPE (TREE_TYPE 1371 (TREE_TYPE (fn))), 1372 fn, 1373 aggr_init_expr_nargs (init), 1374 AGGR_INIT_EXPR_ARGP (init)); 1375 } 1376 } 1377 maybe_warn_nodiscard (expr, implicit); 1378 break; 1379 1380 default:; 1381 } 1382 expr = resolve_nondeduced_context (expr, complain); 1383 { 1384 tree probe = expr; 1385 1386 if (TREE_CODE (probe) == ADDR_EXPR) 1387 probe = TREE_OPERAND (expr, 0); 1388 if (type_unknown_p (probe)) 1389 { 1390 /* [over.over] enumerates the places where we can take the address 1391 of an overloaded function, and this is not one of them. */ 1392 if (complain & tf_error) 1393 switch (implicit) 1394 { 1395 case ICV_CAST: 1396 error_at (loc, "conversion to void " 1397 "cannot resolve address of overloaded function"); 1398 break; 1399 case ICV_SECOND_OF_COND: 1400 error_at (loc, "second operand of conditional expression " 1401 "cannot resolve address of overloaded function"); 1402 break; 1403 case ICV_THIRD_OF_COND: 1404 error_at (loc, "third operand of conditional expression " 1405 "cannot resolve address of overloaded function"); 1406 break; 1407 case ICV_RIGHT_OF_COMMA: 1408 error_at (loc, "right operand of comma operator " 1409 "cannot resolve address of overloaded function"); 1410 break; 1411 case ICV_LEFT_OF_COMMA: 1412 error_at (loc, "left operand of comma operator " 1413 "cannot resolve address of overloaded function"); 1414 break; 1415 case ICV_STATEMENT: 1416 error_at (loc, "statement " 1417 "cannot resolve address of overloaded function"); 1418 break; 1419 case ICV_THIRD_IN_FOR: 1420 error_at (loc, "for increment expression " 1421 "cannot resolve address of overloaded function"); 1422 break; 1423 } 1424 else 1425 return error_mark_node; 1426 expr = void_node; 1427 } 1428 else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe)) 1429 { 1430 /* Only warn when there is no &. */ 1431 if (complain & tf_warning) 1432 switch (implicit) 1433 { 1434 case ICV_SECOND_OF_COND: 1435 warning_at (loc, OPT_Waddress, 1436 "second operand of conditional expression " 1437 "is a reference, not call, to function %qE", expr); 1438 break; 1439 case ICV_THIRD_OF_COND: 1440 warning_at (loc, OPT_Waddress, 1441 "third operand of conditional expression " 1442 "is a reference, not call, to function %qE", expr); 1443 break; 1444 case ICV_RIGHT_OF_COMMA: 1445 warning_at (loc, OPT_Waddress, 1446 "right operand of comma operator " 1447 "is a reference, not call, to function %qE", expr); 1448 break; 1449 case ICV_LEFT_OF_COMMA: 1450 warning_at (loc, OPT_Waddress, 1451 "left operand of comma operator " 1452 "is a reference, not call, to function %qE", expr); 1453 break; 1454 case ICV_STATEMENT: 1455 warning_at (loc, OPT_Waddress, 1456 "statement is a reference, not call, to function %qE", 1457 expr); 1458 break; 1459 case ICV_THIRD_IN_FOR: 1460 warning_at (loc, OPT_Waddress, 1461 "for increment expression " 1462 "is a reference, not call, to function %qE", expr); 1463 break; 1464 default: 1465 gcc_unreachable (); 1466 } 1467 1468 if (TREE_CODE (expr) == COMPONENT_REF) 1469 expr = TREE_OPERAND (expr, 0); 1470 } 1471 } 1472 1473 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) 1474 { 1475 if (implicit != ICV_CAST 1476 && warn_unused_value 1477 && !TREE_NO_WARNING (expr) 1478 && !processing_template_decl) 1479 { 1480 /* The middle end does not warn about expressions that have 1481 been explicitly cast to void, so we must do so here. */ 1482 if (!TREE_SIDE_EFFECTS (expr)) { 1483 if (complain & tf_warning) 1484 switch (implicit) 1485 { 1486 case ICV_SECOND_OF_COND: 1487 warning_at (loc, OPT_Wunused_value, 1488 "second operand of conditional expression " 1489 "has no effect"); 1490 break; 1491 case ICV_THIRD_OF_COND: 1492 warning_at (loc, OPT_Wunused_value, 1493 "third operand of conditional expression " 1494 "has no effect"); 1495 break; 1496 case ICV_RIGHT_OF_COMMA: 1497 warning_at (loc, OPT_Wunused_value, 1498 "right operand of comma operator has no effect"); 1499 break; 1500 case ICV_LEFT_OF_COMMA: 1501 warning_at (loc, OPT_Wunused_value, 1502 "left operand of comma operator has no effect"); 1503 break; 1504 case ICV_STATEMENT: 1505 warning_at (loc, OPT_Wunused_value, 1506 "statement has no effect"); 1507 break; 1508 case ICV_THIRD_IN_FOR: 1509 warning_at (loc, OPT_Wunused_value, 1510 "for increment expression has no effect"); 1511 break; 1512 default: 1513 gcc_unreachable (); 1514 } 1515 } 1516 else 1517 { 1518 tree e; 1519 enum tree_code code; 1520 enum tree_code_class tclass; 1521 1522 e = expr; 1523 /* We might like to warn about (say) "(int) f()", as the 1524 cast has no effect, but the compiler itself will 1525 generate implicit conversions under some 1526 circumstances. (For example a block copy will be 1527 turned into a call to "__builtin_memcpy", with a 1528 conversion of the return value to an appropriate 1529 type.) So, to avoid false positives, we strip 1530 conversions. Do not use STRIP_NOPs because it will 1531 not strip conversions to "void", as that is not a 1532 mode-preserving conversion. */ 1533 while (TREE_CODE (e) == NOP_EXPR) 1534 e = TREE_OPERAND (e, 0); 1535 1536 code = TREE_CODE (e); 1537 tclass = TREE_CODE_CLASS (code); 1538 if ((tclass == tcc_comparison 1539 || tclass == tcc_unary 1540 || (tclass == tcc_binary 1541 && !(code == MODIFY_EXPR 1542 || code == INIT_EXPR 1543 || code == PREDECREMENT_EXPR 1544 || code == PREINCREMENT_EXPR 1545 || code == POSTDECREMENT_EXPR 1546 || code == POSTINCREMENT_EXPR)) 1547 || code == VEC_PERM_EXPR 1548 || code == VEC_COND_EXPR) 1549 && (complain & tf_warning)) 1550 warning_at (loc, OPT_Wunused_value, "value computed is not used"); 1551 } 1552 } 1553 expr = build1 (CONVERT_EXPR, void_type_node, expr); 1554 } 1555 if (! TREE_SIDE_EFFECTS (expr)) 1556 expr = void_node; 1557 return expr; 1558 } 1559 1560 /* Create an expression whose value is that of EXPR, 1561 converted to type TYPE. The TREE_TYPE of the value 1562 is always TYPE. This function implements all reasonable 1563 conversions; callers should filter out those that are 1564 not permitted by the language being compiled. 1565 1566 Most of this routine is from build_reinterpret_cast. 1567 1568 The back end cannot call cp_convert (what was convert) because 1569 conversions to/from basetypes may involve memory references 1570 (vbases) and adding or subtracting small values (multiple 1571 inheritance), but it calls convert from the constant folding code 1572 on subtrees of already built trees after it has ripped them apart. 1573 1574 Also, if we ever support range variables, we'll probably also have to 1575 do a little bit more work. */ 1576 1577 tree 1578 convert (tree type, tree expr) 1579 { 1580 tree intype; 1581 1582 if (type == error_mark_node || expr == error_mark_node) 1583 return error_mark_node; 1584 1585 intype = TREE_TYPE (expr); 1586 1587 if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype)) 1588 return build_nop (type, expr); 1589 1590 return ocp_convert (type, expr, CONV_BACKEND_CONVERT, 1591 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION, 1592 tf_warning_or_error); 1593 } 1594 1595 /* Like cp_convert, except permit conversions to take place which 1596 are not normally allowed due to access restrictions 1597 (such as conversion from sub-type to private super-type). */ 1598 1599 tree 1600 convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain) 1601 { 1602 tree e = expr; 1603 enum tree_code code = TREE_CODE (type); 1604 1605 if (code == REFERENCE_TYPE) 1606 return convert_to_reference (type, e, CONV_C_CAST, 0, 1607 NULL_TREE, complain); 1608 1609 if (code == POINTER_TYPE) 1610 return convert_to_pointer_force (type, e, complain); 1611 1612 /* From typeck.c convert_for_assignment */ 1613 if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR 1614 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) 1615 || integer_zerop (e) 1616 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e))) 1617 && TYPE_PTRMEMFUNC_P (type)) 1618 /* compatible pointer to member functions. */ 1619 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1, 1620 /*c_cast_p=*/1, complain); 1621 1622 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL, complain); 1623 } 1624 1625 /* Convert an aggregate EXPR to type XTYPE. If a conversion 1626 exists, return the attempted conversion. This may 1627 return ERROR_MARK_NODE if the conversion is not 1628 allowed (references private members, etc). 1629 If no conversion exists, NULL_TREE is returned. 1630 1631 FIXME: Ambiguity checking is wrong. Should choose one by the implicit 1632 object parameter, or by the second standard conversion sequence if 1633 that doesn't do it. This will probably wait for an overloading rewrite. 1634 (jason 8/9/95) */ 1635 1636 static tree 1637 build_type_conversion (tree xtype, tree expr) 1638 { 1639 /* C++: check to see if we can convert this aggregate type 1640 into the required type. */ 1641 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL, 1642 tf_warning_or_error); 1643 } 1644 1645 /* Convert the given EXPR to one of a group of types suitable for use in an 1646 expression. DESIRES is a combination of various WANT_* flags (q.v.) 1647 which indicates which types are suitable. If COMPLAIN is true, complain 1648 about ambiguity; otherwise, the caller will deal with it. */ 1649 1650 tree 1651 build_expr_type_conversion (int desires, tree expr, bool complain) 1652 { 1653 tree basetype = TREE_TYPE (expr); 1654 tree conv = NULL_TREE; 1655 tree winner = NULL_TREE; 1656 1657 if (expr == null_node 1658 && (desires & WANT_INT) 1659 && !(desires & WANT_NULL)) 1660 { 1661 source_location loc = 1662 expansion_point_location_if_in_system_header (input_location); 1663 1664 warning_at (loc, OPT_Wconversion_null, 1665 "converting NULL to non-pointer type"); 1666 } 1667 1668 if (basetype == error_mark_node) 1669 return error_mark_node; 1670 1671 if (! MAYBE_CLASS_TYPE_P (basetype)) 1672 switch (TREE_CODE (basetype)) 1673 { 1674 case INTEGER_TYPE: 1675 if ((desires & WANT_NULL) && null_ptr_cst_p (expr)) 1676 return expr; 1677 /* fall through. */ 1678 1679 case BOOLEAN_TYPE: 1680 return (desires & WANT_INT) ? expr : NULL_TREE; 1681 case ENUMERAL_TYPE: 1682 return (desires & WANT_ENUM) ? expr : NULL_TREE; 1683 case REAL_TYPE: 1684 return (desires & WANT_FLOAT) ? expr : NULL_TREE; 1685 case POINTER_TYPE: 1686 return (desires & WANT_POINTER) ? expr : NULL_TREE; 1687 1688 case FUNCTION_TYPE: 1689 case ARRAY_TYPE: 1690 return (desires & WANT_POINTER) ? decay_conversion (expr, 1691 tf_warning_or_error) 1692 : NULL_TREE; 1693 1694 case COMPLEX_TYPE: 1695 case VECTOR_TYPE: 1696 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0) 1697 return NULL_TREE; 1698 switch (TREE_CODE (TREE_TYPE (basetype))) 1699 { 1700 case INTEGER_TYPE: 1701 case BOOLEAN_TYPE: 1702 return (desires & WANT_INT) ? expr : NULL_TREE; 1703 case ENUMERAL_TYPE: 1704 return (desires & WANT_ENUM) ? expr : NULL_TREE; 1705 case REAL_TYPE: 1706 return (desires & WANT_FLOAT) ? expr : NULL_TREE; 1707 default: 1708 return NULL_TREE; 1709 } 1710 1711 default: 1712 return NULL_TREE; 1713 } 1714 1715 /* The code for conversions from class type is currently only used for 1716 delete expressions. Other expressions are handled by build_new_op. */ 1717 if (!complete_type_or_maybe_complain (basetype, expr, complain)) 1718 return error_mark_node; 1719 if (!TYPE_HAS_CONVERSION (basetype)) 1720 return NULL_TREE; 1721 1722 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv)) 1723 { 1724 int win = 0; 1725 tree candidate; 1726 tree cand = TREE_VALUE (conv); 1727 cand = OVL_CURRENT (cand); 1728 1729 if (winner && winner == cand) 1730 continue; 1731 1732 if (DECL_NONCONVERTING_P (cand)) 1733 continue; 1734 1735 candidate = non_reference (TREE_TYPE (TREE_TYPE (cand))); 1736 1737 switch (TREE_CODE (candidate)) 1738 { 1739 case BOOLEAN_TYPE: 1740 case INTEGER_TYPE: 1741 win = (desires & WANT_INT); break; 1742 case ENUMERAL_TYPE: 1743 win = (desires & WANT_ENUM); break; 1744 case REAL_TYPE: 1745 win = (desires & WANT_FLOAT); break; 1746 case POINTER_TYPE: 1747 win = (desires & WANT_POINTER); break; 1748 1749 case COMPLEX_TYPE: 1750 case VECTOR_TYPE: 1751 if ((desires & WANT_VECTOR_OR_COMPLEX) == 0) 1752 break; 1753 switch (TREE_CODE (TREE_TYPE (candidate))) 1754 { 1755 case BOOLEAN_TYPE: 1756 case INTEGER_TYPE: 1757 win = (desires & WANT_INT); break; 1758 case ENUMERAL_TYPE: 1759 win = (desires & WANT_ENUM); break; 1760 case REAL_TYPE: 1761 win = (desires & WANT_FLOAT); break; 1762 default: 1763 break; 1764 } 1765 break; 1766 1767 default: 1768 /* A wildcard could be instantiated to match any desired 1769 type, but we can't deduce the template argument. */ 1770 if (WILDCARD_TYPE_P (candidate)) 1771 win = true; 1772 break; 1773 } 1774 1775 if (win) 1776 { 1777 if (TREE_CODE (cand) == TEMPLATE_DECL) 1778 { 1779 if (complain) 1780 error ("default type conversion can't deduce template" 1781 " argument for %qD", cand); 1782 return error_mark_node; 1783 } 1784 1785 if (winner) 1786 { 1787 tree winner_type 1788 = non_reference (TREE_TYPE (TREE_TYPE (winner))); 1789 1790 if (!same_type_ignoring_top_level_qualifiers_p (winner_type, 1791 candidate)) 1792 { 1793 if (complain) 1794 { 1795 error ("ambiguous default type conversion from %qT", 1796 basetype); 1797 inform (input_location, 1798 " candidate conversions include %qD and %qD", 1799 winner, cand); 1800 } 1801 return error_mark_node; 1802 } 1803 } 1804 1805 winner = cand; 1806 } 1807 } 1808 1809 if (winner) 1810 { 1811 tree type = non_reference (TREE_TYPE (TREE_TYPE (winner))); 1812 return build_user_type_conversion (type, expr, LOOKUP_NORMAL, 1813 tf_warning_or_error); 1814 } 1815 1816 return NULL_TREE; 1817 } 1818 1819 /* Implements integral promotion (4.1) and float->double promotion. */ 1820 1821 tree 1822 type_promotes_to (tree type) 1823 { 1824 tree promoted_type; 1825 1826 if (type == error_mark_node) 1827 return error_mark_node; 1828 1829 type = TYPE_MAIN_VARIANT (type); 1830 1831 /* Check for promotions of target-defined types first. */ 1832 promoted_type = targetm.promoted_type (type); 1833 if (promoted_type) 1834 return promoted_type; 1835 1836 /* bool always promotes to int (not unsigned), even if it's the same 1837 size. */ 1838 if (TREE_CODE (type) == BOOLEAN_TYPE) 1839 type = integer_type_node; 1840 1841 /* Normally convert enums to int, but convert wide enums to something 1842 wider. Scoped enums don't promote, but pretend they do for backward 1843 ABI bug compatibility wrt varargs. */ 1844 else if (TREE_CODE (type) == ENUMERAL_TYPE 1845 || type == char16_type_node 1846 || type == char32_type_node 1847 || type == wchar_type_node) 1848 { 1849 int precision = MAX (TYPE_PRECISION (type), 1850 TYPE_PRECISION (integer_type_node)); 1851 tree totype = c_common_type_for_size (precision, 0); 1852 tree prom = type; 1853 if (TREE_CODE (prom) == ENUMERAL_TYPE) 1854 prom = ENUM_UNDERLYING_TYPE (prom); 1855 if (TYPE_UNSIGNED (prom) 1856 && ! int_fits_type_p (TYPE_MAX_VALUE (prom), totype)) 1857 prom = c_common_type_for_size (precision, 1); 1858 else 1859 prom = totype; 1860 if (SCOPED_ENUM_P (type)) 1861 { 1862 if (abi_version_crosses (6) 1863 && TYPE_MODE (prom) != TYPE_MODE (type)) 1864 warning (OPT_Wabi, "scoped enum %qT passed through ... as " 1865 "%qT before -fabi-version=6, %qT after", 1866 type, prom, ENUM_UNDERLYING_TYPE (type)); 1867 if (!abi_version_at_least (6)) 1868 type = prom; 1869 } 1870 else 1871 type = prom; 1872 } 1873 else if (c_promoting_integer_type_p (type)) 1874 { 1875 /* Retain unsignedness if really not getting bigger. */ 1876 if (TYPE_UNSIGNED (type) 1877 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 1878 type = unsigned_type_node; 1879 else 1880 type = integer_type_node; 1881 } 1882 else if (type == float_type_node) 1883 type = double_type_node; 1884 1885 return type; 1886 } 1887 1888 /* The routines below this point are carefully written to conform to 1889 the standard. They use the same terminology, and follow the rules 1890 closely. Although they are used only in pt.c at the moment, they 1891 should presumably be used everywhere in the future. */ 1892 1893 /* Attempt to perform qualification conversions on EXPR to convert it 1894 to TYPE. Return the resulting expression, or error_mark_node if 1895 the conversion was impossible. */ 1896 1897 tree 1898 perform_qualification_conversions (tree type, tree expr) 1899 { 1900 tree expr_type; 1901 1902 expr_type = TREE_TYPE (expr); 1903 1904 if (same_type_p (type, expr_type)) 1905 return expr; 1906 else if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type) 1907 && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type))) 1908 return build_nop (type, expr); 1909 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (expr_type) 1910 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type), 1911 TYPE_PTRMEM_CLASS_TYPE (expr_type)) 1912 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type), 1913 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type))) 1914 return build_nop (type, expr); 1915 else 1916 return error_mark_node; 1917 } 1918 1919 /* True iff T is a transaction-safe function type. */ 1920 1921 bool 1922 tx_safe_fn_type_p (tree t) 1923 { 1924 if (TREE_CODE (t) != FUNCTION_TYPE 1925 && TREE_CODE (t) != METHOD_TYPE) 1926 return false; 1927 return !!lookup_attribute ("transaction_safe", TYPE_ATTRIBUTES (t)); 1928 } 1929 1930 /* Return the transaction-unsafe variant of transaction-safe function type 1931 T. */ 1932 1933 tree 1934 tx_unsafe_fn_variant (tree t) 1935 { 1936 gcc_assert (tx_safe_fn_type_p (t)); 1937 tree attrs = remove_attribute ("transaction_safe", 1938 TYPE_ATTRIBUTES (t)); 1939 return cp_build_type_attribute_variant (t, attrs); 1940 } 1941 1942 /* Return true iff FROM can convert to TO by a transaction-safety 1943 conversion. */ 1944 1945 static bool 1946 can_convert_tx_safety (tree to, tree from) 1947 { 1948 return (flag_tm && tx_safe_fn_type_p (from) 1949 && same_type_p (to, tx_unsafe_fn_variant (from))); 1950 } 1951 1952 /* Return true iff FROM can convert to TO by dropping noexcept. */ 1953 1954 static bool 1955 noexcept_conv_p (tree to, tree from) 1956 { 1957 if (!flag_noexcept_type) 1958 return false; 1959 1960 tree t = non_reference (to); 1961 tree f = from; 1962 if (TYPE_PTRMEMFUNC_P (t) 1963 && TYPE_PTRMEMFUNC_P (f)) 1964 { 1965 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 1966 f = TYPE_PTRMEMFUNC_FN_TYPE (f); 1967 } 1968 if (TREE_CODE (t) == POINTER_TYPE 1969 && TREE_CODE (f) == POINTER_TYPE) 1970 { 1971 t = TREE_TYPE (t); 1972 f = TREE_TYPE (f); 1973 } 1974 tree_code code = TREE_CODE (f); 1975 if (TREE_CODE (t) != code) 1976 return false; 1977 if (code != FUNCTION_TYPE && code != METHOD_TYPE) 1978 return false; 1979 if (!type_throw_all_p (t) 1980 || type_throw_all_p (f)) 1981 return false; 1982 tree v = build_exception_variant (f, NULL_TREE); 1983 return same_type_p (t, v); 1984 } 1985 1986 /* Return true iff FROM can convert to TO by a function pointer conversion. */ 1987 1988 bool 1989 fnptr_conv_p (tree to, tree from) 1990 { 1991 tree t = non_reference (to); 1992 tree f = from; 1993 if (TYPE_PTRMEMFUNC_P (t) 1994 && TYPE_PTRMEMFUNC_P (f)) 1995 { 1996 t = TYPE_PTRMEMFUNC_FN_TYPE (t); 1997 f = TYPE_PTRMEMFUNC_FN_TYPE (f); 1998 } 1999 if (TREE_CODE (t) == POINTER_TYPE 2000 && TREE_CODE (f) == POINTER_TYPE) 2001 { 2002 t = TREE_TYPE (t); 2003 f = TREE_TYPE (f); 2004 } 2005 2006 return (noexcept_conv_p (t, f) 2007 || can_convert_tx_safety (t, f)); 2008 } 2009 2010 /* Return FN with any NOP_EXPRs that represent function pointer 2011 conversions stripped. */ 2012 2013 tree 2014 strip_fnptr_conv (tree fn) 2015 { 2016 while (TREE_CODE (fn) == NOP_EXPR) 2017 { 2018 tree op = TREE_OPERAND (fn, 0); 2019 if (fnptr_conv_p (TREE_TYPE (fn), TREE_TYPE (op))) 2020 fn = op; 2021 else 2022 break; 2023 } 2024 return fn; 2025 } 2026