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