gcc/cp/typeck.c

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