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