gcc/cp/typeck.c

   1 /* Build expressions with type checking for C++ compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* This file is part of the C++ front end.
  25    It contains routines to build C++ expressions given their operands,
  26    including computing the types of the result, C and C++ specific error
  27    checks, and some optimization.
  28
  29    There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
  30    and to process initializations in declarations (since they work
  31    like a strange sort of assignment).  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "coretypes.h"
  36 #include "tm.h"
  37 #include "tree.h"
  38 #include "rtl.h"
  39 #include "expr.h"
  40 #include "cp-tree.h"
  41 #include "tm_p.h"
  42 #include "flags.h"
  43 #include "output.h"
  44 #include "toplev.h"
  45 #include "diagnostic.h"
  46 #include "target.h"
  47
  48 static tree convert_for_assignment PARAMS ((tree, tree, const char *, tree,
  49                                           int));
  50 static tree cp_pointer_int_sum PARAMS ((enum tree_code, tree, tree));
  51 static tree rationalize_conditional_expr PARAMS ((enum tree_code, tree));
  52 static int comp_target_parms PARAMS ((tree, tree));
  53 static int comp_ptr_ttypes_real PARAMS ((tree, tree, int));
  54 static int comp_ptr_ttypes_const PARAMS ((tree, tree));
  55 static int comp_ptr_ttypes_reinterpret PARAMS ((tree, tree));
  56 static int comp_except_types PARAMS ((tree, tree, int));
  57 static int comp_array_types PARAMS ((int (*) (tree, tree, int), tree,
  58                                    tree, int));
  59 static tree common_base_type PARAMS ((tree, tree));
  60 static tree lookup_anon_field PARAMS ((tree, tree));
  61 static tree pointer_diff PARAMS ((tree, tree, tree));
  62 static tree qualify_type_recursive PARAMS ((tree, tree));
  63 static tree get_delta_difference PARAMS ((tree, tree, int));
  64 static int comp_cv_target_types PARAMS ((tree, tree, int));
  65 static void casts_away_constness_r PARAMS ((tree *, tree *));
  66 static int casts_away_constness PARAMS ((tree, tree));
  67 static void maybe_warn_about_returning_address_of_local PARAMS ((tree));
  68 static tree strip_all_pointer_quals PARAMS ((tree));
  69 static tree lookup_destructor (tree, tree, tree);
  70
  71 /* Return the target type of TYPE, which means return T for:
  72    T*, T&, T[], T (...), and otherwise, just T.  */
  73
  74 tree
  75 target_type (type)
  76      tree type;
  77 {
  78   if (TREE_CODE (type) == REFERENCE_TYPE)
  79     type = TREE_TYPE (type);
  80   while (TREE_CODE (type) == POINTER_TYPE
  81          || TREE_CODE (type) == ARRAY_TYPE
  82          || TREE_CODE (type) == FUNCTION_TYPE
  83          || TREE_CODE (type) == METHOD_TYPE
  84          || TREE_CODE (type) == OFFSET_TYPE)
  85     type = TREE_TYPE (type);
  86   return type;
  87 }
  88
  89 /* Do `exp = require_complete_type (exp);' to make sure exp
  90    does not have an incomplete type.  (That includes void types.)
  91    Returns the error_mark_node if the VALUE does not have
  92    complete type when this function returns.  */
  93
  94 tree
  95 require_complete_type (value)
  96      tree value;
  97 {
  98   tree type;
  99
 100   if (processing_template_decl || value == error_mark_node)
 101     return value;
 102
 103   if (TREE_CODE (value) == OVERLOAD)
 104     type = unknown_type_node;
 105   else
 106     type = TREE_TYPE (value);
 107
 108   /* First, detect a valid value with a complete type.  */
 109   if (COMPLETE_TYPE_P (type))
 110     return value;
 111
 112   /* If we see X::Y, we build an OFFSET_TYPE which has
 113      not been laid out.  Try to avoid an error by interpreting
 114      it as this->X::Y, if reasonable.  */
 115   if (TREE_CODE (value) == OFFSET_REF
 116       && current_class_ref != 0
 117       && TREE_OPERAND (value, 0) == current_class_ref)
 118     {
 119       value = resolve_offset_ref (value);
 120       return require_complete_type (value);
 121     }
 122
 123   if (complete_type_or_else (type, value))
 124     return value;
 125   else
 126     return error_mark_node;
 127 }
 128
 129 /* Try to complete TYPE, if it is incomplete.  For example, if TYPE is
 130    a template instantiation, do the instantiation.  Returns TYPE,
 131    whether or not it could be completed, unless something goes
 132    horribly wrong, in which case the error_mark_node is returned.  */
 133
 134 tree
 135 complete_type (type)
 136      tree type;
 137 {
 138   if (type == NULL_TREE)
 139     /* Rather than crash, we return something sure to cause an error
 140        at some point.  */
 141     return error_mark_node;
 142
 143   if (type == error_mark_node || COMPLETE_TYPE_P (type))
 144     ;
 145   else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
 146     {
 147       tree t = complete_type (TREE_TYPE (type));
 148       if (COMPLETE_TYPE_P (t) && ! processing_template_decl)
 149         layout_type (type);
 150       TYPE_NEEDS_CONSTRUCTING (type)
 151         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
 152       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 153         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));
 154     }
 155   else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))
 156     instantiate_class_template (TYPE_MAIN_VARIANT (type));
 157
 158   return type;
 159 }
 160
 161 /* Like complete_type, but issue an error if the TYPE cannot be completed.
 162    VALUE is used for informative diagnostics.  DIAG_TYPE indicates the type
 163    of diagnostic: 0 for an error, 1 for a warning, 2 for a pedwarn.
 164    Returns NULL_TREE if the type cannot be made complete.  */
 165
 166 tree
 167 complete_type_or_diagnostic (type, value, diag_type)
 168      tree type;
 169      tree value;
 170      int diag_type;
 171 {
 172   type = complete_type (type);
 173   if (type == error_mark_node)
 174     /* We already issued an error.  */
 175     return NULL_TREE;
 176   else if (!COMPLETE_TYPE_P (type))
 177     {
 178       cxx_incomplete_type_diagnostic (value, type, diag_type);
 179       return NULL_TREE;
 180     }
 181   else
 182     return type;
 183 }
 184
 185 /* Return truthvalue of whether type of EXP is instantiated.  */
 186
 187 int
 188 type_unknown_p (exp)
 189      tree exp;
 190 {
 191   return (TREE_CODE (exp) == OVERLOAD
 192           || TREE_CODE (exp) == TREE_LIST
 193           || TREE_TYPE (exp) == unknown_type_node
 194           || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE
 195               && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node));
 196 }
 197
 198 /* Return a pointer or pointer to member type similar to T1, with a
 199    cv-qualification signature that is the union of the cv-qualification
 200    signatures of T1 and T2: [expr.rel], [expr.eq].  */
 201
 202 static tree
 203 qualify_type_recursive (t1, t2)
 204      tree t1, t2;
 205 {
 206   if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
 207       || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)))
 208     {
 209       tree tt1;
 210       tree tt2;
 211       tree b1;
 212       int type_quals;
 213       tree tgt;
 214       tree attributes = (*targetm.merge_type_attributes) (t1, t2);
 215
 216       if (TYPE_PTRMEM_P (t1))
 217         {
 218           b1 = TYPE_PTRMEM_CLASS_TYPE (t1);
 219           tt1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1);
 220           tt2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2);
 221         }
 222       else
 223         {
 224           b1 = NULL_TREE;
 225           tt1 = TREE_TYPE (t1);
 226           tt2 = TREE_TYPE (t2);
 227         }
 228
 229       type_quals = (cp_type_quals (tt1) | cp_type_quals (tt2));
 230       tgt = qualify_type_recursive (tt1, tt2);
 231       tgt = cp_build_qualified_type (tgt, type_quals);
 232       if (b1)
 233         t1 = build_ptrmem_type (b1, tgt);
 234       else
 235         t1 = build_pointer_type (tgt);
 236       t1 = build_type_attribute_variant (t1, attributes);
 237     }
 238   return t1;
 239 }
 240 \f
 241 /* Return the common type of two parameter lists.
 242    We assume that comptypes has already been done and returned 1;
 243    if that isn't so, this may crash.
 244
 245    As an optimization, free the space we allocate if the parameter
 246    lists are already common.  */
 247
 248 tree
 249 commonparms (p1, p2)
 250      tree p1, p2;
 251 {
 252   tree oldargs = p1, newargs, n;
 253   int i, len;
 254   int any_change = 0;
 255
 256   len = list_length (p1);
 257   newargs = tree_last (p1);
 258
 259   if (newargs == void_list_node)
 260     i = 1;
 261   else
 262     {
 263       i = 0;
 264       newargs = 0;
 265     }
 266
 267   for (; i < len; i++)
 268     newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 269
 270   n = newargs;
 271
 272   for (i = 0; p1;
 273        p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++)
 274     {
 275       if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2))
 276         {
 277           TREE_PURPOSE (n) = TREE_PURPOSE (p1);
 278           any_change = 1;
 279         }
 280       else if (! TREE_PURPOSE (p1))
 281         {
 282           if (TREE_PURPOSE (p2))
 283             {
 284               TREE_PURPOSE (n) = TREE_PURPOSE (p2);
 285               any_change = 1;
 286             }
 287         }
 288       else
 289         {
 290           if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2)))
 291             any_change = 1;
 292           TREE_PURPOSE (n) = TREE_PURPOSE (p2);
 293         }
 294       if (TREE_VALUE (p1) != TREE_VALUE (p2))
 295         {
 296           any_change = 1;
 297           TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2));
 298         }
 299       else
 300         TREE_VALUE (n) = TREE_VALUE (p1);
 301     }
 302   if (! any_change)
 303     return oldargs;
 304
 305   return newargs;
 306 }
 307
 308 /* Given a type, perhaps copied for a typedef,
 309    find the "original" version of it.  */
 310 tree
 311 original_type (t)
 312      tree t;
 313 {
 314   while (TYPE_NAME (t) != NULL_TREE)
 315     {
 316       tree x = TYPE_NAME (t);
 317       if (TREE_CODE (x) != TYPE_DECL)
 318         break;
 319       x = DECL_ORIGINAL_TYPE (x);
 320       if (x == NULL_TREE)
 321         break;
 322       t = x;
 323     }
 324   return t;
 325 }
 326
 327 /* T1 and T2 are arithmetic or enumeration types.  Return the type
 328    that will result from the "usual arithmetic conversions" on T1 and
 329    T2 as described in [expr].  */
 330
 331 tree
 332 type_after_usual_arithmetic_conversions (t1, t2)
 333      tree t1;
 334      tree t2;
 335 {
 336   enum tree_code code1 = TREE_CODE (t1);
 337   enum tree_code code2 = TREE_CODE (t2);
 338   tree attributes;
 339
 340   /* FIXME: Attributes.  */
 341   my_friendly_assert (ARITHMETIC_TYPE_P (t1)
 342                       || TREE_CODE (t1) == COMPLEX_TYPE
 343                       || TREE_CODE (t1) == ENUMERAL_TYPE,
 344                       19990725);
 345   my_friendly_assert (ARITHMETIC_TYPE_P (t2)
 346                       || TREE_CODE (t2) == COMPLEX_TYPE
 347                       || TREE_CODE (t2) == ENUMERAL_TYPE,
 348                       19990725);
 349
 350   /* In what follows, we slightly generalize the rules given in [expr] so
 351      as to deal with `long long' and `complex'.  First, merge the
 352      attributes.  */
 353   attributes = (*targetm.merge_type_attributes) (t1, t2);
 354
 355   /* If one type is complex, form the common type of the non-complex
 356      components, then make that complex.  Use T1 or T2 if it is the
 357      required type.  */
 358   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 359     {
 360       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 361       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 362       tree subtype
 363         = type_after_usual_arithmetic_conversions (subtype1, subtype2);
 364
 365       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 366         return build_type_attribute_variant (t1, attributes);
 367       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 368         return build_type_attribute_variant (t2, attributes);
 369       else
 370         return build_type_attribute_variant (build_complex_type (subtype),
 371                                              attributes);
 372     }
 373
 374   /* If only one is real, use it as the result.  */
 375   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 376     return build_type_attribute_variant (t1, attributes);
 377   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 378     return build_type_attribute_variant (t2, attributes);
 379
 380   /* Perform the integral promotions.  */
 381   if (code1 != REAL_TYPE)
 382     {
 383       t1 = type_promotes_to (t1);
 384       t2 = type_promotes_to (t2);
 385     }
 386
 387   /* Both real or both integers; use the one with greater precision.  */
 388   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 389     return build_type_attribute_variant (t1, attributes);
 390   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 391     return build_type_attribute_variant (t2, attributes);
 392
 393   /* The types are the same; no need to do anything fancy.  */
 394   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 395     return build_type_attribute_variant (t1, attributes);
 396
 397   if (code1 != REAL_TYPE)
 398     {
 399       /* If one is a sizetype, use it so size_binop doesn't blow up.  */
 400       if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2))
 401         return build_type_attribute_variant (t1, attributes);
 402       if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1))
 403         return build_type_attribute_variant (t2, attributes);
 404
 405       /* If one is unsigned long long, then convert the other to unsigned
 406          long long.  */
 407       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node)
 408           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node))
 409         return build_type_attribute_variant (long_long_unsigned_type_node,
 410                                              attributes);
 411       /* If one is a long long, and the other is an unsigned long, and
 412          long long can represent all the values of an unsigned long, then
 413          convert to a long long.  Otherwise, convert to an unsigned long
 414          long.  Otherwise, if either operand is long long, convert the
 415          other to long long.
 416
 417          Since we're here, we know the TYPE_PRECISION is the same;
 418          therefore converting to long long cannot represent all the values
 419          of an unsigned long, so we choose unsigned long long in that
 420          case.  */
 421       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node)
 422           || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node))
 423         {
 424           tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
 425                     ? long_long_unsigned_type_node
 426                     : long_long_integer_type_node);
 427           return build_type_attribute_variant (t, attributes);
 428         }
 429
 430       /* Go through the same procedure, but for longs.  */
 431       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node)
 432           || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node))
 433         return build_type_attribute_variant (long_unsigned_type_node,
 434                                              attributes);
 435       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node)
 436           || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node))
 437         {
 438           tree t = ((TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
 439                     ? long_unsigned_type_node : long_integer_type_node);
 440           return build_type_attribute_variant (t, attributes);
 441         }
 442       /* Otherwise prefer the unsigned one.  */
 443       if (TREE_UNSIGNED (t1))
 444         return build_type_attribute_variant (t1, attributes);
 445       else
 446         return build_type_attribute_variant (t2, attributes);
 447     }
 448   else
 449     {
 450       if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node)
 451           || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node))
 452         return build_type_attribute_variant (long_double_type_node,
 453                                              attributes);
 454       if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node)
 455           || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node))
 456         return build_type_attribute_variant (double_type_node,
 457                                              attributes);
 458       if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node)
 459           || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node))
 460         return build_type_attribute_variant (float_type_node,
 461                                              attributes);
 462
 463       /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of
 464          the standard C++ floating-point types.  Logic earlier in this
 465          function has already eliminated the possibility that
 466          TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no
 467          compelling reason to choose one or the other.  */
 468       return build_type_attribute_variant (t1, attributes);
 469     }
 470 }
 471
 472 /* Return the composite pointer type (see [expr.rel]) for T1 and T2.
 473    ARG1 and ARG2 are the values with those types.  The LOCATION is a
 474    string describing the current location, in case an error occurs.  */
 475
 476 tree
 477 composite_pointer_type (t1, t2, arg1, arg2, location)
 478      tree t1;
 479      tree t2;
 480      tree arg1;
 481      tree arg2;
 482      const char* location;
 483 {
 484   tree result_type;
 485   tree attributes;
 486
 487   /* [expr.rel]
 488
 489      If one operand is a null pointer constant, the composite pointer
 490      type is the type of the other operand.  */
 491   if (null_ptr_cst_p (arg1))
 492     return t2;
 493   if (null_ptr_cst_p (arg2))
 494     return t1;
 495
 496   /* Deal with pointer-to-member functions in the same way as we deal
 497      with pointers to functions.  */
 498   if (TYPE_PTRMEMFUNC_P (t1))
 499     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
 500   if (TYPE_PTRMEMFUNC_P (t2))
 501     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
 502
 503   /* Merge the attributes.  */
 504   attributes = (*targetm.merge_type_attributes) (t1, t2);
 505
 506   /* We have:
 507
 508        [expr.rel]
 509
 510        If one of the operands has type "pointer to cv1 void*", then
 511        the other has type "pointer to cv2T", and the composite pointer
 512        type is "pointer to cv12 void", where cv12 is the union of cv1
 513        and cv2.
 514
 515     If either type is a pointer to void, make sure it is T1.  */
 516   if (VOID_TYPE_P (TREE_TYPE (t2)))
 517     {
 518       tree t;
 519       t = t1;
 520       t1 = t2;
 521       t2 = t;
 522     }
 523   /* Now, if T1 is a pointer to void, merge the qualifiers.  */
 524   if (VOID_TYPE_P (TREE_TYPE (t1)))
 525     {
 526       if (pedantic && TYPE_PTRFN_P (t2))
 527         pedwarn ("ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", location);
 528       t1 = TREE_TYPE (t1);
 529       t2 = TREE_TYPE (t2);
 530       result_type = cp_build_qualified_type (void_type_node,
 531                                              (cp_type_quals (t1)
 532                                               | cp_type_quals (t2)));
 533       result_type = build_pointer_type (result_type);
 534     }
 535   else
 536     {
 537       tree full1 = qualify_type_recursive (t1, t2);
 538       tree full2 = qualify_type_recursive (t2, t1);
 539
 540       int val = comp_target_types (full1, full2, 1);
 541
 542       if (val > 0)
 543         result_type = full1;
 544       else if (val < 0)
 545         result_type = full2;
 546       else
 547         {
 548           pedwarn ("%s between distinct pointer types `%T' and `%T' lacks a cast",
 549                       location, t1, t2);
 550           result_type = ptr_type_node;
 551         }
 552     }
 553
 554   return build_type_attribute_variant (result_type, attributes);
 555 }
 556
 557 /* Return the merged type of two types.
 558    We assume that comptypes has already been done and returned 1;
 559    if that isn't so, this may crash.
 560
 561    This just combines attributes and default arguments; any other
 562    differences would cause the two types to compare unalike.  */
 563
 564 tree
 565 merge_types (t1, t2)
 566      tree t1, t2;
 567 {
 568   register enum tree_code code1;
 569   register enum tree_code code2;
 570   tree attributes;
 571
 572   /* Save time if the two types are the same.  */
 573   if (t1 == t2)
 574     return t1;
 575   if (original_type (t1) == original_type (t2))
 576     return t1;
 577
 578   /* If one type is nonsense, use the other.  */
 579   if (t1 == error_mark_node)
 580     return t2;
 581   if (t2 == error_mark_node)
 582     return t1;
 583
 584   /* Merge the attributes.  */
 585   attributes = (*targetm.merge_type_attributes) (t1, t2);
 586
 587   /* Treat an enum type as the unsigned integer type of the same width.  */
 588
 589   if (TYPE_PTRMEMFUNC_P (t1))
 590     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
 591   if (TYPE_PTRMEMFUNC_P (t2))
 592     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
 593
 594   code1 = TREE_CODE (t1);
 595   code2 = TREE_CODE (t2);
 596
 597   switch (code1)
 598     {
 599     case POINTER_TYPE:
 600     case REFERENCE_TYPE:
 601       /* For two pointers, do this recursively on the target type.  */
 602       {
 603         tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
 604         int quals = cp_type_quals (t1);
 605
 606         if (code1 == POINTER_TYPE)
 607           t1 = build_pointer_type (target);
 608         else
 609           t1 = build_reference_type (target);
 610         t1 = build_type_attribute_variant (t1, attributes);
 611         t1 = cp_build_qualified_type (t1, quals);
 612
 613         if (TREE_CODE (target) == METHOD_TYPE)
 614           t1 = build_ptrmemfunc_type (t1);
 615
 616         return t1;
 617       }
 618
 619     case OFFSET_TYPE:
 620       {
 621         tree base = TYPE_OFFSET_BASETYPE (t1);
 622         tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
 623         t1 = build_offset_type (base, target);
 624         break;
 625       }
 626
 627     case ARRAY_TYPE:
 628       {
 629         tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
 630         /* Save space: see if the result is identical to one of the args.  */
 631         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
 632           return build_type_attribute_variant (t1, attributes);
 633         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
 634           return build_type_attribute_variant (t2, attributes);
 635         /* Merge the element types, and have a size if either arg has one.  */
 636         t1 = build_cplus_array_type
 637           (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
 638         break;
 639       }
 640
 641     case FUNCTION_TYPE:
 642       /* Function types: prefer the one that specified arg types.
 643          If both do, merge the arg types.  Also merge the return types.  */
 644       {
 645         tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2));
 646         tree p1 = TYPE_ARG_TYPES (t1);
 647         tree p2 = TYPE_ARG_TYPES (t2);
 648         tree rval, raises;
 649
 650         /* Save space: see if the result is identical to one of the args.  */
 651         if (valtype == TREE_TYPE (t1) && ! p2)
 652           return build_type_attribute_variant (t1, attributes);
 653         if (valtype == TREE_TYPE (t2) && ! p1)
 654           return build_type_attribute_variant (t2, attributes);
 655
 656         /* Simple way if one arg fails to specify argument types.  */
 657         if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node)
 658           {
 659             rval = build_function_type (valtype, p2);
 660             if ((raises = TYPE_RAISES_EXCEPTIONS (t2)))
 661               rval = build_exception_variant (rval, raises);
 662             return build_type_attribute_variant (rval, attributes);
 663           }
 664         raises = TYPE_RAISES_EXCEPTIONS (t1);
 665         if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node)
 666           {
 667             rval = build_function_type (valtype, p1);
 668             if (raises)
 669               rval = build_exception_variant (rval, raises);
 670             return build_type_attribute_variant (rval, attributes);
 671           }
 672
 673         rval = build_function_type (valtype, commonparms (p1, p2));
 674         t1 = build_exception_variant (rval, raises);
 675         break;
 676       }
 677
 678     case METHOD_TYPE:
 679       {
 680         /* Get this value the long way, since TYPE_METHOD_BASETYPE
 681            is just the main variant of this.  */
 682         tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2)));
 683         tree raises = TYPE_RAISES_EXCEPTIONS (t1);
 684         tree t3;
 685
 686         /* If this was a member function type, get back to the
 687            original type of type member function (i.e., without
 688            the class instance variable up front.  */
 689         t1 = build_function_type (TREE_TYPE (t1),
 690                                   TREE_CHAIN (TYPE_ARG_TYPES (t1)));
 691         t2 = build_function_type (TREE_TYPE (t2),
 692                                   TREE_CHAIN (TYPE_ARG_TYPES (t2)));
 693         t3 = merge_types (t1, t2);
 694         t3 = build_cplus_method_type (basetype, TREE_TYPE (t3),
 695                                       TYPE_ARG_TYPES (t3));
 696         t1 = build_exception_variant (t3, raises);
 697         break;
 698       }
 699
 700     default:;
 701     }
 702   return build_type_attribute_variant (t1, attributes);
 703 }
 704
 705 /* Return the common type of two types.
 706    We assume that comptypes has already been done and returned 1;
 707    if that isn't so, this may crash.
 708
 709    This is the type for the result of most arithmetic operations
 710    if the operands have the given two types.  */
 711
 712 tree
 713 common_type (t1, t2)
 714      tree t1, t2;
 715 {
 716   enum tree_code code1;
 717   enum tree_code code2;
 718
 719   /* If one type is nonsense, bail.  */
 720   if (t1 == error_mark_node || t2 == error_mark_node)
 721     return error_mark_node;
 722
 723   code1 = TREE_CODE (t1);
 724   code2 = TREE_CODE (t2);
 725
 726   if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE
 727        || code1 == COMPLEX_TYPE)
 728       && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE
 729           || code2 == COMPLEX_TYPE))
 730     return type_after_usual_arithmetic_conversions (t1, t2);
 731
 732   else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2))
 733            || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
 734            || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2)))
 735     return composite_pointer_type (t1, t2, error_mark_node, error_mark_node,
 736                                    "conversion");
 737
 738   else
 739     abort ();
 740 }
 741 \f
 742 /* Compare two exception specifier types for exactness or subsetness, if
 743    allowed. Returns 0 for mismatch, 1 for same, 2 if B is allowed by A.
 744
 745    [except.spec] "If a class X ... objects of class X or any class publicly
 746    and unambigously derrived from X. Similarly, if a pointer type Y * ...
 747    exceptions of type Y * or that are pointers to any type publicly and
 748    unambigously derrived from Y. Otherwise a function only allows exceptions
 749    that have the same type ..."
 750    This does not mention cv qualifiers and is different to what throw
 751    [except.throw] and catch [except.catch] will do. They will ignore the
 752    top level cv qualifiers, and allow qualifiers in the pointer to class
 753    example.
 754
 755    We implement the letter of the standard.  */
 756
 757 static int
 758 comp_except_types (a, b, exact)
 759      tree a, b;
 760      int exact;
 761 {
 762   if (same_type_p (a, b))
 763     return 1;
 764   else if (!exact)
 765     {
 766       if (cp_type_quals (a) || cp_type_quals (b))
 767         return 0;
 768
 769       if (TREE_CODE (a) == POINTER_TYPE
 770           && TREE_CODE (b) == POINTER_TYPE)
 771         {
 772           a = TREE_TYPE (a);
 773           b = TREE_TYPE (b);
 774           if (cp_type_quals (a) || cp_type_quals (b))
 775             return 0;
 776         }
 777
 778       if (TREE_CODE (a) != RECORD_TYPE
 779           || TREE_CODE (b) != RECORD_TYPE)
 780         return 0;
 781
 782       if (ACCESSIBLY_UNIQUELY_DERIVED_P (a, b))
 783         return 2;
 784     }
 785   return 0;
 786 }
 787
 788 /* Return 1 if TYPE1 and TYPE2 are equivalent exception specifiers.
 789    If EXACT is 0, T2 can be stricter than T1 (according to 15.4/7),
 790    otherwise it must be exact. Exception lists are unordered, but
 791    we've already filtered out duplicates. Most lists will be in order,
 792    we should try to make use of that.  */
 793
 794 int
 795 comp_except_specs (t1, t2, exact)
 796      tree t1, t2;
 797      int exact;
 798 {
 799   tree probe;
 800   tree base;
 801   int  length = 0;
 802
 803   if (t1 == t2)
 804     return 1;
 805
 806   if (t1 == NULL_TREE)              /* T1 is ...  */
 807     return t2 == NULL_TREE || !exact;
 808   if (!TREE_VALUE (t1)) /* t1 is EMPTY */
 809     return t2 != NULL_TREE && !TREE_VALUE (t2);
 810   if (t2 == NULL_TREE)              /* T2 is ...  */
 811     return 0;
 812   if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
 813     return !exact;
 814
 815   /* Neither set is ... or EMPTY, make sure each part of T2 is in T1.
 816      Count how many we find, to determine exactness. For exact matching and
 817      ordered T1, T2, this is an O(n) operation, otherwise its worst case is
 818      O(nm).  */
 819   for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2))
 820     {
 821       for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe))
 822         {
 823           tree a = TREE_VALUE (probe);
 824           tree b = TREE_VALUE (t2);
 825
 826           if (comp_except_types (a, b, exact))
 827             {
 828               if (probe == base && exact)
 829                 base = TREE_CHAIN (probe);
 830               length++;
 831               break;
 832             }
 833         }
 834       if (probe == NULL_TREE)
 835         return 0;
 836     }
 837   return !exact || base == NULL_TREE || length == list_length (t1);
 838 }
 839
 840 /* Compare the array types T1 and T2, using CMP as the type comparison
 841    function for the element types.  STRICT is as for comptypes.  */
 842
 843 static int
 844 comp_array_types (cmp, t1, t2, strict)
 845      register int (*cmp) PARAMS ((tree, tree, int));
 846      tree t1, t2;
 847      int strict;
 848 {
 849   tree d1;
 850   tree d2;
 851
 852   if (t1 == t2)
 853     return 1;
 854
 855   /* The type of the array elements must be the same.  */
 856   if (!(TREE_TYPE (t1) == TREE_TYPE (t2)
 857         || (*cmp) (TREE_TYPE (t1), TREE_TYPE (t2),
 858                    strict & ~COMPARE_REDECLARATION)))
 859     return 0;
 860
 861   d1 = TYPE_DOMAIN (t1);
 862   d2 = TYPE_DOMAIN (t2);
 863
 864   if (d1 == d2)
 865     return 1;
 866
 867   /* If one of the arrays is dimensionless, and the other has a
 868      dimension, they are of different types.  However, it is valid to
 869      write:
 870
 871        extern int a[];
 872        int a[3];
 873
 874      by [basic.link]:
 875
 876        declarations for an array object can specify
 877        array types that differ by the presence or absence of a major
 878        array bound (_dcl.array_).  */
 879   if (!d1 || !d2)
 880     return strict & COMPARE_REDECLARATION;
 881
 882   /* Check that the dimensions are the same.  */
 883   return (cp_tree_equal (TYPE_MIN_VALUE (d1),
 884                          TYPE_MIN_VALUE (d2))
 885           && cp_tree_equal (TYPE_MAX_VALUE (d1),
 886                             TYPE_MAX_VALUE (d2)));
 887 }
 888
 889 /* Return 1 if T1 and T2 are compatible types for assignment or
 890    various other operations.  STRICT is a bitwise-or of the COMPARE_*
 891    flags.  */
 892
 893 int
 894 comptypes (t1, t2, strict)
 895      tree t1;
 896      tree t2;
 897      int strict;
 898 {
 899   int attrval, val;
 900   int orig_strict = strict;
 901
 902   /* The special exemption for redeclaring array types without an
 903      array bound only applies at the top level:
 904
 905        extern int (*i)[];
 906        int (*i)[8];
 907
 908      is invalid, for example.  */
 909   strict &= ~COMPARE_REDECLARATION;
 910
 911   /* Suppress errors caused by previously reported errors */
 912   if (t1 == t2)
 913     return 1;
 914
 915   /* This should never happen.  */
 916   my_friendly_assert (t1 != error_mark_node, 307);
 917
 918   if (t2 == error_mark_node)
 919     return 0;
 920
 921   /* If either type is the internal version of sizetype, return the
 922      language version.  */
 923   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
 924       && TYPE_DOMAIN (t1) != 0)
 925     t1 = TYPE_DOMAIN (t1);
 926
 927   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
 928       && TYPE_DOMAIN (t2) != 0)
 929     t2 = TYPE_DOMAIN (t2);
 930
 931   if (strict & COMPARE_RELAXED)
 932     {
 933       /* Treat an enum type as the unsigned integer type of the same width.  */
 934
 935       if (TREE_CODE (t1) == ENUMERAL_TYPE)
 936         t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
 937       if (TREE_CODE (t2) == ENUMERAL_TYPE)
 938         t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
 939
 940       if (t1 == t2)
 941         return 1;
 942     }
 943
 944   if (TYPE_PTRMEMFUNC_P (t1))
 945     t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
 946   if (TYPE_PTRMEMFUNC_P (t2))
 947     t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2);
 948
 949   /* TYPENAME_TYPEs should be resolved if the qualifying scope is the
 950      current instantiation.  */
 951   if (TREE_CODE (t1) == TYPENAME_TYPE)
 952     t1 = resolve_typename_type_in_current_instantiation (t1);
 953   if (TREE_CODE (t2) == TYPENAME_TYPE)
 954     t2 = resolve_typename_type_in_current_instantiation (t2);
 955
 956   /* Different classes of types can't be compatible.  */
 957   if (TREE_CODE (t1) != TREE_CODE (t2))
 958     return 0;
 959
 960   /* Qualifiers must match.  */
 961   if (cp_type_quals (t1) != cp_type_quals (t2))
 962     return 0;
 963   if (strict == COMPARE_STRICT
 964       && TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2))
 965     return 0;
 966
 967   /* Allow for two different type nodes which have essentially the same
 968      definition.  Note that we already checked for equality of the type
 969      qualifiers (just above).  */
 970
 971   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 972     return 1;
 973
 974   if (strict & COMPARE_NO_ATTRIBUTES)
 975     attrval = 1;
 976   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 977   else if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
 978      return 0;
 979
 980   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 981   val = 0;
 982
 983   switch (TREE_CODE (t1))
 984     {
 985     case TEMPLATE_TEMPLATE_PARM:
 986     case BOUND_TEMPLATE_TEMPLATE_PARM:
 987       if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2)
 988           || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2))
 989         return 0;
 990       if (! comp_template_parms
 991               (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)),
 992                DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2))))
 993         return 0;
 994       if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)
 995         return 1;
 996       /* Don't check inheritance.  */
 997       strict = COMPARE_STRICT;
 998       /* fall through */
 999
