contrib/gcc-3.4/gcc/cp/cvt.c

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