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