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