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