gcc/cp/typeck.c

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