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