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