cvt.c revision 161651
118334Speter/* Language-level data type conversion for GNU C++. 290075Sobrien Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3132718Skan 1999, 2000, 2001, 2002, 2003 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 2018334Speterthe Free Software Foundation, 59 Temple Place - Suite 330, 2118334SpeterBoston, MA 02111-1307, 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" 3918334Speter 40132718Skanstatic tree cp_convert_to_pointer (tree, tree, bool); 41132718Skanstatic tree convert_to_pointer_force (tree, tree); 42132718Skanstatic tree build_up_reference (tree, tree, int, tree); 43132718Skanstatic void warn_ref_binding (tree, tree, tree); 4450397Sobrien 4518334Speter/* Change of width--truncation and extension of integers or reals-- 4618334Speter is represented with NOP_EXPR. Proper functioning of many things 4718334Speter assumes that no other conversions can be NOP_EXPRs. 4818334Speter 4918334Speter Conversion between integer and pointer is represented with CONVERT_EXPR. 5018334Speter Converting integer to real uses FLOAT_EXPR 5118334Speter and real to integer uses FIX_TRUNC_EXPR. 5218334Speter 5318334Speter Here is a list of all the functions that assume that widening and 5418334Speter narrowing is always done with a NOP_EXPR: 5518334Speter In convert.c, convert_to_integer. 5618334Speter In c-typeck.c, build_binary_op_nodefault (boolean ops), 57117395Skan and c_common_truthvalue_conversion. 5818334Speter In expr.c: expand_expr, for operands of a MULT_EXPR. 5918334Speter In fold-const.c: fold. 6018334Speter In tree.c: get_narrower and get_unwidened. 6118334Speter 6218334Speter C++: in multiple-inheritance, converting between pointers may involve 6318334Speter adjusting them by a delta stored within the class definition. */ 6418334Speter 6518334Speter/* Subroutines of `convert'. */ 6618334Speter 6718334Speter/* if converting pointer to pointer 6818334Speter if dealing with classes, check for derived->base or vice versa 6918334Speter else if dealing with method pointers, delegate 7018334Speter else convert blindly 7118334Speter else if converting class, pass off to build_type_conversion 7290075Sobrien else try C-style pointer conversion. If FORCE is true then allow 7390075Sobrien conversions via virtual bases (these are permitted by reinterpret_cast, 7490075Sobrien but not static_cast). */ 7550397Sobrien 7618334Speterstatic tree 77132718Skancp_convert_to_pointer (tree type, tree expr, bool force) 7818334Speter{ 79132718Skan tree intype = TREE_TYPE (expr); 80132718Skan enum tree_code form; 8150397Sobrien tree rval; 82161651Skan if (intype == error_mark_node) 83161651Skan return error_mark_node; 8418334Speter 8550397Sobrien if (IS_AGGR_TYPE (intype)) 8650397Sobrien { 8750397Sobrien intype = complete_type (intype); 8890075Sobrien if (!COMPLETE_TYPE_P (intype)) 8950397Sobrien { 9090075Sobrien error ("can't convert from incomplete type `%T' to `%T'", 9150397Sobrien intype, type); 9250397Sobrien return error_mark_node; 9350397Sobrien } 9450397Sobrien 95117395Skan rval = build_type_conversion (type, expr); 9650397Sobrien if (rval) 9750397Sobrien { 9850397Sobrien if (rval == error_mark_node) 9990075Sobrien error ("conversion of `%E' from `%T' to `%T' is ambiguous", 10050397Sobrien expr, intype, type); 10150397Sobrien return rval; 10250397Sobrien } 10350397Sobrien } 10450397Sobrien 10550397Sobrien /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */ 10650397Sobrien if (TREE_CODE (type) == POINTER_TYPE 10750397Sobrien && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 10890075Sobrien || VOID_TYPE_P (TREE_TYPE (type)))) 10950397Sobrien { 11050397Sobrien /* Allow an implicit this pointer for pointer to member 11150397Sobrien functions. */ 11250397Sobrien if (TYPE_PTRMEMFUNC_P (intype)) 11350397Sobrien { 114132718Skan if (pedantic || warn_pmf2ptr) 115132718Skan pedwarn ("converting from `%T' to `%T'", intype, type); 116132718Skan if (TREE_CODE (expr) == PTRMEM_CST) 117132718Skan expr = build_address (PTRMEM_CST_MEMBER (expr)); 118132718Skan else 119132718Skan { 120132718Skan tree decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 121132718Skan 0); 122132718Skan decl = build_address (decl); 123132718Skan expr = get_member_function_from_ptrfunc (&decl, expr); 124132718Skan } 12550397Sobrien } 126132718Skan else if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE) 12750397Sobrien { 128132718Skan if (pedantic || warn_pmf2ptr) 129132718Skan pedwarn ("converting from `%T' to `%T'", intype, type); 130132718Skan expr = build_addr_func (expr); 13150397Sobrien } 132132718Skan if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) 133132718Skan return build_nop (type, expr); 13450397Sobrien intype = TREE_TYPE (expr); 13550397Sobrien } 13650397Sobrien 137117395Skan if (expr == error_mark_node) 138117395Skan return error_mark_node; 139117395Skan 14018334Speter form = TREE_CODE (intype); 14118334Speter 14252284Sobrien if (POINTER_TYPE_P (intype)) 14318334Speter { 14418334Speter intype = TYPE_MAIN_VARIANT (intype); 14518334Speter 14618334Speter if (TYPE_MAIN_VARIANT (type) != intype 14752284Sobrien && TREE_CODE (type) == POINTER_TYPE 14818334Speter && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 14950397Sobrien && IS_AGGR_TYPE (TREE_TYPE (type)) 15050397Sobrien && IS_AGGR_TYPE (TREE_TYPE (intype)) 15190075Sobrien && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 15218334Speter { 15318334Speter enum tree_code code = PLUS_EXPR; 15490075Sobrien tree binfo; 155117395Skan tree intype_class; 156117395Skan tree type_class; 157117395Skan bool same_p; 15890075Sobrien 159117395Skan intype_class = TREE_TYPE (intype); 160117395Skan type_class = TREE_TYPE (type); 161117395Skan 162117395Skan same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class), 163117395Skan TYPE_MAIN_VARIANT (type_class)); 164117395Skan binfo = NULL_TREE; 165117395Skan /* Try derived to base conversion. */ 166117395Skan if (!same_p) 167117395Skan binfo = lookup_base (intype_class, type_class, ba_check, NULL); 168117395Skan if (!same_p && !binfo) 16918334Speter { 170117395Skan /* Try base to derived conversion. */ 171117395Skan binfo = lookup_base (type_class, intype_class, ba_check, NULL); 17218334Speter code = MINUS_EXPR; 17318334Speter } 17490075Sobrien if (binfo == error_mark_node) 17590075Sobrien return error_mark_node; 176117395Skan if (binfo || same_p) 17718334Speter { 178117395Skan if (binfo) 179117395Skan expr = build_base_path (code, expr, binfo, 0); 180117395Skan /* Add any qualifier conversions. */ 181117395Skan return build_nop (type, expr); 18218334Speter } 18318334Speter } 18418334Speter 185132718Skan if (TYPE_PTRMEMFUNC_P (type)) 18618334Speter { 187132718Skan error ("cannot convert `%E' from type `%T' to type `%T'", 188132718Skan expr, intype, type); 189132718Skan return error_mark_node; 190132718Skan } 19150397Sobrien 192132718Skan return build_nop (type, expr); 193132718Skan } 194132718Skan else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) 195132718Skan { 196132718Skan tree b1; 197132718Skan tree b2; 198132718Skan tree binfo; 199132718Skan enum tree_code code = PLUS_EXPR; 200132718Skan base_kind bk; 20190075Sobrien 202132718Skan b1 = TYPE_PTRMEM_CLASS_TYPE (type); 203132718Skan b2 = TYPE_PTRMEM_CLASS_TYPE (intype); 204132718Skan binfo = lookup_base (b1, b2, ba_check, &bk); 205132718Skan if (!binfo) 206132718Skan { 207132718Skan binfo = lookup_base (b2, b1, ba_check, &bk); 208132718Skan code = MINUS_EXPR; 209132718Skan } 210132718Skan if (binfo == error_mark_node) 211132718Skan return error_mark_node; 212132718Skan 213132718Skan if (bk == bk_via_virtual) 214132718Skan { 215132718Skan if (force) 216132718Skan warning ("pointer to member cast from `%T' to `%T' is via virtual base", 217132718Skan intype, type); 218132718Skan else 21990075Sobrien { 220132718Skan error ("pointer to member cast from `%T' to `%T' is via virtual base", 221132718Skan intype, type); 222132718Skan return error_mark_node; 22390075Sobrien } 224132718Skan /* This is a reinterpret cast, whose result is unspecified. 225132718Skan We choose to do nothing. */ 226132718Skan return build1 (NOP_EXPR, type, expr); 22718334Speter } 22818334Speter 229132718Skan if (TREE_CODE (expr) == PTRMEM_CST) 230132718Skan expr = cplus_expand_constant (expr); 231132718Skan 232132718Skan if (binfo && !integer_zerop (BINFO_OFFSET (binfo))) 233132718Skan expr = size_binop (code, 234132718Skan build_nop (sizetype, expr), 235132718Skan BINFO_OFFSET (binfo)); 236117395Skan return build_nop (type, expr); 23718334Speter } 23852284Sobrien else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)) 23990075Sobrien return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0); 24052284Sobrien else if (TYPE_PTRMEMFUNC_P (intype)) 24152284Sobrien { 242132718Skan if (!warn_pmf2ptr) 243132718Skan { 244132718Skan if (TREE_CODE (expr) == PTRMEM_CST) 245132718Skan return cp_convert_to_pointer (type, 246132718Skan PTRMEM_CST_MEMBER (expr), 247132718Skan force); 248132718Skan else if (TREE_CODE (expr) == OFFSET_REF) 249132718Skan { 250132718Skan tree object = TREE_OPERAND (expr, 0); 251132718Skan return get_member_function_from_ptrfunc (&object, 252132718Skan TREE_OPERAND (expr, 1)); 253132718Skan } 254132718Skan } 25590075Sobrien error ("cannot convert `%E' from type `%T' to type `%T'", 25652284Sobrien expr, intype, type); 25752284Sobrien return error_mark_node; 25852284Sobrien } 25918334Speter 26018334Speter if (integer_zerop (expr)) 26118334Speter { 26252284Sobrien if (TYPE_PTRMEMFUNC_P (type)) 26352284Sobrien return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0); 26490075Sobrien 26590075Sobrien if (TYPE_PTRMEM_P (type)) 26690075Sobrien /* A NULL pointer-to-member is represented by -1, not by 26790075Sobrien zero. */ 26890075Sobrien expr = build_int_2 (-1, -1); 26990075Sobrien else 27090075Sobrien expr = build_int_2 (0, 0); 27118334Speter TREE_TYPE (expr) = type; 272102780Skan /* Fix up the representation of -1 if appropriate. */ 273102780Skan force_fit_type (expr, 0); 27418334Speter return expr; 27518334Speter } 276132718Skan else if (TYPE_PTR_TO_MEMBER_P (type) && INTEGRAL_CODE_P (form)) 277117395Skan { 278117395Skan error ("invalid conversion from '%T' to '%T'", intype, type); 279117395Skan return error_mark_node; 280117395Skan } 28118334Speter 28218334Speter if (INTEGRAL_CODE_P (form)) 28318334Speter { 28450397Sobrien if (TYPE_PRECISION (intype) == POINTER_SIZE) 28518334Speter return build1 (CONVERT_EXPR, type, expr); 286117395Skan expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); 28718334Speter /* Modes may be different but sizes should be the same. */ 28818334Speter if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) 28918334Speter != GET_MODE_SIZE (TYPE_MODE (type))) 29018334Speter /* There is supposed to be some integral type 29118334Speter that is the same width as a pointer. */ 29218334Speter abort (); 29318334Speter return convert_to_pointer (type, expr); 29418334Speter } 29518334Speter 29652284Sobrien if (type_unknown_p (expr)) 29796263Sobrien return instantiate_type (type, expr, tf_error | tf_warning); 29852284Sobrien 29990075Sobrien error ("cannot convert `%E' from type `%T' to type `%T'", 30018334Speter expr, intype, type); 30118334Speter return error_mark_node; 30218334Speter} 30318334Speter 30418334Speter/* Like convert, except permit conversions to take place which 30518334Speter are not normally allowed due to access restrictions 30618334Speter (such as conversion from sub-type to private super-type). */ 30750397Sobrien 30818334Speterstatic tree 309132718Skanconvert_to_pointer_force (tree type, tree expr) 31018334Speter{ 311132718Skan tree intype = TREE_TYPE (expr); 312132718Skan enum tree_code form = TREE_CODE (intype); 31318334Speter 31418334Speter if (form == POINTER_TYPE) 31518334Speter { 31618334Speter intype = TYPE_MAIN_VARIANT (intype); 31718334Speter 31818334Speter if (TYPE_MAIN_VARIANT (type) != intype 31918334Speter && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 32050397Sobrien && IS_AGGR_TYPE (TREE_TYPE (type)) 32150397Sobrien && IS_AGGR_TYPE (TREE_TYPE (intype)) 32218334Speter && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 32318334Speter { 32418334Speter enum tree_code code = PLUS_EXPR; 32590075Sobrien tree binfo; 32690075Sobrien 32790075Sobrien binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type), 32890075Sobrien ba_ignore, NULL); 32990075Sobrien if (!binfo) 33018334Speter { 33190075Sobrien binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), 33290075Sobrien ba_ignore, NULL); 33390075Sobrien code = MINUS_EXPR; 33418334Speter } 33590075Sobrien if (binfo == error_mark_node) 33690075Sobrien return error_mark_node; 33790075Sobrien if (binfo) 33818334Speter { 33990075Sobrien expr = build_base_path (code, expr, binfo, 0); 340117395Skan if (expr == error_mark_node) 341117395Skan return error_mark_node; 342117395Skan /* Add any qualifier conversions. */ 34390075Sobrien if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)), 34490075Sobrien TREE_TYPE (type))) 345117395Skan expr = build_nop (type, expr); 34690075Sobrien return expr; 34718334Speter } 34818334Speter } 34918334Speter } 35018334Speter 351132718Skan return cp_convert_to_pointer (type, expr, true); 35218334Speter} 35318334Speter 35418334Speter/* We are passing something to a function which requires a reference. 35518334Speter The type we are interested in is in TYPE. The initial 35618334Speter value we have to begin with is in ARG. 35718334Speter 35818334Speter FLAGS controls how we manage access checking. 35990075Sobrien DIRECT_BIND in FLAGS controls how any temporaries are generated. 36090075Sobrien If DIRECT_BIND is set, DECL is the reference we're binding to. */ 36150397Sobrien 36218334Speterstatic tree 363132718Skanbuild_up_reference (tree type, tree arg, int flags, tree decl) 36418334Speter{ 36550397Sobrien tree rval; 36618334Speter tree argtype = TREE_TYPE (arg); 36718334Speter tree target_type = TREE_TYPE (type); 36818334Speter 36918334Speter my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187); 37050397Sobrien 37150397Sobrien if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg)) 37250397Sobrien { 37390075Sobrien /* Create a new temporary variable. We can't just use a TARGET_EXPR 37490075Sobrien here because it needs to live as long as DECL. */ 37550397Sobrien tree targ = arg; 37690075Sobrien 377117395Skan arg = make_temporary_var_for_ref_to_temp (decl, TREE_TYPE (arg)); 37890075Sobrien 37990075Sobrien /* Process the initializer for the declaration. */ 38050397Sobrien DECL_INITIAL (arg) = targ; 38190075Sobrien cp_finish_decl (arg, targ, NULL_TREE, 38252284Sobrien LOOKUP_ONLYCONVERTING|DIRECT_BIND); 38350397Sobrien } 38450397Sobrien else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg)) 38590075Sobrien return get_target_expr (arg); 38650397Sobrien 38790075Sobrien /* If we had a way to wrap this up, and say, if we ever needed its 38850397Sobrien address, transform all occurrences of the register, into a memory 38950397Sobrien reference we could win better. */ 39050397Sobrien rval = build_unary_op (ADDR_EXPR, arg, 1); 39152284Sobrien if (rval == error_mark_node) 39252284Sobrien return error_mark_node; 39352284Sobrien 39418334Speter if ((flags & LOOKUP_PROTECT) 39518334Speter && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type) 39618334Speter && IS_AGGR_TYPE (argtype) 39718334Speter && IS_AGGR_TYPE (target_type)) 39818334Speter { 39990075Sobrien /* We go through lookup_base for the access control. */ 40090075Sobrien tree binfo = lookup_base (argtype, target_type, ba_check, NULL); 40118334Speter if (binfo == error_mark_node) 40218334Speter return error_mark_node; 40318334Speter if (binfo == NULL_TREE) 40418334Speter return error_not_base_type (target_type, argtype); 40590075Sobrien rval = build_base_path (PLUS_EXPR, rval, binfo, 1); 40618334Speter } 40718334Speter else 40850397Sobrien rval 40950397Sobrien = convert_to_pointer_force (build_pointer_type (target_type), rval); 410117395Skan return build_nop (type, rval); 41118334Speter} 41218334Speter 41390075Sobrien/* Subroutine of convert_to_reference. REFTYPE is the target reference type. 41490075Sobrien INTYPE is the original rvalue type and DECL is an optional _DECL node 41590075Sobrien for diagnostics. 41690075Sobrien 41790075Sobrien [dcl.init.ref] says that if an rvalue is used to 41890075Sobrien initialize a reference, then the reference must be to a 41990075Sobrien non-volatile const type. */ 42090075Sobrien 42190075Sobrienstatic void 422132718Skanwarn_ref_binding (tree reftype, tree intype, tree decl) 42390075Sobrien{ 42490075Sobrien tree ttl = TREE_TYPE (reftype); 42590075Sobrien 42690075Sobrien if (!CP_TYPE_CONST_NON_VOLATILE_P (ttl)) 42790075Sobrien { 42890075Sobrien const char *msg; 42990075Sobrien 43090075Sobrien if (CP_TYPE_VOLATILE_P (ttl) && decl) 43190075Sobrien msg = "initialization of volatile reference type `%#T' from rvalue of type `%T'"; 43290075Sobrien else if (CP_TYPE_VOLATILE_P (ttl)) 43390075Sobrien msg = "conversion to volatile reference type `%#T' from rvalue of type `%T'"; 43490075Sobrien else if (decl) 43590075Sobrien msg = "initialization of non-const reference type `%#T' from rvalue of type `%T'"; 43690075Sobrien else 43790075Sobrien msg = "conversion to non-const reference type `%#T' from rvalue of type `%T'"; 43890075Sobrien 43990075Sobrien pedwarn (msg, reftype, intype); 44090075Sobrien } 44190075Sobrien} 44290075Sobrien 44318334Speter/* For C++: Only need to do one-level references, but cannot 44418334Speter get tripped up on signed/unsigned differences. 44518334Speter 44618334Speter DECL is either NULL_TREE or the _DECL node for a reference that is being 44718334Speter initialized. It can be error_mark_node if we don't know the _DECL but 44818334Speter we know it's an initialization. */ 44918334Speter 45018334Spetertree 451132718Skanconvert_to_reference (tree reftype, tree expr, int convtype, 452132718Skan int flags, tree decl) 45318334Speter{ 454132718Skan tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype)); 455132718Skan tree intype; 45618334Speter tree rval = NULL_TREE; 45718334Speter tree rval_as_conversion = NULL_TREE; 458132718Skan bool can_convert_intype_to_type; 45918334Speter 460107590Sobrien if (TREE_CODE (type) == FUNCTION_TYPE 461107590Sobrien && TREE_TYPE (expr) == unknown_type_node) 462132718Skan expr = instantiate_type (type, expr, 463132718Skan (flags & LOOKUP_COMPLAIN) 464132718Skan ? tf_error | tf_warning : tf_none); 465107590Sobrien else 466132718Skan expr = convert_from_reference (expr); 46752284Sobrien 468132718Skan if (expr == error_mark_node) 469132718Skan return error_mark_node; 470132718Skan 471132718Skan intype = TREE_TYPE (expr); 472132718Skan 47390075Sobrien my_friendly_assert (TREE_CODE (intype) != REFERENCE_TYPE, 364); 47418334Speter 47518334Speter intype = TYPE_MAIN_VARIANT (intype); 47618334Speter 477132718Skan can_convert_intype_to_type = can_convert (type, intype); 478132718Skan if (!can_convert_intype_to_type 479132718Skan && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype) 48018334Speter && ! (flags & LOOKUP_NO_CONVERSION)) 48118334Speter { 48218334Speter /* Look for a user-defined conversion to lvalue that we can use. */ 48318334Speter 48450397Sobrien rval_as_conversion 485117395Skan = build_type_conversion (reftype, expr); 48618334Speter 48718334Speter if (rval_as_conversion && rval_as_conversion != error_mark_node 48818334Speter && real_lvalue_p (rval_as_conversion)) 48918334Speter { 49018334Speter expr = rval_as_conversion; 49118334Speter rval_as_conversion = NULL_TREE; 49218334Speter intype = type; 493132718Skan can_convert_intype_to_type = 1; 49418334Speter } 49518334Speter } 49618334Speter 497132718Skan if (((convtype & CONV_STATIC) && can_convert (intype, type)) 498132718Skan || ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type)) 49918334Speter { 50018334Speter if (flags & LOOKUP_COMPLAIN) 50118334Speter { 50218334Speter tree ttl = TREE_TYPE (reftype); 50352284Sobrien tree ttr = lvalue_type (expr); 50418334Speter 50590075Sobrien if (! real_lvalue_p (expr)) 50690075Sobrien warn_ref_binding (reftype, intype, decl); 50790075Sobrien 50890075Sobrien if (! (convtype & CONV_CONST) 50952284Sobrien && !at_least_as_qualified_p (ttl, ttr)) 51090075Sobrien pedwarn ("conversion from `%T' to `%T' discards qualifiers", 51152284Sobrien ttr, reftype); 51218334Speter } 51318334Speter 51490075Sobrien return build_up_reference (reftype, expr, flags, decl); 51518334Speter } 51618334Speter else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr)) 51718334Speter { 51818334Speter /* When casting an lvalue to a reference type, just convert into 51918334Speter a pointer to the new type and deference it. This is allowed 52018334Speter by San Diego WP section 5.2.9 paragraph 12, though perhaps it 52118334Speter should be done directly (jason). (int &)ri ---> *(int*)&ri */ 52218334Speter 52318334Speter /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they 52418334Speter meant. */ 52518334Speter if (TREE_CODE (intype) == POINTER_TYPE 526132718Skan && (comptypes (TREE_TYPE (intype), type, 527132718Skan COMPARE_BASE | COMPARE_DERIVED))) 52890075Sobrien warning ("casting `%T' to `%T' does not dereference pointer", 529132718Skan intype, reftype); 53018334Speter 53118334Speter rval = build_unary_op (ADDR_EXPR, expr, 0); 53218334Speter if (rval != error_mark_node) 53350397Sobrien rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), 53450397Sobrien rval, 0); 53518334Speter if (rval != error_mark_node) 53618334Speter rval = build1 (NOP_EXPR, reftype, rval); 53718334Speter } 53850397Sobrien else 53918334Speter { 54050397Sobrien rval = convert_for_initialization (NULL_TREE, type, expr, flags, 54150397Sobrien "converting", 0, 0); 54252284Sobrien if (rval == NULL_TREE || rval == error_mark_node) 54352284Sobrien return rval; 54490075Sobrien warn_ref_binding (reftype, intype, decl); 54590075Sobrien rval = build_up_reference (reftype, rval, flags, decl); 54618334Speter } 54718334Speter 54818334Speter if (rval) 54918334Speter { 55050397Sobrien /* If we found a way to convert earlier, then use it. */ 55118334Speter return rval; 55218334Speter } 55318334Speter 55418334Speter if (flags & LOOKUP_COMPLAIN) 55590075Sobrien error ("cannot convert type `%T' to type `%T'", intype, reftype); 55618334Speter 55718334Speter if (flags & LOOKUP_SPECULATIVELY) 55818334Speter return NULL_TREE; 55918334Speter 56018334Speter return error_mark_node; 56118334Speter} 56218334Speter 56318334Speter/* We are using a reference VAL for its value. Bash that reference all the 56450397Sobrien way down to its lowest form. */ 56550397Sobrien 56618334Spetertree 567132718Skanconvert_from_reference (tree val) 56818334Speter{ 569132718Skan if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE) 57090075Sobrien return build_indirect_ref (val, NULL); 57118334Speter return val; 57218334Speter} 57350397Sobrien 57490075Sobrien/* Implicitly convert the lvalue EXPR to another lvalue of type TOTYPE, 57590075Sobrien preserving cv-qualification. */ 57618334Speter 57718334Spetertree 578132718Skanconvert_lvalue (tree totype, tree expr) 57918334Speter{ 58090075Sobrien totype = cp_build_qualified_type (totype, TYPE_QUALS (TREE_TYPE (expr))); 58190075Sobrien totype = build_reference_type (totype); 58290075Sobrien expr = convert_to_reference (totype, expr, CONV_IMPLICIT, LOOKUP_NORMAL, 58390075Sobrien NULL_TREE); 58490075Sobrien return convert_from_reference (expr); 58518334Speter} 586117395Skan 587117395Skan/* Really perform an lvalue-to-rvalue conversion, including copying an 588117395Skan argument of class type into a temporary. */ 589117395Skan 590117395Skantree 591117395Skanforce_rvalue (tree expr) 592117395Skan{ 593117395Skan if (IS_AGGR_TYPE (TREE_TYPE (expr)) && TREE_CODE (expr) != TARGET_EXPR) 594117395Skan expr = ocp_convert (TREE_TYPE (expr), expr, 595117395Skan CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL); 596117395Skan else 597117395Skan expr = decay_conversion (expr); 598117395Skan 599117395Skan return expr; 600117395Skan} 60118334Speter 60250397Sobrien/* C++ conversions, preference to static cast conversions. */ 60350397Sobrien 60450397Sobrientree 605132718Skancp_convert (tree type, tree expr) 60650397Sobrien{ 60750397Sobrien return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL); 60850397Sobrien} 60950397Sobrien 61018334Speter/* Conversion... 61118334Speter 61218334Speter FLAGS indicates how we should behave. */ 61318334Speter 61418334Spetertree 615132718Skanocp_convert (tree type, tree expr, int convtype, int flags) 61618334Speter{ 617132718Skan tree e = expr; 618132718Skan enum tree_code code = TREE_CODE (type); 61918334Speter 620132718Skan if (error_operand_p (e) || type == error_mark_node) 62118334Speter return error_mark_node; 62218334Speter 62390075Sobrien complete_type (type); 62490075Sobrien complete_type (TREE_TYPE (expr)); 62550397Sobrien 62690075Sobrien e = decl_constant_value (e); 62790075Sobrien 62850397Sobrien if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP) 62950397Sobrien /* Some internal structures (vtable_entry_type, sigtbl_ptr_type) 63050397Sobrien don't go through finish_struct, so they don't have the synthesized 63150397Sobrien constructors. So don't force a temporary. */ 63250397Sobrien && TYPE_HAS_CONSTRUCTOR (type)) 63318334Speter /* We need a new temporary; don't take this shortcut. */; 63418334Speter else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e))) 63552284Sobrien { 63652284Sobrien if (same_type_p (type, TREE_TYPE (e))) 63752284Sobrien /* The call to fold will not always remove the NOP_EXPR as 63852284Sobrien might be expected, since if one of the types is a typedef; 639132718Skan the comparison in fold is just equality of pointers, not a 64052284Sobrien call to comptypes. We don't call fold in this case because 64152284Sobrien that can result in infinite recursion; fold will call 64252284Sobrien convert, which will call ocp_convert, etc. */ 64352284Sobrien return e; 64490075Sobrien /* For complex data types, we need to perform componentwise 64590075Sobrien conversion. */ 64690075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE) 64790075Sobrien return fold (convert_to_complex (type, e)); 648132718Skan else if (TREE_CODE (e) == TARGET_EXPR) 649132718Skan { 650132718Skan /* Don't build a NOP_EXPR of class type. Instead, change the 651132718Skan type of the temporary. Only allow this for cv-qual changes, 652132718Skan though. */ 653132718Skan if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (e)), 654132718Skan TYPE_MAIN_VARIANT (type))) 655132718Skan abort (); 656132718Skan TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type; 657132718Skan return e; 658132718Skan } 659132718Skan else if (TREE_ADDRESSABLE (type)) 660132718Skan /* We shouldn't be treating objects of ADDRESSABLE type as rvalues. */ 661132718Skan abort (); 66252284Sobrien else 66352284Sobrien return fold (build1 (NOP_EXPR, type, e)); 66452284Sobrien } 66552284Sobrien 66618334Speter if (code == VOID_TYPE && (convtype & CONV_STATIC)) 66752284Sobrien { 66890075Sobrien e = convert_to_void (e, /*implicit=*/NULL); 66952284Sobrien return e; 67052284Sobrien } 67152284Sobrien 67218334Speter if (INTEGRAL_CODE_P (code)) 67318334Speter { 67418334Speter tree intype = TREE_TYPE (e); 67550397Sobrien /* enum = enum, enum = int, enum = float, (enum)pointer are all 67650397Sobrien errors. */ 67752284Sobrien if (TREE_CODE (type) == ENUMERAL_TYPE 67850397Sobrien && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC)) 67950397Sobrien || (TREE_CODE (intype) == POINTER_TYPE))) 68018334Speter { 68190075Sobrien pedwarn ("conversion from `%#T' to `%#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) 69390075Sobrien error ("`%#T' used where a `%T' was expected", intype, type); 69418334Speter if (flags & LOOKUP_SPECULATIVELY) 69518334Speter return NULL_TREE; 69618334Speter return error_mark_node; 69718334Speter } 69818334Speter if (code == BOOLEAN_TYPE) 699132718Skan return cp_truthvalue_conversion (e); 70090075Sobrien 70118334Speter return fold (convert_to_integer (type, e)); 70218334Speter } 703132718Skan if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type)) 704132718Skan return fold (cp_convert_to_pointer (type, e, false)); 70590075Sobrien if (code == VECTOR_TYPE) 70690075Sobrien return fold (convert_to_vector (type, e)); 70750397Sobrien if (code == REAL_TYPE || code == COMPLEX_TYPE) 70818334Speter { 70918334Speter if (IS_AGGR_TYPE (TREE_TYPE (e))) 71018334Speter { 71118334Speter tree rval; 712117395Skan rval = build_type_conversion (type, e); 71318334Speter if (rval) 71418334Speter return rval; 71518334Speter else 71618334Speter if (flags & LOOKUP_COMPLAIN) 71790075Sobrien error ("`%#T' used where a floating point value was expected", 71818334Speter TREE_TYPE (e)); 71918334Speter } 72050397Sobrien if (code == REAL_TYPE) 72150397Sobrien return fold (convert_to_real (type, e)); 72250397Sobrien else if (code == COMPLEX_TYPE) 72350397Sobrien return fold (convert_to_complex (type, e)); 72418334Speter } 72518334Speter 72618334Speter /* New C++ semantics: since assignment is now based on 72718334Speter memberwise copying, if the rhs type is derived from the 72818334Speter lhs type, then we may still do a conversion. */ 72918334Speter if (IS_AGGR_TYPE_CODE (code)) 73018334Speter { 73118334Speter tree dtype = TREE_TYPE (e); 73218334Speter tree ctor = NULL_TREE; 73318334Speter 73418334Speter dtype = TYPE_MAIN_VARIANT (dtype); 73518334Speter 73618334Speter /* Conversion between aggregate types. New C++ semantics allow 73718334Speter objects of derived type to be cast to objects of base type. 73818334Speter Old semantics only allowed this between pointers. 73918334Speter 74018334Speter There may be some ambiguity between using a constructor 74118334Speter vs. using a type conversion operator when both apply. */ 74218334Speter 74350397Sobrien ctor = e; 74418334Speter 74590075Sobrien if (abstract_virtuals_error (NULL_TREE, type)) 74690075Sobrien return error_mark_node; 74752284Sobrien 74850397Sobrien if ((flags & LOOKUP_ONLYCONVERTING) 74950397Sobrien && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype))) 75050397Sobrien /* For copy-initialization, first we create a temp of the proper type 75150397Sobrien with a user-defined conversion sequence, then we direct-initialize 75250397Sobrien the target with the temp (see [dcl.init]). */ 75350397Sobrien ctor = build_user_type_conversion (type, ctor, flags); 75490075Sobrien else 755117395Skan ctor = build_special_member_call (NULL_TREE, 756117395Skan complete_ctor_identifier, 757117395Skan build_tree_list (NULL_TREE, ctor), 758117395Skan TYPE_BINFO (type), flags); 75950397Sobrien if (ctor) 76050397Sobrien return build_cplus_new (type, ctor); 76118334Speter } 76218334Speter 76318334Speter if (flags & LOOKUP_COMPLAIN) 76490075Sobrien error ("conversion from `%T' to non-scalar type `%T' requested", 76518334Speter TREE_TYPE (expr), type); 76618334Speter if (flags & LOOKUP_SPECULATIVELY) 76718334Speter return NULL_TREE; 76818334Speter return error_mark_node; 76918334Speter} 77018334Speter 77190075Sobrien/* When an expression is used in a void context, its value is discarded and 77290075Sobrien no lvalue-rvalue and similar conversions happen [expr.static.cast/4, 77390075Sobrien stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type 77490075Sobrien in a void context. The C++ standard does not define what an `access' to an 775132718Skan object is, but there is reason to believe that it is the lvalue to rvalue 77690075Sobrien conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it 77790075Sobrien accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8 77890075Sobrien indicates that volatile semantics should be the same between C and C++ 77990075Sobrien where ever possible. C leaves it implementation defined as to what 78090075Sobrien constitutes an access to a volatile. So, we interpret `*vp' as a read of 78190075Sobrien the volatile object `vp' points to, unless that is an incomplete type. For 78290075Sobrien volatile references we do not do this interpretation, because that would 78390075Sobrien make it impossible to ignore the reference return value from functions. We 78490075Sobrien issue warnings in the confusing cases. 78590075Sobrien 78690075Sobrien IMPLICIT is tells us the context of an implicit void conversion. */ 78790075Sobrien 78890075Sobrientree 789132718Skanconvert_to_void (tree expr, const char *implicit) 79090075Sobrien{ 79190075Sobrien if (expr == error_mark_node 79290075Sobrien || TREE_TYPE (expr) == error_mark_node) 79390075Sobrien return error_mark_node; 79490075Sobrien if (!TREE_TYPE (expr)) 79590075Sobrien return expr; 796132718Skan if (invalid_nonstatic_memfn_p (expr)) 797132718Skan return error_mark_node; 798146895Skan if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) 799146895Skan { 800146895Skan error ("pseudo-destructor is not called"); 801146895Skan return error_mark_node; 802146895Skan } 80390075Sobrien if (VOID_TYPE_P (TREE_TYPE (expr))) 80490075Sobrien return expr; 80590075Sobrien switch (TREE_CODE (expr)) 80690075Sobrien { 80790075Sobrien case COND_EXPR: 80890075Sobrien { 80990075Sobrien /* The two parts of a cond expr might be separate lvalues. */ 81090075Sobrien tree op1 = TREE_OPERAND (expr,1); 81190075Sobrien tree op2 = TREE_OPERAND (expr,2); 812132718Skan tree new_op1 = convert_to_void 813132718Skan (op1, (implicit && !TREE_SIDE_EFFECTS (op2) 814132718Skan ? "second operand of conditional" : NULL)); 815132718Skan tree new_op2 = convert_to_void 816132718Skan (op2, (implicit && !TREE_SIDE_EFFECTS (op1) 817132718Skan ? "third operand of conditional" : NULL)); 81890075Sobrien 81996263Sobrien expr = build (COND_EXPR, TREE_TYPE (new_op1), 82090075Sobrien TREE_OPERAND (expr, 0), new_op1, new_op2); 82190075Sobrien break; 82290075Sobrien } 82390075Sobrien 82490075Sobrien case COMPOUND_EXPR: 82590075Sobrien { 82690075Sobrien /* The second part of a compound expr contains the value. */ 82790075Sobrien tree op1 = TREE_OPERAND (expr,1); 828132718Skan tree new_op1 = convert_to_void 829132718Skan (op1, (implicit && !TREE_NO_UNUSED_WARNING (expr) 830132718Skan ? "right-hand operand of comma" : NULL)); 83190075Sobrien 83290075Sobrien if (new_op1 != op1) 83390075Sobrien { 83490075Sobrien tree t = build (COMPOUND_EXPR, TREE_TYPE (new_op1), 83590075Sobrien TREE_OPERAND (expr, 0), new_op1); 83690075Sobrien expr = t; 83790075Sobrien } 83890075Sobrien 83990075Sobrien break; 84090075Sobrien } 84190075Sobrien 84290075Sobrien case NON_LVALUE_EXPR: 84390075Sobrien case NOP_EXPR: 844117395Skan /* These have already decayed to rvalue. */ 84590075Sobrien break; 84690075Sobrien 847132718Skan case CALL_EXPR: /* We have a special meaning for volatile void fn(). */ 84890075Sobrien break; 84990075Sobrien 85090075Sobrien case INDIRECT_REF: 85190075Sobrien { 85290075Sobrien tree type = TREE_TYPE (expr); 85390075Sobrien int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) 85490075Sobrien == REFERENCE_TYPE; 85590075Sobrien int is_volatile = TYPE_VOLATILE (type); 85690075Sobrien int is_complete = COMPLETE_TYPE_P (complete_type (type)); 85790075Sobrien 85890075Sobrien if (is_volatile && !is_complete) 85990075Sobrien warning ("object of incomplete type `%T' will not be accessed in %s", 86090075Sobrien type, implicit ? implicit : "void context"); 86190075Sobrien else if (is_reference && is_volatile) 86290075Sobrien warning ("object of type `%T' will not be accessed in %s", 86390075Sobrien TREE_TYPE (TREE_OPERAND (expr, 0)), 86490075Sobrien implicit ? implicit : "void context"); 86590075Sobrien if (is_reference || !is_volatile || !is_complete) 86690075Sobrien expr = TREE_OPERAND (expr, 0); 86790075Sobrien 86890075Sobrien break; 86990075Sobrien } 87090075Sobrien 87190075Sobrien case VAR_DECL: 87290075Sobrien { 87390075Sobrien /* External variables might be incomplete. */ 87490075Sobrien tree type = TREE_TYPE (expr); 87590075Sobrien int is_complete = COMPLETE_TYPE_P (complete_type (type)); 87690075Sobrien 87790075Sobrien if (TYPE_VOLATILE (type) && !is_complete) 87890075Sobrien warning ("object `%E' of incomplete type `%T' will not be accessed in %s", 87990075Sobrien expr, type, implicit ? implicit : "void context"); 88090075Sobrien break; 88190075Sobrien } 88290075Sobrien 88390075Sobrien default:; 88490075Sobrien } 88590075Sobrien { 88690075Sobrien tree probe = expr; 88790075Sobrien 88890075Sobrien if (TREE_CODE (probe) == ADDR_EXPR) 88990075Sobrien probe = TREE_OPERAND (expr, 0); 89090075Sobrien if (type_unknown_p (probe)) 89190075Sobrien { 89290075Sobrien /* [over.over] enumerates the places where we can take the address 89390075Sobrien of an overloaded function, and this is not one of them. */ 89490075Sobrien pedwarn ("%s cannot resolve address of overloaded function", 89590075Sobrien implicit ? implicit : "void cast"); 896132718Skan expr = void_zero_node; 89790075Sobrien } 89890075Sobrien else if (implicit && probe == expr && is_overloaded_fn (probe)) 89990075Sobrien /* Only warn when there is no &. */ 90090075Sobrien warning ("%s is a reference, not call, to function `%E'", 90190075Sobrien implicit, expr); 90290075Sobrien } 90390075Sobrien 90490075Sobrien if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr))) 90590075Sobrien { 906132718Skan if (implicit && !TREE_SIDE_EFFECTS (expr) && warn_unused_value) 907132718Skan warning ("%s has no effect", implicit); 908132718Skan expr = build1 (CONVERT_EXPR, void_type_node, expr); 90990075Sobrien } 91090075Sobrien return expr; 91190075Sobrien} 91290075Sobrien 91318334Speter/* Create an expression whose value is that of EXPR, 91418334Speter converted to type TYPE. The TREE_TYPE of the value 91518334Speter is always TYPE. This function implements all reasonable 91618334Speter conversions; callers should filter out those that are 91750397Sobrien not permitted by the language being compiled. 91818334Speter 91950397Sobrien Most of this routine is from build_reinterpret_cast. 92050397Sobrien 92150397Sobrien The backend cannot call cp_convert (what was convert) because 92250397Sobrien conversions to/from basetypes may involve memory references 92350397Sobrien (vbases) and adding or subtracting small values (multiple 92450397Sobrien inheritance), but it calls convert from the constant folding code 92590075Sobrien on subtrees of already built trees after it has ripped them apart. 92650397Sobrien 92750397Sobrien Also, if we ever support range variables, we'll probably also have to 92850397Sobrien do a little bit more work. */ 92950397Sobrien 93018334Spetertree 931132718Skanconvert (tree type, tree expr) 93218334Speter{ 93350397Sobrien tree intype; 93450397Sobrien 93550397Sobrien if (type == error_mark_node || expr == error_mark_node) 93650397Sobrien return error_mark_node; 93750397Sobrien 93850397Sobrien intype = TREE_TYPE (expr); 93950397Sobrien 94050397Sobrien if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype)) 94150397Sobrien { 94290075Sobrien expr = decl_constant_value (expr); 94350397Sobrien return fold (build1 (NOP_EXPR, type, expr)); 94450397Sobrien } 94550397Sobrien 94650397Sobrien return ocp_convert (type, expr, CONV_OLD_CONVERT, 94750397Sobrien LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); 94818334Speter} 94918334Speter 95050397Sobrien/* Like cp_convert, except permit conversions to take place which 95118334Speter are not normally allowed due to access restrictions 95218334Speter (such as conversion from sub-type to private super-type). */ 95350397Sobrien 95418334Spetertree 955132718Skanconvert_force (tree type, tree expr, int convtype) 95618334Speter{ 957132718Skan tree e = expr; 958132718Skan enum tree_code code = TREE_CODE (type); 95918334Speter 96018334Speter if (code == REFERENCE_TYPE) 96118334Speter return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN, 96218334Speter NULL_TREE)); 96318334Speter else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE) 96418334Speter e = convert_from_reference (e); 96518334Speter 96618334Speter if (code == POINTER_TYPE) 96718334Speter return fold (convert_to_pointer_force (type, e)); 96818334Speter 96918334Speter /* From typeck.c convert_for_assignment */ 97018334Speter if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR 97118334Speter && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE 97218334Speter && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) 97318334Speter || integer_zerop (e) 97418334Speter || TYPE_PTRMEMFUNC_P (TREE_TYPE (e))) 97518334Speter && TYPE_PTRMEMFUNC_P (type)) 97618334Speter { 97750397Sobrien /* compatible pointer to member functions. */ 97818334Speter return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1); 97918334Speter } 98018334Speter 98150397Sobrien return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL); 98218334Speter} 98318334Speter 98418334Speter/* Convert an aggregate EXPR to type XTYPE. If a conversion 98518334Speter exists, return the attempted conversion. This may 98618334Speter return ERROR_MARK_NODE if the conversion is not 98718334Speter allowed (references private members, etc). 98818334Speter If no conversion exists, NULL_TREE is returned. 98918334Speter 99018334Speter FIXME: Ambiguity checking is wrong. Should choose one by the implicit 99118334Speter object parameter, or by the second standard conversion sequence if 99218334Speter that doesn't do it. This will probably wait for an overloading rewrite. 99318334Speter (jason 8/9/95) */ 99418334Speter 99518334Spetertree 996132718Skanbuild_type_conversion (tree xtype, tree expr) 99718334Speter{ 99818334Speter /* C++: check to see if we can convert this aggregate type 99918334Speter into the required type. */ 1000117395Skan return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL); 100118334Speter} 100218334Speter 100318334Speter/* Convert the given EXPR to one of a group of types suitable for use in an 100418334Speter expression. DESIRES is a combination of various WANT_* flags (q.v.) 1005132718Skan which indicates which types are suitable. If COMPLAIN is true, complain 100618334Speter about ambiguity; otherwise, the caller will deal with it. */ 100718334Speter 100818334Spetertree 1009132718Skanbuild_expr_type_conversion (int desires, tree expr, bool complain) 101018334Speter{ 101118334Speter tree basetype = TREE_TYPE (expr); 101252284Sobrien tree conv = NULL_TREE; 101318334Speter tree winner = NULL_TREE; 101418334Speter 101552284Sobrien if (expr == null_node 101652284Sobrien && (desires & WANT_INT) 101752284Sobrien && !(desires & WANT_NULL)) 101890075Sobrien warning ("converting NULL to non-pointer type"); 101952284Sobrien 102018334Speter expr = convert_from_reference (expr); 102118334Speter basetype = TREE_TYPE (expr); 102218334Speter 102390075Sobrien if (basetype == error_mark_node) 102490075Sobrien return error_mark_node; 102590075Sobrien 102618334Speter if (! IS_AGGR_TYPE (basetype)) 102718334Speter switch (TREE_CODE (basetype)) 102818334Speter { 102918334Speter case INTEGER_TYPE: 103052284Sobrien if ((desires & WANT_NULL) && null_ptr_cst_p (expr)) 103118334Speter return expr; 103250397Sobrien /* else fall through... */ 103318334Speter 1034161651Skan case VECTOR_TYPE: 103518334Speter case BOOLEAN_TYPE: 103618334Speter return (desires & WANT_INT) ? expr : NULL_TREE; 103718334Speter case ENUMERAL_TYPE: 103818334Speter return (desires & WANT_ENUM) ? expr : NULL_TREE; 103918334Speter case REAL_TYPE: 104018334Speter return (desires & WANT_FLOAT) ? expr : NULL_TREE; 104118334Speter case POINTER_TYPE: 104218334Speter return (desires & WANT_POINTER) ? expr : NULL_TREE; 104318334Speter 104418334Speter case FUNCTION_TYPE: 104518334Speter case ARRAY_TYPE: 1046132718Skan return (desires & WANT_POINTER) ? decay_conversion (expr) 104718334Speter : NULL_TREE; 104818334Speter default: 104918334Speter return NULL_TREE; 105018334Speter } 105118334Speter 105250397Sobrien /* The code for conversions from class type is currently only used for 105350397Sobrien delete expressions. Other expressions are handled by build_new_op. */ 1054132718Skan if (!complete_type_or_else (basetype, expr)) 1055132718Skan return error_mark_node; 1056132718Skan if (!TYPE_HAS_CONVERSION (basetype)) 105718334Speter return NULL_TREE; 105818334Speter 105918334Speter for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv)) 106018334Speter { 106118334Speter int win = 0; 106218334Speter tree candidate; 106350397Sobrien tree cand = TREE_VALUE (conv); 106418334Speter 106550397Sobrien if (winner && winner == cand) 106618334Speter continue; 106718334Speter 1068132718Skan candidate = non_reference (TREE_TYPE (TREE_TYPE (cand))); 106918334Speter 107018334Speter switch (TREE_CODE (candidate)) 107118334Speter { 107218334Speter case BOOLEAN_TYPE: 107318334Speter case INTEGER_TYPE: 107418334Speter win = (desires & WANT_INT); break; 107518334Speter case ENUMERAL_TYPE: 107618334Speter win = (desires & WANT_ENUM); break; 107718334Speter case REAL_TYPE: 107818334Speter win = (desires & WANT_FLOAT); break; 107918334Speter case POINTER_TYPE: 108018334Speter win = (desires & WANT_POINTER); break; 108150397Sobrien 108250397Sobrien default: 108350397Sobrien break; 108418334Speter } 108518334Speter 108618334Speter if (win) 108718334Speter { 108818334Speter if (winner) 108918334Speter { 109018334Speter if (complain) 109118334Speter { 109290075Sobrien error ("ambiguous default type conversion from `%T'", 109318334Speter basetype); 109490075Sobrien error (" candidate conversions include `%D' and `%D'", 109550397Sobrien winner, cand); 109618334Speter } 109718334Speter return error_mark_node; 109818334Speter } 109918334Speter else 110050397Sobrien winner = cand; 110118334Speter } 110218334Speter } 110318334Speter 110418334Speter if (winner) 110550397Sobrien { 1106132718Skan tree type = non_reference (TREE_TYPE (TREE_TYPE (winner))); 110750397Sobrien return build_user_type_conversion (type, expr, LOOKUP_NORMAL); 110850397Sobrien } 110918334Speter 111018334Speter return NULL_TREE; 111118334Speter} 111218334Speter 111350397Sobrien/* Implements integral promotion (4.1) and float->double promotion. */ 111418334Speter 111518334Spetertree 1116132718Skantype_promotes_to (tree type) 111718334Speter{ 111818334Speter if (type == error_mark_node) 111918334Speter return error_mark_node; 112018334Speter 112118334Speter type = TYPE_MAIN_VARIANT (type); 112218334Speter 112318334Speter /* bool always promotes to int (not unsigned), even if it's the same 112418334Speter size. */ 112518334Speter if (type == boolean_type_node) 112618334Speter type = integer_type_node; 112718334Speter 112818334Speter /* Normally convert enums to int, but convert wide enums to something 112918334Speter wider. */ 113018334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE 113118334Speter || type == wchar_type_node) 113218334Speter { 113318334Speter int precision = MAX (TYPE_PRECISION (type), 113418334Speter TYPE_PRECISION (integer_type_node)); 1135117395Skan tree totype = c_common_type_for_size (precision, 0); 113618334Speter if (TREE_UNSIGNED (type) 113718334Speter && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) 1138117395Skan type = c_common_type_for_size (precision, 1); 113918334Speter else 114018334Speter type = totype; 114118334Speter } 114290075Sobrien else if (c_promoting_integer_type_p (type)) 114318334Speter { 114450397Sobrien /* Retain unsignedness if really not getting bigger. */ 114518334Speter if (TREE_UNSIGNED (type) 114650397Sobrien && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 114718334Speter type = unsigned_type_node; 114818334Speter else 114918334Speter type = integer_type_node; 115018334Speter } 115118334Speter else if (type == float_type_node) 115218334Speter type = double_type_node; 1153132718Skan 1154132718Skan return type; 115518334Speter} 115650397Sobrien 115750397Sobrien/* The routines below this point are carefully written to conform to 115850397Sobrien the standard. They use the same terminology, and follow the rules 115950397Sobrien closely. Although they are used only in pt.c at the moment, they 116050397Sobrien should presumably be used everywhere in the future. */ 116150397Sobrien 116250397Sobrien/* Attempt to perform qualification conversions on EXPR to convert it 116350397Sobrien to TYPE. Return the resulting expression, or error_mark_node if 116450397Sobrien the conversion was impossible. */ 116550397Sobrien 116650397Sobrientree 1167132718Skanperform_qualification_conversions (tree type, tree expr) 116850397Sobrien{ 1169132718Skan tree expr_type; 1170132718Skan 1171132718Skan expr_type = TREE_TYPE (expr); 1172132718Skan 1173132718Skan if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type) 1174132718Skan && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type))) 1175132718Skan return build_nop (type, expr); 1176132718Skan else if (TYPE_PTR_TO_MEMBER_P (type) 1177132718Skan && TYPE_PTR_TO_MEMBER_P (expr_type) 1178132718Skan && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type), 1179132718Skan TYPE_PTRMEM_CLASS_TYPE (expr_type)) 1180132718Skan && comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type), 1181132718Skan TYPE_PTRMEM_POINTED_TO_TYPE (expr_type))) 1182132718Skan return build_nop (type, expr); 118350397Sobrien else 118450397Sobrien return error_mark_node; 118550397Sobrien} 1186