118334Speter/* Language-level data type conversion for GNU C++. 290075Sobrien Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 418334Speter Hacked by Michael Tiemann (tiemann@cygnus.com) 518334Speter 6132718SkanThis file is part of GCC. 718334Speter 8132718SkanGCC is free software; you can redistribute it and/or modify 918334Speterit under the terms of the GNU General Public License as published by 1018334Speterthe Free Software Foundation; either version 2, or (at your option) 1118334Speterany later version. 1218334Speter 13132718SkanGCC is distributed in the hope that it will be useful, 1418334Speterbut WITHOUT ANY WARRANTY; without even the implied warranty of 1518334SpeterMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1618334SpeterGNU General Public License for more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 19132718Skanalong with GCC; see the file COPYING. If not, write to 20169689Skanthe Free Software Foundation, 51 Franklin Street, Fifth Floor, 21169689SkanBoston, MA 02110-1301, USA. */ 2218334Speter 2318334Speter 24132718Skan/* This file contains the functions for converting C++ expressions 2518334Speter to different data types. The only entry point is `convert'. 2618334Speter Every language front end must have a `convert' function 2718334Speter but what kind of conversions it does will depend on the language. */ 2818334Speter 2918334Speter#include "config.h" 3050397Sobrien#include "system.h" 31132718Skan#include "coretypes.h" 32132718Skan#include "tm.h" 3318334Speter#include "tree.h" 3418334Speter#include "flags.h" 3518334Speter#include "cp-tree.h" 3618334Speter#include "convert.h" 3752284Sobrien#include "toplev.h" 3852284Sobrien#include "decl.h" 39169689Skan#include "target.h" 4018334Speter 41132718Skanstatic tree cp_convert_to_pointer (tree, tree, bool); 42132718Skanstatic tree convert_to_pointer_force (tree, tree); 43169689Skanstatic tree build_type_conversion (tree, tree); 44132718Skanstatic tree build_up_reference (tree, tree, int, tree); 45132718Skanstatic void warn_ref_binding (tree, tree, tree); 4650397Sobrien 4718334Speter/* Change of width--truncation and extension of integers or reals-- 4818334Speter is represented with NOP_EXPR. Proper functioning of many things 4918334Speter assumes that no other conversions can be NOP_EXPRs. 5018334Speter 5118334Speter Conversion between integer and pointer is represented with CONVERT_EXPR. 5218334Speter Converting integer to real uses FLOAT_EXPR 5318334Speter and real to integer uses FIX_TRUNC_EXPR. 5418334Speter 5518334Speter Here is a list of all the functions that assume that widening and 5618334Speter narrowing is always done with a NOP_EXPR: 5718334Speter In convert.c, convert_to_integer. 5818334Speter In c-typeck.c, build_binary_op_nodefault (boolean ops), 59169689Skan and c_common_truthvalue_conversion. 6018334Speter In expr.c: expand_expr, for operands of a MULT_EXPR. 6118334Speter In fold-const.c: fold. 6218334Speter In tree.c: get_narrower and get_unwidened. 6318334Speter 6418334Speter C++: in multiple-inheritance, converting between pointers may involve 6518334Speter adjusting them by a delta stored within the class definition. */ 6618334Speter 6718334Speter/* Subroutines of `convert'. */ 6818334Speter 6918334Speter/* if converting pointer to pointer 7018334Speter if dealing with classes, check for derived->base or vice versa 7118334Speter else if dealing with method pointers, delegate 7218334Speter else convert blindly 7318334Speter else if converting class, pass off to build_type_conversion 7490075Sobrien else try C-style pointer conversion. If FORCE is true then allow 7590075Sobrien conversions via virtual bases (these are permitted by reinterpret_cast, 7690075Sobrien but not static_cast). */ 7750397Sobrien 7818334Speterstatic tree 79132718Skancp_convert_to_pointer (tree type, tree expr, bool force) 8018334Speter{ 81132718Skan tree intype = TREE_TYPE (expr); 82132718Skan enum tree_code form; 8350397Sobrien tree rval; 84161651Skan if (intype == error_mark_node) 85161651Skan return error_mark_node; 8618334Speter 8750397Sobrien if (IS_AGGR_TYPE (intype)) 8850397Sobrien { 8950397Sobrien intype = complete_type (intype); 9090075Sobrien if (!COMPLETE_TYPE_P (intype)) 9150397Sobrien { 92169689Skan error ("can't convert from incomplete type %qT to %qT", 93169689Skan intype, type); 9450397Sobrien return error_mark_node; 9550397Sobrien } 9650397Sobrien 97117395Skan rval = build_type_conversion (type, expr); 9850397Sobrien if (rval) 9950397Sobrien { 10050397Sobrien if (rval == error_mark_node) 101169689Skan error ("conversion of %qE from %qT to %qT is ambiguous", 102169689Skan expr, intype, type); 10350397Sobrien return rval; 10450397Sobrien } 10550397Sobrien } 10650397Sobrien 10750397Sobrien /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */ 10850397Sobrien if (TREE_CODE (type) == POINTER_TYPE 10950397Sobrien && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 11090075Sobrien || VOID_TYPE_P (TREE_TYPE (type)))) 11150397Sobrien { 112169689Skan if (TYPE_PTRMEMFUNC_P (intype) 113169689Skan || TREE_CODE (intype) == METHOD_TYPE) 114169689Skan return convert_member_func_to_ptr (type, expr); 115132718Skan if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) 116132718Skan return build_nop (type, expr); 11750397Sobrien intype = TREE_TYPE (expr); 11850397Sobrien } 11950397Sobrien 120117395Skan if (expr == error_mark_node) 121117395Skan return error_mark_node; 122117395Skan 12318334Speter form = TREE_CODE (intype); 12418334Speter 12552284Sobrien if (POINTER_TYPE_P (intype)) 12618334Speter { 12718334Speter intype = TYPE_MAIN_VARIANT (intype); 12818334Speter 12918334Speter if (TYPE_MAIN_VARIANT (type) != intype 13052284Sobrien && TREE_CODE (type) == POINTER_TYPE 13118334Speter && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 13250397Sobrien && IS_AGGR_TYPE (TREE_TYPE (type)) 13350397Sobrien && IS_AGGR_TYPE (TREE_TYPE (intype)) 13490075Sobrien && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 13518334Speter { 13618334Speter enum tree_code code = PLUS_EXPR; 13790075Sobrien tree binfo; 138117395Skan tree intype_class; 139117395Skan tree type_class; 140117395Skan bool same_p; 14190075Sobrien 142117395Skan intype_class = TREE_TYPE (intype); 143117395Skan type_class = TREE_TYPE (type); 144117395Skan 145169689Skan same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class), 146117395Skan TYPE_MAIN_VARIANT (type_class)); 147117395Skan binfo = NULL_TREE; 148117395Skan /* Try derived to base conversion. */ 149117395Skan if (!same_p) 150117395Skan binfo = lookup_base (intype_class, type_class, ba_check, NULL); 151117395Skan if (!same_p && !binfo) 15218334Speter { 153117395Skan /* Try base to derived conversion. */ 154117395Skan binfo = lookup_base (type_class, intype_class, ba_check, NULL); 15518334Speter code = MINUS_EXPR; 15618334Speter } 15790075Sobrien if (binfo == error_mark_node) 15890075Sobrien return error_mark_node; 159117395Skan if (binfo || same_p) 16018334Speter { 161117395Skan if (binfo) 162117395Skan expr = build_base_path (code, expr, binfo, 0); 163117395Skan /* Add any qualifier conversions. */ 164117395Skan return build_nop (type, expr); 16518334Speter } 16618334Speter } 16718334Speter 168132718Skan if (TYPE_PTRMEMFUNC_P (type)) 16918334Speter { 170169689Skan error ("cannot convert %qE from type %qT to type %qT", 171169689Skan expr, intype, type); 172132718Skan return error_mark_node; 173132718Skan } 17450397Sobrien 175132718Skan return build_nop (type, expr); 176132718Skan } 177132718Skan else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) 178132718Skan { 179169689Skan tree b1; 180132718Skan tree b2; 181132718Skan tree binfo; 182132718Skan enum tree_code code = PLUS_EXPR; 183132718Skan base_kind bk; 18490075Sobrien 185132718Skan b1 = TYPE_PTRMEM_CLASS_TYPE (type); 186132718Skan b2 = TYPE_PTRMEM_CLASS_TYPE (intype); 187132718Skan binfo = lookup_base (b1, b2, ba_check, &bk); 188132718Skan if (!binfo) 189132718Skan { 190132718Skan binfo = lookup_base (b2, b1, ba_check, &bk); 191132718Skan code = MINUS_EXPR; 192132718Skan } 193132718Skan if (binfo == error_mark_node) 194132718Skan return error_mark_node; 195132718Skan 196132718Skan if (bk == bk_via_virtual) 197132718Skan { 198132718Skan if (force) 199169689Skan warning (0, "pointer to member cast from %qT to %qT is via" 200169689Skan " virtual base", intype, type); 201132718Skan else 20290075Sobrien { 203169689Skan error ("pointer to member cast from %qT to %qT is" 204169689Skan " via virtual base", intype, type); 205132718Skan return error_mark_node; 20690075Sobrien } 207132718Skan /* This is a reinterpret cast, whose result is unspecified. 208132718Skan We choose to do nothing. */ 209132718Skan return build1 (NOP_EXPR, type, expr); 21018334Speter } 21118334Speter 212132718Skan if (TREE_CODE (expr) == PTRMEM_CST) 213132718Skan expr = cplus_expand_constant (expr); 214132718Skan 215132718Skan if (binfo && !integer_zerop (BINFO_OFFSET (binfo))) 216169689Skan expr = size_binop (code, 217132718Skan build_nop (sizetype, expr), 218132718Skan BINFO_OFFSET (binfo)); 219117395Skan return build_nop (type, expr); 22018334Speter } 22152284Sobrien else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)) 222169689Skan return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0, 223169689Skan /*c_cast_p=*/false); 22452284Sobrien else if (TYPE_PTRMEMFUNC_P (intype)) 22552284Sobrien { 226132718Skan if (!warn_pmf2ptr) 227132718Skan { 228132718Skan if (TREE_CODE (expr) == PTRMEM_CST) 229132718Skan return cp_convert_to_pointer (type, 230132718Skan PTRMEM_CST_MEMBER (expr), 231132718Skan force); 232132718Skan else if (TREE_CODE (expr) == OFFSET_REF) 233132718Skan { 234132718Skan tree object = TREE_OPERAND (expr, 0); 235132718Skan return get_member_function_from_ptrfunc (&object, 236132718Skan TREE_OPERAND (expr, 1)); 237132718Skan } 238132718Skan } 239169689Skan error ("cannot convert %qE from type %qT to type %qT", 240169689Skan expr, intype, type); 24152284Sobrien return error_mark_node; 24252284Sobrien } 24318334Speter 24418334Speter if (integer_zerop (expr)) 24518334Speter { 24652284Sobrien if (TYPE_PTRMEMFUNC_P (type)) 247169689Skan return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0, 248169689Skan /*c_cast_p=*/false); 24990075Sobrien 25090075Sobrien if (TYPE_PTRMEM_P (type)) 251169689Skan { 252169689Skan /* A NULL pointer-to-member is represented by -1, not by 253169689Skan zero. */ 254169689Skan expr = build_int_cst (type, -1); 255169689Skan /* Fix up the representation of -1 if appropriate. */ 256169689Skan expr = force_fit_type (expr, 0, false, false); 257169689Skan } 25890075Sobrien else 259169689Skan expr = build_int_cst (type, 0); 260169689Skan 26118334Speter return expr; 26218334Speter } 263132718Skan else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form)) 264117395Skan { 265169689Skan error ("invalid conversion from %qT to %qT", intype, type); 266117395Skan return error_mark_node; 267117395Skan } 26818334Speter 26918334Speter if (INTEGRAL_CODE_P (form)) 27018334Speter { 27150397Sobrien if (TYPE_PRECISION (intype) == POINTER_SIZE) 27218334Speter return build1 (CONVERT_EXPR, type, expr); 273117395Skan expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); 274169689Skan /* Modes may be different but sizes should be the same. There 275169689Skan is supposed to be some integral type that is the same width 276169689Skan as a pointer. */ 277169689Skan gcc_assert (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) 278169689Skan == GET_MODE_SIZE (TYPE_MODE (type))); 279169689Skan 28018334Speter return convert_to_pointer (type, expr); 28118334Speter } 28218334Speter 28352284Sobrien if (type_unknown_p (expr)) 284169689Skan return instantiate_type (type, expr, tf_warning_or_error); 28552284Sobrien 286169689Skan error ("cannot convert %qE from type %qT to type %qT", 287169689Skan expr, intype, type); 28818334Speter return error_mark_node; 28918334Speter} 29018334Speter 29118334Speter/* Like convert, except permit conversions to take place which 29218334Speter are not normally allowed due to access restrictions 29318334Speter (such as conversion from sub-type to private super-type). */ 29450397Sobrien 29518334Speterstatic tree 296132718Skanconvert_to_pointer_force (tree type, tree expr) 29718334Speter{ 298132718Skan tree intype = TREE_TYPE (expr); 299132718Skan enum tree_code form = TREE_CODE (intype); 300169689Skan 30118334Speter if (form == POINTER_TYPE) 30218334Speter { 30318334Speter intype = TYPE_MAIN_VARIANT (intype); 30418334Speter 30518334Speter if (TYPE_MAIN_VARIANT (type) != intype 30618334Speter && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 30750397Sobrien && IS_AGGR_TYPE (TREE_TYPE (type)) 30850397Sobrien && IS_AGGR_TYPE (TREE_TYPE (intype)) 30918334Speter && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 31018334Speter { 31118334Speter enum tree_code code = PLUS_EXPR; 31290075Sobrien tree binfo; 31390075Sobrien 31490075Sobrien binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type), 315169689Skan ba_unique, NULL); 31690075Sobrien if (!binfo) 31718334Speter { 31890075Sobrien binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), 319169689Skan ba_unique, NULL); 32090075Sobrien code = MINUS_EXPR; 32118334Speter } 32290075Sobrien if (binfo == error_mark_node) 32390075Sobrien return error_mark_node; 32490075Sobrien if (binfo) 32518334Speter { 32690075Sobrien expr = build_base_path (code, expr, binfo, 0); 327169689Skan if (expr == error_mark_node) 328169689Skan return error_mark_node; 329117395Skan /* Add any qualifier conversions. */ 33090075Sobrien if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)), 33190075Sobrien TREE_TYPE (type))) 332117395Skan expr = build_nop (type, expr); 33390075Sobrien return expr; 33418334Speter } 33518334Speter } 33618334Speter } 33718334Speter 338132718Skan return cp_convert_to_pointer (type, expr, true); 33918334Speter} 34018334Speter 34118334Speter/* We are passing something to a function which requires a reference. 34218334Speter The type we are interested in is in TYPE. The initial 34318334Speter value we have to begin with is in ARG. 34418334Speter 34518334Speter FLAGS controls how we manage access checking. 34690075Sobrien DIRECT_BIND in FLAGS controls how any temporaries are generated. 34790075Sobrien If DIRECT_BIND is set, DECL is the reference we're binding to. */ 34850397Sobrien 34918334Speterstatic tree 350132718Skanbuild_up_reference (tree type, tree arg, int flags, tree decl) 35118334Speter{ 35250397Sobrien tree rval; 35318334Speter tree argtype = TREE_TYPE (arg); 35418334Speter tree target_type = TREE_TYPE (type); 35518334Speter 356169689Skan gcc_assert (TREE_CODE (type) == REFERENCE_TYPE); 35750397Sobrien 35850397Sobrien if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg)) 35950397Sobrien { 36090075Sobrien /* Create a new temporary variable. We can't just use a TARGET_EXPR 36190075Sobrien here because it needs to live as long as DECL. */ 36250397Sobrien tree targ = arg; 36390075Sobrien 364117395Skan arg = make_temporary_var_for_ref_to_temp (decl, TREE_TYPE (arg)); 36590075Sobrien 36690075Sobrien /* Process the initializer for the declaration. */ 36750397Sobrien DECL_INITIAL (arg) = targ; 368169689Skan cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE, 36952284Sobrien LOOKUP_ONLYCONVERTING|DIRECT_BIND); 37050397Sobrien } 37150397Sobrien else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg)) 37290075Sobrien return get_target_expr (arg); 37350397Sobrien 37490075Sobrien /* If we had a way to wrap this up, and say, if we ever needed its 37550397Sobrien address, transform all occurrences of the register, into a memory 37650397Sobrien reference we could win better. */ 37750397Sobrien rval = build_unary_op (ADDR_EXPR, arg, 1); 37852284Sobrien if (rval == error_mark_node) 37952284Sobrien return error_mark_node; 38052284Sobrien 38118334Speter if ((flags & LOOKUP_PROTECT) 38218334Speter && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type) 38318334Speter && IS_AGGR_TYPE (argtype) 38418334Speter && IS_AGGR_TYPE (target_type)) 38518334Speter { 38690075Sobrien /* We go through lookup_base for the access control. */ 38790075Sobrien tree binfo = lookup_base (argtype, target_type, ba_check, NULL); 38818334Speter if (binfo == error_mark_node) 38918334Speter return error_mark_node; 39018334Speter if (binfo == NULL_TREE) 39118334Speter return error_not_base_type (target_type, argtype); 39290075Sobrien rval = build_base_path (PLUS_EXPR, rval, binfo, 1); 39318334Speter } 39418334Speter else 39550397Sobrien rval 39650397Sobrien = convert_to_pointer_force (build_pointer_type (target_type), rval); 397117395Skan return build_nop (type, rval); 39818334Speter} 39918334Speter 40090075Sobrien/* Subroutine of convert_to_reference. REFTYPE is the target reference type. 40190075Sobrien INTYPE is the original rvalue type and DECL is an optional _DECL node 40290075Sobrien for diagnostics. 403169689Skan 40490075Sobrien [dcl.init.ref] says that if an rvalue is used to 40590075Sobrien initialize a reference, then the reference must be to a 40690075Sobrien non-volatile const type. */ 40790075Sobrien 40890075Sobrienstatic void 409132718Skanwarn_ref_binding (tree reftype, tree intype, tree decl) 41090075Sobrien{ 41190075Sobrien tree ttl = TREE_TYPE (reftype); 412169689Skan 41390075Sobrien if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl)) 41490075Sobrien { 41590075Sobrien const char *msg; 41690075Sobrien 41790075Sobrien if (CP_TYPE_VOLATILE_P (ttl) && decl) 418169689Skan msg = "initialization of volatile reference type %q#T from" 419169689Skan " rvalue of type %qT"; 42090075Sobrien else if (CP_TYPE_VOLATILE_P (ttl)) 421169689Skan msg = "conversion to volatile reference type %q#T " 422169689Skan " from rvalue of type %qT"; 42390075Sobrien else if (decl) 424169689Skan msg = "initialization of non-const reference type %q#T from" 425169689Skan " rvalue of type %qT"; 42690075Sobrien else 427169689Skan msg = "conversion to non-const reference type %q#T from" 428169689Skan " rvalue of type %qT"; 42990075Sobrien 43090075Sobrien pedwarn (msg, reftype, intype); 43190075Sobrien } 43290075Sobrien} 43390075Sobrien 43418334Speter/* For C++: Only need to do one-level references, but cannot 43518334Speter get tripped up on signed/unsigned differences. 43618334Speter 43718334Speter DECL is either NULL_TREE or the _DECL node for a reference that is being 43818334Speter initialized. It can be error_mark_node if we don't know the _DECL but 43918334Speter we know it's an initialization. */ 44018334Speter 44118334Spetertree 442132718Skanconvert_to_reference (tree reftype, tree expr, int convtype, 443169689Skan int flags, tree decl) 44418334Speter{ 445132718Skan tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype)); 446132718Skan tree intype; 44718334Speter tree rval = NULL_TREE; 44818334Speter tree rval_as_conversion = NULL_TREE; 449132718Skan bool can_convert_intype_to_type; 45018334Speter 451169689Skan if (TREE_CODE (type) == FUNCTION_TYPE 452107590Sobrien && TREE_TYPE (expr) == unknown_type_node) 453169689Skan expr = instantiate_type (type, expr, 454132718Skan (flags & LOOKUP_COMPLAIN) 455169689Skan ? tf_warning_or_error : tf_none); 45652284Sobrien 457132718Skan if (expr == error_mark_node) 458132718Skan return error_mark_node; 459132718Skan 460132718Skan intype = TREE_TYPE (expr); 461132718Skan 462169689Skan gcc_assert (TREE_CODE (intype) != REFERENCE_TYPE); 463169689Skan gcc_assert (TREE_CODE (reftype) == REFERENCE_TYPE); 46418334Speter 46518334Speter intype = TYPE_MAIN_VARIANT (intype); 46618334Speter 467132718Skan can_convert_intype_to_type = can_convert (type, intype); 468132718Skan if (!can_convert_intype_to_type 469132718Skan && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype) 47018334Speter && ! (flags & LOOKUP_NO_CONVERSION)) 47118334Speter { 47218334Speter /* Look for a user-defined conversion to lvalue that we can use. */ 47318334Speter 47450397Sobrien rval_as_conversion 475117395Skan = build_type_conversion (reftype, expr); 47618334Speter 47718334Speter if (rval_as_conversion && rval_as_conversion != error_mark_node 47818334Speter && real_lvalue_p (rval_as_conversion)) 47918334Speter { 48018334Speter expr = rval_as_conversion; 48118334Speter rval_as_conversion = NULL_TREE; 48218334Speter intype = type; 483132718Skan can_convert_intype_to_type = 1; 48418334Speter } 48518334Speter } 48618334Speter 487132718Skan if (((convtype & CONV_STATIC) && can_convert (intype, type)) 488132718Skan || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type)) 48918334Speter { 49018334Speter if (flags & LOOKUP_COMPLAIN) 49118334Speter { 49218334Speter tree ttl = TREE_TYPE (reftype); 49352284Sobrien tree ttr = lvalue_type (expr); 49418334Speter 49590075Sobrien if (! real_lvalue_p (expr)) 49690075Sobrien warn_ref_binding (reftype, intype, decl); 497169689Skan 49890075Sobrien if (! (convtype & CONV_CONST) 49952284Sobrien && !at_least_as_qualified_p (ttl, ttr)) 500169689Skan pedwarn ("conversion from %qT to %qT discards qualifiers", 501169689Skan ttr, reftype); 50218334Speter } 50318334Speter 50490075Sobrien return build_up_reference (reftype, expr, flags, decl); 50518334Speter } 50618334Speter else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr)) 50718334Speter { 50818334Speter /* When casting an lvalue to a reference type, just convert into 50918334Speter a pointer to the new type and deference it. This is allowed 51018334Speter by San Diego WP section 5.2.9 paragraph 12, though perhaps it 51118334Speter should be done directly (jason). (int &)ri ---> *(int*)&ri */ 51218334Speter 51318334Speter /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they 514169689Skan meant. */ 51518334Speter if (TREE_CODE (intype) == POINTER_TYPE 516132718Skan && (comptypes (TREE_TYPE (intype), type, 517132718Skan COMPARE_BASE | COMPARE_DERIVED))) 518169689Skan warning (0, "casting %qT to %qT does not dereference pointer", 519132718Skan intype, reftype); 520169689Skan 52118334Speter rval = build_unary_op (ADDR_EXPR, expr, 0); 52218334Speter if (rval != error_mark_node) 52350397Sobrien rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), 52450397Sobrien rval, 0); 52518334Speter if (rval != error_mark_node) 52618334Speter rval = build1 (NOP_EXPR, reftype, rval); 52718334Speter } 52850397Sobrien else 52918334Speter { 53050397Sobrien rval = convert_for_initialization (NULL_TREE, type, expr, flags, 53150397Sobrien "converting", 0, 0); 53252284Sobrien if (rval == NULL_TREE || rval == error_mark_node) 53352284Sobrien return rval; 53490075Sobrien warn_ref_binding (reftype, intype, decl); 53590075Sobrien rval = build_up_reference (reftype, rval, flags, decl); 53618334Speter } 53718334Speter 53818334Speter if (rval) 53918334Speter { 54050397Sobrien /* If we found a way to convert earlier, then use it. */ 54118334Speter return rval; 54218334Speter } 54318334Speter 54418334Speter if (flags & LOOKUP_COMPLAIN) 545169689Skan error ("cannot convert type %qT to type %qT", intype, reftype); 54618334Speter 54718334Speter return error_mark_node; 54818334Speter} 54918334Speter 55018334Speter/* We are using a reference VAL for its value. Bash that reference all the 55150397Sobrien way down to its lowest form. */ 55250397Sobrien 55318334Spetertree 554132718Skanconvert_from_reference (tree val) 55518334Speter{ 556132718Skan if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE) 557169689Skan { 558169689Skan tree t = canonical_type_variant (TREE_TYPE (TREE_TYPE (val))); 559169689Skan tree ref = build1 (INDIRECT_REF, t, val); 56050397Sobrien 561169689Skan /* We *must* set TREE_READONLY when dereferencing a pointer to const, 562169689Skan so that we get the proper error message if the result is used 563169689Skan to assign to. Also, &* is supposed to be a no-op. */ 564169689Skan TREE_READONLY (ref) = CP_TYPE_CONST_P (t); 565169689Skan TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t); 566169689Skan TREE_SIDE_EFFECTS (ref) 567169689Skan = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val)); 568169689Skan REFERENCE_REF_P (ref) = 1; 569169689Skan val = ref; 570169689Skan } 57118334Speter 572169689Skan return val; 57318334Speter} 574117395Skan 575117395Skan/* Really perform an lvalue-to-rvalue conversion, including copying an 576117395Skan argument of class type into a temporary. */ 577117395Skan 578117395Skantree 579117395Skanforce_rvalue (tree expr) 580117395Skan{ 581117395Skan if (IS_AGGR_TYPE (TREE_TYPE (expr)) && TREE_CODE (expr) != TARGET_EXPR) 582117395Skan expr = ocp_convert (TREE_TYPE (expr), expr, 583117395Skan CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL); 584117395Skan else 585117395Skan expr = decay_conversion (expr); 586117395Skan 587117395Skan return expr; 588117395Skan} 58918334Speter 59050397Sobrien/* C++ conversions, preference to static cast conversions. */ 59150397Sobrien 59250397Sobrientree 593132718Skancp_convert (tree type, tree expr) 59450397Sobrien{ 59550397Sobrien return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL); 59650397Sobrien} 59750397Sobrien 59818334Speter/* Conversion... 59918334Speter 60018334Speter FLAGS indicates how we should behave. */ 60118334Speter 60218334Spetertree 603132718Skanocp_convert (tree type, tree expr, int convtype, int flags) 60418334Speter{ 605132718Skan tree e = expr; 606132718Skan enum tree_code code = TREE_CODE (type); 607169689Skan const char *invalid_conv_diag; 60818334Speter 609132718Skan if (error_operand_p (e) || type == error_mark_node) 61018334Speter return error_mark_node; 61118334Speter 61290075Sobrien complete_type (type); 61390075Sobrien complete_type (TREE_TYPE (expr)); 61450397Sobrien 615169689Skan if ((invalid_conv_diag 616169689Skan = targetm.invalid_conversion (TREE_TYPE (expr), type))) 617169689Skan { 618260011Spfg error (invalid_conv_diag, ""); 619169689Skan return error_mark_node; 620169689Skan } 62190075Sobrien 622169689Skan e = integral_constant_value (e); 623169689Skan 62450397Sobrien if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP) 62550397Sobrien /* Some internal structures (vtable_entry_type, sigtbl_ptr_type) 62650397Sobrien don't go through finish_struct, so they don't have the synthesized 62750397Sobrien constructors. So don't force a temporary. */ 62850397Sobrien && TYPE_HAS_CONSTRUCTOR (type)) 62918334Speter /* We need a new temporary; don't take this shortcut. */; 63018334Speter else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e))) 63152284Sobrien { 63252284Sobrien if (same_type_p (type, TREE_TYPE (e))) 63352284Sobrien /* The call to fold will not always remove the NOP_EXPR as 63452284Sobrien might be expected, since if one of the types is a typedef; 635132718Skan the comparison in fold is just equality of pointers, not a 63652284Sobrien call to comptypes. We don't call fold in this case because 63752284Sobrien that can result in infinite recursion; fold will call 63852284Sobrien convert, which will call ocp_convert, etc. */ 63952284Sobrien return e; 64090075Sobrien /* For complex data types, we need to perform componentwise 641169689Skan conversion. */ 64290075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE) 643169689Skan return fold_if_not_in_template (convert_to_complex (type, e)); 644132718Skan else if (TREE_CODE (e) == TARGET_EXPR) 645132718Skan { 646132718Skan /* Don't build a NOP_EXPR of class type. Instead, change the 647132718Skan type of the temporary. Only allow this for cv-qual changes, 648132718Skan though. */ 649169689Skan gcc_assert (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (e)), 650169689Skan TYPE_MAIN_VARIANT (type))); 651132718Skan TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type; 652132718Skan return e; 653132718Skan } 65452284Sobrien else 655169689Skan { 656169689Skan /* We shouldn't be treating objects of ADDRESSABLE type as 657169689Skan rvalues. */ 658169689Skan gcc_assert (!TREE_ADDRESSABLE (type)); 659169689Skan return fold_if_not_in_template (build_nop (type, e)); 660169689Skan } 66152284Sobrien } 66252284Sobrien 66318334Speter if (code == VOID_TYPE && (convtype & CONV_STATIC)) 66452284Sobrien { 66590075Sobrien e = convert_to_void (e, /*implicit=*/NULL); 66652284Sobrien return e; 66752284Sobrien } 66852284Sobrien 66918334Speter if (INTEGRAL_CODE_P (code)) 67018334Speter { 67118334Speter tree intype = TREE_TYPE (e); 67250397Sobrien /* enum = enum, enum = int, enum = float, (enum)pointer are all 673169689Skan errors. */ 67452284Sobrien if (TREE_CODE (type) == ENUMERAL_TYPE 675169689Skan && (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype) 676169689Skan || TREE_CODE (intype) == REAL_TYPE) 677169689Skan && ! (convtype & CONV_STATIC)) 678169689Skan || TREE_CODE (intype) == POINTER_TYPE)) 67918334Speter { 680169689Skan if (flags & LOOKUP_COMPLAIN) 681169689Skan pedwarn ("conversion from %q#T to %q#T", intype, type); 68218334Speter 68318334Speter if (flag_pedantic_errors) 68418334Speter return error_mark_node; 68518334Speter } 68618334Speter if (IS_AGGR_TYPE (intype)) 68718334Speter { 68818334Speter tree rval; 689117395Skan rval = build_type_conversion (type, e); 69018334Speter if (rval) 69118334Speter return rval; 69218334Speter if (flags & LOOKUP_COMPLAIN) 693169689Skan error ("%q#T used where a %qT was expected", intype, type); 69418334Speter return error_mark_node; 69518334Speter } 69618334Speter if (code == BOOLEAN_TYPE) 697132718Skan return cp_truthvalue_conversion (e); 69890075Sobrien 699169689Skan return fold_if_not_in_template (convert_to_integer (type, e)); 70018334Speter } 701132718Skan if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type)) 702169689Skan return fold_if_not_in_template (cp_convert_to_pointer (type, e, false)); 70390075Sobrien if (code == VECTOR_TYPE) 704169689Skan { 705169689Skan tree in_vtype = TREE_TYPE (e); 706169689Skan if (IS_AGGR_TYPE (in_vtype)) 707169689Skan { 708169689Skan tree ret_val; 709169689Skan ret_val = build_type_conversion (type, e); 710169689Skan if (ret_val) 711169689Skan return ret_val; 712169689Skan if (flags & LOOKUP_COMPLAIN) 713169689Skan error ("%q#T used where a %qT was expected", in_vtype, type); 714169689Skan return error_mark_node; 715169689Skan } 716169689Skan return fold_if_not_in_template (convert_to_vector (type, e)); 717169689Skan } 71850397Sobrien if (code == REAL_TYPE || code == COMPLEX_TYPE) 71918334Speter { 72018334Speter if (IS_AGGR_TYPE (TREE_TYPE (e))) 72118334Speter { 72218334Speter tree rval; 723117395Skan rval = build_type_conversion (type, e); 72418334Speter if (rval) 72518334Speter return rval; 72618334Speter else 72718334Speter if (flags & LOOKUP_COMPLAIN) 728169689Skan error ("%q#T used where a floating point value was expected", 72918334Speter TREE_TYPE (e)); 73018334Speter } 73150397Sobrien if (code == REAL_TYPE) 732169689Skan return fold_if_not_in_template (convert_to_real (type, e)); 73350397Sobrien else if (code == COMPLEX_TYPE) 734169689Skan return fold_if_not_in_template (convert_to_complex (type, e)); 73518334Speter } 73618334Speter 73718334Speter /* New C++ semantics: since assignment is now based on 73818334Speter memberwise copying, if the rhs type is derived from the 73918334Speter lhs type, then we may still do a conversion. */ 74018334Speter if (IS_AGGR_TYPE_CODE (code)) 74118334Speter { 74218334Speter tree dtype = TREE_TYPE (e); 74318334Speter tree ctor = NULL_TREE; 74418334Speter 74518334Speter dtype = TYPE_MAIN_VARIANT (dtype); 74618334Speter 74718334Speter /* Conversion between aggregate types. New C++ semantics allow 74818334Speter objects of derived type to be cast to objects of base type. 74918334Speter Old semantics only allowed this between pointers. 75018334Speter 75118334Speter There may be some ambiguity between using a constructor 75218334Speter vs. using a type conversion operator when both apply. */ 75318334Speter 75450397Sobrien ctor = e; 75518334Speter 75690075Sobrien if (abstract_virtuals_error (NULL_TREE, type)) 75790075Sobrien return error_mark_node; 75852284Sobrien 75950397Sobrien if ((flags & LOOKUP_ONLYCONVERTING) 76050397Sobrien && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype))) 76150397Sobrien /* For copy-initialization, first we create a temp of the proper type 76250397Sobrien with a user-defined conversion sequence, then we direct-initialize 76350397Sobrien the target with the temp (see [dcl.init]). */ 76450397Sobrien ctor = build_user_type_conversion (type, ctor, flags); 76590075Sobrien else 766169689Skan ctor = build_special_member_call (NULL_TREE, 767117395Skan complete_ctor_identifier, 768117395Skan build_tree_list (NULL_TREE, ctor), 769169689Skan type, flags); 77050397Sobrien if (ctor) 77150397Sobrien return build_cplus_new (type, ctor); 77218334Speter } 77318334Speter 77418334Speter if (flags & LOOKUP_COMPLAIN) 775169689Skan error ("conversion from %qT to non-scalar type %qT requested", 776169689Skan TREE_TYPE (expr), type); 77718334Speter return error_mark_node; 77818334Speter} 77918334Speter 78090075Sobrien/* When an expression is used in a void context, its value is discarded and 78190075Sobrien no lvalue-rvalue and similar conversions happen [expr.static.cast/4, 78290075Sobrien stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type 78390075Sobrien in a void context. The C++ standard does not define what an `access' to an 784132718Skan object is, but there is reason to believe that it is the lvalue to rvalue 78590075Sobrien conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it 78690075Sobrien accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8 78790075Sobrien indicates that volatile semantics should be the same between C and C++ 78890075Sobrien where ever possible. C leaves it implementation defined as to what 78990075Sobrien constitutes an access to a volatile. So, we interpret `*vp' as a read of 79090075Sobrien the volatile object `vp' points to, unless that is an incomplete type. For 79190075Sobrien volatile references we do not do this interpretation, because that would 79290075Sobrien make it impossible to ignore the reference return value from functions. We 79390075Sobrien issue warnings in the confusing cases. 794169689Skan 79590075Sobrien IMPLICIT is tells us the context of an implicit void conversion. */ 79690075Sobrien 79790075Sobrientree 798132718Skanconvert_to_void (tree expr, const char *implicit) 79990075Sobrien{ 800169689Skan if (expr == error_mark_node 80190075Sobrien || TREE_TYPE (expr) == error_mark_node) 80290075Sobrien return error_mark_node; 80390075Sobrien if (!TREE_TYPE (expr)) 80490075Sobrien return expr; 805132718Skan if (invalid_nonstatic_memfn_p (expr)) 806132718Skan return error_mark_node; 807146895Skan if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) 808146895Skan { 809146895Skan error ("pseudo-destructor is not called"); 810146895Skan return error_mark_node; 811146895Skan } 81290075Sobrien if (VOID_TYPE_P (TREE_TYPE (expr))) 81390075Sobrien return expr; 81490075Sobrien switch (TREE_CODE (expr)) 81590075Sobrien { 81690075Sobrien case COND_EXPR: 81790075Sobrien { 818169689Skan /* The two parts of a cond expr might be separate lvalues. */ 819169689Skan tree op1 = TREE_OPERAND (expr,1); 820169689Skan tree op2 = TREE_OPERAND (expr,2); 821169689Skan tree new_op1 = convert_to_void 822132718Skan (op1, (implicit && !TREE_SIDE_EFFECTS (op2) 823132718Skan ? "second operand of conditional" : NULL)); 824169689Skan tree new_op2 = convert_to_void 825132718Skan (op2, (implicit && !TREE_SIDE_EFFECTS (op1) 826132718Skan ? "third operand of conditional" : NULL)); 827169689Skan 828169689Skan expr = build3 (COND_EXPR, TREE_TYPE (new_op1), 829169689Skan TREE_OPERAND (expr, 0), new_op1, new_op2); 830169689Skan break; 83190075Sobrien } 832169689Skan 83390075Sobrien case COMPOUND_EXPR: 83490075Sobrien { 835169689Skan /* The second part of a compound expr contains the value. */ 836169689Skan tree op1 = TREE_OPERAND (expr,1); 837169689Skan tree new_op1 = convert_to_void 838169689Skan (op1, (implicit && !TREE_NO_WARNING (expr) 839132718Skan ? "right-hand operand of comma" : NULL)); 840169689Skan 841169689Skan if (new_op1 != op1) 84290075Sobrien { 843169689Skan tree t = build2 (COMPOUND_EXPR, TREE_TYPE (new_op1), 844169689Skan TREE_OPERAND (expr, 0), new_op1); 84590075Sobrien expr = t; 84690075Sobrien } 84790075Sobrien 848169689Skan break; 84990075Sobrien } 850169689Skan 85190075Sobrien case NON_LVALUE_EXPR: 85290075Sobrien case NOP_EXPR: 853117395Skan /* These have already decayed to rvalue. */ 85490075Sobrien break; 855169689Skan 856132718Skan case CALL_EXPR: /* We have a special meaning for volatile void fn(). */ 85790075Sobrien break; 858169689Skan 85990075Sobrien case INDIRECT_REF: 86090075Sobrien { 861169689Skan tree type = TREE_TYPE (expr); 862169689Skan int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) 863169689Skan == REFERENCE_TYPE; 864169689Skan int is_volatile = TYPE_VOLATILE (type); 865169689Skan int is_complete = COMPLETE_TYPE_P (complete_type (type)); 866169689Skan 867169689Skan /* Can't load the value if we don't know the type. */ 868169689Skan if (is_volatile && !is_complete) 869169689Skan warning (0, "object of incomplete type %qT will not be accessed in %s", 870169689Skan type, implicit ? implicit : "void context"); 871169689Skan /* Don't load the value if this is an implicit dereference, or if 872169689Skan the type needs to be handled by ctors/dtors. */ 873169689Skan else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type))) 874169689Skan warning (0, "object of type %qT will not be accessed in %s", 875169689Skan TREE_TYPE (TREE_OPERAND (expr, 0)), 876169689Skan implicit ? implicit : "void context"); 877169689Skan if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type)) 878169689Skan expr = TREE_OPERAND (expr, 0); 879169689Skan 880169689Skan break; 88190075Sobrien } 882169689Skan 88390075Sobrien case VAR_DECL: 88490075Sobrien { 885169689Skan /* External variables might be incomplete. */ 886169689Skan tree type = TREE_TYPE (expr); 887169689Skan int is_complete = COMPLETE_TYPE_P (complete_type (type)); 888169689Skan 889169689Skan if (TYPE_VOLATILE (type) && !is_complete) 890169689Skan warning (0, "object %qE of incomplete type %qT will not be accessed in %s", 891169689Skan expr, type, implicit ? implicit : "void context"); 892169689Skan break; 89390075Sobrien } 89490075Sobrien 895169689Skan case TARGET_EXPR: 896169689Skan /* Don't bother with the temporary object returned from a function if 897169689Skan we don't use it and don't need to destroy it. We'll still 898169689Skan allocate space for it in expand_call or declare_return_variable, 899169689Skan but we don't need to track it through all the tree phases. */ 900169689Skan if (TARGET_EXPR_IMPLICIT_P (expr) 901169689Skan && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (expr))) 902169689Skan { 903169689Skan tree init = TARGET_EXPR_INITIAL (expr); 904169689Skan if (TREE_CODE (init) == AGGR_INIT_EXPR 905169689Skan && !AGGR_INIT_VIA_CTOR_P (init)) 906169689Skan { 907169689Skan tree fn = TREE_OPERAND (init, 0); 908169689Skan expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))), 909169689Skan fn, TREE_OPERAND (init, 1), NULL_TREE); 910169689Skan } 911169689Skan } 912169689Skan break; 913169689Skan 91490075Sobrien default:; 91590075Sobrien } 91690075Sobrien { 91790075Sobrien tree probe = expr; 918169689Skan 91990075Sobrien if (TREE_CODE (probe) == ADDR_EXPR) 92090075Sobrien probe = TREE_OPERAND (expr, 0); 92190075Sobrien if (type_unknown_p (probe)) 92290075Sobrien { 92390075Sobrien /* [over.over] enumerates the places where we can take the address 92490075Sobrien of an overloaded function, and this is not one of them. */ 92590075Sobrien pedwarn ("%s cannot resolve address of overloaded function", 92690075Sobrien implicit ? implicit : "void cast"); 927132718Skan expr = void_zero_node; 92890075Sobrien } 92990075Sobrien else if (implicit && probe == expr && is_overloaded_fn (probe)) 930169689Skan { 931169689Skan /* Only warn when there is no &. */ 932169689Skan warning (OPT_Waddress, "%s is a reference, not call, to function %qE", 933169689Skan implicit, expr); 934169689Skan if (TREE_CODE (expr) == COMPONENT_REF) 935169689Skan expr = TREE_OPERAND (expr, 0); 936169689Skan } 93790075Sobrien } 938169689Skan 93990075Sobrien if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) 94090075Sobrien { 941169689Skan if (implicit 942169689Skan && warn_unused_value 943169689Skan && !TREE_NO_WARNING (expr) 944169689Skan && !processing_template_decl) 945169689Skan { 946169689Skan /* The middle end does not warn about expressions that have 947169689Skan been explicitly cast to void, so we must do so here. */ 948169689Skan if (!TREE_SIDE_EFFECTS (expr)) 949169689Skan warning (OPT_Wunused_value, "%s has no effect", implicit); 950169689Skan else 951169689Skan { 952169689Skan tree e; 953169689Skan enum tree_code code; 954169689Skan enum tree_code_class class; 955169689Skan 956169689Skan e = expr; 957169689Skan /* We might like to warn about (say) "(int) f()", as the 958169689Skan cast has no effect, but the compiler itself will 959169689Skan generate implicit conversions under some 960169689Skan circumstances. (For example a block copy will be 961169689Skan turned into a call to "__builtin_memcpy", with a 962169689Skan conversion of the return value to an appropriate 963169689Skan type.) So, to avoid false positives, we strip 964169689Skan conversions. Do not use STRIP_NOPs because it will 965169689Skan not strip conversions to "void", as that is not a 966169689Skan mode-preserving conversion. */ 967169689Skan while (TREE_CODE (e) == NOP_EXPR) 968169689Skan e = TREE_OPERAND (e, 0); 969169689Skan 970169689Skan code = TREE_CODE (e); 971169689Skan class = TREE_CODE_CLASS (code); 972169689Skan if (class == tcc_comparison 973169689Skan || class == tcc_unary 974169689Skan || (class == tcc_binary 975169689Skan && !(code == MODIFY_EXPR 976169689Skan || code == INIT_EXPR 977169689Skan || code == PREDECREMENT_EXPR 978169689Skan || code == PREINCREMENT_EXPR 979169689Skan || code == POSTDECREMENT_EXPR 980169689Skan || code == POSTINCREMENT_EXPR))) 981169689Skan warning (OPT_Wunused_value, "value computed is not used"); 982169689Skan } 983169689Skan } 984132718Skan expr = build1 (CONVERT_EXPR, void_type_node, expr); 98590075Sobrien } 986169689Skan if (! TREE_SIDE_EFFECTS (expr)) 987169689Skan expr = void_zero_node; 98890075Sobrien return expr; 98990075Sobrien} 99090075Sobrien 99118334Speter/* Create an expression whose value is that of EXPR, 99218334Speter converted to type TYPE. The TREE_TYPE of the value 99318334Speter is always TYPE. This function implements all reasonable 99418334Speter conversions; callers should filter out those that are 99550397Sobrien not permitted by the language being compiled. 99618334Speter 99750397Sobrien Most of this routine is from build_reinterpret_cast. 99850397Sobrien 99950397Sobrien The backend cannot call cp_convert (what was convert) because 100050397Sobrien conversions to/from basetypes may involve memory references 100150397Sobrien (vbases) and adding or subtracting small values (multiple 100250397Sobrien inheritance), but it calls convert from the constant folding code 100390075Sobrien on subtrees of already built trees after it has ripped them apart. 100450397Sobrien 100550397Sobrien Also, if we ever support range variables, we'll probably also have to 100650397Sobrien do a little bit more work. */ 100750397Sobrien 100818334Spetertree 1009132718Skanconvert (tree type, tree expr) 101018334Speter{ 101150397Sobrien tree intype; 101250397Sobrien 101350397Sobrien if (type == error_mark_node || expr == error_mark_node) 101450397Sobrien return error_mark_node; 101550397Sobrien 101650397Sobrien intype = TREE_TYPE (expr); 101750397Sobrien 101850397Sobrien if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype)) 1019169689Skan return fold_if_not_in_template (build_nop (type, expr)); 102050397Sobrien 102150397Sobrien return ocp_convert (type, expr, CONV_OLD_CONVERT, 102250397Sobrien LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); 102318334Speter} 102418334Speter 102550397Sobrien/* Like cp_convert, except permit conversions to take place which 102618334Speter are not normally allowed due to access restrictions 102718334Speter (such as conversion from sub-type to private super-type). */ 102850397Sobrien 102918334Spetertree 1030132718Skanconvert_force (tree type, tree expr, int convtype) 103118334Speter{ 1032132718Skan tree e = expr; 1033132718Skan enum tree_code code = TREE_CODE (type); 103418334Speter 103518334Speter if (code == REFERENCE_TYPE) 1036169689Skan return (fold_if_not_in_template 1037169689Skan (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN, 1038169689Skan NULL_TREE))); 103918334Speter 104018334Speter if (code == POINTER_TYPE) 1041169689Skan return fold_if_not_in_template (convert_to_pointer_force (type, e)); 104218334Speter 104318334Speter /* From typeck.c convert_for_assignment */ 104418334Speter if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR 104518334Speter && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE 104618334Speter && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) 104718334Speter || integer_zerop (e) 104818334Speter || TYPE_PTRMEMFUNC_P (TREE_TYPE (e))) 104918334Speter && TYPE_PTRMEMFUNC_P (type)) 1050169689Skan /* compatible pointer to member functions. */ 1051169689Skan return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1, 1052169689Skan /*c_cast_p=*/1); 105318334Speter 105450397Sobrien return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL); 105518334Speter} 105618334Speter 105718334Speter/* Convert an aggregate EXPR to type XTYPE. If a conversion 105818334Speter exists, return the attempted conversion. This may 105918334Speter return ERROR_MARK_NODE if the conversion is not 106018334Speter allowed (references private members, etc). 106118334Speter If no conversion exists, NULL_TREE is returned. 106218334Speter 106318334Speter FIXME: Ambiguity checking is wrong. Should choose one by the implicit 106418334Speter object parameter, or by the second standard conversion sequence if 106518334Speter that doesn't do it. This will probably wait for an overloading rewrite. 106618334Speter (jason 8/9/95) */ 106718334Speter 1068169689Skanstatic tree 1069132718Skanbuild_type_conversion (tree xtype, tree expr) 107018334Speter{ 107118334Speter /* C++: check to see if we can convert this aggregate type 107218334Speter into the required type. */ 1073117395Skan return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL); 107418334Speter} 107518334Speter 107618334Speter/* Convert the given EXPR to one of a group of types suitable for use in an 107718334Speter expression. DESIRES is a combination of various WANT_* flags (q.v.) 1078132718Skan which indicates which types are suitable. If COMPLAIN is true, complain 107918334Speter about ambiguity; otherwise, the caller will deal with it. */ 108018334Speter 108118334Spetertree 1082132718Skanbuild_expr_type_conversion (int desires, tree expr, bool complain) 108318334Speter{ 108418334Speter tree basetype = TREE_TYPE (expr); 108552284Sobrien tree conv = NULL_TREE; 108618334Speter tree winner = NULL_TREE; 108718334Speter 1088169689Skan if (expr == null_node 1089169689Skan && (desires & WANT_INT) 109052284Sobrien && !(desires & WANT_NULL)) 1091169689Skan warning (OPT_Wconversion, "converting NULL to non-pointer type"); 1092169689Skan 109318334Speter basetype = TREE_TYPE (expr); 109418334Speter 109590075Sobrien if (basetype == error_mark_node) 109690075Sobrien return error_mark_node; 109790075Sobrien 109818334Speter if (! IS_AGGR_TYPE (basetype)) 109918334Speter switch (TREE_CODE (basetype)) 110018334Speter { 110118334Speter case INTEGER_TYPE: 110252284Sobrien if ((desires & WANT_NULL) && null_ptr_cst_p (expr)) 110318334Speter return expr; 110450397Sobrien /* else fall through... */ 110518334Speter 110618334Speter case BOOLEAN_TYPE: 110718334Speter return (desires & WANT_INT) ? expr : NULL_TREE; 110818334Speter case ENUMERAL_TYPE: 110918334Speter return (desires & WANT_ENUM) ? expr : NULL_TREE; 111018334Speter case REAL_TYPE: 111118334Speter return (desires & WANT_FLOAT) ? expr : NULL_TREE; 111218334Speter case POINTER_TYPE: 111318334Speter return (desires & WANT_POINTER) ? expr : NULL_TREE; 1114169689Skan 111518334Speter case FUNCTION_TYPE: 111618334Speter case ARRAY_TYPE: 1117132718Skan return (desires & WANT_POINTER) ? decay_conversion (expr) 1118169689Skan : NULL_TREE; 1119169689Skan 1120169689Skan case VECTOR_TYPE: 1121169689Skan if ((desires & WANT_VECTOR) == 0) 1122169689Skan return NULL_TREE; 1123169689Skan switch (TREE_CODE (TREE_TYPE (basetype))) 1124169689Skan { 1125169689Skan case INTEGER_TYPE: 1126169689Skan case BOOLEAN_TYPE: 1127169689Skan return (desires & WANT_INT) ? expr : NULL_TREE; 1128169689Skan case ENUMERAL_TYPE: 1129169689Skan return (desires & WANT_ENUM) ? expr : NULL_TREE; 1130169689Skan case REAL_TYPE: 1131169689Skan return (desires & WANT_FLOAT) ? expr : NULL_TREE; 1132169689Skan default: 1133169689Skan return NULL_TREE; 1134169689Skan } 1135169689Skan 113618334Speter default: 113718334Speter return NULL_TREE; 113818334Speter } 113918334Speter 114050397Sobrien /* The code for conversions from class type is currently only used for 114150397Sobrien delete expressions. Other expressions are handled by build_new_op. */ 1142132718Skan if (!complete_type_or_else (basetype, expr)) 1143132718Skan return error_mark_node; 1144132718Skan if (!TYPE_HAS_CONVERSION (basetype)) 114518334Speter return NULL_TREE; 114618334Speter 114718334Speter for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv)) 114818334Speter { 114918334Speter int win = 0; 115018334Speter tree candidate; 115150397Sobrien tree cand = TREE_VALUE (conv); 115218334Speter 115350397Sobrien if (winner && winner == cand) 115418334Speter continue; 115518334Speter 1156132718Skan candidate = non_reference (TREE_TYPE (TREE_TYPE (cand))); 115718334Speter 115818334Speter switch (TREE_CODE (candidate)) 115918334Speter { 116018334Speter case BOOLEAN_TYPE: 116118334Speter case INTEGER_TYPE: 116218334Speter win = (desires & WANT_INT); break; 116318334Speter case ENUMERAL_TYPE: 116418334Speter win = (desires & WANT_ENUM); break; 116518334Speter case REAL_TYPE: 116618334Speter win = (desires & WANT_FLOAT); break; 116718334Speter case POINTER_TYPE: 116818334Speter win = (desires & WANT_POINTER); break; 116950397Sobrien 1170169689Skan case VECTOR_TYPE: 1171169689Skan if ((desires & WANT_VECTOR) == 0) 1172169689Skan break; 1173169689Skan switch (TREE_CODE (TREE_TYPE (candidate))) 1174169689Skan { 1175169689Skan case BOOLEAN_TYPE: 1176169689Skan case INTEGER_TYPE: 1177169689Skan win = (desires & WANT_INT); break; 1178169689Skan case ENUMERAL_TYPE: 1179169689Skan win = (desires & WANT_ENUM); break; 1180169689Skan case REAL_TYPE: 1181169689Skan win = (desires & WANT_FLOAT); break; 1182169689Skan default: 1183169689Skan break; 1184169689Skan } 1185169689Skan break; 1186169689Skan 118750397Sobrien default: 118850397Sobrien break; 118918334Speter } 119018334Speter 119118334Speter if (win) 119218334Speter { 119318334Speter if (winner) 119418334Speter { 119518334Speter if (complain) 119618334Speter { 1197169689Skan error ("ambiguous default type conversion from %qT", 1198169689Skan basetype); 1199169689Skan error (" candidate conversions include %qD and %qD", 1200169689Skan winner, cand); 120118334Speter } 120218334Speter return error_mark_node; 120318334Speter } 120418334Speter else 120550397Sobrien winner = cand; 120618334Speter } 120718334Speter } 120818334Speter 120918334Speter if (winner) 121050397Sobrien { 1211132718Skan tree type = non_reference (TREE_TYPE (TREE_TYPE (winner))); 121250397Sobrien return build_user_type_conversion (type, expr, LOOKUP_NORMAL); 121350397Sobrien } 121418334Speter 121518334Speter return NULL_TREE; 121618334Speter} 121718334Speter 121850397Sobrien/* Implements integral promotion (4.1) and float->double promotion. */ 121918334Speter 122018334Spetertree 1221132718Skantype_promotes_to (tree type) 122218334Speter{ 122318334Speter if (type == error_mark_node) 122418334Speter return error_mark_node; 122518334Speter 122618334Speter type = TYPE_MAIN_VARIANT (type); 122718334Speter 122818334Speter /* bool always promotes to int (not unsigned), even if it's the same 122918334Speter size. */ 123018334Speter if (type == boolean_type_node) 123118334Speter type = integer_type_node; 123218334Speter 123318334Speter /* Normally convert enums to int, but convert wide enums to something 123418334Speter wider. */ 123518334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE 123618334Speter || type == wchar_type_node) 123718334Speter { 123818334Speter int precision = MAX (TYPE_PRECISION (type), 123918334Speter TYPE_PRECISION (integer_type_node)); 1240117395Skan tree totype = c_common_type_for_size (precision, 0); 1241169689Skan if (TYPE_UNSIGNED (type) 124218334Speter && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) 1243117395Skan type = c_common_type_for_size (precision, 1); 124418334Speter else 124518334Speter type = totype; 124618334Speter } 124790075Sobrien else if (c_promoting_integer_type_p (type)) 124818334Speter { 124950397Sobrien /* Retain unsignedness if really not getting bigger. */ 1250169689Skan if (TYPE_UNSIGNED (type) 125150397Sobrien && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 125218334Speter type = unsigned_type_node; 125318334Speter else 125418334Speter type = integer_type_node; 125518334Speter } 125618334Speter else if (type == float_type_node) 125718334Speter type = double_type_node; 1258169689Skan 1259132718Skan return type; 126018334Speter} 126150397Sobrien 126250397Sobrien/* The routines below this point are carefully written to conform to 126350397Sobrien the standard. They use the same terminology, and follow the rules 126450397Sobrien closely. Although they are used only in pt.c at the moment, they 126550397Sobrien should presumably be used everywhere in the future. */ 126650397Sobrien 126750397Sobrien/* Attempt to perform qualification conversions on EXPR to convert it 126850397Sobrien to TYPE. Return the resulting expression, or error_mark_node if 126950397Sobrien the conversion was impossible. */ 127050397Sobrien 1271169689Skantree 1272132718Skanperform_qualification_conversions (tree type, tree expr) 127350397Sobrien{ 1274132718Skan tree expr_type; 1275132718Skan 1276132718Skan expr_type = TREE_TYPE (expr); 1277132718Skan 1278169689Skan if (same_type_p (type, expr_type)) 1279169689Skan return expr; 1280169689Skan else if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type) 1281169689Skan && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type))) 1282132718Skan return build_nop (type, expr); 1283132718Skan else if (TYPE_PTR_TO_MEMBER_P (type) 1284132718Skan && TYPE_PTR_TO_MEMBER_P (expr_type) 1285132718Skan && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type), 1286132718Skan TYPE_PTRMEM_CLASS_TYPE (expr_type)) 1287132718Skan && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type), 1288132718Skan TYPE_PTRMEM_POINTED_TO_TYPE (expr_type))) 1289132718Skan return build_nop (type, expr); 129050397Sobrien else 129150397Sobrien return error_mark_node; 129250397Sobrien} 1293