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