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