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