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