gcc/cp/cvt.c

   1 /* Language-level data type conversion for GNU C++.
   2    Copyright (C) 1987-1988, 1992-1999 Free Software Foundation, Inc.
   3    Hacked by Michael Tiemann (tiemann@cygnus.com)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* This file contains the functions for converting C expressions
  24    to different data types.  The only entry point is `convert'.
  25    Every language front end must have a `convert' function
  26    but what kind of conversions it does will depend on the language.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "tree.h"
  31 #include "flags.h"
  32 #include "cp-tree.h"
  33 #include "convert.h"
  34 #include "toplev.h"
  35 #include "decl.h"
  36
  37 static tree cp_convert_to_pointer PROTO((tree, tree));
  38 static tree convert_to_pointer_force PROTO((tree, tree));
  39 static tree build_up_reference PROTO((tree, tree, int));
  40
  41 /* Change of width--truncation and extension of integers or reals--
  42    is represented with NOP_EXPR.  Proper functioning of many things
  43    assumes that no other conversions can be NOP_EXPRs.
  44
  45    Conversion between integer and pointer is represented with CONVERT_EXPR.
  46    Converting integer to real uses FLOAT_EXPR
  47    and real to integer uses FIX_TRUNC_EXPR.
  48
  49    Here is a list of all the functions that assume that widening and
  50    narrowing is always done with a NOP_EXPR:
  51      In convert.c, convert_to_integer.
  52      In c-typeck.c, build_binary_op_nodefault (boolean ops),
  53         and truthvalue_conversion.
  54      In expr.c: expand_expr, for operands of a MULT_EXPR.
  55      In fold-const.c: fold.
  56      In tree.c: get_narrower and get_unwidened.
  57
  58    C++: in multiple-inheritance, converting between pointers may involve
  59    adjusting them by a delta stored within the class definition.  */
  60 \f
  61 /* Subroutines of `convert'.  */
  62
  63 /* if converting pointer to pointer
  64      if dealing with classes, check for derived->base or vice versa
  65      else if dealing with method pointers, delegate
  66      else convert blindly
  67    else if converting class, pass off to build_type_conversion
  68    else try C-style pointer conversion  */
  69
  70 static tree
  71 cp_convert_to_pointer (type, expr)
  72      tree type, expr;
  73 {
  74   register tree intype = TREE_TYPE (expr);
  75   register enum tree_code form;
  76   tree rval;
  77
  78   if (IS_AGGR_TYPE (intype))
  79     {
  80       intype = complete_type (intype);
  81       if (TYPE_SIZE (intype) == NULL_TREE)
  82         {
  83           cp_error ("can't convert from incomplete type `%T' to `%T'",
  84                     intype, type);
  85           return error_mark_node;
  86         }
  87
  88       rval = build_type_conversion (type, expr, 1);
  89       if (rval)
  90         {
  91           if (rval == error_mark_node)
  92             cp_error ("conversion of `%E' from `%T' to `%T' is ambiguous",
  93                       expr, intype, type);
  94           return rval;
  95         }
  96     }
  97
  98   /* Handle anachronistic conversions from (::*)() to cv void* or (*)().  */
  99   if (TREE_CODE (type) == POINTER_TYPE
 100       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
 101           || TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node))
 102     {
 103       /* Allow an implicit this pointer for pointer to member
 104          functions.  */
 105       if (TYPE_PTRMEMFUNC_P (intype))
 106         {
 107           tree fntype = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype));
 108           tree decl = maybe_dummy_object (TYPE_METHOD_BASETYPE (fntype), 0);
 109           expr = build (OFFSET_REF, fntype, decl, expr);
 110         }
 111
 112       if (TREE_CODE (expr) == OFFSET_REF
 113           && TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
 114         expr = resolve_offset_ref (expr);
 115       if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
 116         expr = build_addr_func (expr);
 117       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
 118         {
 119           if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
 120             if (pedantic || warn_pmf2ptr)
 121               cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
 122                           type);
 123           return build1 (NOP_EXPR, type, expr);
 124         }
 125       intype = TREE_TYPE (expr);
 126     }
 127
 128   form = TREE_CODE (intype);
 129
 130   if (POINTER_TYPE_P (intype))
 131     {
 132       intype = TYPE_MAIN_VARIANT (intype);
 133
 134       if (TYPE_MAIN_VARIANT (type) != intype
 135           && TREE_CODE (type) == POINTER_TYPE
 136           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
 137           && IS_AGGR_TYPE (TREE_TYPE (type))
 138           && IS_AGGR_TYPE (TREE_TYPE (intype))
 139           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
 140           /* If EXPR is NULL, then we don't need to do any arithmetic
 141              to convert it:
 142
 143                [conv.ptr]
 144
 145                The null pointer value is converted to the null pointer
 146                value of the destination type.  */
 147           && !integer_zerop (expr))
 148         {
 149           enum tree_code code = PLUS_EXPR;
 150           tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
 151           if (binfo == error_mark_node)
 152             return error_mark_node;
 153           if (binfo == NULL_TREE)
 154             {
 155               binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
 156               if (binfo == error_mark_node)
 157                 return error_mark_node;
 158               code = MINUS_EXPR;
 159             }
 160           if (binfo)
 161             {
 162               if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
 163                   || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
 164                   || ! BINFO_OFFSET_ZEROP (binfo))
 165                 {
 166                   /* Need to get the path we took.  */
 167                   tree path;
 168
 169                   if (code == PLUS_EXPR)
 170                     get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
 171                                        0, &path);
 172                   else
 173                     get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
 174                                        0, &path);
 175                   return build_vbase_path (code, type, expr, path, 0);
 176                 }
 177             }
 178         }
 179
 180       if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
 181         {
 182           tree b1;
 183           tree b2;
 184           tree binfo;
 185           enum tree_code code;
 186
 187           b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
 188           b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
 189           binfo = get_binfo (b2, b1, 1);
 190
 191           if (binfo == NULL_TREE)
 192             {
 193               binfo = get_binfo (b1, b2, 1);
 194               code = MINUS_EXPR;
 195             }
 196           else
 197             code = PLUS_EXPR;
 198
 199           if (binfo == error_mark_node)
 200             return error_mark_node;
 201
 202           if (binfo_from_vbase (binfo))
 203             {
 204               cp_error ("conversion to `%T' from pointer to member of virtual base `%T'",
 205                         type, intype);
 206               return error_mark_node;
 207             }
 208
 209           if (TREE_CODE (expr) == PTRMEM_CST)
 210             expr = cplus_expand_constant (expr);
 211
 212           if (binfo && ! TREE_VIA_VIRTUAL (binfo))
 213             expr = size_binop (code, expr, BINFO_OFFSET (binfo));
 214         }
 215       else if (TYPE_PTRMEMFUNC_P (type))
 216         {
 217           cp_error ("cannot convert `%E' from type `%T' to type `%T'",
 218                     expr, intype, type);
 219           return error_mark_node;
 220         }
 221
 222       rval = build1 (NOP_EXPR, type, expr);
 223       TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
 224       return rval;
 225     }
 226   else if (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))
 227     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
 228   else if (TYPE_PTRMEMFUNC_P (intype))
 229     {
 230       cp_error ("cannot convert `%E' from type `%T' to type `%T'",
 231                 expr, intype, type);
 232       return error_mark_node;
 233     }
 234
 235   my_friendly_assert (form != OFFSET_TYPE, 186);
 236
 237   if (integer_zerop (expr))
 238     {
 239       if (TYPE_PTRMEMFUNC_P (type))
 240         return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0);
 241       expr = build_int_2 (0, 0);
 242       TREE_TYPE (expr) = type;
 243       return expr;
 244     }
 245
 246   if (INTEGRAL_CODE_P (form))
 247     {
 248       if (TYPE_PRECISION (intype) == POINTER_SIZE)
 249         return build1 (CONVERT_EXPR, type, expr);
 250       expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr);
 251       /* Modes may be different but sizes should be the same.  */
 252       if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
 253           != GET_MODE_SIZE (TYPE_MODE (type)))
 254         /* There is supposed to be some integral type
 255            that is the same width as a pointer.  */
 256         abort ();
 257       return convert_to_pointer (type, expr);
 258     }
 259
 260   if (type_unknown_p (expr))
 261     return instantiate_type (type, expr, 1);
 262
 263   cp_error ("cannot convert `%E' from type `%T' to type `%T'",
 264             expr, intype, type);
 265   return error_mark_node;
 266 }
 267
 268 /* Like convert, except permit conversions to take place which
 269    are not normally allowed due to access restrictions
 270    (such as conversion from sub-type to private super-type).  */
 271
 272 static tree
 273 convert_to_pointer_force (type, expr)
 274      tree type, expr;
 275 {
 276   register tree intype = TREE_TYPE (expr);
 277   register enum tree_code form = TREE_CODE (intype);
 278
 279   if (integer_zerop (expr))
 280     {
 281       expr = build_int_2 (0, 0);
 282       TREE_TYPE (expr) = type;
 283       return expr;
 284     }
 285
 286   if (form == POINTER_TYPE)
 287     {
 288       intype = TYPE_MAIN_VARIANT (intype);
 289
 290       if (TYPE_MAIN_VARIANT (type) != intype
 291           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
 292           && IS_AGGR_TYPE (TREE_TYPE (type))
 293           && IS_AGGR_TYPE (TREE_TYPE (intype))
 294           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
 295         {
 296           enum tree_code code = PLUS_EXPR;
 297           tree path;
 298           int distance = get_base_distance (TREE_TYPE (type),
 299                                             TREE_TYPE (intype), 0, &path);
 300           if (distance == -2)
 301             {
 302             ambig:
 303               cp_error ("type `%T' is ambiguous baseclass of `%s'",
 304                         TREE_TYPE (type),
 305                         TYPE_NAME_STRING (TREE_TYPE (intype)));
 306               return error_mark_node;
 307             }
 308           if (distance == -1)
 309             {
 310               distance = get_base_distance (TREE_TYPE (intype),
 311                                             TREE_TYPE (type), 0, &path);
 312               if (distance == -2)
 313                 goto ambig;
 314               if (distance < 0)
 315                 /* Doesn't need any special help from us.  */
 316                 return build1 (NOP_EXPR, type, expr);
 317
 318               code = MINUS_EXPR;
 319             }
 320           return build_vbase_path (code, type, expr, path, 0);
 321         }
 322     }
 323
 324   return cp_convert_to_pointer (type, expr);
 325 }
 326
 327 /* We are passing something to a function which requires a reference.
 328    The type we are interested in is in TYPE. The initial
 329    value we have to begin with is in ARG.
 330
 331    FLAGS controls how we manage access checking.
 332    DIRECT_BIND in FLAGS controls how any temporaries are generated.  */
 333
 334 static tree
 335 build_up_reference (type, arg, flags)
 336      tree type, arg;
 337      int flags;
 338 {
 339   tree rval;
 340   tree argtype = TREE_TYPE (arg);
 341   tree target_type = TREE_TYPE (type);
 342   tree stmt_expr = NULL_TREE;
 343
 344   my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
 345
 346   if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
 347     {
 348       /* Create a new temporary variable.  */
 349       tree targ = arg;
 350       if (toplevel_bindings_p ())
 351         arg = get_temp_name (argtype, 1);
 352       else
 353         {
 354           arg = pushdecl (build_decl (VAR_DECL, NULL_TREE, argtype));
 355           DECL_ARTIFICIAL (arg) = 1;
 356         }
 357
 358       /* Process the initializer for the declaration.  */
 359       DECL_INITIAL (arg) = targ;
 360       cp_finish_decl (arg, targ, NULL_TREE,
 361                       LOOKUP_ONLYCONVERTING|DIRECT_BIND);
 362     }
 363   else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
 364     return get_target_expr (arg);
 365
 366   /* If we had a way to wrap this up, and say, if we ever needed it's
 367      address, transform all occurrences of the register, into a memory
 368      reference we could win better.  */
 369   rval = build_unary_op (ADDR_EXPR, arg, 1);
 370   if (rval == error_mark_node)
 371     return error_mark_node;
 372
 373   if ((flags & LOOKUP_PROTECT)
 374       && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
 375       && IS_AGGR_TYPE (argtype)
 376       && IS_AGGR_TYPE (target_type))
 377     {
 378       /* We go through get_binfo for the access control.  */
 379       tree binfo = get_binfo (target_type, argtype, 1);
 380       if (binfo == error_mark_node)
 381         return error_mark_node;
 382       if (binfo == NULL_TREE)
 383         return error_not_base_type (target_type, argtype);
 384       rval = convert_pointer_to_real (binfo, rval);
 385     }
 386   else
 387     rval
 388       = convert_to_pointer_force (build_pointer_type (target_type), rval);
 389   rval = build1 (NOP_EXPR, type, rval);
 390   TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
 391
 392   /* If we created and initialized a new temporary variable, add the
 393      representation of that initialization to the RVAL.  */
 394   if (stmt_expr)
 395     rval = build (COMPOUND_EXPR, TREE_TYPE (rval), stmt_expr, rval);
 396
 397   /* And return the result.  */
 398   return rval;
 399 }
 400
 401 /* For C++: Only need to do one-level references, but cannot
 402    get tripped up on signed/unsigned differences.
 403
 404    DECL is either NULL_TREE or the _DECL node for a reference that is being
 405    initialized.  It can be error_mark_node if we don't know the _DECL but
 406    we know it's an initialization.  */
 407
 408 tree
 409 convert_to_reference (reftype, expr, convtype, flags, decl)
 410      tree reftype, expr;
 411      int convtype, flags;
 412      tree decl;
 413 {
 414   register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
 415   register tree intype = TREE_TYPE (expr);
 416   tree rval = NULL_TREE;
 417   tree rval_as_conversion = NULL_TREE;
 418   int i;
 419
 420   if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
 421     {
 422       expr = instantiate_type (type, expr,
 423                                (flags & LOOKUP_COMPLAIN) != 0);
 424       if (expr == error_mark_node)
 425         return error_mark_node;
 426
 427       intype = TREE_TYPE (expr);
 428     }
 429
 430   if (TREE_CODE (intype) == REFERENCE_TYPE)
 431     my_friendly_abort (364);
 432
 433   intype = TYPE_MAIN_VARIANT (intype);
 434
 435   i = comp_target_types (type, intype, 0);
 436
 437   if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
 438       && ! (flags & LOOKUP_NO_CONVERSION))
 439     {
 440       /* Look for a user-defined conversion to lvalue that we can use.  */
 441
 442       rval_as_conversion
 443         = build_type_conversion (reftype, expr, 1);
 444
 445       if (rval_as_conversion && rval_as_conversion != error_mark_node
 446           && real_lvalue_p (rval_as_conversion))
 447         {
 448           expr = rval_as_conversion;
 449           rval_as_conversion = NULL_TREE;
 450           intype = type;
 451           i = 1;
 452         }
 453     }
 454
 455   if (((convtype & CONV_STATIC) && i == -1)
 456       || ((convtype & CONV_IMPLICIT) && i == 1))
 457     {
 458       if (flags & LOOKUP_COMPLAIN)
 459         {
 460           tree ttl = TREE_TYPE (reftype);
 461           tree ttr = lvalue_type (expr);
 462
 463           /* [dcl.init.ref] says that if an rvalue is used to
 464              initialize a reference, then the reference must be to a
 465              non-volatile const type.  */
 466           if (! real_lvalue_p (expr)
 467               && !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
 468             {
 469               const char *msg;
 470
 471               if (CP_TYPE_VOLATILE_P (ttl) && decl)
 472                 msg = "initialization of volatile reference type `%#T'";
 473               else if (CP_TYPE_VOLATILE_P (ttl))
 474                 msg = "conversion to volatile reference type `%#T'";
 475               else if (decl)
 476                 msg = "initialization of non-const reference type `%#T'";
 477               else
 478                 msg = "conversion to non-const reference type `%#T'";
 479
 480               cp_pedwarn (msg, reftype);
 481               cp_pedwarn ("from rvalue of type `%T'", intype);
 482             }
 483           else if (! (convtype & CONV_CONST)
 484                    && !at_least_as_qualified_p (ttl, ttr))
 485             cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
 486                         ttr, reftype);
 487         }
 488
 489       return build_up_reference (reftype, expr, flags);
 490     }
 491   else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
 492     {
 493       /* When casting an lvalue to a reference type, just convert into
 494          a pointer to the new type and deference it.  This is allowed
 495          by San Diego WP section 5.2.9 paragraph 12, though perhaps it
 496          should be done directly (jason).  (int &)ri ---> *(int*)&ri */
 497
 498       /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
 499          meant.  */
 500       if (TREE_CODE (intype) == POINTER_TYPE
 501           && (comptypes (TREE_TYPE (intype), type,
 502                          COMPARE_BASE | COMPARE_RELAXED )))
 503         cp_warning ("casting `%T' to `%T' does not dereference pointer",
 504                     intype, reftype);
 505
 506       rval = build_unary_op (ADDR_EXPR, expr, 0);
 507       if (rval != error_mark_node)
 508         rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
 509                               rval, 0);
 510       if (rval != error_mark_node)
 511         rval = build1 (NOP_EXPR, reftype, rval);
 512     }
 513   else
 514     {
 515       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
 516                                          "converting", 0, 0);
 517       if (rval == NULL_TREE || rval == error_mark_node)
 518         return rval;
 519       rval = build_up_reference (reftype, rval, flags);
 520
 521       if (rval && ! CP_TYPE_CONST_P (TREE_TYPE (reftype)))
 522         cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
 523                     reftype, intype);
 524     }
 525
 526   if (rval)
 527     {
 528       /* If we found a way to convert earlier, then use it.  */
 529       return rval;
 530     }
 531
 532   my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
 533
 534   if (flags & LOOKUP_COMPLAIN)
 535     cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
 536
 537   if (flags & LOOKUP_SPECULATIVELY)
 538     return NULL_TREE;
 539
 540   return error_mark_node;
 541 }
 542
 543 /* We are using a reference VAL for its value. Bash that reference all the
 544    way down to its lowest form.  */
 545
 546 tree
 547 convert_from_reference (val)
 548      tree val;
 549 {
 550   tree type = TREE_TYPE (val);
 551
 552   if (TREE_CODE (type) == OFFSET_TYPE)
 553     type = TREE_TYPE (type);
 554   if (TREE_CODE (type) == REFERENCE_TYPE)
 555     return build_indirect_ref (val, NULL_PTR);
 556   return val;
 557 }
 558 \f
 559 /* Call this when we know (for any reason) that expr is not, in fact,
 560    zero.  This routine is like convert_pointer_to, but it pays
 561    attention to which specific instance of what type we want to
 562    convert to.  This routine should eventually become
 563    convert_to_pointer after all references to convert_to_pointer
 564    are removed.  */
 565
 566 tree
 567 convert_pointer_to_real (binfo, expr)
 568      tree binfo, expr;
 569 {
 570   register tree intype = TREE_TYPE (expr);
 571   tree ptr_type;
 572   tree type, rval;
 573
 574   if (intype == error_mark_node)
 575     return error_mark_node;
 576
 577   if (TREE_CODE (binfo) == TREE_VEC)
 578     type = BINFO_TYPE (binfo);
 579   else if (IS_AGGR_TYPE (binfo))
 580     {
 581       type = binfo;
 582     }
 583   else
 584     {
 585       type = binfo;
 586       binfo = NULL_TREE;
 587     }
 588
 589   ptr_type = cp_build_qualified_type (type,
 590                                       CP_TYPE_QUALS (TREE_TYPE (intype)));
 591   ptr_type = build_pointer_type (ptr_type);
 592   if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
 593     return expr;
 594
 595   my_friendly_assert (!integer_zerop (expr), 191);
 596
 597   intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
 598   if (TREE_CODE (type) == RECORD_TYPE
 599       && TREE_CODE (intype) == RECORD_TYPE
 600       && type != intype)
 601     {
 602       tree path;
 603       int distance
 604         = get_base_distance (binfo, intype, 0, &path);
 605
 606       /* This function shouldn't be called with unqualified arguments
 607          but if it is, give them an error message that they can read.  */
 608       if (distance < 0)
 609         {
 610           cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
 611                     intype, type);
 612
 613           if (distance == -2)
 614             cp_error ("because `%T' is an ambiguous base class", type);
 615           return error_mark_node;
 616         }
 617
 618       return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
 619     }
 620   rval = build1 (NOP_EXPR, ptr_type,
 621                  TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
 622   TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
 623   return rval;
 624 }
 625
 626 /* Call this when we know (for any reason) that expr is
 627    not, in fact, zero.  This routine gets a type out of the first
 628    argument and uses it to search for the type to convert to.  If there
 629    is more than one instance of that type in the expr, the conversion is
 630    ambiguous.  This routine should eventually go away, and all
 631    callers should use convert_to_pointer_real.  */
 632
 633 tree
 634 convert_pointer_to (binfo, expr)
 635      tree binfo, expr;
 636 {
 637   tree type;
 638
 639   if (TREE_CODE (binfo) == TREE_VEC)
 640     type = BINFO_TYPE (binfo);
 641   else if (IS_AGGR_TYPE (binfo))
 642     type = binfo;
 643   else
 644     type = binfo;
 645   return convert_pointer_to_real (type, 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_expr_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     return expr;
 856   if (!TREE_TYPE (expr))
 857     return expr;
 858   if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 859     return expr;
 860   switch (TREE_CODE (expr))
 861     {
 862     case COND_EXPR:
 863       {
 864         /* The two parts of a cond expr might be separate lvalues.  */
 865         tree op1 = TREE_OPERAND (expr,1);
 866         tree op2 = TREE_OPERAND (expr,2);
 867         tree new_op1 = convert_to_void (op1, implicit);
 868         tree new_op2 = convert_to_void (op2, implicit);
 869
 870         if (new_op1 != op1 || new_op2 != op2)
 871           expr = build (COND_EXPR,
 872                         implicit ? TREE_TYPE (expr) : void_type_node,
 873                         TREE_OPERAND (expr, 0), new_op1, new_op2);
 874         break;
 875       }
 876
 877     case COMPOUND_EXPR:
 878       {
 879         /* The second part of a compound expr contains the value.  */
 880         tree op1 = TREE_OPERAND (expr,1);
 881         tree new_op1 = convert_to_void (op1, implicit);
 882
 883         if (new_op1 != op1)
 884           expr = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
 885                         TREE_OPERAND (expr, 0), new_op1);
 886         break;
 887       }
 888
 889     case NON_LVALUE_EXPR:
 890     case NOP_EXPR:
 891       /* These have already decayed to rvalue. */
 892       break;
 893
 894     case CALL_EXPR:   /* we have a special meaning for volatile void fn() */
 895       break;
 896
 897     case INDIRECT_REF:
 898       {
 899         tree type = TREE_TYPE (expr);
 900         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
 901                            == REFERENCE_TYPE;
 902         int is_volatile = TYPE_VOLATILE (type);
 903         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 904
 905         if (is_volatile && !is_complete)
 906           cp_warning ("object of incomplete type `%T' will not be accessed in %s",
 907                       type, implicit ? implicit : "void context");
 908         else if (is_reference && is_volatile)
 909           cp_warning ("object of type `%T' will not be accessed in %s",
 910                       TREE_TYPE (TREE_OPERAND (expr, 0)),
 911                       implicit ? implicit : "void context");
 912         if (is_reference || !is_volatile || !is_complete)
 913           expr = TREE_OPERAND (expr, 0);
 914
 915         break;
 916       }
 917
 918     case VAR_DECL:
 919       {
 920         /* External variables might be incomplete.  */
 921         tree type = TREE_TYPE (expr);
 922         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 923
 924         if (TYPE_VOLATILE (type) && !is_complete)
 925           cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
 926                       expr, type, implicit ? implicit : "void context");
 927         break;
 928       }
 929
 930     default:;
 931     }
 932   {
 933     tree probe = expr;
 934
 935     if (TREE_CODE (probe) == ADDR_EXPR)
 936       probe = TREE_OPERAND (expr, 0);
 937     if (!is_overloaded_fn (probe))
 938       ;/* OK */
 939     else if (really_overloaded_fn (probe))
 940         {
 941           /* [over.over] enumerates the places where we can take the address
 942              of an overloaded function, and this is not one of them.  */
 943           cp_pedwarn ("%s has no context for overloaded function name `%E'",
 944                       implicit ? implicit : "void cast", expr);
 945         }
 946     else if (implicit && probe == expr)
 947       /* Only warn when there is no &.  */
 948       cp_warning ("%s is a reference, not call, to function `%E'",
 949                     implicit, expr);
 950   }
 951
 952   if (expr != error_mark_node
 953       && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 954     {
 955       /* FIXME: This is where we should check for expressions with no
 956          effects.  At the moment we do that in both build_x_component_expr
 957          and expand_expr_stmt -- inconsistently too.  For the moment
 958          leave implicit void conversions unadorned so that expand_expr_stmt
 959          has a chance of detecting some of the cases.  */
 960       if (!implicit)
 961         expr = build1 (CONVERT_EXPR, void_type_node, expr);
 962     }
 963   return expr;
 964 }
 965
 966 /* Create an expression whose value is that of EXPR,
 967    converted to type TYPE.  The TREE_TYPE of the value
 968    is always TYPE.  This function implements all reasonable
 969    conversions; callers should filter out those that are
 970    not permitted by the language being compiled.
 971
 972    Most of this routine is from build_reinterpret_cast.
 973
 974    The backend cannot call cp_convert (what was convert) because
 975    conversions to/from basetypes may involve memory references
 976    (vbases) and adding or subtracting small values (multiple
 977    inheritance), but it calls convert from the constant folding code
 978    on subtrees of already build trees after it has ripped them apart.
 979
 980    Also, if we ever support range variables, we'll probably also have to
 981    do a little bit more work.  */
 982
 983 tree
 984 convert (type, expr)
 985      tree type, expr;
 986 {
 987   tree intype;
 988
 989   if (type == error_mark_node || expr == error_mark_node)
 990     return error_mark_node;
 991
 992   intype = TREE_TYPE (expr);
 993
 994   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
 995     {
 996       if (TREE_READONLY_DECL_P (expr))
 997         expr = decl_constant_value (expr);
 998       return fold (build1 (NOP_EXPR, type, expr));
 999     }
1000
1001   return ocp_convert (type, expr, CONV_OLD_CONVERT,
1002                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
1003 }
1004
1005 /* Like cp_convert, except permit conversions to take place which
1006    are not normally allowed due to access restrictions
1007    (such as conversion from sub-type to private super-type).  */
1008
1009 tree
1010 convert_force (type, expr, convtype)
1011      tree type;
1012      tree expr;
1013      int convtype;
1014 {
1015   register tree e = expr;
1016   register enum tree_code code = TREE_CODE (type);
1017
1018   if (code == REFERENCE_TYPE)
1019     return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1020                                        NULL_TREE));
1021   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1022     e = convert_from_reference (e);
1023
1024   if (code == POINTER_TYPE)
1025     return fold (convert_to_pointer_force (type, e));
1026
1027   /* From typeck.c convert_for_assignment */
1028   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1029         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1030         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1031        || integer_zerop (e)
1032        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1033       && TYPE_PTRMEMFUNC_P (type))
1034     {
1035       /* compatible pointer to member functions.  */
1036       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1037     }
1038
1039   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1040 }
1041
1042 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1043    exists, return the attempted conversion.  This may
1044    return ERROR_MARK_NODE if the conversion is not
1045    allowed (references private members, etc).
1046    If no conversion exists, NULL_TREE is returned.
1047
1048    If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1049    to take place immediately.  Otherwise, we build a SAVE_EXPR
1050    which can be evaluated if the results are ever needed.
1051
1052    Changes to this functions should be mirrored in user_harshness.
1053
1054    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1055    object parameter, or by the second standard conversion sequence if
1056    that doesn't do it.  This will probably wait for an overloading rewrite.
1057    (jason 8/9/95)  */
1058
1059 tree
1060 build_type_conversion (xtype, expr, for_sure)
1061      tree xtype, expr;
1062      int for_sure;
1063 {
1064   /* C++: check to see if we can convert this aggregate type
1065      into the required type.  */
1066   return build_user_type_conversion
1067     (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
1068 }
1069
1070 /* Convert the given EXPR to one of a group of types suitable for use in an
1071    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1072    which indicates which types are suitable.  If COMPLAIN is 1, complain
1073    about ambiguity; otherwise, the caller will deal with it.  */
1074
1075 tree
1076 build_expr_type_conversion (desires, expr, complain)
1077      int desires;
1078      tree expr;
1079      int complain;
1080 {
1081   tree basetype = TREE_TYPE (expr);
1082   tree conv = NULL_TREE;
1083   tree winner = NULL_TREE;
1084
1085   if (expr == null_node
1086       && (desires & WANT_INT)
1087       && !(desires & WANT_NULL))
1088     cp_warning ("converting NULL to non-pointer type");
1089
1090   if (TREE_CODE (expr) == OFFSET_REF)
1091     expr = resolve_offset_ref (expr);
1092   expr = convert_from_reference (expr);
1093   basetype = TREE_TYPE (expr);
1094
1095   if (! IS_AGGR_TYPE (basetype))
1096     switch (TREE_CODE (basetype))
1097       {
1098       case INTEGER_TYPE:
1099         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1100           return expr;
1101         /* else fall through...  */
1102
1103       case BOOLEAN_TYPE:
1104         return (desires & WANT_INT) ? expr : NULL_TREE;
1105       case ENUMERAL_TYPE:
1106         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1107       case REAL_TYPE:
1108         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1109       case POINTER_TYPE:
1110         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1111
1112       case FUNCTION_TYPE:
1113       case ARRAY_TYPE:
1114         return (desires & WANT_POINTER) ? default_conversion (expr)
1115                                         : NULL_TREE;
1116       default:
1117         return NULL_TREE;
1118       }
1119
1120   /* The code for conversions from class type is currently only used for
1121      delete expressions.  Other expressions are handled by build_new_op.  */
1122
1123   if (! TYPE_HAS_CONVERSION (basetype))
1124     return NULL_TREE;
1125
1126   for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1127     {
1128       int win = 0;
1129       tree candidate;
1130       tree cand = TREE_VALUE (conv);
1131
1132       if (winner && winner == cand)
1133         continue;
1134
1135       candidate = TREE_TYPE (TREE_TYPE (cand));
1136       if (TREE_CODE (candidate) == REFERENCE_TYPE)
1137         candidate = TREE_TYPE (candidate);
1138
1139       switch (TREE_CODE (candidate))
1140         {
1141         case BOOLEAN_TYPE:
1142         case INTEGER_TYPE:
1143           win = (desires & WANT_INT); break;
1144         case ENUMERAL_TYPE:
1145           win = (desires & WANT_ENUM); break;
1146         case REAL_TYPE:
1147           win = (desires & WANT_FLOAT); break;
1148         case POINTER_TYPE:
1149           win = (desires & WANT_POINTER); break;
1150
1151         default:
1152           break;
1153         }
1154
1155       if (win)
1156         {
1157           if (winner)
1158             {
1159               if (complain)
1160                 {
1161                   cp_error ("ambiguous default type conversion from `%T'",
1162                             basetype);
1163                   cp_error ("  candidate conversions include `%D' and `%D'",
1164                             winner, cand);
1165                 }
1166               return error_mark_node;
1167             }
1168           else
1169             winner = cand;
1170         }
1171     }
1172
1173   if (winner)
1174     {
1175       tree type = TREE_TYPE (TREE_TYPE (winner));
1176       if (TREE_CODE (type) == REFERENCE_TYPE)
1177         type = TREE_TYPE (type);
1178       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1179     }
1180
1181   return NULL_TREE;
1182 }
1183
1184 /* Implements integral promotion (4.1) and float->double promotion.  */
1185
1186 tree
1187 type_promotes_to (type)
1188      tree type;
1189 {
1190   int type_quals;
1191
1192   if (type == error_mark_node)
1193     return error_mark_node;
1194
1195   type_quals = CP_TYPE_QUALS (type);
1196   type = TYPE_MAIN_VARIANT (type);
1197
1198   /* bool always promotes to int (not unsigned), even if it's the same
1199      size.  */
1200   if (type == boolean_type_node)
1201     type = integer_type_node;
1202
1203   /* Normally convert enums to int, but convert wide enums to something
1204      wider.  */
1205   else if (TREE_CODE (type) == ENUMERAL_TYPE
1206            || type == wchar_type_node)
1207     {
1208       int precision = MAX (TYPE_PRECISION (type),
1209                            TYPE_PRECISION (integer_type_node));
1210       tree totype = type_for_size (precision, 0);
1211       if (TREE_UNSIGNED (type)
1212           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1213         type = type_for_size (precision, 1);
1214       else
1215         type = totype;
1216     }
1217   else if (C_PROMOTING_INTEGER_TYPE_P (type))
1218     {
1219       /* Retain unsignedness if really not getting bigger.  */
1220       if (TREE_UNSIGNED (type)
1221           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1222         type = unsigned_type_node;
1223       else
1224         type = integer_type_node;
1225     }
1226   else if (type == float_type_node)
1227     type = double_type_node;
1228
1229   return cp_build_qualified_type (type, type_quals);
1230 }
1231
1232 /* The routines below this point are carefully written to conform to
1233    the standard.  They use the same terminology, and follow the rules
1234    closely.  Although they are used only in pt.c at the moment, they
1235    should presumably be used everywhere in the future.  */
1236
1237 /* Attempt to perform qualification conversions on EXPR to convert it
1238    to TYPE.  Return the resulting expression, or error_mark_node if
1239    the conversion was impossible.  */
1240
1241 tree
1242 perform_qualification_conversions (type, expr)
1243      tree type;
1244      tree expr;
1245 {
1246   if (TREE_CODE (type) == POINTER_TYPE
1247       && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1248       && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1249     return build1 (NOP_EXPR, type, expr);
1250   else
1251     return error_mark_node;
1252 }