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 (TYPE_SIZE (intype) == NULL_TREE)
  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   if (TREE_READONLY_DECL_P (e))
 677     e = decl_constant_value (e);
 678
 679   if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
 680       /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
 681          don't go through finish_struct, so they don't have the synthesized
 682          constructors.  So don't force a temporary.  */
 683       && TYPE_HAS_CONSTRUCTOR (type))
 684     /* We need a new temporary; don't take this shortcut.  */;
 685   else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
 686     {
 687       if (same_type_p (type, TREE_TYPE (e)))
 688         /* The call to fold will not always remove the NOP_EXPR as
 689            might be expected, since if one of the types is a typedef;
 690            the comparsion in fold is just equality of pointers, not a
 691            call to comptypes.  We don't call fold in this case because
 692            that can result in infinite recursion; fold will call
 693            convert, which will call ocp_convert, etc.  */
 694         return e;
 695       else
 696         return fold (build1 (NOP_EXPR, type, e));
 697     }
 698
 699   if (code == VOID_TYPE && (convtype & CONV_STATIC))
 700     {
 701       e = convert_to_void (e, /*implicit=*/NULL);
 702       return e;
 703     }
 704
 705   /* Just convert to the type of the member.  */
 706   if (code == OFFSET_TYPE)
 707     {
 708       type = TREE_TYPE (type);
 709       code = TREE_CODE (type);
 710     }
 711
 712   if (TREE_CODE (e) == OFFSET_REF)
 713     e = resolve_offset_ref (e);
 714
 715   if (INTEGRAL_CODE_P (code))
 716     {
 717       tree intype = TREE_TYPE (e);
 718       /* enum = enum, enum = int, enum = float, (enum)pointer are all
 719          errors.  */
 720       if (TREE_CODE (type) == ENUMERAL_TYPE
 721           && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
 722               || (TREE_CODE (intype) == POINTER_TYPE)))
 723         {
 724           cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
 725
 726           if (flag_pedantic_errors)
 727             return error_mark_node;
 728         }
 729       if (IS_AGGR_TYPE (intype))
 730         {
 731           tree rval;
 732           rval = build_type_conversion (type, e, 1);
 733           if (rval)
 734             return rval;
 735           if (flags & LOOKUP_COMPLAIN)
 736             cp_error ("`%#T' used where a `%T' was expected", intype, type);
 737           if (flags & LOOKUP_SPECULATIVELY)
 738             return NULL_TREE;
 739           return error_mark_node;
 740         }
 741       if (code == BOOLEAN_TYPE)
 742         {
 743           tree fn = NULL_TREE;
 744
 745           /* Common Ada/Pascal programmer's mistake.  We always warn
 746              about this since it is so bad.  */
 747           if (TREE_CODE (expr) == FUNCTION_DECL)
 748             fn = expr;
 749           else if (TREE_CODE (expr) == ADDR_EXPR
 750                    && TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL)
 751             fn = TREE_OPERAND (expr, 0);
 752           if (fn)
 753             cp_warning ("the address of `%D', will always be `true'", fn);
 754           return truthvalue_conversion (e);
 755         }
 756       return fold (convert_to_integer (type, e));
 757     }
 758   if (code == POINTER_TYPE || code == REFERENCE_TYPE
 759       || TYPE_PTRMEMFUNC_P (type))
 760     return fold (cp_convert_to_pointer (type, e));
 761   if (code == REAL_TYPE || code == COMPLEX_TYPE)
 762     {
 763       if (IS_AGGR_TYPE (TREE_TYPE (e)))
 764         {
 765           tree rval;
 766           rval = build_type_conversion (type, e, 1);
 767           if (rval)
 768             return rval;
 769           else
 770             if (flags & LOOKUP_COMPLAIN)
 771               cp_error ("`%#T' used where a floating point value was expected",
 772                         TREE_TYPE (e));
 773         }
 774       if (code == REAL_TYPE)
 775         return fold (convert_to_real (type, e));
 776       else if (code == COMPLEX_TYPE)
 777         return fold (convert_to_complex (type, e));
 778     }
 779
 780   /* New C++ semantics:  since assignment is now based on
 781      memberwise copying,  if the rhs type is derived from the
 782      lhs type, then we may still do a conversion.  */
 783   if (IS_AGGR_TYPE_CODE (code))
 784     {
 785       tree dtype = TREE_TYPE (e);
 786       tree ctor = NULL_TREE;
 787
 788       dtype = TYPE_MAIN_VARIANT (dtype);
 789
 790       /* Conversion between aggregate types.  New C++ semantics allow
 791          objects of derived type to be cast to objects of base type.
 792          Old semantics only allowed this between pointers.
 793
 794          There may be some ambiguity between using a constructor
 795          vs. using a type conversion operator when both apply.  */
 796
 797       ctor = e;
 798
 799       if (abstract_virtuals_error (NULL_TREE, type))
 800         return error_mark_node;
 801
 802       if ((flags & LOOKUP_ONLYCONVERTING)
 803           && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
 804         /* For copy-initialization, first we create a temp of the proper type
 805            with a user-defined conversion sequence, then we direct-initialize
 806            the target with the temp (see [dcl.init]).  */
 807         ctor = build_user_type_conversion (type, ctor, flags);
 808       if (ctor)
 809         ctor = build_method_call (NULL_TREE, ctor_identifier,
 810                                   build_tree_list (NULL_TREE, ctor),
 811                                   TYPE_BINFO (type), flags);
 812       if (ctor)
 813         return build_cplus_new (type, ctor);
 814     }
 815
 816   /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
 817      then it won't be hashed and hence compare as not equal,
 818      even when it is.  */
 819   if (code == ARRAY_TYPE
 820       && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
 821       && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
 822     return e;
 823
 824   if (flags & LOOKUP_COMPLAIN)
 825     cp_error ("conversion from `%T' to non-scalar type `%T' requested",
 826               TREE_TYPE (expr), type);
 827   if (flags & LOOKUP_SPECULATIVELY)
 828     return NULL_TREE;
 829   return error_mark_node;
 830 }
 831
 832 /* When an expression is used in a void context, its value is discarded and
 833    no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
 834    stmt.expr/1, expr.comma/1].  This permits dereferencing an incomplete type
 835    in a void context. The C++ standard does not define what an `access' to an
 836    object is, but there is reason to beleive that it is the lvalue to rvalue
 837    conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
 838    accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
 839    indicates that volatile semantics should be the same between C and C++
 840    where ever possible. C leaves it implementation defined as to what
 841    constitutes an access to a volatile. So, we interpret `*vp' as a read of
 842    the volatile object `vp' points to, unless that is an incomplete type. For
 843    volatile references we do not do this interpretation, because that would
 844    make it impossible to ignore the reference return value from functions. We
 845    issue warnings in the confusing cases.
 846
 847    IMPLICIT is tells us the context of an implicit void conversion.  */
 848
 849 tree
 850 convert_to_void (expr, implicit)
 851      tree expr;
 852      const char *implicit;
 853 {
 854   if (expr == error_mark_node
 855       || TREE_TYPE (expr) == error_mark_node)
 856     return error_mark_node;
 857   if (!TREE_TYPE (expr))
 858     return expr;
 859   if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 860     return expr;
 861   switch (TREE_CODE (expr))
 862     {
 863     case COND_EXPR:
 864       {
 865         /* The two parts of a cond expr might be separate lvalues.  */
 866         tree op1 = TREE_OPERAND (expr,1);
 867         tree op2 = TREE_OPERAND (expr,2);
 868         tree new_op1 = convert_to_void (op1, implicit);
 869         tree new_op2 = convert_to_void (op2, implicit);
 870
 871         if (new_op1 != op1 || new_op2 != op2)
 872           expr = build (COND_EXPR,
 873                         implicit ? TREE_TYPE (expr) : void_type_node,
 874                         TREE_OPERAND (expr, 0), new_op1, new_op2);
 875         break;
 876       }
 877
 878     case COMPOUND_EXPR:
 879       {
 880         /* The second part of a compound expr contains the value.  */
 881         tree op1 = TREE_OPERAND (expr,1);
 882         tree new_op1 = convert_to_void (op1, implicit);
 883
 884         if (new_op1 != op1)
 885           expr = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
 886                         TREE_OPERAND (expr, 0), new_op1);
 887         break;
 888       }
 889
 890     case NON_LVALUE_EXPR:
 891     case NOP_EXPR:
 892       /* These have already decayed to rvalue. */
 893       break;
 894
 895     case CALL_EXPR:   /* we have a special meaning for volatile void fn() */
 896       break;
 897
 898     case INDIRECT_REF:
 899       {
 900         tree type = TREE_TYPE (expr);
 901         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
 902                            == REFERENCE_TYPE;
 903         int is_volatile = TYPE_VOLATILE (type);
 904         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 905
 906         if (is_volatile && !is_complete)
 907           cp_warning ("object of incomplete type `%T' will not be accessed in %s",
 908                       type, implicit ? implicit : "void context");
 909         else if (is_reference && is_volatile)
 910           cp_warning ("object of type `%T' will not be accessed in %s",
 911                       TREE_TYPE (TREE_OPERAND (expr, 0)),
 912                       implicit ? implicit : "void context");
 913         if (is_reference || !is_volatile || !is_complete)
 914           expr = TREE_OPERAND (expr, 0);
 915
 916         break;
 917       }
 918
 919     case VAR_DECL:
 920       {
 921         /* External variables might be incomplete.  */
 922         tree type = TREE_TYPE (expr);
 923         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 924
 925         if (TYPE_VOLATILE (type) && !is_complete)
 926           cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
 927                       expr, type, implicit ? implicit : "void context");
 928         break;
 929       }
 930
 931     default:;
 932     }
 933   {
 934     tree probe = expr;
 935
 936     if (TREE_CODE (probe) == ADDR_EXPR)
 937       probe = TREE_OPERAND (expr, 0);
 938     if (!is_overloaded_fn (probe))
 939       ;/* OK */
 940     else if (really_overloaded_fn (probe))
 941         {
 942           /* [over.over] enumerates the places where we can take the address
 943              of an overloaded function, and this is not one of them.  */
 944           cp_pedwarn ("%s has no context for overloaded function name `%E'",
 945                       implicit ? implicit : "void cast", expr);
 946         }
 947     else if (implicit && probe == expr)
 948       /* Only warn when there is no &.  */
 949       cp_warning ("%s is a reference, not call, to function `%E'",
 950                     implicit, expr);
 951   }
 952
 953   if (expr != error_mark_node
 954       && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 955     {
 956       /* FIXME: This is where we should check for expressions with no
 957          effects.  At the moment we do that in both build_x_component_expr
 958          and expand_expr_stmt -- inconsistently too.  For the moment
 959          leave implicit void conversions unadorned so that expand_expr_stmt
 960          has a chance of detecting some of the cases.  */
 961       if (!implicit)
 962         expr = build1 (CONVERT_EXPR, void_type_node, expr);
 963     }
 964   return expr;
 965 }
 966
 967 /* Create an expression whose value is that of EXPR,
 968    converted to type TYPE.  The TREE_TYPE of the value
 969    is always TYPE.  This function implements all reasonable
 970    conversions; callers should filter out those that are
 971    not permitted by the language being compiled.
 972
 973    Most of this routine is from build_reinterpret_cast.
 974
 975    The backend cannot call cp_convert (what was convert) because
 976    conversions to/from basetypes may involve memory references
 977    (vbases) and adding or subtracting small values (multiple
 978    inheritance), but it calls convert from the constant folding code
 979    on subtrees of already build trees after it has ripped them apart.
 980
 981    Also, if we ever support range variables, we'll probably also have to
 982    do a little bit more work.  */
 983
 984 tree
 985 convert (type, expr)
 986      tree type, expr;
 987 {
 988   tree intype;
 989
 990   if (type == error_mark_node || expr == error_mark_node)
 991     return error_mark_node;
 992
 993   intype = TREE_TYPE (expr);
 994
 995   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
 996     {
 997       if (TREE_READONLY_DECL_P (expr))
 998         expr = decl_constant_value (expr);
 999       return fold (build1 (NOP_EXPR, type, expr));
1000     }
1001
1002   return ocp_convert (type, expr, CONV_OLD_CONVERT,
1003                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1004 }
1005
1006 /* Like cp_convert, except permit conversions to take place which
1007    are not normally allowed due to access restrictions
1008    (such as conversion from sub-type to private super-type).  */
1009
1010 tree
1011 convert_force (type, expr, convtype)
1012      tree type;
1013      tree expr;
1014      int convtype;
1015 {
1016   register tree e = expr;
1017   register enum tree_code code = TREE_CODE (type);
1018
1019   if (code == REFERENCE_TYPE)
1020     return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1021                                        NULL_TREE));
1022   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1023     e = convert_from_reference (e);
1024
1025   if (code == POINTER_TYPE)
1026     return fold (convert_to_pointer_force (type, e));
1027
1028   /* From typeck.c convert_for_assignment */
1029   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1030         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1031         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1032        || integer_zerop (e)
1033        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1034       && TYPE_PTRMEMFUNC_P (type))
1035     {
1036       /* compatible pointer to member functions.  */
1037       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1038     }
1039
1040   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1041 }
1042
1043 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1044    exists, return the attempted conversion.  This may
1045    return ERROR_MARK_NODE if the conversion is not
1046    allowed (references private members, etc).
1047    If no conversion exists, NULL_TREE is returned.
1048
1049    If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1050    to take place immediately.  Otherwise, we build a SAVE_EXPR
1051    which can be evaluated if the results are ever needed.
1052
1053    Changes to this functions should be mirrored in user_harshness.
1054
1055    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1056    object parameter, or by the second standard conversion sequence if
1057    that doesn't do it.  This will probably wait for an overloading rewrite.
1058    (jason 8/9/95)  */
1059
1060 tree
1061 build_type_conversion (xtype, expr, for_sure)
1062      tree xtype, expr;
1063      int for_sure;
1064 {
1065   /* C++: check to see if we can convert this aggregate type
1066      into the required type.  */
1067   return build_user_type_conversion
1068     (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
1069 }
1070
1071 /* Convert the given EXPR to one of a group of types suitable for use in an
1072    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1073    which indicates which types are suitable.  If COMPLAIN is 1, complain
1074    about ambiguity; otherwise, the caller will deal with it.  */
1075
1076 tree
1077 build_expr_type_conversion (desires, expr, complain)
1078      int desires;
1079      tree expr;
1080      int complain;
1081 {
1082   tree basetype = TREE_TYPE (expr);
1083   tree conv = NULL_TREE;
1084   tree winner = NULL_TREE;
1085
1086   if (expr == null_node
1087       && (desires & WANT_INT)
1088       && !(desires & WANT_NULL))
1089     cp_warning ("converting NULL to non-pointer type");
1090
1091   if (TREE_CODE (expr) == OFFSET_REF)
1092     expr = resolve_offset_ref (expr);
1093   expr = convert_from_reference (expr);
1094   basetype = TREE_TYPE (expr);
1095
1096   if (basetype == error_mark_node)
1097     return error_mark_node;
1098
1099   if (! IS_AGGR_TYPE (basetype))
1100     switch (TREE_CODE (basetype))
1101       {
1102       case INTEGER_TYPE:
1103         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1104           return expr;
1105         /* else fall through...  */
1106
1107       case BOOLEAN_TYPE:
1108         return (desires & WANT_INT) ? expr : NULL_TREE;
1109       case ENUMERAL_TYPE:
1110         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1111       case REAL_TYPE:
1112         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1113       case POINTER_TYPE:
1114         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1115
1116       case FUNCTION_TYPE:
1117       case ARRAY_TYPE:
1118         return (desires & WANT_POINTER) ? default_conversion (expr)
1119                                         : NULL_TREE;
1120       default:
1121         return NULL_TREE;
1122       }
1123
1124   /* The code for conversions from class type is currently only used for
1125      delete expressions.  Other expressions are handled by build_new_op.  */
1126
1127   if (! TYPE_HAS_CONVERSION (basetype))
1128     return NULL_TREE;
1129
1130   for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1131     {
1132       int win = 0;
1133       tree candidate;
1134       tree cand = TREE_VALUE (conv);
1135
1136       if (winner && winner == cand)
1137         continue;
1138
1139       candidate = TREE_TYPE (TREE_TYPE (cand));
1140       if (TREE_CODE (candidate) == REFERENCE_TYPE)
1141         candidate = TREE_TYPE (candidate);
1142
1143       switch (TREE_CODE (candidate))
1144         {
1145         case BOOLEAN_TYPE:
1146         case INTEGER_TYPE:
1147           win = (desires & WANT_INT); break;
1148         case ENUMERAL_TYPE:
1149           win = (desires & WANT_ENUM); break;
1150         case REAL_TYPE:
1151           win = (desires & WANT_FLOAT); break;
1152         case POINTER_TYPE:
1153           win = (desires & WANT_POINTER); break;
1154
1155         default:
1156           break;
1157         }
1158
1159       if (win)
1160         {
1161           if (winner)
1162             {
1163               if (complain)
1164                 {
1165                   cp_error ("ambiguous default type conversion from `%T'",
1166                             basetype);
1167                   cp_error ("  candidate conversions include `%D' and `%D'",
1168                             winner, cand);
1169                 }
1170               return error_mark_node;
1171             }
1172           else
1173             winner = cand;
1174         }
1175     }
1176
1177   if (winner)
1178     {
1179       tree type = TREE_TYPE (TREE_TYPE (winner));
1180       if (TREE_CODE (type) == REFERENCE_TYPE)
1181         type = TREE_TYPE (type);
1182       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1183     }
1184
1185   return NULL_TREE;
1186 }
1187
1188 /* Implements integral promotion (4.1) and float->double promotion.  */
1189
1190 tree
1191 type_promotes_to (type)
1192      tree type;
1193 {
1194   int type_quals;
1195
1196   if (type == error_mark_node)
1197     return error_mark_node;
1198
1199   type_quals = CP_TYPE_QUALS (type);
1200   type = TYPE_MAIN_VARIANT (type);
1201
1202   /* bool always promotes to int (not unsigned), even if it's the same
1203      size.  */
1204   if (type == boolean_type_node)
1205     type = integer_type_node;
1206
1207   /* Normally convert enums to int, but convert wide enums to something
1208      wider.  */
1209   else if (TREE_CODE (type) == ENUMERAL_TYPE
1210            || type == wchar_type_node)
1211     {
1212       int precision = MAX (TYPE_PRECISION (type),
1213                            TYPE_PRECISION (integer_type_node));
1214       tree totype = type_for_size (precision, 0);
1215       if (TREE_UNSIGNED (type)
1216           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1217         type = type_for_size (precision, 1);
1218       else
1219         type = totype;
1220     }
1221   else if (C_PROMOTING_INTEGER_TYPE_P (type))
1222     {
1223       /* Retain unsignedness if really not getting bigger.  */
1224       if (TREE_UNSIGNED (type)
1225           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1226         type = unsigned_type_node;
1227       else
1228         type = integer_type_node;
1229     }
1230   else if (type == float_type_node)
1231     type = double_type_node;
1232
1233   return cp_build_qualified_type (type, type_quals);
1234 }
1235
1236 /* The routines below this point are carefully written to conform to
1237    the standard.  They use the same terminology, and follow the rules
1238    closely.  Although they are used only in pt.c at the moment, they
1239    should presumably be used everywhere in the future.  */
1240
1241 /* Attempt to perform qualification conversions on EXPR to convert it
1242    to TYPE.  Return the resulting expression, or error_mark_node if
1243    the conversion was impossible.  */
1244
1245 tree
1246 perform_qualification_conversions (type, expr)
1247      tree type;
1248      tree expr;
1249 {
1250   if (TREE_CODE (type) == POINTER_TYPE
1251       && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1252       && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1253     return build1 (NOP_EXPR, type, expr);
1254   else
1255     return error_mark_node;
1256 }