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