gcc/cp/typeck.c

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