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, 0,
 361                       LOOKUP_ONLYCONVERTING|DIRECT_BIND);
 362     }
 363   else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
 364     {
 365       tree slot = build_decl (VAR_DECL, NULL_TREE, argtype);
 366       DECL_ARTIFICIAL (slot) = 1;
 367       arg = build (TARGET_EXPR, argtype, slot, arg, NULL_TREE, NULL_TREE);
 368       TREE_SIDE_EFFECTS (arg) = 1;
 369     }
 370
 371   /* If we had a way to wrap this up, and say, if we ever needed it's
 372      address, transform all occurrences of the register, into a memory
 373      reference we could win better.  */
 374   rval = build_unary_op (ADDR_EXPR, arg, 1);
 375   if (rval == error_mark_node)
 376     return error_mark_node;
 377
 378   if ((flags & LOOKUP_PROTECT)
 379       && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
 380       && IS_AGGR_TYPE (argtype)
 381       && IS_AGGR_TYPE (target_type))
 382     {
 383       /* We go through get_binfo for the access control.  */
 384       tree binfo = get_binfo (target_type, argtype, 1);
 385       if (binfo == error_mark_node)
 386         return error_mark_node;
 387       if (binfo == NULL_TREE)
 388         return error_not_base_type (target_type, argtype);
 389       rval = convert_pointer_to_real (binfo, rval);
 390     }
 391   else
 392     rval
 393       = convert_to_pointer_force (build_pointer_type (target_type), rval);
 394   rval = build1 (NOP_EXPR, type, rval);
 395   TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
 396
 397   /* If we created and initialized a new temporary variable, add the
 398      representation of that initialization to the RVAL.  */
 399   if (stmt_expr)
 400     rval = build (COMPOUND_EXPR, TREE_TYPE (rval), stmt_expr, rval);
 401
 402   /* And return the result.  */
 403   return rval;
 404 }
 405
 406 /* For C++: Only need to do one-level references, but cannot
 407    get tripped up on signed/unsigned differences.
 408
 409    DECL is either NULL_TREE or the _DECL node for a reference that is being
 410    initialized.  It can be error_mark_node if we don't know the _DECL but
 411    we know it's an initialization.  */
 412
 413 tree
 414 convert_to_reference (reftype, expr, convtype, flags, decl)
 415      tree reftype, expr;
 416      int convtype, flags;
 417      tree decl;
 418 {
 419   register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
 420   register tree intype = TREE_TYPE (expr);
 421   tree rval = NULL_TREE;
 422   tree rval_as_conversion = NULL_TREE;
 423   int i;
 424
 425   if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
 426     {
 427       expr = instantiate_type (type, expr,
 428                                (flags & LOOKUP_COMPLAIN) != 0);
 429       if (expr == error_mark_node)
 430         return error_mark_node;
 431
 432       intype = TREE_TYPE (expr);
 433     }
 434
 435   if (TREE_CODE (intype) == REFERENCE_TYPE)
 436     my_friendly_abort (364);
 437
 438   intype = TYPE_MAIN_VARIANT (intype);
 439
 440   i = comp_target_types (type, intype, 0);
 441
 442   if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
 443       && ! (flags & LOOKUP_NO_CONVERSION))
 444     {
 445       /* Look for a user-defined conversion to lvalue that we can use.  */
 446
 447       rval_as_conversion
 448         = build_type_conversion (reftype, expr, 1);
 449
 450       if (rval_as_conversion && rval_as_conversion != error_mark_node
 451           && real_lvalue_p (rval_as_conversion))
 452         {
 453           expr = rval_as_conversion;
 454           rval_as_conversion = NULL_TREE;
 455           intype = type;
 456           i = 1;
 457         }
 458     }
 459
 460   if (((convtype & CONV_STATIC) && i == -1)
 461       || ((convtype & CONV_IMPLICIT) && i == 1))
 462     {
 463       if (flags & LOOKUP_COMPLAIN)
 464         {
 465           tree ttl = TREE_TYPE (reftype);
 466           tree ttr = lvalue_type (expr);
 467
 468           /* [dcl.init.ref] says that if an rvalue is used to
 469              initialize a reference, then the reference must be to a
 470              non-volatile const type.  */
 471           if (! real_lvalue_p (expr)
 472               && !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
 473             {
 474               const char *msg;
 475
 476               if (CP_TYPE_VOLATILE_P (ttl) && decl)
 477                 msg = "initialization of volatile reference type `%#T'";
 478               else if (CP_TYPE_VOLATILE_P (ttl))
 479                 msg = "conversion to volatile reference type `%#T'";
 480               else if (decl)
 481                 msg = "initialization of non-const reference type `%#T'";
 482               else
 483                 msg = "conversion to non-const reference type `%#T'";
 484
 485               cp_pedwarn (msg, reftype);
 486               cp_pedwarn ("from rvalue of type `%T'", intype);
 487             }
 488           else if (! (convtype & CONV_CONST)
 489                    && !at_least_as_qualified_p (ttl, ttr))
 490             cp_pedwarn ("conversion from `%T' to `%T' discards qualifiers",
 491                         ttr, reftype);
 492         }
 493
 494       return build_up_reference (reftype, expr, flags);
 495     }
 496   else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
 497     {
 498       /* When casting an lvalue to a reference type, just convert into
 499          a pointer to the new type and deference it.  This is allowed
 500          by San Diego WP section 5.2.9 paragraph 12, though perhaps it
 501          should be done directly (jason).  (int &)ri ---> *(int*)&ri */
 502
 503       /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
 504          meant.  */
 505       if (TREE_CODE (intype) == POINTER_TYPE
 506           && (comptypes (TREE_TYPE (intype), type,
 507                          COMPARE_BASE | COMPARE_RELAXED )))
 508         cp_warning ("casting `%T' to `%T' does not dereference pointer",
 509                     intype, reftype);
 510
 511       rval = build_unary_op (ADDR_EXPR, expr, 0);
 512       if (rval != error_mark_node)
 513         rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
 514                               rval, 0);
 515       if (rval != error_mark_node)
 516         rval = build1 (NOP_EXPR, reftype, rval);
 517     }
 518   else
 519     {
 520       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
 521                                          "converting", 0, 0);
 522       if (rval == NULL_TREE || rval == error_mark_node)
 523         return rval;
 524       rval = build_up_reference (reftype, rval, flags);
 525
 526       if (rval && ! CP_TYPE_CONST_P (TREE_TYPE (reftype)))
 527         cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
 528                     reftype, intype);
 529     }
 530
 531   if (rval)
 532     {
 533       /* If we found a way to convert earlier, then use it.  */
 534       return rval;
 535     }
 536
 537   my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
 538
 539   if (flags & LOOKUP_COMPLAIN)
 540     cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
 541
 542   if (flags & LOOKUP_SPECULATIVELY)
 543     return NULL_TREE;
 544
 545   return error_mark_node;
 546 }
 547
 548 /* We are using a reference VAL for its value. Bash that reference all the
 549    way down to its lowest form.  */
 550
 551 tree
 552 convert_from_reference (val)
 553      tree val;
 554 {
 555   tree type = TREE_TYPE (val);
 556
 557   if (TREE_CODE (type) == OFFSET_TYPE)
 558     type = TREE_TYPE (type);
 559   if (TREE_CODE (type) == REFERENCE_TYPE)
 560     return build_indirect_ref (val, NULL_PTR);
 561   return val;
 562 }
 563 \f
 564 /* Call this when we know (for any reason) that expr is not, in fact,
 565    zero.  This routine is like convert_pointer_to, but it pays
 566    attention to which specific instance of what type we want to
 567    convert to.  This routine should eventually become
 568    convert_to_pointer after all references to convert_to_pointer
 569    are removed.  */
 570
 571 tree
 572 convert_pointer_to_real (binfo, expr)
 573      tree binfo, expr;
 574 {
 575   register tree intype = TREE_TYPE (expr);
 576   tree ptr_type;
 577   tree type, rval;
 578
 579   if (intype == error_mark_node)
 580     return error_mark_node;
 581
 582   if (TREE_CODE (binfo) == TREE_VEC)
 583     type = BINFO_TYPE (binfo);
 584   else if (IS_AGGR_TYPE (binfo))
 585     {
 586       type = binfo;
 587     }
 588   else
 589     {
 590       type = binfo;
 591       binfo = NULL_TREE;
 592     }
 593
 594   ptr_type = cp_build_qualified_type (type,
 595                                       CP_TYPE_QUALS (TREE_TYPE (intype)));
 596   ptr_type = build_pointer_type (ptr_type);
 597   if (same_type_p (ptr_type, TYPE_MAIN_VARIANT (intype)))
 598     return expr;
 599
 600   my_friendly_assert (!integer_zerop (expr), 191);
 601
 602   intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
 603   if (TREE_CODE (type) == RECORD_TYPE
 604       && TREE_CODE (intype) == RECORD_TYPE
 605       && type != intype)
 606     {
 607       tree path;
 608       int distance
 609         = get_base_distance (binfo, intype, 0, &path);
 610
 611       /* This function shouldn't be called with unqualified arguments
 612          but if it is, give them an error message that they can read.  */
 613       if (distance < 0)
 614         {
 615           cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
 616                     intype, type);
 617
 618           if (distance == -2)
 619             cp_error ("because `%T' is an ambiguous base class", type);
 620           return error_mark_node;
 621         }
 622
 623       return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
 624     }
 625   rval = build1 (NOP_EXPR, ptr_type,
 626                  TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
 627   TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
 628   return rval;
 629 }
 630
 631 /* Call this when we know (for any reason) that expr is
 632    not, in fact, zero.  This routine gets a type out of the first
 633    argument and uses it to search for the type to convert to.  If there
 634    is more than one instance of that type in the expr, the conversion is
 635    ambiguous.  This routine should eventually go away, and all
 636    callers should use convert_to_pointer_real.  */
 637
 638 tree
 639 convert_pointer_to (binfo, expr)
 640      tree binfo, expr;
 641 {
 642   tree type;
 643
 644   if (TREE_CODE (binfo) == TREE_VEC)
 645     type = BINFO_TYPE (binfo);
 646   else if (IS_AGGR_TYPE (binfo))
 647     type = binfo;
 648   else
 649     type = binfo;
 650   return convert_pointer_to_real (type, expr);
 651 }
 652 \f
 653 /* C++ conversions, preference to static cast conversions.  */
 654
 655 tree
 656 cp_convert (type, expr)
 657      tree type, expr;
 658 {
 659   return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
 660 }
 661
 662 /* Conversion...
 663
 664    FLAGS indicates how we should behave.  */
 665
 666 tree
 667 ocp_convert (type, expr, convtype, flags)
 668      tree type, expr;
 669      int convtype, flags;
 670 {
 671   register tree e = expr;
 672   register enum tree_code code = TREE_CODE (type);
 673
 674   if (e == error_mark_node
 675       || TREE_TYPE (e) == error_mark_node)
 676     return error_mark_node;
 677
 678   if (TREE_READONLY_DECL_P (e))
 679     e = decl_constant_value (e);
 680
 681   if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
 682       /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
 683          don't go through finish_struct, so they don't have the synthesized
 684          constructors.  So don't force a temporary.  */
 685       && TYPE_HAS_CONSTRUCTOR (type))
 686     /* We need a new temporary; don't take this shortcut.  */;
 687   else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
 688     {
 689       if (same_type_p (type, TREE_TYPE (e)))
 690         /* The call to fold will not always remove the NOP_EXPR as
 691            might be expected, since if one of the types is a typedef;
 692            the comparsion in fold is just equality of pointers, not a
 693            call to comptypes.  We don't call fold in this case because
 694            that can result in infinite recursion; fold will call
 695            convert, which will call ocp_convert, etc.  */
 696         return e;
 697       else
 698         return fold (build1 (NOP_EXPR, type, e));
 699     }
 700
 701   if (code == VOID_TYPE && (convtype & CONV_STATIC))
 702     {
 703       e = convert_to_void (e, /*implicit=*/NULL);
 704       return e;
 705     }
 706
 707   /* Just convert to the type of the member.  */
 708   if (code == OFFSET_TYPE)
 709     {
 710       type = TREE_TYPE (type);
 711       code = TREE_CODE (type);
 712     }
 713
 714   if (TREE_CODE (e) == OFFSET_REF)
 715     e = resolve_offset_ref (e);
 716
 717   if (INTEGRAL_CODE_P (code))
 718     {
 719       tree intype = TREE_TYPE (e);
 720       /* enum = enum, enum = int, enum = float, (enum)pointer are all
 721          errors.  */
 722       if (TREE_CODE (type) == ENUMERAL_TYPE
 723           && ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
 724               || (TREE_CODE (intype) == POINTER_TYPE)))
 725         {
 726           cp_pedwarn ("conversion from `%#T' to `%#T'", intype, type);
 727
 728           if (flag_pedantic_errors)
 729             return error_mark_node;
 730         }
 731       if (IS_AGGR_TYPE (intype))
 732         {
 733           tree rval;
 734           rval = build_type_conversion (type, e, 1);
 735           if (rval)
 736             return rval;
 737           if (flags & LOOKUP_COMPLAIN)
 738             cp_error ("`%#T' used where a `%T' was expected", intype, type);
 739           if (flags & LOOKUP_SPECULATIVELY)
 740             return NULL_TREE;
 741           return error_mark_node;
 742         }
 743       if (code == BOOLEAN_TYPE)
 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             cp_warning ("the address of `%D', will always be `true'", expr);
 749           return truthvalue_conversion (e);
 750         }
 751       return fold (convert_to_integer (type, e));
 752     }
 753   if (code == POINTER_TYPE || code == REFERENCE_TYPE
 754       || TYPE_PTRMEMFUNC_P (type))
 755     return fold (cp_convert_to_pointer (type, e));
 756   if (code == REAL_TYPE || code == COMPLEX_TYPE)
 757     {
 758       if (IS_AGGR_TYPE (TREE_TYPE (e)))
 759         {
 760           tree rval;
 761           rval = build_type_conversion (type, e, 1);
 762           if (rval)
 763             return rval;
 764           else
 765             if (flags & LOOKUP_COMPLAIN)
 766               cp_error ("`%#T' used where a floating point value was expected",
 767                         TREE_TYPE (e));
 768         }
 769       if (code == REAL_TYPE)
 770         return fold (convert_to_real (type, e));
 771       else if (code == COMPLEX_TYPE)
 772         return fold (convert_to_complex (type, e));
 773     }
 774
 775   /* New C++ semantics:  since assignment is now based on
 776      memberwise copying,  if the rhs type is derived from the
 777      lhs type, then we may still do a conversion.  */
 778   if (IS_AGGR_TYPE_CODE (code))
 779     {
 780       tree dtype = TREE_TYPE (e);
 781       tree ctor = NULL_TREE;
 782
 783       dtype = TYPE_MAIN_VARIANT (dtype);
 784
 785       /* Conversion between aggregate types.  New C++ semantics allow
 786          objects of derived type to be cast to objects of base type.
 787          Old semantics only allowed this between pointers.
 788
 789          There may be some ambiguity between using a constructor
 790          vs. using a type conversion operator when both apply.  */
 791
 792       ctor = e;
 793
 794       if (abstract_virtuals_error (NULL_TREE, type))
 795         return error_mark_node;
 796
 797       if ((flags & LOOKUP_ONLYCONVERTING)
 798           && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
 799         /* For copy-initialization, first we create a temp of the proper type
 800            with a user-defined conversion sequence, then we direct-initialize
 801            the target with the temp (see [dcl.init]).  */
 802         ctor = build_user_type_conversion (type, ctor, flags);
 803       if (ctor)
 804         ctor = build_method_call (NULL_TREE, ctor_identifier,
 805                                   build_expr_list (NULL_TREE, ctor),
 806                                   TYPE_BINFO (type), flags);
 807       if (ctor)
 808         return build_cplus_new (type, ctor);
 809     }
 810
 811   /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
 812      then it won't be hashed and hence compare as not equal,
 813      even when it is.  */
 814   if (code == ARRAY_TYPE
 815       && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
 816       && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
 817     return e;
 818
 819   if (flags & LOOKUP_COMPLAIN)
 820     cp_error ("conversion from `%T' to non-scalar type `%T' requested",
 821               TREE_TYPE (expr), type);
 822   if (flags & LOOKUP_SPECULATIVELY)
 823     return NULL_TREE;
 824   return error_mark_node;
 825 }
 826
 827 /* When an expression is used in a void context, its value is discarded and
 828    no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
 829    stmt.expr/1, expr.comma/1].  This permits dereferencing an incomplete type
 830    in a void context. The C++ standard does not define what an `access' to an
 831    object is, but there is reason to beleive that it is the lvalue to rvalue
 832    conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
 833    accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
 834    indicates that volatile semantics should be the same between C and C++
 835    where ever possible. C leaves it implementation defined as to what
 836    constitutes an access to a volatile. So, we interpret `*vp' as a read of
 837    the volatile object `vp' points to, unless that is an incomplete type. For
 838    volatile references we do not do this interpretation, because that would
 839    make it impossible to ignore the reference return value from functions. We
 840    issue warnings in the confusing cases.
 841
 842    IMPLICIT is tells us the context of an implicit void conversion.  */
 843
 844 tree
 845 convert_to_void (expr, implicit)
 846      tree expr;
 847      const char *implicit;
 848 {
 849   if (expr == error_mark_node)
 850     return expr;
 851   if (!TREE_TYPE (expr))
 852     return expr;
 853   if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 854     return expr;
 855   switch (TREE_CODE (expr))
 856     {
 857     case COND_EXPR:
 858       {
 859         /* The two parts of a cond expr might be separate lvalues.  */
 860         tree op1 = TREE_OPERAND (expr,1);
 861         tree op2 = TREE_OPERAND (expr,2);
 862         tree new_op1 = convert_to_void (op1, implicit);
 863         tree new_op2 = convert_to_void (op2, implicit);
 864
 865         if (new_op1 != op1 || new_op2 != op2)
 866           expr = build (COND_EXPR,
 867                         implicit ? TREE_TYPE (expr) : void_type_node,
 868                         TREE_OPERAND (expr, 0), new_op1, new_op2);
 869         break;
 870       }
 871
 872     case COMPOUND_EXPR:
 873       {
 874         /* The second part of a compound expr contains the value.  */
 875         tree op1 = TREE_OPERAND (expr,1);
 876         tree new_op1 = convert_to_void (op1, implicit);
 877
 878         if (new_op1 != op1)
 879           expr = build (COMPOUND_EXPR, TREE_TYPE (new_op1),
 880                         TREE_OPERAND (expr, 0), new_op1);
 881         break;
 882       }
 883
 884     case NON_LVALUE_EXPR:
 885     case NOP_EXPR:
 886       /* These have already decayed to rvalue. */
 887       break;
 888
 889     case CALL_EXPR:   /* we have a special meaning for volatile void fn() */
 890       break;
 891
 892     case INDIRECT_REF:
 893       {
 894         tree type = TREE_TYPE (expr);
 895         int is_reference = TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0)))
 896                            == REFERENCE_TYPE;
 897         int is_volatile = TYPE_VOLATILE (type);
 898         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 899
 900         if (is_volatile && !is_complete)
 901           cp_warning ("object of incomplete type `%T' will not be accessed in %s",
 902                       type, implicit ? implicit : "void context");
 903         else if (is_reference && is_volatile)
 904           cp_warning ("object of type `%T' will not be accessed in %s",
 905                       TREE_TYPE (TREE_OPERAND (expr, 0)),
 906                       implicit ? implicit : "void context");
 907         if (is_reference || !is_volatile || !is_complete)
 908           expr = TREE_OPERAND (expr, 0);
 909
 910         break;
 911       }
 912
 913     case VAR_DECL:
 914       {
 915         /* External variables might be incomplete.  */
 916         tree type = TREE_TYPE (expr);
 917         int is_complete = TYPE_SIZE (complete_type (type)) != NULL_TREE;
 918
 919         if (TYPE_VOLATILE (type) && !is_complete)
 920           cp_warning ("object `%E' of incomplete type `%T' will not be accessed in %s",
 921                       expr, type, implicit ? implicit : "void context");
 922         break;
 923       }
 924
 925     default:;
 926     }
 927   {
 928     tree probe = expr;
 929
 930     if (TREE_CODE (probe) == ADDR_EXPR)
 931       probe = TREE_OPERAND (expr, 0);
 932     if (!is_overloaded_fn (probe))
 933       ;/* OK */
 934     else if (really_overloaded_fn (probe))
 935         {
 936           /* [over.over] enumerates the places where we can take the address
 937              of an overloaded function, and this is not one of them.  */
 938           cp_pedwarn ("%s has no context for overloaded function name `%E'",
 939                       implicit ? implicit : "void cast", expr);
 940         }
 941     else if (implicit && probe == expr)
 942       /* Only warn when there is no &.  */
 943       cp_warning ("%s is a reference, not call, to function `%E'",
 944                     implicit, expr);
 945   }
 946
 947   if (expr != error_mark_node
 948       && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)), void_type_node))
 949     {
 950       /* FIXME: This is where we should check for expressions with no
 951          effects.  At the moment we do that in both build_x_component_expr
 952          and expand_expr_stmt -- inconsistently too.  For the moment
 953          leave implicit void conversions unadorned so that expand_expr_stmt
 954          has a chance of detecting some of the cases.  */
 955       if (!implicit)
 956         expr = build1 (CONVERT_EXPR, void_type_node, expr);
 957     }
 958   return expr;
 959 }
 960
 961 /* Create an expression whose value is that of EXPR,
 962    converted to type TYPE.  The TREE_TYPE of the value
 963    is always TYPE.  This function implements all reasonable
 964    conversions; callers should filter out those that are
 965    not permitted by the language being compiled.
 966
 967    Most of this routine is from build_reinterpret_cast.
 968
 969    The backend cannot call cp_convert (what was convert) because
 970    conversions to/from basetypes may involve memory references
 971    (vbases) and adding or subtracting small values (multiple
 972    inheritance), but it calls convert from the constant folding code
 973    on subtrees of already build trees after it has ripped them apart.
 974
 975    Also, if we ever support range variables, we'll probably also have to
 976    do a little bit more work.  */
 977
 978 tree
 979 convert (type, expr)
 980      tree type, expr;
 981 {
 982   tree intype;
 983
 984   if (type == error_mark_node || expr == error_mark_node)
 985     return error_mark_node;
 986
 987   intype = TREE_TYPE (expr);
 988
 989   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
 990     {
 991       if (TREE_READONLY_DECL_P (expr))
 992         expr = decl_constant_value (expr);
 993       return fold (build1 (NOP_EXPR, type, expr));
 994     }
 995
 996   return ocp_convert (type, expr, CONV_OLD_CONVERT,
 997                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
 998 }
 999
1000 /* Like cp_convert, except permit conversions to take place which
1001    are not normally allowed due to access restrictions
1002    (such as conversion from sub-type to private super-type).  */
1003
1004 tree
1005 convert_force (type, expr, convtype)
1006      tree type;
1007      tree expr;
1008      int convtype;
1009 {
1010   register tree e = expr;
1011   register enum tree_code code = TREE_CODE (type);
1012
1013   if (code == REFERENCE_TYPE)
1014     return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
1015                                        NULL_TREE));
1016   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
1017     e = convert_from_reference (e);
1018
1019   if (code == POINTER_TYPE)
1020     return fold (convert_to_pointer_force (type, e));
1021
1022   /* From typeck.c convert_for_assignment */
1023   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
1024         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
1025         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1026        || integer_zerop (e)
1027        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1028       && TYPE_PTRMEMFUNC_P (type))
1029     {
1030       /* compatible pointer to member functions.  */
1031       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
1032     }
1033
1034   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
1035 }
1036
1037 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
1038    exists, return the attempted conversion.  This may
1039    return ERROR_MARK_NODE if the conversion is not
1040    allowed (references private members, etc).
1041    If no conversion exists, NULL_TREE is returned.
1042
1043    If (FOR_SURE & 1) is non-zero, then we allow this type conversion
1044    to take place immediately.  Otherwise, we build a SAVE_EXPR
1045    which can be evaluated if the results are ever needed.
1046
1047    Changes to this functions should be mirrored in user_harshness.
1048
1049    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
1050    object parameter, or by the second standard conversion sequence if
1051    that doesn't do it.  This will probably wait for an overloading rewrite.
1052    (jason 8/9/95)  */
1053
1054 tree
1055 build_type_conversion (xtype, expr, for_sure)
1056      tree xtype, expr;
1057      int for_sure;
1058 {
1059   /* C++: check to see if we can convert this aggregate type
1060      into the required type.  */
1061   return build_user_type_conversion
1062     (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
1063 }
1064
1065 /* Convert the given EXPR to one of a group of types suitable for use in an
1066    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
1067    which indicates which types are suitable.  If COMPLAIN is 1, complain
1068    about ambiguity; otherwise, the caller will deal with it.  */
1069
1070 tree
1071 build_expr_type_conversion (desires, expr, complain)
1072      int desires;
1073      tree expr;
1074      int complain;
1075 {
1076   tree basetype = TREE_TYPE (expr);
1077   tree conv = NULL_TREE;
1078   tree winner = NULL_TREE;
1079
1080   if (expr == null_node
1081       && (desires & WANT_INT)
1082       && !(desires & WANT_NULL))
1083     cp_warning ("converting NULL to non-pointer type");
1084
1085   if (TREE_CODE (expr) == OFFSET_REF)
1086     expr = resolve_offset_ref (expr);
1087   expr = convert_from_reference (expr);
1088   basetype = TREE_TYPE (expr);
1089
1090   if (! IS_AGGR_TYPE (basetype))
1091     switch (TREE_CODE (basetype))
1092       {
1093       case INTEGER_TYPE:
1094         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1095           return expr;
1096         /* else fall through...  */
1097
1098       case BOOLEAN_TYPE:
1099         return (desires & WANT_INT) ? expr : NULL_TREE;
1100       case ENUMERAL_TYPE:
1101         return (desires & WANT_ENUM) ? expr : NULL_TREE;
1102       case REAL_TYPE:
1103         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1104       case POINTER_TYPE:
1105         return (desires & WANT_POINTER) ? expr : NULL_TREE;
1106
1107       case FUNCTION_TYPE:
1108       case ARRAY_TYPE:
1109         return (desires & WANT_POINTER) ? default_conversion (expr)
1110                                         : NULL_TREE;
1111       default:
1112         return NULL_TREE;
1113       }
1114
1115   /* The code for conversions from class type is currently only used for
1116      delete expressions.  Other expressions are handled by build_new_op.  */
1117
1118   if (! TYPE_HAS_CONVERSION (basetype))
1119     return NULL_TREE;
1120
1121   for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1122     {
1123       int win = 0;
1124       tree candidate;
1125       tree cand = TREE_VALUE (conv);
1126
1127       if (winner && winner == cand)
1128         continue;
1129
1130       candidate = TREE_TYPE (TREE_TYPE (cand));
1131       if (TREE_CODE (candidate) == REFERENCE_TYPE)
1132         candidate = TREE_TYPE (candidate);
1133
1134       switch (TREE_CODE (candidate))
1135         {
1136         case BOOLEAN_TYPE:
1137         case INTEGER_TYPE:
1138           win = (desires & WANT_INT); break;
1139         case ENUMERAL_TYPE:
1140           win = (desires & WANT_ENUM); break;
1141         case REAL_TYPE:
1142           win = (desires & WANT_FLOAT); break;
1143         case POINTER_TYPE:
1144           win = (desires & WANT_POINTER); break;
1145
1146         default:
1147           break;
1148         }
1149
1150       if (win)
1151         {
1152           if (winner)
1153             {
1154               if (complain)
1155                 {
1156                   cp_error ("ambiguous default type conversion from `%T'",
1157                             basetype);
1158                   cp_error ("  candidate conversions include `%D' and `%D'",
1159                             winner, cand);
1160                 }
1161               return error_mark_node;
1162             }
1163           else
1164             winner = cand;
1165         }
1166     }
1167
1168   if (winner)
1169     {
1170       tree type = TREE_TYPE (TREE_TYPE (winner));
1171       if (TREE_CODE (type) == REFERENCE_TYPE)
1172         type = TREE_TYPE (type);
1173       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1174     }
1175
1176   return NULL_TREE;
1177 }
1178
1179 /* Implements integral promotion (4.1) and float->double promotion.  */
1180
1181 tree
1182 type_promotes_to (type)
1183      tree type;
1184 {
1185   int type_quals;
1186
1187   if (type == error_mark_node)
1188     return error_mark_node;
1189
1190   type_quals = CP_TYPE_QUALS (type);
1191   type = TYPE_MAIN_VARIANT (type);
1192
1193   /* bool always promotes to int (not unsigned), even if it's the same
1194      size.  */
1195   if (type == boolean_type_node)
1196     type = integer_type_node;
1197
1198   /* Normally convert enums to int, but convert wide enums to something
1199      wider.  */
1200   else if (TREE_CODE (type) == ENUMERAL_TYPE
1201            || type == wchar_type_node)
1202     {
1203       int precision = MAX (TYPE_PRECISION (type),
1204                            TYPE_PRECISION (integer_type_node));
1205       tree totype = type_for_size (precision, 0);
1206       if (TREE_UNSIGNED (type)
1207           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1208         type = type_for_size (precision, 1);
1209       else
1210         type = totype;
1211     }
1212   else if (C_PROMOTING_INTEGER_TYPE_P (type))
1213     {
1214       /* Retain unsignedness if really not getting bigger.  */
1215       if (TREE_UNSIGNED (type)
1216           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1217         type = unsigned_type_node;
1218       else
1219         type = integer_type_node;
1220     }
1221   else if (type == float_type_node)
1222     type = double_type_node;
1223
1224   return cp_build_qualified_type (type, type_quals);
1225 }
1226
1227 /* The routines below this point are carefully written to conform to
1228    the standard.  They use the same terminology, and follow the rules
1229    closely.  Although they are used only in pt.c at the moment, they
1230    should presumably be used everywhere in the future.  */
1231
1232 /* Attempt to perform qualification conversions on EXPR to convert it
1233    to TYPE.  Return the resulting expression, or error_mark_node if
1234    the conversion was impossible.  */
1235
1236 tree
1237 perform_qualification_conversions (type, expr)
1238      tree type;
1239      tree expr;
1240 {
1241   if (TREE_CODE (type) == POINTER_TYPE
1242       && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1243       && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1244     return build1 (NOP_EXPR, type, expr);
1245   else
1246     return error_mark_node;
1247 }