gcc/cp/cvt.c

   1 /* Language-level data type conversion for GNU C++.
   2    Copyright (C) 1987, 88, 92-96, 1998 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
  35 extern tree static_aggregates;
  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 (CONVERT_EXPR, 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   if (TYPE_PTRMEMFUNC_P (type))
  99     type = TYPE_PTRMEMFUNC_FN_TYPE (type);
 100
 101   /* Handle anachronistic conversions from (::*)() to cv void* or (*)().  */
 102   if (TREE_CODE (type) == POINTER_TYPE
 103       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
 104           || TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node))
 105     {
 106       /* Allow an implicit this pointer for pointer to member
 107          functions.  */
 108       if (TYPE_PTRMEMFUNC_P (intype))
 109         {
 110           tree fntype = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (intype));
 111           tree decl = maybe_dummy_object (TYPE_METHOD_BASETYPE (fntype), 0);
 112           expr = build (OFFSET_REF, fntype, decl, expr);
 113         }
 114
 115       if (TREE_CODE (expr) == OFFSET_REF
 116           && TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
 117         expr = resolve_offset_ref (expr);
 118       if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE)
 119         expr = build_addr_func (expr);
 120       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
 121         {
 122           if (TREE_CODE (TREE_TYPE (TREE_TYPE (expr))) == METHOD_TYPE)
 123             if (pedantic || warn_pmf2ptr)
 124               cp_pedwarn ("converting from `%T' to `%T'", TREE_TYPE (expr),
 125                           type);
 126           return build1 (NOP_EXPR, type, expr);
 127         }
 128       intype = TREE_TYPE (expr);
 129     }
 130
 131   if (TYPE_PTRMEMFUNC_P (intype))
 132     intype = TYPE_PTRMEMFUNC_FN_TYPE (intype);
 133
 134   form = TREE_CODE (intype);
 135
 136   if (form == POINTER_TYPE || form == REFERENCE_TYPE)
 137     {
 138       intype = TYPE_MAIN_VARIANT (intype);
 139
 140       if (TYPE_MAIN_VARIANT (type) != intype
 141           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
 142           && IS_AGGR_TYPE (TREE_TYPE (type))
 143           && IS_AGGR_TYPE (TREE_TYPE (intype))
 144           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE
 145           /* If EXPR is NULL, then we don't need to do any arithmetic
 146              to convert it:
 147
 148                [conv.ptr]
 149
 150                The null pointer value is converted to the null pointer
 151                value of the destination type.  */
 152           && !integer_zerop (expr))
 153         {
 154           enum tree_code code = PLUS_EXPR;
 155           tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1);
 156           if (binfo == error_mark_node)
 157             return error_mark_node;
 158           if (binfo == NULL_TREE)
 159             {
 160               binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1);
 161               if (binfo == error_mark_node)
 162                 return error_mark_node;
 163               code = MINUS_EXPR;
 164             }
 165           if (binfo)
 166             {
 167               if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type))
 168                   || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype))
 169                   || ! BINFO_OFFSET_ZEROP (binfo))
 170                 {
 171                   /* Need to get the path we took.  */
 172                   tree path;
 173
 174                   if (code == PLUS_EXPR)
 175                     get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
 176                                        0, &path);
 177                   else
 178                     get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
 179                                        0, &path);
 180                   return build_vbase_path (code, type, expr, path, 0);
 181                 }
 182             }
 183         }
 184       if (TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE
 185           && TREE_CODE (type) == POINTER_TYPE
 186           && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
 187         return build_ptrmemfunc (type, expr, 1);
 188
 189       if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
 190           && TREE_CODE (TREE_TYPE (intype)) == OFFSET_TYPE)
 191         {
 192           tree b1 = TYPE_OFFSET_BASETYPE (TREE_TYPE (type));
 193           tree b2 = TYPE_OFFSET_BASETYPE (TREE_TYPE (intype));
 194           tree binfo = get_binfo (b2, b1, 1);
 195           enum tree_code code = PLUS_EXPR;
 196
 197           if (binfo == NULL_TREE)
 198             {
 199               binfo = get_binfo (b1, b2, 1);
 200               code = MINUS_EXPR;
 201             }
 202
 203           if (binfo == error_mark_node)
 204             return error_mark_node;
 205           if (binfo && ! TREE_VIA_VIRTUAL (binfo))
 206             expr = size_binop (code, expr, BINFO_OFFSET (binfo));
 207         }
 208
 209       if (TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE
 210           || (TREE_CODE (type) == POINTER_TYPE
 211               && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
 212         {
 213           cp_error ("cannot convert `%E' from type `%T' to type `%T'",
 214                     expr, intype, type);
 215           return error_mark_node;
 216         }
 217
 218       rval = build1 (NOP_EXPR, type, expr);
 219       TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
 220       return rval;
 221     }
 222
 223   my_friendly_assert (form != OFFSET_TYPE, 186);
 224
 225   if (TYPE_LANG_SPECIFIC (intype)
 226       && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
 227     return convert_to_pointer (type, build_optr_ref (expr));
 228
 229   if (integer_zerop (expr))
 230     {
 231       if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
 232         return build_ptrmemfunc (type, expr, 0);
 233       expr = build_int_2 (0, 0);
 234       TREE_TYPE (expr) = type;
 235       return expr;
 236     }
 237
 238   if (INTEGRAL_CODE_P (form))
 239     {
 240       if (TYPE_PRECISION (intype) == POINTER_SIZE)
 241         return build1 (CONVERT_EXPR, type, expr);
 242       expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr);
 243       /* Modes may be different but sizes should be the same.  */
 244       if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr)))
 245           != GET_MODE_SIZE (TYPE_MODE (type)))
 246         /* There is supposed to be some integral type
 247            that is the same width as a pointer.  */
 248         abort ();
 249       return convert_to_pointer (type, expr);
 250     }
 251
 252   if (type_unknown_p (expr))
 253     return instantiate_type (type, expr, 1);
 254
 255   cp_error ("cannot convert `%E' from type `%T' to type `%T'",
 256             expr, intype, type);
 257   return error_mark_node;
 258 }
 259
 260 /* Like convert, except permit conversions to take place which
 261    are not normally allowed due to access restrictions
 262    (such as conversion from sub-type to private super-type).  */
 263
 264 static tree
 265 convert_to_pointer_force (type, expr)
 266      tree type, expr;
 267 {
 268   register tree intype = TREE_TYPE (expr);
 269   register enum tree_code form = TREE_CODE (intype);
 270
 271   if (integer_zerop (expr))
 272     {
 273       expr = build_int_2 (0, 0);
 274       TREE_TYPE (expr) = type;
 275       return expr;
 276     }
 277
 278   /* Convert signature pointer/reference to `void *' first.  */
 279   if (form == RECORD_TYPE
 280       && (IS_SIGNATURE_POINTER (intype) || IS_SIGNATURE_REFERENCE (intype)))
 281     {
 282       expr = build_optr_ref (expr);
 283       intype = TREE_TYPE (expr);
 284       form = TREE_CODE (intype);
 285     }
 286
 287   if (form == POINTER_TYPE)
 288     {
 289       intype = TYPE_MAIN_VARIANT (intype);
 290
 291       if (TYPE_MAIN_VARIANT (type) != intype
 292           && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
 293           && IS_AGGR_TYPE (TREE_TYPE (type))
 294           && IS_AGGR_TYPE (TREE_TYPE (intype))
 295           && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
 296         {
 297           enum tree_code code = PLUS_EXPR;
 298           tree path;
 299           int distance = get_base_distance (TREE_TYPE (type),
 300                                             TREE_TYPE (intype), 0, &path);
 301           if (distance == -2)
 302             {
 303             ambig:
 304               cp_error ("type `%T' is ambiguous baseclass of `%s'",
 305                         TREE_TYPE (type),
 306                         TYPE_NAME_STRING (TREE_TYPE (intype)));
 307               return error_mark_node;
 308             }
 309           if (distance == -1)
 310             {
 311               distance = get_base_distance (TREE_TYPE (intype),
 312                                             TREE_TYPE (type), 0, &path);
 313               if (distance == -2)
 314                 goto ambig;
 315               if (distance < 0)
 316                 /* Doesn't need any special help from us.  */
 317                 return build1 (NOP_EXPR, type, expr);
 318
 319               code = MINUS_EXPR;
 320             }
 321           return build_vbase_path (code, type, expr, path, 0);
 322         }
 323     }
 324
 325   return cp_convert_to_pointer (type, expr);
 326 }
 327
 328 /* We are passing something to a function which requires a reference.
 329    The type we are interested in is in TYPE. The initial
 330    value we have to begin with is in ARG.
 331
 332    FLAGS controls how we manage access checking.
 333    DIRECT_BIND in FLAGS controls how any temporaries are generated.  */
 334
 335 static tree
 336 build_up_reference (type, arg, flags)
 337      tree type, arg;
 338      int flags;
 339 {
 340   tree rval;
 341   tree argtype = TREE_TYPE (arg);
 342   tree target_type = TREE_TYPE (type);
 343
 344   my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187);
 345
 346   if ((flags & DIRECT_BIND) && ! real_lvalue_p (arg))
 347     {
 348       tree targ = arg;
 349       if (toplevel_bindings_p ())
 350         arg = get_temp_name (argtype, 1);
 351       else
 352         {
 353           arg = pushdecl (build_decl (VAR_DECL, NULL_TREE, argtype));
 354           DECL_ARTIFICIAL (arg) = 1;
 355         }
 356       DECL_INITIAL (arg) = targ;
 357       cp_finish_decl (arg, targ, NULL_TREE, 0, LOOKUP_ONLYCONVERTING);
 358     }
 359   else if (!(flags & DIRECT_BIND) && ! lvalue_p (arg))
 360     {
 361       tree slot = build_decl (VAR_DECL, NULL_TREE, argtype);
 362       arg = build (TARGET_EXPR, argtype, slot, arg, NULL_TREE, NULL_TREE);
 363       TREE_SIDE_EFFECTS (arg) = 1;
 364     }
 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   return rval;
 392 }
 393
 394 /* For C++: Only need to do one-level references, but cannot
 395    get tripped up on signed/unsigned differences.
 396
 397    DECL is either NULL_TREE or the _DECL node for a reference that is being
 398    initialized.  It can be error_mark_node if we don't know the _DECL but
 399    we know it's an initialization.  */
 400
 401 tree
 402 convert_to_reference (reftype, expr, convtype, flags, decl)
 403      tree reftype, expr;
 404      int convtype, flags;
 405      tree decl;
 406 {
 407   register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
 408   register tree intype = TREE_TYPE (expr);
 409   tree rval = NULL_TREE;
 410   tree rval_as_conversion = NULL_TREE;
 411   int i;
 412
 413   if (TREE_CODE (type) == FUNCTION_TYPE && intype == unknown_type_node)
 414     {
 415       expr = instantiate_type (type, expr, 0);
 416       intype = TREE_TYPE (expr);
 417     }
 418
 419   if (TREE_CODE (intype) == REFERENCE_TYPE)
 420     my_friendly_abort (364);
 421
 422   intype = TYPE_MAIN_VARIANT (intype);
 423
 424   i = comp_target_types (type, intype, 0);
 425
 426   if (i <= 0 && (convtype & CONV_IMPLICIT) && IS_AGGR_TYPE (intype)
 427       && ! (flags & LOOKUP_NO_CONVERSION))
 428     {
 429       /* Look for a user-defined conversion to lvalue that we can use.  */
 430
 431       rval_as_conversion
 432         = build_type_conversion (CONVERT_EXPR, reftype, expr, 1);
 433
 434       if (rval_as_conversion && rval_as_conversion != error_mark_node
 435           && real_lvalue_p (rval_as_conversion))
 436         {
 437           expr = rval_as_conversion;
 438           rval_as_conversion = NULL_TREE;
 439           intype = type;
 440           i = 1;
 441         }
 442     }
 443
 444   if (((convtype & CONV_STATIC) && i == -1)
 445       || ((convtype & CONV_IMPLICIT) && i == 1))
 446     {
 447       if (flags & LOOKUP_COMPLAIN)
 448         {
 449           tree ttl = TREE_TYPE (reftype);
 450           tree ttr = lvalue_type (expr);
 451
 452           /* [dcl.init.ref] says that if an rvalue is used to
 453              initialize a reference, then the reference must be to a
 454              non-volatile const type.  */
 455           if (! real_lvalue_p (expr)
 456               && !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
 457             {
 458               char* msg;
 459
 460               if (CP_TYPE_VOLATILE_P (ttl) && decl)
 461                 msg = "initialization of volatile reference type `%#T'";
 462               else if (CP_TYPE_VOLATILE_P (ttl))
 463                 msg = "conversion to volatile reference type `%#T'";
 464               else if (decl)
 465                 msg = "initialization of non-const reference type `%#T'";
 466               else
 467                 msg = "conversion to non-const reference type `%#T'";
 468
 469               cp_error (msg, reftype);
 470               cp_error ("from rvalue of type `%T'", intype);
 471             }
 472           else if (! (convtype & CONV_CONST)
 473                    && !at_least_as_qualified_p (ttl, ttr))
 474             cp_error ("conversion from `%T' to `%T' discards qualifiers",
 475                       ttr, reftype);
 476         }
 477
 478       return build_up_reference (reftype, expr, flags);
 479     }
 480   else if ((convtype & CONV_REINTERPRET) && lvalue_p (expr))
 481     {
 482       /* When casting an lvalue to a reference type, just convert into
 483          a pointer to the new type and deference it.  This is allowed
 484          by San Diego WP section 5.2.9 paragraph 12, though perhaps it
 485          should be done directly (jason).  (int &)ri ---> *(int*)&ri */
 486
 487       /* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
 488          meant.  */
 489       if (TREE_CODE (intype) == POINTER_TYPE
 490           && (comptypes (TREE_TYPE (intype), type,
 491                          COMPARE_BASE | COMPARE_RELAXED )))
 492         cp_warning ("casting `%T' to `%T' does not dereference pointer",
 493                     intype, reftype);
 494
 495       rval = build_unary_op (ADDR_EXPR, expr, 0);
 496       if (rval != error_mark_node)
 497         rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
 498                               rval, 0);
 499       if (rval != error_mark_node)
 500         rval = build1 (NOP_EXPR, reftype, rval);
 501     }
 502   else
 503     {
 504       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
 505                                          "converting", 0, 0);
 506       if (rval == error_mark_node)
 507         return error_mark_node;
 508       rval = build_up_reference (reftype, rval, flags);
 509
 510       if (rval && ! CP_TYPE_CONST_P (TREE_TYPE (reftype)))
 511         cp_pedwarn ("initializing non-const `%T' with `%T' will use a temporary",
 512                     reftype, intype);
 513     }
 514
 515   if (rval)
 516     {
 517       /* If we found a way to convert earlier, then use it.  */
 518       return rval;
 519     }
 520
 521   my_friendly_assert (TREE_CODE (intype) != OFFSET_TYPE, 189);
 522
 523   if (flags & LOOKUP_COMPLAIN)
 524     cp_error ("cannot convert type `%T' to type `%T'", intype, reftype);
 525
 526   if (flags & LOOKUP_SPECULATIVELY)
 527     return NULL_TREE;
 528
 529   return error_mark_node;
 530 }
 531
 532 /* We are using a reference VAL for its value. Bash that reference all the
 533    way down to its lowest form.  */
 534
 535 tree
 536 convert_from_reference (val)
 537      tree val;
 538 {
 539   tree type = TREE_TYPE (val);
 540
 541   if (TREE_CODE (type) == OFFSET_TYPE)
 542     type = TREE_TYPE (type);
 543   if (TREE_CODE (type) == REFERENCE_TYPE)
 544     return build_indirect_ref (val, NULL_PTR);
 545   return val;
 546 }
 547 \f
 548 /* Call this when we know (for any reason) that expr is not, in fact,
 549    zero.  This routine is like convert_pointer_to, but it pays
 550    attention to which specific instance of what type we want to
 551    convert to.  This routine should eventually become
 552    convert_to_pointer after all references to convert_to_pointer
 553    are removed.  */
 554
 555 tree
 556 convert_pointer_to_real (binfo, expr)
 557      tree binfo, expr;
 558 {
 559   register tree intype = TREE_TYPE (expr);
 560   tree ptr_type;
 561   tree type, rval;
 562
 563   if (intype == error_mark_node)
 564     return error_mark_node;
 565
 566   if (TREE_CODE (binfo) == TREE_VEC)
 567     type = BINFO_TYPE (binfo);
 568   else if (IS_AGGR_TYPE (binfo))
 569     {
 570       type = binfo;
 571     }
 572   else
 573     {
 574       type = binfo;
 575       binfo = NULL_TREE;
 576     }
 577
 578   ptr_type = cp_build_qualified_type (type,
 579                                       CP_TYPE_QUALS (TREE_TYPE (intype)));
 580   ptr_type = build_pointer_type (ptr_type);
 581   if (ptr_type == TYPE_MAIN_VARIANT (intype))
 582     return expr;
 583
 584   my_friendly_assert (!integer_zerop (expr), 191);
 585
 586   intype = TYPE_MAIN_VARIANT (TREE_TYPE (intype));
 587   if (TREE_CODE (type) == RECORD_TYPE
 588       && TREE_CODE (intype) == RECORD_TYPE
 589       && type != intype)
 590     {
 591       tree path;
 592       int distance
 593         = get_base_distance (binfo, intype, 0, &path);
 594
 595       /* This function shouldn't be called with unqualified arguments
 596          but if it is, give them an error message that they can read.  */
 597       if (distance < 0)
 598         {
 599           cp_error ("cannot convert a pointer of type `%T' to a pointer of type `%T'",
 600                     intype, type);
 601
 602           if (distance == -2)
 603             cp_error ("because `%T' is an ambiguous base class", type);
 604           return error_mark_node;
 605         }
 606
 607       return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1);
 608     }
 609   rval = build1 (NOP_EXPR, ptr_type,
 610                  TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr);
 611   TREE_CONSTANT (rval) = TREE_CONSTANT (expr);
 612   return rval;
 613 }
 614
 615 /* Call this when we know (for any reason) that expr is
 616    not, in fact, zero.  This routine gets a type out of the first
 617    argument and uses it to search for the type to convert to.  If there
 618    is more than one instance of that type in the expr, the conversion is
 619    ambiguous.  This routine should eventually go away, and all
 620    callers should use convert_to_pointer_real.  */
 621
 622 tree
 623 convert_pointer_to (binfo, expr)
 624      tree binfo, expr;
 625 {
 626   tree type;
 627
 628   if (TREE_CODE (binfo) == TREE_VEC)
 629     type = BINFO_TYPE (binfo);
 630   else if (IS_AGGR_TYPE (binfo))
 631       type = binfo;
 632   else
 633       type = binfo;
 634   return convert_pointer_to_real (type, expr);
 635 }
 636 \f
 637 /* C++ conversions, preference to static cast conversions.  */
 638
 639 tree
 640 cp_convert (type, expr)
 641      tree type, expr;
 642 {
 643   return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL);
 644 }
 645
 646 /* Conversion...
 647
 648    FLAGS indicates how we should behave.  */
 649
 650 tree
 651 ocp_convert (type, expr, convtype, flags)
 652      tree type, expr;
 653      int convtype, flags;
 654 {
 655   register tree e = expr;
 656   register enum tree_code code = TREE_CODE (type);
 657
 658   if (e == error_mark_node
 659       || TREE_TYPE (e) == error_mark_node)
 660     return error_mark_node;
 661
 662   if (TREE_READONLY_DECL_P (e))
 663     e = decl_constant_value (e);
 664
 665   if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
 666       /* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
 667          don't go through finish_struct, so they don't have the synthesized
 668          constructors.  So don't force a temporary.  */
 669       && TYPE_HAS_CONSTRUCTOR (type))
 670     /* We need a new temporary; don't take this shortcut.  */;
 671   else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
 672     {
 673       if (same_type_p (type, TREE_TYPE (e)))
 674         /* The call to fold will not always remove the NOP_EXPR as
 675            might be expected, since if one of the types is a typedef;
 676            the comparsion in fold is just equality of pointers, not a
 677            call to comptypes.  We don't call fold in this case because
 678            that can result in infinite recursion; fold will call
 679            convert, which will call ocp_convert, etc.  */
 680         return e;
 681       else
 682         return fold (build1 (NOP_EXPR, type, e));
 683     }
 684
 685   if (code == VOID_TYPE && (convtype & CONV_STATIC))
 686     {
 687       if (type_unknown_p (e))
 688         error ("address of overloaded function with no contextual type information");
 689
 690       return build1 (CONVERT_EXPR, type, e);
 691     }
 692
 693 #if 0
 694   /* This is incorrect.  A truncation can't be stripped this way.
 695      Extensions will be stripped by the use of get_unwidened.  */
 696   if (TREE_CODE (e) == NOP_EXPR)
 697     return cp_convert (type, TREE_OPERAND (e, 0));
 698 #endif
 699
 700   /* Just convert to the type of the member.  */
 701   if (code == OFFSET_TYPE)
 702     {
 703       type = TREE_TYPE (type);
 704       code = TREE_CODE (type);
 705     }
 706
 707 #if 0
 708   if (code == REFERENCE_TYPE)
 709     return fold (convert_to_reference (type, e, convtype, flags, NULL_TREE));
 710   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
 711     e = convert_from_reference (e);
 712 #endif
 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 (CONVERT_EXPR, 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 (CONVERT_EXPR, 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 of object pointers or signature pointers/references
 786          to signature pointers/references.  */
 787
 788       if (TYPE_LANG_SPECIFIC (type)
 789           && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)))
 790         {
 791           tree constructor = build_signature_pointer_constructor (type, expr);
 792           tree sig_ty = SIGNATURE_TYPE (type);
 793           tree sig_ptr;
 794
 795           if (constructor == error_mark_node)
 796             return error_mark_node;
 797
 798           sig_ptr = get_temp_name (type, 1);
 799           DECL_INITIAL (sig_ptr) = constructor;
 800           CLEAR_SIGNATURE (sig_ty);
 801           cp_finish_decl (sig_ptr, constructor, NULL_TREE, 0, 0);
 802           SET_SIGNATURE (sig_ty);
 803           TREE_READONLY (sig_ptr) = 1;
 804
 805           return sig_ptr;
 806         }
 807
 808       /* Conversion between aggregate types.  New C++ semantics allow
 809          objects of derived type to be cast to objects of base type.
 810          Old semantics only allowed this between pointers.
 811
 812          There may be some ambiguity between using a constructor
 813          vs. using a type conversion operator when both apply.  */
 814
 815       ctor = e;
 816
 817       if ((flags & LOOKUP_ONLYCONVERTING)
 818           && ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
 819         /* For copy-initialization, first we create a temp of the proper type
 820            with a user-defined conversion sequence, then we direct-initialize
 821            the target with the temp (see [dcl.init]).  */
 822         ctor = build_user_type_conversion (type, ctor, flags);
 823       if (ctor)
 824         ctor = build_method_call (NULL_TREE, ctor_identifier,
 825                                   build_expr_list (NULL_TREE, ctor),
 826                                   TYPE_BINFO (type), flags);
 827       if (ctor)
 828         return build_cplus_new (type, ctor);
 829     }
 830
 831   /* If TYPE or TREE_TYPE (E) is not on the permanent_obstack,
 832      then it won't be hashed and hence compare as not equal,
 833      even when it is.  */
 834   if (code == ARRAY_TYPE
 835       && TREE_TYPE (TREE_TYPE (e)) == TREE_TYPE (type)
 836       && index_type_equal (TYPE_DOMAIN (TREE_TYPE (e)), TYPE_DOMAIN (type)))
 837     return e;
 838
 839   if (flags & LOOKUP_COMPLAIN)
 840     cp_error ("conversion from `%T' to non-scalar type `%T' requested",
 841               TREE_TYPE (expr), type);
 842   if (flags & LOOKUP_SPECULATIVELY)
 843     return NULL_TREE;
 844   return error_mark_node;
 845 }
 846
 847 /* Create an expression whose value is that of EXPR,
 848    converted to type TYPE.  The TREE_TYPE of the value
 849    is always TYPE.  This function implements all reasonable
 850    conversions; callers should filter out those that are
 851    not permitted by the language being compiled.
 852
 853    Most of this routine is from build_reinterpret_cast.
 854
 855    The backend cannot call cp_convert (what was convert) because
 856    conversions to/from basetypes may involve memory references
 857    (vbases) and adding or subtracting small values (multiple
 858    inheritance), but it calls convert from the constant folding code
 859    on subtrees of already build trees after it has ripped them apart.
 860
 861    Also, if we ever support range variables, we'll probably also have to
 862    do a little bit more work.  */
 863
 864 tree
 865 convert (type, expr)
 866      tree type, expr;
 867 {
 868   tree intype;
 869
 870   if (type == error_mark_node || expr == error_mark_node)
 871     return error_mark_node;
 872
 873   intype = TREE_TYPE (expr);
 874
 875   if (POINTER_TYPE_P (type) && POINTER_TYPE_P (intype))
 876     {
 877       if (TREE_READONLY_DECL_P (expr))
 878         expr = decl_constant_value (expr);
 879       return fold (build1 (NOP_EXPR, type, expr));
 880     }
 881
 882   return ocp_convert (type, expr, CONV_OLD_CONVERT,
 883                       LOOKUP_NORMAL|LOOKUP_NO_CONVERSION);
 884 }
 885
 886 /* Like cp_convert, except permit conversions to take place which
 887    are not normally allowed due to access restrictions
 888    (such as conversion from sub-type to private super-type).  */
 889
 890 tree
 891 convert_force (type, expr, convtype)
 892      tree type;
 893      tree expr;
 894      int convtype;
 895 {
 896   register tree e = expr;
 897   register enum tree_code code = TREE_CODE (type);
 898
 899   if (code == REFERENCE_TYPE)
 900     return fold (convert_to_reference (type, e, CONV_C_CAST, LOOKUP_COMPLAIN,
 901                                        NULL_TREE));
 902   else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE)
 903     e = convert_from_reference (e);
 904
 905   if (code == POINTER_TYPE)
 906     return fold (convert_to_pointer_force (type, e));
 907
 908   /* From typeck.c convert_for_assignment */
 909   if (((TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE && TREE_CODE (e) == ADDR_EXPR
 910         && TREE_CODE (TREE_TYPE (e)) == POINTER_TYPE
 911         && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
 912        || integer_zerop (e)
 913        || TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
 914       && TYPE_PTRMEMFUNC_P (type))
 915     {
 916       /* compatible pointer to member functions.  */
 917       return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1);
 918     }
 919
 920   return ocp_convert (type, e, CONV_C_CAST|convtype, LOOKUP_NORMAL);
 921 }
 922
 923 /* Convert an aggregate EXPR to type XTYPE.  If a conversion
 924    exists, return the attempted conversion.  This may
 925    return ERROR_MARK_NODE if the conversion is not
 926    allowed (references private members, etc).
 927    If no conversion exists, NULL_TREE is returned.
 928
 929    If (FOR_SURE & 1) is non-zero, then we allow this type conversion
 930    to take place immediately.  Otherwise, we build a SAVE_EXPR
 931    which can be evaluated if the results are ever needed.
 932
 933    Changes to this functions should be mirrored in user_harshness.
 934
 935    FIXME: Ambiguity checking is wrong.  Should choose one by the implicit
 936    object parameter, or by the second standard conversion sequence if
 937    that doesn't do it.  This will probably wait for an overloading rewrite.
 938    (jason 8/9/95)  */
 939
 940 tree
 941 build_type_conversion (code, xtype, expr, for_sure)
 942      enum tree_code code ATTRIBUTE_UNUSED;
 943      tree xtype, expr;
 944      int for_sure;
 945 {
 946   /* C++: check to see if we can convert this aggregate type
 947      into the required type.  */
 948   return build_user_type_conversion
 949     (xtype, expr, for_sure ? LOOKUP_NORMAL : 0);
 950 }
 951
 952 /* Convert the given EXPR to one of a group of types suitable for use in an
 953    expression.  DESIRES is a combination of various WANT_* flags (q.v.)
 954    which indicates which types are suitable.  If COMPLAIN is 1, complain
 955    about ambiguity; otherwise, the caller will deal with it.  */
 956
 957 tree
 958 build_expr_type_conversion (desires, expr, complain)
 959      int desires;
 960      tree expr;
 961      int complain;
 962 {
 963   tree basetype = TREE_TYPE (expr);
 964   tree conv = NULL_TREE;
 965   tree winner = NULL_TREE;
 966
 967   if (expr == null_node
 968       && (desires & WANT_INT)
 969       && !(desires & WANT_NULL))
 970     cp_warning ("converting NULL to non-pointer type");
 971
 972   if (TREE_CODE (basetype) == OFFSET_TYPE)
 973     expr = resolve_offset_ref (expr);
 974   expr = convert_from_reference (expr);
 975   basetype = TREE_TYPE (expr);
 976
 977   if (! IS_AGGR_TYPE (basetype))
 978     switch (TREE_CODE (basetype))
 979       {
 980       case INTEGER_TYPE:
 981         if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
 982           return expr;
 983         /* else fall through...  */
 984
 985       case BOOLEAN_TYPE:
 986         return (desires & WANT_INT) ? expr : NULL_TREE;
 987       case ENUMERAL_TYPE:
 988         return (desires & WANT_ENUM) ? expr : NULL_TREE;
 989       case REAL_TYPE:
 990         return (desires & WANT_FLOAT) ? expr : NULL_TREE;
 991       case POINTER_TYPE:
 992         return (desires & WANT_POINTER) ? expr : NULL_TREE;
 993
 994       case FUNCTION_TYPE:
 995       case ARRAY_TYPE:
 996         return (desires & WANT_POINTER) ? default_conversion (expr)
 997                                         : NULL_TREE;
 998       default:
 999         return NULL_TREE;
1000       }
1001
1002   /* The code for conversions from class type is currently only used for
1003      delete expressions.  Other expressions are handled by build_new_op.  */
1004
1005   if (! TYPE_HAS_CONVERSION (basetype))
1006     return NULL_TREE;
1007
1008   for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1009     {
1010       int win = 0;
1011       tree candidate;
1012       tree cand = TREE_VALUE (conv);
1013
1014       if (winner && winner == cand)
1015         continue;
1016
1017       candidate = TREE_TYPE (TREE_TYPE (cand));
1018       if (TREE_CODE (candidate) == REFERENCE_TYPE)
1019         candidate = TREE_TYPE (candidate);
1020
1021       switch (TREE_CODE (candidate))
1022         {
1023         case BOOLEAN_TYPE:
1024         case INTEGER_TYPE:
1025           win = (desires & WANT_INT); break;
1026         case ENUMERAL_TYPE:
1027           win = (desires & WANT_ENUM); break;
1028         case REAL_TYPE:
1029           win = (desires & WANT_FLOAT); break;
1030         case POINTER_TYPE:
1031           win = (desires & WANT_POINTER); break;
1032
1033         default:
1034           break;
1035         }
1036
1037       if (win)
1038         {
1039           if (winner)
1040             {
1041               if (complain)
1042                 {
1043                   cp_error ("ambiguous default type conversion from `%T'",
1044                             basetype);
1045                   cp_error ("  candidate conversions include `%D' and `%D'",
1046                             winner, cand);
1047                 }
1048               return error_mark_node;
1049             }
1050           else
1051             winner = cand;
1052         }
1053     }
1054
1055   if (winner)
1056     {
1057       tree type = TREE_TYPE (TREE_TYPE (winner));
1058       if (TREE_CODE (type) == REFERENCE_TYPE)
1059         type = TREE_TYPE (type);
1060       return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
1061     }
1062
1063   return NULL_TREE;
1064 }
1065
1066 /* Implements integral promotion (4.1) and float->double promotion.  */
1067
1068 tree
1069 type_promotes_to (type)
1070      tree type;
1071 {
1072   int type_quals;
1073
1074   if (type == error_mark_node)
1075     return error_mark_node;
1076
1077   type_quals = CP_TYPE_QUALS (type);
1078   type = TYPE_MAIN_VARIANT (type);
1079
1080   /* bool always promotes to int (not unsigned), even if it's the same
1081      size.  */
1082   if (type == boolean_type_node)
1083     type = integer_type_node;
1084
1085   /* Normally convert enums to int, but convert wide enums to something
1086      wider.  */
1087   else if (TREE_CODE (type) == ENUMERAL_TYPE
1088            || type == wchar_type_node)
1089     {
1090       int precision = MAX (TYPE_PRECISION (type),
1091                            TYPE_PRECISION (integer_type_node));
1092       tree totype = type_for_size (precision, 0);
1093       if (TREE_UNSIGNED (type)
1094           && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype))
1095         type = type_for_size (precision, 1);
1096       else
1097         type = totype;
1098     }
1099   else if (C_PROMOTING_INTEGER_TYPE_P (type))
1100     {
1101       /* Retain unsignedness if really not getting bigger.  */
1102       if (TREE_UNSIGNED (type)
1103           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1104         type = unsigned_type_node;
1105       else
1106         type = integer_type_node;
1107     }
1108   else if (type == float_type_node)
1109     type = double_type_node;
1110
1111   return cp_build_qualified_type (type, type_quals);
1112 }
1113
1114 /* The routines below this point are carefully written to conform to
1115    the standard.  They use the same terminology, and follow the rules
1116    closely.  Although they are used only in pt.c at the moment, they
1117    should presumably be used everywhere in the future.  */
1118
1119 /* Attempt to perform qualification conversions on EXPR to convert it
1120    to TYPE.  Return the resulting expression, or error_mark_node if
1121    the conversion was impossible.  */
1122
1123 tree
1124 perform_qualification_conversions (type, expr)
1125      tree type;
1126      tree expr;
1127 {
1128   if (TREE_CODE (type) == POINTER_TYPE
1129       && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE
1130       && comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (expr))))
1131     return build1 (NOP_EXPR, type, expr);
1132   else
1133     return error_mark_node;
1134 }