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