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 (expr && 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 /* Used by the C-common bits.  */
2861 tree
2862 build_function_call_vec (tree function, VEC(tree,gc) *params,
2863                          VEC(tree,gc) *origtypes ATTRIBUTE_UNUSED)
2864 {
2865   tree p;
2866   tree *pp;
2867   unsigned int i;
2868   tree t;
2869
2870   /* FIXME: Should just change cp_build_function_call to use a
2871      VEC.  */
2872   p = NULL_TREE;
2873   pp = &p;
2874   for (i = 0; VEC_iterate (tree, params, i, t); ++i)
2875     {
2876       *pp = build_tree_list (NULL, t);
2877       pp = &TREE_CHAIN (*pp);
2878     }
2879   return cp_build_function_call (function, p, tf_warning_or_error);
2880 }
2881
2882 tree
2883 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
2884 {
2885   tree fntype, fndecl;
2886   tree name = NULL_TREE;
2887   int is_method;
2888   tree original = function;
2889   int nargs, parm_types_len;
2890   tree *argarray;
2891   tree parm_types;
2892
2893   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2894      expressions, like those used for ObjC messenger dispatches.  */
2895   if (params != NULL_TREE)
2896     function = objc_rewrite_function_call (function, TREE_VALUE (params));
2897
2898   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2899      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2900   if (TREE_CODE (function) == NOP_EXPR
2901       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2902     function = TREE_OPERAND (function, 0);
2903
2904   if (TREE_CODE (function) == FUNCTION_DECL)
2905     {
2906       name = DECL_NAME (function);
2907
2908       mark_used (function);
2909       fndecl = function;
2910
2911       /* Convert anything with function type to a pointer-to-function.  */
2912       if (DECL_MAIN_P (function) && (complain & tf_error))
2913         pedwarn (input_location, OPT_pedantic,
2914                  "ISO C++ forbids calling %<::main%> from within program");
2915
2916       function = build_addr_func (function);
2917     }
2918   else
2919     {
2920       fndecl = NULL_TREE;
2921
2922       function = build_addr_func (function);
2923     }
2924
2925   if (function == error_mark_node)
2926     return error_mark_node;
2927
2928   fntype = TREE_TYPE (function);
2929
2930   if (TYPE_PTRMEMFUNC_P (fntype))
2931     {
2932       if (complain & tf_error)
2933         error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2934                "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
2935                original, original);
2936       return error_mark_node;
2937     }
2938
2939   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2940                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2941
2942   if (!((TREE_CODE (fntype) == POINTER_TYPE
2943          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2944         || is_method
2945         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2946     {
2947       if (complain & tf_error)
2948         error ("%qE cannot be used as a function", original);
2949       return error_mark_node;
2950     }
2951
2952   /* fntype now gets the type of function pointed to.  */
2953   fntype = TREE_TYPE (fntype);
2954   parm_types = TYPE_ARG_TYPES (fntype);
2955
2956   /* Allocate storage for converted arguments.  */
2957   parm_types_len = list_length (parm_types);
2958   nargs = list_length (params);
2959   if (parm_types_len > nargs)
2960     nargs = parm_types_len;
2961   argarray = (tree *) alloca (nargs * sizeof (tree));
2962
2963   /* Convert the parameters to the types declared in the
2964      function prototype, or apply default promotions.  */
2965   nargs = convert_arguments (nargs, argarray, parm_types,
2966                              params, fndecl, LOOKUP_NORMAL,
2967                              complain);
2968   if (nargs < 0)
2969     return error_mark_node;
2970
2971   /* Check for errors in format strings and inappropriately
2972      null parameters.  */
2973   check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
2974                             parm_types);
2975
2976   return build_cxx_call (function, nargs, argarray);
2977 }
2978 \f
2979 /* Convert the actual parameter expressions in the list VALUES
2980    to the types in the list TYPELIST.
2981    If parmdecls is exhausted, or when an element has NULL as its type,
2982    perform the default conversions.
2983
2984    Store the converted arguments in ARGARRAY.  NARGS is the size of this array.
2985
2986    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2987
2988    This is also where warnings about wrong number of args are generated.
2989
2990    Returns the actual number of arguments processed (which might be less
2991    than NARGS), or -1 on error.
2992
2993    VALUES is a chain of TREE_LIST nodes with the elements of the list
2994    in the TREE_VALUE slots of those nodes.
2995
2996    In C++, unspecified trailing parameters can be filled in with their
2997    default arguments, if such were specified.  Do so here.  */
2998
2999 static int
3000 convert_arguments (int nargs, tree *argarray,
3001                    tree typelist, tree values, tree fndecl, int flags,
3002                    tsubst_flags_t complain)
3003 {
3004   tree typetail, valtail;
3005   const char *called_thing = 0;
3006   int i = 0;
3007
3008   /* Argument passing is always copy-initialization.  */
3009   flags |= LOOKUP_ONLYCONVERTING;
3010
3011   if (fndecl)
3012     {
3013       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
3014         {
3015           if (DECL_NAME (fndecl) == NULL_TREE
3016               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
3017             called_thing = "constructor";
3018           else
3019             called_thing = "member function";
3020         }
3021       else
3022         called_thing = "function";
3023     }
3024
3025   for (valtail = values, typetail = typelist;
3026        valtail;
3027        valtail = TREE_CHAIN (valtail), i++)
3028     {
3029       tree type = typetail ? TREE_VALUE (typetail) : 0;
3030       tree val = TREE_VALUE (valtail);
3031
3032       if (val == error_mark_node || type == error_mark_node)
3033         return -1;
3034
3035       if (type == void_type_node)
3036         {
3037           if (complain & tf_error)
3038             {
3039               if (fndecl)
3040                 {
3041                   error ("too many arguments to %s %q+#D",
3042                          called_thing, fndecl);
3043                   error ("at this point in file");
3044                 }
3045               else
3046                 error ("too many arguments to function");
3047               return i;
3048             }
3049           else
3050             return -1;
3051         }
3052
3053       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3054          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
3055       if (TREE_CODE (val) == NOP_EXPR
3056           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3057           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3058         val = TREE_OPERAND (val, 0);
3059
3060       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3061         {
3062           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3063               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3064               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3065             val = decay_conversion (val);
3066         }
3067
3068       if (val == error_mark_node)
3069         return -1;
3070
3071       if (type != 0)
3072         {
3073           /* Formal parm type is specified by a function prototype.  */
3074           tree parmval;
3075
3076           if (!COMPLETE_TYPE_P (complete_type (type)))
3077             {
3078               if (complain & tf_error)
3079                 {
3080                   if (fndecl)
3081                     error ("parameter %P of %qD has incomplete type %qT",
3082                            i, fndecl, type);
3083                   else
3084                     error ("parameter %P has incomplete type %qT", i, type);
3085                 }
3086               parmval = error_mark_node;
3087             }
3088           else
3089             {
3090               parmval = convert_for_initialization
3091                 (NULL_TREE, type, val, flags,
3092                  "argument passing", fndecl, i, complain);
3093               parmval = convert_for_arg_passing (type, parmval);
3094             }
3095
3096           if (parmval == error_mark_node)
3097             return -1;
3098
3099           argarray[i] = parmval;
3100         }
3101       else
3102         {
3103           if (fndecl && DECL_BUILT_IN (fndecl)
3104               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3105             /* Don't do ellipsis conversion for __built_in_constant_p
3106                as this will result in spurious warnings for non-POD
3107                types.  */
3108             val = require_complete_type (val);
3109           else
3110             val = convert_arg_to_ellipsis (val);
3111
3112           argarray[i] = val;
3113         }
3114
3115       if (typetail)
3116         typetail = TREE_CHAIN (typetail);
3117     }
3118
3119   if (typetail != 0 && typetail != void_list_node)
3120     {
3121       /* See if there are default arguments that can be used.  Because
3122          we hold default arguments in the FUNCTION_TYPE (which is so
3123          wrong), we can see default parameters here from deduced
3124          contexts (and via typeof) for indirect function calls.
3125          Fortunately we know whether we have a function decl to
3126          provide default arguments in a language conformant
3127          manner.  */
3128       if (fndecl && TREE_PURPOSE (typetail)
3129           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3130         {
3131           for (; typetail != void_list_node; ++i)
3132             {
3133               tree parmval
3134                 = convert_default_arg (TREE_VALUE (typetail),
3135                                        TREE_PURPOSE (typetail),
3136                                        fndecl, i);
3137
3138               if (parmval == error_mark_node)
3139                 return -1;
3140
3141               argarray[i] = parmval;
3142               typetail = TREE_CHAIN (typetail);
3143               /* ends with `...'.  */
3144               if (typetail == NULL_TREE)
3145                 break;
3146             }
3147         }
3148       else
3149         {
3150           if (complain & tf_error)
3151             {
3152               if (fndecl)
3153                 {
3154                   error ("too few arguments to %s %q+#D",
3155                          called_thing, fndecl);
3156                   error ("at this point in file");
3157                 }
3158               else
3159                 error ("too few arguments to function");
3160             }
3161           return -1;
3162         }
3163     }
3164
3165   gcc_assert (i <= nargs);
3166   return i;
3167 }
3168 \f
3169 /* Build a binary-operation expression, after performing default
3170    conversions on the operands.  CODE is the kind of expression to
3171    build.  ARG1 and ARG2 are the arguments.  ARG1_CODE and ARG2_CODE
3172    are the tree codes which correspond to ARG1 and ARG2 when issuing
3173    warnings about possibly misplaced parentheses.  They may differ
3174    from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3175    folding (e.g., if the parser sees "a | 1 + 1", it may call this
3176    routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3177    To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3178    ARG2_CODE as ERROR_MARK.  */
3179
3180 tree
3181 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3182                    tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3183                    tsubst_flags_t complain)
3184 {
3185   tree orig_arg1;
3186   tree orig_arg2;
3187   tree expr;
3188
3189   orig_arg1 = arg1;
3190   orig_arg2 = arg2;
3191
3192   if (processing_template_decl)
3193     {
3194       if (type_dependent_expression_p (arg1)
3195           || type_dependent_expression_p (arg2))
3196         return build_min_nt (code, arg1, arg2);
3197       arg1 = build_non_dependent_expr (arg1);
3198       arg2 = build_non_dependent_expr (arg2);
3199     }
3200
3201   if (code == DOTSTAR_EXPR)
3202     expr = build_m_component_ref (arg1, arg2);
3203   else
3204     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3205                          overloaded_p, complain);
3206
3207   /* Check for cases such as x+y<<z which users are likely to
3208      misinterpret.  But don't warn about obj << x + y, since that is a
3209      common idiom for I/O.  */
3210   if (warn_parentheses
3211       && !processing_template_decl
3212       && !error_operand_p (arg1)
3213       && !error_operand_p (arg2)
3214       && (code != LSHIFT_EXPR
3215           || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3216     warn_about_parentheses (code, arg1_code, orig_arg1, arg2_code, orig_arg2);
3217
3218   if (processing_template_decl && expr != error_mark_node)
3219     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3220
3221   return expr;
3222 }
3223
3224 /* Build and return an ARRAY_REF expression.  */
3225
3226 tree
3227 build_x_array_ref (tree arg1, tree arg2, tsubst_flags_t complain)
3228 {
3229   tree orig_arg1 = arg1;
3230   tree orig_arg2 = arg2;
3231   tree expr;
3232
3233   if (processing_template_decl)
3234     {
3235       if (type_dependent_expression_p (arg1)
3236           || type_dependent_expression_p (arg2))
3237         return build_min_nt (ARRAY_REF, arg1, arg2,
3238                              NULL_TREE, NULL_TREE);
3239       arg1 = build_non_dependent_expr (arg1);
3240       arg2 = build_non_dependent_expr (arg2);
3241     }
3242
3243   expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3244                        /*overloaded_p=*/NULL, complain);
3245
3246   if (processing_template_decl && expr != error_mark_node)
3247     return build_min_non_dep (ARRAY_REF, expr, orig_arg1, orig_arg2,
3248                               NULL_TREE, NULL_TREE);
3249   return expr;
3250 }
3251
3252 /* For the c-common bits.  */
3253 tree
3254 build_binary_op (location_t location, enum tree_code code, tree op0, tree op1,
3255                  int convert_p ATTRIBUTE_UNUSED)
3256 {
3257   return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error);
3258 }
3259
3260
3261 /* Build a binary-operation expression without default conversions.
3262    CODE is the kind of expression to build.
3263    LOCATION is the location_t of the operator in the source code.
3264    This function differs from `build' in several ways:
3265    the data type of the result is computed and recorded in it,
3266    warnings are generated if arg data types are invalid,
3267    special handling for addition and subtraction of pointers is known,
3268    and some optimization is done (operations on narrow ints
3269    are done in the narrower type when that gives the same result).
3270    Constant folding is also done before the result is returned.
3271
3272    Note that the operands will never have enumeral types
3273    because either they have just had the default conversions performed
3274    or they have both just been converted to some other type in which
3275    the arithmetic is to be done.
3276
3277    C++: must do special pointer arithmetic when implementing
3278    multiple inheritance, and deal with pointer to member functions.  */
3279
3280 tree
3281 cp_build_binary_op (location_t location,
3282                     enum tree_code code, tree orig_op0, tree orig_op1,
3283                     tsubst_flags_t complain)
3284 {
3285   tree op0, op1;
3286   enum tree_code code0, code1;
3287   tree type0, type1;
3288   const char *invalid_op_diag;
3289
3290   /* Expression code to give to the expression when it is built.
3291      Normally this is CODE, which is what the caller asked for,
3292      but in some special cases we change it.  */
3293   enum tree_code resultcode = code;
3294
3295   /* Data type in which the computation is to be performed.
3296      In the simplest cases this is the common type of the arguments.  */
3297   tree result_type = NULL;
3298
3299   /* Nonzero means operands have already been type-converted
3300      in whatever way is necessary.
3301      Zero means they need to be converted to RESULT_TYPE.  */
3302   int converted = 0;
3303
3304   /* Nonzero means create the expression with this type, rather than
3305      RESULT_TYPE.  */
3306   tree build_type = 0;
3307
3308   /* Nonzero means after finally constructing the expression
3309      convert it to this type.  */
3310   tree final_type = 0;
3311
3312   tree result;
3313
3314   /* Nonzero if this is an operation like MIN or MAX which can
3315      safely be computed in short if both args are promoted shorts.
3316      Also implies COMMON.
3317      -1 indicates a bitwise operation; this makes a difference
3318      in the exact conditions for when it is safe to do the operation
3319      in a narrower mode.  */
3320   int shorten = 0;
3321
3322   /* Nonzero if this is a comparison operation;
3323      if both args are promoted shorts, compare the original shorts.
3324      Also implies COMMON.  */
3325   int short_compare = 0;
3326
3327   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
3328   int common = 0;
3329
3330   /* True if both operands have arithmetic type.  */
3331   bool arithmetic_types_p;
3332
3333   /* Apply default conversions.  */
3334   op0 = orig_op0;
3335   op1 = orig_op1;
3336
3337   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3338       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3339       || code == TRUTH_XOR_EXPR)
3340     {
3341       if (!really_overloaded_fn (op0))
3342         op0 = decay_conversion (op0);
3343       if (!really_overloaded_fn (op1))
3344         op1 = decay_conversion (op1);
3345     }
3346   else
3347     {
3348       if (!really_overloaded_fn (op0))
3349         op0 = default_conversion (op0);
3350       if (!really_overloaded_fn (op1))
3351         op1 = default_conversion (op1);
3352     }
3353
3354   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3355   STRIP_TYPE_NOPS (op0);
3356   STRIP_TYPE_NOPS (op1);
3357
3358   /* DTRT if one side is an overloaded function, but complain about it.  */
3359   if (type_unknown_p (op0))
3360     {
3361       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3362       if (t != error_mark_node)
3363         {
3364           if (complain & tf_error)
3365             permerror (input_location, "assuming cast to type %qT from overloaded function",
3366                        TREE_TYPE (t));
3367           op0 = t;
3368         }
3369     }
3370   if (type_unknown_p (op1))
3371     {
3372       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3373       if (t != error_mark_node)
3374         {
3375           if (complain & tf_error)
3376             permerror (input_location, "assuming cast to type %qT from overloaded function",
3377                        TREE_TYPE (t));
3378           op1 = t;
3379         }
3380     }
3381
3382   type0 = TREE_TYPE (op0);
3383   type1 = TREE_TYPE (op1);
3384
3385   /* The expression codes of the data types of the arguments tell us
3386      whether the arguments are integers, floating, pointers, etc.  */
3387   code0 = TREE_CODE (type0);
3388   code1 = TREE_CODE (type1);
3389
3390   /* If an error was already reported for one of the arguments,
3391      avoid reporting another error.  */
3392
3393   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3394     return error_mark_node;
3395
3396   if ((invalid_op_diag
3397        = targetm.invalid_binary_op (code, type0, type1)))
3398     {
3399       error (invalid_op_diag);
3400       return error_mark_node;
3401     }
3402
3403   switch (code)
3404     {
3405     case MINUS_EXPR:
3406       /* Subtraction of two similar pointers.
3407          We must subtract them as integers, then divide by object size.  */
3408       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3409           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3410                                                         TREE_TYPE (type1)))
3411         return pointer_diff (op0, op1, common_pointer_type (type0, type1));
3412       /* In all other cases except pointer - int, the usual arithmetic
3413          rules apply.  */
3414       else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3415         {
3416           common = 1;
3417           break;
3418         }
3419       /* The pointer - int case is just like pointer + int; fall
3420          through.  */
3421     case PLUS_EXPR:
3422       if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3423           && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3424         {
3425           tree ptr_operand;
3426           tree int_operand;
3427           ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3428           int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3429           if (processing_template_decl)
3430             {
3431               result_type = TREE_TYPE (ptr_operand);
3432               break;
3433             }
3434           return cp_pointer_int_sum (code,
3435                                      ptr_operand,
3436                                      int_operand);
3437         }
3438       common = 1;
3439       break;
3440
3441     case MULT_EXPR:
3442       common = 1;
3443       break;
3444
3445     case TRUNC_DIV_EXPR:
3446     case CEIL_DIV_EXPR:
3447     case FLOOR_DIV_EXPR:
3448     case ROUND_DIV_EXPR:
3449     case EXACT_DIV_EXPR:
3450       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3451            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3452           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3453               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3454         {
3455           enum tree_code tcode0 = code0, tcode1 = code1;
3456
3457           warn_for_div_by_zero (location, op1);
3458
3459           if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3460             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3461           if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3462             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3463
3464           if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3465             resultcode = RDIV_EXPR;
3466           else
3467             /* When dividing two signed integers, we have to promote to int.
3468                unless we divide by a constant != -1.  Note that default
3469                conversion will have been performed on the operands at this
3470                point, so we have to dig out the original type to find out if
3471                it was unsigned.  */
3472             shorten = ((TREE_CODE (op0) == NOP_EXPR
3473                         && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3474                        || (TREE_CODE (op1) == INTEGER_CST
3475                            && ! integer_all_onesp (op1)));
3476
3477           common = 1;
3478         }
3479       break;
3480
3481     case BIT_AND_EXPR:
3482     case BIT_IOR_EXPR:
3483     case BIT_XOR_EXPR:
3484       if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3485           || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3486               && !VECTOR_FLOAT_TYPE_P (type0)
3487               && !VECTOR_FLOAT_TYPE_P (type1)))
3488         shorten = -1;
3489       break;
3490
3491     case TRUNC_MOD_EXPR:
3492     case FLOOR_MOD_EXPR:
3493       warn_for_div_by_zero (location, op1);
3494
3495       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3496         {
3497           /* Although it would be tempting to shorten always here, that loses
3498              on some targets, since the modulo instruction is undefined if the
3499              quotient can't be represented in the computation mode.  We shorten
3500              only if unsigned or if dividing by something we know != -1.  */
3501           shorten = ((TREE_CODE (op0) == NOP_EXPR
3502                       && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3503                      || (TREE_CODE (op1) == INTEGER_CST
3504                          && ! integer_all_onesp (op1)));
3505           common = 1;
3506         }
3507       break;
3508
3509     case TRUTH_ANDIF_EXPR:
3510     case TRUTH_ORIF_EXPR:
3511     case TRUTH_AND_EXPR:
3512     case TRUTH_OR_EXPR:
3513       result_type = boolean_type_node;
3514       break;
3515
3516       /* Shift operations: result has same type as first operand;
3517          always convert second operand to int.
3518          Also set SHORT_SHIFT if shifting rightward.  */
3519
3520     case RSHIFT_EXPR:
3521       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3522         {
3523           result_type = type0;
3524           if (TREE_CODE (op1) == INTEGER_CST)
3525             {
3526               if (tree_int_cst_lt (op1, integer_zero_node))
3527                 {
3528                   if (complain & tf_warning)
3529                     warning (0, "right shift count is negative");
3530                 }
3531               else
3532                 {
3533                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3534                       && (complain & tf_warning))
3535                     warning (0, "right shift count >= width of type");
3536                 }
3537             }
3538           /* Convert the shift-count to an integer, regardless of
3539              size of value being shifted.  */
3540           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3541             op1 = cp_convert (integer_type_node, op1);
3542           /* Avoid converting op1 to result_type later.  */
3543           converted = 1;
3544         }
3545       break;
3546
3547     case LSHIFT_EXPR:
3548       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3549         {
3550           result_type = type0;
3551           if (TREE_CODE (op1) == INTEGER_CST)
3552             {
3553               if (tree_int_cst_lt (op1, integer_zero_node))
3554                 {
3555                   if (complain & tf_warning)
3556                     warning (0, "left shift count is negative");
3557                 }
3558               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3559                 {
3560                   if (complain & tf_warning)
3561                     warning (0, "left shift count >= width of type");
3562                 }
3563             }
3564           /* Convert the shift-count to an integer, regardless of
3565              size of value being shifted.  */
3566           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3567             op1 = cp_convert (integer_type_node, op1);
3568           /* Avoid converting op1 to result_type later.  */
3569           converted = 1;
3570         }
3571       break;
3572
3573     case RROTATE_EXPR:
3574     case LROTATE_EXPR:
3575       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3576         {
3577           result_type = type0;
3578           if (TREE_CODE (op1) == INTEGER_CST)
3579             {
3580               if (tree_int_cst_lt (op1, integer_zero_node))
3581                 {
3582                   if (complain & tf_warning)
3583                     warning (0, (code == LROTATE_EXPR)
3584                                   ? G_("left rotate count is negative")
3585                                   : G_("right rotate count is negative"));
3586                 }
3587               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3588                 {
3589                   if (complain & tf_warning)
3590                     warning (0, (code == LROTATE_EXPR)
3591                                   ? G_("left rotate count >= width of type")
3592                                   : G_("right rotate count >= width of type"));
3593                 }
3594             }
3595           /* Convert the shift-count to an integer, regardless of
3596              size of value being shifted.  */
3597           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3598             op1 = cp_convert (integer_type_node, op1);
3599         }
3600       break;
3601
3602     case EQ_EXPR:
3603     case NE_EXPR:
3604       if ((complain & tf_warning)
3605           && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3606         warning (OPT_Wfloat_equal,
3607                  "comparing floating point with == or != is unsafe");
3608       if ((complain & tf_warning)
3609           && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3610               || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3611         warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3612
3613       build_type = boolean_type_node;
3614       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3615            || code0 == COMPLEX_TYPE)
3616           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3617               || code1 == COMPLEX_TYPE))
3618         short_compare = 1;
3619       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3620                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3621         result_type = composite_pointer_type (type0, type1, op0, op1,
3622                                               "comparison", complain);
3623       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3624                && null_ptr_cst_p (op1))
3625         {
3626           if (TREE_CODE (op0) == ADDR_EXPR
3627               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3628             {
3629               if (complain & tf_warning)
3630                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3631                          TREE_OPERAND (op0, 0));
3632             }
3633           result_type = type0;
3634         }
3635       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3636                && null_ptr_cst_p (op0))
3637         {
3638           if (TREE_CODE (op1) == ADDR_EXPR
3639               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3640             {
3641               if (complain & tf_warning)
3642                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3643                          TREE_OPERAND (op1, 0));
3644             }
3645           result_type = type1;
3646         }
3647       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3648         {
3649           result_type = type0;
3650           if (complain & tf_error)
3651             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3652           else
3653             return error_mark_node;
3654         }
3655       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3656         {
3657           result_type = type1;
3658           if (complain & tf_error)
3659             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3660           else
3661             return error_mark_node;
3662         }
3663       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3664         {
3665           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3666               == ptrmemfunc_vbit_in_delta)
3667             {
3668               tree pfn0 = pfn_from_ptrmemfunc (op0);
3669               tree delta0 = delta_from_ptrmemfunc (op0);
3670               tree e1 = cp_build_binary_op (location,
3671                                             EQ_EXPR,
3672                                             pfn0,
3673                                             fold_convert (TREE_TYPE (pfn0),
3674                                                           integer_zero_node),
3675                                             complain);
3676               tree e2 = cp_build_binary_op (location,
3677                                             BIT_AND_EXPR,
3678                                             delta0,
3679                                             integer_one_node,
3680                                             complain);
3681               e2 = cp_build_binary_op (location,
3682                                        EQ_EXPR, e2, integer_zero_node,
3683                                        complain);
3684               op0 = cp_build_binary_op (location,
3685                                         TRUTH_ANDIF_EXPR, e1, e2,
3686                                         complain);
3687               op1 = cp_convert (TREE_TYPE (op0), integer_one_node);
3688             }
3689           else
3690             {
3691               op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3692               op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3693             }
3694           result_type = TREE_TYPE (op0);
3695         }
3696       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3697         return cp_build_binary_op (location, code, op1, op0, complain);
3698       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3699         {
3700           tree type;
3701           /* E will be the final comparison.  */
3702           tree e;
3703           /* E1 and E2 are for scratch.  */
3704           tree e1;
3705           tree e2;
3706           tree pfn0;
3707           tree pfn1;
3708           tree delta0;
3709           tree delta1;
3710
3711           type = composite_pointer_type (type0, type1, op0, op1, "comparison",
3712                                          complain);
3713
3714           if (!same_type_p (TREE_TYPE (op0), type))
3715             op0 = cp_convert_and_check (type, op0);
3716           if (!same_type_p (TREE_TYPE (op1), type))
3717             op1 = cp_convert_and_check (type, op1);
3718
3719           if (op0 == error_mark_node || op1 == error_mark_node)
3720             return error_mark_node;
3721
3722           if (TREE_SIDE_EFFECTS (op0))
3723             op0 = save_expr (op0);
3724           if (TREE_SIDE_EFFECTS (op1))
3725             op1 = save_expr (op1);
3726
3727           pfn0 = pfn_from_ptrmemfunc (op0);
3728           pfn1 = pfn_from_ptrmemfunc (op1);
3729           delta0 = delta_from_ptrmemfunc (op0);
3730           delta1 = delta_from_ptrmemfunc (op1);
3731           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3732               == ptrmemfunc_vbit_in_delta)
3733             {
3734               /* We generate:
3735
3736                  (op0.pfn == op1.pfn
3737                   && ((op0.delta == op1.delta)
3738                        || (!op0.pfn && op0.delta & 1 == 0
3739                            && op1.delta & 1 == 0))
3740
3741                  The reason for the `!op0.pfn' bit is that a NULL
3742                  pointer-to-member is any member with a zero PFN and
3743                  LSB of the DELTA field is 0.  */
3744
3745               e1 = cp_build_binary_op (location, BIT_AND_EXPR,
3746                                        delta0,
3747                                        integer_one_node,
3748                                        complain);
3749               e1 = cp_build_binary_op (location,
3750                                        EQ_EXPR, e1, integer_zero_node,
3751                                        complain);
3752               e2 = cp_build_binary_op (location, BIT_AND_EXPR,
3753                                        delta1,
3754                                        integer_one_node,
3755                                        complain);
3756               e2 = cp_build_binary_op (location,
3757                                        EQ_EXPR, e2, integer_zero_node,
3758                                        complain);
3759               e1 = cp_build_binary_op (location,
3760                                        TRUTH_ANDIF_EXPR, e2, e1,
3761                                        complain);
3762               e2 = cp_build_binary_op (location, EQ_EXPR,
3763                                        pfn0,
3764                                        fold_convert (TREE_TYPE (pfn0),
3765                                                      integer_zero_node),
3766                                        complain);
3767               e2 = cp_build_binary_op (location,
3768                                        TRUTH_ANDIF_EXPR, e2, e1, complain);
3769               e1 = cp_build_binary_op (location,
3770                                        EQ_EXPR, delta0, delta1, complain);
3771               e1 = cp_build_binary_op (location,
3772                                        TRUTH_ORIF_EXPR, e1, e2, complain);
3773             }
3774           else
3775             {
3776               /* We generate:
3777
3778                  (op0.pfn == op1.pfn
3779                  && (!op0.pfn || op0.delta == op1.delta))
3780
3781                  The reason for the `!op0.pfn' bit is that a NULL
3782                  pointer-to-member is any member with a zero PFN; the
3783                  DELTA field is unspecified.  */
3784
3785               e1 = cp_build_binary_op (location,
3786                                        EQ_EXPR, delta0, delta1, complain);
3787               e2 = cp_build_binary_op (location,
3788                                        EQ_EXPR,
3789                                        pfn0,
3790                                        fold_convert (TREE_TYPE (pfn0),
3791                                                      integer_zero_node),
3792                                        complain);
3793               e1 = cp_build_binary_op (location,
3794                                        TRUTH_ORIF_EXPR, e1, e2, complain);
3795             }
3796           e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3797           e = cp_build_binary_op (location,
3798                                   TRUTH_ANDIF_EXPR, e2, e1, complain);
3799           if (code == EQ_EXPR)
3800             return e;
3801           return cp_build_binary_op (location,
3802                                      EQ_EXPR, e, integer_zero_node, complain);
3803         }
3804       else
3805         {
3806           gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3807                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3808                                        type1));
3809           gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3810                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3811                                        type0));
3812         }
3813
3814       break;
3815
3816     case MAX_EXPR:
3817     case MIN_EXPR:
3818       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3819            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3820         shorten = 1;
3821       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3822         result_type = composite_pointer_type (type0, type1, op0, op1,
3823                                               "comparison", complain);
3824       break;
3825
3826     case LE_EXPR:
3827     case GE_EXPR:
3828     case LT_EXPR:
3829     case GT_EXPR:
3830       if (TREE_CODE (orig_op0) == STRING_CST
3831           || TREE_CODE (orig_op1) == STRING_CST)
3832         {
3833           if (complain & tf_warning)
3834             warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3835         }
3836
3837       build_type = boolean_type_node;
3838       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3839            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3840         short_compare = 1;
3841       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3842         result_type = composite_pointer_type (type0, type1, op0, op1,
3843                                               "comparison", complain);
3844       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3845                && integer_zerop (op1))
3846         result_type = type0;
3847       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3848                && integer_zerop (op0))
3849         result_type = type1;
3850       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3851         {
3852           result_type = type0;
3853           if (complain & tf_error)
3854             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3855           else
3856             return error_mark_node;
3857         }
3858       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3859         {
3860           result_type = type1;
3861           if (complain & tf_error)
3862             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3863           else
3864             return error_mark_node;
3865         }
3866       break;
3867
3868     case UNORDERED_EXPR:
3869     case ORDERED_EXPR:
3870     case UNLT_EXPR:
3871     case UNLE_EXPR:
3872     case UNGT_EXPR:
3873     case UNGE_EXPR:
3874     case UNEQ_EXPR:
3875       build_type = integer_type_node;
3876       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3877         {
3878           if (complain & tf_error)
3879             error ("unordered comparison on non-floating point argument");
3880           return error_mark_node;
3881         }
3882       common = 1;
3883       break;
3884
3885     default:
3886       break;
3887     }
3888
3889   if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3890        && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3891            || code1 == COMPLEX_TYPE)))
3892     arithmetic_types_p = 1;
3893   else
3894     {
3895       arithmetic_types_p = 0;
3896       /* Vector arithmetic is only allowed when both sides are vectors.  */
3897       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
3898         {
3899           if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
3900               || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
3901                                                         TREE_TYPE (type1)))
3902             {
3903               binary_op_error (location, code, type0, type1);
3904               return error_mark_node;
3905             }
3906           arithmetic_types_p = 1;
3907         }
3908     }
3909   /* Determine the RESULT_TYPE, if it is not already known.  */
3910   if (!result_type
3911       && arithmetic_types_p
3912       && (shorten || common || short_compare))
3913     result_type = cp_common_type (type0, type1);
3914
3915   if (!result_type)
3916     {
3917       if (complain & tf_error)
3918         error ("invalid operands of types %qT and %qT to binary %qO",
3919                TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3920       return error_mark_node;
3921     }
3922
3923   /* If we're in a template, the only thing we need to know is the
3924      RESULT_TYPE.  */
3925   if (processing_template_decl)
3926     {
3927       /* Since the middle-end checks the type when doing a build2, we
3928          need to build the tree in pieces.  This built tree will never
3929          get out of the front-end as we replace it when instantiating
3930          the template.  */
3931       tree tmp = build2 (resultcode,
3932                          build_type ? build_type : result_type,
3933                          NULL_TREE, op1);
3934       TREE_OPERAND (tmp, 0) = op0;
3935       return tmp;
3936     }
3937
3938   if (arithmetic_types_p)
3939     {
3940       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3941
3942       /* For certain operations (which identify themselves by shorten != 0)
3943          if both args were extended from the same smaller type,
3944          do the arithmetic in that type and then extend.
3945
3946          shorten !=0 and !=1 indicates a bitwise operation.
3947          For them, this optimization is safe only if
3948          both args are zero-extended or both are sign-extended.
3949          Otherwise, we might change the result.
3950          E.g., (short)-1 | (unsigned short)-1 is (int)-1
3951          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3952
3953       if (shorten && none_complex)
3954         {
3955           final_type = result_type;
3956           result_type = shorten_binary_op (result_type, op0, op1,
3957                                            shorten == -1);
3958         }
3959
3960       /* Comparison operations are shortened too but differently.
3961          They identify themselves by setting short_compare = 1.  */
3962
3963       if (short_compare)
3964         {
3965           /* Don't write &op0, etc., because that would prevent op0
3966              from being kept in a register.
3967              Instead, make copies of the our local variables and
3968              pass the copies by reference, then copy them back afterward.  */
3969           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3970           enum tree_code xresultcode = resultcode;
3971           tree val
3972             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3973           if (val != 0)
3974             return cp_convert (boolean_type_node, val);
3975           op0 = xop0, op1 = xop1;
3976           converted = 1;
3977           resultcode = xresultcode;
3978         }
3979
3980       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3981           && warn_sign_compare
3982           /* Do not warn until the template is instantiated; we cannot
3983              bound the ranges of the arguments until that point.  */
3984           && !processing_template_decl
3985           && (complain & tf_warning))
3986         {
3987           warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1,
3988                                  result_type, resultcode);
3989         }
3990     }
3991
3992   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3993   if ((orig_op0 == null_node || orig_op1 == null_node)
3994       /* It's reasonable to use pointer values as operands of &&
3995          and ||, so NULL is no exception.  */
3996       && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR
3997       && ( /* Both are NULL (or 0) and the operation was not a comparison.  */
3998           (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1)
3999            && code != EQ_EXPR && code != NE_EXPR)
4000           /* Or if one of OP0 or OP1 is neither a pointer nor NULL.  */
4001           || (!null_ptr_cst_p (orig_op0) && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
4002           || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE))
4003       && (complain & tf_warning))
4004     /* Some sort of arithmetic operation involving NULL was
4005        performed.  Note that pointer-difference and pointer-addition
4006        have already been handled above, and so we don't end up here in
4007        that case.  */
4008     warning (OPT_Wpointer_arith, "NULL used in arithmetic");
4009
4010
4011   /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
4012      Then the expression will be built.
4013      It will be given type FINAL_TYPE if that is nonzero;
4014      otherwise, it will be given type RESULT_TYPE.  */
4015   if (! converted)
4016     {
4017       if (TREE_TYPE (op0) != result_type)
4018         op0 = cp_convert_and_check (result_type, op0);
4019       if (TREE_TYPE (op1) != result_type)
4020         op1 = cp_convert_and_check (result_type, op1);
4021
4022       if (op0 == error_mark_node || op1 == error_mark_node)
4023         return error_mark_node;
4024     }
4025
4026   if (build_type == NULL_TREE)
4027     build_type = result_type;
4028
4029   result = build2 (resultcode, build_type, op0, op1);
4030   result = fold_if_not_in_template (result);
4031   if (final_type != 0)
4032     result = cp_convert (final_type, result);
4033
4034   if (TREE_OVERFLOW_P (result)
4035       && !TREE_OVERFLOW_P (op0)
4036       && !TREE_OVERFLOW_P (op1))
4037     overflow_warning (result);
4038
4039   return result;
4040 }
4041 \f
4042 /* Return a tree for the sum or difference (RESULTCODE says which)
4043    of pointer PTROP and integer INTOP.  */
4044
4045 static tree
4046 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
4047 {
4048   tree res_type = TREE_TYPE (ptrop);
4049
4050   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
4051      in certain circumstance (when it's valid to do so).  So we need
4052      to make sure it's complete.  We don't need to check here, if we
4053      can actually complete it at all, as those checks will be done in
4054      pointer_int_sum() anyway.  */
4055   complete_type (TREE_TYPE (res_type));
4056
4057   return pointer_int_sum (input_location, resultcode, ptrop,
4058                           fold_if_not_in_template (intop));
4059 }
4060
4061 /* Return a tree for the difference of pointers OP0 and OP1.
4062    The resulting tree has type int.  */
4063
4064 static tree
4065 pointer_diff (tree op0, tree op1, tree ptrtype)
4066 {
4067   tree result;
4068   tree restype = ptrdiff_type_node;
4069   tree target_type = TREE_TYPE (ptrtype);
4070
4071   if (!complete_type_or_else (target_type, NULL_TREE))
4072     return error_mark_node;
4073
4074   if (TREE_CODE (target_type) == VOID_TYPE)
4075     permerror (input_location, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
4076   if (TREE_CODE (target_type) == FUNCTION_TYPE)
4077     permerror (input_location, "ISO C++ forbids using pointer to a function in subtraction");
4078   if (TREE_CODE (target_type) == METHOD_TYPE)
4079     permerror (input_location, "ISO C++ forbids using pointer to a method in subtraction");
4080
4081   /* First do the subtraction as integers;
4082      then drop through to build the divide operator.  */
4083
4084   op0 = cp_build_binary_op (input_location,
4085                             MINUS_EXPR,
4086                             cp_convert (restype, op0),
4087                             cp_convert (restype, op1),
4088                             tf_warning_or_error);
4089
4090   /* This generates an error if op1 is a pointer to an incomplete type.  */
4091   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
4092     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4093
4094   op1 = (TYPE_PTROB_P (ptrtype)
4095          ? size_in_bytes (target_type)
4096          : integer_one_node);
4097
4098   /* Do the division.  */
4099
4100   result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4101   return fold_if_not_in_template (result);
4102 }
4103 \f
4104 /* Construct and perhaps optimize a tree representation
4105    for a unary operation.  CODE, a tree_code, specifies the operation
4106    and XARG is the operand.  */
4107
4108 tree
4109 build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain)
4110 {
4111   tree orig_expr = xarg;
4112   tree exp;
4113   int ptrmem = 0;
4114
4115   if (processing_template_decl)
4116     {
4117       if (type_dependent_expression_p (xarg))
4118         return build_min_nt (code, xarg, NULL_TREE);
4119
4120       xarg = build_non_dependent_expr (xarg);
4121     }
4122
4123   exp = NULL_TREE;
4124
4125   /* [expr.unary.op] says:
4126
4127        The address of an object of incomplete type can be taken.
4128
4129      (And is just the ordinary address operator, not an overloaded
4130      "operator &".)  However, if the type is a template
4131      specialization, we must complete the type at this point so that
4132      an overloaded "operator &" will be available if required.  */
4133   if (code == ADDR_EXPR
4134       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4135       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
4136            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
4137           || (TREE_CODE (xarg) == OFFSET_REF)))
4138     /* Don't look for a function.  */;
4139   else
4140     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
4141                         /*overloaded_p=*/NULL, complain);
4142   if (!exp && code == ADDR_EXPR)
4143     {
4144       /*  A pointer to member-function can be formed only by saying
4145           &X::mf.  */
4146       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4147           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4148         {
4149           if (TREE_CODE (xarg) != OFFSET_REF
4150               || !TYPE_P (TREE_OPERAND (xarg, 0)))
4151             {
4152               error ("invalid use of %qE to form a pointer-to-member-function",
4153                      xarg);
4154               if (TREE_CODE (xarg) != OFFSET_REF)
4155                 inform (input_location, "  a qualified-id is required");
4156               return error_mark_node;
4157             }
4158           else
4159             {
4160               error ("parentheses around %qE cannot be used to form a"
4161                      " pointer-to-member-function",
4162                      xarg);
4163               PTRMEM_OK_P (xarg) = 1;
4164             }
4165         }
4166
4167       if (TREE_CODE (xarg) == OFFSET_REF)
4168         {
4169           ptrmem = PTRMEM_OK_P (xarg);
4170
4171           if (!ptrmem && !flag_ms_extensions
4172               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4173             {
4174               /* A single non-static member, make sure we don't allow a
4175                  pointer-to-member.  */
4176               xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
4177                              TREE_OPERAND (xarg, 0),
4178                              ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4179               PTRMEM_OK_P (xarg) = ptrmem;
4180             }
4181         }
4182       else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning))
4183         warning (0, "taking address of temporary");
4184       exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain);
4185     }
4186
4187   if (processing_template_decl && exp != error_mark_node)
4188     exp = build_min_non_dep (code, exp, orig_expr,
4189                              /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
4190   if (TREE_CODE (exp) == ADDR_EXPR)
4191     PTRMEM_OK_P (exp) = ptrmem;
4192   return exp;
4193 }
4194
4195 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4196    constants, where a null value is represented by an INTEGER_CST of
4197    -1.  */
4198
4199 tree
4200 cp_truthvalue_conversion (tree expr)
4201 {
4202   tree type = TREE_TYPE (expr);
4203   if (TYPE_PTRMEM_P (type))
4204     return build_binary_op (EXPR_LOCATION (expr),
4205                             NE_EXPR, expr, integer_zero_node, 1);
4206   else
4207     return c_common_truthvalue_conversion (input_location, expr);
4208 }
4209
4210 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
4211
4212 tree
4213 condition_conversion (tree expr)
4214 {
4215   tree t;
4216   if (processing_template_decl)
4217     return expr;
4218   t = perform_implicit_conversion (boolean_type_node, expr,
4219                                    tf_warning_or_error);
4220   t = fold_build_cleanup_point_expr (boolean_type_node, t);
4221   return t;
4222 }
4223
4224 /* Return an ADDR_EXPR giving the address of T.  This function
4225    attempts no optimizations or simplifications; it is a low-level
4226    primitive.  */
4227
4228 tree
4229 build_address (tree t)
4230 {
4231   tree addr;
4232
4233   if (error_operand_p (t) || !cxx_mark_addressable (t))
4234     return error_mark_node;
4235
4236   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
4237
4238   return addr;
4239 }
4240
4241 /* Return a NOP_EXPR converting EXPR to TYPE.  */
4242
4243 tree
4244 build_nop (tree type, tree expr)
4245 {
4246   if (type == error_mark_node || error_operand_p (expr))
4247     return expr;
4248   return build1 (NOP_EXPR, type, expr);
4249 }
4250
4251 /* C++: Must handle pointers to members.
4252
4253    Perhaps type instantiation should be extended to handle conversion
4254    from aggregates to types we don't yet know we want?  (Or are those
4255    cases typically errors which should be reported?)
4256
4257    NOCONVERT nonzero suppresses the default promotions
4258    (such as from short to int).  */
4259
4260 tree
4261 cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
4262                    tsubst_flags_t complain)
4263 {
4264   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
4265   tree arg = xarg;
4266   tree argtype = 0;
4267   const char *errstring = NULL;
4268   tree val;
4269   const char *invalid_op_diag;
4270
4271   if (error_operand_p (arg))
4272     return error_mark_node;
4273
4274   if ((invalid_op_diag
4275        = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
4276                                     ? CONVERT_EXPR
4277                                     : code),
4278                                    TREE_TYPE (xarg))))
4279     {
4280       error (invalid_op_diag);
4281       return error_mark_node;
4282     }
4283
4284   switch (code)
4285     {
4286     case UNARY_PLUS_EXPR:
4287     case NEGATE_EXPR:
4288       {
4289         int flags = WANT_ARITH | WANT_ENUM;
4290         /* Unary plus (but not unary minus) is allowed on pointers.  */
4291         if (code == UNARY_PLUS_EXPR)
4292           flags |= WANT_POINTER;
4293         arg = build_expr_type_conversion (flags, arg, true);
4294         if (!arg)
4295           errstring = (code == NEGATE_EXPR
4296                        ? "wrong type argument to unary minus"
4297                        : "wrong type argument to unary plus");
4298         else
4299           {
4300             if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4301               arg = perform_integral_promotions (arg);
4302
4303             /* Make sure the result is not an lvalue: a unary plus or minus
4304                expression is always a rvalue.  */
4305             arg = rvalue (arg);
4306           }
4307       }
4308       break;
4309
4310     case BIT_NOT_EXPR:
4311       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4312         {
4313           code = CONJ_EXPR;
4314           if (!noconvert)
4315             arg = default_conversion (arg);
4316         }
4317       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
4318                                                    | WANT_VECTOR,
4319                                                    arg, true)))
4320         errstring = "wrong type argument to bit-complement";
4321       else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4322         arg = perform_integral_promotions (arg);
4323       break;
4324
4325     case ABS_EXPR:
4326       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4327         errstring = "wrong type argument to abs";
4328       else if (!noconvert)
4329         arg = default_conversion (arg);
4330       break;
4331
4332     case CONJ_EXPR:
4333       /* Conjugating a real value is a no-op, but allow it anyway.  */
4334       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4335         errstring = "wrong type argument to conjugation";
4336       else if (!noconvert)
4337         arg = default_conversion (arg);
4338       break;
4339
4340     case TRUTH_NOT_EXPR:
4341       arg = perform_implicit_conversion (boolean_type_node, arg,
4342                                          complain);
4343       val = invert_truthvalue (arg);
4344       if (arg != error_mark_node)
4345         return val;
4346       errstring = "in argument to unary !";
4347       break;
4348
4349     case NOP_EXPR:
4350       break;
4351
4352     case REALPART_EXPR:
4353       if (TREE_CODE (arg) == COMPLEX_CST)
4354         return TREE_REALPART (arg);
4355       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4356         {
4357           arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4358           return fold_if_not_in_template (arg);
4359         }
4360       else
4361         return arg;
4362
4363     case IMAGPART_EXPR:
4364       if (TREE_CODE (arg) == COMPLEX_CST)
4365         return TREE_IMAGPART (arg);
4366       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4367         {
4368           arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4369           return fold_if_not_in_template (arg);
4370         }
4371       else
4372         return cp_convert (TREE_TYPE (arg), integer_zero_node);
4373
4374     case PREINCREMENT_EXPR:
4375     case POSTINCREMENT_EXPR:
4376     case PREDECREMENT_EXPR:
4377     case POSTDECREMENT_EXPR:
4378       /* Handle complex lvalues (when permitted)
4379          by reduction to simpler cases.  */
4380
4381       val = unary_complex_lvalue (code, arg);
4382       if (val != 0)
4383         return val;
4384
4385       /* Increment or decrement the real part of the value,
4386          and don't change the imaginary part.  */
4387       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4388         {
4389           tree real, imag;
4390
4391           arg = stabilize_reference (arg);
4392           real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain);
4393           imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain);
4394           real = cp_build_unary_op (code, real, 1, complain);
4395           if (real == error_mark_node || imag == error_mark_node)
4396             return error_mark_node;
4397           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4398                          real, imag);
4399         }
4400
4401       /* Report invalid types.  */
4402
4403       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4404                                               arg, true)))
4405         {
4406           if (code == PREINCREMENT_EXPR)
4407             errstring ="no pre-increment operator for type";
4408           else if (code == POSTINCREMENT_EXPR)
4409             errstring ="no post-increment operator for type";
4410           else if (code == PREDECREMENT_EXPR)
4411             errstring ="no pre-decrement operator for type";
4412           else
4413             errstring ="no post-decrement operator for type";
4414           break;
4415         }
4416       else if (arg == error_mark_node)
4417         return error_mark_node;
4418
4419       /* Report something read-only.  */
4420
4421       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4422           || TREE_READONLY (arg))
4423         {
4424           if (complain & tf_error)
4425             readonly_error (arg, ((code == PREINCREMENT_EXPR
4426                                    || code == POSTINCREMENT_EXPR)
4427                                   ? "increment" : "decrement"));
4428           else
4429             return error_mark_node;
4430         }
4431
4432       {
4433         tree inc;
4434         tree declared_type = unlowered_expr_type (arg);
4435
4436         argtype = TREE_TYPE (arg);
4437
4438         /* ARM $5.2.5 last annotation says this should be forbidden.  */
4439         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4440           {
4441             if (complain & tf_error)
4442               permerror (input_location, (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4443                          ? G_("ISO C++ forbids incrementing an enum")
4444                          : G_("ISO C++ forbids decrementing an enum"));
4445             else
4446               return error_mark_node;
4447           }
4448
4449         /* Compute the increment.  */
4450
4451         if (TREE_CODE (argtype) == POINTER_TYPE)
4452           {
4453             tree type = complete_type (TREE_TYPE (argtype));
4454
4455             if (!COMPLETE_OR_VOID_TYPE_P (type))
4456               {
4457                 if (complain & tf_error)
4458                   error (((code == PREINCREMENT_EXPR
4459                            || code == POSTINCREMENT_EXPR))
4460                          ? G_("cannot increment a pointer to incomplete type %qT")
4461                          : G_("cannot decrement a pointer to incomplete type %qT"),
4462                          TREE_TYPE (argtype));
4463                 else
4464                   return error_mark_node;
4465               }
4466             else if ((pedantic || warn_pointer_arith)
4467                      && !TYPE_PTROB_P (argtype))
4468               {
4469                 if (complain & tf_error)
4470                   permerror (input_location, (code == PREINCREMENT_EXPR
4471                               || code == POSTINCREMENT_EXPR)
4472                              ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4473                              : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4474                              argtype);
4475                 else
4476                   return error_mark_node;
4477               }
4478
4479             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4480           }
4481         else
4482           inc = integer_one_node;
4483
4484         inc = cp_convert (argtype, inc);
4485
4486         /* Complain about anything else that is not a true lvalue.  */
4487         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4488                                     || code == POSTINCREMENT_EXPR)
4489                                    ? lv_increment : lv_decrement),
4490                              complain))
4491           return error_mark_node;
4492
4493         /* Forbid using -- on `bool'.  */
4494         if (same_type_p (declared_type, boolean_type_node))
4495           {
4496             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4497               {
4498                 if (complain & tf_error)
4499                   error ("invalid use of Boolean expression as operand "
4500                          "to %<operator--%>");
4501                 return error_mark_node;
4502               }
4503             val = boolean_increment (code, arg);
4504           }
4505         else
4506           val = build2 (code, TREE_TYPE (arg), arg, inc);
4507
4508         TREE_SIDE_EFFECTS (val) = 1;
4509         return val;
4510       }
4511
4512     case ADDR_EXPR:
4513       /* Note that this operation never does default_conversion
4514          regardless of NOCONVERT.  */
4515
4516       argtype = lvalue_type (arg);
4517
4518       if (TREE_CODE (arg) == OFFSET_REF)
4519         goto offset_ref;
4520
4521       if (TREE_CODE (argtype) == REFERENCE_TYPE)
4522         {
4523           tree type = build_pointer_type (TREE_TYPE (argtype));
4524           arg = build1 (CONVERT_EXPR, type, arg);
4525           return arg;
4526         }
4527       else if (pedantic && DECL_MAIN_P (arg))
4528         {
4529           /* ARM $3.4 */
4530           /* Apparently a lot of autoconf scripts for C++ packages do this,
4531              so only complain if -pedantic.  */
4532           if (complain & (flag_pedantic_errors ? tf_error : tf_warning))
4533             pedwarn (input_location, OPT_pedantic,
4534                      "ISO C++ forbids taking address of function %<::main%>");
4535           else if (flag_pedantic_errors)
4536             return error_mark_node;
4537         }
4538
4539       /* Let &* cancel out to simplify resulting code.  */
4540       if (TREE_CODE (arg) == INDIRECT_REF)
4541         {
4542           /* We don't need to have `current_class_ptr' wrapped in a
4543              NON_LVALUE_EXPR node.  */
4544           if (arg == current_class_ref)
4545             return current_class_ptr;
4546
4547           arg = TREE_OPERAND (arg, 0);
4548           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4549             {
4550               tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4551               arg = build1 (CONVERT_EXPR, type, arg);
4552             }
4553           else
4554             /* Don't let this be an lvalue.  */
4555             arg = rvalue (arg);
4556           return arg;
4557         }
4558
4559       /* Uninstantiated types are all functions.  Taking the
4560          address of a function is a no-op, so just return the
4561          argument.  */
4562
4563       gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4564                   || !IDENTIFIER_OPNAME_P (arg));
4565
4566       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4567           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4568         {
4569           /* They're trying to take the address of a unique non-static
4570              member function.  This is ill-formed (except in MS-land),
4571              but let's try to DTRT.
4572              Note: We only handle unique functions here because we don't
4573              want to complain if there's a static overload; non-unique
4574              cases will be handled by instantiate_type.  But we need to
4575              handle this case here to allow casts on the resulting PMF.
4576              We could defer this in non-MS mode, but it's easier to give
4577              a useful error here.  */
4578
4579           /* Inside constant member functions, the `this' pointer
4580              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4581              is used here to remove this const from the diagnostics
4582              and the created OFFSET_REF.  */
4583           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4584           tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4585           mark_used (fn);
4586
4587           if (! flag_ms_extensions)
4588             {
4589               tree name = DECL_NAME (fn);
4590               if (!(complain & tf_error))
4591                 return error_mark_node;
4592               else if (current_class_type
4593                        && TREE_OPERAND (arg, 0) == current_class_ref)
4594                   /* An expression like &memfn.  */
4595                 permerror (input_location, "ISO C++ forbids taking the address of an unqualified"
4596                            " or parenthesized non-static member function to form"
4597                            " a pointer to member function.  Say %<&%T::%D%>",
4598                            base, name);
4599               else
4600                 permerror (input_location, "ISO C++ forbids taking the address of a bound member"
4601                            " function to form a pointer to member function."
4602                            "  Say %<&%T::%D%>",
4603                            base, name);
4604             }
4605           arg = build_offset_ref (base, fn, /*address_p=*/true);
4606         }
4607
4608     offset_ref:
4609       if (type_unknown_p (arg))
4610         return build1 (ADDR_EXPR, unknown_type_node, arg);
4611
4612       /* Handle complex lvalues (when permitted)
4613          by reduction to simpler cases.  */
4614       val = unary_complex_lvalue (code, arg);
4615       if (val != 0)
4616         return val;
4617
4618       switch (TREE_CODE (arg))
4619         {
4620         CASE_CONVERT:
4621         case FLOAT_EXPR:
4622         case FIX_TRUNC_EXPR:
4623           /* Even if we're not being pedantic, we cannot allow this
4624              extension when we're instantiating in a SFINAE
4625              context.  */
4626           if (! lvalue_p (arg) && complain == tf_none)
4627             {
4628               if (complain & tf_error)
4629                 permerror (input_location, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4630               else
4631                 return error_mark_node;
4632             }
4633           break;
4634
4635         case BASELINK:
4636           arg = BASELINK_FUNCTIONS (arg);
4637           /* Fall through.  */
4638
4639         case OVERLOAD:
4640           arg = OVL_CURRENT (arg);
4641           break;
4642
4643         case OFFSET_REF:
4644           /* Turn a reference to a non-static data member into a
4645              pointer-to-member.  */
4646           {
4647             tree type;
4648             tree t;
4649
4650             if (!PTRMEM_OK_P (arg))
4651               return cp_build_unary_op (code, arg, 0, complain);
4652
4653             t = TREE_OPERAND (arg, 1);
4654             if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4655               {
4656                 if (complain & tf_error)
4657                   error ("cannot create pointer to reference member %qD", t);
4658                 return error_mark_node;
4659               }
4660
4661             type = build_ptrmem_type (context_for_name_lookup (t),
4662                                       TREE_TYPE (t));
4663             t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4664             return t;
4665           }
4666
4667         default:
4668           break;
4669         }
4670
4671       /* Anything not already handled and not a true memory reference
4672          is an error.  */
4673       if (TREE_CODE (argtype) != FUNCTION_TYPE
4674           && TREE_CODE (argtype) != METHOD_TYPE
4675           && TREE_CODE (arg) != OFFSET_REF
4676           && !lvalue_or_else (arg, lv_addressof, complain))
4677         return error_mark_node;
4678
4679       if (argtype != error_mark_node)
4680         argtype = build_pointer_type (argtype);
4681
4682       /* In a template, we are processing a non-dependent expression
4683          so we can just form an ADDR_EXPR with the correct type.  */
4684       if (processing_template_decl || TREE_CODE (arg) != COMPONENT_REF)
4685         {
4686           val = build_address (arg);
4687           if (TREE_CODE (arg) == OFFSET_REF)
4688             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4689         }
4690       else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4691         {
4692           tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4693
4694           /* We can only get here with a single static member
4695              function.  */
4696           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4697                       && DECL_STATIC_FUNCTION_P (fn));
4698           mark_used (fn);
4699           val = build_address (fn);
4700           if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4701             /* Do not lose object's side effects.  */
4702             val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4703                           TREE_OPERAND (arg, 0), val);
4704         }
4705       else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4706         {
4707           if (complain & tf_error)
4708             error ("attempt to take address of bit-field structure member %qD",
4709                    TREE_OPERAND (arg, 1));
4710           return error_mark_node;
4711         }
4712       else
4713         {
4714           tree object = TREE_OPERAND (arg, 0);
4715           tree field = TREE_OPERAND (arg, 1);
4716           gcc_assert (same_type_ignoring_top_level_qualifiers_p
4717                       (TREE_TYPE (object), decl_type_context (field)));
4718           val = build_address (arg);
4719         }
4720
4721       if (TREE_CODE (argtype) == POINTER_TYPE
4722           && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4723         {
4724           build_ptrmemfunc_type (argtype);
4725           val = build_ptrmemfunc (argtype, val, 0,
4726                                   /*c_cast_p=*/false);
4727         }
4728
4729       return val;
4730
4731     default:
4732       break;
4733     }
4734
4735   if (!errstring)
4736     {
4737       if (argtype == 0)
4738         argtype = TREE_TYPE (arg);
4739       return fold_if_not_in_template (build1 (code, argtype, arg));
4740     }
4741
4742   if (complain & tf_error)
4743     error ("%s", errstring);
4744   return error_mark_node;
4745 }
4746
4747 /* Hook for the c-common bits that build a unary op.  */
4748 tree
4749 build_unary_op (location_t location ATTRIBUTE_UNUSED,
4750                 enum tree_code code, tree xarg, int noconvert)
4751 {
4752   return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
4753 }
4754
4755 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4756    for certain kinds of expressions which are not really lvalues
4757    but which we can accept as lvalues.
4758
4759    If ARG is not a kind of expression we can handle, return
4760    NULL_TREE.  */
4761
4762 tree
4763 unary_complex_lvalue (enum tree_code code, tree arg)
4764 {
4765   /* Inside a template, making these kinds of adjustments is
4766      pointless; we are only concerned with the type of the
4767      expression.  */
4768   if (processing_template_decl)
4769     return NULL_TREE;
4770
4771   /* Handle (a, b) used as an "lvalue".  */
4772   if (TREE_CODE (arg) == COMPOUND_EXPR)
4773     {
4774       tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0,
4775                                             tf_warning_or_error);
4776       return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4777                      TREE_OPERAND (arg, 0), real_result);
4778     }
4779
4780   /* Handle (a ? b : c) used as an "lvalue".  */
4781   if (TREE_CODE (arg) == COND_EXPR
4782       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4783     return rationalize_conditional_expr (code, arg, tf_warning_or_error);
4784
4785   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4786   if (TREE_CODE (arg) == MODIFY_EXPR
4787       || TREE_CODE (arg) == PREINCREMENT_EXPR
4788       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4789     {
4790       tree lvalue = TREE_OPERAND (arg, 0);
4791       if (TREE_SIDE_EFFECTS (lvalue))
4792         {
4793           lvalue = stabilize_reference (lvalue);
4794           arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4795                         lvalue, TREE_OPERAND (arg, 1));
4796         }
4797       return unary_complex_lvalue
4798         (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4799     }
4800
4801   if (code != ADDR_EXPR)
4802     return NULL_TREE;
4803
4804   /* Handle (a = b) used as an "lvalue" for `&'.  */
4805   if (TREE_CODE (arg) == MODIFY_EXPR
4806       || TREE_CODE (arg) == INIT_EXPR)
4807     {
4808       tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0,
4809                                             tf_warning_or_error);
4810       arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4811                     arg, real_result);
4812       TREE_NO_WARNING (arg) = 1;
4813       return arg;
4814     }
4815
4816   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4817       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4818       || TREE_CODE (arg) == OFFSET_REF)
4819     return NULL_TREE;
4820
4821   /* We permit compiler to make function calls returning
4822      objects of aggregate type look like lvalues.  */
4823   {
4824     tree targ = arg;
4825
4826     if (TREE_CODE (targ) == SAVE_EXPR)
4827       targ = TREE_OPERAND (targ, 0);
4828
4829     if (TREE_CODE (targ) == CALL_EXPR && MAYBE_CLASS_TYPE_P (TREE_TYPE (targ)))
4830       {
4831         if (TREE_CODE (arg) == SAVE_EXPR)
4832           targ = arg;
4833         else
4834           targ = build_cplus_new (TREE_TYPE (arg), arg);
4835         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4836       }
4837
4838     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4839       return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4840                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4841   }
4842
4843   /* Don't let anything else be handled specially.  */
4844   return NULL_TREE;
4845 }
4846 \f
4847 /* Mark EXP saying that we need to be able to take the
4848    address of it; it should not be allocated in a register.
4849    Value is true if successful.
4850
4851    C++: we do not allow `current_class_ptr' to be addressable.  */
4852
4853 bool
4854 cxx_mark_addressable (tree exp)
4855 {
4856   tree x = exp;
4857
4858   while (1)
4859     switch (TREE_CODE (x))
4860       {
4861       case ADDR_EXPR:
4862       case COMPONENT_REF:
4863       case ARRAY_REF:
4864       case REALPART_EXPR:
4865       case IMAGPART_EXPR:
4866         x = TREE_OPERAND (x, 0);
4867         break;
4868
4869       case PARM_DECL:
4870         if (x == current_class_ptr)
4871           {
4872             error ("cannot take the address of %<this%>, which is an rvalue expression");
4873             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4874             return true;
4875           }
4876         /* Fall through.  */
4877
4878       case VAR_DECL:
4879         /* Caller should not be trying to mark initialized
4880            constant fields addressable.  */
4881         gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4882                     || DECL_IN_AGGR_P (x) == 0
4883                     || TREE_STATIC (x)
4884                     || DECL_EXTERNAL (x));
4885         /* Fall through.  */
4886
4887       case CONST_DECL:
4888       case RESULT_DECL:
4889         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4890             && !DECL_ARTIFICIAL (x))
4891           {
4892             if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
4893               {
4894                 error
4895                   ("address of explicit register variable %qD requested", x);
4896                 return false;
4897               }
4898             else if (extra_warnings)
4899               warning
4900                 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
4901           }
4902         TREE_ADDRESSABLE (x) = 1;
4903         return true;
4904
4905       case FUNCTION_DECL:
4906         TREE_ADDRESSABLE (x) = 1;
4907         return true;
4908
4909       case CONSTRUCTOR:
4910         TREE_ADDRESSABLE (x) = 1;
4911         return true;
4912
4913       case TARGET_EXPR:
4914         TREE_ADDRESSABLE (x) = 1;
4915         cxx_mark_addressable (TREE_OPERAND (x, 0));
4916         return true;
4917
4918       default:
4919         return true;
4920     }
4921 }
4922 \f
4923 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4924
4925 tree
4926 build_x_conditional_expr (tree ifexp, tree op1, tree op2,
4927                           tsubst_flags_t complain)
4928 {
4929   tree orig_ifexp = ifexp;
4930   tree orig_op1 = op1;
4931   tree orig_op2 = op2;
4932   tree expr;
4933
4934   if (processing_template_decl)
4935     {
4936       /* The standard says that the expression is type-dependent if
4937          IFEXP is type-dependent, even though the eventual type of the
4938          expression doesn't dependent on IFEXP.  */
4939       if (type_dependent_expression_p (ifexp)
4940           /* As a GNU extension, the middle operand may be omitted.  */
4941           || (op1 && type_dependent_expression_p (op1))
4942           || type_dependent_expression_p (op2))
4943         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4944       ifexp = build_non_dependent_expr (ifexp);
4945       if (op1)
4946         op1 = build_non_dependent_expr (op1);
4947       op2 = build_non_dependent_expr (op2);
4948     }
4949
4950   expr = build_conditional_expr (ifexp, op1, op2, complain);
4951   if (processing_template_decl && expr != error_mark_node)
4952     return build_min_non_dep (COND_EXPR, expr,
4953                               orig_ifexp, orig_op1, orig_op2);
4954   return expr;
4955 }
4956 \f
4957 /* Given a list of expressions, return a compound expression
4958    that performs them all and returns the value of the last of them.  */
4959
4960 tree build_x_compound_expr_from_list (tree list, const char *msg)
4961 {
4962   tree expr = TREE_VALUE (list);
4963
4964   if (TREE_CHAIN (list))
4965     {
4966       if (msg)
4967         permerror (input_location, "%s expression list treated as compound expression", msg);
4968
4969       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4970         expr = build_x_compound_expr (expr, TREE_VALUE (list),
4971                                       tf_warning_or_error);
4972     }
4973
4974   return expr;
4975 }
4976
4977 /* Handle overloading of the ',' operator when needed.  */
4978
4979 tree
4980 build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain)
4981 {
4982   tree result;
4983   tree orig_op1 = op1;
4984   tree orig_op2 = op2;
4985
4986   if (processing_template_decl)
4987     {
4988       if (type_dependent_expression_p (op1)
4989           || type_dependent_expression_p (op2))
4990         return build_min_nt (COMPOUND_EXPR, op1, op2);
4991       op1 = build_non_dependent_expr (op1);
4992       op2 = build_non_dependent_expr (op2);
4993     }
4994
4995   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4996                          /*overloaded_p=*/NULL, complain);
4997   if (!result)
4998     result = cp_build_compound_expr (op1, op2, complain);
4999
5000   if (processing_template_decl && result != error_mark_node)
5001     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
5002
5003   return result;
5004 }
5005
5006 /* Like cp_build_compound_expr, but for the c-common bits.  */
5007
5008 tree
5009 build_compound_expr (tree lhs, tree rhs)
5010 {
5011   return cp_build_compound_expr (lhs, rhs, tf_warning_or_error);
5012 }
5013
5014 /* Build a compound expression.  */
5015
5016 tree
5017 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
5018 {
5019   lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
5020
5021   if (lhs == error_mark_node || rhs == error_mark_node)
5022     return error_mark_node;
5023
5024   if (TREE_CODE (rhs) == TARGET_EXPR)
5025     {
5026       /* If the rhs is a TARGET_EXPR, then build the compound
5027          expression inside the target_expr's initializer. This
5028          helps the compiler to eliminate unnecessary temporaries.  */
5029       tree init = TREE_OPERAND (rhs, 1);
5030
5031       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
5032       TREE_OPERAND (rhs, 1) = init;
5033
5034       return rhs;
5035     }
5036
5037   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
5038 }
5039
5040 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
5041    casts away constness.  CAST gives the type of cast.
5042
5043    ??? This function warns for casting away any qualifier not just
5044    const.  We would like to specify exactly what qualifiers are casted
5045    away.
5046 */
5047
5048 static void
5049 check_for_casting_away_constness (tree src_type, tree dest_type,
5050                                   enum tree_code cast)
5051 {
5052   /* C-style casts are allowed to cast away constness.  With
5053      WARN_CAST_QUAL, we still want to issue a warning.  */
5054   if (cast == CAST_EXPR && !warn_cast_qual)
5055       return;
5056
5057   if (!casts_away_constness (src_type, dest_type))
5058     return;
5059
5060   switch (cast)
5061     {
5062     case CAST_EXPR:
5063       warning (OPT_Wcast_qual,
5064                "cast from type %qT to type %qT casts away qualifiers",
5065                src_type, dest_type);
5066       return;
5067
5068     case STATIC_CAST_EXPR:
5069       error ("static_cast from type %qT to type %qT casts away qualifiers",
5070              src_type, dest_type);
5071       return;
5072
5073     case REINTERPRET_CAST_EXPR:
5074       error ("reinterpret_cast from type %qT to type %qT casts away qualifiers",
5075              src_type, dest_type);
5076       return;
5077     default:
5078       gcc_unreachable();
5079     }
5080 }
5081
5082 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
5083    (another pointer-to-member type in the same hierarchy) and return
5084    the converted expression.  If ALLOW_INVERSE_P is permitted, a
5085    pointer-to-derived may be converted to pointer-to-base; otherwise,
5086    only the other direction is permitted.  If C_CAST_P is true, this
5087    conversion is taking place as part of a C-style cast.  */
5088
5089 tree
5090 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
5091                 bool c_cast_p)
5092 {
5093   if (TYPE_PTRMEM_P (type))
5094     {
5095       tree delta;
5096
5097       if (TREE_CODE (expr) == PTRMEM_CST)
5098         expr = cplus_expand_constant (expr);
5099       delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
5100                                     TYPE_PTRMEM_CLASS_TYPE (type),
5101                                     allow_inverse_p,
5102                                     c_cast_p);
5103       if (!integer_zerop (delta))
5104         {
5105           tree cond, op1, op2;
5106
5107           cond = cp_build_binary_op (input_location,
5108                                      EQ_EXPR,
5109                                      expr,
5110                                      build_int_cst (TREE_TYPE (expr), -1),
5111                                      tf_warning_or_error);
5112           op1 = build_nop (ptrdiff_type_node, expr);
5113           op2 = cp_build_binary_op (input_location,
5114                                     PLUS_EXPR, op1, delta,
5115                                     tf_warning_or_error);
5116
5117           expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2);
5118
5119         }
5120
5121       return build_nop (type, expr);
5122     }
5123   else
5124     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
5125                              allow_inverse_p, c_cast_p);
5126 }
5127
5128 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5129    a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5130    Otherwise, return EXPR unchanged.  */
5131
5132 static tree
5133 ignore_overflows (tree expr, tree orig)
5134 {
5135   if (TREE_CODE (expr) == INTEGER_CST
5136       && CONSTANT_CLASS_P (orig)
5137       && TREE_CODE (orig) != STRING_CST
5138       && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
5139     {
5140       if (!TREE_OVERFLOW (orig))
5141         /* Ensure constant sharing.  */
5142         expr = build_int_cst_wide (TREE_TYPE (expr),
5143                                    TREE_INT_CST_LOW (expr),
5144                                    TREE_INT_CST_HIGH (expr));
5145       else
5146         {
5147           /* Avoid clobbering a shared constant.  */
5148           expr = copy_node (expr);
5149           TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
5150         }
5151     }
5152   return expr;
5153 }
5154
5155 /* Perform a static_cast from EXPR to TYPE.  When C_CAST_P is true,
5156    this static_cast is being attempted as one of the possible casts
5157    allowed by a C-style cast.  (In that case, accessibility of base
5158    classes is not considered, and it is OK to cast away
5159    constness.)  Return the result of the cast.  *VALID_P is set to
5160    indicate whether or not the cast was valid.  */
5161
5162 static tree
5163 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
5164                      bool *valid_p, tsubst_flags_t complain)
5165 {
5166   tree intype;
5167   tree result;
5168   tree orig;
5169
5170   /* Assume the cast is valid.  */
5171   *valid_p = true;
5172
5173   intype = TREE_TYPE (expr);
5174
5175   /* Save casted types in the function's used types hash table.  */
5176   used_types_insert (type);
5177
5178   /* [expr.static.cast]
5179
5180      An lvalue of type "cv1 B", where B is a class type, can be cast
5181      to type "reference to cv2 D", where D is a class derived (clause
5182      _class.derived_) from B, if a valid standard conversion from
5183      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5184      same cv-qualification as, or greater cv-qualification than, cv1,
5185      and B is not a virtual base class of D.  */
5186   /* We check this case before checking the validity of "TYPE t =
5187      EXPR;" below because for this case:
5188
5189        struct B {};
5190        struct D : public B { D(const B&); };
5191        extern B& b;
5192        void f() { static_cast<const D&>(b); }
5193
5194      we want to avoid constructing a new D.  The standard is not
5195      completely clear about this issue, but our interpretation is
5196      consistent with other compilers.  */
5197   if (TREE_CODE (type) == REFERENCE_TYPE
5198       && CLASS_TYPE_P (TREE_TYPE (type))
5199       && CLASS_TYPE_P (intype)
5200       && real_lvalue_p (expr)
5201       && DERIVED_FROM_P (intype, TREE_TYPE (type))
5202       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
5203                       build_pointer_type (TYPE_MAIN_VARIANT
5204                                           (TREE_TYPE (type))))
5205       && (c_cast_p
5206           || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5207     {
5208       tree base;
5209
5210       /* There is a standard conversion from "D*" to "B*" even if "B"
5211          is ambiguous or inaccessible.  If this is really a
5212          static_cast, then we check both for inaccessibility and
5213          ambiguity.  However, if this is a static_cast being performed
5214          because the user wrote a C-style cast, then accessibility is
5215          not considered.  */
5216       base = lookup_base (TREE_TYPE (type), intype,
5217                           c_cast_p ? ba_unique : ba_check,
5218                           NULL);
5219
5220       /* Convert from "B*" to "D*".  This function will check that "B"
5221          is not a virtual base of "D".  */
5222       expr = build_base_path (MINUS_EXPR, build_address (expr),
5223                               base, /*nonnull=*/false);
5224       /* Convert the pointer to a reference -- but then remember that
5225          there are no expressions with reference type in C++.  */
5226       return convert_from_reference (build_nop (type, expr));
5227     }
5228
5229   orig = expr;
5230
5231   /* [expr.static.cast]
5232
5233      An expression e can be explicitly converted to a type T using a
5234      static_cast of the form static_cast<T>(e) if the declaration T
5235      t(e);" is well-formed, for some invented temporary variable
5236      t.  */
5237   result = perform_direct_initialization_if_possible (type, expr,
5238                                                       c_cast_p, complain);
5239   if (result)
5240     {
5241       result = convert_from_reference (result);
5242
5243       /* Ignore any integer overflow caused by the cast.  */
5244       result = ignore_overflows (result, orig);
5245
5246       /* [expr.static.cast]
5247
5248          If T is a reference type, the result is an lvalue; otherwise,
5249          the result is an rvalue.  */
5250       if (TREE_CODE (type) != REFERENCE_TYPE)
5251         result = rvalue (result);
5252       return result;
5253     }
5254
5255   /* [expr.static.cast]
5256
5257      Any expression can be explicitly converted to type cv void.  */
5258   if (TREE_CODE (type) == VOID_TYPE)
5259     return convert_to_void (expr, /*implicit=*/NULL, complain);
5260
5261   /* [expr.static.cast]
5262
5263      The inverse of any standard conversion sequence (clause _conv_),
5264      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5265      (_conv.array_), function-to-pointer (_conv.func_), and boolean
5266      (_conv.bool_) conversions, can be performed explicitly using
5267      static_cast subject to the restriction that the explicit
5268      conversion does not cast away constness (_expr.const.cast_), and
5269      the following additional rules for specific cases:  */
5270   /* For reference, the conversions not excluded are: integral
5271      promotions, floating point promotion, integral conversions,
5272      floating point conversions, floating-integral conversions,
5273      pointer conversions, and pointer to member conversions.  */
5274   /* DR 128
5275
5276      A value of integral _or enumeration_ type can be explicitly
5277      converted to an enumeration type.  */
5278   /* The effect of all that is that any conversion between any two
5279      types which are integral, floating, or enumeration types can be
5280      performed.  */
5281   if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
5282       && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
5283     {
5284       expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
5285
5286       /* Ignore any integer overflow caused by the cast.  */
5287       expr = ignore_overflows (expr, orig);
5288       return expr;
5289     }
5290
5291   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
5292       && CLASS_TYPE_P (TREE_TYPE (type))
5293       && CLASS_TYPE_P (TREE_TYPE (intype))
5294       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5295                                           (TREE_TYPE (intype))),
5296                       build_pointer_type (TYPE_MAIN_VARIANT
5297                                           (TREE_TYPE (type)))))
5298     {
5299       tree base;
5300
5301       if (!c_cast_p)
5302         check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5303       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
5304                           c_cast_p ? ba_unique : ba_check,
5305                           NULL);
5306       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
5307     }
5308
5309   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5310       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5311     {
5312       tree c1;
5313       tree c2;
5314       tree t1;
5315       tree t2;
5316
5317       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
5318       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
5319
5320       if (TYPE_PTRMEM_P (type))
5321         {
5322           t1 = (build_ptrmem_type
5323                 (c1,
5324                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
5325           t2 = (build_ptrmem_type
5326                 (c2,
5327                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
5328         }
5329       else
5330         {
5331           t1 = intype;
5332           t2 = type;
5333         }
5334       if (can_convert (t1, t2) || can_convert (t2, t1))
5335         {
5336           if (!c_cast_p)
5337             check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5338           return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
5339                                  c_cast_p);
5340         }
5341     }
5342
5343   /* [expr.static.cast]
5344
5345      An rvalue of type "pointer to cv void" can be explicitly
5346      converted to a pointer to object type.  A value of type pointer
5347      to object converted to "pointer to cv void" and back to the
5348      original pointer type will have its original value.  */
5349   if (TREE_CODE (intype) == POINTER_TYPE
5350       && VOID_TYPE_P (TREE_TYPE (intype))
5351       && TYPE_PTROB_P (type))
5352     {
5353       if (!c_cast_p)
5354         check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5355       return build_nop (type, expr);
5356     }
5357
5358   *valid_p = false;
5359   return error_mark_node;
5360 }
5361
5362 /* Return an expression representing static_cast<TYPE>(EXPR).  */
5363
5364 tree
5365 build_static_cast (tree type, tree expr, tsubst_flags_t complain)
5366 {
5367   tree result;
5368   bool valid_p;
5369
5370   if (type == error_mark_node || expr == error_mark_node)
5371     return error_mark_node;
5372
5373   if (processing_template_decl)
5374     {
5375       expr = build_min (STATIC_CAST_EXPR, type, expr);
5376       /* We don't know if it will or will not have side effects.  */
5377       TREE_SIDE_EFFECTS (expr) = 1;
5378       return convert_from_reference (expr);
5379     }
5380
5381   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5382      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5383   if (TREE_CODE (type) != REFERENCE_TYPE
5384       && TREE_CODE (expr) == NOP_EXPR
5385       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5386     expr = TREE_OPERAND (expr, 0);
5387
5388   result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p,
5389                                 complain);
5390   if (valid_p)
5391     return result;
5392
5393   if (complain & tf_error)
5394     error ("invalid static_cast from type %qT to type %qT",
5395            TREE_TYPE (expr), type);
5396   return error_mark_node;
5397 }
5398
5399 /* EXPR is an expression with member function or pointer-to-member
5400    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
5401    not permitted by ISO C++, but we accept it in some modes.  If we
5402    are not in one of those modes, issue a diagnostic.  Return the
5403    converted expression.  */
5404
5405 tree
5406 convert_member_func_to_ptr (tree type, tree expr)
5407 {
5408   tree intype;
5409   tree decl;
5410
5411   intype = TREE_TYPE (expr);
5412   gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5413               || TREE_CODE (intype) == METHOD_TYPE);
5414
5415   if (pedantic || warn_pmf2ptr)
5416     pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpmf_conversions,
5417              "converting from %qT to %qT", intype, type);
5418
5419   if (TREE_CODE (intype) == METHOD_TYPE)
5420     expr = build_addr_func (expr);
5421   else if (TREE_CODE (expr) == PTRMEM_CST)
5422     expr = build_address (PTRMEM_CST_MEMBER (expr));
5423   else
5424     {
5425       decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5426       decl = build_address (decl);
5427       expr = get_member_function_from_ptrfunc (&decl, expr);
5428     }
5429
5430   return build_nop (type, expr);
5431 }
5432
5433 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5434    If C_CAST_P is true, this reinterpret cast is being done as part of
5435    a C-style cast.  If VALID_P is non-NULL, *VALID_P is set to
5436    indicate whether or not reinterpret_cast was valid.  */
5437
5438 static tree
5439 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5440                           bool *valid_p, tsubst_flags_t complain)
5441 {
5442   tree intype;
5443
5444   /* Assume the cast is invalid.  */
5445   if (valid_p)
5446     *valid_p = true;
5447
5448   if (type == error_mark_node || error_operand_p (expr))
5449     return error_mark_node;
5450
5451   intype = TREE_TYPE (expr);
5452
5453   /* Save casted types in the function's used types hash table.  */
5454   used_types_insert (type);
5455
5456   /* [expr.reinterpret.cast]
5457      An lvalue expression of type T1 can be cast to the type
5458      "reference to T2" if an expression of type "pointer to T1" can be
5459      explicitly converted to the type "pointer to T2" using a
5460      reinterpret_cast.  */
5461   if (TREE_CODE (type) == REFERENCE_TYPE)
5462     {
5463       if (! real_lvalue_p (expr))
5464         {
5465           if (complain & tf_error)
5466             error ("invalid cast of an rvalue expression of type "
5467                    "%qT to type %qT",
5468                    intype, type);
5469           return error_mark_node;
5470         }
5471
5472       /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5473          "B" are related class types; the reinterpret_cast does not
5474          adjust the pointer.  */
5475       if (TYPE_PTR_P (intype)
5476           && (complain & tf_warning)
5477           && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5478                          COMPARE_BASE | COMPARE_DERIVED)))
5479         warning (0, "casting %qT to %qT does not dereference pointer",
5480                  intype, type);
5481
5482       expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5483       if (expr != error_mark_node)
5484         expr = build_reinterpret_cast_1
5485           (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5486            valid_p, complain);
5487       if (expr != error_mark_node)
5488         expr = cp_build_indirect_ref (expr, 0, complain);
5489       return expr;
5490     }
5491
5492   /* As a G++ extension, we consider conversions from member
5493      functions, and pointers to member functions to
5494      pointer-to-function and pointer-to-void types.  If
5495      -Wno-pmf-conversions has not been specified,
5496      convert_member_func_to_ptr will issue an error message.  */
5497   if ((TYPE_PTRMEMFUNC_P (intype)
5498        || TREE_CODE (intype) == METHOD_TYPE)
5499       && TYPE_PTR_P (type)
5500       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5501           || VOID_TYPE_P (TREE_TYPE (type))))
5502     return convert_member_func_to_ptr (type, expr);
5503
5504   /* If the cast is not to a reference type, the lvalue-to-rvalue,
5505      array-to-pointer, and function-to-pointer conversions are
5506      performed.  */
5507   expr = decay_conversion (expr);
5508
5509   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5510      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5511   if (TREE_CODE (expr) == NOP_EXPR
5512       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5513     expr = TREE_OPERAND (expr, 0);
5514
5515   if (error_operand_p (expr))
5516     return error_mark_node;
5517
5518   intype = TREE_TYPE (expr);
5519
5520   /* [expr.reinterpret.cast]
5521      A pointer can be converted to any integral type large enough to
5522      hold it.  */
5523   if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5524     {
5525       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5526         {
5527           if (complain & tf_error)
5528             permerror (input_location, "cast from %qT to %qT loses precision",
5529                        intype, type);
5530           else
5531             return error_mark_node;
5532         }
5533     }
5534   /* [expr.reinterpret.cast]
5535      A value of integral or enumeration type can be explicitly
5536      converted to a pointer.  */
5537   else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5538     /* OK */
5539     ;
5540   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5541            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5542     return fold_if_not_in_template (build_nop (type, expr));
5543   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5544            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5545     {
5546       tree sexpr = expr;
5547
5548       if (!c_cast_p)
5549         check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR);
5550       /* Warn about possible alignment problems.  */
5551       if (STRICT_ALIGNMENT && warn_cast_align
5552           && (complain & tf_warning)
5553           && !VOID_TYPE_P (type)
5554           && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5555           && COMPLETE_TYPE_P (TREE_TYPE (type))
5556           && COMPLETE_TYPE_P (TREE_TYPE (intype))
5557           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5558         warning (OPT_Wcast_align, "cast from %qT to %qT "
5559                  "increases required alignment of target type", intype, type);
5560
5561       /* We need to strip nops here, because the front end likes to
5562          create (int *)&a for array-to-pointer decay, instead of &a[0].  */
5563       STRIP_NOPS (sexpr);
5564       if (warn_strict_aliasing <= 2)
5565         strict_aliasing_warning (intype, type, sexpr);
5566
5567       return fold_if_not_in_template (build_nop (type, expr));
5568     }
5569   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5570            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5571     {
5572       if (pedantic && (complain & tf_warning))
5573         /* Only issue a warning, as we have always supported this
5574            where possible, and it is necessary in some cases.  DR 195
5575            addresses this issue, but as of 2004/10/26 is still in
5576            drafting.  */
5577         warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5578       return fold_if_not_in_template (build_nop (type, expr));
5579     }
5580   else if (TREE_CODE (type) == VECTOR_TYPE)
5581     return fold_if_not_in_template (convert_to_vector (type, expr));
5582   else if (TREE_CODE (intype) == VECTOR_TYPE && INTEGRAL_TYPE_P (type))
5583     return fold_if_not_in_template (convert_to_integer (type, expr));
5584   else
5585     {
5586       if (valid_p)
5587         *valid_p = false;
5588       if (complain & tf_error)
5589         error ("invalid cast from type %qT to type %qT", intype, type);
5590       return error_mark_node;
5591     }
5592
5593   return cp_convert (type, expr);
5594 }
5595
5596 tree
5597 build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain)
5598 {
5599   if (type == error_mark_node || expr == error_mark_node)
5600     return error_mark_node;
5601
5602   if (processing_template_decl)
5603     {
5604       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5605
5606       if (!TREE_SIDE_EFFECTS (t)
5607           && type_dependent_expression_p (expr))
5608         /* There might turn out to be side effects inside expr.  */
5609         TREE_SIDE_EFFECTS (t) = 1;
5610       return convert_from_reference (t);
5611     }
5612
5613   return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5614                                    /*valid_p=*/NULL, complain);
5615 }
5616
5617 /* Perform a const_cast from EXPR to TYPE.  If the cast is valid,
5618    return an appropriate expression.  Otherwise, return
5619    error_mark_node.  If the cast is not valid, and COMPLAIN is true,
5620    then a diagnostic will be issued.  If VALID_P is non-NULL, we are
5621    performing a C-style cast, its value upon return will indicate
5622    whether or not the conversion succeeded.  */
5623
5624 static tree
5625 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5626                     bool *valid_p)
5627 {
5628   tree src_type;
5629   tree reference_type;
5630
5631   /* Callers are responsible for handling error_mark_node as a
5632      destination type.  */
5633   gcc_assert (dst_type != error_mark_node);
5634   /* In a template, callers should be building syntactic
5635      representations of casts, not using this machinery.  */
5636   gcc_assert (!processing_template_decl);
5637
5638   /* Assume the conversion is invalid.  */
5639   if (valid_p)
5640     *valid_p = false;
5641
5642   if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5643     {
5644       if (complain)
5645         error ("invalid use of const_cast with type %qT, "
5646                "which is not a pointer, "
5647                "reference, nor a pointer-to-data-member type", dst_type);
5648       return error_mark_node;
5649     }
5650
5651   if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5652     {
5653       if (complain)
5654         error ("invalid use of const_cast with type %qT, which is a pointer "
5655                "or reference to a function type", dst_type);
5656       return error_mark_node;
5657     }
5658
5659   /* Save casted types in the function's used types hash table.  */
5660   used_types_insert (dst_type);
5661
5662   src_type = TREE_TYPE (expr);
5663   /* Expressions do not really have reference types.  */
5664   if (TREE_CODE (src_type) == REFERENCE_TYPE)
5665     src_type = TREE_TYPE (src_type);
5666
5667   /* [expr.const.cast]
5668
5669      An lvalue of type T1 can be explicitly converted to an lvalue of
5670      type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5671      types) if a pointer to T1 can be explicitly converted to the type
5672      pointer to T2 using a const_cast.  */
5673   if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5674     {
5675       reference_type = dst_type;
5676       if (! real_lvalue_p (expr))
5677         {
5678           if (complain)
5679             error ("invalid const_cast of an rvalue of type %qT to type %qT",
5680                    src_type, dst_type);
5681           return error_mark_node;
5682         }
5683       dst_type = build_pointer_type (TREE_TYPE (dst_type));
5684       src_type = build_pointer_type (src_type);
5685     }
5686   else
5687     {
5688       reference_type = NULL_TREE;
5689       /* If the destination type is not a reference type, the
5690          lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5691          conversions are performed.  */
5692       src_type = type_decays_to (src_type);
5693       if (src_type == error_mark_node)
5694         return error_mark_node;
5695     }
5696
5697   if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5698       && comp_ptr_ttypes_const (dst_type, src_type))
5699     {
5700       if (valid_p)
5701         {
5702           *valid_p = true;
5703           /* This cast is actually a C-style cast.  Issue a warning if
5704              the user is making a potentially unsafe cast.  */
5705           check_for_casting_away_constness (src_type, dst_type, CAST_EXPR);
5706         }
5707       if (reference_type)
5708         {
5709           expr = cp_build_unary_op (ADDR_EXPR, expr, 0,
5710                                     complain? tf_warning_or_error : tf_none);
5711           expr = build_nop (reference_type, expr);
5712           return convert_from_reference (expr);
5713         }
5714       else
5715         {
5716           expr = decay_conversion (expr);
5717           /* build_c_cast puts on a NOP_EXPR to make the result not an
5718              lvalue.  Strip such NOP_EXPRs if VALUE is being used in
5719              non-lvalue context.  */
5720           if (TREE_CODE (expr) == NOP_EXPR
5721               && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5722             expr = TREE_OPERAND (expr, 0);
5723           return build_nop (dst_type, expr);
5724         }
5725     }
5726
5727   if (complain)
5728     error ("invalid const_cast from type %qT to type %qT",
5729            src_type, dst_type);
5730   return error_mark_node;
5731 }
5732
5733 tree
5734 build_const_cast (tree type, tree expr, tsubst_flags_t complain)
5735 {
5736   if (type == error_mark_node || error_operand_p (expr))
5737     return error_mark_node;
5738
5739   if (processing_template_decl)
5740     {
5741       tree t = build_min (CONST_CAST_EXPR, type, expr);
5742
5743       if (!TREE_SIDE_EFFECTS (t)
5744           && type_dependent_expression_p (expr))
5745         /* There might turn out to be side effects inside expr.  */
5746         TREE_SIDE_EFFECTS (t) = 1;
5747       return convert_from_reference (t);
5748     }
5749
5750   return build_const_cast_1 (type, expr, complain & tf_error,
5751                              /*valid_p=*/NULL);
5752 }
5753
5754 /* Like cp_build_c_cast, but for the c-common bits.  */
5755
5756 tree
5757 build_c_cast (tree type, tree expr)
5758 {
5759   return cp_build_c_cast (type, expr, tf_warning_or_error);
5760 }
5761
5762 /* Build an expression representing an explicit C-style cast to type
5763    TYPE of expression EXPR.  */
5764
5765 tree
5766 cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
5767 {
5768   tree value = expr;
5769   tree result;
5770   bool valid_p;
5771
5772   if (type == error_mark_node || error_operand_p (expr))
5773     return error_mark_node;
5774
5775   if (processing_template_decl)
5776     {
5777       tree t = build_min (CAST_EXPR, type,
5778                           tree_cons (NULL_TREE, value, NULL_TREE));
5779       /* We don't know if it will or will not have side effects.  */
5780       TREE_SIDE_EFFECTS (t) = 1;
5781       return convert_from_reference (t);
5782     }
5783
5784   /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5785      'Class') should always be retained, because this information aids
5786      in method lookup.  */
5787   if (objc_is_object_ptr (type)
5788       && objc_is_object_ptr (TREE_TYPE (expr)))
5789     return build_nop (type, expr);
5790
5791   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5792      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5793   if (TREE_CODE (type) != REFERENCE_TYPE
5794       && TREE_CODE (value) == NOP_EXPR
5795       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5796     value = TREE_OPERAND (value, 0);
5797
5798   if (TREE_CODE (type) == ARRAY_TYPE)
5799     {
5800       /* Allow casting from T1* to T2[] because Cfront allows it.
5801          NIHCL uses it. It is not valid ISO C++ however.  */
5802       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5803         {
5804           if (complain & tf_error)
5805             permerror (input_location, "ISO C++ forbids casting to an array type %qT", type);
5806           else
5807             return error_mark_node;
5808           type = build_pointer_type (TREE_TYPE (type));
5809         }
5810       else
5811         {
5812           if (complain & tf_error)
5813             error ("ISO C++ forbids casting to an array type %qT", type);
5814           return error_mark_node;
5815         }
5816     }
5817
5818   if (TREE_CODE (type) == FUNCTION_TYPE
5819       || TREE_CODE (type) == METHOD_TYPE)
5820     {
5821       if (complain & tf_error)
5822         error ("invalid cast to function type %qT", type);
5823       return error_mark_node;
5824     }
5825
5826   /* A C-style cast can be a const_cast.  */
5827   result = build_const_cast_1 (type, value, /*complain=*/false,
5828                                &valid_p);
5829   if (valid_p)
5830     return result;
5831
5832   /* Or a static cast.  */
5833   result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5834                                 &valid_p, complain);
5835   /* Or a reinterpret_cast.  */
5836   if (!valid_p)
5837     result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5838                                        &valid_p, complain);
5839   /* The static_cast or reinterpret_cast may be followed by a
5840      const_cast.  */
5841   if (valid_p
5842       /* A valid cast may result in errors if, for example, a
5843          conversion to am ambiguous base class is required.  */
5844       && !error_operand_p (result))
5845     {
5846       tree result_type;
5847
5848       /* Non-class rvalues always have cv-unqualified type.  */
5849       if (!CLASS_TYPE_P (type))
5850         type = TYPE_MAIN_VARIANT (type);
5851       result_type = TREE_TYPE (result);
5852       if (!CLASS_TYPE_P (result_type))
5853         result_type = TYPE_MAIN_VARIANT (result_type);
5854       /* If the type of RESULT does not match TYPE, perform a
5855          const_cast to make it match.  If the static_cast or
5856          reinterpret_cast succeeded, we will differ by at most
5857          cv-qualification, so the follow-on const_cast is guaranteed
5858          to succeed.  */
5859       if (!same_type_p (non_reference (type), non_reference (result_type)))
5860         {
5861           result = build_const_cast_1 (type, result, false, &valid_p);
5862           gcc_assert (valid_p);
5863         }
5864       return result;
5865     }
5866
5867   return error_mark_node;
5868 }
5869 \f
5870 /* For use from the C common bits.  */
5871 tree
5872 build_modify_expr (location_t location ATTRIBUTE_UNUSED,
5873                    tree lhs, enum tree_code modifycode, tree rhs,
5874                    tree rhs_origtype ATTRIBUTE_UNUSED)
5875 {
5876   return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
5877 }
5878
5879 /* Build an assignment expression of lvalue LHS from value RHS.
5880    MODIFYCODE is the code for a binary operator that we use
5881    to combine the old value of LHS with RHS to get the new value.
5882    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5883
5884    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5885
5886 tree
5887 cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
5888                       tsubst_flags_t complain)
5889 {
5890   tree result;
5891   tree newrhs = rhs;
5892   tree lhstype = TREE_TYPE (lhs);
5893   tree olhstype = lhstype;
5894   bool plain_assign = (modifycode == NOP_EXPR);
5895
5896   /* Avoid duplicate error messages from operands that had errors.  */
5897   if (error_operand_p (lhs) || error_operand_p (rhs))
5898     return error_mark_node;
5899
5900   /* Handle control structure constructs used as "lvalues".  */
5901   switch (TREE_CODE (lhs))
5902     {
5903       /* Handle --foo = 5; as these are valid constructs in C++.  */
5904     case PREDECREMENT_EXPR:
5905     case PREINCREMENT_EXPR:
5906       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5907         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5908                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5909                       TREE_OPERAND (lhs, 1));
5910       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0),
5911                                      modifycode, rhs, complain);
5912       if (newrhs == error_mark_node)
5913         return error_mark_node;
5914       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5915
5916       /* Handle (a, b) used as an "lvalue".  */
5917     case COMPOUND_EXPR:
5918       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1),
5919                                      modifycode, rhs, complain);
5920       if (newrhs == error_mark_node)
5921         return error_mark_node;
5922       return build2 (COMPOUND_EXPR, lhstype,
5923                      TREE_OPERAND (lhs, 0), newrhs);
5924
5925     case MODIFY_EXPR:
5926       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5927         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5928                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5929                       TREE_OPERAND (lhs, 1));
5930       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs,
5931                                      complain);
5932       if (newrhs == error_mark_node)
5933         return error_mark_node;
5934       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5935
5936     case MIN_EXPR:
5937     case MAX_EXPR:
5938       /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5939          when neither operand has side-effects.  */
5940       if (!lvalue_or_else (lhs, lv_assign, complain))
5941         return error_mark_node;
5942
5943       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5944                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5945
5946       lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5947                     build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5948                             boolean_type_node,
5949                             TREE_OPERAND (lhs, 0),
5950                             TREE_OPERAND (lhs, 1)),
5951                     TREE_OPERAND (lhs, 0),
5952                     TREE_OPERAND (lhs, 1));
5953       /* Fall through.  */
5954
5955       /* Handle (a ? b : c) used as an "lvalue".  */
5956     case COND_EXPR:
5957       {
5958         /* Produce (a ? (b = rhs) : (c = rhs))
5959            except that the RHS goes through a save-expr
5960            so the code to compute it is only emitted once.  */
5961         tree cond;
5962         tree preeval = NULL_TREE;
5963
5964         if (VOID_TYPE_P (TREE_TYPE (rhs)))
5965           {
5966             if (complain & tf_error)
5967               error ("void value not ignored as it ought to be");
5968             return error_mark_node;
5969           }
5970
5971         rhs = stabilize_expr (rhs, &preeval);
5972
5973         /* Check this here to avoid odd errors when trying to convert
5974            a throw to the type of the COND_EXPR.  */
5975         if (!lvalue_or_else (lhs, lv_assign, complain))
5976           return error_mark_node;
5977
5978         cond = build_conditional_expr
5979           (TREE_OPERAND (lhs, 0),
5980            cp_build_modify_expr (TREE_OPERAND (lhs, 1),
5981                                  modifycode, rhs, complain),
5982            cp_build_modify_expr (TREE_OPERAND (lhs, 2),
5983                                  modifycode, rhs, complain),
5984            complain);
5985
5986         if (cond == error_mark_node)
5987           return cond;
5988         /* Make sure the code to compute the rhs comes out
5989            before the split.  */
5990         if (preeval)
5991           cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5992         return cond;
5993       }
5994
5995     default:
5996       break;
5997     }
5998
5999   if (modifycode == INIT_EXPR)
6000     {
6001       if (TREE_CODE (rhs) == CONSTRUCTOR)
6002         {
6003           if (! same_type_p (TREE_TYPE (rhs), lhstype))
6004             /* Call convert to generate an error; see PR 11063.  */
6005             rhs = convert (lhstype, rhs);
6006           result = build2 (INIT_EXPR, lhstype, lhs, rhs);
6007           TREE_SIDE_EFFECTS (result) = 1;
6008           return result;
6009         }
6010       else if (! MAYBE_CLASS_TYPE_P (lhstype))
6011         /* Do the default thing.  */;
6012       else
6013         {
6014           result = build_special_member_call (lhs, complete_ctor_identifier,
6015                                               build_tree_list (NULL_TREE, rhs),
6016                                               lhstype, LOOKUP_NORMAL,
6017                                               complain);
6018           if (result == NULL_TREE)
6019             return error_mark_node;
6020           return result;
6021         }
6022     }
6023   else
6024     {
6025       lhs = require_complete_type (lhs);
6026       if (lhs == error_mark_node)
6027         return error_mark_node;
6028
6029       if (modifycode == NOP_EXPR)
6030         {
6031           /* `operator=' is not an inheritable operator.  */
6032           if (! MAYBE_CLASS_TYPE_P (lhstype))
6033             /* Do the default thing.  */;
6034           else
6035             {
6036               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
6037                                      lhs, rhs, make_node (NOP_EXPR),
6038                                      /*overloaded_p=*/NULL,
6039                                      complain);
6040               if (result == NULL_TREE)
6041                 return error_mark_node;
6042               return result;
6043             }
6044           lhstype = olhstype;
6045         }
6046       else
6047         {
6048           /* A binary op has been requested.  Combine the old LHS
6049              value with the RHS producing the value we should actually
6050              store into the LHS.  */
6051           gcc_assert (!((TREE_CODE (lhstype) == REFERENCE_TYPE
6052                          && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype)))
6053                         || MAYBE_CLASS_TYPE_P (lhstype)));
6054
6055           lhs = stabilize_reference (lhs);
6056           newrhs = cp_build_binary_op (input_location,
6057                                        modifycode, lhs, rhs,
6058                                        complain);
6059           if (newrhs == error_mark_node)
6060             {
6061               if (complain & tf_error)
6062                 error ("  in evaluation of %<%Q(%#T, %#T)%>", modifycode,
6063                        TREE_TYPE (lhs), TREE_TYPE (rhs));
6064               return error_mark_node;
6065             }
6066
6067           /* Now it looks like a plain assignment.  */
6068           modifycode = NOP_EXPR;
6069         }
6070       gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
6071       gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
6072     }
6073
6074   /* The left-hand side must be an lvalue.  */
6075   if (!lvalue_or_else (lhs, lv_assign, complain))
6076     return error_mark_node;
6077
6078   /* Warn about modifying something that is `const'.  Don't warn if
6079      this is initialization.  */
6080   if (modifycode != INIT_EXPR
6081       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
6082           /* Functions are not modifiable, even though they are
6083              lvalues.  */
6084           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
6085           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
6086           /* If it's an aggregate and any field is const, then it is
6087              effectively const.  */
6088           || (CLASS_TYPE_P (lhstype)
6089               && C_TYPE_FIELDS_READONLY (lhstype))))
6090     {
6091       if (complain & tf_error)
6092         readonly_error (lhs, "assignment");
6093       else
6094         return error_mark_node;
6095     }
6096
6097   /* If storing into a structure or union member, it may have been given a
6098      lowered bitfield type.  We need to convert to the declared type first,
6099      so retrieve it now.  */
6100
6101   olhstype = unlowered_expr_type (lhs);
6102
6103   /* Convert new value to destination type.  */
6104
6105   if (TREE_CODE (lhstype) == ARRAY_TYPE)
6106     {
6107       int from_array;
6108
6109       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
6110                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
6111         {
6112           if (complain & tf_error)
6113             error ("incompatible types in assignment of %qT to %qT",
6114                    TREE_TYPE (rhs), lhstype);
6115           return error_mark_node;
6116         }
6117
6118       /* Allow array assignment in compiler-generated code.  */
6119       if (!current_function_decl || !DECL_ARTIFICIAL (current_function_decl))
6120         {
6121           /* This routine is used for both initialization and assignment.
6122              Make sure the diagnostic message differentiates the context.  */
6123           if (complain & tf_error)
6124             {
6125               if (modifycode == INIT_EXPR)
6126                 error ("array used as initializer");
6127               else
6128                 error ("invalid array assignment");
6129             }
6130           return error_mark_node;
6131         }
6132
6133       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6134                    ? 1 + (modifycode != INIT_EXPR): 0;
6135       return build_vec_init (lhs, NULL_TREE, newrhs,
6136                              /*explicit_value_init_p=*/false,
6137                              from_array, complain);
6138     }
6139
6140   if (modifycode == INIT_EXPR)
6141     newrhs = convert_for_initialization (lhs, olhstype, newrhs, LOOKUP_NORMAL,
6142                                          "initialization", NULL_TREE, 0,
6143                                          complain);
6144   else
6145     newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6146                                      NULL_TREE, 0, complain);
6147
6148   if (!same_type_p (lhstype, olhstype))
6149     newrhs = cp_convert_and_check (lhstype, newrhs);
6150
6151   if (modifycode != INIT_EXPR)
6152     {
6153       if (TREE_CODE (newrhs) == CALL_EXPR
6154           && TYPE_NEEDS_CONSTRUCTING (lhstype))
6155         newrhs = build_cplus_new (lhstype, newrhs);
6156
6157       /* Can't initialize directly from a TARGET_EXPR, since that would
6158          cause the lhs to be constructed twice, and possibly result in
6159          accidental self-initialization.  So we force the TARGET_EXPR to be
6160          expanded without a target.  */
6161       if (TREE_CODE (newrhs) == TARGET_EXPR)
6162         newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6163                          TREE_OPERAND (newrhs, 0));
6164     }
6165
6166   if (newrhs == error_mark_node)
6167     return error_mark_node;
6168
6169   if (c_dialect_objc () && flag_objc_gc)
6170     {
6171       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6172
6173       if (result)
6174         return result;
6175     }
6176
6177   result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6178                    lhstype, lhs, newrhs);
6179
6180   TREE_SIDE_EFFECTS (result) = 1;
6181   if (!plain_assign)
6182     TREE_NO_WARNING (result) = 1;
6183
6184   return result;
6185 }
6186
6187 tree
6188 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6189                      tsubst_flags_t complain)
6190 {
6191   if (processing_template_decl)
6192     return build_min_nt (MODOP_EXPR, lhs,
6193                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6194
6195   if (modifycode != NOP_EXPR)
6196     {
6197       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6198                                 make_node (modifycode),
6199                                 /*overloaded_p=*/NULL,
6200                                 complain);
6201       if (rval)
6202         {
6203           TREE_NO_WARNING (rval) = 1;
6204           return rval;
6205         }
6206     }
6207   return cp_build_modify_expr (lhs, modifycode, rhs, complain);
6208 }
6209
6210 /* Helper function for get_delta_difference which assumes FROM is a base
6211    class of TO.  Returns a delta for the conversion of pointer-to-member
6212    of FROM to pointer-to-member of TO.  If the conversion is invalid,
6213    returns zero.  If FROM is not a base class of TO, returns NULL_TREE.
6214    If C_CAST_P is true, this conversion is taking place as part of a C-style
6215    cast.  */
6216
6217 static tree
6218 get_delta_difference_1 (tree from, tree to, bool c_cast_p)
6219 {
6220   tree binfo;
6221   base_kind kind;
6222
6223   binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
6224   if (kind == bk_inaccessible || kind == bk_ambig)
6225     {
6226       error ("   in pointer to member function conversion");
6227       return size_zero_node;
6228     }
6229   else if (binfo)
6230     {
6231       if (kind != bk_via_virtual)
6232         return BINFO_OFFSET (binfo);
6233       else
6234         /* FROM is a virtual base class of TO.  Issue an error or warning
6235            depending on whether or not this is a reinterpret cast.  */
6236         {
6237           error ("pointer to member conversion via virtual base %qT",
6238                  BINFO_TYPE (binfo_from_vbase (binfo)));
6239
6240           return size_zero_node;
6241         }
6242       }
6243     else
6244       return NULL_TREE;
6245 }
6246
6247 /* Get difference in deltas for different pointer to member function
6248    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
6249    the conversion is invalid, the constant is zero.  If
6250    ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6251    If C_CAST_P is true this conversion is taking place as part of a
6252    C-style cast.
6253
6254    Note that the naming of FROM and TO is kind of backwards; the return
6255    value is what we add to a TO in order to get a FROM.  They are named
6256    this way because we call this function to find out how to convert from
6257    a pointer to member of FROM to a pointer to member of TO.  */
6258
6259 static tree
6260 get_delta_difference (tree from, tree to,
6261                       bool allow_inverse_p,
6262                       bool c_cast_p)
6263 {
6264   tree result;
6265
6266   if (same_type_ignoring_top_level_qualifiers_p (from, to))
6267     /* Pointer to member of incomplete class is permitted*/
6268     result = size_zero_node;
6269   else
6270     result = get_delta_difference_1 (from, to, c_cast_p);
6271
6272   if (!result)
6273   {
6274     if (!allow_inverse_p)
6275       {
6276         error_not_base_type (from, to);
6277         error ("   in pointer to member conversion");
6278         result = size_zero_node;
6279       }
6280     else
6281       {
6282         result = get_delta_difference_1 (to, from, c_cast_p);
6283
6284         if (result)
6285           result = size_diffop (size_zero_node, result);
6286         else
6287           {
6288             error_not_base_type (from, to);
6289             error ("   in pointer to member conversion");
6290             result = size_zero_node;
6291           }
6292       }
6293   }
6294
6295   return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
6296                                                       result));
6297 }
6298
6299 /* Return a constructor for the pointer-to-member-function TYPE using
6300    the other components as specified.  */
6301
6302 tree
6303 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
6304 {
6305   tree u = NULL_TREE;
6306   tree delta_field;
6307   tree pfn_field;
6308   VEC(constructor_elt, gc) *v;
6309
6310   /* Pull the FIELD_DECLs out of the type.  */
6311   pfn_field = TYPE_FIELDS (type);
6312   delta_field = TREE_CHAIN (pfn_field);
6313
6314   /* Make sure DELTA has the type we want.  */
6315   delta = convert_and_check (delta_type_node, delta);
6316
6317   /* Convert to the correct target type if necessary.  */
6318   pfn = fold_convert (TREE_TYPE (pfn_field), pfn);
6319
6320   /* Finish creating the initializer.  */
6321   v = VEC_alloc(constructor_elt, gc, 2);
6322   CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
6323   CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
6324   u = build_constructor (type, v);
6325   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
6326   TREE_STATIC (u) = (TREE_CONSTANT (u)
6327                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
6328                          != NULL_TREE)
6329                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
6330                          != NULL_TREE));
6331   return u;
6332 }
6333
6334 /* Build a constructor for a pointer to member function.  It can be
6335    used to initialize global variables, local variable, or used
6336    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
6337    want to be.
6338
6339    If FORCE is nonzero, then force this conversion, even if
6340    we would rather not do it.  Usually set when using an explicit
6341    cast.  A C-style cast is being processed iff C_CAST_P is true.
6342
6343    Return error_mark_node, if something goes wrong.  */
6344
6345 tree
6346 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
6347 {
6348   tree fn;
6349   tree pfn_type;
6350   tree to_type;
6351
6352   if (error_operand_p (pfn))
6353     return error_mark_node;
6354
6355   pfn_type = TREE_TYPE (pfn);
6356   to_type = build_ptrmemfunc_type (type);
6357
6358   /* Handle multiple conversions of pointer to member functions.  */
6359   if (TYPE_PTRMEMFUNC_P (pfn_type))
6360     {
6361       tree delta = NULL_TREE;
6362       tree npfn = NULL_TREE;
6363       tree n;
6364
6365       if (!force
6366           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
6367         error ("invalid conversion to type %qT from type %qT",
6368                to_type, pfn_type);
6369
6370       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
6371                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
6372                                 force,
6373                                 c_cast_p);
6374
6375       /* We don't have to do any conversion to convert a
6376          pointer-to-member to its own type.  But, we don't want to
6377          just return a PTRMEM_CST if there's an explicit cast; that
6378          cast should make the expression an invalid template argument.  */
6379       if (TREE_CODE (pfn) != PTRMEM_CST)
6380         {
6381           if (same_type_p (to_type, pfn_type))
6382             return pfn;
6383           else if (integer_zerop (n))
6384             return build_reinterpret_cast (to_type, pfn,
6385                                            tf_warning_or_error);
6386         }
6387
6388       if (TREE_SIDE_EFFECTS (pfn))
6389         pfn = save_expr (pfn);
6390
6391       /* Obtain the function pointer and the current DELTA.  */
6392       if (TREE_CODE (pfn) == PTRMEM_CST)
6393         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6394       else
6395         {
6396           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6397           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6398         }
6399
6400       /* Just adjust the DELTA field.  */
6401       gcc_assert  (same_type_ignoring_top_level_qualifiers_p
6402                    (TREE_TYPE (delta), ptrdiff_type_node));
6403       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6404         n = cp_build_binary_op (input_location,
6405                                 LSHIFT_EXPR, n, integer_one_node,
6406                                 tf_warning_or_error);
6407       delta = cp_build_binary_op (input_location,
6408                                   PLUS_EXPR, delta, n, tf_warning_or_error);
6409       return build_ptrmemfunc1 (to_type, delta, npfn);
6410     }
6411
6412   /* Handle null pointer to member function conversions.  */
6413   if (integer_zerop (pfn))
6414     {
6415       pfn = build_c_cast (type, integer_zero_node);
6416       return build_ptrmemfunc1 (to_type,
6417                                 integer_zero_node,
6418                                 pfn);
6419     }
6420
6421   if (type_unknown_p (pfn))
6422     return instantiate_type (type, pfn, tf_warning_or_error);
6423
6424   fn = TREE_OPERAND (pfn, 0);
6425   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6426               /* In a template, we will have preserved the
6427                  OFFSET_REF.  */
6428               || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6429   return make_ptrmem_cst (to_type, fn);
6430 }
6431
6432 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6433    given by CST.
6434
6435    ??? There is no consistency as to the types returned for the above
6436    values.  Some code acts as if it were a sizetype and some as if it were
6437    integer_type_node.  */
6438
6439 void
6440 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6441 {
6442   tree type = TREE_TYPE (cst);
6443   tree fn = PTRMEM_CST_MEMBER (cst);
6444   tree ptr_class, fn_class;
6445
6446   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6447
6448   /* The class that the function belongs to.  */
6449   fn_class = DECL_CONTEXT (fn);
6450
6451   /* The class that we're creating a pointer to member of.  */
6452   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6453
6454   /* First, calculate the adjustment to the function's class.  */
6455   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6456                                  /*c_cast_p=*/0);
6457
6458   if (!DECL_VIRTUAL_P (fn))
6459     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6460   else
6461     {
6462       /* If we're dealing with a virtual function, we have to adjust 'this'
6463          again, to point to the base which provides the vtable entry for
6464          fn; the call will do the opposite adjustment.  */
6465       tree orig_class = DECL_CONTEXT (fn);
6466       tree binfo = binfo_or_else (orig_class, fn_class);
6467       *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6468                        *delta, BINFO_OFFSET (binfo));
6469       *delta = fold_if_not_in_template (*delta);
6470
6471       /* We set PFN to the vtable offset at which the function can be
6472          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6473          case delta is shifted left, and then incremented).  */
6474       *pfn = DECL_VINDEX (fn);
6475       *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6476                      TYPE_SIZE_UNIT (vtable_entry_type));
6477       *pfn = fold_if_not_in_template (*pfn);
6478
6479       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6480         {
6481         case ptrmemfunc_vbit_in_pfn:
6482           *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6483                          integer_one_node);
6484           *pfn = fold_if_not_in_template (*pfn);
6485           break;
6486
6487         case ptrmemfunc_vbit_in_delta:
6488           *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6489                            *delta, integer_one_node);
6490           *delta = fold_if_not_in_template (*delta);
6491           *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6492                            *delta, integer_one_node);
6493           *delta = fold_if_not_in_template (*delta);
6494           break;
6495
6496         default:
6497           gcc_unreachable ();
6498         }
6499
6500       *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6501       *pfn = fold_if_not_in_template (*pfn);
6502     }
6503 }
6504
6505 /* Return an expression for PFN from the pointer-to-member function
6506    given by T.  */
6507
6508 static tree
6509 pfn_from_ptrmemfunc (tree t)
6510 {
6511   if (TREE_CODE (t) == PTRMEM_CST)
6512     {
6513       tree delta;
6514       tree pfn;
6515
6516       expand_ptrmemfunc_cst (t, &delta, &pfn);
6517       if (pfn)
6518         return pfn;
6519     }
6520
6521   return build_ptrmemfunc_access_expr (t, pfn_identifier);
6522 }
6523
6524 /* Return an expression for DELTA from the pointer-to-member function
6525    given by T.  */
6526
6527 static tree
6528 delta_from_ptrmemfunc (tree t)
6529 {
6530   if (TREE_CODE (t) == PTRMEM_CST)
6531     {
6532       tree delta;
6533       tree pfn;
6534
6535       expand_ptrmemfunc_cst (t, &delta, &pfn);
6536       if (delta)
6537         return delta;
6538     }
6539
6540   return build_ptrmemfunc_access_expr (t, delta_identifier);
6541 }
6542
6543 /* Convert value RHS to type TYPE as preparation for an assignment to
6544    an lvalue of type TYPE.  ERRTYPE is a string to use in error
6545    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
6546    are doing the conversion in order to pass the PARMNUMth argument of
6547    FNDECL.  */
6548
6549 static tree
6550 convert_for_assignment (tree type, tree rhs,
6551                         const char *errtype, tree fndecl, int parmnum,
6552                         tsubst_flags_t complain)
6553 {
6554   tree rhstype;
6555   enum tree_code coder;
6556
6557   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
6558   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6559     rhs = TREE_OPERAND (rhs, 0);
6560
6561   rhstype = TREE_TYPE (rhs);
6562   coder = TREE_CODE (rhstype);
6563
6564   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6565       && vector_types_convertible_p (type, rhstype, true))
6566     return convert (type, rhs);
6567
6568   if (rhs == error_mark_node || rhstype == error_mark_node)
6569     return error_mark_node;
6570   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6571     return error_mark_node;
6572
6573   /* The RHS of an assignment cannot have void type.  */
6574   if (coder == VOID_TYPE)
6575     {
6576       if (complain & tf_error)
6577         error ("void value not ignored as it ought to be");
6578       return error_mark_node;
6579     }
6580
6581   /* Simplify the RHS if possible.  */
6582   if (TREE_CODE (rhs) == CONST_DECL)
6583     rhs = DECL_INITIAL (rhs);
6584
6585   if (c_dialect_objc ())
6586     {
6587       int parmno;
6588       tree rname = fndecl;
6589
6590       if (!strcmp (errtype, "assignment"))
6591         parmno = -1;
6592       else if (!strcmp (errtype, "initialization"))
6593         parmno = -2;
6594       else
6595         {
6596           tree selector = objc_message_selector ();
6597
6598           parmno = parmnum;
6599
6600           if (selector && parmno > 1)
6601             {
6602               rname = selector;
6603               parmno -= 1;
6604             }
6605         }
6606
6607       if (objc_compare_types (type, rhstype, parmno, rname))
6608         return convert (type, rhs);
6609     }
6610
6611   /* [expr.ass]
6612
6613      The expression is implicitly converted (clause _conv_) to the
6614      cv-unqualified type of the left operand.
6615
6616      We allow bad conversions here because by the time we get to this point
6617      we are committed to doing the conversion.  If we end up doing a bad
6618      conversion, convert_like will complain.  */
6619   if (!can_convert_arg_bad (type, rhstype, rhs))
6620     {
6621       /* When -Wno-pmf-conversions is use, we just silently allow
6622          conversions from pointers-to-members to plain pointers.  If
6623          the conversion doesn't work, cp_convert will complain.  */
6624       if (!warn_pmf2ptr
6625           && TYPE_PTR_P (type)
6626           && TYPE_PTRMEMFUNC_P (rhstype))
6627         rhs = cp_convert (strip_top_quals (type), rhs);
6628       else
6629         {
6630           if (complain & tf_error)
6631             {
6632               /* If the right-hand side has unknown type, then it is an
6633                  overloaded function.  Call instantiate_type to get error
6634                  messages.  */
6635               if (rhstype == unknown_type_node)
6636                 instantiate_type (type, rhs, tf_warning_or_error);
6637               else if (fndecl)
6638                 error ("cannot convert %qT to %qT for argument %qP to %qD",
6639                        rhstype, type, parmnum, fndecl);
6640               else
6641                 error ("cannot convert %qT to %qT in %s", rhstype, type,
6642                        errtype);
6643             }
6644           return error_mark_node;
6645         }
6646     }
6647   if (warn_missing_format_attribute)
6648     {
6649       const enum tree_code codel = TREE_CODE (type);
6650       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6651           && coder == codel
6652           && check_missing_format_attribute (type, rhstype)
6653           && (complain & tf_warning))
6654         warning (OPT_Wmissing_format_attribute,
6655                  "%s might be a candidate for a format attribute",
6656                  errtype);
6657     }
6658
6659   /* If -Wparentheses, warn about a = b = c when a has type bool and b
6660      does not.  */
6661   if (warn_parentheses
6662       && type == boolean_type_node
6663       && TREE_CODE (rhs) == MODIFY_EXPR
6664       && !TREE_NO_WARNING (rhs)
6665       && TREE_TYPE (rhs) != boolean_type_node
6666       && (complain & tf_warning))
6667     {
6668       warning (OPT_Wparentheses,
6669                "suggest parentheses around assignment used as truth value");
6670       TREE_NO_WARNING (rhs) = 1;
6671     }
6672
6673   return perform_implicit_conversion (strip_top_quals (type), rhs, complain);
6674 }
6675
6676 /* Convert RHS to be of type TYPE.
6677    If EXP is nonzero, it is the target of the initialization.
6678    ERRTYPE is a string to use in error messages.
6679
6680    Two major differences between the behavior of
6681    `convert_for_assignment' and `convert_for_initialization'
6682    are that references are bashed in the former, while
6683    copied in the latter, and aggregates are assigned in
6684    the former (operator=) while initialized in the
6685    latter (X(X&)).
6686
6687    If using constructor make sure no conversion operator exists, if one does
6688    exist, an ambiguity exists.
6689
6690    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
6691
6692 tree
6693 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
6694                             const char *errtype, tree fndecl, int parmnum,
6695                             tsubst_flags_t complain)
6696 {
6697   enum tree_code codel = TREE_CODE (type);
6698   tree rhstype;
6699   enum tree_code coder;
6700
6701   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6702      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
6703   if (TREE_CODE (rhs) == NOP_EXPR
6704       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6705       && codel != REFERENCE_TYPE)
6706     rhs = TREE_OPERAND (rhs, 0);
6707
6708   if (type == error_mark_node
6709       || rhs == error_mark_node
6710       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6711     return error_mark_node;
6712
6713   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6714        && TREE_CODE (type) != ARRAY_TYPE
6715        && (TREE_CODE (type) != REFERENCE_TYPE
6716            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6717       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6718           && (TREE_CODE (type) != REFERENCE_TYPE
6719               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6720       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6721     rhs = decay_conversion (rhs);
6722
6723   rhstype = TREE_TYPE (rhs);
6724   coder = TREE_CODE (rhstype);
6725
6726   if (coder == ERROR_MARK)
6727     return error_mark_node;
6728
6729   /* We accept references to incomplete types, so we can
6730      return here before checking if RHS is of complete type.  */
6731
6732   if (codel == REFERENCE_TYPE)
6733     {
6734       /* This should eventually happen in convert_arguments.  */
6735       int savew = 0, savee = 0;
6736
6737       if (fndecl)
6738         savew = warningcount, savee = errorcount;
6739       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
6740                                   /*cleanup=*/NULL);
6741       if (fndecl)
6742         {
6743           if (warningcount > savew)
6744             warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
6745           else if (errorcount > savee)
6746             error ("in passing argument %P of %q+D", parmnum, fndecl);
6747         }
6748       return rhs;
6749     }
6750
6751   if (exp != 0)
6752     exp = require_complete_type (exp);
6753   if (exp == error_mark_node)
6754     return error_mark_node;
6755
6756   rhstype = non_reference (rhstype);
6757
6758   type = complete_type (type);
6759
6760   if (MAYBE_CLASS_TYPE_P (type))
6761     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6762
6763   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum,
6764                                  complain);
6765 }
6766 \f
6767 /* If RETVAL is the address of, or a reference to, a local variable or
6768    temporary give an appropriate warning.  */
6769
6770 static void
6771 maybe_warn_about_returning_address_of_local (tree retval)
6772 {
6773   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6774   tree whats_returned = retval;
6775
6776   for (;;)
6777     {
6778       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6779         whats_returned = TREE_OPERAND (whats_returned, 1);
6780       else if (CONVERT_EXPR_P (whats_returned)
6781                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR)
6782         whats_returned = TREE_OPERAND (whats_returned, 0);
6783       else
6784         break;
6785     }
6786
6787   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6788     return;
6789   whats_returned = TREE_OPERAND (whats_returned, 0);
6790
6791   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6792     {
6793       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6794           || TREE_CODE (whats_returned) == TARGET_EXPR)
6795         {
6796           warning (0, "returning reference to temporary");
6797           return;
6798         }
6799       if (TREE_CODE (whats_returned) == VAR_DECL
6800           && DECL_NAME (whats_returned)
6801           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6802         {
6803           warning (0, "reference to non-lvalue returned");
6804           return;
6805         }
6806     }
6807
6808   while (TREE_CODE (whats_returned) == COMPONENT_REF
6809          || TREE_CODE (whats_returned) == ARRAY_REF)
6810     whats_returned = TREE_OPERAND (whats_returned, 0);
6811
6812   if (DECL_P (whats_returned)
6813       && DECL_NAME (whats_returned)
6814       && DECL_FUNCTION_SCOPE_P (whats_returned)
6815       && !(TREE_STATIC (whats_returned)
6816            || TREE_PUBLIC (whats_returned)))
6817     {
6818       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6819         warning (0, "reference to local variable %q+D returned",
6820                  whats_returned);
6821       else
6822         warning (0, "address of local variable %q+D returned",
6823                  whats_returned);
6824       return;
6825     }
6826 }
6827
6828 /* Check that returning RETVAL from the current function is valid.
6829    Return an expression explicitly showing all conversions required to
6830    change RETVAL into the function return type, and to assign it to
6831    the DECL_RESULT for the function.  Set *NO_WARNING to true if
6832    code reaches end of non-void function warning shouldn't be issued
6833    on this RETURN_EXPR.  */
6834
6835 tree
6836 check_return_expr (tree retval, bool *no_warning)
6837 {
6838   tree result;
6839   /* The type actually returned by the function, after any
6840      promotions.  */
6841   tree valtype;
6842   int fn_returns_value_p;
6843   bool named_return_value_okay_p;
6844
6845   *no_warning = false;
6846
6847   /* A `volatile' function is one that isn't supposed to return, ever.
6848      (This is a G++ extension, used to get better code for functions
6849      that call the `volatile' function.)  */
6850   if (TREE_THIS_VOLATILE (current_function_decl))
6851     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6852
6853   /* Check for various simple errors.  */
6854   if (DECL_DESTRUCTOR_P (current_function_decl))
6855     {
6856       if (retval)
6857         error ("returning a value from a destructor");
6858       return NULL_TREE;
6859     }
6860   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6861     {
6862       if (in_function_try_handler)
6863         /* If a return statement appears in a handler of the
6864            function-try-block of a constructor, the program is ill-formed.  */
6865         error ("cannot return from a handler of a function-try-block of a constructor");
6866       else if (retval)
6867         /* You can't return a value from a constructor.  */
6868         error ("returning a value from a constructor");
6869       return NULL_TREE;
6870     }
6871
6872   if (processing_template_decl)
6873     {
6874       current_function_returns_value = 1;
6875       if (check_for_bare_parameter_packs (retval))
6876         retval = error_mark_node;
6877       return retval;
6878     }
6879
6880   /* When no explicit return-value is given in a function with a named
6881      return value, the named return value is used.  */
6882   result = DECL_RESULT (current_function_decl);
6883   valtype = TREE_TYPE (result);
6884   gcc_assert (valtype != NULL_TREE);
6885   fn_returns_value_p = !VOID_TYPE_P (valtype);
6886   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6887     retval = result;
6888
6889   /* Check for a return statement with no return value in a function
6890      that's supposed to return a value.  */
6891   if (!retval && fn_returns_value_p)
6892     {
6893       permerror (input_location, "return-statement with no value, in function returning %qT",
6894                  valtype);
6895       /* Clear this, so finish_function won't say that we reach the
6896          end of a non-void function (which we don't, we gave a
6897          return!).  */
6898       current_function_returns_null = 0;
6899       /* And signal caller that TREE_NO_WARNING should be set on the
6900          RETURN_EXPR to avoid control reaches end of non-void function
6901          warnings in tree-cfg.c.  */
6902       *no_warning = true;
6903     }
6904   /* Check for a return statement with a value in a function that
6905      isn't supposed to return a value.  */
6906   else if (retval && !fn_returns_value_p)
6907     {
6908       if (VOID_TYPE_P (TREE_TYPE (retval)))
6909         /* You can return a `void' value from a function of `void'
6910            type.  In that case, we have to evaluate the expression for
6911            its side-effects.  */
6912           finish_expr_stmt (retval);
6913       else
6914         permerror (input_location, "return-statement with a value, in function "
6915                    "returning 'void'");
6916       current_function_returns_null = 1;
6917
6918       /* There's really no value to return, after all.  */
6919       return NULL_TREE;
6920     }
6921   else if (!retval)
6922     /* Remember that this function can sometimes return without a
6923        value.  */
6924     current_function_returns_null = 1;
6925   else
6926     /* Remember that this function did return a value.  */
6927     current_function_returns_value = 1;
6928
6929   /* Check for erroneous operands -- but after giving ourselves a
6930      chance to provide an error about returning a value from a void
6931      function.  */
6932   if (error_operand_p (retval))
6933     {
6934       current_function_return_value = error_mark_node;
6935       return error_mark_node;
6936     }
6937
6938   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6939   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6940        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6941       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6942       && ! flag_check_new
6943       && retval && null_ptr_cst_p (retval))
6944     warning (0, "%<operator new%> must not return NULL unless it is "
6945              "declared %<throw()%> (or -fcheck-new is in effect)");
6946
6947   /* Effective C++ rule 15.  See also start_function.  */
6948   if (warn_ecpp
6949       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6950     {
6951       bool warn = true;
6952
6953       /* The function return type must be a reference to the current
6954         class.  */
6955       if (TREE_CODE (valtype) == REFERENCE_TYPE
6956           && same_type_ignoring_top_level_qualifiers_p
6957               (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6958         {
6959           /* Returning '*this' is obviously OK.  */
6960           if (retval == current_class_ref)
6961             warn = false;
6962           /* If we are calling a function whose return type is the same of
6963              the current class reference, it is ok.  */
6964           else if (TREE_CODE (retval) == INDIRECT_REF
6965                    && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6966             warn = false;
6967         }
6968
6969       if (warn)
6970         warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
6971     }
6972
6973   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6974
6975      [...]      For  a function with a class return type, if the expression
6976      in the return statement is the name of a local  object,  and  the  cv-
6977      unqualified  type  of  the  local  object  is the same as the function
6978      return type, an implementation is permitted to omit creating the  tem-
6979      porary  object  to  hold  the function return value [...]
6980
6981      So, if this is a value-returning function that always returns the same
6982      local variable, remember it.
6983
6984      It might be nice to be more flexible, and choose the first suitable
6985      variable even if the function sometimes returns something else, but
6986      then we run the risk of clobbering the variable we chose if the other
6987      returned expression uses the chosen variable somehow.  And people expect
6988      this restriction, anyway.  (jason 2000-11-19)
6989
6990      See finish_function and finalize_nrv for the rest of this optimization.  */
6991
6992   named_return_value_okay_p =
6993     (retval != NULL_TREE
6994      /* Must be a local, automatic variable.  */
6995      && TREE_CODE (retval) == VAR_DECL
6996      && DECL_CONTEXT (retval) == current_function_decl
6997      && ! TREE_STATIC (retval)
6998      && ! DECL_ANON_UNION_VAR_P (retval)
6999      && (DECL_ALIGN (retval)
7000          >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
7001      /* The cv-unqualified type of the returned value must be the
7002         same as the cv-unqualified return type of the
7003         function.  */
7004      && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
7005                      (TYPE_MAIN_VARIANT
7006                       (TREE_TYPE (TREE_TYPE (current_function_decl)))))
7007      /* And the returned value must be non-volatile.  */
7008      && ! TYPE_VOLATILE (TREE_TYPE (retval)));
7009
7010   if (fn_returns_value_p && flag_elide_constructors)
7011     {
7012       if (named_return_value_okay_p
7013           && (current_function_return_value == NULL_TREE
7014               || current_function_return_value == retval))
7015         current_function_return_value = retval;
7016       else
7017         current_function_return_value = error_mark_node;
7018     }
7019
7020   /* We don't need to do any conversions when there's nothing being
7021      returned.  */
7022   if (!retval)
7023     return NULL_TREE;
7024
7025   /* Do any required conversions.  */
7026   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
7027     /* No conversions are required.  */
7028     ;
7029   else
7030     {
7031       /* The type the function is declared to return.  */
7032       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
7033       int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
7034
7035       /* The functype's return type will have been set to void, if it
7036          was an incomplete type.  Just treat this as 'return;' */
7037       if (VOID_TYPE_P (functype))
7038         return error_mark_node;
7039
7040       /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
7041          treated as an rvalue for the purposes of overload resolution to
7042          favor move constructors over copy constructors.  */
7043       if ((cxx_dialect != cxx98)
7044           && named_return_value_okay_p
7045           /* The variable must not have the `volatile' qualifier.  */
7046           && !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
7047           /* The return type must be a class type.  */
7048           && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
7049         flags = flags | LOOKUP_PREFER_RVALUE;
7050
7051       /* First convert the value to the function's return type, then
7052          to the type of return value's location to handle the
7053          case that functype is smaller than the valtype.  */
7054       retval = convert_for_initialization
7055         (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0,
7056          tf_warning_or_error);
7057       retval = convert (valtype, retval);
7058
7059       /* If the conversion failed, treat this just like `return;'.  */
7060       if (retval == error_mark_node)
7061         return retval;
7062       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
7063       else if (! cfun->returns_struct
7064                && TREE_CODE (retval) == TARGET_EXPR
7065                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
7066         retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
7067                          TREE_OPERAND (retval, 0));
7068       else
7069         maybe_warn_about_returning_address_of_local (retval);
7070     }
7071
7072   /* Actually copy the value returned into the appropriate location.  */
7073   if (retval && retval != result)
7074     retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
7075
7076   return retval;
7077 }
7078
7079 \f
7080 /* Returns nonzero if the pointer-type FROM can be converted to the
7081    pointer-type TO via a qualification conversion.  If CONSTP is -1,
7082    then we return nonzero if the pointers are similar, and the
7083    cv-qualification signature of FROM is a proper subset of that of TO.
7084
7085    If CONSTP is positive, then all outer pointers have been
7086    const-qualified.  */
7087
7088 static int
7089 comp_ptr_ttypes_real (tree to, tree from, int constp)
7090 {
7091   bool to_more_cv_qualified = false;
7092   bool is_opaque_pointer = false;
7093
7094   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7095     {
7096       if (TREE_CODE (to) != TREE_CODE (from))
7097         return 0;
7098
7099       if (TREE_CODE (from) == OFFSET_TYPE
7100           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
7101                            TYPE_OFFSET_BASETYPE (to)))
7102         return 0;
7103
7104       /* Const and volatile mean something different for function types,
7105          so the usual checks are not appropriate.  */
7106       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7107         {
7108           /* In Objective-C++, some types may have been 'volatilized' by
7109              the compiler for EH; when comparing them here, the volatile
7110              qualification must be ignored.  */
7111           bool objc_quals_match = objc_type_quals_match (to, from);
7112
7113           if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
7114             return 0;
7115
7116           if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
7117             {
7118               if (constp == 0)
7119                 return 0;
7120               to_more_cv_qualified = true;
7121             }
7122
7123           if (constp > 0)
7124             constp &= TYPE_READONLY (to);
7125         }
7126
7127       if (TREE_CODE (to) == VECTOR_TYPE)
7128         is_opaque_pointer = vector_targets_convertible_p (to, from);
7129
7130       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
7131         return ((constp >= 0 || to_more_cv_qualified)
7132                 && (is_opaque_pointer
7133                     || same_type_ignoring_top_level_qualifiers_p (to, from)));
7134     }
7135 }
7136
7137 /* When comparing, say, char ** to char const **, this function takes
7138    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
7139    types to this function.  */
7140
7141 int
7142 comp_ptr_ttypes (tree to, tree from)
7143 {
7144   return comp_ptr_ttypes_real (to, from, 1);
7145 }
7146
7147 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7148    type or inheritance-related types, regardless of cv-quals.  */
7149
7150 int
7151 ptr_reasonably_similar (const_tree to, const_tree from)
7152 {
7153   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7154     {
7155       /* Any target type is similar enough to void.  */
7156       if (TREE_CODE (to) == VOID_TYPE
7157           || TREE_CODE (from) == VOID_TYPE)
7158         return 1;
7159
7160       if (TREE_CODE (to) != TREE_CODE (from))
7161         return 0;
7162
7163       if (TREE_CODE (from) == OFFSET_TYPE
7164           && comptypes (TYPE_OFFSET_BASETYPE (to),
7165                         TYPE_OFFSET_BASETYPE (from),
7166                         COMPARE_BASE | COMPARE_DERIVED))
7167         continue;
7168
7169       if (TREE_CODE (to) == VECTOR_TYPE
7170           && vector_types_convertible_p (to, from, false))
7171         return 1;
7172
7173       if (TREE_CODE (to) == INTEGER_TYPE
7174           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
7175         return 1;
7176
7177       if (TREE_CODE (to) == FUNCTION_TYPE)
7178         return 1;
7179
7180       if (TREE_CODE (to) != POINTER_TYPE)
7181         return comptypes
7182           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7183            COMPARE_BASE | COMPARE_DERIVED);
7184     }
7185 }
7186
7187 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7188    pointer-to-member types) are the same, ignoring cv-qualification at
7189    all levels.  */
7190
7191 bool
7192 comp_ptr_ttypes_const (tree to, tree from)
7193 {
7194   bool is_opaque_pointer = false;
7195
7196   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7197     {
7198       if (TREE_CODE (to) != TREE_CODE (from))
7199         return false;
7200
7201       if (TREE_CODE (from) == OFFSET_TYPE
7202           && same_type_p (TYPE_OFFSET_BASETYPE (from),
7203                           TYPE_OFFSET_BASETYPE (to)))
7204           continue;
7205
7206       if (TREE_CODE (to) == VECTOR_TYPE)
7207         is_opaque_pointer = vector_targets_convertible_p (to, from);
7208
7209       if (TREE_CODE (to) != POINTER_TYPE)
7210         return (is_opaque_pointer
7211                 || same_type_ignoring_top_level_qualifiers_p (to, from));
7212     }
7213 }
7214
7215 /* Returns the type qualifiers for this type, including the qualifiers on the
7216    elements for an array type.  */
7217
7218 int
7219 cp_type_quals (const_tree type)
7220 {
7221   /* This CONST_CAST is okay because strip_array_types returns its
7222      argument unmodified and we assign it to a const_tree.  */
7223   type = strip_array_types (CONST_CAST_TREE(type));
7224   if (type == error_mark_node)
7225     return TYPE_UNQUALIFIED;
7226   return TYPE_QUALS (type);
7227 }
7228
7229 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7230    arrays.  */
7231
7232 bool
7233 cp_type_readonly (const_tree type)
7234 {
7235   /* This CONST_CAST is okay because strip_array_types returns its
7236      argument unmodified and we assign it to a const_tree.  */
7237   type = strip_array_types (CONST_CAST_TREE(type));
7238   return TYPE_READONLY (type);
7239 }
7240
7241 /* Returns nonzero if the TYPE contains a mutable member.  */
7242
7243 bool
7244 cp_has_mutable_p (const_tree type)
7245 {
7246   /* This CONST_CAST is okay because strip_array_types returns its
7247      argument unmodified and we assign it to a const_tree.  */
7248   type = strip_array_types (CONST_CAST_TREE(type));
7249
7250   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
7251 }
7252
7253 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7254    TYPE_QUALS.  For a VAR_DECL, this may be an optimistic
7255    approximation.  In particular, consider:
7256
7257      int f();
7258      struct S { int i; };
7259      const S s = { f(); }
7260
7261    Here, we will make "s" as TREE_READONLY (because it is declared
7262    "const") -- only to reverse ourselves upon seeing that the
7263    initializer is non-constant.  */
7264
7265 void
7266 cp_apply_type_quals_to_decl (int type_quals, tree decl)
7267 {
7268   tree type = TREE_TYPE (decl);
7269
7270   if (type == error_mark_node)
7271     return;
7272
7273   if (TREE_CODE (decl) == TYPE_DECL)
7274     return;
7275
7276   if (TREE_CODE (type) == FUNCTION_TYPE
7277       && type_quals != TYPE_UNQUALIFIED)
7278     {
7279       /* This was an error in C++98 (cv-qualifiers cannot be added to
7280          a function type), but DR 295 makes the code well-formed by
7281          dropping the extra qualifiers. */
7282       if (pedantic)
7283         {
7284           tree bad_type = build_qualified_type (type, type_quals);
7285           pedwarn (input_location, OPT_pedantic,
7286                    "ignoring %qV qualifiers added to function type %qT",
7287                    bad_type, type);
7288         }
7289
7290       TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
7291       return;
7292     }
7293
7294   /* Avoid setting TREE_READONLY incorrectly.  */
7295   if (/* If the object has a constructor, the constructor may modify
7296          the object.  */
7297       TYPE_NEEDS_CONSTRUCTING (type)
7298       /* If the type isn't complete, we don't know yet if it will need
7299          constructing.  */
7300       || !COMPLETE_TYPE_P (type)
7301       /* If the type has a mutable component, that component might be
7302          modified.  */
7303       || TYPE_HAS_MUTABLE_P (type))
7304     type_quals &= ~TYPE_QUAL_CONST;
7305
7306   c_apply_type_quals_to_decl (type_quals, decl);
7307 }
7308
7309 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
7310    exemplar types such that casting T1 to T2 is casting away constness
7311    if and only if there is no implicit conversion from T1 to T2.  */
7312
7313 static void
7314 casts_away_constness_r (tree *t1, tree *t2)
7315 {
7316   int quals1;
7317   int quals2;
7318
7319   /* [expr.const.cast]
7320
7321      For multi-level pointer to members and multi-level mixed pointers
7322      and pointers to members (conv.qual), the "member" aspect of a
7323      pointer to member level is ignored when determining if a const
7324      cv-qualifier has been cast away.  */
7325   /* [expr.const.cast]
7326
7327      For  two  pointer types:
7328
7329             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
7330             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
7331             K is min(N,M)
7332
7333      casting from X1 to X2 casts away constness if, for a non-pointer
7334      type T there does not exist an implicit conversion (clause
7335      _conv_) from:
7336
7337             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7338
7339      to
7340
7341             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
7342   if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
7343       || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
7344     {
7345       *t1 = cp_build_qualified_type (void_type_node,
7346                                      cp_type_quals (*t1));
7347       *t2 = cp_build_qualified_type (void_type_node,
7348                                      cp_type_quals (*t2));
7349       return;
7350     }
7351
7352   quals1 = cp_type_quals (*t1);
7353   quals2 = cp_type_quals (*t2);
7354
7355   if (TYPE_PTRMEM_P (*t1))
7356     *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
7357   else
7358     *t1 = TREE_TYPE (*t1);
7359   if (TYPE_PTRMEM_P (*t2))
7360     *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
7361   else
7362     *t2 = TREE_TYPE (*t2);
7363
7364   casts_away_constness_r (t1, t2);
7365   *t1 = build_pointer_type (*t1);
7366   *t2 = build_pointer_type (*t2);
7367   *t1 = cp_build_qualified_type (*t1, quals1);
7368   *t2 = cp_build_qualified_type (*t2, quals2);
7369 }
7370
7371 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7372    constness.
7373
7374    ??? This function returns non-zero if casting away qualifiers not
7375    just const.  We would like to return to the caller exactly which
7376    qualifiers are casted away to give more accurate diagnostics.
7377 */
7378
7379 static bool
7380 casts_away_constness (tree t1, tree t2)
7381 {
7382   if (TREE_CODE (t2) == REFERENCE_TYPE)
7383     {
7384       /* [expr.const.cast]
7385
7386          Casting from an lvalue of type T1 to an lvalue of type T2
7387          using a reference cast casts away constness if a cast from an
7388          rvalue of type "pointer to T1" to the type "pointer to T2"
7389          casts away constness.  */
7390       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
7391       return casts_away_constness (build_pointer_type (t1),
7392                                    build_pointer_type (TREE_TYPE (t2)));
7393     }
7394
7395   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
7396     /* [expr.const.cast]
7397
7398        Casting from an rvalue of type "pointer to data member of X
7399        of type T1" to the type "pointer to data member of Y of type
7400        T2" casts away constness if a cast from an rvalue of type
7401        "pointer to T1" to the type "pointer to T2" casts away
7402        constness.  */
7403     return casts_away_constness
7404       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
7405        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
7406
7407   /* Casting away constness is only something that makes sense for
7408      pointer or reference types.  */
7409   if (TREE_CODE (t1) != POINTER_TYPE
7410       || TREE_CODE (t2) != POINTER_TYPE)
7411     return false;
7412
7413   /* Top-level qualifiers don't matter.  */
7414   t1 = TYPE_MAIN_VARIANT (t1);
7415   t2 = TYPE_MAIN_VARIANT (t2);
7416   casts_away_constness_r (&t1, &t2);
7417   if (!can_convert (t2, t1))
7418     return true;
7419
7420   return false;
7421 }
7422
7423 /* If T is a REFERENCE_TYPE return the type to which T refers.
7424    Otherwise, return T itself.  */
7425
7426 tree
7427 non_reference (tree t)
7428 {
7429   if (TREE_CODE (t) == REFERENCE_TYPE)
7430     t = TREE_TYPE (t);
7431   return t;
7432 }
7433
7434
7435 /* Return nonzero if REF is an lvalue valid for this language;
7436    otherwise, print an error message and return zero.  USE says
7437    how the lvalue is being used and so selects the error message.  */
7438
7439 int
7440 lvalue_or_else (tree ref, enum lvalue_use use, tsubst_flags_t complain)
7441 {
7442   int win = lvalue_p (ref);
7443
7444   if (!win && (complain & tf_error))
7445     lvalue_error (use);
7446
7447   return win;
7448 }