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