1000     case RECORD_TYPE:
1001     case UNION_TYPE:
1002       if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2)
1003           && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2)
1004               || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM))
1005         val = comp_template_args (TYPE_TI_ARGS (t1),
1006                                   TYPE_TI_ARGS (t2));
1007     look_hard:
1008       if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2))
1009         val = 1;
1010       else if ((strict & COMPARE_RELAXED) && DERIVED_FROM_P (t2, t1))
1011         val = 1;
1012       break;
1013
1014     case OFFSET_TYPE:
1015       val = (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1)),
1016                         build_pointer_type (TYPE_OFFSET_BASETYPE (t2)), strict)
1017              && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict));
1018       break;
1019
1020     case POINTER_TYPE:
1021     case REFERENCE_TYPE:
1022       t1 = TREE_TYPE (t1);
1023       t2 = TREE_TYPE (t2);
1024       /* first, check whether the referred types match with the
1025          required level of strictness */
1026       val = comptypes (t1, t2, strict);
1027       if (val)
1028         break;
1029       if (TREE_CODE (t1) == RECORD_TYPE
1030           && TREE_CODE (t2) == RECORD_TYPE)
1031         goto look_hard;
1032       break;
1033
1034     case METHOD_TYPE:
1035     case FUNCTION_TYPE:
1036       val = ((TREE_TYPE (t1) == TREE_TYPE (t2)
1037               || comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict))
1038              && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)));
1039       break;
1040
1041     case ARRAY_TYPE:
1042       /* Target types must match incl. qualifiers.  We use ORIG_STRICT
1043          here since this is the one place where
1044          COMPARE_REDECLARATION should be used.  */
1045       val = comp_array_types (comptypes, t1, t2, orig_strict);
1046       break;
1047
1048     case TEMPLATE_TYPE_PARM:
1049       return TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2)
1050         && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2);
1051
1052     case TYPENAME_TYPE:
1053       if (cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1),
1054                          TYPENAME_TYPE_FULLNAME (t2)) < 1)
1055         return 0;
1056       return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1057
1058     case UNBOUND_CLASS_TEMPLATE:
1059       if (cp_tree_equal (TYPE_IDENTIFIER (t1),
1060                          TYPE_IDENTIFIER (t2)) < 1)
1061         return 0;
1062       return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1063
1064     case COMPLEX_TYPE:
1065       return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2));
1066
1067     default:
1068       break;
1069     }
1070   return attrval == 2 && val == 1 ? 2 : val;
1071 }
1072
1073 /* Subroutine of comp_target-types.  Make sure that the cv-quals change
1074    only in the same direction as the target type.  */
1075
1076 static int
1077 comp_cv_target_types (ttl, ttr, nptrs)
1078      tree ttl, ttr;
1079      int nptrs;
1080 {
1081   int t;
1082
1083   if (!at_least_as_qualified_p (ttl, ttr)
1084       && !at_least_as_qualified_p (ttr, ttl))
1085     /* The qualifications are incomparable.  */
1086     return 0;
1087
1088   if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr))
1089     return more_qualified_p (ttr, ttl) ? -1 : 1;
1090
1091   t = comp_target_types (ttl, ttr, nptrs);
1092   if ((t == 1 && at_least_as_qualified_p (ttl, ttr))
1093       || (t == -1 && at_least_as_qualified_p (ttr, ttl)))
1094     return t;
1095
1096   return 0;
1097 }
1098
1099 /* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent,
1100    ignoring their qualifiers, 0 if not. Return 1 means that TTR can be
1101    converted to TTL. Return -1 means that TTL can be converted to TTR but
1102    not vice versa.
1103
1104    NPTRS is the number of pointers we can strip off and keep cool.
1105    This is used to permit (for aggr A, aggr B) A, B* to convert to A*,
1106    but to not permit B** to convert to A**.
1107
1108    This should go away.  Callers should use can_convert or something
1109    similar instead.  (jason 17 Apr 1997)  */
1110
1111 int
1112 comp_target_types (ttl, ttr, nptrs)
1113      tree ttl, ttr;
1114      int nptrs;
1115 {
1116   ttl = TYPE_MAIN_VARIANT (ttl);
1117   ttr = TYPE_MAIN_VARIANT (ttr);
1118   if (same_type_p (ttl, ttr))
1119     return 1;
1120
1121   if (TREE_CODE (ttr) != TREE_CODE (ttl))
1122     return 0;
1123
1124   if ((TREE_CODE (ttr) == POINTER_TYPE
1125        || TREE_CODE (ttr) == REFERENCE_TYPE)
1126       /* If we get a pointer with nptrs == 0, we don't allow any tweaking
1127          of the type pointed to.  This is necessary for reference init
1128          semantics.  We won't get here from a previous call with nptrs == 1;
1129          for multi-level pointers we end up in comp_ptr_ttypes.  */
1130       && nptrs > 0)
1131     {
1132       int is_ptr = TREE_CODE (ttr) == POINTER_TYPE;
1133
1134       ttl = TREE_TYPE (ttl);
1135       ttr = TREE_TYPE (ttr);
1136
1137       if (is_ptr)
1138         {
1139           if (TREE_CODE (ttl) == UNKNOWN_TYPE
1140               || TREE_CODE (ttr) == UNKNOWN_TYPE)
1141             return 1;
1142           else if (TREE_CODE (ttl) == VOID_TYPE
1143                    && TREE_CODE (ttr) != FUNCTION_TYPE
1144                    && TREE_CODE (ttr) != METHOD_TYPE
1145                    && TREE_CODE (ttr) != OFFSET_TYPE)
1146             return 1;
1147           else if (TREE_CODE (ttr) == VOID_TYPE
1148                    && TREE_CODE (ttl) != FUNCTION_TYPE
1149                    && TREE_CODE (ttl) != METHOD_TYPE
1150                    && TREE_CODE (ttl) != OFFSET_TYPE)
1151             return -1;
1152           else if (TREE_CODE (ttl) == POINTER_TYPE
1153                    || TREE_CODE (ttl) == ARRAY_TYPE)
1154             {
1155               if (comp_ptr_ttypes (ttl, ttr))
1156                 return 1;
1157               else if (comp_ptr_ttypes (ttr, ttl))
1158                 return -1;
1159               return 0;
1160             }
1161         }
1162
1163       /* Const and volatile mean something different for function types,
1164          so the usual checks are not appropriate.  */
1165       if (TREE_CODE (ttl) == FUNCTION_TYPE || TREE_CODE (ttl) == METHOD_TYPE)
1166         return comp_target_types (ttl, ttr, nptrs - 1);
1167
1168       return comp_cv_target_types (ttl, ttr, nptrs - 1);
1169     }
1170
1171   if (TREE_CODE (ttr) == ARRAY_TYPE)
1172     return comp_array_types (comp_target_types, ttl, ttr, COMPARE_STRICT);
1173   else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
1174     {
1175       tree argsl, argsr;
1176       int saw_contra = 0;
1177
1178       if (pedantic)
1179         {
1180           if (!same_type_p (TREE_TYPE (ttl), TREE_TYPE (ttr)))
1181             return 0;
1182         }
1183       else
1184         {
1185           switch (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
1186             {
1187             case 0:
1188               return 0;
1189             case -1:
1190               saw_contra = 1;
1191             }
1192         }
1193
1194       argsl = TYPE_ARG_TYPES (ttl);
1195       argsr = TYPE_ARG_TYPES (ttr);
1196
1197       /* Compare 'this' here, not in comp_target_parms.  */
1198       if (TREE_CODE (ttr) == METHOD_TYPE)
1199         {
1200           tree tl = TYPE_METHOD_BASETYPE (ttl);
1201           tree tr = TYPE_METHOD_BASETYPE (ttr);
1202
1203           if (!same_or_base_type_p (tr, tl))
1204             {
1205               if (same_or_base_type_p (tl, tr))
1206                 saw_contra = 1;
1207               else
1208                 return 0;
1209             }
1210
1211           argsl = TREE_CHAIN (argsl);
1212           argsr = TREE_CHAIN (argsr);
1213         }
1214
1215         switch (comp_target_parms (argsl, argsr))
1216           {
1217           case 0:
1218             return 0;
1219           case -1:
1220             saw_contra = 1;
1221           }
1222
1223         return saw_contra ? -1 : 1;
1224     }
1225   /* for C++ */
1226   else if (TREE_CODE (ttr) == OFFSET_TYPE)
1227     {
1228       int base;
1229
1230       /* Contravariance: we can assign a pointer to base member to a pointer
1231          to derived member.  Note difference from simple pointer case, where
1232          we can pass a pointer to derived to a pointer to base.  */
1233       if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr),
1234                                TYPE_OFFSET_BASETYPE (ttl)))
1235         base = 1;
1236       else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl),
1237                                     TYPE_OFFSET_BASETYPE (ttr)))
1238         {
1239           tree tmp = ttl;
1240           ttl = ttr;
1241           ttr = tmp;
1242           base = -1;
1243         }
1244       else
1245         return 0;
1246
1247       ttl = TREE_TYPE (ttl);
1248       ttr = TREE_TYPE (ttr);
1249
1250       if (TREE_CODE (ttl) == POINTER_TYPE
1251           || TREE_CODE (ttl) == ARRAY_TYPE)
1252         {
1253           if (comp_ptr_ttypes (ttl, ttr))
1254             return base;
1255           return 0;
1256         }
1257       else
1258         {
1259           if (comp_cv_target_types (ttl, ttr, nptrs) == 1)
1260             return base;
1261           return 0;
1262         }
1263     }
1264   else if (IS_AGGR_TYPE (ttl))
1265     {
1266       if (nptrs < 0)
1267         return 0;
1268       if (same_or_base_type_p (build_pointer_type (ttl),
1269                                build_pointer_type (ttr)))
1270         return 1;
1271       if (same_or_base_type_p (build_pointer_type (ttr),
1272                                build_pointer_type (ttl)))
1273         return -1;
1274       return 0;
1275     }
1276
1277   return 0;
1278 }
1279
1280 /* Returns 1 if TYPE1 is at least as qualified as TYPE2.  */
1281
1282 int
1283 at_least_as_qualified_p (type1, type2)
1284      tree type1;
1285      tree type2;
1286 {
1287   /* All qualifiers for TYPE2 must also appear in TYPE1.  */
1288   return ((cp_type_quals (type1) & cp_type_quals (type2))
1289           == cp_type_quals (type2));
1290 }
1291
1292 /* Returns 1 if TYPE1 is more qualified than TYPE2.  */
1293
1294 int
1295 more_qualified_p (type1, type2)
1296      tree type1;
1297      tree type2;
1298 {
1299   return (cp_type_quals (type1) != cp_type_quals (type2)
1300           && at_least_as_qualified_p (type1, type2));
1301 }
1302
1303 /* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is
1304    more cv-qualified that TYPE1, and 0 otherwise.  */
1305
1306 int
1307 comp_cv_qualification (type1, type2)
1308      tree type1;
1309      tree type2;
1310 {
1311   if (cp_type_quals (type1) == cp_type_quals (type2))
1312     return 0;
1313
1314   if (at_least_as_qualified_p (type1, type2))
1315     return 1;
1316
1317   else if (at_least_as_qualified_p (type2, type1))
1318     return -1;
1319
1320   return 0;
1321 }
1322
1323 /* Returns 1 if the cv-qualification signature of TYPE1 is a proper
1324    subset of the cv-qualification signature of TYPE2, and the types
1325    are similar.  Returns -1 if the other way 'round, and 0 otherwise.  */
1326
1327 int
1328 comp_cv_qual_signature (type1, type2)
1329      tree type1;
1330      tree type2;
1331 {
1332   if (comp_ptr_ttypes_real (type2, type1, -1))
1333     return 1;
1334   else if (comp_ptr_ttypes_real (type1, type2, -1))
1335     return -1;
1336   else
1337     return 0;
1338 }
1339
1340 /* If two types share a common base type, return that basetype.
1341    If there is not a unique most-derived base type, this function
1342    returns ERROR_MARK_NODE.  */
1343
1344 static tree
1345 common_base_type (tt1, tt2)
1346      tree tt1, tt2;
1347 {
1348   tree best = NULL_TREE;
1349   int i;
1350
1351   /* If one is a baseclass of another, that's good enough.  */
1352   if (UNIQUELY_DERIVED_FROM_P (tt1, tt2))
1353     return tt1;
1354   if (UNIQUELY_DERIVED_FROM_P (tt2, tt1))
1355     return tt2;
1356
1357   /* Otherwise, try to find a unique baseclass of TT1
1358      that is shared by TT2, and follow that down.  */
1359   for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--)
1360     {
1361       tree basetype = TYPE_BINFO_BASETYPE (tt1, i);
1362       tree trial = common_base_type (basetype, tt2);
1363       if (trial)
1364         {
1365           if (trial == error_mark_node)
1366             return trial;
1367           if (best == NULL_TREE)
1368             best = trial;
1369           else if (best != trial)
1370             return error_mark_node;
1371         }
1372     }
1373
1374   /* Same for TT2.  */
1375   for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--)
1376     {
1377       tree basetype = TYPE_BINFO_BASETYPE (tt2, i);
1378       tree trial = common_base_type (tt1, basetype);
1379       if (trial)
1380         {
1381           if (trial == error_mark_node)
1382             return trial;
1383           if (best == NULL_TREE)
1384             best = trial;
1385           else if (best != trial)
1386             return error_mark_node;
1387         }
1388     }
1389   return best;
1390 }
1391 \f
1392 /* Subroutines of `comptypes'.  */
1393
1394 /* Return 1 if two parameter type lists PARMS1 and PARMS2 are
1395    equivalent in the sense that functions with those parameter types
1396    can have equivalent types.  The two lists must be equivalent,
1397    element by element.
1398
1399    C++: See comment above about TYPE1, TYPE2.  */
1400
1401 int
1402 compparms (parms1, parms2)
1403      tree parms1, parms2;
1404 {
1405   register tree t1 = parms1, t2 = parms2;
1406
1407   /* An unspecified parmlist matches any specified parmlist
1408      whose argument types don't need default promotions.  */
1409
1410   while (1)
1411     {
1412       if (t1 == 0 && t2 == 0)
1413         return 1;
1414       /* If one parmlist is shorter than the other,
1415          they fail to match.  */
1416       if (t1 == 0 || t2 == 0)
1417         return 0;
1418       if (!same_type_p (TREE_VALUE (t2), TREE_VALUE (t1)))
1419         return 0;
1420
1421       t1 = TREE_CHAIN (t1);
1422       t2 = TREE_CHAIN (t2);
1423     }
1424 }
1425
1426 /* This really wants return whether or not parameter type lists
1427    would make their owning functions assignment compatible or not.
1428
1429    The return value is like for comp_target_types.
1430
1431    This should go away, possibly with the exception of the empty parmlist
1432    conversion; there are no conversions between function types in C++.
1433    (jason 17 Apr 1997)  */
1434
1435 static int
1436 comp_target_parms (parms1, parms2)
1437      tree parms1, parms2;
1438 {
1439   register tree t1 = parms1, t2 = parms2;
1440   int warn_contravariance = 0;
1441
1442   /* In C, an unspecified parmlist matches any specified parmlist
1443      whose argument types don't need default promotions.  This is not
1444      true for C++, but let's do it anyway for unfixed headers.  */
1445
1446   if (t1 == 0 && t2 != 0)
1447     {
1448       pedwarn ("ISO C++ prohibits conversion from `%#T' to `(...)'",
1449                   parms2);
1450       return self_promoting_args_p (t2);
1451     }
1452   if (t2 == 0)
1453     return self_promoting_args_p (t1);
1454
1455   for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1456     {
1457       tree p1, p2;
1458
1459       /* If one parmlist is shorter than the other,
1460          they fail to match, unless STRICT is <= 0.  */
1461       if (t1 == 0 || t2 == 0)
1462         return 0;
1463       p1 = TREE_VALUE (t1);
1464       p2 = TREE_VALUE (t2);
1465       if (same_type_p (p1, p2))
1466         continue;
1467
1468       if (pedantic)
1469         return 0;
1470
1471       if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
1472           || (TREE_CODE (p1) == REFERENCE_TYPE
1473               && TREE_CODE (p2) == REFERENCE_TYPE))
1474         {
1475           /* The following is wrong for contravariance,
1476              but many programs depend on it.  */
1477           if (TREE_TYPE (p1) == void_type_node)
1478             continue;
1479           if (TREE_TYPE (p2) == void_type_node)
1480             {
1481               warn_contravariance = 1;
1482               continue;
1483             }
1484           if (IS_AGGR_TYPE (TREE_TYPE (p1))
1485               && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (p1),
1486                                                              TREE_TYPE (p2)))
1487             return 0;
1488         }
1489       /* Note backwards order due to contravariance.  */
1490       if (comp_target_types (p2, p1, 1) <= 0)
1491         {
1492           if (comp_target_types (p1, p2, 1) > 0)
1493             {
1494               warn_contravariance = 1;
1495               continue;
1496             }
1497           return 0;
1498         }
1499     }
1500   return warn_contravariance ? -1 : 1;
1501 }
1502 \f
1503 tree
1504 cxx_sizeof_or_alignof_type (type, op, complain)
1505      tree type;
1506      enum tree_code op;
1507      int complain;
1508 {
1509   enum tree_code type_code;
1510   tree value;
1511   const char *op_name;
1512
1513   my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
1514   if (processing_template_decl)
1515     return build_min_nt (op, type);
1516
1517   op_name = operator_name_info[(int) op].name;
1518
1519   if (TREE_CODE (type) == REFERENCE_TYPE)
1520     type = TREE_TYPE (type);
1521   type_code = TREE_CODE (type);
1522
1523   if (type_code == METHOD_TYPE)
1524     {
1525       if (complain && (pedantic || warn_pointer_arith))
1526         pedwarn ("invalid application of `%s' to a member function", op_name);
1527       value = size_one_node;
1528     }
1529   else if (type_code == OFFSET_TYPE)
1530     {
1531       if (complain)
1532         error ("invalid application of `%s' to non-static member", op_name);
1533       value = size_zero_node;
1534     }
1535   else
1536     value = c_sizeof_or_alignof_type (complete_type (type), op, complain);
1537
1538   return value;
1539 }
1540
1541 tree
1542 expr_sizeof (e)
1543      tree e;
1544 {
1545   if (processing_template_decl)
1546     return build_min_nt (SIZEOF_EXPR, e);
1547
1548   if (TREE_CODE (e) == COMPONENT_REF
1549       && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1)))
1550     error ("sizeof applied to a bit-field");
1551   if (is_overloaded_fn (e))
1552     {
1553       pedwarn ("ISO C++ forbids applying `sizeof' to an expression of function type");
1554       return c_sizeof (char_type_node);
1555     }
1556   else if (type_unknown_p (e))
1557     {
1558       cxx_incomplete_type_error (e, TREE_TYPE (e));
1559       return c_sizeof (char_type_node);
1560     }
1561   /* It's invalid to say `sizeof (X::i)' for `i' a non-static data
1562      member unless you're in a non-static member of X.  So hand off to
1563      resolve_offset_ref.  [expr.prim]  */
1564   else if (TREE_CODE (e) == OFFSET_REF)
1565     e = resolve_offset_ref (e);
1566
1567   if (e == error_mark_node)
1568     return e;
1569
1570   return cxx_sizeof (TREE_TYPE (e));
1571 }
1572
1573 \f
1574 /* Perform the array-to-pointer and function-to-pointer conversions
1575    for EXP.
1576
1577    In addition, references are converted to lvalues and manifest
1578    constants are replaced by their values.  */
1579
1580 tree
1581 decay_conversion (exp)
1582      tree exp;
1583 {
1584   register tree type;
1585   register enum tree_code code;
1586
1587   if (TREE_CODE (exp) == OFFSET_REF)
1588     exp = resolve_offset_ref (exp);
1589
1590   type = TREE_TYPE (exp);
1591   code = TREE_CODE (type);
1592
1593   if (code == REFERENCE_TYPE)
1594     {
1595       exp = convert_from_reference (exp);
1596       type = TREE_TYPE (exp);
1597       code = TREE_CODE (type);
1598     }
1599
1600   if (type == error_mark_node)
1601     return error_mark_node;
1602
1603   if (type_unknown_p (exp))
1604     {
1605       cxx_incomplete_type_error (exp, TREE_TYPE (exp));
1606       return error_mark_node;
1607     }
1608
1609   /* Constants can be used directly unless they're not loadable.  */
1610   if (TREE_CODE (exp) == CONST_DECL)
1611     exp = DECL_INITIAL (exp);
1612   /* Replace a nonvolatile const static variable with its value.  We
1613      don't do this for arrays, though; we want the address of the
1614      first element of the array, not the address of the first element
1615      of its initializing constant.  */
1616   else if (code != ARRAY_TYPE)
1617     {
1618       exp = decl_constant_value (exp);
1619       type = TREE_TYPE (exp);
1620     }
1621
1622   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
1623      Leave such NOP_EXPRs, since RHS is being used in non-lvalue context.  */
1624
1625   if (code == VOID_TYPE)
1626     {
1627       error ("void value not ignored as it ought to be");
1628       return error_mark_node;
1629     }
1630   if (code == METHOD_TYPE)
1631     abort ();
1632   if (code == FUNCTION_TYPE || is_overloaded_fn (exp))
1633     return build_unary_op (ADDR_EXPR, exp, 0);
1634   if (code == ARRAY_TYPE)
1635     {
1636       register tree adr;
1637       tree ptrtype;
1638
1639       if (TREE_CODE (exp) == INDIRECT_REF)
1640         {
1641           /* Stripping away the INDIRECT_REF is not the right
1642              thing to do for references...  */
1643           tree inner = TREE_OPERAND (exp, 0);
1644           if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
1645             {
1646               inner = build1 (CONVERT_EXPR,
1647                               build_pointer_type (TREE_TYPE
1648                                                   (TREE_TYPE (inner))),
1649                               inner);
1650               TREE_CONSTANT (inner) = TREE_CONSTANT (TREE_OPERAND (inner, 0));
1651             }
1652           return cp_convert (build_pointer_type (TREE_TYPE (type)), inner);
1653         }
1654
1655       if (TREE_CODE (exp) == COMPOUND_EXPR)
1656         {
1657           tree op1 = decay_conversion (TREE_OPERAND (exp, 1));
1658           return build (COMPOUND_EXPR, TREE_TYPE (op1),
1659                         TREE_OPERAND (exp, 0), op1);
1660         }
1661
1662       if (!lvalue_p (exp)
1663           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1664         {
1665           error ("invalid use of non-lvalue array");
1666           return error_mark_node;
1667         }
1668
1669       ptrtype = build_pointer_type (TREE_TYPE (type));
1670
1671       if (TREE_CODE (exp) == VAR_DECL)
1672         {
1673           /* ??? This is not really quite correct
1674              in that the type of the operand of ADDR_EXPR
1675              is not the target type of the type of the ADDR_EXPR itself.
1676              Question is, can this lossage be avoided?  */
1677           adr = build1 (ADDR_EXPR, ptrtype, exp);
1678           if (!cxx_mark_addressable (exp))
1679             return error_mark_node;
1680           TREE_CONSTANT (adr) = staticp (exp);
1681           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1682           return adr;
1683         }
1684       /* This way is better for a COMPONENT_REF since it can
1685          simplify the offset for a component.  */
1686       adr = build_unary_op (ADDR_EXPR, exp, 1);
1687       return cp_convert (ptrtype, adr);
1688     }
1689
1690   /* [basic.lval]: Class rvalues can have cv-qualified types; non-class
1691      rvalues always have cv-unqualified types.  */
1692   if (! CLASS_TYPE_P (type))
1693     exp = cp_convert (TYPE_MAIN_VARIANT (type), exp);
1694
1695   return exp;
1696 }
1697
1698 tree
1699 default_conversion (exp)
1700      tree exp;
1701 {
1702   tree type;
1703   enum tree_code code;
1704
1705   exp = decay_conversion (exp);
1706
1707   type = TREE_TYPE (exp);
1708   code = TREE_CODE (type);
1709
1710   if (INTEGRAL_CODE_P (code))
1711     {
1712       tree t = type_promotes_to (type);
1713       if (t != type)
1714         return cp_convert (t, exp);
1715     }
1716
1717   return exp;
1718 }
1719
1720 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1721    or TREE_USED.  */
1722
1723 tree
1724 inline_conversion (exp)
1725      tree exp;
1726 {
1727   if (TREE_CODE (exp) == FUNCTION_DECL)
1728     exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1729
1730   return exp;
1731 }
1732
1733 /* Returns nonzero iff exp is a STRING_CST or the result of applying
1734    decay_conversion to one.  */
1735
1736 int
1737 string_conv_p (totype, exp, warn)
1738      tree totype, exp;
1739      int warn;
1740 {
1741   tree t;
1742
1743   if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE)
1744     return 0;
1745
1746   t = TREE_TYPE (totype);
1747   if (!same_type_p (t, char_type_node)
1748       && !same_type_p (t, wchar_type_node))
1749     return 0;
1750
1751   if (TREE_CODE (exp) == STRING_CST)
1752     {
1753       /* Make sure that we don't try to convert between char and wchar_t.  */
1754       if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t))
1755         return 0;
1756     }
1757   else
1758     {
1759       /* Is this a string constant which has decayed to 'const char *'?  */
1760       t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST));
1761       if (!same_type_p (TREE_TYPE (exp), t))
1762         return 0;
1763       STRIP_NOPS (exp);
1764       if (TREE_CODE (exp) != ADDR_EXPR
1765           || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST)
1766         return 0;
1767     }
1768
1769   /* This warning is not very useful, as it complains about printf.  */
1770   if (warn && warn_write_strings)
1771     warning ("deprecated conversion from string constant to `%T'", totype);
1772
1773   return 1;
1774 }
1775
1776 /* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we
1777    can, for example, use as an lvalue.  This code used to be in
1778    unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c'
1779    expressions, where we're dealing with aggregates.  But now it's again only
1780    called from unary_complex_lvalue.  The case (in particular) that led to
1781    this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd
1782    get it there.  */
1783
1784 static tree
1785 rationalize_conditional_expr (code, t)
1786      enum tree_code code;
1787      tree t;
1788 {
1789   /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that
1790      the first operand is always the one to be used if both operands
1791      are equal, so we know what conditional expression this used to be.  */
1792   if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR)
1793     {
1794       return
1795         build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR
1796                                                     ? LE_EXPR : GE_EXPR),
1797                                                    TREE_OPERAND (t, 0),
1798                                                    TREE_OPERAND (t, 1)),
1799                             build_unary_op (code, TREE_OPERAND (t, 0), 0),
1800                             build_unary_op (code, TREE_OPERAND (t, 1), 0));
1801     }
1802
1803   return
1804     build_conditional_expr (TREE_OPERAND (t, 0),
1805                             build_unary_op (code, TREE_OPERAND (t, 1), 0),
1806                             build_unary_op (code, TREE_OPERAND (t, 2), 0));
1807 }
1808
1809 /* Given the TYPE of an anonymous union field inside T, return the
1810    FIELD_DECL for the field.  If not found return NULL_TREE.  Because
1811    anonymous unions can nest, we must also search all anonymous unions
1812    that are directly reachable.  */
1813
1814 static tree
1815 lookup_anon_field (t, type)
1816      tree t, type;
1817 {
1818   tree field;
1819
1820   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1821     {
1822       if (TREE_STATIC (field))
1823         continue;
1824       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1825         continue;
1826
1827       /* If we find it directly, return the field.  */
1828       if (DECL_NAME (field) == NULL_TREE
1829           && type == TYPE_MAIN_VARIANT (TREE_TYPE (field)))
1830         {
1831           return field;
1832         }
1833
1834       /* Otherwise, it could be nested, search harder.  */
1835       if (DECL_NAME (field) == NULL_TREE
1836           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1837         {
1838           tree subfield = lookup_anon_field (TREE_TYPE (field), type);
1839           if (subfield)
1840             return subfield;
1841         }
1842     }
1843   return NULL_TREE;
1844 }
1845
1846 /* Build an expression representing OBJECT.MEMBER.  OBJECT is an
1847    expression; MEMBER is a DECL or baselink.  If ACCESS_PATH is
1848    non-NULL, it indicates the path to the base used to name MEMBER.
1849    If PRESERVE_REFERENCE is true, the expression returned will have
1850    REFERENCE_TYPE if the MEMBER does.  Otherwise, the expression
1851    returned will have the type referred to by the reference.
1852
1853    This function does not perform access control; that is either done
1854    earlier by the parser when the name of MEMBER is resolved to MEMBER
1855    itself, or later when overload resolution selects one of the
1856    functions indicated by MEMBER.  */
1857
1858 tree
1859 build_class_member_access_expr (tree object, tree member,
1860                                 tree access_path, bool preserve_reference)
1861 {
1862   tree object_type;
1863   tree member_scope;
1864   tree result = NULL_TREE;
1865
1866   if (object == error_mark_node || member == error_mark_node)
1867     return error_mark_node;
1868
1869   if (TREE_CODE (member) == PSEUDO_DTOR_EXPR)
1870     return member;
1871
1872   my_friendly_assert (DECL_P (member) || BASELINK_P (member),
1873                       20020801);
1874
1875   /* [expr.ref]
1876
1877      The type of the first expression shall be "class object" (of a
1878      complete type).  */
1879   object_type = TREE_TYPE (object);
1880   if (!complete_type_or_else (object_type, object))
1881     return error_mark_node;
1882   if (!CLASS_TYPE_P (object_type))
1883     {
1884       error ("request for member `%D' in `%E', which is of non-class type `%T'",
1885              member, object, object_type);
1886       return error_mark_node;
1887     }
1888
1889   /* The standard does not seem to actually say that MEMBER must be a
1890      member of OBJECT_TYPE.  However, that is clearly what is
1891      intended.  */
1892   if (DECL_P (member))
1893     {
1894       member_scope = DECL_CLASS_CONTEXT (member);
1895       mark_used (member);
1896       if (TREE_DEPRECATED (member))
1897         warn_deprecated_use (member);
1898     }
1899   else
1900     member_scope = BINFO_TYPE (BASELINK_BINFO (member));
1901   /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will
1902      presently be the anonymous union.  Go outwards until we find a
1903      type related to OBJECT_TYPE.  */
1904   while (ANON_AGGR_TYPE_P (member_scope)
1905          && !same_type_ignoring_top_level_qualifiers_p (member_scope,
1906                                                         object_type))
1907     member_scope = TYPE_CONTEXT (member_scope);
1908   if (!member_scope || !DERIVED_FROM_P (member_scope, object_type))
1909     {
1910       error ("`%D' is not a member of `%T'", member, object_type);
1911       return error_mark_node;
1912     }
1913
1914   /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
1915      `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only an lvalue
1916      in the frontend; only _DECLs and _REFs are lvalues in the backend.  */
1917   {
1918     tree temp = unary_complex_lvalue (ADDR_EXPR, object);
1919     if (temp)
1920       object = build_indirect_ref (temp, NULL);
1921   }
1922
1923   /* In [expr.ref], there is an explicit list of the valid choices for
1924      MEMBER.  We check for each of those cases here.  */
1925   if (TREE_CODE (member) == VAR_DECL)
1926     {
1927       /* A static data member.  */
1928       result = member;
1929       /* If OBJECT has side-effects, they are supposed to occur.  */
1930       if (TREE_SIDE_EFFECTS (object))
1931         result = build (COMPOUND_EXPR, TREE_TYPE (result), object, result);
1932     }
1933   else if (TREE_CODE (member) == FIELD_DECL)
1934     {
1935       /* A non-static data member.  */
1936       bool null_object_p;
1937       int type_quals;
1938       tree member_type;
1939
1940       null_object_p = (TREE_CODE (object) == INDIRECT_REF
1941                        && integer_zerop (TREE_OPERAND (object, 0)));
1942
1943       /* Convert OBJECT to the type of MEMBER.  */
1944       if (!same_type_p (object_type, member_scope))
1945         {
1946           tree binfo;
1947           base_kind kind;
1948
1949           binfo = lookup_base (access_path ? access_path : object_type,
1950                                member_scope, ba_ignore,  &kind);
1951           if (binfo == error_mark_node)
1952             return error_mark_node;
1953
1954           /* It is invalid to use to try to get to a virtual base of a
1955              NULL object.  The most common cause is invalid use of
1956              offsetof macro.  */
1957           if (null_object_p && kind == bk_via_virtual)
1958             {
1959               error ("invalid access to non-static data member `%D' of NULL object",
1960                      member);
1961               error ("(perhaps the `offsetof' macro was used incorrectly)");
1962               return error_mark_node;
1963             }
1964
1965           /* Convert to the base.  */
1966           object = build_base_path (PLUS_EXPR, object, binfo,
1967                                     /*nonnull=*/1);
1968           /* If we found the base successfully then we should be able
1969              to convert to it successfully.  */
1970           my_friendly_assert (object != error_mark_node,
1971                               20020801);
1972         }
1973
1974       /* Complain about other invalid uses of offsetof, even though they will
1975          give the right answer.  Note that we complain whether or not they
1976          actually used the offsetof macro, since there's no way to know at this
1977          point.  So we just give a warning, instead of a pedwarn.  */
1978       if (null_object_p && CLASSTYPE_NON_POD_P (object_type))
1979         {
1980           warning ("invalid access to non-static data member `%D' of NULL object",
1981                    member);
1982           warning  ("(perhaps the `offsetof' macro was used incorrectly)");
1983         }
1984
1985       /* If MEMBER is from an anonymous aggregate, we have converted
1986          OBJECT so that it refers to the class containing the
1987          anonymous union.  Generate a reference to the anonymous union
1988          itself, and recur to find MEMBER.  */
1989       if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member))
1990           /* When this code is called from build_field_call, the
1991              object already has the type of the anonymous union.
1992              That is because the COMPONENT_REF was already
1993              constructed, and was then disassembled before calling
1994              build_field_call.  After the function-call code is
1995              cleaned up, this waste can be eliminated.  */
1996           && (!same_type_ignoring_top_level_qualifiers_p
1997               (TREE_TYPE (object), DECL_CONTEXT (member))))
1998         {
1999           tree anonymous_union;
2000
2001           anonymous_union = lookup_anon_field (TREE_TYPE (object),
2002                                                DECL_CONTEXT (member));
2003           object = build_class_member_access_expr (object,
2004                                                    anonymous_union,
2005                                                    /*access_path=*/NULL_TREE,
2006                                                    preserve_reference);
2007         }
2008
2009       /* Compute the type of the field, as described in [expr.ref].  */
2010       type_quals = TYPE_UNQUALIFIED;
2011       member_type = TREE_TYPE (member);
2012       if (TREE_CODE (member_type) != REFERENCE_TYPE)
2013         {
2014           type_quals = (cp_type_quals (member_type)
2015                         | cp_type_quals (object_type));
2016
2017           /* A field is const (volatile) if the enclosing object, or the
2018              field itself, is const (volatile).  But, a mutable field is
2019              not const, even within a const object.  */
2020           if (DECL_MUTABLE_P (member))
2021             type_quals &= ~TYPE_QUAL_CONST;
2022           member_type = cp_build_qualified_type (member_type, type_quals);
2023         }
2024
2025       result = fold (build (COMPONENT_REF, member_type, object, member));
2026
2027       /* Mark the expression const or volatile, as appropriate.  Even
2028          though we've dealt with the type above, we still have to mark the
2029          expression itself.  */
2030       if (type_quals & TYPE_QUAL_CONST)
2031         TREE_READONLY (result) = 1;
2032       else if (type_quals & TYPE_QUAL_VOLATILE)
2033         TREE_THIS_VOLATILE (result) = 1;
2034     }
2035   else if (BASELINK_P (member))
2036     {
2037       /* The member is a (possibly overloaded) member function.  */
2038       tree functions;
2039       tree type;
2040
2041       /* If the MEMBER is exactly one static member function, then we
2042          know the type of the expression.  Otherwise, we must wait
2043          until overload resolution has been performed.  */
2044       functions = BASELINK_FUNCTIONS (member);
2045       if (TREE_CODE (functions) == FUNCTION_DECL
2046           && DECL_STATIC_FUNCTION_P (functions))
2047         type = TREE_TYPE (functions);
2048       else
2049         type = unknown_type_node;
2050       /* Note that we do not convert OBJECT to the BASELINK_BINFO
2051          base.  That will happen when the function is called.  */
2052       result = build (COMPONENT_REF, type, object, member);
2053     }
2054   else if (TREE_CODE (member) == CONST_DECL)
2055     {
2056       /* The member is an enumerator.  */
2057       result = member;
2058       /* If OBJECT has side-effects, they are supposed to occur.  */
2059       if (TREE_SIDE_EFFECTS (object))
2060         result = build (COMPOUND_EXPR, TREE_TYPE (result),
2061                         object, result);
2062     }
2063   else
2064     {
2065       error ("invalid use of `%D'", member);
2066       return error_mark_node;
2067     }
2068
2069   if (!preserve_reference)
2070     /* [expr.ref]
2071
2072        If E2 is declared to have type "reference to T", then ... the
2073        type of E1.E2 is T.  */
2074     result = convert_from_reference (result);
2075
2076   return result;
2077 }
2078
2079 /* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if
2080    SCOPE is NULL, by OBJECT.~DTOR_NAME.  */
2081
2082 static tree
2083 lookup_destructor (tree object, tree scope, tree dtor_name)
2084 {
2085   tree object_type = TREE_TYPE (object);
2086   tree dtor_type = TREE_OPERAND (dtor_name, 0);
2087
2088   if (scope && !check_dtor_name (scope, dtor_name))
2089     {
2090       error ("qualified type `%T' does not match destructor name `~%T'",
2091              scope, dtor_type);
2092       return error_mark_node;
2093     }
2094   if (!same_type_p (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2095     {
2096       error ("destructor name `%T' does not match type `%T' of expression",
2097              dtor_type, object_type);
2098       return error_mark_node;
2099     }
2100   if (!TYPE_HAS_DESTRUCTOR (object_type))
2101     return build (PSEUDO_DTOR_EXPR, void_type_node, object, scope,
2102                   dtor_type);
2103   return lookup_member (object_type, complete_dtor_identifier,
2104                         /*protect=*/1, /*want_type=*/0);
2105 }
2106
2107 /* This function is called by the parser to process a class member
2108    access expression of the form OBJECT.NAME.  NAME is a node used by
2109    the parser to represent a name; it is not yet a DECL.  It may,
2110    however, be a BASELINK where the BASELINK_FUNCTIONS is a
2111    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
2112    there is no reason to do the lookup twice, so the parser keeps the
2113    BASELINK.  */
2114
2115 tree
2116 finish_class_member_access_expr (tree object, tree name)
2117 {
2118   tree object_type;
2119   tree member;
2120   tree access_path = NULL_TREE;
2121
2122   if (object == error_mark_node || name == error_mark_node)
2123     return error_mark_node;
2124
2125   if (processing_template_decl)
2126     return build_min_nt (COMPONENT_REF, object, name);
2127
2128   if (TREE_CODE (object) == OFFSET_REF)
2129     object = resolve_offset_ref (object);
2130
2131   object_type = TREE_TYPE (object);
2132   if (TREE_CODE (object_type) == REFERENCE_TYPE)
2133     {
2134       object = convert_from_reference (object);
2135       object_type = TREE_TYPE (object);
2136     }
2137
2138   /* [expr.ref]
2139
2140      The type of the first expression shall be "class object" (of a
2141      complete type).  */
2142   if (!complete_type_or_else (object_type, object))
2143     return error_mark_node;
2144   if (!CLASS_TYPE_P (object_type))
2145     {
2146       error ("request for member `%D' in `%E', which is of non-class type `%T'",
2147              name, object, object_type);
2148       return error_mark_node;
2149     }
2150
2151   if (BASELINK_P (name))
2152     {
2153       /* A member function that has already been looked up.  */
2154       my_friendly_assert ((TREE_CODE (BASELINK_FUNCTIONS (name))
2155                            == TEMPLATE_ID_EXPR),
2156                           20020805);
2157       member = name;
2158     }
2159   else
2160     {
2161       bool is_template_id = false;
2162       tree template_args = NULL_TREE;
2163
2164       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2165         {
2166           is_template_id = true;
2167           template_args = TREE_OPERAND (name, 1);
2168           name = TREE_OPERAND (name, 0);
2169         }
2170
2171       if (TREE_CODE (name) == SCOPE_REF)
2172         {
2173           tree scope;
2174
2175           /* A qualified name.  The qualifying class or namespace `S' has
2176              already been looked up; it is either a TYPE or a
2177              NAMESPACE_DECL.  The member name is either an IDENTIFIER_NODE
2178              or a BIT_NOT_EXPR.  */
2179           scope = TREE_OPERAND (name, 0);
2180           name = TREE_OPERAND (name, 1);
2181           my_friendly_assert ((CLASS_TYPE_P (scope)
2182                                || TREE_CODE (scope) == NAMESPACE_DECL),
2183                               20020804);
2184           my_friendly_assert ((TREE_CODE (name) == IDENTIFIER_NODE
2185                                || TREE_CODE (name) == BIT_NOT_EXPR),
2186                               20020804);
2187
2188           /* If SCOPE is a namespace, then the qualified name does not
2189              name a member of OBJECT_TYPE.  */
2190           if (TREE_CODE (scope) == NAMESPACE_DECL)
2191             {
2192               error ("`%D::%D' is not a member of `%T'",
2193                      scope, name, object_type);
2194               return error_mark_node;
2195             }
2196
2197           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
2198           access_path = lookup_base (object_type, scope, ba_check, NULL);
2199           if (!access_path || access_path == error_mark_node)
2200             return error_mark_node;
2201
2202           if (TREE_CODE (name) == BIT_NOT_EXPR)
2203             member = lookup_destructor (object, scope, name);
2204           else
2205             {
2206               /* Look up the member.  */
2207               member = lookup_member (access_path, name, /*protect=*/1,
2208                                       /*want_type=*/0);
2209               if (member == NULL_TREE)
2210                 {
2211                   error ("'%D' has no member named '%E'", object_type, name);
2212                   return error_mark_node;
2213                 }
2214               if (member == error_mark_node)
2215                 return error_mark_node;
2216             }
2217         }
2218       else if (TREE_CODE (name) == BIT_NOT_EXPR)
2219         member = lookup_destructor (object, /*scope=*/NULL_TREE, name);
2220       else if (TREE_CODE (name) == IDENTIFIER_NODE)
2221         {
2222           /* An unqualified name.  */
2223           member = lookup_member (object_type, name, /*protect=*/1,
2224                                   /*want_type=*/0);
2225           if (member == NULL_TREE)
2226             {
2227               error ("'%D' has no member named '%E'", object_type, name);
2228               return error_mark_node;
2229             }
2230           else if (member == error_mark_node)
2231             return error_mark_node;
2232         }
2233       else
2234         {
2235           /* The YACC parser sometimes gives us things that are not names.
2236              These always indicate errors.  The recursive-descent parser
2237              does not do this, so this code can go away once that parser
2238              replaces the YACC parser.  */
2239           error ("invalid use of `%D'", name);
2240           return error_mark_node;
2241         }
2242
2243       if (is_template_id)
2244         {
2245           tree template = member;
2246
2247           if (BASELINK_P (template))
2248             BASELINK_FUNCTIONS (template)
2249               = build_nt (TEMPLATE_ID_EXPR,
2250                           BASELINK_FUNCTIONS (template),
2251                           template_args);
2252           else
2253             {
2254               error ("`%D' is not a member template function", name);
2255               return error_mark_node;
2256             }
2257         }
2258     }
2259
2260   if (TREE_DEPRECATED (member))
2261     warn_deprecated_use (member);
2262
2263   return build_class_member_access_expr (object, member, access_path,
2264                                          /*preserve_reference=*/false);
2265 }
2266
2267 /* Return an expression for the MEMBER_NAME field in the internal
2268    representation of PTRMEM, a pointer-to-member function.  (Each
2269    pointer-to-member function type gets its own RECORD_TYPE so it is
2270    more convenient to access the fields by name than by FIELD_DECL.)
2271    This routine converts the NAME to a FIELD_DECL and then creates the
2272    node for the complete expression.  */
2273
2274 tree
2275 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2276 {
2277   tree ptrmem_type;
2278   tree member;
2279   tree member_type;
2280
2281   /* This code is a stripped down version of
2282      build_class_member_access_expr.  It does not work to use that
2283      routine directly because it expects the object to be of class
2284      type.  */
2285   ptrmem_type = TREE_TYPE (ptrmem);
2286   my_friendly_assert (TYPE_PTRMEMFUNC_P (ptrmem_type), 20020804);
2287   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2288                           /*want_type=*/0);
2289   member_type = cp_build_qualified_type (TREE_TYPE (member),
2290                                          cp_type_quals (ptrmem_type));
2291   return fold (build (COMPONENT_REF, member_type, ptrmem, member));
2292 }
2293
2294 /* Given an expression PTR for a pointer, return an expression
2295    for the value pointed to.
2296    ERRORSTRING is the name of the operator to appear in error messages.
2297
2298    This function may need to overload OPERATOR_FNNAME.
2299    Must also handle REFERENCE_TYPEs for C++.  */
2300
2301 tree
2302 build_x_indirect_ref (ptr, errorstring)
2303      tree ptr;
2304      const char *errorstring;
2305 {
2306   tree rval;
2307
2308   if (processing_template_decl)
2309     return build_min_nt (INDIRECT_REF, ptr);
2310
2311   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE,
2312                        NULL_TREE);
2313   if (rval)
2314     return rval;
2315   return build_indirect_ref (ptr, errorstring);
2316 }
2317
2318 tree
2319 build_indirect_ref (ptr, errorstring)
2320      tree ptr;
2321      const char *errorstring;
2322 {
2323   register tree pointer, type;
2324
2325   if (ptr == error_mark_node)
2326     return error_mark_node;
2327
2328   if (ptr == current_class_ptr)
2329     return current_class_ref;
2330
2331   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2332              ? ptr : default_conversion (ptr));
2333   type = TREE_TYPE (pointer);
2334
2335   if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
2336     {
2337       /* [expr.unary.op]
2338
2339          If the type of the expression is "pointer to T," the type
2340          of  the  result  is  "T."
2341
2342          We must use the canonical variant because certain parts of
2343          the back end, like fold, do pointer comparisons between
2344          types.  */
2345       tree t = canonical_type_variant (TREE_TYPE (type));
2346
2347       if (VOID_TYPE_P (t))
2348         {
2349           /* A pointer to incomplete type (other than cv void) can be
2350              dereferenced [expr.unary.op]/1  */
2351           error ("`%T' is not a pointer-to-object type", type);
2352           return error_mark_node;
2353         }
2354       else if (TREE_CODE (pointer) == ADDR_EXPR
2355                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2356         /* The POINTER was something like `&x'.  We simplify `*&x' to
2357            `x'.  */
2358         return TREE_OPERAND (pointer, 0);
2359       else
2360         {
2361           tree ref = build1 (INDIRECT_REF, t, pointer);
2362
2363           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2364              so that we get the proper error message if the result is used
2365              to assign to.  Also, &* is supposed to be a no-op.  */
2366           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2367           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2368           TREE_SIDE_EFFECTS (ref)
2369             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2370           return ref;
2371         }
2372     }
2373   /* `pointer' won't be an error_mark_node if we were given a
2374      pointer to member, so it's cool to check for this here.  */
2375   else if (TYPE_PTRMEM_P (type) || TYPE_PTRMEMFUNC_P (type))
2376     error ("invalid use of `%s' on pointer to member", errorstring);
2377   else if (pointer != error_mark_node)
2378     {
2379       if (errorstring)
2380         error ("invalid type argument of `%s'", errorstring);
2381       else
2382         error ("invalid type argument");
2383     }
2384   return error_mark_node;
2385 }
2386
2387 /* This handles expressions of the form "a[i]", which denotes
2388    an array reference.
2389
2390    This is logically equivalent in C to *(a+i), but we may do it differently.
2391    If A is a variable or a member, we generate a primitive ARRAY_REF.
2392    This avoids forcing the array out of registers, and can work on
2393    arrays that are not lvalues (for example, members of structures returned
2394    by functions).
2395
2396    If INDEX is of some user-defined type, it must be converted to
2397    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2398    will inherit the type of the array, which will be some pointer type.  */
2399
2400 tree
2401 build_array_ref (array, idx)
2402      tree array, idx;
2403 {
2404   if (idx == 0)
2405     {
2406       error ("subscript missing in array reference");
2407       return error_mark_node;
2408     }
2409
2410   if (TREE_TYPE (array) == error_mark_node
2411       || TREE_TYPE (idx) == error_mark_node)
2412     return error_mark_node;
2413
2414   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2415      inside it.  */
2416   switch (TREE_CODE (array))
2417     {
2418     case COMPOUND_EXPR:
2419       {
2420         tree value = build_array_ref (TREE_OPERAND (array, 1), idx);
2421         return build (COMPOUND_EXPR, TREE_TYPE (value),
2422                       TREE_OPERAND (array, 0), value);
2423       }
2424
2425     case COND_EXPR:
2426       return build_conditional_expr
2427         (TREE_OPERAND (array, 0),
2428          build_array_ref (TREE_OPERAND (array, 1), idx),
2429          build_array_ref (TREE_OPERAND (array, 2), idx));
2430
2431     default:
2432       break;
2433     }
2434
2435   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
2436       && TREE_CODE (array) != INDIRECT_REF)
2437     {
2438       tree rval, type;
2439
2440       /* Subscripting with type char is likely to lose
2441          on a machine where chars are signed.
2442          So warn on any machine, but optionally.
2443          Don't warn for unsigned char since that type is safe.
2444          Don't warn for signed char because anyone who uses that
2445          must have done so deliberately.  */
2446       if (warn_char_subscripts
2447           && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node)
2448         warning ("array subscript has type `char'");
2449
2450       /* Apply default promotions *after* noticing character types.  */
2451       idx = default_conversion (idx);
2452
2453       if (TREE_CODE (TREE_TYPE (idx)) != INTEGER_TYPE)
2454         {
2455           error ("array subscript is not an integer");
2456           return error_mark_node;
2457         }
2458
2459       /* An array that is indexed by a non-constant
2460          cannot be stored in a register; we must be able to do
2461          address arithmetic on its address.
2462          Likewise an array of elements of variable size.  */
2463       if (TREE_CODE (idx) != INTEGER_CST
2464           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2465               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2466                   != INTEGER_CST)))
2467         {
2468           if (!cxx_mark_addressable (array))
2469             return error_mark_node;
2470         }
2471
2472       /* An array that is indexed by a constant value which is not within
2473          the array bounds cannot be stored in a register either; because we
2474          would get a crash in store_bit_field/extract_bit_field when trying
2475          to access a non-existent part of the register.  */
2476       if (TREE_CODE (idx) == INTEGER_CST
2477           && TYPE_VALUES (TREE_TYPE (array))
2478           && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array))))
2479         {
2480           if (!cxx_mark_addressable (array))
2481             return error_mark_node;
2482         }
2483
2484       if (pedantic && !lvalue_p (array))
2485         pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2486
2487       /* Note in C++ it is valid to subscript a `register' array, since
2488          it is valid to take the address of something with that
2489          storage specification.  */
2490       if (extra_warnings)
2491         {
2492           tree foo = array;
2493           while (TREE_CODE (foo) == COMPONENT_REF)
2494             foo = TREE_OPERAND (foo, 0);
2495           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2496             warning ("subscripting array declared `register'");
2497         }
2498
2499       type = TREE_TYPE (TREE_TYPE (array));
2500       rval = build (ARRAY_REF, type, array, idx);
2501       /* Array ref is const/volatile if the array elements are
2502          or if the array is..  */
2503       TREE_READONLY (rval)
2504         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2505       TREE_SIDE_EFFECTS (rval)
2506         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2507       TREE_THIS_VOLATILE (rval)
2508         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2509       return require_complete_type (fold (rval));
2510     }
2511
2512   {
2513     tree ar = default_conversion (array);
2514     tree ind = default_conversion (idx);
2515
2516     /* Put the integer in IND to simplify error checking.  */
2517     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2518       {
2519         tree temp = ar;
2520         ar = ind;
2521         ind = temp;
2522       }
2523
2524     if (ar == error_mark_node)
2525       return ar;
2526
2527     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2528       {
2529         error ("subscripted value is neither array nor pointer");
2530         return error_mark_node;
2531       }
2532     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2533       {
2534         error ("array subscript is not an integer");
2535         return error_mark_node;
2536       }
2537
2538     return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2539                                "array indexing");
2540   }
2541 }
2542 \f
2543 /* Resolve a pointer to member function.  INSTANCE is the object
2544    instance to use, if the member points to a virtual member.
2545
2546    This used to avoid checking for virtual functions if basetype
2547    has no virtual functions, according to an earlier ANSI draft.
2548    With the final ISO C++ rules, such an optimization is
2549    incorrect: A pointer to a derived member can be static_cast
2550    to pointer-to-base-member, as long as the dynamic object
2551    later has the right member.  */
2552
2553 tree
2554 get_member_function_from_ptrfunc (instance_ptrptr, function)
2555      tree *instance_ptrptr;
2556      tree function;
2557 {
2558   if (TREE_CODE (function) == OFFSET_REF)
2559     function = TREE_OPERAND (function, 1);
2560
2561   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2562     {
2563       tree idx, delta, e1, e2, e3, vtbl, basetype;
2564       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2565
2566       tree instance_ptr = *instance_ptrptr;
2567       tree instance_save_expr = 0;
2568       if (instance_ptr == error_mark_node)
2569         {
2570           if (TREE_CODE (function) == PTRMEM_CST)
2571             {
2572               /* Extracting the function address from a pmf is only
2573                  allowed with -Wno-pmf-conversions. It only works for
2574                  pmf constants.  */
2575               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2576               e1 = convert (fntype, e1);
2577               return e1;
2578             }
2579           else
2580             {
2581               error ("object missing in use of `%E'", function);
2582               return error_mark_node;
2583             }
2584         }
2585
2586       if (TREE_SIDE_EFFECTS (instance_ptr))
2587         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2588
2589       if (TREE_SIDE_EFFECTS (function))
2590         function = save_expr (function);
2591
2592       /* Start by extracting all the information from the PMF itself.  */
2593       e3 = PFN_FROM_PTRMEMFUNC (function);
2594       delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2595       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2596       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2597         {
2598         case ptrmemfunc_vbit_in_pfn:
2599           e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2600           idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2601           break;
2602
2603         case ptrmemfunc_vbit_in_delta:
2604           e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2605           delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2606           break;
2607
2608         default:
2609           abort ();
2610         }
2611
2612       /* Convert down to the right base before using the instance.  First
2613          use the type...  */
2614       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2615       basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2616                               basetype, ba_check, NULL);
2617       instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1);
2618       if (instance_ptr == error_mark_node)
2619         return error_mark_node;
2620       /* ...and then the delta in the PMF.  */
2621       instance_ptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
2622                             instance_ptr, delta);
2623
2624       /* Hand back the adjusted 'this' argument to our caller.  */
2625       *instance_ptrptr = instance_ptr;
2626
2627       /* Next extract the vtable pointer from the object.  */
2628       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2629                      instance_ptr);
2630       vtbl = build_indirect_ref (vtbl, NULL);
2631
2632       /* Finally, extract the function pointer from the vtable.  */
2633       e2 = fold (build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));
2634       e2 = build_indirect_ref (e2, NULL);
2635       TREE_CONSTANT (e2) = 1;
2636
2637       /* When using function descriptors, the address of the
2638          vtable entry is treated as a function pointer.  */
2639       if (TARGET_VTABLE_USES_DESCRIPTORS)
2640         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2641                      build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2642
2643       TREE_TYPE (e2) = TREE_TYPE (e3);
2644       e1 = build_conditional_expr (e1, e2, e3);
2645
2646       /* Make sure this doesn't get evaluated first inside one of the
2647          branches of the COND_EXPR.  */
2648       if (instance_save_expr)
2649         e1 = build (COMPOUND_EXPR, TREE_TYPE (e1),
2650                     instance_save_expr, e1);
2651
2652       function = e1;
2653     }
2654   return function;
2655 }
2656
2657 tree
2658 build_function_call_real (function, params, require_complete, flags)
2659      tree function, params;
2660      int require_complete, flags;
2661 {
2662   register tree fntype, fndecl;
2663   register tree value_type;
2664   register tree coerced_params;
2665   tree result;
2666   tree name = NULL_TREE, assembler_name = NULL_TREE;
2667   int is_method;
2668   tree original = function;
2669
2670   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2671      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2672   if (TREE_CODE (function) == NOP_EXPR
2673       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2674     function = TREE_OPERAND (function, 0);
2675
2676   if (TREE_CODE (function) == FUNCTION_DECL)
2677     {
2678       name = DECL_NAME (function);
2679       assembler_name = DECL_ASSEMBLER_NAME (function);
2680
2681       mark_used (function);
2682       fndecl = function;
2683
2684       /* Convert anything with function type to a pointer-to-function.  */
2685       if (pedantic && DECL_MAIN_P (function))
2686         pedwarn ("ISO C++ forbids calling `::main' from within program");
2687
2688       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2689          (because calling an inline function does not mean the function
2690          needs to be separately compiled).  */
2691
2692       if (DECL_INLINE (function))
2693         function = inline_conversion (function);
2694       else
2695         function = build_addr_func (function);
2696     }
2697   else
2698     {
2699       fndecl = NULL_TREE;
2700
2701       function = build_addr_func (function);
2702     }
2703
2704   if (function == error_mark_node)
2705     return error_mark_node;
2706
2707   fntype = TREE_TYPE (function);
2708
2709   if (TYPE_PTRMEMFUNC_P (fntype))
2710     {
2711       error ("must use .* or ->* to call pointer-to-member function in `%E (...)'",
2712                 original);
2713       return error_mark_node;
2714     }
2715
2716   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2717                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2718
2719   if (!((TREE_CODE (fntype) == POINTER_TYPE
2720          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2721         || is_method
2722         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2723     {
2724       error ("`%E' cannot be used as a function", original);
2725       return error_mark_node;
2726     }
2727
2728   /* fntype now gets the type of function pointed to.  */
2729   fntype = TREE_TYPE (fntype);
2730
2731   /* Convert the parameters to the types declared in the
2732      function prototype, or apply default promotions.  */
2733
2734   if (flags & LOOKUP_COMPLAIN)
2735     coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2736                                         params, fndecl, LOOKUP_NORMAL);
2737   else
2738     coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2739                                         params, fndecl, 0);
2740
2741   if (coerced_params == error_mark_node)
2742     {
2743       if (flags & LOOKUP_SPECULATIVELY)
2744         return NULL_TREE;
2745       else
2746         return error_mark_node;
2747     }
2748
2749   /* Check for errors in format strings.  */
2750
2751   if (warn_format)
2752     check_function_format (NULL, TYPE_ATTRIBUTES (fntype), coerced_params);
2753
2754   /* Recognize certain built-in functions so we can make tree-codes
2755      other than CALL_EXPR.  We do this when it enables fold-const.c
2756      to do something useful.  */
2757
2758   if (TREE_CODE (function) == ADDR_EXPR
2759       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
2760       && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
2761     {
2762       result = expand_tree_builtin (TREE_OPERAND (function, 0),
2763                                     params, coerced_params);
2764       if (result)
2765         return result;
2766     }
2767
2768   /* Some built-in function calls will be evaluated at
2769      compile-time in fold ().  */
2770   result = fold (build_call (function, coerced_params));
2771   value_type = TREE_TYPE (result);
2772
2773   if (require_complete)
2774     {
2775       if (TREE_CODE (value_type) == VOID_TYPE)
2776         return result;
2777       result = require_complete_type (result);
2778     }
2779   if (IS_AGGR_TYPE (value_type))
2780     result = build_cplus_new (value_type, result);
2781   return convert_from_reference (result);
2782 }
2783
2784 tree
2785 build_function_call (function, params)
2786      tree function, params;
2787 {
2788   return build_function_call_real (function, params, 1, LOOKUP_NORMAL);
2789 }
2790 \f
2791 /* Convert the actual parameter expressions in the list VALUES
2792    to the types in the list TYPELIST.
2793    If parmdecls is exhausted, or when an element has NULL as its type,
2794    perform the default conversions.
2795
2796    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2797
2798    This is also where warnings about wrong number of args are generated.
2799
2800    Return a list of expressions for the parameters as converted.
2801
2802    Both VALUES and the returned value are chains of TREE_LIST nodes
2803    with the elements of the list in the TREE_VALUE slots of those nodes.
2804
2805    In C++, unspecified trailing parameters can be filled in with their
2806    default arguments, if such were specified.  Do so here.  */
2807
2808 tree
2809 convert_arguments (typelist, values, fndecl, flags)
2810      tree typelist, values, fndecl;
2811      int flags;
2812 {
2813   register tree typetail, valtail;
2814   register tree result = NULL_TREE;
2815   const char *called_thing = 0;
2816   int i = 0;
2817
2818   /* Argument passing is always copy-initialization.  */
2819   flags |= LOOKUP_ONLYCONVERTING;
2820
2821   if (fndecl)
2822     {
2823       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2824         {
2825           if (DECL_NAME (fndecl) == NULL_TREE
2826               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2827             called_thing = "constructor";
2828           else
2829             called_thing = "member function";
2830         }
2831       else
2832         called_thing = "function";
2833     }
2834
2835   for (valtail = values, typetail = typelist;
2836        valtail;
2837        valtail = TREE_CHAIN (valtail), i++)
2838     {
2839       register tree type = typetail ? TREE_VALUE (typetail) : 0;
2840       register tree val = TREE_VALUE (valtail);
2841
2842       if (val == error_mark_node)
2843         return error_mark_node;
2844
2845       if (type == void_type_node)
2846         {
2847           if (fndecl)
2848             {
2849               cp_error_at ("too many arguments to %s `%+#D'", called_thing,
2850                            fndecl);
2851               error ("at this point in file");
2852             }
2853           else
2854             error ("too many arguments to function");
2855           /* In case anybody wants to know if this argument
2856              list is valid.  */
2857           if (result)
2858             TREE_TYPE (tree_last (result)) = error_mark_node;
2859           break;
2860         }
2861
2862       if (TREE_CODE (val) == OFFSET_REF)
2863         val = resolve_offset_ref (val);
2864
2865       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2866          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
2867       if (TREE_CODE (val) == NOP_EXPR
2868           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2869           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2870         val = TREE_OPERAND (val, 0);
2871
2872       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2873         {
2874           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2875               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2876               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2877             val = default_conversion (val);
2878         }
2879
2880       if (val == error_mark_node)
2881         return error_mark_node;
2882
2883       if (type != 0)
2884         {
2885           /* Formal parm type is specified by a function prototype.  */
2886           tree parmval;
2887
2888           if (!COMPLETE_TYPE_P (complete_type (type)))
2889             {
2890               error ("parameter type of called function is incomplete");
2891               parmval = val;
2892             }
2893           else
2894             {
2895               parmval = convert_for_initialization
2896                 (NULL_TREE, type, val, flags,
2897                  "argument passing", fndecl, i);
2898               parmval = convert_for_arg_passing (type, parmval);
2899             }
2900
2901           if (parmval == error_mark_node)
2902             return error_mark_node;
2903
2904           result = tree_cons (NULL_TREE, parmval, result);
2905         }
2906       else
2907         {
2908           if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE)
2909             val = convert_from_reference (val);
2910
2911           if (fndecl && DECL_BUILT_IN (fndecl)
2912               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2913             /* Don't do ellipsis conversion for __built_in_constant_p
2914                as this will result in spurious warnings for non-POD
2915                types.  */
2916             val = require_complete_type (val);
2917           else
2918             val = convert_arg_to_ellipsis (val);
2919
2920           result = tree_cons (NULL_TREE, val, result);
2921         }
2922
2923       if (typetail)
2924         typetail = TREE_CHAIN (typetail);
2925     }
2926
2927   if (typetail != 0 && typetail != void_list_node)
2928     {
2929       /* See if there are default arguments that can be used */
2930       if (TREE_PURPOSE (typetail)
2931           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2932         {
2933           for (; typetail != void_list_node; ++i)
2934             {
2935               tree parmval
2936                 = convert_default_arg (TREE_VALUE (typetail),
2937                                        TREE_PURPOSE (typetail),
2938                                        fndecl, i);
2939
2940               if (parmval == error_mark_node)
2941                 return error_mark_node;
2942
2943               result = tree_cons (0, parmval, result);
2944               typetail = TREE_CHAIN (typetail);
2945               /* ends with `...'.  */
2946               if (typetail == NULL_TREE)
2947                 break;
2948             }
2949         }
2950       else
2951         {
2952           if (fndecl)
2953             {
2954               cp_error_at ("too few arguments to %s `%+#D'",
2955                            called_thing, fndecl);
2956               error ("at this point in file");
2957             }
2958           else
2959             error ("too few arguments to function");
2960           return error_mark_list;
2961         }
2962     }
2963
2964   return nreverse (result);
2965 }
2966 \f
2967 /* Build a binary-operation expression, after performing default
2968    conversions on the operands.  CODE is the kind of expression to build.  */
2969
2970 tree
2971 build_x_binary_op (code, arg1, arg2)
2972      enum tree_code code;
2973      tree arg1, arg2;
2974 {
2975   if (processing_template_decl)
2976     return build_min_nt (code, arg1, arg2);
2977
2978   return build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE);
2979 }
2980
2981 #if 0
2982
2983 tree
2984 build_template_expr (enum tree_code code, tree op0, tree op1, tree op2)
2985 {
2986   tree type;
2987
2988   /* If any of the operands is erroneous the result is erroneous too.  */
2989   if (error_operand_p (op0)
2990       || (op1 && error_operand_p (op1))
2991       || (op2 && error_operand_p (op2)))
2992     return error_mark_node;
2993
2994   if (dependent_type_p (TREE_TYPE (op0))
2995       || (op1 && dependent_type_p (TREE_TYPE (op1)))
2996       || (op2 && dependent_type_p (TREE_TYPE (op2))))
2997     /* If at least one operand has a dependent type, we cannot
2998        determine the type of the expression until instantiation time.  */
2999     type = NULL_TREE;
3000   else
3001     {
3002       struct z_candidate *cand;
3003       tree op0_type;
3004       tree op1_type;
3005       tree op2_type;
3006
3007       /* None of the operands is dependent, so we can compute the type
3008          of the expression at this point.  We must compute the type so
3009          that in things like:
3010
3011            template <int I>
3012            void f() { S<sizeof(I + 3)> s; ... }
3013
3014          we can tell that the type of "s" is non-dependent.
3015
3016          If we're processing a template argument, we do not want to
3017          actually change the operands in any way.  Adding conversions,
3018          performing constant folding, etc., would all change mangled
3019          names.  For example, in:
3020
3021            template <int I>
3022            void f(S<sizeof(3 + 4 + I)>);
3023
3024          we need to determine that "3 + 4 + I" has type "int", without
3025          actually turning the expression into "7 + I".  */
3026       cand = find_overloaded_op (code, op0, op1, op2);
3027       if (cand)
3028         /* If an overloaded operator was found, the expression will
3029            have the type returned by the function.  */
3030         type = non_reference (TREE_TYPE (cand->fn));
3031       else
3032         {
3033           /* There is no overloaded operator so we can just use the
3034              default rules for determining the type of the operand.  */
3035           op0_type = TREE_TYPE (op0);
3036           op1_type = op1 ? TREE_TYPE (op1) : NULL_TREE;
3037           op2_type = op2 ? TREE_TYPE (op2) : NULL_TREE;
3038           type = NULL_TREE;
3039
3040           switch (code)
3041             {
3042             case MODIFY_EXPR:
3043               /* [expr.ass]
3044
3045                  The result of the assignment operation is the value
3046                  stored in the left operand.  */
3047               type = op0_type;
3048               break;
3049             case COMPONENT_REF:
3050               /* Implement this case.  */
3051               break;
3052             case POSTINCREMENT_EXPR:
3053             case POSTDECREMENT_EXPR:
3054               /* [expr.post.incr]
3055
3056                  The type of the result is the cv-unqualified version
3057                  of the type of the operand.  */
3058               type = TYPE_MAIN_VARIANT (op0_type);
3059               break;
3060             case PREINCREMENT_EXPR:
3061             case PREDECREMENT_EXPR:
3062               /* [expr.pre.incr]
3063
3064                  The value is the new value of the operand.  */
3065               type = op0_type;
3066               break;
3067             case INDIRECT_REF:
3068               /* [expr.unary.op]
3069
3070                  If the type of the expression is "pointer to T", the
3071                  type of the result is "T".  */
3072               type = TREE_TYPE (op0_type);
3073               break;
3074             case ADDR_EXPR:
3075               /* [expr.unary.op]
3076
3077                  If the type of the expression is "T", the type of the
3078                  result is "pointer to T".  */
3079               /* FIXME: Handle the pointer-to-member case.  */
3080               break;
3081             case MEMBER_REF:
3082               /* FIXME: Implement this case.  */
3083               break;
3084             case LSHIFT_EXPR:
3085             case RSHIFT_EXPR:
3086               /* [expr.shift]
3087
3088                  The type of the result is that of the promoted left
3089                  operand.  */
3090               break;
3091             case PLUS_EXPR:
3092             case MINUS_EXPR:
3093               /* FIXME: Be careful of special pointer-arithmetic
3094                  cases.  */
3095               /* Fall through. */
3096             case MAX_EXPR:
3097             case MIN_EXPR:
3098               /* These are GNU extensions; the result type is computed
3099                  as it would be for other arithmetic operators.  */
3100               /* Fall through. */
3101             case BIT_AND_EXPR:
3102             case BIT_XOR_EXPR:
3103             case BIT_IOR_EXPR:
3104             case MULT_EXPR:
3105             case TRUNC_DIV_EXPR:
3106             case TRUNC_MOD_EXPR:
3107               /* [expr.bit.and], [expr.xor], [expr.or], [expr.mul]
3108
3109                  The usual arithmetic conversions are performed on the
3110                  operands and determine the type of the result.  */
3111               /* FIXME: Check that this is possible.  */
3112               type = type_after_usual_arithmetic_conversions (t1, t2);
3113               break;
3114             case GT_EXPR:
3115             case LT_EXPR:
3116             case GE_EXPR:
3117             case LE_EXPR:
3118             case EQ_EXPR:
3119             case NE_EXPR:
3120               /* [expr.rel]
3121
3122                  The type of the result is bool.  */
3123               type = boolean_type_node;
3124               break;
3125             case TRUTH_ANDIF_EXPR:
3126             case TRUTH_ORIF_EXPR:
3127               /* [expr.log.and], [expr.log.org]
3128
3129                  The result is a bool.  */
3130               type = boolean_type_node;
3131               break;
3132             case COND_EXPR:
3133               /* FIXME: Handle special rules for conditioanl
3134                  expressions.  */
3135               break;
3136             case COMPOUND_EXPR:
3137               type = op1_type;
3138               break;
3139             default:
3140               abort ();
3141             }
3142           /* If the type of the expression could not be determined,
3143              something is wrong.  */
3144           if (!type)
3145             abort ();
3146           /* If the type is erroneous, the expression is erroneous
3147              too.  */
3148           if (type == error_mark_node)
3149             return error_mark_node;
3150         }
3151     }
3152
3153   return build_min (code, type, op0, op1, op2, NULL_TREE);
3154 }
3155
3156 #endif
3157
3158 /* Build a binary-operation expression without default conversions.
3159    CODE is the kind of expression to build.
3160    This function differs from `build' in several ways:
3161    the data type of the result is computed and recorded in it,
3162    warnings are generated if arg data types are invalid,
3163    special handling for addition and subtraction of pointers is known,
3164    and some optimization is done (operations on narrow ints
3165    are done in the narrower type when that gives the same result).
3166    Constant folding is also done before the result is returned.
3167
3168    Note that the operands will never have enumeral types
3169    because either they have just had the default conversions performed
3170    or they have both just been converted to some other type in which
3171    the arithmetic is to be done.
3172
3173    C++: must do special pointer arithmetic when implementing
3174    multiple inheritance, and deal with pointer to member functions.  */
3175
3176 tree
3177 build_binary_op (code, orig_op0, orig_op1, convert_p)
3178      enum tree_code code;
3179      tree orig_op0, orig_op1;
3180      int convert_p ATTRIBUTE_UNUSED;
3181 {
3182   tree op0, op1;
3183   register enum tree_code code0, code1;
3184   tree type0, type1;
3185
3186   /* Expression code to give to the expression when it is built.
3187      Normally this is CODE, which is what the caller asked for,
3188      but in some special cases we change it.  */
3189   register enum tree_code resultcode = code;
3190
3191   /* Data type in which the computation is to be performed.
3192      In the simplest cases this is the common type of the arguments.  */
3193   register tree result_type = NULL;
3194
3195   /* Nonzero means operands have already been type-converted
3196      in whatever way is necessary.
3197      Zero means they need to be converted to RESULT_TYPE.  */
3198   int converted = 0;
3199
3200   /* Nonzero means create the expression with this type, rather than
3201      RESULT_TYPE.  */
3202   tree build_type = 0;
3203
3204   /* Nonzero means after finally constructing the expression
3205      convert it to this type.  */
3206   tree final_type = 0;
3207
3208   /* Nonzero if this is an operation like MIN or MAX which can
3209      safely be computed in short if both args are promoted shorts.
3210      Also implies COMMON.
3211      -1 indicates a bitwise operation; this makes a difference
3212      in the exact conditions for when it is safe to do the operation
3213      in a narrower mode.  */
3214   int shorten = 0;
3215
3216   /* Nonzero if this is a comparison operation;
3217      if both args are promoted shorts, compare the original shorts.
3218      Also implies COMMON.  */
3219   int short_compare = 0;
3220
3221   /* Nonzero if this is a right-shift operation, which can be computed on the
3222      original short and then promoted if the operand is a promoted short.  */
3223   int short_shift = 0;
3224
3225   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
3226   int common = 0;
3227
3228   /* Apply default conversions.  */
3229   op0 = orig_op0;
3230   op1 = orig_op1;
3231
3232   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3233       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3234       || code == TRUTH_XOR_EXPR)
3235     {
3236       if (!really_overloaded_fn (op0))
3237         op0 = decay_conversion (op0);
3238       if (!really_overloaded_fn (op1))
3239         op1 = decay_conversion (op1);
3240     }
3241   else
3242     {
3243       if (!really_overloaded_fn (op0))
3244         op0 = default_conversion (op0);
3245       if (!really_overloaded_fn (op1))
3246         op1 = default_conversion (op1);
3247     }
3248
3249   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3250   STRIP_TYPE_NOPS (op0);
3251   STRIP_TYPE_NOPS (op1);
3252
3253   /* DTRT if one side is an overloaded function, but complain about it.  */
3254   if (type_unknown_p (op0))
3255     {
3256       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3257       if (t != error_mark_node)
3258         {
3259           pedwarn ("assuming cast to type `%T' from overloaded function",
3260                       TREE_TYPE (t));
3261           op0 = t;
3262         }
3263     }
3264   if (type_unknown_p (op1))
3265     {
3266       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3267       if (t != error_mark_node)
3268         {
3269           pedwarn ("assuming cast to type `%T' from overloaded function",
3270                       TREE_TYPE (t));
3271           op1 = t;
3272         }
3273     }
3274
3275   type0 = TREE_TYPE (op0);
3276   type1 = TREE_TYPE (op1);
3277
3278   /* The expression codes of the data types of the arguments tell us
3279      whether the arguments are integers, floating, pointers, etc.  */
3280   code0 = TREE_CODE (type0);
3281   code1 = TREE_CODE (type1);
3282
3283   /* If an error was already reported for one of the arguments,
3284      avoid reporting another error.  */
3285
3286   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3287     return error_mark_node;
3288
3289   switch (code)
3290     {
3291     case PLUS_EXPR:
3292       /* Handle the pointer + int case.  */
3293       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3294         return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
3295       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
3296         return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
3297       else
3298         common = 1;
3299       break;
3300
3301     case MINUS_EXPR:
3302       /* Subtraction of two similar pointers.
3303          We must subtract them as integers, then divide by object size.  */
3304       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3305           && comp_target_types (type0, type1, 1))
3306         return pointer_diff (op0, op1, common_type (type0, type1));
3307       /* Handle pointer minus int.  Just like pointer plus int.  */
3308       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3309         return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
3310       else
3311         common = 1;
3312       break;
3313
3314     case MULT_EXPR:
3315       common = 1;
3316       break;
3317
3318     case TRUNC_DIV_EXPR:
3319     case CEIL_DIV_EXPR:
3320     case FLOOR_DIV_EXPR:
3321     case ROUND_DIV_EXPR:
3322     case EXACT_DIV_EXPR:
3323       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3324            || code0 == COMPLEX_TYPE)
3325           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3326               || code1 == COMPLEX_TYPE))
3327         {
3328           if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
3329             warning ("division by zero in `%E / 0'", op0);
3330           else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
3331             warning ("division by zero in `%E / 0.'", op0);
3332
3333           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
3334             resultcode = RDIV_EXPR;
3335           else
3336             /* When dividing two signed integers, we have to promote to int.
3337                unless we divide by a constant != -1.  Note that default
3338                conversion will have been performed on the operands at this
3339                point, so we have to dig out the original type to find out if
3340                it was unsigned.  */
3341             shorten = ((TREE_CODE (op0) == NOP_EXPR
3342                         && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3343                        || (TREE_CODE (op1) == INTEGER_CST
3344                            && ! integer_all_onesp (op1)));
3345
3346           common = 1;
3347         }
3348       break;
3349
3350     case BIT_AND_EXPR:
3351     case BIT_ANDTC_EXPR:
3352     case BIT_IOR_EXPR:
3353     case BIT_XOR_EXPR:
3354       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3355         shorten = -1;
3356       break;
3357
3358     case TRUNC_MOD_EXPR:
3359     case FLOOR_MOD_EXPR:
3360       if (code1 == INTEGER_TYPE && integer_zerop (op1))
3361         warning ("division by zero in `%E %% 0'", op0);
3362       else if (code1 == REAL_TYPE && real_zerop (op1))
3363         warning ("division by zero in `%E %% 0.'", op0);
3364
3365       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3366         {
3367           /* Although it would be tempting to shorten always here, that loses
3368              on some targets, since the modulo instruction is undefined if the
3369              quotient can't be represented in the computation mode.  We shorten
3370              only if unsigned or if dividing by something we know != -1.  */
3371           shorten = ((TREE_CODE (op0) == NOP_EXPR
3372                       && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3373                      || (TREE_CODE (op1) == INTEGER_CST
3374                          && ! integer_all_onesp (op1)));
3375           common = 1;
3376         }
3377       break;
3378
3379     case TRUTH_ANDIF_EXPR:
3380     case TRUTH_ORIF_EXPR:
3381     case TRUTH_AND_EXPR:
3382     case TRUTH_OR_EXPR:
3383       result_type = boolean_type_node;
3384       break;
3385
3386       /* Shift operations: result has same type as first operand;
3387          always convert second operand to int.
3388          Also set SHORT_SHIFT if shifting rightward.  */
3389
3390     case RSHIFT_EXPR:
3391       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3392         {
3393           result_type = type0;
3394           if (TREE_CODE (op1) == INTEGER_CST)
3395             {
3396               if (tree_int_cst_lt (op1, integer_zero_node))
3397                 warning ("right shift count is negative");
3398               else
3399                 {
3400                   if (! integer_zerop (op1))
3401                     short_shift = 1;
3402                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3403                     warning ("right shift count >= width of type");
3404                 }
3405             }
3406           /* Convert the shift-count to an integer, regardless of
3407              size of value being shifted.  */
3408           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3409             op1 = cp_convert (integer_type_node, op1);
3410           /* Avoid converting op1 to result_type later.  */
3411           converted = 1;
3412         }
3413       break;
3414
3415     case LSHIFT_EXPR:
3416       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3417         {
3418           result_type = type0;
3419           if (TREE_CODE (op1) == INTEGER_CST)
3420             {
3421               if (tree_int_cst_lt (op1, integer_zero_node))
3422                 warning ("left shift count is negative");
3423               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3424                 warning ("left shift count >= width of type");
3425             }
3426           /* Convert the shift-count to an integer, regardless of
3427              size of value being shifted.  */
3428           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3429             op1 = cp_convert (integer_type_node, op1);
3430           /* Avoid converting op1 to result_type later.  */
3431           converted = 1;
3432         }
3433       break;
3434
3435     case RROTATE_EXPR:
3436     case LROTATE_EXPR:
3437       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3438         {
3439           result_type = type0;
3440           if (TREE_CODE (op1) == INTEGER_CST)
3441             {
3442               if (tree_int_cst_lt (op1, integer_zero_node))
3443                 warning ("%s rotate count is negative",
3444                          (code == LROTATE_EXPR) ? "left" : "right");
3445               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3446                 warning ("%s rotate count >= width of type",
3447                          (code == LROTATE_EXPR) ? "left" : "right");
3448             }
3449           /* Convert the shift-count to an integer, regardless of
3450              size of value being shifted.  */
3451           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3452             op1 = cp_convert (integer_type_node, op1);
3453         }
3454       break;
3455
3456     case EQ_EXPR:
3457     case NE_EXPR:
3458       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3459         warning ("comparing floating point with == or != is unsafe");
3460
3461       build_type = boolean_type_node;
3462       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3463            || code0 == COMPLEX_TYPE)
3464           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3465               || code1 == COMPLEX_TYPE))
3466         short_compare = 1;
3467       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3468         result_type = composite_pointer_type (type0, type1, op0, op1,
3469                                               "comparison");
3470       else if (code0 == POINTER_TYPE && null_ptr_cst_p (op1))
3471         result_type = type0;
3472       else if (code1 == POINTER_TYPE && null_ptr_cst_p (op0))
3473         result_type = type1;
3474       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3475         {
3476           result_type = type0;
3477           error ("ISO C++ forbids comparison between pointer and integer");
3478         }
3479       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3480         {
3481           result_type = type1;
3482           error ("ISO C++ forbids comparison between pointer and integer");
3483         }
3484       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3485         {
3486           op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3487           op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3488           result_type = TREE_TYPE (op0);
3489         }
3490       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3491         return cp_build_binary_op (code, op1, op0);
3492       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3493                && same_type_p (type0, type1))
3494         {
3495           /* E will be the final comparison.  */
3496           tree e;
3497           /* E1 and E2 are for scratch.  */
3498           tree e1;
3499           tree e2;
3500           tree pfn0;
3501           tree pfn1;
3502           tree delta0;
3503           tree delta1;
3504
3505           if (TREE_SIDE_EFFECTS (op0))
3506             op0 = save_expr (op0);
3507           if (TREE_SIDE_EFFECTS (op1))
3508             op1 = save_expr (op1);
3509
3510           /* We generate:
3511
3512              (op0.pfn == op1.pfn
3513               && (!op0.pfn || op0.delta == op1.delta))
3514
3515              The reason for the `!op0.pfn' bit is that a NULL
3516              pointer-to-member is any member with a zero PFN; the
3517              DELTA field is unspecified.  */
3518           pfn0 = pfn_from_ptrmemfunc (op0);
3519           pfn1 = pfn_from_ptrmemfunc (op1);
3520           delta0 = build_ptrmemfunc_access_expr (op0,
3521                                                  delta_identifier);
3522           delta1 = build_ptrmemfunc_access_expr (op1,
3523                                                  delta_identifier);
3524           e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3525           e2 = cp_build_binary_op (EQ_EXPR,
3526                                    pfn0,
3527                                    cp_convert (TREE_TYPE (pfn0),
3528                                                integer_zero_node));
3529           e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3530           e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3531           e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3532           if (code == EQ_EXPR)
3533             return e;
3534           return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3535         }
3536       else if ((TYPE_PTRMEMFUNC_P (type0)
3537                 && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
3538                || (TYPE_PTRMEMFUNC_P (type1)
3539                    && same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), type0)))
3540         abort ();
3541       break;
3542
3543     case MAX_EXPR:
3544     case MIN_EXPR:
3545       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3546            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3547         shorten = 1;
3548       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3549         result_type = composite_pointer_type (type0, type1, op0, op1,
3550                                               "comparison");
3551       break;
3552
3553     case LE_EXPR:
3554     case GE_EXPR:
3555     case LT_EXPR:
3556     case GT_EXPR:
3557       build_type = boolean_type_node;
3558       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3559            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3560         short_compare = 1;
3561       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3562         result_type = composite_pointer_type (type0, type1, op0, op1,
3563                                               "comparison");
3564       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3565                && integer_zerop (op1))
3566         result_type = type0;
3567       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3568                && integer_zerop (op0))
3569         result_type = type1;
3570       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3571         {
3572           result_type = type0;
3573           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3574         }
3575       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3576         {
3577           result_type = type1;
3578           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3579         }
3580       break;
3581
3582     case UNORDERED_EXPR:
3583     case ORDERED_EXPR:
3584     case UNLT_EXPR:
3585     case UNLE_EXPR:
3586     case UNGT_EXPR:
3587     case UNGE_EXPR:
3588     case UNEQ_EXPR:
3589       build_type = integer_type_node;
3590       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3591         {
3592           error ("unordered comparison on non-floating point argument");
3593           return error_mark_node;
3594         }
3595       common = 1;
3596       break;
3597
3598     default:
3599       break;
3600     }
3601
3602   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3603       &&
3604       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
3605     {
3606       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3607
3608       if (shorten || common || short_compare)
3609         result_type = common_type (type0, type1);
3610
3611       /* For certain operations (which identify themselves by shorten != 0)
3612          if both args were extended from the same smaller type,
3613          do the arithmetic in that type and then extend.
3614
3615          shorten !=0 and !=1 indicates a bitwise operation.
3616          For them, this optimization is safe only if
3617          both args are zero-extended or both are sign-extended.
3618          Otherwise, we might change the result.
3619          Eg, (short)-1 | (unsigned short)-1 is (int)-1
3620          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3621
3622       if (shorten && none_complex)
3623         {
3624           int unsigned0, unsigned1;
3625           tree arg0 = get_narrower (op0, &unsigned0);
3626           tree arg1 = get_narrower (op1, &unsigned1);
3627           /* UNS is 1 if the operation to be done is an unsigned one.  */
3628           int uns = TREE_UNSIGNED (result_type);
3629           tree type;
3630
3631           final_type = result_type;
3632
3633           /* Handle the case that OP0 does not *contain* a conversion
3634              but it *requires* conversion to FINAL_TYPE.  */
3635
3636           if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3637             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
3638           if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3639             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
3640
3641           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
3642
3643           /* For bitwise operations, signedness of nominal type
3644              does not matter.  Consider only how operands were extended.  */
3645           if (shorten == -1)
3646             uns = unsigned0;
3647
3648           /* Note that in all three cases below we refrain from optimizing
3649              an unsigned operation on sign-extended args.
3650              That would not be valid.  */
3651
3652           /* Both args variable: if both extended in same way
3653              from same width, do it in that width.
3654              Do it unsigned if args were zero-extended.  */
3655           if ((TYPE_PRECISION (TREE_TYPE (arg0))
3656                < TYPE_PRECISION (result_type))
3657               && (TYPE_PRECISION (TREE_TYPE (arg1))
3658                   == TYPE_PRECISION (TREE_TYPE (arg0)))
3659               && unsigned0 == unsigned1
3660               && (unsigned0 || !uns))
3661             result_type = c_common_signed_or_unsigned_type
3662               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3663           else if (TREE_CODE (arg0) == INTEGER_CST
3664                    && (unsigned1 || !uns)
3665                    && (TYPE_PRECISION (TREE_TYPE (arg1))
3666                        < TYPE_PRECISION (result_type))
3667                    && (type = c_common_signed_or_unsigned_type
3668                        (unsigned1, TREE_TYPE (arg1)),
3669                        int_fits_type_p (arg0, type)))
3670             result_type = type;
3671           else if (TREE_CODE (arg1) == INTEGER_CST
3672                    && (unsigned0 || !uns)
3673                    && (TYPE_PRECISION (TREE_TYPE (arg0))
3674                        < TYPE_PRECISION (result_type))
3675                    && (type = c_common_signed_or_unsigned_type
3676                        (unsigned0, TREE_TYPE (arg0)),
3677                        int_fits_type_p (arg1, type)))
3678             result_type = type;
3679         }
3680
3681       /* Shifts can be shortened if shifting right.  */
3682
3683       if (short_shift)
3684         {
3685           int unsigned_arg;
3686           tree arg0 = get_narrower (op0, &unsigned_arg);
3687
3688           final_type = result_type;
3689
3690           if (arg0 == op0 && final_type == TREE_TYPE (op0))
3691             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
3692
3693           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3694               /* We can shorten only if the shift count is less than the
3695                  number of bits in the smaller type size.  */
3696               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3697               /* If arg is sign-extended and then unsigned-shifted,
3698                  we can simulate this with a signed shift in arg's type
3699                  only if the extended result is at least twice as wide
3700                  as the arg.  Otherwise, the shift could use up all the
3701                  ones made by sign-extension and bring in zeros.
3702                  We can't optimize that case at all, but in most machines
3703                  it never happens because available widths are 2**N.  */
3704               && (!TREE_UNSIGNED (final_type)
3705                   || unsigned_arg
3706                   || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3707                       <= TYPE_PRECISION (result_type))))
3708             {
3709               /* Do an unsigned shift if the operand was zero-extended.  */
3710               result_type
3711                 = c_common_signed_or_unsigned_type (unsigned_arg,
3712                                                     TREE_TYPE (arg0));
3713               /* Convert value-to-be-shifted to that type.  */
3714               if (TREE_TYPE (op0) != result_type)
3715                 op0 = cp_convert (result_type, op0);
3716               converted = 1;
3717             }
3718         }
3719
3720       /* Comparison operations are shortened too but differently.
3721          They identify themselves by setting short_compare = 1.  */
3722
3723       if (short_compare)
3724         {
3725           /* Don't write &op0, etc., because that would prevent op0
3726              from being kept in a register.
3727              Instead, make copies of the our local variables and
3728              pass the copies by reference, then copy them back afterward.  */
3729           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3730           enum tree_code xresultcode = resultcode;
3731           tree val
3732             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3733           if (val != 0)
3734             return cp_convert (boolean_type_node, val);
3735           op0 = xop0, op1 = xop1;
3736           converted = 1;
3737           resultcode = xresultcode;
3738         }
3739
3740       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3741           && warn_sign_compare)
3742         {
3743           int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
3744           int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
3745
3746           int unsignedp0, unsignedp1;
3747           tree primop0 = get_narrower (op0, &unsignedp0);
3748           tree primop1 = get_narrower (op1, &unsignedp1);
3749
3750           /* Check for comparison of different enum types.  */
3751           if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3752               && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3753               && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3754                  != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3755             {
3756               warning ("comparison between types `%#T' and `%#T'",
3757                           TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3758             }
3759
3760           /* Give warnings for comparisons between signed and unsigned
3761              quantities that may fail.  */
3762           /* Do the checking based on the original operand trees, so that
3763              casts will be considered, but default promotions won't be.  */
3764
3765           /* Do not warn if the comparison is being done in a signed type,
3766              since the signed type will only be chosen if it can represent
3767              all the values of the unsigned type.  */
3768           if (! TREE_UNSIGNED (result_type))
3769             /* OK */;
3770           /* Do not warn if both operands are unsigned.  */
3771           else if (op0_signed == op1_signed)
3772             /* OK */;
3773           /* Do not warn if the signed quantity is an unsuffixed
3774              integer literal (or some static constant expression
3775              involving such literals or a conditional expression
3776              involving such literals) and it is non-negative.  */
3777           else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3778                    || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3779             /* OK */;
3780           /* Do not warn if the comparison is an equality operation,
3781              the unsigned quantity is an integral constant and it does
3782              not use the most significant bit of result_type.  */
3783           else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3784                    && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3785                         && int_fits_type_p (orig_op1, c_common_signed_type
3786                                             (result_type)))
3787                         || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3788                             && int_fits_type_p (orig_op0, c_common_signed_type
3789                                                 (result_type)))))
3790             /* OK */;
3791           else
3792             warning ("comparison between signed and unsigned integer expressions");
3793
3794           /* Warn if two unsigned values are being compared in a size
3795              larger than their original size, and one (and only one) is the
3796              result of a `~' operator.  This comparison will always fail.
3797
3798              Also warn if one operand is a constant, and the constant does not
3799              have all bits set that are set in the ~ operand when it is
3800              extended.  */
3801
3802           if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3803               ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3804             {
3805               if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3806                 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3807               if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3808                 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3809
3810               if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3811                 {
3812                   tree primop;
3813                   HOST_WIDE_INT constant, mask;
3814                   int unsignedp;
3815                   unsigned int bits;
3816
3817                   if (host_integerp (primop0, 0))
3818                     {
3819                       primop = primop1;
3820                       unsignedp = unsignedp1;
3821                       constant = tree_low_cst (primop0, 0);
3822                     }
3823                   else
3824                     {
3825                       primop = primop0;
3826                       unsignedp = unsignedp0;
3827                       constant = tree_low_cst (primop1, 0);
3828                     }
3829
3830                   bits = TYPE_PRECISION (TREE_TYPE (primop));
3831                   if (bits < TYPE_PRECISION (result_type)
3832                       && bits < HOST_BITS_PER_LONG && unsignedp)
3833                     {
3834                       mask = (~ (HOST_WIDE_INT) 0) << bits;
3835                       if ((mask & constant) != mask)
3836                         warning ("comparison of promoted ~unsigned with constant");
3837                     }
3838                 }
3839               else if (unsignedp0 && unsignedp1
3840                        && (TYPE_PRECISION (TREE_TYPE (primop0))
3841                            < TYPE_PRECISION (result_type))
3842                        && (TYPE_PRECISION (TREE_TYPE (primop1))
3843                            < TYPE_PRECISION (result_type)))
3844                 warning ("comparison of promoted ~unsigned with unsigned");
3845             }
3846         }
3847     }
3848
3849   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
3850      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3851      Then the expression will be built.
3852      It will be given type FINAL_TYPE if that is nonzero;
3853      otherwise, it will be given type RESULT_TYPE.  */
3854
3855   if (!result_type)
3856     {
3857       error ("invalid operands of types `%T' and `%T' to binary `%O'",
3858                 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3859       return error_mark_node;
3860     }
3861
3862   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3863   if (/* It's reasonable to use pointer values as operands of &&
3864          and ||, so NULL is no exception.  */
3865       !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3866       && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
3867           (orig_op0 == null_node
3868            && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3869           /* Or vice versa.  */
3870           || (orig_op1 == null_node
3871               && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3872           /* Or, both are NULL and the operation was not a comparison.  */
3873           || (orig_op0 == null_node && orig_op1 == null_node
3874               && code != EQ_EXPR && code != NE_EXPR)))
3875     /* Some sort of arithmetic operation involving NULL was
3876        performed.  Note that pointer-difference and pointer-addition
3877        have already been handled above, and so we don't end up here in
3878        that case.  */
3879     warning ("NULL used in arithmetic");
3880
3881   if (! converted)
3882     {
3883       if (TREE_TYPE (op0) != result_type)
3884         op0 = cp_convert (result_type, op0);
3885       if (TREE_TYPE (op1) != result_type)
3886         op1 = cp_convert (result_type, op1);
3887
3888       if (op0 == error_mark_node || op1 == error_mark_node)
3889         return error_mark_node;
3890     }
3891
3892   if (build_type == NULL_TREE)
3893     build_type = result_type;
3894
3895   {
3896     register tree result = build (resultcode, build_type, op0, op1);
3897     register tree folded;
3898
3899     folded = fold (result);
3900     if (folded == result)
3901       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3902     if (final_type != 0)
3903       return cp_convert (final_type, folded);
3904     return folded;
3905   }
3906 }
3907 \f
3908 /* Return a tree for the sum or difference (RESULTCODE says which)
3909    of pointer PTROP and integer INTOP.  */
3910
3911 static tree
3912 cp_pointer_int_sum (resultcode, ptrop, intop)
3913      enum tree_code resultcode;
3914      register tree ptrop, intop;
3915 {
3916   tree res_type = TREE_TYPE (ptrop);
3917
3918   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3919      in certain circumstance (when it's valid to do so).  So we need
3920      to make sure it's complete.  We don't need to check here, if we
3921      can actually complete it at all, as those checks will be done in
3922      pointer_int_sum() anyway.  */
3923   complete_type (TREE_TYPE (res_type));
3924
3925   return pointer_int_sum (resultcode, ptrop, fold (intop));
3926 }
3927
3928 /* Return a tree for the difference of pointers OP0 and OP1.
3929    The resulting tree has type int.  */
3930
3931 static tree
3932 pointer_diff (op0, op1, ptrtype)
3933      register tree op0, op1;
3934      register tree ptrtype;
3935 {
3936   register tree result, folded;
3937   tree restype = ptrdiff_type_node;
3938   tree target_type = TREE_TYPE (ptrtype);
3939
3940   if (!complete_type_or_else (target_type, NULL_TREE))
3941     return error_mark_node;
3942
3943   if (pedantic || warn_pointer_arith)
3944     {
3945       if (TREE_CODE (target_type) == VOID_TYPE)
3946         pedwarn ("ISO C++ forbids using pointer of type `void *' in subtraction");
3947       if (TREE_CODE (target_type) == FUNCTION_TYPE)
3948         pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3949       if (TREE_CODE (target_type) == METHOD_TYPE)
3950         pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3951       if (TREE_CODE (target_type) == OFFSET_TYPE)
3952         pedwarn ("ISO C++ forbids using pointer to a member in subtraction");
3953     }
3954
3955   /* First do the subtraction as integers;
3956      then drop through to build the divide operator.  */
3957
3958   op0 = cp_build_binary_op (MINUS_EXPR,
3959                             cp_convert (restype, op0),
3960                             cp_convert (restype, op1));
3961
3962   /* This generates an error if op1 is a pointer to an incomplete type.  */
3963   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3964     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3965
3966   op1 = ((TREE_CODE (target_type) == VOID_TYPE
3967           || TREE_CODE (target_type) == FUNCTION_TYPE
3968           || TREE_CODE (target_type) == METHOD_TYPE
3969           || TREE_CODE (target_type) == OFFSET_TYPE)
3970          ? integer_one_node
3971          : size_in_bytes (target_type));
3972
3973   /* Do the division.  */
3974
3975   result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3976
3977   folded = fold (result);
3978   if (folded == result)
3979     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
3980   return folded;
3981 }
3982 \f
3983 /* Construct and perhaps optimize a tree representation
3984    for a unary operation.  CODE, a tree_code, specifies the operation
3985    and XARG is the operand.  */
3986
3987 tree
3988 build_x_unary_op (code, xarg)
3989      enum tree_code code;
3990      tree xarg;
3991 {
3992   tree exp;
3993   int ptrmem = 0;
3994
3995   if (processing_template_decl)
3996     return build_min_nt (code, xarg, NULL_TREE);
3997
3998   /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
3999      error message.  */
4000   if (code == ADDR_EXPR
4001       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4002       && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg)))
4003            && !COMPLETE_TYPE_P (TREE_TYPE (xarg)))
4004           || (TREE_CODE (xarg) == OFFSET_REF)))
4005     /* don't look for a function */;
4006   else
4007     {
4008       tree rval;
4009
4010       rval = build_new_op (code, LOOKUP_NORMAL, xarg,
4011                            NULL_TREE, NULL_TREE);
4012       if (rval || code != ADDR_EXPR)
4013         return rval;
4014     }
4015   if (code == ADDR_EXPR)
4016     {
4017       /*  A pointer to member-function can be formed only by saying
4018           &X::mf.  */
4019       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4020           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4021         {
4022           if (TREE_CODE (xarg) != OFFSET_REF)
4023             {
4024               error ("invalid use of '%E' to form a pointer-to-member-function.  Use a qualified-id.",
4025                      xarg);
4026               return error_mark_node;
4027             }
4028           else
4029             {
4030               error ("parenthesis around '%E' cannot be used to form a pointer-to-member-function",
4031                      xarg);
4032               PTRMEM_OK_P (xarg) = 1;
4033             }
4034         }
4035
4036       if (TREE_CODE (xarg) == OFFSET_REF)
4037         {
4038           ptrmem = PTRMEM_OK_P (xarg);
4039
4040           if (!ptrmem && !flag_ms_extensions
4041               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4042             {
4043               /* A single non-static member, make sure we don't allow a
4044                  pointer-to-member.  */
4045               xarg = build (OFFSET_REF, TREE_TYPE (xarg),
4046                             TREE_OPERAND (xarg, 0),
4047                             ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4048               PTRMEM_OK_P (xarg) = ptrmem;
4049             }
4050
4051         }
4052       else if (TREE_CODE (xarg) == TARGET_EXPR)
4053         warning ("taking address of temporary");
4054     }
4055   exp = build_unary_op (code, xarg, 0);
4056   if (TREE_CODE (exp) == ADDR_EXPR)
4057     PTRMEM_OK_P (exp) = ptrmem;
4058
4059   return exp;
4060 }
4061
4062 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4063    constants, where a null value is represented by an INTEGER_CST of
4064    -1.  */
4065
4066 tree
4067 cp_truthvalue_conversion (expr)
4068      tree expr;
4069 {
4070   tree type = TREE_TYPE (expr);
4071   if (TYPE_PTRMEM_P (type))
4072     return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
4073   else
4074     return c_common_truthvalue_conversion (expr);
4075 }
4076
4077 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
4078
4079 tree
4080 condition_conversion (expr)
4081      tree expr;
4082 {
4083   tree t;
4084   if (processing_template_decl)
4085     return expr;
4086   if (TREE_CODE (expr) == OFFSET_REF)
4087     expr = resolve_offset_ref (expr);
4088   t = perform_implicit_conversion (boolean_type_node, expr);
4089   t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
4090   return t;
4091 }
4092
4093 /* C++: Must handle pointers to members.
4094
4095    Perhaps type instantiation should be extended to handle conversion
4096    from aggregates to types we don't yet know we want?  (Or are those
4097    cases typically errors which should be reported?)
4098
4099    NOCONVERT nonzero suppresses the default promotions
4100    (such as from short to int).  */
4101
4102 tree
4103 build_unary_op (code, xarg, noconvert)
4104      enum tree_code code;
4105      tree xarg;
4106      int noconvert;
4107 {
4108   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
4109   register tree arg = xarg;
4110   register tree argtype = 0;
4111   const char *errstring = NULL;
4112   tree val;
4113
4114   if (arg == error_mark_node)
4115     return error_mark_node;
4116
4117   switch (code)
4118     {
4119     case CONVERT_EXPR:
4120       /* This is used for unary plus, because a CONVERT_EXPR
4121          is enough to prevent anybody from looking inside for
4122          associativity, but won't generate any code.  */
4123       if (!(arg = build_expr_type_conversion
4124             (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, true)))
4125         errstring = "wrong type argument to unary plus";
4126       else
4127         {
4128           if (!noconvert)
4129            arg = default_conversion (arg);
4130           arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
4131           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4132         }
4133       break;
4134
4135     case NEGATE_EXPR:
4136       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4137         errstring = "wrong type argument to unary minus";
4138       else if (!noconvert)
4139         arg = default_conversion (arg);
4140       break;
4141
4142     case BIT_NOT_EXPR:
4143       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4144         {
4145           code = CONJ_EXPR;
4146           if (!noconvert)
4147             arg = default_conversion (arg);
4148         }
4149       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
4150                                                    arg, true)))
4151         errstring = "wrong type argument to bit-complement";
4152       else if (!noconvert)
4153         arg = default_conversion (arg);
4154       break;
4155
4156     case ABS_EXPR:
4157       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4158         errstring = "wrong type argument to abs";
4159       else if (!noconvert)
4160         arg = default_conversion (arg);
4161       break;
4162
4163     case CONJ_EXPR:
4164       /* Conjugating a real value is a no-op, but allow it anyway.  */
4165       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4166         errstring = "wrong type argument to conjugation";
4167       else if (!noconvert)
4168         arg = default_conversion (arg);
4169       break;
4170
4171     case TRUTH_NOT_EXPR:
4172       arg = cp_convert (boolean_type_node, arg);
4173       val = invert_truthvalue (arg);
4174       if (arg != error_mark_node)
4175         return val;
4176       errstring = "in argument to unary !";
4177       break;
4178
4179     case NOP_EXPR:
4180       break;
4181
4182     case REALPART_EXPR:
4183       if (TREE_CODE (arg) == COMPLEX_CST)
4184         return TREE_REALPART (arg);
4185       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4186         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
4187       else
4188         return arg;
4189
4190     case IMAGPART_EXPR:
4191       if (TREE_CODE (arg) == COMPLEX_CST)
4192         return TREE_IMAGPART (arg);
4193       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4194         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
4195       else
4196         return cp_convert (TREE_TYPE (arg), integer_zero_node);
4197
4198     case PREINCREMENT_EXPR:
4199     case POSTINCREMENT_EXPR:
4200     case PREDECREMENT_EXPR:
4201     case POSTDECREMENT_EXPR:
4202       /* Handle complex lvalues (when permitted)
4203          by reduction to simpler cases.  */
4204
4205       val = unary_complex_lvalue (code, arg);
4206       if (val != 0)
4207         return val;
4208
4209       /* Increment or decrement the real part of the value,
4210          and don't change the imaginary part.  */
4211       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4212         {
4213           tree real, imag;
4214
4215           arg = stabilize_reference (arg);
4216           real = build_unary_op (REALPART_EXPR, arg, 1);
4217           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
4218           return build (COMPLEX_EXPR, TREE_TYPE (arg),
4219                         build_unary_op (code, real, 1), imag);
4220         }
4221
4222       /* Report invalid types.  */
4223
4224       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4225                                               arg, true)))
4226         {
4227           if (code == PREINCREMENT_EXPR)
4228             errstring ="no pre-increment operator for type";
4229           else if (code == POSTINCREMENT_EXPR)
4230             errstring ="no post-increment operator for type";
4231           else if (code == PREDECREMENT_EXPR)
4232             errstring ="no pre-decrement operator for type";
4233           else
4234             errstring ="no post-decrement operator for type";
4235           break;
4236         }
4237
4238       /* Report something read-only.  */
4239
4240       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4241           || TREE_READONLY (arg))
4242         readonly_error (arg, ((code == PREINCREMENT_EXPR
4243                                || code == POSTINCREMENT_EXPR)
4244                               ? "increment" : "decrement"),
4245                         0);
4246
4247       {
4248         register tree inc;
4249         tree result_type = TREE_TYPE (arg);
4250
4251         arg = get_unwidened (arg, 0);
4252         argtype = TREE_TYPE (arg);
4253
4254         /* ARM $5.2.5 last annotation says this should be forbidden.  */
4255         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4256           pedwarn ("ISO C++ forbids %sing an enum",
4257                    (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4258                    ? "increment" : "decrement");
4259
4260         /* Compute the increment.  */
4261
4262         if (TREE_CODE (argtype) == POINTER_TYPE)
4263           {
4264             enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype));
4265             tree type = complete_type (TREE_TYPE (argtype));
4266
4267             if (!COMPLETE_OR_VOID_TYPE_P (type))
4268               error ("cannot %s a pointer to incomplete type `%T'",
4269                         ((code == PREINCREMENT_EXPR
4270                           || code == POSTINCREMENT_EXPR)
4271                          ? "increment" : "decrement"), TREE_TYPE (argtype));
4272             else if ((pedantic || warn_pointer_arith)
4273                      && (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE
4274                          || tmp == VOID_TYPE || tmp == OFFSET_TYPE))
4275               pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
4276                           ((code == PREINCREMENT_EXPR
4277                             || code == POSTINCREMENT_EXPR)
4278                            ? "increment" : "decrement"), argtype);
4279             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4280           }
4281         else
4282           inc = integer_one_node;
4283
4284         inc = cp_convert (argtype, inc);
4285
4286         /* Handle incrementing a cast-expression.  */
4287
4288         switch (TREE_CODE (arg))
4289           {
4290           case NOP_EXPR:
4291           case CONVERT_EXPR:
4292           case FLOAT_EXPR:
4293           case FIX_TRUNC_EXPR:
4294           case FIX_FLOOR_EXPR:
4295           case FIX_ROUND_EXPR:
4296           case FIX_CEIL_EXPR:
4297             {
4298               tree incremented, modify, value, compound;
4299               if (! lvalue_p (arg) && pedantic)
4300                 pedwarn ("cast to non-reference type used as lvalue");
4301               arg = stabilize_reference (arg);
4302               if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
4303                 value = arg;
4304               else
4305                 value = save_expr (arg);
4306               incremented = build (((code == PREINCREMENT_EXPR
4307                                      || code == POSTINCREMENT_EXPR)
4308                                     ? PLUS_EXPR : MINUS_EXPR),
4309                                    argtype, value, inc);
4310
4311               modify = build_modify_expr (arg, NOP_EXPR, incremented);
4312               compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
4313
4314               /* Eliminate warning about unused result of + or -.  */
4315               TREE_NO_UNUSED_WARNING (compound) = 1;
4316               return compound;
4317             }
4318
4319           default:
4320             break;
4321           }
4322
4323         /* Complain about anything else that is not a true lvalue.  */
4324         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4325                                     || code == POSTINCREMENT_EXPR)
4326                                    ? "increment" : "decrement")))
4327           return error_mark_node;
4328
4329         /* Forbid using -- on `bool'.  */
4330         if (TREE_TYPE (arg) == boolean_type_node)
4331           {
4332             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4333               {
4334                 error ("invalid use of `--' on bool variable `%D'", arg);
4335                 return error_mark_node;
4336               }
4337 #if 0
4338             /* This will only work if someone can convince Kenner to accept
4339                my patch to expand_increment. (jason)  */
4340             val = build (code, TREE_TYPE (arg), arg, inc);
4341 #else
4342             val = boolean_increment (code, arg);
4343 #endif
4344           }
4345         else
4346           val = build (code, TREE_TYPE (arg), arg, inc);
4347
4348         TREE_SIDE_EFFECTS (val) = 1;
4349         return cp_convert (result_type, val);
4350       }
4351
4352     case ADDR_EXPR:
4353       /* Note that this operation never does default_conversion
4354          regardless of NOCONVERT.  */
4355
4356       argtype = lvalue_type (arg);
4357       if (TREE_CODE (argtype) == REFERENCE_TYPE)
4358         {
4359           arg = build1
4360             (CONVERT_EXPR,
4361              build_pointer_type (TREE_TYPE (argtype)), arg);
4362           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4363           return arg;
4364         }
4365       else if (pedantic && DECL_MAIN_P (arg))
4366         /* ARM $3.4 */
4367         pedwarn ("ISO C++ forbids taking address of function `::main'");
4368
4369       /* Let &* cancel out to simplify resulting code.  */
4370       if (TREE_CODE (arg) == INDIRECT_REF)
4371         {
4372           /* We don't need to have `current_class_ptr' wrapped in a
4373              NON_LVALUE_EXPR node.  */
4374           if (arg == current_class_ref)
4375             return current_class_ptr;
4376
4377           arg = TREE_OPERAND (arg, 0);
4378           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4379             {
4380               arg = build1
4381                 (CONVERT_EXPR,
4382                  build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
4383               TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
4384             }
4385           else if (lvalue_p (arg))
4386             /* Don't let this be an lvalue.  */
4387             return non_lvalue (arg);
4388           return arg;
4389         }
4390
4391       /* For &x[y], return x+y */
4392       if (TREE_CODE (arg) == ARRAY_REF)
4393         {
4394           if (!cxx_mark_addressable (TREE_OPERAND (arg, 0)))
4395             return error_mark_node;
4396           return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4397                                      TREE_OPERAND (arg, 1));
4398         }
4399
4400       /* Uninstantiated types are all functions.  Taking the
4401          address of a function is a no-op, so just return the
4402          argument.  */
4403
4404       if (TREE_CODE (arg) == IDENTIFIER_NODE
4405           && IDENTIFIER_OPNAME_P (arg))
4406         {
4407           abort ();
4408           /* We don't know the type yet, so just work around the problem.
4409              We know that this will resolve to an lvalue.  */
4410           return build1 (ADDR_EXPR, unknown_type_node, arg);
4411         }
4412
4413       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4414           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4415         {
4416           /* They're trying to take the address of a unique non-static
4417              member function.  This is ill-formed (except in MS-land),
4418              but let's try to DTRT.
4419              Note: We only handle unique functions here because we don't
4420              want to complain if there's a static overload; non-unique
4421              cases will be handled by instantiate_type.  But we need to
4422              handle this case here to allow casts on the resulting PMF.
4423              We could defer this in non-MS mode, but it's easier to give
4424              a useful error here.  */
4425
4426           tree base = TREE_TYPE (TREE_OPERAND (arg, 0));
4427           tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4428
4429           if (! flag_ms_extensions)
4430             {
4431               if (current_class_type
4432                   && TREE_OPERAND (arg, 0) == current_class_ref)
4433                 /* An expression like &memfn.  */
4434                 pedwarn ("ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say `&%T::%D'", base, name);
4435               else
4436                 pedwarn ("ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'", base, name);
4437             }
4438           arg = build_offset_ref (base, name);
4439         }
4440
4441       if (type_unknown_p (arg))
4442         return build1 (ADDR_EXPR, unknown_type_node, arg);
4443
4444       /* Handle complex lvalues (when permitted)
4445          by reduction to simpler cases.  */
4446       val = unary_complex_lvalue (code, arg);
4447       if (val != 0)
4448         return val;
4449
4450       switch (TREE_CODE (arg))
4451         {
4452         case NOP_EXPR:
4453         case CONVERT_EXPR:
4454         case FLOAT_EXPR:
4455         case FIX_TRUNC_EXPR:
4456         case FIX_FLOOR_EXPR:
4457         case FIX_ROUND_EXPR:
4458         case FIX_CEIL_EXPR:
4459           if (! lvalue_p (arg) && pedantic)
4460             pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4461           break;
4462
4463         default:
4464           break;
4465         }
4466
4467       /* Allow the address of a constructor if all the elements
4468          are constant.  */
4469       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4470           && TREE_CONSTANT (arg))
4471         ;
4472       /* Anything not already handled and not a true memory reference
4473          is an error.  */
4474       else if (TREE_CODE (argtype) != FUNCTION_TYPE
4475                && TREE_CODE (argtype) != METHOD_TYPE
4476                && !non_cast_lvalue_or_else (arg, "unary `&'"))
4477         return error_mark_node;
4478
4479       if (argtype != error_mark_node)
4480         argtype = build_pointer_type (argtype);
4481
4482       if (!cxx_mark_addressable (arg))
4483         return error_mark_node;
4484
4485       {
4486         tree addr;
4487
4488         if (TREE_CODE (arg) == COMPONENT_REF
4489             && TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4490           arg = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4491
4492         if (TREE_CODE (arg) == COMPONENT_REF
4493             && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4494           {
4495             error ("attempt to take address of bit-field structure member `%D'",
4496                    TREE_OPERAND (arg, 1));
4497             return error_mark_node;
4498           }
4499         else if (TREE_CODE (arg) == COMPONENT_REF
4500                  && TREE_CODE (TREE_OPERAND (arg, 0)) == INDIRECT_REF
4501                  && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg, 0), 0))
4502                      == INTEGER_CST))
4503           {
4504             /* offsetof idiom, fold it.  */
4505             tree field = TREE_OPERAND (arg, 1);
4506             tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4507             tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
4508                                       decl_type_context (field),
4509                                       ba_check, NULL);
4510
4511             rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
4512             rval = build1 (NOP_EXPR, argtype, rval);
4513             TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0));
4514             addr = fold (build (PLUS_EXPR, argtype, rval,
4515                                 cp_convert (argtype, byte_position (field))));
4516           }
4517         else
4518           addr = build1 (ADDR_EXPR, argtype, arg);
4519
4520         /* Address of a static or external variable or
4521            function counts as a constant */
4522         if (staticp (arg))
4523           TREE_CONSTANT (addr) = 1;
4524
4525         if (TREE_CODE (argtype) == POINTER_TYPE
4526             && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4527           {
4528             build_ptrmemfunc_type (argtype);
4529             addr = build_ptrmemfunc (argtype, addr, 0);
4530           }
4531
4532         return addr;
4533       }
4534
4535     default:
4536       break;
4537     }
4538
4539   if (!errstring)
4540     {
4541       if (argtype == 0)
4542         argtype = TREE_TYPE (arg);
4543       return fold (build1 (code, argtype, arg));
4544     }
4545
4546   error ("%s", errstring);
4547   return error_mark_node;
4548 }
4549
4550 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4551    for certain kinds of expressions which are not really lvalues
4552    but which we can accept as lvalues.
4553
4554    If ARG is not a kind of expression we can handle, return zero.  */
4555
4556 tree
4557 unary_complex_lvalue (code, arg)
4558      enum tree_code code;
4559      tree arg;
4560 {
4561   /* Handle (a, b) used as an "lvalue".  */
4562   if (TREE_CODE (arg) == COMPOUND_EXPR)
4563     {
4564       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4565       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4566                     TREE_OPERAND (arg, 0), real_result);
4567     }
4568
4569   /* Handle (a ? b : c) used as an "lvalue".  */
4570   if (TREE_CODE (arg) == COND_EXPR
4571       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4572     return rationalize_conditional_expr (code, arg);
4573
4574   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4575   if (TREE_CODE (arg) == MODIFY_EXPR
4576       || TREE_CODE (arg) == PREINCREMENT_EXPR
4577       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4578     {
4579       tree lvalue = TREE_OPERAND (arg, 0);
4580       if (TREE_SIDE_EFFECTS (lvalue))
4581         {
4582           lvalue = stabilize_reference (lvalue);
4583           arg = build (TREE_CODE (arg), TREE_TYPE (arg),
4584                        lvalue, TREE_OPERAND (arg, 1));
4585         }
4586       return unary_complex_lvalue
4587         (code, build (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4588     }
4589
4590   if (code != ADDR_EXPR)
4591     return 0;
4592
4593   /* Handle (a = b) used as an "lvalue" for `&'.  */
4594   if (TREE_CODE (arg) == MODIFY_EXPR
4595       || TREE_CODE (arg) == INIT_EXPR)
4596     {
4597       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4598       arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4599       TREE_NO_UNUSED_WARNING (arg) = 1;
4600       return arg;
4601     }
4602
4603   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4604       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4605       || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
4606     {
4607       /* The representation of something of type OFFSET_TYPE
4608          is really the representation of a pointer to it.
4609          Here give the representation its true type.  */
4610       tree t;
4611
4612       my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4613
4614       if (TREE_CODE (arg) != OFFSET_REF)
4615         return 0;
4616
4617       t = TREE_OPERAND (arg, 1);
4618
4619       /* Check all this code for right semantics.  */
4620       if (TREE_CODE (t) == FUNCTION_DECL)
4621         {
4622           if (DECL_DESTRUCTOR_P (t))
4623             error ("taking address of destructor");
4624           return build_unary_op (ADDR_EXPR, t, 0);
4625         }
4626       if (TREE_CODE (t) == VAR_DECL)
4627         return build_unary_op (ADDR_EXPR, t, 0);
4628       else
4629         {
4630           tree type;
4631
4632           if (TREE_OPERAND (arg, 0)
4633               && ! is_dummy_object (TREE_OPERAND (arg, 0))
4634               && TREE_CODE (t) != FIELD_DECL)
4635             {
4636               error ("taking address of bound pointer-to-member expression");
4637               return error_mark_node;
4638             }
4639           if (!PTRMEM_OK_P (arg))
4640             {
4641               /* This cannot form a pointer to method, so we must
4642                  resolve the offset ref, and take the address of the
4643                  result.  For instance,
4644                         &(C::m)       */
4645               arg = resolve_offset_ref (arg);
4646
4647               return build_unary_op (code, arg, 0);
4648             }
4649
4650           if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4651             {
4652               error ("cannot create pointer to reference member `%D'", t);
4653               return error_mark_node;
4654             }
4655
4656           type = build_ptrmem_type (DECL_FIELD_CONTEXT (t), TREE_TYPE (t));
4657           t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4658           return t;
4659         }
4660     }
4661
4662
4663   /* We permit compiler to make function calls returning
4664      objects of aggregate type look like lvalues.  */
4665   {
4666     tree targ = arg;
4667
4668     if (TREE_CODE (targ) == SAVE_EXPR)
4669       targ = TREE_OPERAND (targ, 0);
4670
4671     if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4672       {
4673         if (TREE_CODE (arg) == SAVE_EXPR)
4674           targ = arg;
4675         else
4676           targ = build_cplus_new (TREE_TYPE (arg), arg);
4677         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4678       }
4679
4680     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4681       return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4682                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4683   }
4684
4685   /* Don't let anything else be handled specially.  */
4686   return 0;
4687 }
4688 \f
4689 /* Mark EXP saying that we need to be able to take the
4690    address of it; it should not be allocated in a register.
4691    Value is true if successful.
4692
4693    C++: we do not allow `current_class_ptr' to be addressable.  */
4694
4695 bool
4696 cxx_mark_addressable (exp)
4697      tree exp;
4698 {
4699   register tree x = exp;
4700
4701   while (1)
4702     switch (TREE_CODE (x))
4703       {
4704       case ADDR_EXPR:
4705       case COMPONENT_REF:
4706       case ARRAY_REF:
4707       case REALPART_EXPR:
4708       case IMAGPART_EXPR:
4709         x = TREE_OPERAND (x, 0);
4710         break;
4711
4712       case PARM_DECL:
4713         if (x == current_class_ptr)
4714           {
4715             error ("cannot take the address of `this', which is an rvalue expression");
4716             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */
4717             return true;
4718           }
4719         /* FALLTHRU */
4720
4721       case VAR_DECL:
4722         /* Caller should not be trying to mark initialized
4723            constant fields addressable.  */
4724         my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4725                             || DECL_IN_AGGR_P (x) == 0
4726                             || TREE_STATIC (x)
4727                             || DECL_EXTERNAL (x), 314);
4728         /* FALLTHRU */
4729
4730       case CONST_DECL:
4731       case RESULT_DECL:
4732         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4733             && !DECL_ARTIFICIAL (x) && extra_warnings)
4734           warning ("address requested for `%D', which is declared `register'",
4735                       x);
4736         TREE_ADDRESSABLE (x) = 1;
4737         put_var_into_stack (x);
4738         return true;
4739
4740       case FUNCTION_DECL:
4741         TREE_ADDRESSABLE (x) = 1;
4742         TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4743         return true;
4744
4745       case CONSTRUCTOR:
4746         TREE_ADDRESSABLE (x) = 1;
4747         return true;
4748
4749       case TARGET_EXPR:
4750         TREE_ADDRESSABLE (x) = 1;
4751         cxx_mark_addressable (TREE_OPERAND (x, 0));
4752         return true;
4753
4754       default:
4755         return true;
4756     }
4757 }
4758 \f
4759 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4760
4761 tree
4762 build_x_conditional_expr (ifexp, op1, op2)
4763      tree ifexp, op1, op2;
4764 {
4765   if (processing_template_decl)
4766     return build_min_nt (COND_EXPR, ifexp, op1, op2);
4767
4768   return build_conditional_expr (ifexp, op1, op2);
4769 }
4770 \f
4771 /* Handle overloading of the ',' operator when needed.  Otherwise,
4772    this function just builds an expression list.  */
4773
4774 tree
4775 build_x_compound_expr (list)
4776      tree list;
4777 {
4778   tree rest = TREE_CHAIN (list);
4779   tree result;
4780
4781   if (processing_template_decl)
4782     return build_min_nt (COMPOUND_EXPR, list, NULL_TREE);
4783
4784   if (rest == NULL_TREE)
4785     return build_compound_expr (list);
4786
4787   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL,
4788                          TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
4789   if (result)
4790     return build_x_compound_expr (tree_cons (NULL_TREE, result,
4791                                                   TREE_CHAIN (rest)));
4792
4793   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
4794     {
4795       /* FIXME: This test should be in the implicit cast to void of the LHS.  */
4796       /* the left-hand operand of a comma expression is like an expression
4797          statement: we should warn if it doesn't have any side-effects,
4798          unless it was explicitly cast to (void).  */
4799       if ((extra_warnings || warn_unused_value)
4800            && !(TREE_CODE (TREE_VALUE(list)) == CONVERT_EXPR
4801                 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE(list)))))
4802         warning("left-hand operand of comma expression has no effect");
4803     }
4804 #if 0 /* this requires a gcc backend patch to export warn_if_unused_value */
4805   else if (warn_unused_value)
4806     warn_if_unused_value (TREE_VALUE(list));
4807 #endif
4808
4809   return build_compound_expr
4810     (tree_cons (NULL_TREE, TREE_VALUE (list),
4811                      build_tree_list (NULL_TREE,
4812                                       build_x_compound_expr (rest))));
4813 }
4814
4815 /* Given a list of expressions, return a compound expression
4816    that performs them all and returns the value of the last of them.  */
4817
4818 tree
4819 build_compound_expr (list)
4820      tree list;
4821 {
4822   register tree rest;
4823   tree first;
4824
4825   TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list));
4826
4827   if (TREE_CHAIN (list) == 0)
4828     {
4829       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4830          Strip such NOP_EXPRs, since LIST is used in non-lvalue context.  */
4831       if (TREE_CODE (list) == NOP_EXPR
4832           && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0)))
4833         list = TREE_OPERAND (list, 0);
4834
4835       return TREE_VALUE (list);
4836     }
4837
4838   first = TREE_VALUE (list);
4839   first = convert_to_void (first, "left-hand operand of comma");
4840   if (first == error_mark_node)
4841     return error_mark_node;
4842
4843   rest = build_compound_expr (TREE_CHAIN (list));
4844   if (rest == error_mark_node)
4845     return error_mark_node;
4846
4847   /* When pedantic, a compound expression cannot be a constant expression.  */
4848   if (! TREE_SIDE_EFFECTS (first) && ! pedantic)
4849     return rest;
4850
4851   return build (COMPOUND_EXPR, TREE_TYPE (rest), first, rest);
4852 }
4853
4854 tree
4855 build_static_cast (type, expr)
4856    tree type, expr;
4857 {
4858   tree intype;
4859   int ok;
4860
4861   if (type == error_mark_node || expr == error_mark_node)
4862     return error_mark_node;
4863
4864   if (TREE_CODE (expr) == OFFSET_REF)
4865     expr = resolve_offset_ref (expr);
4866
4867   if (processing_template_decl)
4868     {
4869       tree t = build_min (STATIC_CAST_EXPR, type, expr);
4870       return t;
4871     }
4872
4873   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4874      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4875   if (TREE_CODE (type) != REFERENCE_TYPE
4876       && TREE_CODE (expr) == NOP_EXPR
4877       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4878     expr = TREE_OPERAND (expr, 0);
4879
4880   if (TREE_CODE (type) == VOID_TYPE)
4881     {
4882       expr = convert_to_void (expr, /*implicit=*/NULL);
4883       return expr;
4884     }
4885
4886   if (TREE_CODE (type) == REFERENCE_TYPE)
4887     return (convert_from_reference
4888             (convert_to_reference (type, expr, CONV_STATIC|CONV_IMPLICIT,
4889                                    LOOKUP_COMPLAIN, NULL_TREE)));
4890
4891   if (IS_AGGR_TYPE (type))
4892     return build_cplus_new (type, (build_special_member_call
4893                                    (NULL_TREE, complete_ctor_identifier,
4894                                     build_tree_list (NULL_TREE, expr),
4895                                     TYPE_BINFO (type), LOOKUP_NORMAL)));
4896
4897   intype = TREE_TYPE (expr);
4898
4899   /* FIXME handle casting to array type.  */
4900
4901   ok = 0;
4902   if (IS_AGGR_TYPE (intype)
4903       ? can_convert_arg (type, intype, expr)
4904       : can_convert_arg (strip_all_pointer_quals (type),
4905                          strip_all_pointer_quals (intype), expr))
4906     /* This is a standard conversion.  */
4907     ok = 1;
4908   else if (TYPE_PTROB_P (type) && TYPE_PTROB_P (intype))
4909     {
4910       /* They're pointers to objects. They must be aggregates that
4911          are related non-virtually.  */
4912       base_kind kind;
4913
4914       if (IS_AGGR_TYPE (TREE_TYPE (type)) && IS_AGGR_TYPE (TREE_TYPE (intype))
4915           && lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4916                           ba_ignore | ba_quiet, &kind)
4917           && kind != bk_via_virtual)
4918         ok = 1;
4919     }
4920   else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4921     {
4922       /* They're pointers to members. The pointed to objects must be
4923          the same (ignoring CV qualifiers), and the containing classes
4924          must be related non-virtually.  */
4925       base_kind kind;
4926
4927       if (same_type_p
4928           (strip_all_pointer_quals (TREE_TYPE (TREE_TYPE (type))),
4929            strip_all_pointer_quals (TREE_TYPE (TREE_TYPE (intype))))
4930           && (lookup_base (TYPE_OFFSET_BASETYPE (TREE_TYPE (intype)),
4931                            TYPE_OFFSET_BASETYPE (TREE_TYPE (type)),
4932                            ba_ignore | ba_quiet, &kind))
4933           && kind != bk_via_virtual)
4934         ok = 1;
4935     }
4936   else if (TREE_CODE (intype) != BOOLEAN_TYPE
4937            && TREE_CODE (type) != ARRAY_TYPE
4938            && TREE_CODE (type) != FUNCTION_TYPE
4939            && can_convert (intype, strip_all_pointer_quals (type)))
4940     ok = 1;
4941   else if (TREE_CODE (intype) == ENUMERAL_TYPE
4942            && TREE_CODE (type) == ENUMERAL_TYPE)
4943     /* DR 128: "A value of integral _or enumeration_ type can be explicitly
4944        converted to an enumeration type."
4945        The integral to enumeration will be accepted by the previous clause.
4946        We need to explicitly check for enumeration to enumeration.  */
4947     ok = 1;
4948
4949   /* [expr.static.cast]
4950
4951      The static_cast operator shall not be used to cast away
4952      constness.  */
4953   if (ok && casts_away_constness (intype, type))
4954     {
4955       error ("static_cast from type `%T' to type `%T' casts away constness",
4956                 intype, type);
4957       return error_mark_node;
4958     }
4959
4960   if (ok)
4961     return build_c_cast (type, expr);
4962
4963   error ("invalid static_cast from type `%T' to type `%T'", intype, type);
4964   return error_mark_node;
4965 }
4966
4967 tree
4968 build_reinterpret_cast (type, expr)
4969    tree type, expr;
4970 {
4971   tree intype;
4972
4973   if (type == error_mark_node || expr == error_mark_node)
4974     return error_mark_node;
4975
4976   if (TREE_CODE (expr) == OFFSET_REF)
4977     expr = resolve_offset_ref (expr);
4978
4979   if (processing_template_decl)
4980     {
4981       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4982       return t;
4983     }
4984
4985   if (TREE_CODE (type) != REFERENCE_TYPE)
4986     {
4987       expr = decay_conversion (expr);
4988
4989       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4990          Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4991       if (TREE_CODE (expr) == NOP_EXPR
4992           && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4993         expr = TREE_OPERAND (expr, 0);
4994     }
4995
4996   intype = TREE_TYPE (expr);
4997
4998   if (TREE_CODE (type) == REFERENCE_TYPE)
4999     {
5000       if (! real_lvalue_p (expr))
5001         {
5002           error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
5003           return error_mark_node;
5004         }
5005       expr = build_unary_op (ADDR_EXPR, expr, 0);
5006       if (expr != error_mark_node)
5007         expr = build_reinterpret_cast
5008           (build_pointer_type (TREE_TYPE (type)), expr);
5009       if (expr != error_mark_node)
5010         expr = build_indirect_ref (expr, 0);
5011       return expr;
5012     }
5013   else if (same_type_ignoring_top_level_qualifiers_p (intype, type))
5014     return build_static_cast (type, expr);
5015
5016   if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE
5017                             || TREE_CODE (intype) == ENUMERAL_TYPE))
5018     /* OK */;
5019   else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
5020     {
5021       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5022         pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
5023                     intype, type);
5024     }
5025   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5026            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5027     {
5028       expr = decl_constant_value (expr);
5029       return fold (build1 (NOP_EXPR, type, expr));
5030     }
5031   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5032            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5033     {
5034       if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type), TREE_TYPE (intype)))
5035         pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)",
5036                     intype, type);
5037
5038       expr = decl_constant_value (expr);
5039       return fold (build1 (NOP_EXPR, type, expr));
5040     }
5041   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5042            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5043     {
5044       pedwarn ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5045       expr = decl_constant_value (expr);
5046       return fold (build1 (NOP_EXPR, type, expr));
5047     }
5048   else
5049     {
5050       error ("invalid reinterpret_cast from type `%T' to type `%T'",
5051                 intype, type);
5052       return error_mark_node;
5053     }
5054
5055   return cp_convert (type, expr);
5056 }
5057
5058 tree
5059 build_const_cast (type, expr)
5060    tree type, expr;
5061 {
5062   tree intype;
5063
5064   if (type == error_mark_node || expr == error_mark_node)
5065     return error_mark_node;
5066
5067   if (TREE_CODE (expr) == OFFSET_REF)
5068     expr = resolve_offset_ref (expr);
5069
5070   if (processing_template_decl)
5071     {
5072       tree t = build_min (CONST_CAST_EXPR, type, expr);
5073       return t;
5074     }
5075
5076   if (!POINTER_TYPE_P (type))
5077     error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
5078   else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5079     {
5080       error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
5081       return error_mark_node;
5082     }
5083
5084   if (TREE_CODE (type) != REFERENCE_TYPE)
5085     {
5086       expr = decay_conversion (expr);
5087
5088       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5089          Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5090       if (TREE_CODE (expr) == NOP_EXPR
5091           && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5092         expr = TREE_OPERAND (expr, 0);
5093     }
5094
5095   intype = TREE_TYPE (expr);
5096
5097   if (same_type_ignoring_top_level_qualifiers_p (intype, type))
5098     return build_static_cast (type, expr);
5099   else if (TREE_CODE (type) == REFERENCE_TYPE)
5100     {
5101       if (! real_lvalue_p (expr))
5102         {
5103           error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
5104           return error_mark_node;
5105         }
5106
5107       if (comp_ptr_ttypes_const (TREE_TYPE (type), intype))
5108         {
5109           expr = build_unary_op (ADDR_EXPR, expr, 0);
5110           expr = build1 (NOP_EXPR, type, expr);
5111           return convert_from_reference (expr);
5112         }
5113     }
5114   else if (TREE_CODE (type) == POINTER_TYPE
5115            && TREE_CODE (intype) == POINTER_TYPE
5116            && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
5117     return cp_convert (type, expr);
5118
5119   error ("invalid const_cast from type `%T' to type `%T'", intype, type);
5120   return error_mark_node;
5121 }
5122
5123 /* Build an expression representing a cast to type TYPE of expression EXPR.
5124
5125    ALLOW_NONCONVERTING is true if we should allow non-converting constructors
5126    when doing the cast.  */
5127
5128 tree
5129 build_c_cast (type, expr)
5130      tree type, expr;
5131 {
5132   register tree value = expr;
5133   tree otype;
5134
5135   if (type == error_mark_node || expr == error_mark_node)
5136     return error_mark_node;
5137
5138   if (processing_template_decl)
5139     {
5140       tree t = build_min (CAST_EXPR, type,
5141                           tree_cons (NULL_TREE, value, NULL_TREE));
5142       return t;
5143     }
5144
5145   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5146      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5147   if (TREE_CODE (type) != REFERENCE_TYPE
5148       && TREE_CODE (value) == NOP_EXPR
5149       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5150     value = TREE_OPERAND (value, 0);
5151
5152   if (TREE_CODE (value) == OFFSET_REF)
5153     value = resolve_offset_ref (value);
5154
5155   if (TREE_CODE (type) == ARRAY_TYPE)
5156     {
5157       /* Allow casting from T1* to T2[] because Cfront allows it.
5158          NIHCL uses it. It is not valid ISO C++ however.  */
5159       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5160         {
5161           pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
5162           type = build_pointer_type (TREE_TYPE (type));
5163         }
5164       else
5165         {
5166           error ("ISO C++ forbids casting to an array type `%T'", type);
5167           return error_mark_node;
5168         }
5169     }
5170
5171   if (TREE_CODE (type) == FUNCTION_TYPE
5172       || TREE_CODE (type) == METHOD_TYPE)
5173     {
5174       error ("invalid cast to function type `%T'", type);
5175       return error_mark_node;
5176     }
5177
5178   if (TREE_CODE (type) == VOID_TYPE)
5179     {
5180       /* Conversion to void does not cause any of the normal function to
5181        * pointer, array to pointer and lvalue to rvalue decays.  */
5182
5183       value = convert_to_void (value, /*implicit=*/NULL);
5184       return value;
5185     }
5186   /* Convert functions and arrays to pointers and
5187      convert references to their expanded types,
5188      but don't convert any other types.  If, however, we are
5189      casting to a class type, there's no reason to do this: the
5190      cast will only succeed if there is a converting constructor,
5191      and the default conversions will be done at that point.  In
5192      fact, doing the default conversion here is actually harmful
5193      in cases like this:
5194
5195      typedef int A[2];
5196      struct S { S(const A&); };
5197
5198      since we don't want the array-to-pointer conversion done.  */
5199   if (!IS_AGGR_TYPE (type))
5200     {
5201       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5202           || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
5203               /* Don't do the default conversion on a ->* expression.  */
5204               && ! (TREE_CODE (type) == POINTER_TYPE
5205                     && bound_pmf_p (value)))
5206           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5207           || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5208         value = default_conversion (value);
5209     }
5210   else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
5211     /* However, even for class types, we still need to strip away
5212        the reference type, since the call to convert_force below
5213        does not expect the input expression to be of reference
5214        type.  */
5215     value = convert_from_reference (value);
5216
5217   otype = TREE_TYPE (value);
5218
5219   /* Optionally warn about potentially worrisome casts.  */
5220
5221   if (warn_cast_qual
5222       && TREE_CODE (type) == POINTER_TYPE
5223       && TREE_CODE (otype) == POINTER_TYPE
5224       && !at_least_as_qualified_p (TREE_TYPE (type),
5225                                    TREE_TYPE (otype)))
5226     warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
5227                 otype, type);
5228
5229   if (TREE_CODE (type) == INTEGER_TYPE
5230       && TREE_CODE (otype) == POINTER_TYPE
5231       && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
5232     warning ("cast from pointer to integer of different size");
5233
5234   if (TREE_CODE (type) == POINTER_TYPE
5235       && TREE_CODE (otype) == INTEGER_TYPE
5236       && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
5237       /* Don't warn about converting any constant.  */
5238       && !TREE_CONSTANT (value))
5239     warning ("cast to pointer from integer of different size");
5240
5241   if (TREE_CODE (type) == REFERENCE_TYPE)
5242     value = (convert_from_reference
5243              (convert_to_reference (type, value, CONV_C_CAST,
5244                                     LOOKUP_COMPLAIN, NULL_TREE)));
5245   else
5246     {
5247       tree ovalue;
5248
5249       value = decl_constant_value (value);
5250
5251       ovalue = value;
5252       value = convert_force (type, value, CONV_C_CAST);
5253
5254       /* Ignore any integer overflow caused by the cast.  */
5255       if (TREE_CODE (value) == INTEGER_CST)
5256         {
5257           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
5258           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
5259         }
5260     }
5261
5262   /* Warn about possible alignment problems.  Do this here when we will have
5263      instantiated any necessary template types.  */
5264   if (STRICT_ALIGNMENT && warn_cast_align
5265       && TREE_CODE (type) == POINTER_TYPE
5266       && TREE_CODE (otype) == POINTER_TYPE
5267       && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5268       && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5269       && COMPLETE_TYPE_P (TREE_TYPE (otype))
5270       && COMPLETE_TYPE_P (TREE_TYPE (type))
5271       && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
5272     warning ("cast from `%T' to `%T' increases required alignment of target type",
5273                 otype, type);
5274
5275     /* Always produce some operator for an explicit cast,
5276        so we can tell (for -pedantic) that the cast is no lvalue.  */
5277   if (TREE_CODE (type) != REFERENCE_TYPE && value == expr
5278       && real_lvalue_p (value))
5279     value = non_lvalue (value);
5280
5281   return value;
5282 }
5283 \f
5284 /* Build an assignment expression of lvalue LHS from value RHS.
5285    MODIFYCODE is the code for a binary operator that we use
5286    to combine the old value of LHS with RHS to get the new value.
5287    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5288
5289    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5290
5291 tree
5292 build_modify_expr (lhs, modifycode, rhs)
5293      tree lhs;
5294      enum tree_code modifycode;
5295      tree rhs;
5296 {
5297   register tree result;
5298   tree newrhs = rhs;
5299   tree lhstype = TREE_TYPE (lhs);
5300   tree olhstype = lhstype;
5301   tree olhs = lhs;
5302
5303   /* Avoid duplicate error messages from operands that had errors.  */
5304   if (lhs == error_mark_node || rhs == error_mark_node)
5305     return error_mark_node;
5306
5307   /* Handle control structure constructs used as "lvalues".  */
5308   switch (TREE_CODE (lhs))
5309     {
5310       /* Handle --foo = 5; as these are valid constructs in C++ */
5311     case PREDECREMENT_EXPR:
5312     case PREINCREMENT_EXPR:
5313       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5314         lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5315                      stabilize_reference (TREE_OPERAND (lhs, 0)),
5316                      TREE_OPERAND (lhs, 1));
5317       return build (COMPOUND_EXPR, lhstype,
5318                     lhs,
5319                     build_modify_expr (TREE_OPERAND (lhs, 0),
5320                                        modifycode, rhs));
5321
5322       /* Handle (a, b) used as an "lvalue".  */
5323     case COMPOUND_EXPR:
5324       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5325                                   modifycode, rhs);
5326       if (newrhs == error_mark_node)
5327         return error_mark_node;
5328       return build (COMPOUND_EXPR, lhstype,
5329                     TREE_OPERAND (lhs, 0), newrhs);
5330
5331     case MODIFY_EXPR:
5332       newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5333       if (newrhs == error_mark_node)
5334         return error_mark_node;
5335       return build (COMPOUND_EXPR, lhstype, lhs, newrhs);
5336
5337       /* Handle (a ? b : c) used as an "lvalue".  */
5338     case COND_EXPR:
5339       {
5340         /* Produce (a ? (b = rhs) : (c = rhs))
5341            except that the RHS goes through a save-expr
5342            so the code to compute it is only emitted once.  */
5343         tree cond;
5344         tree preeval = NULL_TREE;
5345
5346         rhs = stabilize_expr (rhs, &preeval);
5347
5348         /* Check this here to avoid odd errors when trying to convert
5349            a throw to the type of the COND_EXPR.  */
5350         if (!lvalue_or_else (lhs, "assignment"))
5351           return error_mark_node;
5352
5353         cond = build_conditional_expr
5354           (TREE_OPERAND (lhs, 0),
5355            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5356                                           TREE_OPERAND (lhs, 1)),
5357                               modifycode, rhs),
5358            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5359                                           TREE_OPERAND (lhs, 2)),
5360                               modifycode, rhs));
5361
5362         if (cond == error_mark_node)
5363           return cond;
5364         /* Make sure the code to compute the rhs comes out
5365            before the split.  */
5366         return build (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5367       }
5368
5369     case OFFSET_REF:
5370       lhs = resolve_offset_ref (lhs);
5371       if (lhs == error_mark_node)
5372         return error_mark_node;
5373       olhstype = lhstype = TREE_TYPE (lhs);
5374
5375     default:
5376       break;
5377     }
5378
5379   if (modifycode == INIT_EXPR)
5380     {
5381       if (TREE_CODE (rhs) == CONSTRUCTOR)
5382         {
5383           my_friendly_assert (same_type_p (TREE_TYPE (rhs), lhstype),
5384                               20011220);
5385           result = build (INIT_EXPR, lhstype, lhs, rhs);
5386           TREE_SIDE_EFFECTS (result) = 1;
5387           return result;
5388         }
5389       else if (! IS_AGGR_TYPE (lhstype))
5390         /* Do the default thing */;
5391       else
5392         {
5393           result = build_special_member_call (lhs, complete_ctor_identifier,
5394                                               build_tree_list (NULL_TREE, rhs),
5395                                               TYPE_BINFO (lhstype),
5396                                               LOOKUP_NORMAL);
5397           if (result == NULL_TREE)
5398             return error_mark_node;
5399           return result;
5400         }
5401     }
5402   else
5403     {
5404       if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5405         {
5406           lhs = convert_from_reference (lhs);
5407           olhstype = lhstype = TREE_TYPE (lhs);
5408         }
5409       lhs = require_complete_type (lhs);
5410       if (lhs == error_mark_node)
5411         return error_mark_node;
5412
5413       if (modifycode == NOP_EXPR)
5414         {
5415           /* `operator=' is not an inheritable operator.  */
5416           if (! IS_AGGR_TYPE (lhstype))
5417             /* Do the default thing */;
5418           else
5419             {
5420               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5421                                      lhs, rhs, make_node (NOP_EXPR));
5422               if (result == NULL_TREE)
5423                 return error_mark_node;
5424               return result;
5425             }
5426           lhstype = olhstype;
5427         }
5428       else
5429         {
5430           /* A binary op has been requested.  Combine the old LHS
5431              value with the RHS producing the value we should actually
5432              store into the LHS.  */
5433
5434           my_friendly_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE),
5435                               978652);
5436           lhs = stabilize_reference (lhs);
5437           newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5438           if (newrhs == error_mark_node)
5439             {
5440               error ("  in evaluation of `%Q(%#T, %#T)'", modifycode,
5441                      TREE_TYPE (lhs), TREE_TYPE (rhs));
5442               return error_mark_node;
5443             }
5444
5445           /* Now it looks like a plain assignment.  */
5446           modifycode = NOP_EXPR;
5447         }
5448       my_friendly_assert (TREE_CODE (lhstype) != REFERENCE_TYPE, 20011220);
5449       my_friendly_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE,
5450                           20011220);
5451     }
5452
5453   /* Handle a cast used as an "lvalue".
5454      We have already performed any binary operator using the value as cast.
5455      Now convert the result to the cast type of the lhs,
5456      and then true type of the lhs and store it there;
5457      then convert result back to the cast type to be the value
5458      of the assignment.  */
5459
5460   switch (TREE_CODE (lhs))
5461     {
5462     case NOP_EXPR:
5463     case CONVERT_EXPR:
5464     case FLOAT_EXPR:
5465     case FIX_TRUNC_EXPR:
5466     case FIX_FLOOR_EXPR:
5467     case FIX_ROUND_EXPR:
5468     case FIX_CEIL_EXPR:
5469       {
5470         tree inner_lhs = TREE_OPERAND (lhs, 0);
5471         tree result;
5472
5473         if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5474             || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5475             || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5476             || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5477           newrhs = default_conversion (newrhs);
5478
5479         /* ISO C++ 5.4/1: The result is an lvalue if T is a reference
5480            type, otherwise the result is an rvalue.  */
5481         if (! lvalue_p (lhs))
5482           pedwarn ("ISO C++ forbids cast to non-reference type used as lvalue");
5483
5484         result = build_modify_expr (inner_lhs, NOP_EXPR,
5485                                     cp_convert (TREE_TYPE (inner_lhs),
5486                                                 cp_convert (lhstype, newrhs)));
5487         if (result == error_mark_node)
5488           return result;
5489         return cp_convert (TREE_TYPE (lhs), result);
5490       }
5491
5492     default:
5493       break;
5494     }
5495
5496   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5497      Reject anything strange now.  */
5498
5499   if (!lvalue_or_else (lhs, "assignment"))
5500     return error_mark_node;
5501
5502   /* Warn about modifying something that is `const'.  Don't warn if
5503      this is initialization.  */
5504   if (modifycode != INIT_EXPR
5505       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5506           /* Functions are not modifiable, even though they are
5507              lvalues.  */
5508           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5509           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5510           /* If it's an aggregate and any field is const, then it is
5511              effectively const.  */
5512           || (CLASS_TYPE_P (lhstype)
5513               && C_TYPE_FIELDS_READONLY (lhstype))))
5514     readonly_error (lhs, "assignment", 0);
5515
5516   /* If storing into a structure or union member, it has probably been
5517      given type `int'.  Compute the type that would go with the actual
5518      amount of storage the member occupies.  */
5519
5520   if (TREE_CODE (lhs) == COMPONENT_REF
5521       && (TREE_CODE (lhstype) == INTEGER_TYPE
5522           || TREE_CODE (lhstype) == REAL_TYPE
5523           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5524     {
5525       lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5526
5527       /* If storing in a field that is in actuality a short or narrower
5528          than one, we must store in the field in its actual type.  */
5529
5530       if (lhstype != TREE_TYPE (lhs))
5531         {
5532           lhs = copy_node (lhs);
5533           TREE_TYPE (lhs) = lhstype;
5534         }
5535     }
5536
5537   if (TREE_CODE (lhstype) != REFERENCE_TYPE)
5538     {
5539       if (TREE_SIDE_EFFECTS (lhs))
5540         lhs = stabilize_reference (lhs);
5541       if (TREE_SIDE_EFFECTS (newrhs))
5542         newrhs = stabilize_reference (newrhs);
5543     }
5544
5545   /* Convert new value to destination type.  */
5546
5547   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5548     {
5549       int from_array;
5550
5551       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5552                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5553         {
5554           error ("incompatible types in assignment of `%T' to `%T'",
5555                  TREE_TYPE (rhs), lhstype);
5556           return error_mark_node;
5557         }
5558
5559       /* Allow array assignment in compiler-generated code.  */
5560       if (! DECL_ARTIFICIAL (current_function_decl))
5561         pedwarn ("ISO C++ forbids assignment of arrays");
5562
5563       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5564                    ? 1 + (modifycode != INIT_EXPR): 0;
5565       return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5566     }
5567
5568   if (modifycode == INIT_EXPR)
5569     newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5570                                          "initialization", NULL_TREE, 0);
5571   else
5572     {
5573       /* Avoid warnings on enum bit fields.  */
5574       if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5575           && TREE_CODE (lhstype) == INTEGER_TYPE)
5576         {
5577           newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5578                                            NULL_TREE, 0);
5579           newrhs = convert_force (lhstype, newrhs, 0);
5580         }
5581       else
5582         newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5583                                          NULL_TREE, 0);
5584       if (TREE_CODE (newrhs) == CALL_EXPR
5585           && TYPE_NEEDS_CONSTRUCTING (lhstype))
5586         newrhs = build_cplus_new (lhstype, newrhs);
5587
5588       /* Can't initialize directly from a TARGET_EXPR, since that would
5589          cause the lhs to be constructed twice, and possibly result in
5590          accidental self-initialization.  So we force the TARGET_EXPR to be
5591          expanded without a target.  */
5592       if (TREE_CODE (newrhs) == TARGET_EXPR)
5593         newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5594                         TREE_OPERAND (newrhs, 0));
5595     }
5596
5597   if (newrhs == error_mark_node)
5598     return error_mark_node;
5599
5600   if (TREE_CODE (newrhs) == COND_EXPR)
5601     {
5602       tree lhs1;
5603       tree cond = TREE_OPERAND (newrhs, 0);
5604
5605       if (TREE_SIDE_EFFECTS (lhs))
5606         cond = build_compound_expr (tree_cons
5607                                     (NULL_TREE, lhs,
5608                                      build_tree_list (NULL_TREE, cond)));
5609
5610       /* Cannot have two identical lhs on this one tree (result) as preexpand
5611          calls will rip them out and fill in RTL for them, but when the
5612          rtl is generated, the calls will only be in the first side of the
5613          condition, not on both, or before the conditional jump! (mrs) */
5614       lhs1 = break_out_calls (lhs);
5615
5616       if (lhs == lhs1)
5617         /* If there's no change, the COND_EXPR behaves like any other rhs.  */
5618         result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5619                         lhstype, lhs, newrhs);
5620       else
5621         {
5622           tree result_type = TREE_TYPE (newrhs);
5623           /* We have to convert each arm to the proper type because the
5624              types may have been munged by constant folding.  */
5625           result
5626             = build (COND_EXPR, result_type, cond,
5627                      build_modify_expr (lhs, modifycode,
5628                                         cp_convert (result_type,
5629                                                     TREE_OPERAND (newrhs, 1))),
5630                      build_modify_expr (lhs1, modifycode,
5631                                         cp_convert (result_type,
5632                                                     TREE_OPERAND (newrhs, 2))));
5633         }
5634     }
5635   else
5636     result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5637                     lhstype, lhs, newrhs);
5638
5639   TREE_SIDE_EFFECTS (result) = 1;
5640
5641   /* If we got the LHS in a different type for storing in,
5642      convert the result back to the nominal type of LHS
5643      so that the value we return always has the same type
5644      as the LHS argument.  */
5645
5646   if (olhstype == TREE_TYPE (result))
5647     return result;
5648   /* Avoid warnings converting integral types back into enums
5649      for enum bit fields.  */
5650   if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
5651       && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5652     {
5653       result = build (COMPOUND_EXPR, olhstype, result, olhs);
5654       TREE_NO_UNUSED_WARNING (result) = 1;
5655       return result;
5656     }
5657   return convert_for_assignment (olhstype, result, "assignment",
5658                                  NULL_TREE, 0);
5659 }
5660
5661 tree
5662 build_x_modify_expr (lhs, modifycode, rhs)
5663      tree lhs;
5664      enum tree_code modifycode;
5665      tree rhs;
5666 {
5667   if (processing_template_decl)
5668     return build_min_nt (MODOP_EXPR, lhs,
5669                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5670
5671   if (modifycode != NOP_EXPR)
5672     {
5673       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5674                                 make_node (modifycode));
5675       if (rval)
5676         return rval;
5677     }
5678   return build_modify_expr (lhs, modifycode, rhs);
5679 }
5680
5681 \f
5682 /* Get difference in deltas for different pointer to member function
5683    types.  Return integer_zero_node, if FROM cannot be converted to a
5684    TO type.  If FORCE is true, then allow reverse conversions as well.
5685
5686    Note that the naming of FROM and TO is kind of backwards; the return
5687    value is what we add to a TO in order to get a FROM.  They are named
5688    this way because we call this function to find out how to convert from
5689    a pointer to member of FROM to a pointer to member of TO.  */
5690
5691 static tree
5692 get_delta_difference (from, to, force)
5693      tree from, to;
5694      int force;
5695 {
5696   tree delta = integer_zero_node;
5697   tree binfo;
5698   tree virt_binfo;
5699   base_kind kind;
5700
5701   binfo = lookup_base (to, from, ba_check, &kind);
5702   if (kind == bk_inaccessible || kind == bk_ambig)
5703     {
5704       error ("   in pointer to member function conversion");
5705       return delta;
5706     }
5707   if (!binfo)
5708     {
5709       if (!force)
5710         {
5711           error_not_base_type (from, to);
5712           error ("   in pointer to member conversion");
5713           return delta;
5714         }
5715       binfo = lookup_base (from, to, ba_check, &kind);
5716       if (binfo == 0)
5717         return delta;
5718       virt_binfo = binfo_from_vbase (binfo);
5719
5720       if (virt_binfo)
5721         {
5722           /* This is a reinterpret cast, we choose to do nothing.  */
5723           warning ("pointer to member cast via virtual base `%T' of `%T'",
5724                       BINFO_TYPE (virt_binfo),
5725                       BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
5726           return delta;
5727         }
5728       delta = BINFO_OFFSET (binfo);
5729       delta = cp_convert (ptrdiff_type_node, delta);
5730       delta = cp_build_binary_op (MINUS_EXPR,
5731                                  integer_zero_node,
5732                                  delta);
5733
5734       return delta;
5735     }
5736
5737   virt_binfo = binfo_from_vbase (binfo);
5738   if (virt_binfo)
5739     {
5740       /* This is a reinterpret cast, we choose to do nothing.  */
5741       if (force)
5742         warning ("pointer to member cast via virtual base `%T' of `%T'",
5743                     BINFO_TYPE (virt_binfo),
5744                     BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
5745       else
5746         error ("pointer to member conversion via virtual base `%T' of `%T'",
5747                   BINFO_TYPE (virt_binfo),
5748                   BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
5749       return delta;
5750     }
5751   delta = BINFO_OFFSET (binfo);
5752
5753   return cp_convert (ptrdiff_type_node, delta);
5754 }
5755
5756 /* Return a constructor for the pointer-to-member-function TYPE using
5757    the other components as specified.  */
5758
5759 tree
5760 build_ptrmemfunc1 (type, delta, pfn)
5761      tree type, delta, pfn;
5762 {
5763   tree u = NULL_TREE;
5764   tree delta_field;
5765   tree pfn_field;
5766
5767   /* Pull the FIELD_DECLs out of the type.  */
5768   pfn_field = TYPE_FIELDS (type);
5769   delta_field = TREE_CHAIN (pfn_field);
5770
5771   /* Make sure DELTA has the type we want.  */
5772   delta = convert_and_check (delta_type_node, delta);
5773
5774   /* Finish creating the initializer.  */
5775   u = tree_cons (pfn_field, pfn,
5776                  build_tree_list (delta_field, delta));
5777   u = build (CONSTRUCTOR, type, NULL_TREE, u);
5778   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) && TREE_CONSTANT (delta);
5779   TREE_STATIC (u) = (TREE_CONSTANT (u)
5780                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5781                          != NULL_TREE)
5782                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5783                          != NULL_TREE));
5784   return u;
5785 }
5786
5787 /* Build a constructor for a pointer to member function.  It can be
5788    used to initialize global variables, local variable, or used
5789    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
5790    want to be.
5791
5792    If FORCE is nonzero, then force this conversion, even if
5793    we would rather not do it.  Usually set when using an explicit
5794    cast.
5795
5796    Return error_mark_node, if something goes wrong.  */
5797
5798 tree
5799 build_ptrmemfunc (type, pfn, force)
5800      tree type, pfn;
5801      int force;
5802 {
5803   tree fn;
5804   tree pfn_type = TREE_TYPE (pfn);
5805   tree to_type = build_ptrmemfunc_type (type);
5806
5807   /* Handle multiple conversions of pointer to member functions.  */
5808   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn)))
5809     {
5810       tree delta = NULL_TREE;
5811       tree npfn = NULL_TREE;
5812       tree n;
5813
5814       if (!force
5815           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5816         error ("invalid conversion to type `%T' from type `%T'",
5817                   to_type, pfn_type);
5818
5819       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5820                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5821                                 force);
5822
5823       /* We don't have to do any conversion to convert a
5824          pointer-to-member to its own type.  But, we don't want to
5825          just return a PTRMEM_CST if there's an explicit cast; that
5826          cast should make the expression an invalid template argument.  */
5827       if (TREE_CODE (pfn) != PTRMEM_CST)
5828         {
5829           if (same_type_p (to_type, pfn_type))
5830             return pfn;
5831           else if (integer_zerop (n))
5832             return build_reinterpret_cast (to_type, pfn);
5833         }
5834
5835       if (TREE_SIDE_EFFECTS (pfn))
5836         pfn = save_expr (pfn);
5837
5838       /* Obtain the function pointer and the current DELTA.  */
5839       if (TREE_CODE (pfn) == PTRMEM_CST)
5840         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5841       else
5842         {
5843           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5844           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5845         }
5846
5847       /* Just adjust the DELTA field.  */
5848       delta = cp_convert (ptrdiff_type_node, delta);
5849       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5850         n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5851       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5852       return build_ptrmemfunc1 (to_type, delta, npfn);
5853     }
5854
5855   /* Handle null pointer to member function conversions.  */
5856   if (integer_zerop (pfn))
5857     {
5858       pfn = build_c_cast (type, integer_zero_node);
5859       return build_ptrmemfunc1 (to_type,
5860                                 integer_zero_node,
5861                                 pfn);
5862     }
5863
5864   if (type_unknown_p (pfn))
5865     return instantiate_type (type, pfn, tf_error | tf_warning);
5866
5867   fn = TREE_OPERAND (pfn, 0);
5868   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5869   return make_ptrmem_cst (to_type, fn);
5870 }
5871
5872 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5873    given by CST.
5874
5875    ??? There is no consistency as to the types returned for the above
5876    values.  Some code acts as if its a sizetype and some as if its
5877    integer_type_node.  */
5878
5879 void
5880 expand_ptrmemfunc_cst (cst, delta, pfn)
5881      tree cst;
5882      tree *delta;
5883      tree *pfn;
5884 {
5885   tree type = TREE_TYPE (cst);
5886   tree fn = PTRMEM_CST_MEMBER (cst);
5887   tree ptr_class, fn_class;
5888
5889   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5890
5891   /* The class that the function belongs to.  */
5892   fn_class = DECL_CONTEXT (fn);
5893
5894   /* The class that we're creating a pointer to member of.  */
5895   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5896
5897   /* First, calculate the adjustment to the function's class.  */
5898   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0);
5899
5900   if (!DECL_VIRTUAL_P (fn))
5901     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5902   else
5903     {
5904       /* If we're dealing with a virtual function, we have to adjust 'this'
5905          again, to point to the base which provides the vtable entry for
5906          fn; the call will do the opposite adjustment.  */
5907       tree orig_class = DECL_CONTEXT (fn);
5908       tree binfo = binfo_or_else (orig_class, fn_class);
5909       *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5910                             *delta, BINFO_OFFSET (binfo)));
5911
5912       /* We set PFN to the vtable offset at which the function can be
5913          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5914          case delta is shifted left, and then incremented).  */
5915       *pfn = DECL_VINDEX (fn);
5916       *pfn = fold (build (MULT_EXPR, integer_type_node, *pfn,
5917                           TYPE_SIZE_UNIT (vtable_entry_type)));
5918
5919       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5920         {
5921         case ptrmemfunc_vbit_in_pfn:
5922           *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn,
5923                               integer_one_node));
5924           break;
5925
5926         case ptrmemfunc_vbit_in_delta:
5927           *delta = fold (build (LSHIFT_EXPR, TREE_TYPE (*delta),
5928                                 *delta, integer_one_node));
5929           *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5930                                 *delta, integer_one_node));
5931           break;
5932
5933         default:
5934           abort ();
5935         }
5936
5937       *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
5938                            *pfn));
5939     }
5940 }
5941
5942 /* Return an expression for PFN from the pointer-to-member function
5943    given by T.  */
5944
5945 tree
5946 pfn_from_ptrmemfunc (t)
5947      tree t;
5948 {
5949   if (TREE_CODE (t) == PTRMEM_CST)
5950     {
5951       tree delta;
5952       tree pfn;
5953
5954       expand_ptrmemfunc_cst (t, &delta, &pfn);
5955       if (pfn)
5956         return pfn;
5957     }
5958
5959   return build_ptrmemfunc_access_expr (t, pfn_identifier);
5960 }
5961
5962 /* Expression EXPR is about to be implicitly converted to TYPE.  Warn
5963    if this is a potentially dangerous thing to do.  Returns a possibly
5964    marked EXPR.  */
5965
5966 tree
5967 dubious_conversion_warnings (type, expr, errtype, fndecl, parmnum)
5968      tree type;
5969      tree expr;
5970      const char *errtype;
5971      tree fndecl;
5972      int parmnum;
5973 {
5974   if (TREE_CODE (type) == REFERENCE_TYPE)
5975     type = TREE_TYPE (type);
5976
5977   /* Issue warnings about peculiar, but valid, uses of NULL.  */
5978   if (ARITHMETIC_TYPE_P (type) && expr == null_node)
5979     {
5980       if (fndecl)
5981         warning ("passing NULL used for non-pointer %s %P of `%D'",
5982                     errtype, parmnum, fndecl);
5983       else
5984         warning ("%s to non-pointer type `%T' from NULL", errtype, type);
5985     }
5986
5987   /* Warn about assigning a floating-point type to an integer type.  */
5988   if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
5989       && TREE_CODE (type) == INTEGER_TYPE)
5990     {
5991       if (fndecl)
5992         warning ("passing `%T' for %s %P of `%D'",
5993                     TREE_TYPE (expr), errtype, parmnum, fndecl);
5994       else
5995         warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
5996     }
5997   /* And warn about assigning a negative value to an unsigned
5998      variable.  */
5999   else if (TREE_UNSIGNED (type) && TREE_CODE (type) != BOOLEAN_TYPE)
6000     {
6001       if (TREE_CODE (expr) == INTEGER_CST
6002           && TREE_NEGATED_INT (expr))
6003         {
6004           if (fndecl)
6005             warning ("passing negative value `%E' for %s %P of `%D'",
6006                         expr, errtype, parmnum, fndecl);
6007           else
6008             warning ("%s of negative value `%E' to `%T'",
6009                         errtype, expr, type);
6010         }
6011
6012       overflow_warning (expr);
6013
6014       if (TREE_CONSTANT (expr))
6015         expr = fold (expr);
6016     }
6017   return expr;
6018 }
6019
6020 /* Convert value RHS to type TYPE as preparation for an assignment to
6021    an lvalue of type TYPE.  ERRTYPE is a string to use in error
6022    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
6023    are doing the conversion in order to pass the PARMNUMth argument of
6024    FNDECL.  */
6025
6026 static tree
6027 convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
6028      tree type, rhs;
6029      const char *errtype;
6030      tree fndecl;
6031      int parmnum;
6032 {
6033   register enum tree_code codel = TREE_CODE (type);
6034   register tree rhstype;
6035   register enum tree_code coder;
6036
6037   if (codel == OFFSET_TYPE)
6038     abort ();
6039
6040   if (TREE_CODE (rhs) == OFFSET_REF)
6041     rhs = resolve_offset_ref (rhs);
6042
6043   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
6044   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6045     rhs = TREE_OPERAND (rhs, 0);
6046
6047   rhstype = TREE_TYPE (rhs);
6048   coder = TREE_CODE (rhstype);
6049
6050   if (rhs == error_mark_node || rhstype == error_mark_node)
6051     return error_mark_node;
6052   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6053     return error_mark_node;
6054
6055   rhs = dubious_conversion_warnings (type, rhs, errtype, fndecl, parmnum);
6056
6057   /* The RHS of an assignment cannot have void type.  */
6058   if (coder == VOID_TYPE)
6059     {
6060       error ("void value not ignored as it ought to be");
6061       return error_mark_node;
6062     }
6063
6064   /* Simplify the RHS if possible.  */
6065   if (TREE_CODE (rhs) == CONST_DECL)
6066     rhs = DECL_INITIAL (rhs);
6067
6068   /* We do not use decl_constant_value here because of this case:
6069
6070        const char* const s = "s";
6071
6072      The conversion rules for a string literal are more lax than for a
6073      variable; in particular, a string literal can be converted to a
6074      "char *" but the variable "s" cannot be converted in the same
6075      way.  If the conversion is allowed, the optimization should be
6076      performed while creating the converted expression.  */
6077
6078   /* [expr.ass]
6079
6080      The expression is implicitly converted (clause _conv_) to the
6081      cv-unqualified type of the left operand.
6082
6083      We allow bad conversions here because by the time we get to this point
6084      we are committed to doing the conversion.  If we end up doing a bad
6085      conversion, convert_like will complain.  */
6086   if (!can_convert_arg_bad (type, rhstype, rhs))
6087     {
6088       /* When -Wno-pmf-conversions is use, we just silently allow
6089          conversions from pointers-to-members to plain pointers.  If
6090          the conversion doesn't work, cp_convert will complain.  */
6091       if (!warn_pmf2ptr
6092           && TYPE_PTR_P (type)
6093           && TYPE_PTRMEMFUNC_P (rhstype))
6094         rhs = cp_convert (strip_top_quals (type), rhs);
6095       else
6096         {
6097           /* If the right-hand side has unknown type, then it is an
6098              overloaded function.  Call instantiate_type to get error
6099              messages.  */
6100           if (rhstype == unknown_type_node)
6101             instantiate_type (type, rhs, tf_error | tf_warning);
6102           else if (fndecl)
6103             error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
6104                       rhstype, type, parmnum, fndecl);
6105           else
6106             error ("cannot convert `%T' to `%T' in %s", rhstype, type,
6107                       errtype);
6108           return error_mark_node;
6109         }
6110     }
6111   return perform_implicit_conversion (strip_top_quals (type), rhs);
6112 }
6113
6114 /* Convert RHS to be of type TYPE.
6115    If EXP is nonzero, it is the target of the initialization.
6116    ERRTYPE is a string to use in error messages.
6117
6118    Two major differences between the behavior of
6119    `convert_for_assignment' and `convert_for_initialization'
6120    are that references are bashed in the former, while
6121    copied in the latter, and aggregates are assigned in
6122    the former (operator=) while initialized in the
6123    latter (X(X&)).
6124
6125    If using constructor make sure no conversion operator exists, if one does
6126    exist, an ambiguity exists.
6127
6128    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
6129
6130 tree
6131 convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum)
6132      tree exp, type, rhs;
6133      int flags;
6134      const char *errtype;
6135      tree fndecl;
6136      int parmnum;
6137 {
6138   register enum tree_code codel = TREE_CODE (type);
6139   register tree rhstype;
6140   register enum tree_code coder;
6141
6142   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6143      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
6144   if (TREE_CODE (rhs) == NOP_EXPR
6145       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6146       && codel != REFERENCE_TYPE)
6147     rhs = TREE_OPERAND (rhs, 0);
6148
6149   if (rhs == error_mark_node
6150       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6151     return error_mark_node;
6152
6153   if (TREE_CODE (rhs) == OFFSET_REF)
6154     {
6155       rhs = resolve_offset_ref (rhs);
6156       if (rhs == error_mark_node)
6157         return error_mark_node;
6158     }
6159
6160   if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
6161     rhs = convert_from_reference (rhs);
6162
6163   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6164        && TREE_CODE (type) != ARRAY_TYPE
6165        && (TREE_CODE (type) != REFERENCE_TYPE
6166            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6167       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6168           && (TREE_CODE (type) != REFERENCE_TYPE
6169               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6170       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6171     rhs = default_conversion (rhs);
6172
6173   rhstype = TREE_TYPE (rhs);
6174   coder = TREE_CODE (rhstype);
6175
6176   if (coder == ERROR_MARK)
6177     return error_mark_node;
6178
6179   /* We accept references to incomplete types, so we can
6180      return here before checking if RHS is of complete type.  */
6181
6182   if (codel == REFERENCE_TYPE)
6183     {
6184       /* This should eventually happen in convert_arguments.  */
6185       int savew = 0, savee = 0;
6186
6187       if (fndecl)
6188         savew = warningcount, savee = errorcount;
6189       rhs = initialize_reference (type, rhs);
6190       if (fndecl)
6191         {
6192           if (warningcount > savew)
6193             cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
6194           else if (errorcount > savee)
6195             cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
6196         }
6197       return rhs;
6198     }
6199
6200   if (exp != 0)
6201     exp = require_complete_type (exp);
6202   if (exp == error_mark_node)
6203     return error_mark_node;
6204
6205   if (TREE_CODE (rhstype) == REFERENCE_TYPE)
6206     rhstype = TREE_TYPE (rhstype);
6207
6208   type = complete_type (type);
6209
6210   if (IS_AGGR_TYPE (type))
6211     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6212
6213   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
6214 }
6215 \f
6216 /* Expand an ASM statement with operands, handling output operands
6217    that are not variables or INDIRECT_REFS by transforming such
6218    cases into cases that expand_asm_operands can handle.
6219
6220    Arguments are same as for expand_asm_operands.
6221
6222    We don't do default conversions on all inputs, because it can screw
6223    up operands that are expected to be in memory.  */
6224
6225 void
6226 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6227      tree string, outputs, inputs, clobbers;
6228      int vol;
6229      const char *filename;
6230      int line;
6231 {
6232   int noutputs = list_length (outputs);
6233   register int i;
6234   /* o[I] is the place that output number I should be written.  */
6235   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6236   register tree tail;
6237
6238   /* Record the contents of OUTPUTS before it is modified.  */
6239   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6240     o[i] = TREE_VALUE (tail);
6241
6242   /* Generate the ASM_OPERANDS insn;
6243      store into the TREE_VALUEs of OUTPUTS some trees for
6244      where the values were actually stored.  */
6245   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6246
6247   /* Copy all the intermediate outputs into the specified outputs.  */
6248   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6249     {
6250       if (o[i] != TREE_VALUE (tail))
6251         {
6252           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6253                        const0_rtx, VOIDmode, EXPAND_NORMAL);
6254           free_temp_slots ();
6255
6256           /* Restore the original value so that it's correct the next
6257              time we expand this function.  */
6258           TREE_VALUE (tail) = o[i];
6259         }
6260       /* Detect modification of read-only values.
6261          (Otherwise done by build_modify_expr.)  */
6262       else
6263         {
6264           tree type = TREE_TYPE (o[i]);
6265           if (type != error_mark_node
6266               && (CP_TYPE_CONST_P (type)
6267                   || (CLASS_TYPE_P (type) && C_TYPE_FIELDS_READONLY (type))))
6268             readonly_error (o[i], "modification by `asm'", 1);
6269         }
6270     }
6271
6272   /* Those MODIFY_EXPRs could do autoincrements.  */
6273   emit_queue ();
6274 }
6275 \f
6276 /* If RETVAL is the address of, or a reference to, a local variable or
6277    temporary give an appropraite warning.  */
6278
6279 static void
6280 maybe_warn_about_returning_address_of_local (retval)
6281      tree retval;
6282 {
6283   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6284   tree whats_returned = retval;
6285
6286   for (;;)
6287     {
6288       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6289         whats_returned = TREE_OPERAND (whats_returned, 1);
6290       else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6291                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6292                || TREE_CODE (whats_returned) == NOP_EXPR)
6293         whats_returned = TREE_OPERAND (whats_returned, 0);
6294       else
6295         break;
6296     }
6297
6298   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6299     return;
6300   whats_returned = TREE_OPERAND (whats_returned, 0);
6301
6302   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6303     {
6304       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6305           || TREE_CODE (whats_returned) == TARGET_EXPR)
6306         {
6307           /* Get the target.  */
6308           whats_returned = TREE_OPERAND (whats_returned, 0);
6309           warning ("returning reference to temporary");
6310           return;
6311         }
6312       if (TREE_CODE (whats_returned) == VAR_DECL
6313           && DECL_NAME (whats_returned)
6314           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6315         {
6316           warning ("reference to non-lvalue returned");
6317           return;
6318         }
6319     }
6320
6321   if (TREE_CODE (whats_returned) == VAR_DECL
6322       && DECL_NAME (whats_returned)
6323       && DECL_FUNCTION_SCOPE_P (whats_returned)
6324       && !(TREE_STATIC (whats_returned)
6325            || TREE_PUBLIC (whats_returned)))
6326     {
6327       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6328         cp_warning_at ("reference to local variable `%D' returned",
6329                        whats_returned);
6330       else
6331         cp_warning_at ("address of local variable `%D' returned",
6332                        whats_returned);
6333       return;
6334     }
6335 }
6336
6337 /* Check that returning RETVAL from the current function is valid.
6338    Return an expression explicitly showing all conversions required to
6339    change RETVAL into the function return type, and to assign it to
6340    the DECL_RESULT for the function.  */
6341
6342 tree
6343 check_return_expr (retval)
6344      tree retval;
6345 {
6346   tree result;
6347   /* The type actually returned by the function, after any
6348      promotions.  */
6349   tree valtype;
6350   int fn_returns_value_p;
6351
6352   /* A `volatile' function is one that isn't supposed to return, ever.
6353      (This is a G++ extension, used to get better code for functions
6354      that call the `volatile' function.)  */
6355   if (TREE_THIS_VOLATILE (current_function_decl))
6356     warning ("function declared `noreturn' has a `return' statement");
6357
6358   /* Check for various simple errors.  */
6359   if (DECL_DESTRUCTOR_P (current_function_decl))
6360     {
6361       if (retval)
6362         error ("returning a value from a destructor");
6363       return NULL_TREE;
6364     }
6365   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6366     {
6367       if (in_function_try_handler)
6368         /* If a return statement appears in a handler of the
6369            function-try-block of a constructor, the program is ill-formed.  */
6370         error ("cannot return from a handler of a function-try-block of a constructor");
6371       else if (retval)
6372         /* You can't return a value from a constructor.  */
6373         error ("returning a value from a constructor");
6374       return NULL_TREE;
6375     }
6376
6377   if (processing_template_decl)
6378     {
6379       current_function_returns_value = 1;
6380       return retval;
6381     }
6382
6383   /* When no explicit return-value is given in a function with a named
6384      return value, the named return value is used.  */
6385   result = DECL_RESULT (current_function_decl);
6386   valtype = TREE_TYPE (result);
6387   my_friendly_assert (valtype != NULL_TREE, 19990924);
6388   fn_returns_value_p = !VOID_TYPE_P (valtype);
6389   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6390     retval = result;
6391
6392   /* Check for a return statement with no return value in a function
6393      that's supposed to return a value.  */
6394   if (!retval && fn_returns_value_p)
6395     {
6396       pedwarn ("return-statement with no value, in function declared with a non-void return type");
6397       /* Clear this, so finish_function won't say that we reach the
6398          end of a non-void function (which we don't, we gave a
6399          return!).  */
6400       current_function_returns_null = 0;
6401     }
6402   /* Check for a return statement with a value in a function that
6403      isn't supposed to return a value.  */
6404   else if (retval && !fn_returns_value_p)
6405     {
6406       if (VOID_TYPE_P (TREE_TYPE (retval)))
6407         /* You can return a `void' value from a function of `void'
6408            type.  In that case, we have to evaluate the expression for
6409            its side-effects.  */
6410           finish_expr_stmt (retval);
6411       else
6412         pedwarn ("return-statement with a value, in function declared with a void return type");
6413
6414       current_function_returns_null = 1;
6415
6416       /* There's really no value to return, after all.  */
6417       return NULL_TREE;
6418     }
6419   else if (!retval)
6420     /* Remember that this function can sometimes return without a
6421        value.  */
6422     current_function_returns_null = 1;
6423   else
6424     /* Remember that this function did return a value.  */
6425     current_function_returns_value = 1;
6426
6427   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6428   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6429        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6430       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6431       && ! flag_check_new
6432       && null_ptr_cst_p (retval))
6433     warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
6434
6435   /* Effective C++ rule 15.  See also start_function.  */
6436   if (warn_ecpp
6437       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)
6438       && retval != current_class_ref)
6439     warning ("`operator=' should return a reference to `*this'");
6440
6441   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6442
6443      [...]      For  a function with a class return type, if the expression
6444      in the return statement is the name of a local  object,  and  the  cv-
6445      unqualified  type  of  the  local  object  is the same as the function
6446      return type, an implementation is permitted to omit creating the  tem-
6447      porary  object  to  hold  the function return value [...]
6448
6449      So, if this is a value-returning function that always returns the same
6450      local variable, remember it.
6451
6452      It might be nice to be more flexible, and choose the first suitable
6453      variable even if the function sometimes returns something else, but
6454      then we run the risk of clobbering the variable we chose if the other
6455      returned expression uses the chosen variable somehow.  And people expect
6456      this restriction, anyway.  (jason 2000-11-19)
6457
6458      See finish_function, genrtl_start_function, and declare_return_variable
6459      for other pieces of this optimization.  */
6460
6461   if (fn_returns_value_p && flag_elide_constructors)
6462     {
6463       if (retval != NULL_TREE
6464           && (current_function_return_value == NULL_TREE
6465               || current_function_return_value == retval)
6466           && TREE_CODE (retval) == VAR_DECL
6467           && DECL_CONTEXT (retval) == current_function_decl
6468           && ! TREE_STATIC (retval)
6469           && (DECL_ALIGN (retval)
6470               >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6471           && same_type_p ((TYPE_MAIN_VARIANT
6472                            (TREE_TYPE (retval))),
6473                           (TYPE_MAIN_VARIANT
6474                            (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6475         current_function_return_value = retval;
6476       else
6477         current_function_return_value = error_mark_node;
6478     }
6479
6480   /* We don't need to do any conversions when there's nothing being
6481      returned.  */
6482   if (!retval || retval == error_mark_node)
6483     return retval;
6484
6485   /* Do any required conversions.  */
6486   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6487     /* No conversions are required.  */
6488     ;
6489   else
6490     {
6491       /* The type the function is declared to return.  */
6492       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6493
6494       /* First convert the value to the function's return type, then
6495          to the type of return value's location to handle the
6496          case that functype is smaller than the valtype.  */
6497       retval = convert_for_initialization
6498         (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6499          "return", NULL_TREE, 0);
6500       retval = convert (valtype, retval);
6501
6502       /* If the conversion failed, treat this just like `return;'.  */
6503       if (retval == error_mark_node)
6504         return retval;
6505       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6506       else if (! current_function_returns_struct
6507                && TREE_CODE (retval) == TARGET_EXPR
6508                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6509         retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6510                         TREE_OPERAND (retval, 0));
6511       else
6512         maybe_warn_about_returning_address_of_local (retval);
6513     }
6514
6515   /* Actually copy the value returned into the appropriate location.  */
6516   if (retval && retval != result)
6517     retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6518
6519   return retval;
6520 }
6521
6522 \f
6523 /* Returns nonzero if the pointer-type FROM can be converted to the
6524    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6525    then we return nonzero if the pointers are similar, and the
6526    cv-qualification signature of FROM is a proper subset of that of TO.
6527
6528    If CONSTP is positive, then all outer pointers have been
6529    const-qualified.  */
6530
6531 static int
6532 comp_ptr_ttypes_real (to, from, constp)
6533      tree to, from;
6534      int constp;
6535 {
6536   int to_more_cv_qualified = 0;
6537
6538   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6539     {
6540       if (TREE_CODE (to) != TREE_CODE (from))
6541         return 0;
6542
6543       if (TREE_CODE (from) == OFFSET_TYPE
6544           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6545                           TYPE_OFFSET_BASETYPE (to)))
6546           continue;
6547
6548       /* Const and volatile mean something different for function types,
6549          so the usual checks are not appropriate.  */
6550       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6551         {
6552           if (!at_least_as_qualified_p (to, from))
6553             return 0;
6554
6555           if (!at_least_as_qualified_p (from, to))
6556             {
6557               if (constp == 0)
6558                 return 0;
6559               else
6560                 ++to_more_cv_qualified;
6561             }
6562
6563           if (constp > 0)
6564             constp &= TYPE_READONLY (to);
6565         }
6566
6567       if (TREE_CODE (to) != POINTER_TYPE)
6568         return
6569           same_type_ignoring_top_level_qualifiers_p (to, from)
6570           && (constp >= 0 || to_more_cv_qualified);
6571     }
6572 }
6573
6574 /* When comparing, say, char ** to char const **, this function takes the
6575    'char *' and 'char const *'.  Do not pass non-pointer types to this
6576    function.  */
6577
6578 int
6579 comp_ptr_ttypes (to, from)
6580      tree to, from;
6581 {
6582   return comp_ptr_ttypes_real (to, from, 1);
6583 }
6584
6585 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6586    type or inheritance-related types, regardless of cv-quals.  */
6587
6588 int
6589 ptr_reasonably_similar (to, from)
6590      tree to, from;
6591 {
6592   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6593     {
6594       /* Any target type is similar enough to void.  */
6595       if (TREE_CODE (to) == VOID_TYPE
6596           || TREE_CODE (from) == VOID_TYPE)
6597         return 1;
6598
6599       if (TREE_CODE (to) != TREE_CODE (from))
6600         return 0;
6601
6602       if (TREE_CODE (from) == OFFSET_TYPE
6603           && comptypes (TYPE_OFFSET_BASETYPE (to),
6604                         TYPE_OFFSET_BASETYPE (from),
6605                         COMPARE_BASE | COMPARE_RELAXED))
6606         continue;
6607
6608       if (TREE_CODE (to) == INTEGER_TYPE
6609           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6610         return 1;
6611
6612       if (TREE_CODE (to) == FUNCTION_TYPE)
6613         return 1;
6614
6615       if (TREE_CODE (to) != POINTER_TYPE)
6616         return comptypes
6617           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6618            COMPARE_BASE | COMPARE_RELAXED);
6619     }
6620 }
6621
6622 /* Like comp_ptr_ttypes, for const_cast.  */
6623
6624 static int
6625 comp_ptr_ttypes_const (to, from)
6626      tree to, from;
6627 {
6628   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6629     {
6630       if (TREE_CODE (to) != TREE_CODE (from))
6631         return 0;
6632
6633       if (TREE_CODE (from) == OFFSET_TYPE
6634           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6635                           TYPE_OFFSET_BASETYPE (to)))
6636           continue;
6637
6638       if (TREE_CODE (to) != POINTER_TYPE)
6639         return same_type_ignoring_top_level_qualifiers_p (to, from);
6640     }
6641 }
6642
6643 /* Like comp_ptr_ttypes, for reinterpret_cast.  */
6644
6645 static int
6646 comp_ptr_ttypes_reinterpret (to, from)
6647      tree to, from;
6648 {
6649   int constp = 1;
6650
6651   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6652     {
6653       if (TREE_CODE (from) == OFFSET_TYPE)
6654         from = TREE_TYPE (from);
6655       if (TREE_CODE (to) == OFFSET_TYPE)
6656         to = TREE_TYPE (to);
6657
6658       /* Const and volatile mean something different for function types,
6659          so the usual checks are not appropriate.  */
6660       if (TREE_CODE (from) != FUNCTION_TYPE && TREE_CODE (from) != METHOD_TYPE
6661           && TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6662         {
6663           if (!at_least_as_qualified_p (to, from))
6664             return 0;
6665
6666           if (! constp
6667               && !at_least_as_qualified_p (from, to))
6668             return 0;
6669           constp &= TYPE_READONLY (to);
6670         }
6671
6672       if (TREE_CODE (from) != POINTER_TYPE
6673           || TREE_CODE (to) != POINTER_TYPE)
6674         return 1;
6675     }
6676 }
6677
6678 /* Returns the type qualifiers for this type, including the qualifiers on the
6679    elements for an array type.  */
6680
6681 int
6682 cp_type_quals (type)
6683      tree type;
6684 {
6685   type = strip_array_types (type);
6686   if (type == error_mark_node)
6687     return TYPE_UNQUALIFIED;
6688   return TYPE_QUALS (type);
6689 }
6690
6691 /* Returns nonzero if the TYPE contains a mutable member */
6692
6693 int
6694 cp_has_mutable_p (type)
6695      tree type;
6696 {
6697   type = strip_array_types (type);
6698
6699   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6700 }
6701
6702 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
6703    exemplar types such that casting T1 to T2 is casting away castness
6704    if and only if there is no implicit conversion from T1 to T2.  */
6705
6706 static void
6707 casts_away_constness_r (t1, t2)
6708      tree *t1;
6709      tree *t2;
6710 {
6711   int quals1;
6712   int quals2;
6713
6714   /* [expr.const.cast]
6715
6716      For multi-level pointer to members and multi-level mixed pointers
6717      and pointers to members (conv.qual), the "member" aspect of a
6718      pointer to member level is ignored when determining if a const
6719      cv-qualifier has been cast away.  */
6720   if (TYPE_PTRMEM_P (*t1))
6721     *t1 = build_pointer_type (TREE_TYPE (TREE_TYPE (*t1)));
6722   if (TYPE_PTRMEM_P (*t2))
6723     *t2 = build_pointer_type (TREE_TYPE (TREE_TYPE (*t2)));
6724
6725   /* [expr.const.cast]
6726
6727      For  two  pointer types:
6728
6729             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
6730             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
6731             K is min(N,M)
6732
6733      casting from X1 to X2 casts away constness if, for a non-pointer
6734      type T there does not exist an implicit conversion (clause
6735      _conv_) from:
6736
6737             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6738
6739      to
6740
6741             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
6742
6743   if (TREE_CODE (*t1) != POINTER_TYPE
6744       || TREE_CODE (*t2) != POINTER_TYPE)
6745     {
6746       *t1 = cp_build_qualified_type (void_type_node,
6747                                      cp_type_quals (*t1));
6748       *t2 = cp_build_qualified_type (void_type_node,
6749                                      cp_type_quals (*t2));
6750       return;
6751     }
6752
6753   quals1 = cp_type_quals (*t1);
6754   quals2 = cp_type_quals (*t2);
6755   *t1 = TREE_TYPE (*t1);
6756   *t2 = TREE_TYPE (*t2);
6757   casts_away_constness_r (t1, t2);
6758   *t1 = build_pointer_type (*t1);
6759   *t2 = build_pointer_type (*t2);
6760   *t1 = cp_build_qualified_type (*t1, quals1);
6761   *t2 = cp_build_qualified_type (*t2, quals2);
6762 }
6763
6764 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6765    constness.  */
6766
6767 static int
6768 casts_away_constness (t1, t2)
6769      tree t1;
6770      tree t2;
6771 {
6772   if (TREE_CODE (t2) == REFERENCE_TYPE)
6773     {
6774       /* [expr.const.cast]
6775
6776          Casting from an lvalue of type T1 to an lvalue of type T2
6777          using a reference cast casts away constness if a cast from an
6778          rvalue of type "pointer to T1" to the type "pointer to T2"
6779          casts away constness.  */
6780       t1 = (TREE_CODE (t1) == REFERENCE_TYPE
6781             ? TREE_TYPE (t1) : t1);
6782       return casts_away_constness (build_pointer_type (t1),
6783                                    build_pointer_type (TREE_TYPE (t2)));
6784     }
6785
6786   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6787     /* [expr.const.cast]
6788
6789        Casting from an rvalue of type "pointer to data member of X
6790        of type T1" to the type "pointer to data member of Y of type
6791        T2" casts away constness if a cast from an rvalue of type
6792        "pointer to T1" to the type "pointer to T2" casts away
6793        constness.  */
6794     return casts_away_constness
6795       (build_pointer_type (TREE_TYPE (TREE_TYPE (t1))),
6796        build_pointer_type (TREE_TYPE (TREE_TYPE (t2))));
6797
6798   /* Casting away constness is only something that makes sense for
6799      pointer or reference types.  */
6800   if (TREE_CODE (t1) != POINTER_TYPE
6801       || TREE_CODE (t2) != POINTER_TYPE)
6802     return 0;
6803
6804   /* Top-level qualifiers don't matter.  */
6805   t1 = TYPE_MAIN_VARIANT (t1);
6806   t2 = TYPE_MAIN_VARIANT (t2);
6807   casts_away_constness_r (&t1, &t2);
6808   if (!can_convert (t2, t1))
6809     return 1;
6810
6811   return 0;
6812 }
6813
6814 /* Returns TYPE with its cv qualifiers removed
6815    TYPE is T cv* .. *cv where T is not a pointer type,
6816    returns T * .. *. (If T is an array type, then the cv qualifiers
6817    above are those of the array members.)  */
6818
6819 static tree
6820 strip_all_pointer_quals (type)
6821      tree type;
6822 {
6823   if (TREE_CODE (type) == POINTER_TYPE)
6824     return build_pointer_type (strip_all_pointer_quals (TREE_TYPE (type)));
6825   else if (TREE_CODE (type) == OFFSET_TYPE)
6826     return build_offset_type (TYPE_OFFSET_BASETYPE (type),
6827                               strip_all_pointer_quals (TREE_TYPE (type)));
6828   else
6829     return TYPE_MAIN_VARIANT (type);
6830 }