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