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