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