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