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