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