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 BASELINK:
4315           arg = BASELINK_FUNCTIONS (arg);
4316           /* Fall through.  */
4317
4318         case OVERLOAD:
4319           arg = OVL_CURRENT (arg);
4320           break;
4321
4322         case OFFSET_REF:
4323           /* Turn a reference to a non-static data member into a
4324              pointer-to-member.  */
4325           {
4326             tree type;
4327             tree t;
4328
4329             if (!PTRMEM_OK_P (arg))
4330               return build_unary_op (code, arg, 0);
4331
4332             t = TREE_OPERAND (arg, 1);
4333             if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4334               {
4335                 error ("cannot create pointer to reference member %qD", t);
4336                 return error_mark_node;
4337               }
4338
4339             type = build_ptrmem_type (context_for_name_lookup (t),
4340                                       TREE_TYPE (t));
4341             t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4342             return t;
4343           }
4344
4345         default:
4346           break;
4347         }
4348
4349       /* Anything not already handled and not a true memory reference
4350          is an error.  */
4351       if (TREE_CODE (argtype) != FUNCTION_TYPE
4352           && TREE_CODE (argtype) != METHOD_TYPE
4353           && TREE_CODE (arg) != OFFSET_REF
4354           && !lvalue_or_else (arg, lv_addressof))
4355         return error_mark_node;
4356
4357       if (argtype != error_mark_node)
4358         argtype = build_pointer_type (argtype);
4359
4360       /* In a template, we are processing a non-dependent expression
4361          so we can just form an ADDR_EXPR with the correct type.  */
4362       if (processing_template_decl)
4363         {
4364           val = build_address (arg);
4365           if (TREE_CODE (arg) == OFFSET_REF)
4366             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4367           return val;
4368         }
4369
4370       if (TREE_CODE (arg) != COMPONENT_REF)
4371         {
4372           val = build_address (arg);
4373           if (TREE_CODE (arg) == OFFSET_REF)
4374             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4375         }
4376       else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4377         {
4378           tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4379
4380           /* We can only get here with a single static member
4381              function.  */
4382           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4383                       && DECL_STATIC_FUNCTION_P (fn));
4384           mark_used (fn);
4385           val = build_address (fn);
4386           if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4387             /* Do not lose object's side effects.  */
4388             val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4389                           TREE_OPERAND (arg, 0), val);
4390         }
4391       else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4392         {
4393           error ("attempt to take address of bit-field structure member %qD",
4394                  TREE_OPERAND (arg, 1));
4395           return error_mark_node;
4396         }
4397       else
4398         {
4399           tree object = TREE_OPERAND (arg, 0);
4400           tree field = TREE_OPERAND (arg, 1);
4401           gcc_assert (same_type_ignoring_top_level_qualifiers_p
4402                       (TREE_TYPE (object), decl_type_context (field)));
4403           val = build_address (arg);
4404         }
4405
4406       if (TREE_CODE (argtype) == POINTER_TYPE
4407           && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4408         {
4409           build_ptrmemfunc_type (argtype);
4410           val = build_ptrmemfunc (argtype, val, 0,
4411                                   /*c_cast_p=*/false);
4412         }
4413
4414       return val;
4415
4416     default:
4417       break;
4418     }
4419
4420   if (!errstring)
4421     {
4422       if (argtype == 0)
4423         argtype = TREE_TYPE (arg);
4424       return fold_if_not_in_template (build1 (code, argtype, arg));
4425     }
4426
4427   error ("%s", errstring);
4428   return error_mark_node;
4429 }
4430
4431 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4432    for certain kinds of expressions which are not really lvalues
4433    but which we can accept as lvalues.
4434
4435    If ARG is not a kind of expression we can handle, return
4436    NULL_TREE.  */
4437
4438 tree
4439 unary_complex_lvalue (enum tree_code code, tree arg)
4440 {
4441   /* Inside a template, making these kinds of adjustments is
4442      pointless; we are only concerned with the type of the
4443      expression.  */
4444   if (processing_template_decl)
4445     return NULL_TREE;
4446
4447   /* Handle (a, b) used as an "lvalue".  */
4448   if (TREE_CODE (arg) == COMPOUND_EXPR)
4449     {
4450       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4451       return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4452                      TREE_OPERAND (arg, 0), real_result);
4453     }
4454
4455   /* Handle (a ? b : c) used as an "lvalue".  */
4456   if (TREE_CODE (arg) == COND_EXPR
4457       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4458     return rationalize_conditional_expr (code, arg);
4459
4460   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4461   if (TREE_CODE (arg) == MODIFY_EXPR
4462       || TREE_CODE (arg) == PREINCREMENT_EXPR
4463       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4464     {
4465       tree lvalue = TREE_OPERAND (arg, 0);
4466       if (TREE_SIDE_EFFECTS (lvalue))
4467         {
4468           lvalue = stabilize_reference (lvalue);
4469           arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4470                         lvalue, TREE_OPERAND (arg, 1));
4471         }
4472       return unary_complex_lvalue
4473         (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4474     }
4475
4476   if (code != ADDR_EXPR)
4477     return NULL_TREE;
4478
4479   /* Handle (a = b) used as an "lvalue" for `&'.  */
4480   if (TREE_CODE (arg) == MODIFY_EXPR
4481       || TREE_CODE (arg) == INIT_EXPR)
4482     {
4483       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4484       arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4485                     arg, real_result);
4486       TREE_NO_WARNING (arg) = 1;
4487       return arg;
4488     }
4489
4490   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4491       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4492       || TREE_CODE (arg) == OFFSET_REF)
4493     return NULL_TREE;
4494
4495   /* We permit compiler to make function calls returning
4496      objects of aggregate type look like lvalues.  */
4497   {
4498     tree targ = arg;
4499
4500     if (TREE_CODE (targ) == SAVE_EXPR)
4501       targ = TREE_OPERAND (targ, 0);
4502
4503     if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4504       {
4505         if (TREE_CODE (arg) == SAVE_EXPR)
4506           targ = arg;
4507         else
4508           targ = build_cplus_new (TREE_TYPE (arg), arg);
4509         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4510       }
4511
4512     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4513       return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4514                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4515   }
4516
4517   /* Don't let anything else be handled specially.  */
4518   return NULL_TREE;
4519 }
4520 \f
4521 /* Mark EXP saying that we need to be able to take the
4522    address of it; it should not be allocated in a register.
4523    Value is true if successful.
4524
4525    C++: we do not allow `current_class_ptr' to be addressable.  */
4526
4527 bool
4528 cxx_mark_addressable (tree exp)
4529 {
4530   tree x = exp;
4531
4532   while (1)
4533     switch (TREE_CODE (x))
4534       {
4535       case ADDR_EXPR:
4536       case COMPONENT_REF:
4537       case ARRAY_REF:
4538       case REALPART_EXPR:
4539       case IMAGPART_EXPR:
4540         x = TREE_OPERAND (x, 0);
4541         break;
4542
4543       case PARM_DECL:
4544         if (x == current_class_ptr)
4545           {
4546             error ("cannot take the address of %<this%>, which is an rvalue expression");
4547             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4548             return true;
4549           }
4550         /* Fall through.  */
4551
4552       case VAR_DECL:
4553         /* Caller should not be trying to mark initialized
4554            constant fields addressable.  */
4555         gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4556                     || DECL_IN_AGGR_P (x) == 0
4557                     || TREE_STATIC (x)
4558                     || DECL_EXTERNAL (x));
4559         /* Fall through.  */
4560
4561       case CONST_DECL:
4562       case RESULT_DECL:
4563         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4564             && !DECL_ARTIFICIAL (x))
4565           {
4566             if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
4567               {
4568                 error
4569                   ("address of explicit register variable %qD requested", x);
4570                 return false;
4571               }
4572             else if (extra_warnings)
4573               warning
4574                 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
4575           }
4576         TREE_ADDRESSABLE (x) = 1;
4577         return true;
4578
4579       case FUNCTION_DECL:
4580         TREE_ADDRESSABLE (x) = 1;
4581         return true;
4582
4583       case CONSTRUCTOR:
4584         TREE_ADDRESSABLE (x) = 1;
4585         return true;
4586
4587       case TARGET_EXPR:
4588         TREE_ADDRESSABLE (x) = 1;
4589         cxx_mark_addressable (TREE_OPERAND (x, 0));
4590         return true;
4591
4592       default:
4593         return true;
4594     }
4595 }
4596 \f
4597 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4598
4599 tree
4600 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4601 {
4602   tree orig_ifexp = ifexp;
4603   tree orig_op1 = op1;
4604   tree orig_op2 = op2;
4605   tree expr;
4606
4607   if (processing_template_decl)
4608     {
4609       /* The standard says that the expression is type-dependent if
4610          IFEXP is type-dependent, even though the eventual type of the
4611          expression doesn't dependent on IFEXP.  */
4612       if (type_dependent_expression_p (ifexp)
4613           /* As a GNU extension, the middle operand may be omitted.  */
4614           || (op1 && type_dependent_expression_p (op1))
4615           || type_dependent_expression_p (op2))
4616         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4617       ifexp = build_non_dependent_expr (ifexp);
4618       if (op1)
4619         op1 = build_non_dependent_expr (op1);
4620       op2 = build_non_dependent_expr (op2);
4621     }
4622
4623   expr = build_conditional_expr (ifexp, op1, op2);
4624   if (processing_template_decl && expr != error_mark_node)
4625     return build_min_non_dep (COND_EXPR, expr,
4626                               orig_ifexp, orig_op1, orig_op2);
4627   return expr;
4628 }
4629 \f
4630 /* Given a list of expressions, return a compound expression
4631    that performs them all and returns the value of the last of them.  */
4632
4633 tree build_x_compound_expr_from_list (tree list, const char *msg)
4634 {
4635   tree expr = TREE_VALUE (list);
4636
4637   if (TREE_CHAIN (list))
4638     {
4639       if (msg)
4640         pedwarn ("%s expression list treated as compound expression", msg);
4641
4642       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4643         expr = build_x_compound_expr (expr, TREE_VALUE (list));
4644     }
4645
4646   return expr;
4647 }
4648
4649 /* Handle overloading of the ',' operator when needed.  */
4650
4651 tree
4652 build_x_compound_expr (tree op1, tree op2)
4653 {
4654   tree result;
4655   tree orig_op1 = op1;
4656   tree orig_op2 = op2;
4657
4658   if (processing_template_decl)
4659     {
4660       if (type_dependent_expression_p (op1)
4661           || type_dependent_expression_p (op2))
4662         return build_min_nt (COMPOUND_EXPR, op1, op2);
4663       op1 = build_non_dependent_expr (op1);
4664       op2 = build_non_dependent_expr (op2);
4665     }
4666
4667   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4668                          /*overloaded_p=*/NULL);
4669   if (!result)
4670     result = build_compound_expr (op1, op2);
4671
4672   if (processing_template_decl && result != error_mark_node)
4673     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4674
4675   return result;
4676 }
4677
4678 /* Build a compound expression.  */
4679
4680 tree
4681 build_compound_expr (tree lhs, tree rhs)
4682 {
4683   lhs = convert_to_void (lhs, "left-hand operand of comma");
4684
4685   if (lhs == error_mark_node || rhs == error_mark_node)
4686     return error_mark_node;
4687
4688   if (TREE_CODE (rhs) == TARGET_EXPR)
4689     {
4690       /* If the rhs is a TARGET_EXPR, then build the compound
4691          expression inside the target_expr's initializer. This
4692          helps the compiler to eliminate unnecessary temporaries.  */
4693       tree init = TREE_OPERAND (rhs, 1);
4694
4695       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4696       TREE_OPERAND (rhs, 1) = init;
4697
4698       return rhs;
4699     }
4700
4701   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4702 }
4703
4704 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4705    casts away constness.  DIAG_FN gives the function to call if we
4706    need to issue a diagnostic; if it is NULL, no diagnostic will be
4707    issued.  DESCRIPTION explains what operation is taking place.  */
4708
4709 static void
4710 check_for_casting_away_constness (tree src_type, tree dest_type,
4711                                   void (*diag_fn)(const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2),
4712                                   const char *description)
4713 {
4714   if (diag_fn && casts_away_constness (src_type, dest_type))
4715     diag_fn ("%s from type %qT to type %qT casts away constness",
4716              description, src_type, dest_type);
4717 }
4718
4719 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4720    (another pointer-to-member type in the same hierarchy) and return
4721    the converted expression.  If ALLOW_INVERSE_P is permitted, a
4722    pointer-to-derived may be converted to pointer-to-base; otherwise,
4723    only the other direction is permitted.  If C_CAST_P is true, this
4724    conversion is taking place as part of a C-style cast.  */
4725
4726 tree
4727 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
4728                 bool c_cast_p)
4729 {
4730   if (TYPE_PTRMEM_P (type))
4731     {
4732       tree delta;
4733
4734       if (TREE_CODE (expr) == PTRMEM_CST)
4735         expr = cplus_expand_constant (expr);
4736       delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
4737                                     TYPE_PTRMEM_CLASS_TYPE (type),
4738                                     allow_inverse_p,
4739                                     c_cast_p);
4740       if (!integer_zerop (delta))
4741         expr = cp_build_binary_op (PLUS_EXPR,
4742                                    build_nop (ptrdiff_type_node, expr),
4743                                    delta);
4744       return build_nop (type, expr);
4745     }
4746   else
4747     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4748                              allow_inverse_p, c_cast_p);
4749 }
4750
4751 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
4752    a version of EXPR that has TREE_OVERFLOW and/or TREE_CONSTANT_OVERFLOW
4753    set iff they are set in ORIG.  Otherwise, return EXPR unchanged.  */
4754
4755 static tree
4756 ignore_overflows (tree expr, tree orig)
4757 {
4758   if (TREE_CODE (expr) == INTEGER_CST
4759       && CONSTANT_CLASS_P (orig)
4760       && TREE_CODE (orig) != STRING_CST
4761       && (TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig)
4762           || TREE_CONSTANT_OVERFLOW (expr)
4763              != TREE_CONSTANT_OVERFLOW (orig)))
4764     {
4765       if (!TREE_OVERFLOW (orig) && !TREE_CONSTANT_OVERFLOW (orig))
4766         /* Ensure constant sharing.  */
4767         expr = build_int_cst_wide (TREE_TYPE (expr),
4768                                    TREE_INT_CST_LOW (expr),
4769                                    TREE_INT_CST_HIGH (expr));
4770       else
4771         {
4772           /* Avoid clobbering a shared constant.  */
4773           expr = copy_node (expr);
4774           TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
4775           TREE_CONSTANT_OVERFLOW (expr)
4776             = TREE_CONSTANT_OVERFLOW (orig);
4777         }
4778     }
4779   return expr;
4780 }
4781
4782 /* Perform a static_cast from EXPR to TYPE.  When C_CAST_P is true,
4783    this static_cast is being attempted as one of the possible casts
4784    allowed by a C-style cast.  (In that case, accessibility of base
4785    classes is not considered, and it is OK to cast away
4786    constness.)  Return the result of the cast.  *VALID_P is set to
4787    indicate whether or not the cast was valid.  */
4788
4789 static tree
4790 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
4791                      bool *valid_p)
4792 {
4793   tree intype;
4794   tree result;
4795   tree orig;
4796   void (*diag_fn)(const char*, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
4797   const char *desc;
4798
4799   /* Assume the cast is valid.  */
4800   *valid_p = true;
4801
4802   intype = TREE_TYPE (expr);
4803
4804   /* Save casted types in the function's used types hash table.  */
4805   used_types_insert (type);
4806
4807   /* Determine what to do when casting away constness.  */
4808   if (c_cast_p)
4809     {
4810       /* C-style casts are allowed to cast away constness.  With
4811          WARN_CAST_QUAL, we still want to issue a warning.  */
4812       diag_fn = warn_cast_qual ? warning0 : NULL;
4813       desc = "cast";
4814     }
4815   else
4816     {
4817       /* A static_cast may not cast away constness.  */
4818       diag_fn = error;
4819       desc = "static_cast";
4820     }
4821
4822   /* [expr.static.cast]
4823
4824      An lvalue of type "cv1 B", where B is a class type, can be cast
4825      to type "reference to cv2 D", where D is a class derived (clause
4826      _class.derived_) from B, if a valid standard conversion from
4827      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4828      same cv-qualification as, or greater cv-qualification than, cv1,
4829      and B is not a virtual base class of D.  */
4830   /* We check this case before checking the validity of "TYPE t =
4831      EXPR;" below because for this case:
4832
4833        struct B {};
4834        struct D : public B { D(const B&); };
4835        extern B& b;
4836        void f() { static_cast<const D&>(b); }
4837
4838      we want to avoid constructing a new D.  The standard is not
4839      completely clear about this issue, but our interpretation is
4840      consistent with other compilers.  */
4841   if (TREE_CODE (type) == REFERENCE_TYPE
4842       && CLASS_TYPE_P (TREE_TYPE (type))
4843       && CLASS_TYPE_P (intype)
4844       && real_lvalue_p (expr)
4845       && DERIVED_FROM_P (intype, TREE_TYPE (type))
4846       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4847                       build_pointer_type (TYPE_MAIN_VARIANT
4848                                           (TREE_TYPE (type))))
4849       && (c_cast_p
4850           || at_least_as_qualified_p (TREE_TYPE (type), intype)))
4851     {
4852       tree base;
4853
4854       /* There is a standard conversion from "D*" to "B*" even if "B"
4855          is ambiguous or inaccessible.  If this is really a
4856          static_cast, then we check both for inaccessibility and
4857          ambiguity.  However, if this is a static_cast being performed
4858          because the user wrote a C-style cast, then accessibility is
4859          not considered.  */
4860       base = lookup_base (TREE_TYPE (type), intype,
4861                           c_cast_p ? ba_unique : ba_check,
4862                           NULL);
4863
4864       /* Convert from "B*" to "D*".  This function will check that "B"
4865          is not a virtual base of "D".  */
4866       expr = build_base_path (MINUS_EXPR, build_address (expr),
4867                               base, /*nonnull=*/false);
4868       /* Convert the pointer to a reference -- but then remember that
4869          there are no expressions with reference type in C++.  */
4870       return convert_from_reference (build_nop (type, expr));
4871     }
4872
4873   orig = expr;
4874
4875   /* [expr.static.cast]
4876
4877      An expression e can be explicitly converted to a type T using a
4878      static_cast of the form static_cast<T>(e) if the declaration T
4879      t(e);" is well-formed, for some invented temporary variable
4880      t.  */
4881   result = perform_direct_initialization_if_possible (type, expr,
4882                                                       c_cast_p);
4883   if (result)
4884     {
4885       result = convert_from_reference (result);
4886
4887       /* Ignore any integer overflow caused by the cast.  */
4888       result = ignore_overflows (result, orig);
4889
4890       /* [expr.static.cast]
4891
4892          If T is a reference type, the result is an lvalue; otherwise,
4893          the result is an rvalue.  */
4894       if (TREE_CODE (type) != REFERENCE_TYPE)
4895         result = rvalue (result);
4896       return result;
4897     }
4898
4899   /* [expr.static.cast]
4900
4901      Any expression can be explicitly converted to type cv void.  */
4902   if (TREE_CODE (type) == VOID_TYPE)
4903     return convert_to_void (expr, /*implicit=*/NULL);
4904
4905   /* [expr.static.cast]
4906
4907      The inverse of any standard conversion sequence (clause _conv_),
4908      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4909      (_conv.array_), function-to-pointer (_conv.func_), and boolean
4910      (_conv.bool_) conversions, can be performed explicitly using
4911      static_cast subject to the restriction that the explicit
4912      conversion does not cast away constness (_expr.const.cast_), and
4913      the following additional rules for specific cases:  */
4914   /* For reference, the conversions not excluded are: integral
4915      promotions, floating point promotion, integral conversions,
4916      floating point conversions, floating-integral conversions,
4917      pointer conversions, and pointer to member conversions.  */
4918   /* DR 128
4919
4920      A value of integral _or enumeration_ type can be explicitly
4921      converted to an enumeration type.  */
4922   /* The effect of all that is that any conversion between any two
4923      types which are integral, floating, or enumeration types can be
4924      performed.  */
4925   if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
4926       && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
4927     {
4928       expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
4929
4930       /* Ignore any integer overflow caused by the cast.  */
4931       expr = ignore_overflows (expr, orig);
4932       return expr;
4933     }
4934
4935   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4936       && CLASS_TYPE_P (TREE_TYPE (type))
4937       && CLASS_TYPE_P (TREE_TYPE (intype))
4938       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4939                                           (TREE_TYPE (intype))),
4940                       build_pointer_type (TYPE_MAIN_VARIANT
4941                                           (TREE_TYPE (type)))))
4942     {
4943       tree base;
4944
4945       if (!c_cast_p)
4946         check_for_casting_away_constness (intype, type, diag_fn, desc);
4947       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4948                           c_cast_p ? ba_unique : ba_check,
4949                           NULL);
4950       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4951     }
4952
4953   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4954       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4955     {
4956       tree c1;
4957       tree c2;
4958       tree t1;
4959       tree t2;
4960
4961       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4962       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4963
4964       if (TYPE_PTRMEM_P (type))
4965         {
4966           t1 = (build_ptrmem_type
4967                 (c1,
4968                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4969           t2 = (build_ptrmem_type
4970                 (c2,
4971                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4972         }
4973       else
4974         {
4975           t1 = intype;
4976           t2 = type;
4977         }
4978       if (can_convert (t1, t2))
4979         {
4980           if (!c_cast_p)
4981             check_for_casting_away_constness (intype, type, diag_fn,
4982                                               desc);
4983           return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
4984                                  c_cast_p);
4985         }
4986     }
4987
4988   /* [expr.static.cast]
4989
4990      An rvalue of type "pointer to cv void" can be explicitly
4991      converted to a pointer to object type.  A value of type pointer
4992      to object converted to "pointer to cv void" and back to the
4993      original pointer type will have its original value.  */
4994   if (TREE_CODE (intype) == POINTER_TYPE
4995       && VOID_TYPE_P (TREE_TYPE (intype))
4996       && TYPE_PTROB_P (type))
4997     {
4998       if (!c_cast_p)
4999         check_for_casting_away_constness (intype, type, diag_fn, desc);
5000       return build_nop (type, expr);
5001     }
5002
5003   *valid_p = false;
5004   return error_mark_node;
5005 }
5006
5007 /* Return an expression representing static_cast<TYPE>(EXPR).  */
5008
5009 tree
5010 build_static_cast (tree type, tree expr)
5011 {
5012   tree result;
5013   bool valid_p;
5014
5015   if (type == error_mark_node || expr == error_mark_node)
5016     return error_mark_node;
5017
5018   if (processing_template_decl)
5019     {
5020       expr = build_min (STATIC_CAST_EXPR, type, expr);
5021       /* We don't know if it will or will not have side effects.  */
5022       TREE_SIDE_EFFECTS (expr) = 1;
5023       return convert_from_reference (expr);
5024     }
5025
5026   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5027      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5028   if (TREE_CODE (type) != REFERENCE_TYPE
5029       && TREE_CODE (expr) == NOP_EXPR
5030       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5031     expr = TREE_OPERAND (expr, 0);
5032
5033   result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p);
5034   if (valid_p)
5035     return result;
5036
5037   error ("invalid static_cast from type %qT to type %qT",
5038          TREE_TYPE (expr), type);
5039   return error_mark_node;
5040 }
5041
5042 /* EXPR is an expression with member function or pointer-to-member
5043    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
5044    not permitted by ISO C++, but we accept it in some modes.  If we
5045    are not in one of those modes, issue a diagnostic.  Return the
5046    converted expression.  */
5047
5048 tree
5049 convert_member_func_to_ptr (tree type, tree expr)
5050 {
5051   tree intype;
5052   tree decl;
5053
5054   intype = TREE_TYPE (expr);
5055   gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5056               || TREE_CODE (intype) == METHOD_TYPE);
5057
5058   if (pedantic || warn_pmf2ptr)
5059     pedwarn ("converting from %qT to %qT", intype, type);
5060
5061   if (TREE_CODE (intype) == METHOD_TYPE)
5062     expr = build_addr_func (expr);
5063   else if (TREE_CODE (expr) == PTRMEM_CST)
5064     expr = build_address (PTRMEM_CST_MEMBER (expr));
5065   else
5066     {
5067       decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5068       decl = build_address (decl);
5069       expr = get_member_function_from_ptrfunc (&decl, expr);
5070     }
5071
5072   return build_nop (type, expr);
5073 }
5074
5075 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5076    If C_CAST_P is true, this reinterpret cast is being done as part of
5077    a C-style cast.  If VALID_P is non-NULL, *VALID_P is set to
5078    indicate whether or not reinterpret_cast was valid.  */
5079
5080 static tree
5081 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5082                           bool *valid_p)
5083 {
5084   tree intype;
5085
5086   /* Assume the cast is invalid.  */
5087   if (valid_p)
5088     *valid_p = true;
5089
5090   if (type == error_mark_node || error_operand_p (expr))
5091     return error_mark_node;
5092
5093   intype = TREE_TYPE (expr);
5094
5095   /* Save casted types in the function's used types hash table.  */
5096   used_types_insert (type);
5097
5098   /* [expr.reinterpret.cast]
5099      An lvalue expression of type T1 can be cast to the type
5100      "reference to T2" if an expression of type "pointer to T1" can be
5101      explicitly converted to the type "pointer to T2" using a
5102      reinterpret_cast.  */
5103   if (TREE_CODE (type) == REFERENCE_TYPE)
5104     {
5105       if (! real_lvalue_p (expr))
5106         {
5107           error ("invalid cast of an rvalue expression of type "
5108                  "%qT to type %qT",
5109                  intype, type);
5110           return error_mark_node;
5111         }
5112
5113       /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5114          "B" are related class types; the reinterpret_cast does not
5115          adjust the pointer.  */
5116       if (TYPE_PTR_P (intype)
5117           && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5118                          COMPARE_BASE | COMPARE_DERIVED)))
5119         warning (0, "casting %qT to %qT does not dereference pointer",
5120                  intype, type);
5121
5122       expr = build_unary_op (ADDR_EXPR, expr, 0);
5123       if (expr != error_mark_node)
5124         expr = build_reinterpret_cast_1
5125           (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5126            valid_p);
5127       if (expr != error_mark_node)
5128         expr = build_indirect_ref (expr, 0);
5129       return expr;
5130     }
5131
5132   /* As a G++ extension, we consider conversions from member
5133      functions, and pointers to member functions to
5134      pointer-to-function and pointer-to-void types.  If
5135      -Wno-pmf-conversions has not been specified,
5136      convert_member_func_to_ptr will issue an error message.  */
5137   if ((TYPE_PTRMEMFUNC_P (intype)
5138        || TREE_CODE (intype) == METHOD_TYPE)
5139       && TYPE_PTR_P (type)
5140       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5141           || VOID_TYPE_P (TREE_TYPE (type))))
5142     return convert_member_func_to_ptr (type, expr);
5143
5144   /* If the cast is not to a reference type, the lvalue-to-rvalue,
5145      array-to-pointer, and function-to-pointer conversions are
5146      performed.  */
5147   expr = decay_conversion (expr);
5148
5149   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5150      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5151   if (TREE_CODE (expr) == NOP_EXPR
5152       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5153     expr = TREE_OPERAND (expr, 0);
5154
5155   if (error_operand_p (expr))
5156     return error_mark_node;
5157
5158   intype = TREE_TYPE (expr);
5159
5160   /* [expr.reinterpret.cast]
5161      A pointer can be converted to any integral type large enough to
5162      hold it.  */
5163   if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5164     {
5165       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5166         pedwarn ("cast from %qT to %qT loses precision",
5167                  intype, type);
5168     }
5169   /* [expr.reinterpret.cast]
5170      A value of integral or enumeration type can be explicitly
5171      converted to a pointer.  */
5172   else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5173     /* OK */
5174     ;
5175   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5176            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5177     return fold_if_not_in_template (build_nop (type, expr));
5178   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5179            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5180     {
5181       tree sexpr = expr;
5182
5183       if (!c_cast_p)
5184         check_for_casting_away_constness (intype, type, error,
5185                                           "reinterpret_cast");
5186       /* Warn about possible alignment problems.  */
5187       if (STRICT_ALIGNMENT && warn_cast_align
5188           && !VOID_TYPE_P (type)
5189           && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5190           && COMPLETE_TYPE_P (TREE_TYPE (type))
5191           && COMPLETE_TYPE_P (TREE_TYPE (intype))
5192           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5193         warning (0, "cast from %qT to %qT increases required alignment of "
5194                  "target type",
5195                  intype, type);
5196
5197       /* We need to strip nops here, because the frontend likes to
5198          create (int *)&a for array-to-pointer decay, instead of &a[0].  */
5199       STRIP_NOPS (sexpr);
5200       strict_aliasing_warning (intype, type, sexpr);
5201
5202       return fold_if_not_in_template (build_nop (type, expr));
5203     }
5204   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5205            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5206     {
5207       if (pedantic)
5208         /* Only issue a warning, as we have always supported this
5209            where possible, and it is necessary in some cases.  DR 195
5210            addresses this issue, but as of 2004/10/26 is still in
5211            drafting.  */
5212         warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5213       return fold_if_not_in_template (build_nop (type, expr));
5214     }
5215   else if (TREE_CODE (type) == VECTOR_TYPE)
5216     return fold_if_not_in_template (convert_to_vector (type, expr));
5217   else if (TREE_CODE (intype) == VECTOR_TYPE)
5218     return fold_if_not_in_template (convert_to_integer (type, expr));
5219   else
5220     {
5221       if (valid_p)
5222         *valid_p = false;
5223       error ("invalid cast from type %qT to type %qT", intype, type);
5224       return error_mark_node;
5225     }
5226
5227   return cp_convert (type, expr);
5228 }
5229
5230 tree
5231 build_reinterpret_cast (tree type, tree expr)
5232 {
5233   if (type == error_mark_node || expr == error_mark_node)
5234     return error_mark_node;
5235
5236   if (processing_template_decl)
5237     {
5238       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5239
5240       if (!TREE_SIDE_EFFECTS (t)
5241           && type_dependent_expression_p (expr))
5242         /* There might turn out to be side effects inside expr.  */
5243         TREE_SIDE_EFFECTS (t) = 1;
5244       return convert_from_reference (t);
5245     }
5246
5247   return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5248                                    /*valid_p=*/NULL);
5249 }
5250
5251 /* Perform a const_cast from EXPR to TYPE.  If the cast is valid,
5252    return an appropriate expression.  Otherwise, return
5253    error_mark_node.  If the cast is not valid, and COMPLAIN is true,
5254    then a diagnostic will be issued.  If VALID_P is non-NULL, we are
5255    performing a C-style cast, its value upon return will indicate
5256    whether or not the conversion succeeded.  */
5257
5258 static tree
5259 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5260                     bool *valid_p)
5261 {
5262   tree src_type;
5263   tree reference_type;
5264
5265   /* Callers are responsible for handling error_mark_node as a
5266      destination type.  */
5267   gcc_assert (dst_type != error_mark_node);
5268   /* In a template, callers should be building syntactic
5269      representations of casts, not using this machinery.  */
5270   gcc_assert (!processing_template_decl);
5271
5272   /* Assume the conversion is invalid.  */
5273   if (valid_p)
5274     *valid_p = false;
5275
5276   if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5277     {
5278       if (complain)
5279         error ("invalid use of const_cast with type %qT, "
5280                "which is not a pointer, "
5281                "reference, nor a pointer-to-data-member type", dst_type);
5282       return error_mark_node;
5283     }
5284
5285   if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5286     {
5287       if (complain)
5288         error ("invalid use of const_cast with type %qT, which is a pointer "
5289                "or reference to a function type", dst_type);
5290       return error_mark_node;
5291     }
5292
5293   /* Save casted types in the function's used types hash table.  */
5294   used_types_insert (dst_type);
5295
5296   src_type = TREE_TYPE (expr);
5297   /* Expressions do not really have reference types.  */
5298   if (TREE_CODE (src_type) == REFERENCE_TYPE)
5299     src_type = TREE_TYPE (src_type);
5300
5301   /* [expr.const.cast]
5302
5303      An lvalue of type T1 can be explicitly converted to an lvalue of
5304      type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5305      types) if a pointer to T1 can be explicitly converted to the type
5306      pointer to T2 using a const_cast.  */
5307   if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5308     {
5309       reference_type = dst_type;
5310       if (! real_lvalue_p (expr))
5311         {
5312           if (complain)
5313             error ("invalid const_cast of an rvalue of type %qT to type %qT",
5314                    src_type, dst_type);
5315           return error_mark_node;
5316         }
5317       dst_type = build_pointer_type (TREE_TYPE (dst_type));
5318       src_type = build_pointer_type (src_type);
5319     }
5320   else
5321     {
5322       reference_type = NULL_TREE;
5323       /* If the destination type is not a reference type, the
5324          lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5325          conversions are performed.  */
5326       src_type = type_decays_to (src_type);
5327       if (src_type == error_mark_node)
5328         return error_mark_node;
5329     }
5330
5331   if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5332       && comp_ptr_ttypes_const (dst_type, src_type))
5333     {
5334       if (valid_p)
5335         {
5336           *valid_p = true;
5337           /* This cast is actually a C-style cast.  Issue a warning if
5338              the user is making a potentially unsafe cast.  */
5339           if (warn_cast_qual)
5340             check_for_casting_away_constness (src_type, dst_type,
5341                                               warning0,
5342                                               "cast");
5343         }
5344       if (reference_type)
5345         {
5346           expr = build_unary_op (ADDR_EXPR, expr, 0);
5347           expr = build_nop (reference_type, expr);
5348           return convert_from_reference (expr);
5349         }
5350       else
5351         {
5352           expr = decay_conversion (expr);
5353           /* build_c_cast puts on a NOP_EXPR to make the result not an
5354              lvalue.  Strip such NOP_EXPRs if VALUE is being used in
5355              non-lvalue context.  */
5356           if (TREE_CODE (expr) == NOP_EXPR
5357               && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5358             expr = TREE_OPERAND (expr, 0);
5359           return build_nop (dst_type, expr);
5360         }
5361     }
5362
5363   if (complain)
5364     error ("invalid const_cast from type %qT to type %qT",
5365            src_type, dst_type);
5366   return error_mark_node;
5367 }
5368
5369 tree
5370 build_const_cast (tree type, tree expr)
5371 {
5372   if (type == error_mark_node || error_operand_p (expr))
5373     return error_mark_node;
5374
5375   if (processing_template_decl)
5376     {
5377       tree t = build_min (CONST_CAST_EXPR, type, expr);
5378
5379       if (!TREE_SIDE_EFFECTS (t)
5380           && type_dependent_expression_p (expr))
5381         /* There might turn out to be side effects inside expr.  */
5382         TREE_SIDE_EFFECTS (t) = 1;
5383       return convert_from_reference (t);
5384     }
5385
5386   return build_const_cast_1 (type, expr, /*complain=*/true,
5387                              /*valid_p=*/NULL);
5388 }
5389
5390 /* Build an expression representing an explicit C-style cast to type
5391    TYPE of expression EXPR.  */
5392
5393 tree
5394 build_c_cast (tree type, tree expr)
5395 {
5396   tree value = expr;
5397   tree result;
5398   bool valid_p;
5399
5400   if (type == error_mark_node || error_operand_p (expr))
5401     return error_mark_node;
5402
5403   if (processing_template_decl)
5404     {
5405       tree t = build_min (CAST_EXPR, type,
5406                           tree_cons (NULL_TREE, value, NULL_TREE));
5407       /* We don't know if it will or will not have side effects.  */
5408       TREE_SIDE_EFFECTS (t) = 1;
5409       return convert_from_reference (t);
5410     }
5411
5412   /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5413      'Class') should always be retained, because this information aids
5414      in method lookup.  */
5415   if (objc_is_object_ptr (type)
5416       && objc_is_object_ptr (TREE_TYPE (expr)))
5417     return build_nop (type, expr);
5418
5419   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5420      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5421   if (TREE_CODE (type) != REFERENCE_TYPE
5422       && TREE_CODE (value) == NOP_EXPR
5423       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5424     value = TREE_OPERAND (value, 0);
5425
5426   if (TREE_CODE (type) == ARRAY_TYPE)
5427     {
5428       /* Allow casting from T1* to T2[] because Cfront allows it.
5429          NIHCL uses it. It is not valid ISO C++ however.  */
5430       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5431         {
5432           pedwarn ("ISO C++ forbids casting to an array type %qT", type);
5433           type = build_pointer_type (TREE_TYPE (type));
5434         }
5435       else
5436         {
5437           error ("ISO C++ forbids casting to an array type %qT", type);
5438           return error_mark_node;
5439         }
5440     }
5441
5442   if (TREE_CODE (type) == FUNCTION_TYPE
5443       || TREE_CODE (type) == METHOD_TYPE)
5444     {
5445       error ("invalid cast to function type %qT", type);
5446       return error_mark_node;
5447     }
5448
5449   /* A C-style cast can be a const_cast.  */
5450   result = build_const_cast_1 (type, value, /*complain=*/false,
5451                                &valid_p);
5452   if (valid_p)
5453     return result;
5454
5455   /* Or a static cast.  */
5456   result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5457                                 &valid_p);
5458   /* Or a reinterpret_cast.  */
5459   if (!valid_p)
5460     result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5461                                        &valid_p);
5462   /* The static_cast or reinterpret_cast may be followed by a
5463      const_cast.  */
5464   if (valid_p
5465       /* A valid cast may result in errors if, for example, a
5466          conversion to am ambiguous base class is required.  */
5467       && !error_operand_p (result))
5468     {
5469       tree result_type;
5470
5471       /* Non-class rvalues always have cv-unqualified type.  */
5472       if (!CLASS_TYPE_P (type))
5473         type = TYPE_MAIN_VARIANT (type);
5474       result_type = TREE_TYPE (result);
5475       if (!CLASS_TYPE_P (result_type))
5476         result_type = TYPE_MAIN_VARIANT (result_type);
5477       /* If the type of RESULT does not match TYPE, perform a
5478          const_cast to make it match.  If the static_cast or
5479          reinterpret_cast succeeded, we will differ by at most
5480          cv-qualification, so the follow-on const_cast is guaranteed
5481          to succeed.  */
5482       if (!same_type_p (non_reference (type), non_reference (result_type)))
5483         {
5484           result = build_const_cast_1 (type, result, false, &valid_p);
5485           gcc_assert (valid_p);
5486         }
5487       return result;
5488     }
5489
5490   return error_mark_node;
5491 }
5492 \f
5493 /* Build an assignment expression of lvalue LHS from value RHS.
5494    MODIFYCODE is the code for a binary operator that we use
5495    to combine the old value of LHS with RHS to get the new value.
5496    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5497
5498    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5499
5500 tree
5501 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5502 {
5503   tree result;
5504   tree newrhs = rhs;
5505   tree lhstype = TREE_TYPE (lhs);
5506   tree olhstype = lhstype;
5507   tree olhs = NULL_TREE;
5508   bool plain_assign = (modifycode == NOP_EXPR);
5509
5510   /* Avoid duplicate error messages from operands that had errors.  */
5511   if (error_operand_p (lhs) || error_operand_p (rhs))
5512     return error_mark_node;
5513
5514   /* Handle control structure constructs used as "lvalues".  */
5515   switch (TREE_CODE (lhs))
5516     {
5517       /* Handle --foo = 5; as these are valid constructs in C++.  */
5518     case PREDECREMENT_EXPR:
5519     case PREINCREMENT_EXPR:
5520       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5521         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5522                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5523                       TREE_OPERAND (lhs, 1));
5524       return build2 (COMPOUND_EXPR, lhstype,
5525                      lhs,
5526                      build_modify_expr (TREE_OPERAND (lhs, 0),
5527                                         modifycode, rhs));
5528
5529       /* Handle (a, b) used as an "lvalue".  */
5530     case COMPOUND_EXPR:
5531       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5532                                   modifycode, rhs);
5533       if (newrhs == error_mark_node)
5534         return error_mark_node;
5535       return build2 (COMPOUND_EXPR, lhstype,
5536                      TREE_OPERAND (lhs, 0), newrhs);
5537
5538     case MODIFY_EXPR:
5539       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5540         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5541                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5542                       TREE_OPERAND (lhs, 1));
5543       newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5544       if (newrhs == error_mark_node)
5545         return error_mark_node;
5546       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5547
5548     case MIN_EXPR:
5549     case MAX_EXPR:
5550       /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5551          when neither operand has side-effects.  */
5552       if (!lvalue_or_else (lhs, lv_assign))
5553         return error_mark_node;
5554
5555       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5556                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5557
5558       lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5559                     build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5560                             boolean_type_node,
5561                             TREE_OPERAND (lhs, 0),
5562                             TREE_OPERAND (lhs, 1)),
5563                     TREE_OPERAND (lhs, 0),
5564                     TREE_OPERAND (lhs, 1));
5565       /* Fall through.  */
5566
5567       /* Handle (a ? b : c) used as an "lvalue".  */
5568     case COND_EXPR:
5569       {
5570         /* Produce (a ? (b = rhs) : (c = rhs))
5571            except that the RHS goes through a save-expr
5572            so the code to compute it is only emitted once.  */
5573         tree cond;
5574         tree preeval = NULL_TREE;
5575
5576         rhs = stabilize_expr (rhs, &preeval);
5577
5578         /* Check this here to avoid odd errors when trying to convert
5579            a throw to the type of the COND_EXPR.  */
5580         if (!lvalue_or_else (lhs, lv_assign))
5581           return error_mark_node;
5582
5583         cond = build_conditional_expr
5584           (TREE_OPERAND (lhs, 0),
5585            build_modify_expr (TREE_OPERAND (lhs, 1),
5586                               modifycode, rhs),
5587            build_modify_expr (TREE_OPERAND (lhs, 2),
5588                               modifycode, rhs));
5589
5590         if (cond == error_mark_node)
5591           return cond;
5592         /* Make sure the code to compute the rhs comes out
5593            before the split.  */
5594         if (preeval)
5595           cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5596         return cond;
5597       }
5598
5599     default:
5600       break;
5601     }
5602
5603   if (modifycode == INIT_EXPR)
5604     {
5605       if (TREE_CODE (rhs) == CONSTRUCTOR)
5606         {
5607           if (! same_type_p (TREE_TYPE (rhs), lhstype))
5608             /* Call convert to generate an error; see PR 11063.  */
5609             rhs = convert (lhstype, rhs);
5610           result = build2 (INIT_EXPR, lhstype, lhs, rhs);
5611           TREE_SIDE_EFFECTS (result) = 1;
5612           return result;
5613         }
5614       else if (! IS_AGGR_TYPE (lhstype))
5615         /* Do the default thing.  */;
5616       else
5617         {
5618           result = build_special_member_call (lhs, complete_ctor_identifier,
5619                                               build_tree_list (NULL_TREE, rhs),
5620                                               lhstype, LOOKUP_NORMAL);
5621           if (result == NULL_TREE)
5622             return error_mark_node;
5623           return result;
5624         }
5625     }
5626   else
5627     {
5628       lhs = require_complete_type (lhs);
5629       if (lhs == error_mark_node)
5630         return error_mark_node;
5631
5632       if (modifycode == NOP_EXPR)
5633         {
5634           /* `operator=' is not an inheritable operator.  */
5635           if (! IS_AGGR_TYPE (lhstype))
5636             /* Do the default thing.  */;
5637           else
5638             {
5639               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5640                                      lhs, rhs, make_node (NOP_EXPR),
5641                                      /*overloaded_p=*/NULL);
5642               if (result == NULL_TREE)
5643                 return error_mark_node;
5644               return result;
5645             }
5646           lhstype = olhstype;
5647         }
5648       else
5649         {
5650           /* A binary op has been requested.  Combine the old LHS
5651              value with the RHS producing the value we should actually
5652              store into the LHS.  */
5653
5654           gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
5655           lhs = stabilize_reference (lhs);
5656           newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5657           if (newrhs == error_mark_node)
5658             {
5659               error ("  in evaluation of %<%Q(%#T, %#T)%>", modifycode,
5660                      TREE_TYPE (lhs), TREE_TYPE (rhs));
5661               return error_mark_node;
5662             }
5663
5664           /* Now it looks like a plain assignment.  */
5665           modifycode = NOP_EXPR;
5666         }
5667       gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
5668       gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
5669     }
5670
5671   /* The left-hand side must be an lvalue.  */
5672   if (!lvalue_or_else (lhs, lv_assign))
5673     return error_mark_node;
5674
5675   /* Warn about modifying something that is `const'.  Don't warn if
5676      this is initialization.  */
5677   if (modifycode != INIT_EXPR
5678       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5679           /* Functions are not modifiable, even though they are
5680              lvalues.  */
5681           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5682           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5683           /* If it's an aggregate and any field is const, then it is
5684              effectively const.  */
5685           || (CLASS_TYPE_P (lhstype)
5686               && C_TYPE_FIELDS_READONLY (lhstype))))
5687     readonly_error (lhs, "assignment", 0);
5688
5689   /* If storing into a structure or union member, it has probably been
5690      given type `int'.  Compute the type that would go with the actual
5691      amount of storage the member occupies.  */
5692
5693   if (TREE_CODE (lhs) == COMPONENT_REF
5694       && (TREE_CODE (lhstype) == INTEGER_TYPE
5695           || TREE_CODE (lhstype) == REAL_TYPE
5696           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5697     {
5698       lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5699
5700       /* If storing in a field that is in actuality a short or narrower
5701          than one, we must store in the field in its actual type.  */
5702
5703       if (lhstype != TREE_TYPE (lhs))
5704         {
5705           /* Avoid warnings converting integral types back into enums for
5706              enum bit fields.  */
5707           if (TREE_CODE (lhstype) == INTEGER_TYPE
5708               && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5709             {
5710               if (TREE_SIDE_EFFECTS (lhs))
5711                 lhs = stabilize_reference (lhs);
5712               olhs = lhs;
5713             }
5714           lhs = copy_node (lhs);
5715           TREE_TYPE (lhs) = lhstype;
5716         }
5717     }
5718
5719   /* Convert new value to destination type.  */
5720
5721   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5722     {
5723       int from_array;
5724
5725       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5726                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5727         {
5728           error ("incompatible types in assignment of %qT to %qT",
5729                  TREE_TYPE (rhs), lhstype);
5730           return error_mark_node;
5731         }
5732
5733       /* Allow array assignment in compiler-generated code.  */
5734       if (! DECL_ARTIFICIAL (current_function_decl))
5735         {
5736           /* This routine is used for both initialization and assignment.
5737              Make sure the diagnostic message differentiates the context.  */
5738           if (modifycode == INIT_EXPR)
5739             error ("array used as initializer");
5740           else
5741             error ("invalid array assignment");
5742           return error_mark_node;
5743         }
5744
5745       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5746                    ? 1 + (modifycode != INIT_EXPR): 0;
5747       return build_vec_init (lhs, NULL_TREE, newrhs,
5748                              /*explicit_default_init_p=*/false,
5749                              from_array);
5750     }
5751
5752   if (modifycode == INIT_EXPR)
5753     newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5754                                          "initialization", NULL_TREE, 0);
5755   else
5756     {
5757       /* Avoid warnings on enum bit fields.  */
5758       if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5759           && TREE_CODE (lhstype) == INTEGER_TYPE)
5760         {
5761           newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5762                                            NULL_TREE, 0);
5763           newrhs = convert_force (lhstype, newrhs, 0);
5764         }
5765       else
5766         newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5767                                          NULL_TREE, 0);
5768       if (TREE_CODE (newrhs) == CALL_EXPR
5769           && TYPE_NEEDS_CONSTRUCTING (lhstype))
5770         newrhs = build_cplus_new (lhstype, newrhs);
5771
5772       /* Can't initialize directly from a TARGET_EXPR, since that would
5773          cause the lhs to be constructed twice, and possibly result in
5774          accidental self-initialization.  So we force the TARGET_EXPR to be
5775          expanded without a target.  */
5776       if (TREE_CODE (newrhs) == TARGET_EXPR)
5777         newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5778                          TREE_OPERAND (newrhs, 0));
5779     }
5780
5781   if (newrhs == error_mark_node)
5782     return error_mark_node;
5783
5784   if (c_dialect_objc () && flag_objc_gc)
5785     {
5786       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
5787
5788       if (result)
5789         return result;
5790     }
5791
5792   result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5793                    lhstype, lhs, newrhs);
5794
5795   TREE_SIDE_EFFECTS (result) = 1;
5796   if (!plain_assign)
5797     TREE_NO_WARNING (result) = 1;
5798
5799   /* If we got the LHS in a different type for storing in,
5800      convert the result back to the nominal type of LHS
5801      so that the value we return always has the same type
5802      as the LHS argument.  */
5803
5804   if (olhstype == TREE_TYPE (result))
5805     return result;
5806   if (olhs)
5807     {
5808       result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
5809       TREE_NO_WARNING (result) = 1;
5810       return result;
5811     }
5812   return convert_for_assignment (olhstype, result, "assignment",
5813                                  NULL_TREE, 0);
5814 }
5815
5816 tree
5817 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5818 {
5819   if (processing_template_decl)
5820     return build_min_nt (MODOP_EXPR, lhs,
5821                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5822
5823   if (modifycode != NOP_EXPR)
5824     {
5825       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5826                                 make_node (modifycode),
5827                                 /*overloaded_p=*/NULL);
5828       if (rval)
5829         {
5830           TREE_NO_WARNING (rval) = 1;
5831           return rval;
5832         }
5833     }
5834   return build_modify_expr (lhs, modifycode, rhs);
5835 }
5836
5837 \f
5838 /* Get difference in deltas for different pointer to member function
5839    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
5840    the conversion is invalid, the constant is zero.  If
5841    ALLOW_INVERSE_P is true, then allow reverse conversions as well.
5842    If C_CAST_P is true this conversion is taking place as part of a
5843    C-style cast.
5844
5845    Note that the naming of FROM and TO is kind of backwards; the return
5846    value is what we add to a TO in order to get a FROM.  They are named
5847    this way because we call this function to find out how to convert from
5848    a pointer to member of FROM to a pointer to member of TO.  */
5849
5850 static tree
5851 get_delta_difference (tree from, tree to,
5852                       bool allow_inverse_p,
5853                       bool c_cast_p)
5854 {
5855   tree binfo;
5856   base_kind kind;
5857   tree result;
5858
5859   /* Assume no conversion is required.  */
5860   result = integer_zero_node;
5861   binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
5862   if (kind == bk_inaccessible || kind == bk_ambig)
5863     error ("   in pointer to member function conversion");
5864   else if (binfo)
5865     {
5866       if (kind != bk_via_virtual)
5867         result = BINFO_OFFSET (binfo);
5868       else
5869         {
5870           tree virt_binfo = binfo_from_vbase (binfo);
5871
5872           /* This is a reinterpret cast, we choose to do nothing.  */
5873           if (allow_inverse_p)
5874             warning (0, "pointer to member cast via virtual base %qT",
5875                      BINFO_TYPE (virt_binfo));
5876           else
5877             error ("pointer to member conversion via virtual base %qT",
5878                    BINFO_TYPE (virt_binfo));
5879         }
5880     }
5881   else if (same_type_ignoring_top_level_qualifiers_p (from, to))
5882     /* Pointer to member of incomplete class is permitted*/;
5883   else if (!allow_inverse_p)
5884     {
5885       error_not_base_type (from, to);
5886       error ("   in pointer to member conversion");
5887     }
5888   else
5889     {
5890       binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind);
5891       if (binfo)
5892         {
5893           if (kind != bk_via_virtual)
5894             result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
5895           else
5896             {
5897               /* This is a reinterpret cast, we choose to do nothing.  */
5898               tree virt_binfo = binfo_from_vbase (binfo);
5899
5900               warning (0, "pointer to member cast via virtual base %qT",
5901                        BINFO_TYPE (virt_binfo));
5902             }
5903         }
5904     }
5905
5906   return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
5907                                                       result));
5908 }
5909
5910 /* Return a constructor for the pointer-to-member-function TYPE using
5911    the other components as specified.  */
5912
5913 tree
5914 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5915 {
5916   tree u = NULL_TREE;
5917   tree delta_field;
5918   tree pfn_field;
5919   VEC(constructor_elt, gc) *v;
5920
5921   /* Pull the FIELD_DECLs out of the type.  */
5922   pfn_field = TYPE_FIELDS (type);
5923   delta_field = TREE_CHAIN (pfn_field);
5924
5925   /* Make sure DELTA has the type we want.  */
5926   delta = convert_and_check (delta_type_node, delta);
5927
5928   /* Finish creating the initializer.  */
5929   v = VEC_alloc(constructor_elt, gc, 2);
5930   CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
5931   CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
5932   u = build_constructor (type, v);
5933   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
5934   TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta);
5935   TREE_STATIC (u) = (TREE_CONSTANT (u)
5936                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5937                          != NULL_TREE)
5938                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5939                          != NULL_TREE));
5940   return u;
5941 }
5942
5943 /* Build a constructor for a pointer to member function.  It can be
5944    used to initialize global variables, local variable, or used
5945    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
5946    want to be.
5947
5948    If FORCE is nonzero, then force this conversion, even if
5949    we would rather not do it.  Usually set when using an explicit
5950    cast.  A C-style cast is being processed iff C_CAST_P is true.
5951
5952    Return error_mark_node, if something goes wrong.  */
5953
5954 tree
5955 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
5956 {
5957   tree fn;
5958   tree pfn_type;
5959   tree to_type;
5960
5961   if (error_operand_p (pfn))
5962     return error_mark_node;
5963
5964   pfn_type = TREE_TYPE (pfn);
5965   to_type = build_ptrmemfunc_type (type);
5966
5967   /* Handle multiple conversions of pointer to member functions.  */
5968   if (TYPE_PTRMEMFUNC_P (pfn_type))
5969     {
5970       tree delta = NULL_TREE;
5971       tree npfn = NULL_TREE;
5972       tree n;
5973
5974       if (!force
5975           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
5976         error ("invalid conversion to type %qT from type %qT",
5977                to_type, pfn_type);
5978
5979       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5980                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5981                                 force,
5982                                 c_cast_p);
5983
5984       /* We don't have to do any conversion to convert a
5985          pointer-to-member to its own type.  But, we don't want to
5986          just return a PTRMEM_CST if there's an explicit cast; that
5987          cast should make the expression an invalid template argument.  */
5988       if (TREE_CODE (pfn) != PTRMEM_CST)
5989         {
5990           if (same_type_p (to_type, pfn_type))
5991             return pfn;
5992           else if (integer_zerop (n))
5993             return build_reinterpret_cast (to_type, pfn);
5994         }
5995
5996       if (TREE_SIDE_EFFECTS (pfn))
5997         pfn = save_expr (pfn);
5998
5999       /* Obtain the function pointer and the current DELTA.  */
6000       if (TREE_CODE (pfn) == PTRMEM_CST)
6001         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6002       else
6003         {
6004           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6005           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6006         }
6007
6008       /* Just adjust the DELTA field.  */
6009       gcc_assert  (same_type_ignoring_top_level_qualifiers_p
6010                    (TREE_TYPE (delta), ptrdiff_type_node));
6011       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6012         n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
6013       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
6014       return build_ptrmemfunc1 (to_type, delta, npfn);
6015     }
6016
6017   /* Handle null pointer to member function conversions.  */
6018   if (integer_zerop (pfn))
6019     {
6020       pfn = build_c_cast (type, integer_zero_node);
6021       return build_ptrmemfunc1 (to_type,
6022                                 integer_zero_node,
6023                                 pfn);
6024     }
6025
6026   if (type_unknown_p (pfn))
6027     return instantiate_type (type, pfn, tf_warning_or_error);
6028
6029   fn = TREE_OPERAND (pfn, 0);
6030   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6031               /* In a template, we will have preserved the
6032                  OFFSET_REF.  */
6033               || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6034   return make_ptrmem_cst (to_type, fn);
6035 }
6036
6037 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6038    given by CST.
6039
6040    ??? There is no consistency as to the types returned for the above
6041    values.  Some code acts as if it were a sizetype and some as if it were
6042    integer_type_node.  */
6043
6044 void
6045 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6046 {
6047   tree type = TREE_TYPE (cst);
6048   tree fn = PTRMEM_CST_MEMBER (cst);
6049   tree ptr_class, fn_class;
6050
6051   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6052
6053   /* The class that the function belongs to.  */
6054   fn_class = DECL_CONTEXT (fn);
6055
6056   /* The class that we're creating a pointer to member of.  */
6057   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6058
6059   /* First, calculate the adjustment to the function's class.  */
6060   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6061                                  /*c_cast_p=*/0);
6062
6063   if (!DECL_VIRTUAL_P (fn))
6064     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6065   else
6066     {
6067       /* If we're dealing with a virtual function, we have to adjust 'this'
6068          again, to point to the base which provides the vtable entry for
6069          fn; the call will do the opposite adjustment.  */
6070       tree orig_class = DECL_CONTEXT (fn);
6071       tree binfo = binfo_or_else (orig_class, fn_class);
6072       *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6073                        *delta, BINFO_OFFSET (binfo));
6074       *delta = fold_if_not_in_template (*delta);
6075
6076       /* We set PFN to the vtable offset at which the function can be
6077          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6078          case delta is shifted left, and then incremented).  */
6079       *pfn = DECL_VINDEX (fn);
6080       *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6081                      TYPE_SIZE_UNIT (vtable_entry_type));
6082       *pfn = fold_if_not_in_template (*pfn);
6083
6084       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6085         {
6086         case ptrmemfunc_vbit_in_pfn:
6087           *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6088                          integer_one_node);
6089           *pfn = fold_if_not_in_template (*pfn);
6090           break;
6091
6092         case ptrmemfunc_vbit_in_delta:
6093           *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6094                            *delta, integer_one_node);
6095           *delta = fold_if_not_in_template (*delta);
6096           *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6097                            *delta, integer_one_node);
6098           *delta = fold_if_not_in_template (*delta);
6099           break;
6100
6101         default:
6102           gcc_unreachable ();
6103         }
6104
6105       *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6106       *pfn = fold_if_not_in_template (*pfn);
6107     }
6108 }
6109
6110 /* Return an expression for PFN from the pointer-to-member function
6111    given by T.  */
6112
6113 static tree
6114 pfn_from_ptrmemfunc (tree t)
6115 {
6116   if (TREE_CODE (t) == PTRMEM_CST)
6117     {
6118       tree delta;
6119       tree pfn;
6120
6121       expand_ptrmemfunc_cst (t, &delta, &pfn);
6122       if (pfn)
6123         return pfn;
6124     }
6125
6126   return build_ptrmemfunc_access_expr (t, pfn_identifier);
6127 }
6128
6129 /* Convert value RHS to type TYPE as preparation for an assignment to
6130    an lvalue of type TYPE.  ERRTYPE is a string to use in error
6131    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
6132    are doing the conversion in order to pass the PARMNUMth argument of
6133    FNDECL.  */
6134
6135 static tree
6136 convert_for_assignment (tree type, tree rhs,
6137                         const char *errtype, tree fndecl, int parmnum)
6138 {
6139   tree rhstype;
6140   enum tree_code coder;
6141
6142   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
6143   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6144     rhs = TREE_OPERAND (rhs, 0);
6145
6146   rhstype = TREE_TYPE (rhs);
6147   coder = TREE_CODE (rhstype);
6148
6149   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6150       && vector_types_convertible_p (type, rhstype))
6151     return convert (type, rhs);
6152
6153   if (rhs == error_mark_node || rhstype == error_mark_node)
6154     return error_mark_node;
6155   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6156     return error_mark_node;
6157
6158   /* The RHS of an assignment cannot have void type.  */
6159   if (coder == VOID_TYPE)
6160     {
6161       error ("void value not ignored as it ought to be");
6162       return error_mark_node;
6163     }
6164
6165   /* Simplify the RHS if possible.  */
6166   if (TREE_CODE (rhs) == CONST_DECL)
6167     rhs = DECL_INITIAL (rhs);
6168
6169   if (c_dialect_objc ())
6170     {
6171       int parmno;
6172       tree rname = fndecl;
6173
6174       if (!strcmp (errtype, "assignment"))
6175         parmno = -1;
6176       else if (!strcmp (errtype, "initialization"))
6177         parmno = -2;
6178       else
6179         {
6180           tree selector = objc_message_selector ();
6181
6182           parmno = parmnum;
6183
6184           if (selector && parmno > 1)
6185             {
6186               rname = selector;
6187               parmno -= 1;
6188             }
6189         }
6190
6191       if (objc_compare_types (type, rhstype, parmno, rname))
6192         return convert (type, rhs);
6193     }
6194
6195   /* [expr.ass]
6196
6197      The expression is implicitly converted (clause _conv_) to the
6198      cv-unqualified type of the left operand.
6199
6200      We allow bad conversions here because by the time we get to this point
6201      we are committed to doing the conversion.  If we end up doing a bad
6202      conversion, convert_like will complain.  */
6203   if (!can_convert_arg_bad (type, rhstype, rhs))
6204     {
6205       /* When -Wno-pmf-conversions is use, we just silently allow
6206          conversions from pointers-to-members to plain pointers.  If
6207          the conversion doesn't work, cp_convert will complain.  */
6208       if (!warn_pmf2ptr
6209           && TYPE_PTR_P (type)
6210           && TYPE_PTRMEMFUNC_P (rhstype))
6211         rhs = cp_convert (strip_top_quals (type), rhs);
6212       else
6213         {
6214           /* If the right-hand side has unknown type, then it is an
6215              overloaded function.  Call instantiate_type to get error
6216              messages.  */
6217           if (rhstype == unknown_type_node)
6218             instantiate_type (type, rhs, tf_warning_or_error);
6219           else if (fndecl)
6220             error ("cannot convert %qT to %qT for argument %qP to %qD",
6221                    rhstype, type, parmnum, fndecl);
6222           else
6223             error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
6224           return error_mark_node;
6225         }
6226     }
6227   if (warn_missing_format_attribute)
6228     {
6229       const enum tree_code codel = TREE_CODE (type);
6230       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6231           && coder == codel
6232           && check_missing_format_attribute (type, rhstype))
6233         warning (OPT_Wmissing_format_attribute,
6234                  "%s might be a candidate for a format attribute",
6235                  errtype);
6236     }
6237
6238   return perform_implicit_conversion (strip_top_quals (type), rhs);
6239 }
6240
6241 /* Convert RHS to be of type TYPE.
6242    If EXP is nonzero, it is the target of the initialization.
6243    ERRTYPE is a string to use in error messages.
6244
6245    Two major differences between the behavior of
6246    `convert_for_assignment' and `convert_for_initialization'
6247    are that references are bashed in the former, while
6248    copied in the latter, and aggregates are assigned in
6249    the former (operator=) while initialized in the
6250    latter (X(X&)).
6251
6252    If using constructor make sure no conversion operator exists, if one does
6253    exist, an ambiguity exists.
6254
6255    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
6256
6257 tree
6258 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
6259                             const char *errtype, tree fndecl, int parmnum)
6260 {
6261   enum tree_code codel = TREE_CODE (type);
6262   tree rhstype;
6263   enum tree_code coder;
6264
6265   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6266      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
6267   if (TREE_CODE (rhs) == NOP_EXPR
6268       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6269       && codel != REFERENCE_TYPE)
6270     rhs = TREE_OPERAND (rhs, 0);
6271
6272   if (type == error_mark_node
6273       || rhs == error_mark_node
6274       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6275     return error_mark_node;
6276
6277   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6278        && TREE_CODE (type) != ARRAY_TYPE
6279        && (TREE_CODE (type) != REFERENCE_TYPE
6280            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6281       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6282           && (TREE_CODE (type) != REFERENCE_TYPE
6283               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6284       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6285     rhs = decay_conversion (rhs);
6286
6287   rhstype = TREE_TYPE (rhs);
6288   coder = TREE_CODE (rhstype);
6289
6290   if (coder == ERROR_MARK)
6291     return error_mark_node;
6292
6293   /* We accept references to incomplete types, so we can
6294      return here before checking if RHS is of complete type.  */
6295
6296   if (codel == REFERENCE_TYPE)
6297     {
6298       /* This should eventually happen in convert_arguments.  */
6299       int savew = 0, savee = 0;
6300
6301       if (fndecl)
6302         savew = warningcount, savee = errorcount;
6303       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
6304                                   /*cleanup=*/NULL);
6305       if (fndecl)
6306         {
6307           if (warningcount > savew)
6308             warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
6309           else if (errorcount > savee)
6310             error ("in passing argument %P of %q+D", parmnum, fndecl);
6311         }
6312       return rhs;
6313     }
6314
6315   if (exp != 0)
6316     exp = require_complete_type (exp);
6317   if (exp == error_mark_node)
6318     return error_mark_node;
6319
6320   rhstype = non_reference (rhstype);
6321
6322   type = complete_type (type);
6323
6324   if (IS_AGGR_TYPE (type))
6325     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6326
6327   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
6328 }
6329 \f
6330 /* If RETVAL is the address of, or a reference to, a local variable or
6331    temporary give an appropriate warning.  */
6332
6333 static void
6334 maybe_warn_about_returning_address_of_local (tree retval)
6335 {
6336   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6337   tree whats_returned = retval;
6338
6339   for (;;)
6340     {
6341       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6342         whats_returned = TREE_OPERAND (whats_returned, 1);
6343       else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6344                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6345                || TREE_CODE (whats_returned) == NOP_EXPR)
6346         whats_returned = TREE_OPERAND (whats_returned, 0);
6347       else
6348         break;
6349     }
6350
6351   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6352     return;
6353   whats_returned = TREE_OPERAND (whats_returned, 0);
6354
6355   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6356     {
6357       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6358           || TREE_CODE (whats_returned) == TARGET_EXPR)
6359         {
6360           warning (0, "returning reference to temporary");
6361           return;
6362         }
6363       if (TREE_CODE (whats_returned) == VAR_DECL
6364           && DECL_NAME (whats_returned)
6365           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6366         {
6367           warning (0, "reference to non-lvalue returned");
6368           return;
6369         }
6370     }
6371
6372   while (TREE_CODE (whats_returned) == COMPONENT_REF
6373          || TREE_CODE (whats_returned) == ARRAY_REF)
6374     whats_returned = TREE_OPERAND (whats_returned, 0);
6375
6376   if (DECL_P (whats_returned)
6377       && DECL_NAME (whats_returned)
6378       && DECL_FUNCTION_SCOPE_P (whats_returned)
6379       && !(TREE_STATIC (whats_returned)
6380            || TREE_PUBLIC (whats_returned)))
6381     {
6382       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6383         warning (0, "reference to local variable %q+D returned",
6384                  whats_returned);
6385       else
6386         warning (0, "address of local variable %q+D returned",
6387                  whats_returned);
6388       return;
6389     }
6390 }
6391
6392 /* Check that returning RETVAL from the current function is valid.
6393    Return an expression explicitly showing all conversions required to
6394    change RETVAL into the function return type, and to assign it to
6395    the DECL_RESULT for the function.  Set *NO_WARNING to true if
6396    code reaches end of non-void function warning shouldn't be issued
6397    on this RETURN_EXPR.  */
6398
6399 tree
6400 check_return_expr (tree retval, bool *no_warning)
6401 {
6402   tree result;
6403   /* The type actually returned by the function, after any
6404      promotions.  */
6405   tree valtype;
6406   int fn_returns_value_p;
6407
6408   *no_warning = false;
6409
6410   /* A `volatile' function is one that isn't supposed to return, ever.
6411      (This is a G++ extension, used to get better code for functions
6412      that call the `volatile' function.)  */
6413   if (TREE_THIS_VOLATILE (current_function_decl))
6414     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6415
6416   /* Check for various simple errors.  */
6417   if (DECL_DESTRUCTOR_P (current_function_decl))
6418     {
6419       if (retval)
6420         error ("returning a value from a destructor");
6421       return NULL_TREE;
6422     }
6423   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6424     {
6425       if (in_function_try_handler)
6426         /* If a return statement appears in a handler of the
6427            function-try-block of a constructor, the program is ill-formed.  */
6428         error ("cannot return from a handler of a function-try-block of a constructor");
6429       else if (retval)
6430         /* You can't return a value from a constructor.  */
6431         error ("returning a value from a constructor");
6432       return NULL_TREE;
6433     }
6434
6435   if (processing_template_decl)
6436     {
6437       current_function_returns_value = 1;
6438       return retval;
6439     }
6440
6441   /* When no explicit return-value is given in a function with a named
6442      return value, the named return value is used.  */
6443   result = DECL_RESULT (current_function_decl);
6444   valtype = TREE_TYPE (result);
6445   gcc_assert (valtype != NULL_TREE);
6446   fn_returns_value_p = !VOID_TYPE_P (valtype);
6447   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6448     retval = result;
6449
6450   /* Check for a return statement with no return value in a function
6451      that's supposed to return a value.  */
6452   if (!retval && fn_returns_value_p)
6453     {
6454       pedwarn ("return-statement with no value, in function returning %qT",
6455                valtype);
6456       /* Clear this, so finish_function won't say that we reach the
6457          end of a non-void function (which we don't, we gave a
6458          return!).  */
6459       current_function_returns_null = 0;
6460       /* And signal caller that TREE_NO_WARNING should be set on the
6461          RETURN_EXPR to avoid control reaches end of non-void function
6462          warnings in tree-cfg.c.  */
6463       *no_warning = true;
6464     }
6465   /* Check for a return statement with a value in a function that
6466      isn't supposed to return a value.  */
6467   else if (retval && !fn_returns_value_p)
6468     {
6469       if (VOID_TYPE_P (TREE_TYPE (retval)))
6470         /* You can return a `void' value from a function of `void'
6471            type.  In that case, we have to evaluate the expression for
6472            its side-effects.  */
6473           finish_expr_stmt (retval);
6474       else
6475         pedwarn ("return-statement with a value, in function "
6476                  "returning 'void'");
6477
6478       current_function_returns_null = 1;
6479
6480       /* There's really no value to return, after all.  */
6481       return NULL_TREE;
6482     }
6483   else if (!retval)
6484     /* Remember that this function can sometimes return without a
6485        value.  */
6486     current_function_returns_null = 1;
6487   else
6488     /* Remember that this function did return a value.  */
6489     current_function_returns_value = 1;
6490
6491   /* Check for erroneous operands -- but after giving ourselves a
6492      chance to provide an error about returning a value from a void
6493      function.  */
6494   if (error_operand_p (retval))
6495     {
6496       current_function_return_value = error_mark_node;
6497       return error_mark_node;
6498     }
6499
6500   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6501   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6502        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6503       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6504       && ! flag_check_new
6505       && null_ptr_cst_p (retval))
6506     warning (0, "%<operator new%> must not return NULL unless it is "
6507              "declared %<throw()%> (or -fcheck-new is in effect)");
6508
6509   /* Effective C++ rule 15.  See also start_function.  */
6510   if (warn_ecpp
6511       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6512     {
6513       bool warn = true;
6514
6515       /* The function return type must be a reference to the current
6516         class.  */
6517       if (TREE_CODE (valtype) == REFERENCE_TYPE
6518           && same_type_ignoring_top_level_qualifiers_p
6519               (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6520         {
6521           /* Returning '*this' is obviously OK.  */
6522           if (retval == current_class_ref)
6523             warn = false;
6524           /* If we are calling a function whose return type is the same of
6525              the current class reference, it is ok.  */
6526           else if (TREE_CODE (retval) == INDIRECT_REF
6527                    && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6528             warn = false;
6529         }
6530
6531       if (warn)
6532         warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
6533     }
6534
6535   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6536
6537      [...]      For  a function with a class return type, if the expression
6538      in the return statement is the name of a local  object,  and  the  cv-
6539      unqualified  type  of  the  local  object  is the same as the function
6540      return type, an implementation is permitted to omit creating the  tem-
6541      porary  object  to  hold  the function return value [...]
6542
6543      So, if this is a value-returning function that always returns the same
6544      local variable, remember it.
6545
6546      It might be nice to be more flexible, and choose the first suitable
6547      variable even if the function sometimes returns something else, but
6548      then we run the risk of clobbering the variable we chose if the other
6549      returned expression uses the chosen variable somehow.  And people expect
6550      this restriction, anyway.  (jason 2000-11-19)
6551
6552      See finish_function and finalize_nrv for the rest of this optimization.  */
6553
6554   if (fn_returns_value_p && flag_elide_constructors)
6555     {
6556       if (retval != NULL_TREE
6557           && (current_function_return_value == NULL_TREE
6558               || current_function_return_value == retval)
6559           && TREE_CODE (retval) == VAR_DECL
6560           && DECL_CONTEXT (retval) == current_function_decl
6561           && ! TREE_STATIC (retval)
6562           && (DECL_ALIGN (retval)
6563               >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6564           && same_type_p ((TYPE_MAIN_VARIANT
6565                            (TREE_TYPE (retval))),
6566                           (TYPE_MAIN_VARIANT
6567                            (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6568         current_function_return_value = retval;
6569       else
6570         current_function_return_value = error_mark_node;
6571     }
6572
6573   /* We don't need to do any conversions when there's nothing being
6574      returned.  */
6575   if (!retval)
6576     return NULL_TREE;
6577
6578   /* Do any required conversions.  */
6579   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6580     /* No conversions are required.  */
6581     ;
6582   else
6583     {
6584       /* The type the function is declared to return.  */
6585       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6586
6587       /* The functype's return type will have been set to void, if it
6588          was an incomplete type.  Just treat this as 'return;' */
6589       if (VOID_TYPE_P (functype))
6590         return error_mark_node;
6591
6592       /* First convert the value to the function's return type, then
6593          to the type of return value's location to handle the
6594          case that functype is smaller than the valtype.  */
6595       retval = convert_for_initialization
6596         (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6597          "return", NULL_TREE, 0);
6598       retval = convert (valtype, retval);
6599
6600       /* If the conversion failed, treat this just like `return;'.  */
6601       if (retval == error_mark_node)
6602         return retval;
6603       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6604       else if (! current_function_returns_struct
6605                && TREE_CODE (retval) == TARGET_EXPR
6606                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6607         retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6608                          TREE_OPERAND (retval, 0));
6609       else
6610         maybe_warn_about_returning_address_of_local (retval);
6611     }
6612
6613   /* Actually copy the value returned into the appropriate location.  */
6614   if (retval && retval != result)
6615     retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
6616
6617   return retval;
6618 }
6619
6620 \f
6621 /* Returns nonzero if the pointer-type FROM can be converted to the
6622    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6623    then we return nonzero if the pointers are similar, and the
6624    cv-qualification signature of FROM is a proper subset of that of TO.
6625
6626    If CONSTP is positive, then all outer pointers have been
6627    const-qualified.  */
6628
6629 static int
6630 comp_ptr_ttypes_real (tree to, tree from, int constp)
6631 {
6632   bool to_more_cv_qualified = false;
6633
6634   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6635     {
6636       if (TREE_CODE (to) != TREE_CODE (from))
6637         return 0;
6638
6639       if (TREE_CODE (from) == OFFSET_TYPE
6640           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6641                            TYPE_OFFSET_BASETYPE (to)))
6642         return 0;
6643
6644       /* Const and volatile mean something different for function types,
6645          so the usual checks are not appropriate.  */
6646       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6647         {
6648           /* In Objective-C++, some types may have been 'volatilized' by
6649              the compiler for EH; when comparing them here, the volatile
6650              qualification must be ignored.  */
6651           bool objc_quals_match = objc_type_quals_match (to, from);
6652
6653           if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
6654             return 0;
6655
6656           if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
6657             {
6658               if (constp == 0)
6659                 return 0;
6660               to_more_cv_qualified = true;
6661             }
6662
6663           if (constp > 0)
6664             constp &= TYPE_READONLY (to);
6665         }
6666
6667       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6668         return ((constp >= 0 || to_more_cv_qualified)
6669                 && same_type_ignoring_top_level_qualifiers_p (to, from));
6670     }
6671 }
6672
6673 /* When comparing, say, char ** to char const **, this function takes
6674    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
6675    types to this function.  */
6676
6677 int
6678 comp_ptr_ttypes (tree to, tree from)
6679 {
6680   return comp_ptr_ttypes_real (to, from, 1);
6681 }
6682
6683 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6684    type or inheritance-related types, regardless of cv-quals.  */
6685
6686 int
6687 ptr_reasonably_similar (tree to, tree from)
6688 {
6689   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6690     {
6691       /* Any target type is similar enough to void.  */
6692       if (TREE_CODE (to) == VOID_TYPE
6693           || TREE_CODE (from) == VOID_TYPE)
6694         return 1;
6695
6696       if (TREE_CODE (to) != TREE_CODE (from))
6697         return 0;
6698
6699       if (TREE_CODE (from) == OFFSET_TYPE
6700           && comptypes (TYPE_OFFSET_BASETYPE (to),
6701                         TYPE_OFFSET_BASETYPE (from),
6702                         COMPARE_BASE | COMPARE_DERIVED))
6703         continue;
6704
6705       if (TREE_CODE (to) == VECTOR_TYPE
6706           && vector_types_convertible_p (to, from))
6707         return 1;
6708
6709       if (TREE_CODE (to) == INTEGER_TYPE
6710           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6711         return 1;
6712
6713       if (TREE_CODE (to) == FUNCTION_TYPE)
6714         return 1;
6715
6716       if (TREE_CODE (to) != POINTER_TYPE)
6717         return comptypes
6718           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6719            COMPARE_BASE | COMPARE_DERIVED);
6720     }
6721 }
6722
6723 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
6724    pointer-to-member types) are the same, ignoring cv-qualification at
6725    all levels.  */
6726
6727 bool
6728 comp_ptr_ttypes_const (tree to, tree from)
6729 {
6730   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6731     {
6732       if (TREE_CODE (to) != TREE_CODE (from))
6733         return false;
6734
6735       if (TREE_CODE (from) == OFFSET_TYPE
6736           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6737                           TYPE_OFFSET_BASETYPE (to)))
6738           continue;
6739
6740       if (TREE_CODE (to) != POINTER_TYPE)
6741         return same_type_ignoring_top_level_qualifiers_p (to, from);
6742     }
6743 }
6744
6745 /* Returns the type qualifiers for this type, including the qualifiers on the
6746    elements for an array type.  */
6747
6748 int
6749 cp_type_quals (tree type)
6750 {
6751   type = strip_array_types (type);
6752   if (type == error_mark_node)
6753     return TYPE_UNQUALIFIED;
6754   return TYPE_QUALS (type);
6755 }
6756
6757 /* Returns nonzero if the TYPE contains a mutable member.  */
6758
6759 bool
6760 cp_has_mutable_p (tree type)
6761 {
6762   type = strip_array_types (type);
6763
6764   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6765 }
6766
6767 /* Apply the TYPE_QUALS to the new DECL.  */
6768 void
6769 cp_apply_type_quals_to_decl (int type_quals, tree decl)
6770 {
6771   tree type = TREE_TYPE (decl);
6772
6773   if (type == error_mark_node)
6774     return;
6775
6776   if (TREE_CODE (type) == FUNCTION_TYPE
6777       && type_quals != TYPE_UNQUALIFIED)
6778     {
6779       /* This was an error in C++98 (cv-qualifiers cannot be added to
6780          a function type), but DR 295 makes the code well-formed by
6781          dropping the extra qualifiers. */
6782       if (pedantic)
6783         {
6784           tree bad_type = build_qualified_type (type, type_quals);
6785           pedwarn ("ignoring %qV qualifiers added to function type %qT",
6786                    bad_type, type);
6787         }
6788
6789       TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
6790       return;
6791     }
6792
6793   /* Avoid setting TREE_READONLY incorrectly.  */
6794   if (/* If the object has a constructor, the constructor may modify
6795          the object.  */
6796       TYPE_NEEDS_CONSTRUCTING (type)
6797       /* If the type isn't complete, we don't know yet if it will need
6798          constructing.  */
6799       || !COMPLETE_TYPE_P (type)
6800       /* If the type has a mutable component, that component might be
6801          modified.  */
6802       || TYPE_HAS_MUTABLE_P (type))
6803     type_quals &= ~TYPE_QUAL_CONST;
6804
6805   c_apply_type_quals_to_decl (type_quals, decl);
6806 }
6807
6808 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
6809    exemplar types such that casting T1 to T2 is casting away constness
6810    if and only if there is no implicit conversion from T1 to T2.  */
6811
6812 static void
6813 casts_away_constness_r (tree *t1, tree *t2)
6814 {
6815   int quals1;
6816   int quals2;
6817
6818   /* [expr.const.cast]
6819
6820      For multi-level pointer to members and multi-level mixed pointers
6821      and pointers to members (conv.qual), the "member" aspect of a
6822      pointer to member level is ignored when determining if a const
6823      cv-qualifier has been cast away.  */
6824   /* [expr.const.cast]
6825
6826      For  two  pointer types:
6827
6828             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
6829             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
6830             K is min(N,M)
6831
6832      casting from X1 to X2 casts away constness if, for a non-pointer
6833      type T there does not exist an implicit conversion (clause
6834      _conv_) from:
6835
6836             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6837
6838      to
6839
6840             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
6841   if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
6842       || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
6843     {
6844       *t1 = cp_build_qualified_type (void_type_node,
6845                                      cp_type_quals (*t1));
6846       *t2 = cp_build_qualified_type (void_type_node,
6847                                      cp_type_quals (*t2));
6848       return;
6849     }
6850
6851   quals1 = cp_type_quals (*t1);
6852   quals2 = cp_type_quals (*t2);
6853
6854   if (TYPE_PTRMEM_P (*t1))
6855     *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
6856   else
6857     *t1 = TREE_TYPE (*t1);
6858   if (TYPE_PTRMEM_P (*t2))
6859     *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
6860   else
6861     *t2 = TREE_TYPE (*t2);
6862
6863   casts_away_constness_r (t1, t2);
6864   *t1 = build_pointer_type (*t1);
6865   *t2 = build_pointer_type (*t2);
6866   *t1 = cp_build_qualified_type (*t1, quals1);
6867   *t2 = cp_build_qualified_type (*t2, quals2);
6868 }
6869
6870 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6871    constness.  */
6872
6873 static bool
6874 casts_away_constness (tree t1, tree t2)
6875 {
6876   if (TREE_CODE (t2) == REFERENCE_TYPE)
6877     {
6878       /* [expr.const.cast]
6879
6880          Casting from an lvalue of type T1 to an lvalue of type T2
6881          using a reference cast casts away constness if a cast from an
6882          rvalue of type "pointer to T1" to the type "pointer to T2"
6883          casts away constness.  */
6884       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6885       return casts_away_constness (build_pointer_type (t1),
6886                                    build_pointer_type (TREE_TYPE (t2)));
6887     }
6888
6889   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6890     /* [expr.const.cast]
6891
6892        Casting from an rvalue of type "pointer to data member of X
6893        of type T1" to the type "pointer to data member of Y of type
6894        T2" casts away constness if a cast from an rvalue of type
6895        "pointer to T1" to the type "pointer to T2" casts away
6896        constness.  */
6897     return casts_away_constness
6898       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6899        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6900
6901   /* Casting away constness is only something that makes sense for
6902      pointer or reference types.  */
6903   if (TREE_CODE (t1) != POINTER_TYPE
6904       || TREE_CODE (t2) != POINTER_TYPE)
6905     return false;
6906
6907   /* Top-level qualifiers don't matter.  */
6908   t1 = TYPE_MAIN_VARIANT (t1);
6909   t2 = TYPE_MAIN_VARIANT (t2);
6910   casts_away_constness_r (&t1, &t2);
6911   if (!can_convert (t2, t1))
6912     return true;
6913
6914   return false;
6915 }
6916
6917 /* If T is a REFERENCE_TYPE return the type to which T refers.
6918    Otherwise, return T itself.  */
6919
6920 tree
6921 non_reference (tree t)
6922 {
6923   if (TREE_CODE (t) == REFERENCE_TYPE)
6924     t = TREE_TYPE (t);
6925   return t;
6926 }
6927
6928
6929 /* Return nonzero if REF is an lvalue valid for this language;
6930    otherwise, print an error message and return zero.  USE says
6931    how the lvalue is being used and so selects the error message.  */
6932
6933 int
6934 lvalue_or_else (tree ref, enum lvalue_use use)
6935 {
6936   int win = lvalue_p (ref);
6937
6938   if (!win)
6939     lvalue_error (use);
6940
6941   return win;
6942 }