1/* Language-level data type conversion for GNU C++. 2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Hacked by Michael Tiemann (tiemann@cygnus.com) 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GCC is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to 20the Free Software Foundation, 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, USA. */ 22 23 24/* This file contains the functions for converting C++ expressions 25 to different data types. The only entry point is `convert'. 26 Every language front end must have a `convert' function 27 but what kind of conversions it does will depend on the language. */ 28 29#include "config.h" 30#include "system.h" 31#include "coretypes.h" 32#include "tm.h" 33#include "tree.h" 34#include "flags.h" 35#include "cp-tree.h" 36#include "convert.h" 37#include "toplev.h" 38#include "decl.h" 39#include "target.h" 40 41static tree cp_convert_to_pointer (tree, tree, bool); 42static tree convert_to_pointer_force (tree, tree); 43static tree build_type_conversion (tree, tree); 44static tree build_up_reference (tree, tree, int, tree); 45static void warn_ref_binding (tree, tree, tree); 46 47/* Change of width--truncation and extension of integers or reals-- 48 is represented with NOP_EXPR. Proper functioning of many things 49 assumes that no other conversions can be NOP_EXPRs. 50 51 Conversion between integer and pointer is represented with CONVERT_EXPR. 52 Converting integer to real uses FLOAT_EXPR 53 and real to integer uses FIX_TRUNC_EXPR. 54 55 Here is a list of all the functions that assume that widening and 56 narrowing is always done with a NOP_EXPR: 57 In convert.c, convert_to_integer. 58 In c-typeck.c, build_binary_op_nodefault (boolean ops), 59 and c_common_truthvalue_conversion. 60 In expr.c: expand_expr, for operands of a MULT_EXPR. 61 In fold-const.c: fold. 62 In tree.c: get_narrower and get_unwidened. 63 64 C++: in multiple-inheritance, converting between pointers may involve 65 adjusting them by a delta stored within the class definition. */ 66 67/* Subroutines of `convert'. */ 68 69/* if converting pointer to pointer 70 if dealing with classes, check for derived->base or vice versa 71 else if dealing with method pointers, delegate 72 else convert blindly 73 else if converting class, pass off to build_type_conversion 74 else try C-style pointer conversion. If FORCE is true then allow 75 conversions via virtual bases (these are permitted by reinterpret_cast, 76 but not static_cast). */ 77 78static tree 79cp_convert_to_pointer (tree type, tree expr, bool force) 80{ 81 tree intype = TREE_TYPE (expr); 82 enum tree_code form; 83 tree rval; 84 if (intype == error_mark_node) 85 return error_mark_node; 86 87 if (IS_AGGR_TYPE (intype)) 88 { 89 intype = complete_type (intype); 90 if (!COMPLETE_TYPE_P (intype)) 91 { 92 error ("can't convert from incomplete type %qT to %qT", 93 intype, type); 94 return error_mark_node; 95 } 96 97 rval = build_type_conversion (type, expr); 98 if (rval) 99 { 100 if (rval == error_mark_node) 101 error ("conversion of %qE from %qT to %qT is ambiguous", 102 expr, intype, type); 103 return rval; 104 } 105 } 106 107 /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */ 108 if (TREE_CODE (type) == POINTER_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); 115 if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) 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 && TREE_CODE (type) == POINTER_TYPE 131 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 132 && IS_AGGR_TYPE (TREE_TYPE (type)) 133 && IS_AGGR_TYPE (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, NULL); 151 if (!same_p && !binfo) 152 { 153 /* Try base to derived conversion. */ 154 binfo = lookup_base (type_class, intype_class, ba_check, NULL); 155 code = MINUS_EXPR; 156 } 157 if (binfo == error_mark_node) 158 return error_mark_node; 159 if (binfo || same_p) 160 { 161 if (binfo) 162 expr = build_base_path (code, expr, binfo, 0); 163 /* Add any qualifier conversions. */ 164 return build_nop (type, expr); 165 } 166 } 167 168 if (TYPE_PTRMEMFUNC_P (type)) 169 { 170 error ("cannot convert %qE from type %qT to type %qT", 171 expr, intype, type); 172 return error_mark_node; 173 } 174 175 return build_nop (type, expr); 176 } 177 else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) 178 { 179 tree b1; 180 tree b2; 181 tree binfo; 182 enum tree_code code = PLUS_EXPR; 183 base_kind bk; 184 185 b1 = TYPE_PTRMEM_CLASS_TYPE (type); 186 b2 = TYPE_PTRMEM_CLASS_TYPE (intype); 187 binfo = lookup_base (b1, b2, ba_check, &bk); 188 if (!binfo) 189 { 190 binfo = lookup_base (b2, b1, ba_check, &bk); 191 code = MINUS_EXPR; 192 } 193 if (binfo == error_mark_node) 194 return error_mark_node; 195 196 if (bk == bk_via_virtual) 197 { 198 if (force) 199 warning (0, "pointer to member cast from %qT to %qT is via" 200 " virtual base", intype, type); 201 else 202 { 203 error ("pointer to member cast from %qT to %qT is" 204 " via virtual base", intype, type); 205 return error_mark_node; 206 } 207 /* This is a reinterpret cast, whose result is unspecified. 208 We choose to do nothing. */ 209 return build1 (NOP_EXPR, type, expr); 210 } 211 212 if (TREE_CODE (expr) == PTRMEM_CST) 213 expr = cplus_expand_constant (expr); 214 215 if (binfo && !integer_zerop (BINFO_OFFSET (binfo))) 216 expr = size_binop (code, 217 build_nop (sizetype, expr), 218 BINFO_OFFSET (binfo)); 219 return build_nop (type, expr); 220 } 221 else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)) 222 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0, 223 /*c_cast_p=*/false); 224 else if (TYPE_PTRMEMFUNC_P (intype)) 225 { 226 if (!warn_pmf2ptr) 227 { 228 if (TREE_CODE (expr) == PTRMEM_CST) 229 return cp_convert_to_pointer (type, 230 PTRMEM_CST_MEMBER (expr), 231 force); 232 else if (TREE_CODE (expr) == OFFSET_REF) 233 { 234 tree object = TREE_OPERAND (expr, 0); 235 return get_member_function_from_ptrfunc (&object, 236 TREE_OPERAND (expr, 1)); 237 } 238 } 239 error ("cannot convert %qE from type %qT to type %qT", 240 expr, intype, type); 241 return error_mark_node; 242 } 243 244 if (integer_zerop (expr)) 245 { 246 if (TYPE_PTRMEMFUNC_P (type)) 247 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0, 248 /*c_cast_p=*/false); 249 250 if (TYPE_PTRMEM_P (type)) 251 { 252 /* A NULL pointer-to-member is represented by -1, not by 253 zero. */ 254 expr = build_int_cst (type, -1); 255 /* Fix up the representation of -1 if appropriate. */ 256 expr = force_fit_type (expr, 0, false, false); 257 } 258 else 259 expr = build_int_cst (type, 0); 260 261 return expr; 262 } 263 else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form)) 264 { 265 error ("invalid conversion from %qT to %qT", intype, type); 266 return error_mark_node; 267 } 268 269 if (INTEGRAL_CODE_P (form)) 270 { 271 if (TYPE_PRECISION (intype) == POINTER_SIZE) 272 return build1 (CONVERT_EXPR, type, expr); 273 expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); 274 /* Modes may be different but sizes should be the same. There 275 is supposed to be some integral type that is the same width 276 as a pointer. */ 277 gcc_assert (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) 278 == GET_MODE_SIZE (TYPE_MODE (type))); 279 280 return convert_to_pointer (type, expr); 281 } 282 283 if (type_unknown_p (expr)) 284 return instantiate_type (type, expr, tf_warning_or_error); 285 286 error ("cannot convert %qE from type %qT to type %qT", 287 expr, intype, type); 288 return error_mark_node; 289} 290 291/* Like convert, except permit conversions to take place which 292 are not normally allowed due to access restrictions 293 (such as conversion from sub-type to private super-type). */ 294 295static tree 296convert_to_pointer_force (tree type, tree expr) 297{ 298 tree intype = TREE_TYPE (expr); 299 enum tree_code form = TREE_CODE (intype); 300 301 if (form == POINTER_TYPE) 302 { 303 intype = TYPE_MAIN_VARIANT (intype); 304 305 if (TYPE_MAIN_VARIANT (type) != intype 306 && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 307 && IS_AGGR_TYPE (TREE_TYPE (type)) 308 && IS_AGGR_TYPE (TREE_TYPE (intype)) 309 && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 310 { 311 enum tree_code code = PLUS_EXPR; 312 tree binfo; 313 314 binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type), 315 ba_unique, NULL); 316 if (!binfo) 317 { 318 binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), 319 ba_unique, NULL); 320 code = MINUS_EXPR; 321 } 322 if (binfo == error_mark_node) 323 return error_mark_node; 324 if (binfo) 325 { 326 expr = build_base_path (code, expr, binfo, 0); 327 if (expr == error_mark_node) 328 return error_mark_node; 329 /* Add any qualifier conversions. */ 330 if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)), 331 TREE_TYPE (type))) 332 expr = build_nop (type, expr); 333 return expr; 334 } 335 } 336 } 337 338 return cp_convert_to_pointer (type, expr, true); 339} 340 341/* We are passing something to a function which requires a reference. 342 The type we are interested in is in TYPE. The initial 343 value we have to begin with is in ARG. 344 345 FLAGS controls how we manage access checking. 346 DIRECT_BIND in FLAGS controls how any temporaries are generated. 347 If DIRECT_BIND is set, DECL is the reference we're binding to. */ 348 349static tree 350build_up_reference (tree type, tree arg, int flags, tree decl) 351{ 352 tree rval; 353 tree argtype = TREE_TYPE (arg); 354 tree target_type = TREE_TYPE (type); 355 356 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE); 357 358 if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg)) 359 { 360 /* Create a new temporary variable. We can't just use a TARGET_EXPR 361 here because it needs to live as long as DECL. */ 362 tree targ = arg; 363 364 arg = make_temporary_var_for_ref_to_temp (decl, TREE_TYPE (arg)); 365 366 /* Process the initializer for the declaration. */ 367 DECL_INITIAL (arg) = targ; 368 cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE, 369 LOOKUP_ONLYCONVERTING|DIRECT_BIND); 370 } 371 else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg)) 372 return get_target_expr (arg); 373 374 /* If we had a way to wrap this up, and say, if we ever needed its 375 address, transform all occurrences of the register, into a memory 376 reference we could win better. */ 377 rval = build_unary_op (ADDR_EXPR, arg, 1); 378 if (rval == error_mark_node) 379 return error_mark_node; 380 381 if ((flags & LOOKUP_PROTECT) 382 && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type) 383 && IS_AGGR_TYPE (argtype) 384 && IS_AGGR_TYPE (target_type)) 385 { 386 /* We go through lookup_base for the access control. */ 387 tree binfo = lookup_base (argtype, target_type, ba_check, NULL); 388 if (binfo == error_mark_node) 389 return error_mark_node; 390 if (binfo == NULL_TREE) 391 return error_not_base_type (target_type, argtype); 392 rval = build_base_path (PLUS_EXPR, rval, binfo, 1); 393 } 394 else 395 rval 396 = convert_to_pointer_force (build_pointer_type (target_type), rval); 397 return build_nop (type, rval); 398} 399 400/* Subroutine of convert_to_reference. REFTYPE is the target reference type. 401 INTYPE is the original rvalue type and DECL is an optional _DECL node 402 for diagnostics. 403 404 [dcl.init.ref] says that if an rvalue is used to 405 initialize a reference, then the reference must be to a 406 non-volatile const type. */ 407 408static void 409warn_ref_binding (tree reftype, tree intype, tree decl) 410{ 411 tree ttl = TREE_TYPE (reftype); 412 413 if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl)) 414 { 415 const char *msg; 416 417 if (CP_TYPE_VOLATILE_P (ttl) && decl) 418 msg = "initialization of volatile reference type %q#T from" 419 " rvalue of type %qT"; 420 else if (CP_TYPE_VOLATILE_P (ttl)) 421 msg = "conversion to volatile reference type %q#T " 422 " from rvalue of type %qT"; 423 else if (decl) 424 msg = "initialization of non-const reference type %q#T from" 425 " rvalue of type %qT"; 426 else 427 msg = "conversion to non-const reference type %q#T from" 428 " rvalue of type %qT"; 429 430 pedwarn (msg, reftype, intype); 431 } 432} 433 434/* For C++: Only need to do one-level references, but cannot 435 get tripped up on signed/unsigned differences. 436 437 DECL is either NULL_TREE or the _DECL node for a reference that is being 438 initialized. It can be error_mark_node if we don't know the _DECL but 439 we know it's an initialization. */ 440 441tree 442convert_to_reference (tree reftype, tree expr, int convtype, 443 int flags, tree decl) 444{ 445 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype)); 446 tree intype; 447 tree rval = NULL_TREE; 448 tree rval_as_conversion = NULL_TREE; 449 bool can_convert_intype_to_type; 450 451 if (TREE_CODE (type) == FUNCTION_TYPE 452 && TREE_TYPE (expr) == unknown_type_node) 453 expr = instantiate_type (type, expr, 454 (flags & LOOKUP_COMPLAIN) 455 ? tf_warning_or_error : tf_none); 456 457 if (expr == error_mark_node) 458 return error_mark_node; 459 460 intype = TREE_TYPE (expr); 461 462 gcc_assert (TREE_CODE (intype) != REFERENCE_TYPE); 463 gcc_assert (TREE_CODE (reftype) == REFERENCE_TYPE); 464 465 intype = TYPE_MAIN_VARIANT (intype); 466 467 can_convert_intype_to_type = can_convert (type, intype); 468 if (!can_convert_intype_to_type 469 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype) 470 && ! (flags & LOOKUP_NO_CONVERSION)) 471 { 472 /* Look for a user-defined conversion to lvalue that we can use. */ 473 474 rval_as_conversion 475 = build_type_conversion (reftype, expr); 476 477 if (rval_as_conversion && rval_as_conversion != error_mark_node 478 && real_lvalue_p (rval_as_conversion)) 479 { 480 expr = rval_as_conversion; 481 rval_as_conversion = NULL_TREE; 482 intype = type; 483 can_convert_intype_to_type = 1; 484 } 485 } 486 487 if (((convtype & CONV_STATIC) && can_convert (intype, type)) 488 || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type)) 489 { 490 if (flags & LOOKUP_COMPLAIN) 491 { 492 tree ttl = TREE_TYPE (reftype); 493 tree ttr = lvalue_type (expr); 494 495 if (! real_lvalue_p (expr)) 496 warn_ref_binding (reftype, intype, decl); 497 498 if (! (convtype & CONV_CONST) 499 && !at_least_as_qualified_p (ttl, ttr)) 500 pedwarn ("conversion from %qT to %qT discards qualifiers", 501 ttr, reftype); 502 } 503 504 return build_up_reference (reftype, expr, flags, decl); 505 } 506 else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr)) 507 { 508 /* When casting an lvalue to a reference type, just convert into 509 a pointer to the new type and deference it. This is allowed 510 by San Diego WP section 5.2.9 paragraph 12, though perhaps it 511 should be done directly (jason). (int &)ri ---> *(int*)&ri */ 512 513 /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they 514 meant. */ 515 if (TREE_CODE (intype) == POINTER_TYPE 516 && (comptypes (TREE_TYPE (intype), type, 517 COMPARE_BASE | COMPARE_DERIVED))) 518 warning (0, "casting %qT to %qT does not dereference pointer", 519 intype, reftype); 520 521 rval = build_unary_op (ADDR_EXPR, expr, 0); 522 if (rval != error_mark_node) 523 rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), 524 rval, 0); 525 if (rval != error_mark_node) 526 rval = build1 (NOP_EXPR, reftype, rval); 527 } 528 else 529 { 530 rval = convert_for_initialization (NULL_TREE, type, expr, flags, 531 "converting", 0, 0); 532 if (rval == NULL_TREE || rval == error_mark_node) 533 return rval; 534 warn_ref_binding (reftype, intype, decl); 535 rval = build_up_reference (reftype, rval, flags, decl); 536 } 537 538 if (rval) 539 { 540 /* If we found a way to convert earlier, then use it. */ 541 return rval; 542 } 543 544 if (flags & LOOKUP_COMPLAIN) 545 error ("cannot convert type %qT to type %qT", intype, reftype); 546 547 return error_mark_node; 548} 549 550/* We are using a reference VAL for its value. Bash that reference all the 551 way down to its lowest form. */ 552 553tree 554convert_from_reference (tree val) 555{ 556 if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE) 557 { 558 tree t = canonical_type_variant (TREE_TYPE (TREE_TYPE (val))); 559 tree ref = build1 (INDIRECT_REF, t, val); 560 561 /* We *must* set TREE_READONLY when dereferencing a pointer to const, 562 so that we get the proper error message if the result is used 563 to assign to. Also, &* is supposed to be a no-op. */ 564 TREE_READONLY (ref) = CP_TYPE_CONST_P (t); 565 TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t); 566 TREE_SIDE_EFFECTS (ref) 567 = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val)); 568 REFERENCE_REF_P (ref) = 1; 569 val = ref; 570 } 571 572 return val; 573} 574 575/* Really perform an lvalue-to-rvalue conversion, including copying an 576 argument of class type into a temporary. */ 577 578tree 579force_rvalue (tree expr) 580{ 581 if (IS_AGGR_TYPE (TREE_TYPE (expr)) && TREE_CODE (expr) != TARGET_EXPR) 582 expr = ocp_convert (TREE_TYPE (expr), expr, 583 CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL); 584 else 585 expr = decay_conversion (expr); 586 587 return expr; 588} 589 590/* C++ conversions, preference to static cast conversions. */ 591 592tree 593cp_convert (tree type, tree expr) 594{ 595 return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL); 596} 597 598/* Conversion... 599 600 FLAGS indicates how we should behave. */ 601 602tree 603ocp_convert (tree type, tree expr, int convtype, int flags) 604{ 605 tree e = expr; 606 enum tree_code code = TREE_CODE (type); 607 const char *invalid_conv_diag; 608 609 if (error_operand_p (e) || type == error_mark_node) 610 return error_mark_node; 611 612 complete_type (type); 613 complete_type (TREE_TYPE (expr)); 614 615 if ((invalid_conv_diag 616 = targetm.invalid_conversion (TREE_TYPE (expr), type))) 617 { 618 error (invalid_conv_diag); 619 return error_mark_node; 620 } 621 622 e = integral_constant_value (e); 623 624 if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP) 625 /* Some internal structures (vtable_entry_type, sigtbl_ptr_type) 626 don't go through finish_struct, so they don't have the synthesized 627 constructors. So don't force a temporary. */ 628 && TYPE_HAS_CONSTRUCTOR (type)) 629 /* We need a new temporary; don't take this shortcut. */; 630 else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e))) 631 { 632 if (same_type_p (type, TREE_TYPE (e))) 633 /* The call to fold will not always remove the NOP_EXPR as 634 might be expected, since if one of the types is a typedef; 635 the comparison in fold is just equality of pointers, not a 636 call to comptypes. We don't call fold in this case because 637 that can result in infinite recursion; fold will call 638 convert, which will call ocp_convert, etc. */ 639 return e; 640 /* For complex data types, we need to perform componentwise 641 conversion. */ 642 else if (TREE_CODE (type) == COMPLEX_TYPE) 643 return fold_if_not_in_template (convert_to_complex (type, e)); 644 else if (TREE_CODE (e) == TARGET_EXPR) 645 { 646 /* Don't build a NOP_EXPR of class type. Instead, change the 647 type of the temporary. Only allow this for cv-qual changes, 648 though. */ 649 gcc_assert (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (e)), 650 TYPE_MAIN_VARIANT (type))); 651 TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type; 652 return e; 653 } 654 else 655 { 656 /* We shouldn't be treating objects of ADDRESSABLE type as 657 rvalues. */ 658 gcc_assert (!TREE_ADDRESSABLE (type)); 659 return fold_if_not_in_template (build_nop (type, e)); 660 } 661 } 662 663 if (code == VOID_TYPE && (convtype & CONV_STATIC)) 664 { 665 e = convert_to_void (e, /*implicit=*/NULL); 666 return e; 667 } 668 669 if (INTEGRAL_CODE_P (code)) 670 { 671 tree intype = TREE_TYPE (e); 672 /* enum = enum, enum = int, enum = float, (enum)pointer are all 673 errors. */ 674 if (TREE_CODE (type) == ENUMERAL_TYPE 675 && (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype) 676 || TREE_CODE (intype) == REAL_TYPE) 677 && ! (convtype & CONV_STATIC)) 678 || TREE_CODE (intype) == POINTER_TYPE)) 679 { 680 if (flags & LOOKUP_COMPLAIN) 681 pedwarn ("conversion from %q#T to %q#T", intype, type); 682 683 if (flag_pedantic_errors) 684 return error_mark_node; 685 } 686 if (IS_AGGR_TYPE (intype)) 687 { 688 tree rval; 689 rval = build_type_conversion (type, e); 690 if (rval) 691 return rval; 692 if (flags & LOOKUP_COMPLAIN) 693 error ("%q#T used where a %qT was expected", intype, type); 694 return error_mark_node; 695 } 696 if (code == BOOLEAN_TYPE) 697 return cp_truthvalue_conversion (e); 698 699 return fold_if_not_in_template (convert_to_integer (type, e)); 700 } 701 if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type)) 702 return fold_if_not_in_template (cp_convert_to_pointer (type, e, false)); 703 if (code == VECTOR_TYPE) 704 { 705 tree in_vtype = TREE_TYPE (e); 706 if (IS_AGGR_TYPE (in_vtype)) 707 { 708 tree ret_val; 709 ret_val = build_type_conversion (type, e); 710 if (ret_val) 711 return ret_val; 712 if (flags & LOOKUP_COMPLAIN) 713 error ("%q#T used where a %qT was expected", in_vtype, type); 714 return error_mark_node; 715 } 716 return fold_if_not_in_template (convert_to_vector (type, e)); 717 } 718 if (code == REAL_TYPE || code == COMPLEX_TYPE) 719 { 720 if (IS_AGGR_TYPE (TREE_TYPE (e))) 721 { 722 tree rval; 723 rval = build_type_conversion (type, e); 724 if (rval) 725 return rval; 726 else 727 if (flags & LOOKUP_COMPLAIN) 728 error ("%q#T used where a floating point value was expected", 729 TREE_TYPE (e)); 730 } 731 if (code == REAL_TYPE) 732 return fold_if_not_in_template (convert_to_real (type, e)); 733 else if (code == COMPLEX_TYPE) 734 return fold_if_not_in_template (convert_to_complex (type, e)); 735 } 736 737 /* New C++ semantics: since assignment is now based on 738 memberwise copying, if the rhs type is derived from the 739 lhs type, then we may still do a conversion. */ 740 if (IS_AGGR_TYPE_CODE (code)) 741 { 742 tree dtype = TREE_TYPE (e); 743 tree ctor = NULL_TREE; 744 745 dtype = TYPE_MAIN_VARIANT (dtype); 746 747 /* Conversion between aggregate types. New C++ semantics allow 748 objects of derived type to be cast to objects of base type. 749 Old semantics only allowed this between pointers. 750 751 There may be some ambiguity between using a constructor 752 vs. using a type conversion operator when both apply. */ 753 754 ctor = e; 755 756 if (abstract_virtuals_error (NULL_TREE, type)) 757 return error_mark_node; 758 759 if ((flags & LOOKUP_ONLYCONVERTING) 760 && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype))) 761 /* For copy-initialization, first we create a temp of the proper type 762 with a user-defined conversion sequence, then we direct-initialize 763 the target with the temp (see [dcl.init]). */ 764 ctor = build_user_type_conversion (type, ctor, flags); 765 else 766 ctor = build_special_member_call (NULL_TREE, 767 complete_ctor_identifier, 768 build_tree_list (NULL_TREE, ctor), 769 type, flags); 770 if (ctor) 771 return build_cplus_new (type, ctor); 772 } 773 774 if (flags & LOOKUP_COMPLAIN) 775 error ("conversion from %qT to non-scalar type %qT requested", 776 TREE_TYPE (expr), type); 777 return error_mark_node; 778} 779 780/* When an expression is used in a void context, its value is discarded and 781 no lvalue-rvalue and similar conversions happen [expr.static.cast/4, 782 stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type 783 in a void context. The C++ standard does not define what an `access' to an 784 object is, but there is reason to believe that it is the lvalue to rvalue 785 conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it 786 accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8 787 indicates that volatile semantics should be the same between C and C++ 788 where ever possible. C leaves it implementation defined as to what 789 constitutes an access to a volatile. So, we interpret `*vp' as a read of 790 the volatile object `vp' points to, unless that is an incomplete type. For 791 volatile references we do not do this interpretation, because that would 792 make it impossible to ignore the reference return value from functions. We 793 issue warnings in the confusing cases. 794 795 IMPLICIT is tells us the context of an implicit void conversion. */ 796 797tree 798convert_to_void (tree expr, const char *implicit) 799{ 800 if (expr == error_mark_node 801 || TREE_TYPE (expr) == error_mark_node) 802 return error_mark_node; 803 if (!TREE_TYPE (expr)) 804 return expr; 805 if (invalid_nonstatic_memfn_p (expr)) 806 return error_mark_node; 807 if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) 808 { 809 error ("pseudo-destructor is not called"); 810 return error_mark_node; 811 } 812 if (VOID_TYPE_P (TREE_TYPE (expr))) 813 return expr; 814 switch (TREE_CODE (expr)) 815 { 816 case COND_EXPR: 817 { 818 /* The two parts of a cond expr might be separate lvalues. */ 819 tree op1 = TREE_OPERAND (expr,1); 820 tree op2 = TREE_OPERAND (expr,2); 821 tree new_op1 = convert_to_void 822 (op1, (implicit && !TREE_SIDE_EFFECTS (op2) 823 ? "second operand of conditional" : NULL)); 824 tree new_op2 = convert_to_void 825 (op2, (implicit && !TREE_SIDE_EFFECTS (op1) 826 ? "third operand of conditional" : NULL)); 827 828 expr = build3 (COND_EXPR, TREE_TYPE (new_op1), 829 TREE_OPERAND (expr, 0), new_op1, new_op2); 830 break; 831 } 832 833 case COMPOUND_EXPR: 834 { 835 /* The second part of a compound expr contains the value. */ 836 tree op1 = TREE_OPERAND (expr,1); 837 tree new_op1 = convert_to_void 838 (op1, (implicit && !TREE_NO_WARNING (expr) 839 ? "right-hand operand of comma" : NULL)); 840 841 if (new_op1 != op1) 842 { 843 tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1), 844 TREE_OPERAND (expr, 0), new_op1); 845 expr = t; 846 } 847 848 break; 849 } 850 851 case NON_LVALUE_EXPR: 852 case NOP_EXPR: 853 /* These have already decayed to rvalue. */ 854 break; 855 856 case CALL_EXPR: /* We have a special meaning for volatile void fn(). */ 857 break; 858 859 case INDIRECT_REF: 860 { 861 tree type = TREE_TYPE (expr); 862 int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) 863 == REFERENCE_TYPE; 864 int is_volatile = TYPE_VOLATILE (type); 865 int is_complete = COMPLETE_TYPE_P (complete_type (type)); 866 867 /* Can't load the value if we don't know the type. */ 868 if (is_volatile && !is_complete) 869 warning (0, "object of incomplete type %qT will not be accessed in %s", 870 type, implicit ? implicit : "void context"); 871 /* Don't load the value if this is an implicit dereference, or if 872 the type needs to be handled by ctors/dtors. */ 873 else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type))) 874 warning (0, "object of type %qT will not be accessed in %s", 875 TREE_TYPE (TREE_OPERAND (expr, 0)), 876 implicit ? implicit : "void context"); 877 if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type)) 878 expr = TREE_OPERAND (expr, 0); 879 880 break; 881 } 882 883 case VAR_DECL: 884 { 885 /* External variables might be incomplete. */ 886 tree type = TREE_TYPE (expr); 887 int is_complete = COMPLETE_TYPE_P (complete_type (type)); 888 889 if (TYPE_VOLATILE (type) && !is_complete) 890 warning (0, "object %qE of incomplete type %qT will not be accessed in %s", 891 expr, type, implicit ? implicit : "void context"); 892 break; 893 } 894 895 case TARGET_EXPR: 896 /* Don't bother with the temporary object returned from a function if 897 we don't use it and don't need to destroy it. We'll still 898 allocate space for it in expand_call or declare_return_variable, 899 but we don't need to track it through all the tree phases. */ 900 if (TARGET_EXPR_IMPLICIT_P (expr) 901 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr))) 902 { 903 tree init = TARGET_EXPR_INITIAL (expr); 904 if (TREE_CODE (init) == AGGR_INIT_EXPR 905 && !AGGR_INIT_VIA_CTOR_P (init)) 906 { 907 tree fn = TREE_OPERAND (init, 0); 908 expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))), 909 fn, TREE_OPERAND (init, 1), NULL_TREE); 910 } 911 } 912 break; 913 914 default:; 915 } 916 { 917 tree probe = expr; 918 919 if (TREE_CODE (probe) == ADDR_EXPR) 920 probe = TREE_OPERAND (expr, 0); 921 if (type_unknown_p (probe)) 922 { 923 /* [over.over] enumerates the places where we can take the address 924 of an overloaded function, and this is not one of them. */ 925 pedwarn ("%s cannot resolve address of overloaded function", 926 implicit ? implicit : "void cast"); 927 expr = void_zero_node; 928 } 929 else if (implicit && probe == expr && is_overloaded_fn (probe)) 930 { 931 /* Only warn when there is no &. */ 932 warning (OPT_Waddress, "%s is a reference, not call, to function %qE", 933 implicit, expr); 934 if (TREE_CODE (expr) == COMPONENT_REF) 935 expr = TREE_OPERAND (expr, 0); 936 } 937 } 938 939 if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) 940 { 941 if (implicit 942 && warn_unused_value 943 && !TREE_NO_WARNING (expr) 944 && !processing_template_decl) 945 { 946 /* The middle end does not warn about expressions that have 947 been explicitly cast to void, so we must do so here. */ 948 if (!TREE_SIDE_EFFECTS (expr)) 949 warning (OPT_Wunused_value, "%s has no effect", implicit); 950 else 951 { 952 tree e; 953 enum tree_code code; 954 enum tree_code_class class; 955 956 e = expr; 957 /* We might like to warn about (say) "(int) f()", as the 958 cast has no effect, but the compiler itself will 959 generate implicit conversions under some 960 circumstances. (For example a block copy will be 961 turned into a call to "__builtin_memcpy", with a 962 conversion of the return value to an appropriate 963 type.) So, to avoid false positives, we strip 964 conversions. Do not use STRIP_NOPs because it will 965 not strip conversions to "void", as that is not a 966 mode-preserving conversion. */ 967 while (TREE_CODE (e) == NOP_EXPR) 968 e = TREE_OPERAND (e, 0); 969 970 code = TREE_CODE (e); 971 class = TREE_CODE_CLASS (code); 972 if (class == tcc_comparison 973 || class == tcc_unary 974 || (class == tcc_binary 975 && !(code == MODIFY_EXPR 976 || code == INIT_EXPR 977 || code == PREDECREMENT_EXPR 978 || code == PREINCREMENT_EXPR 979 || code == POSTDECREMENT_EXPR 980 || code == POSTINCREMENT_EXPR))) 981 warning (OPT_Wunused_value, "value computed is not used"); 982 } 983 } 984 expr = build1 (CONVERT_EXPR, void_type_node, expr); 985 } 986 if (! TREE_SIDE_EFFECTS (expr)) 987 expr = void_zero_node; 988 return expr; 989} 990 991/* Create an expression whose value is that of EXPR, 992 converted to type TYPE. The TREE_TYPE of the value 993 is always TYPE. This function implements all reasonable 994 conversions; callers should filter out those that are 995 not permitted by the language being compiled. 996 997 Most of this routine is from build_reinterpret_cast. 998 999 The backend cannot call cp_convert (what was convert) because 1000 conversions to/from basetypes may involve memory references 1001 (vbases) and adding or subtracting small values (multiple 1002 inheritance), but it calls convert from the constant folding code 1003 on subtrees of already built trees after it has ripped them apart. 1004 1005 Also, if we ever support range variables, we'll probably also have to 1006 do a little bit more work. */ 1007 1008tree 1009convert (tree type, tree expr) 1010{ 1011 tree intype; 1012 1013 if (type == error_mark_node || expr == error_mark_node) 1014 return error_mark_node; 1015 1016 intype = TREE_TYPE (expr); 1017 1018 if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype)) 1019 return fold_if_not_in_template (build_nop (type, expr)); 1020 1021 return ocp_convert (type, expr, CONV_OLD_CONVERT, 1022 LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); 1023} 1024 1025/* Like cp_convert, except permit conversions to take place which 1026 are not normally allowed due to access restrictions 1027 (such as conversion from sub-type to private super-type). */ 1028 1029tree 1030convert_force (tree type, tree expr, int convtype) 1031{ 1032 tree e = expr; 1033 enum tree_code code = TREE_CODE (type); 1034 1035 if (code == REFERENCE_TYPE) 1036 return (fold_if_not_in_template 1037 (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN, 1038 NULL_TREE))); 1039 1040 if (code == POINTER_TYPE) 1041 return fold_if_not_in_template (convert_to_pointer_force (type, e)); 1042 1043 /* From typeck.c convert_for_assignment */ 1044 if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR 1045 && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE 1046 && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) 1047 || integer_zerop (e) 1048 || TYPE_PTRMEMFUNC_P (TREE_TYPE (e))) 1049 && TYPE_PTRMEMFUNC_P (type)) 1050 /* compatible pointer to member functions. */ 1051 return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1, 1052 /*c_cast_p=*/1); 1053 1054 return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL); 1055} 1056 1057/* Convert an aggregate EXPR to type XTYPE. If a conversion 1058 exists, return the attempted conversion. This may 1059 return ERROR_MARK_NODE if the conversion is not 1060 allowed (references private members, etc). 1061 If no conversion exists, NULL_TREE is returned. 1062 1063 FIXME: Ambiguity checking is wrong. Should choose one by the implicit 1064 object parameter, or by the second standard conversion sequence if 1065 that doesn't do it. This will probably wait for an overloading rewrite. 1066 (jason 8/9/95) */ 1067 1068static tree 1069build_type_conversion (tree xtype, tree expr) 1070{ 1071 /* C++: check to see if we can convert this aggregate type 1072 into the required type. */ 1073 return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL); 1074} 1075 1076/* Convert the given EXPR to one of a group of types suitable for use in an 1077 expression. DESIRES is a combination of various WANT_* flags (q.v.) 1078 which indicates which types are suitable. If COMPLAIN is true, complain 1079 about ambiguity; otherwise, the caller will deal with it. */ 1080 1081tree 1082build_expr_type_conversion (int desires, tree expr, bool complain) 1083{ 1084 tree basetype = TREE_TYPE (expr); 1085 tree conv = NULL_TREE; 1086 tree winner = NULL_TREE; 1087 1088 if (expr == null_node 1089 && (desires & WANT_INT) 1090 && !(desires & WANT_NULL)) 1091 warning (OPT_Wconversion, "converting NULL to non-pointer type"); 1092 1093 basetype = TREE_TYPE (expr); 1094 1095 if (basetype == error_mark_node) 1096 return error_mark_node; 1097 1098 if (! IS_AGGR_TYPE (basetype)) 1099 switch (TREE_CODE (basetype)) 1100 { 1101 case INTEGER_TYPE: 1102 if ((desires & WANT_NULL) && null_ptr_cst_p (expr)) 1103 return expr; 1104 /* else fall through... */ 1105 1106 case BOOLEAN_TYPE: 1107 return (desires & WANT_INT) ? expr : NULL_TREE; 1108 case ENUMERAL_TYPE: 1109 return (desires & WANT_ENUM) ? expr : NULL_TREE; 1110 case REAL_TYPE: 1111 return (desires & WANT_FLOAT) ? expr : NULL_TREE; 1112 case POINTER_TYPE: 1113 return (desires & WANT_POINTER) ? expr : NULL_TREE; 1114 1115 case FUNCTION_TYPE: 1116 case ARRAY_TYPE: 1117 return (desires & WANT_POINTER) ? decay_conversion (expr) 1118 : NULL_TREE; 1119 1120 case VECTOR_TYPE: 1121 if ((desires & WANT_VECTOR) == 0) 1122 return NULL_TREE; 1123 switch (TREE_CODE (TREE_TYPE (basetype))) 1124 { 1125 case INTEGER_TYPE: 1126 case BOOLEAN_TYPE: 1127 return (desires & WANT_INT) ? expr : NULL_TREE; 1128 case ENUMERAL_TYPE: 1129 return (desires & WANT_ENUM) ? expr : NULL_TREE; 1130 case REAL_TYPE: 1131 return (desires & WANT_FLOAT) ? expr : NULL_TREE; 1132 default: 1133 return NULL_TREE; 1134 } 1135 1136 default: 1137 return NULL_TREE; 1138 } 1139 1140 /* The code for conversions from class type is currently only used for 1141 delete expressions. Other expressions are handled by build_new_op. */ 1142 if (!complete_type_or_else (basetype, expr)) 1143 return error_mark_node; 1144 if (!TYPE_HAS_CONVERSION (basetype)) 1145 return NULL_TREE; 1146 1147 for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv)) 1148 { 1149 int win = 0; 1150 tree candidate; 1151 tree cand = TREE_VALUE (conv); 1152 1153 if (winner && winner == cand) 1154 continue; 1155 1156 candidate = non_reference (TREE_TYPE (TREE_TYPE (cand))); 1157 1158 switch (TREE_CODE (candidate)) 1159 { 1160 case BOOLEAN_TYPE: 1161 case INTEGER_TYPE: 1162 win = (desires & WANT_INT); break; 1163 case ENUMERAL_TYPE: 1164 win = (desires & WANT_ENUM); break; 1165 case REAL_TYPE: 1166 win = (desires & WANT_FLOAT); break; 1167 case POINTER_TYPE: 1168 win = (desires & WANT_POINTER); break; 1169 1170 case VECTOR_TYPE: 1171 if ((desires & WANT_VECTOR) == 0) 1172 break; 1173 switch (TREE_CODE (TREE_TYPE (candidate))) 1174 { 1175 case BOOLEAN_TYPE: 1176 case INTEGER_TYPE: 1177 win = (desires & WANT_INT); break; 1178 case ENUMERAL_TYPE: 1179 win = (desires & WANT_ENUM); break; 1180 case REAL_TYPE: 1181 win = (desires & WANT_FLOAT); break; 1182 default: 1183 break; 1184 } 1185 break; 1186 1187 default: 1188 break; 1189 } 1190 1191 if (win) 1192 { 1193 if (winner) 1194 { 1195 if (complain) 1196 { 1197 error ("ambiguous default type conversion from %qT", 1198 basetype); 1199 error (" candidate conversions include %qD and %qD", 1200 winner, cand); 1201 } 1202 return error_mark_node; 1203 } 1204 else 1205 winner = cand; 1206 } 1207 } 1208 1209 if (winner) 1210 { 1211 tree type = non_reference (TREE_TYPE (TREE_TYPE (winner))); 1212 return build_user_type_conversion (type, expr, LOOKUP_NORMAL); 1213 } 1214 1215 return NULL_TREE; 1216} 1217 1218/* Implements integral promotion (4.1) and float->double promotion. */ 1219 1220tree 1221type_promotes_to (tree type) 1222{ 1223 if (type == error_mark_node) 1224 return error_mark_node; 1225 1226 type = TYPE_MAIN_VARIANT (type); 1227 1228 /* bool always promotes to int (not unsigned), even if it's the same 1229 size. */ 1230 if (type == boolean_type_node) 1231 type = integer_type_node; 1232 1233 /* Normally convert enums to int, but convert wide enums to something 1234 wider. */ 1235 else if (TREE_CODE (type) == ENUMERAL_TYPE 1236 || type == wchar_type_node) 1237 { 1238 int precision = MAX (TYPE_PRECISION (type), 1239 TYPE_PRECISION (integer_type_node)); 1240 tree totype = c_common_type_for_size (precision, 0); 1241 if (TYPE_UNSIGNED (type) 1242 && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) 1243 type = c_common_type_for_size (precision, 1); 1244 else 1245 type = totype; 1246 } 1247 else if (c_promoting_integer_type_p (type)) 1248 { 1249 /* Retain unsignedness if really not getting bigger. */ 1250 if (TYPE_UNSIGNED (type) 1251 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 1252 type = unsigned_type_node; 1253 else 1254 type = integer_type_node; 1255 } 1256 else if (type == float_type_node) 1257 type = double_type_node; 1258 1259 return type; 1260} 1261 1262/* The routines below this point are carefully written to conform to 1263 the standard. They use the same terminology, and follow the rules 1264 closely. Although they are used only in pt.c at the moment, they 1265 should presumably be used everywhere in the future. */ 1266 1267/* Attempt to perform qualification conversions on EXPR to convert it 1268 to TYPE. Return the resulting expression, or error_mark_node if 1269 the conversion was impossible. */ 1270 1271tree 1272perform_qualification_conversions (tree type, tree expr) 1273{ 1274 tree expr_type; 1275 1276 expr_type = TREE_TYPE (expr); 1277 1278 if (same_type_p (type, expr_type)) 1279 return expr; 1280 else if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type) 1281 && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type))) 1282 return build_nop (type, expr); 1283 else if (TYPE_PTR_TO_MEMBER_P (type) 1284 && TYPE_PTR_TO_MEMBER_P (expr_type) 1285 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type), 1286 TYPE_PTRMEM_CLASS_TYPE (expr_type)) 1287 && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type), 1288 TYPE_PTRMEM_POINTED_TO_TYPE (expr_type))) 1289 return build_nop (type, expr); 1290 else 1291 return error_mark_node; 1292} 1293