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