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