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