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