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               || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
3186                                                         TREE_TYPE (type1)))
3187             {
3188               binary_op_error (code);
3189               return error_mark_node;
3190             }
3191           arithmetic_types_p = 1;
3192         }
3193     }
3194   /* Determine the RESULT_TYPE, if it is not already known.  */
3195   if (!result_type
3196       && arithmetic_types_p
3197       && (shorten || common || short_compare))
3198     result_type = common_type (type0, type1);
3199
3200   if (!result_type)
3201     {
3202       error ("invalid operands of types %qT and %qT to binary %qO",
3203              TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3204       return error_mark_node;
3205     }
3206
3207   /* If we're in a template, the only thing we need to know is the
3208      RESULT_TYPE.  */
3209   if (processing_template_decl)
3210     return build2 (resultcode,
3211                    build_type ? build_type : result_type,
3212                    op0, op1);
3213
3214   if (arithmetic_types_p)
3215     {
3216       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3217
3218       /* For certain operations (which identify themselves by shorten != 0)
3219          if both args were extended from the same smaller type,
3220          do the arithmetic in that type and then extend.
3221
3222          shorten !=0 and !=1 indicates a bitwise operation.
3223          For them, this optimization is safe only if
3224          both args are zero-extended or both are sign-extended.
3225          Otherwise, we might change the result.
3226          Eg, (short)-1 | (unsigned short)-1 is (int)-1
3227          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3228
3229       if (shorten && none_complex)
3230         {
3231           int unsigned0, unsigned1;
3232           tree arg0 = get_narrower (op0, &unsigned0);
3233           tree arg1 = get_narrower (op1, &unsigned1);
3234           /* UNS is 1 if the operation to be done is an unsigned one.  */
3235           int uns = TYPE_UNSIGNED (result_type);
3236           tree type;
3237
3238           final_type = result_type;
3239
3240           /* Handle the case that OP0 does not *contain* a conversion
3241              but it *requires* conversion to FINAL_TYPE.  */
3242
3243           if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3244             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3245           if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3246             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3247
3248           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
3249
3250           /* For bitwise operations, signedness of nominal type
3251              does not matter.  Consider only how operands were extended.  */
3252           if (shorten == -1)
3253             uns = unsigned0;
3254
3255           /* Note that in all three cases below we refrain from optimizing
3256              an unsigned operation on sign-extended args.
3257              That would not be valid.  */
3258
3259           /* Both args variable: if both extended in same way
3260              from same width, do it in that width.
3261              Do it unsigned if args were zero-extended.  */
3262           if ((TYPE_PRECISION (TREE_TYPE (arg0))
3263                < TYPE_PRECISION (result_type))
3264               && (TYPE_PRECISION (TREE_TYPE (arg1))
3265                   == TYPE_PRECISION (TREE_TYPE (arg0)))
3266               && unsigned0 == unsigned1
3267               && (unsigned0 || !uns))
3268             result_type = c_common_signed_or_unsigned_type
3269               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3270           else if (TREE_CODE (arg0) == INTEGER_CST
3271                    && (unsigned1 || !uns)
3272                    && (TYPE_PRECISION (TREE_TYPE (arg1))
3273                        < TYPE_PRECISION (result_type))
3274                    && (type = c_common_signed_or_unsigned_type
3275                        (unsigned1, TREE_TYPE (arg1)),
3276                        int_fits_type_p (arg0, type)))
3277             result_type = type;
3278           else if (TREE_CODE (arg1) == INTEGER_CST
3279                    && (unsigned0 || !uns)
3280                    && (TYPE_PRECISION (TREE_TYPE (arg0))
3281                        < TYPE_PRECISION (result_type))
3282                    && (type = c_common_signed_or_unsigned_type
3283                        (unsigned0, TREE_TYPE (arg0)),
3284                        int_fits_type_p (arg1, type)))
3285             result_type = type;
3286         }
3287
3288       /* Shifts can be shortened if shifting right.  */
3289
3290       if (short_shift)
3291         {
3292           int unsigned_arg;
3293           tree arg0 = get_narrower (op0, &unsigned_arg);
3294
3295           final_type = result_type;
3296
3297           if (arg0 == op0 && final_type == TREE_TYPE (op0))
3298             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
3299
3300           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3301               /* We can shorten only if the shift count is less than the
3302                  number of bits in the smaller type size.  */
3303               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3304               /* If arg is sign-extended and then unsigned-shifted,
3305                  we can simulate this with a signed shift in arg's type
3306                  only if the extended result is at least twice as wide
3307                  as the arg.  Otherwise, the shift could use up all the
3308                  ones made by sign-extension and bring in zeros.
3309                  We can't optimize that case at all, but in most machines
3310                  it never happens because available widths are 2**N.  */
3311               && (!TYPE_UNSIGNED (final_type)
3312                   || unsigned_arg
3313                   || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3314                       <= TYPE_PRECISION (result_type))))
3315             {
3316               /* Do an unsigned shift if the operand was zero-extended.  */
3317               result_type
3318                 = c_common_signed_or_unsigned_type (unsigned_arg,
3319                                                     TREE_TYPE (arg0));
3320               /* Convert value-to-be-shifted to that type.  */
3321               if (TREE_TYPE (op0) != result_type)
3322                 op0 = cp_convert (result_type, op0);
3323               converted = 1;
3324             }
3325         }
3326
3327       /* Comparison operations are shortened too but differently.
3328          They identify themselves by setting short_compare = 1.  */
3329
3330       if (short_compare)
3331         {
3332           /* Don't write &op0, etc., because that would prevent op0
3333              from being kept in a register.
3334              Instead, make copies of the our local variables and
3335              pass the copies by reference, then copy them back afterward.  */
3336           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3337           enum tree_code xresultcode = resultcode;
3338           tree val
3339             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3340           if (val != 0)
3341             return cp_convert (boolean_type_node, val);
3342           op0 = xop0, op1 = xop1;
3343           converted = 1;
3344           resultcode = xresultcode;
3345         }
3346
3347       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3348           && warn_sign_compare
3349           /* Do not warn until the template is instantiated; we cannot
3350              bound the ranges of the arguments until that point.  */
3351           && !processing_template_decl)
3352         {
3353           int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
3354           int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3355
3356           int unsignedp0, unsignedp1;
3357           tree primop0 = get_narrower (op0, &unsignedp0);
3358           tree primop1 = get_narrower (op1, &unsignedp1);
3359
3360           /* Check for comparison of different enum types.  */
3361           if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3362               && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3363               && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3364                  != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3365             {
3366               warning (0, "comparison between types %q#T and %q#T",
3367                        TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3368             }
3369
3370           /* Give warnings for comparisons between signed and unsigned
3371              quantities that may fail.  */
3372           /* Do the checking based on the original operand trees, so that
3373              casts will be considered, but default promotions won't be.  */
3374
3375           /* Do not warn if the comparison is being done in a signed type,
3376              since the signed type will only be chosen if it can represent
3377              all the values of the unsigned type.  */
3378           if (!TYPE_UNSIGNED (result_type))
3379             /* OK */;
3380           /* Do not warn if both operands are unsigned.  */
3381           else if (op0_signed == op1_signed)
3382             /* OK */;
3383           /* Do not warn if the signed quantity is an unsuffixed
3384              integer literal (or some static constant expression
3385              involving such literals or a conditional expression
3386              involving such literals) and it is non-negative.  */
3387           else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3388                    || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3389             /* OK */;
3390           /* Do not warn if the comparison is an equality operation,
3391              the unsigned quantity is an integral constant and it does
3392              not use the most significant bit of result_type.  */
3393           else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3394                    && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3395                         && int_fits_type_p (orig_op1, c_common_signed_type
3396                                             (result_type)))
3397                         || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3398                             && int_fits_type_p (orig_op0, c_common_signed_type
3399                                                 (result_type)))))
3400             /* OK */;
3401           else
3402             warning (0, "comparison between signed and unsigned integer expressions");
3403
3404           /* Warn if two unsigned values are being compared in a size
3405              larger than their original size, and one (and only one) is the
3406              result of a `~' operator.  This comparison will always fail.
3407
3408              Also warn if one operand is a constant, and the constant does not
3409              have all bits set that are set in the ~ operand when it is
3410              extended.  */
3411
3412           if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3413               ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3414             {
3415               if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3416                 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3417               if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3418                 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3419
3420               if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3421                 {
3422                   tree primop;
3423                   HOST_WIDE_INT constant, mask;
3424                   int unsignedp;
3425                   unsigned int bits;
3426
3427                   if (host_integerp (primop0, 0))
3428                     {
3429                       primop = primop1;
3430                       unsignedp = unsignedp1;
3431                       constant = tree_low_cst (primop0, 0);
3432                     }
3433                   else
3434                     {
3435                       primop = primop0;
3436                       unsignedp = unsignedp0;
3437                       constant = tree_low_cst (primop1, 0);
3438                     }
3439
3440                   bits = TYPE_PRECISION (TREE_TYPE (primop));
3441                   if (bits < TYPE_PRECISION (result_type)
3442                       && bits < HOST_BITS_PER_LONG && unsignedp)
3443                     {
3444                       mask = (~ (HOST_WIDE_INT) 0) << bits;
3445                       if ((mask & constant) != mask)
3446                         warning (0, "comparison of promoted ~unsigned with constant");
3447                     }
3448                 }
3449               else if (unsignedp0 && unsignedp1
3450                        && (TYPE_PRECISION (TREE_TYPE (primop0))
3451                            < TYPE_PRECISION (result_type))
3452                        && (TYPE_PRECISION (TREE_TYPE (primop1))
3453                            < TYPE_PRECISION (result_type)))
3454                 warning (0, "comparison of promoted ~unsigned with unsigned");
3455             }
3456         }
3457     }
3458
3459   /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3460      Then the expression will be built.
3461      It will be given type FINAL_TYPE if that is nonzero;
3462      otherwise, it will be given type RESULT_TYPE.  */
3463
3464   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3465   if (/* It's reasonable to use pointer values as operands of &&
3466          and ||, so NULL is no exception.  */
3467       !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3468       && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
3469           (orig_op0 == null_node
3470            && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3471           /* Or vice versa.  */
3472           || (orig_op1 == null_node
3473               && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3474           /* Or, both are NULL and the operation was not a comparison.  */
3475           || (orig_op0 == null_node && orig_op1 == null_node
3476               && code != EQ_EXPR && code != NE_EXPR)))
3477     /* Some sort of arithmetic operation involving NULL was
3478        performed.  Note that pointer-difference and pointer-addition
3479        have already been handled above, and so we don't end up here in
3480        that case.  */
3481     warning (0, "NULL used in arithmetic");
3482
3483   if (! converted)
3484     {
3485       if (TREE_TYPE (op0) != result_type)
3486         op0 = cp_convert (result_type, op0);
3487       if (TREE_TYPE (op1) != result_type)
3488         op1 = cp_convert (result_type, op1);
3489
3490       if (op0 == error_mark_node || op1 == error_mark_node)
3491         return error_mark_node;
3492     }
3493
3494   if (build_type == NULL_TREE)
3495     build_type = result_type;
3496
3497   result = build2 (resultcode, build_type, op0, op1);
3498   result = fold_if_not_in_template (result);
3499   if (final_type != 0)
3500     result = cp_convert (final_type, result);
3501   return result;
3502 }
3503 \f
3504 /* Return a tree for the sum or difference (RESULTCODE says which)
3505    of pointer PTROP and integer INTOP.  */
3506
3507 static tree
3508 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3509 {
3510   tree res_type = TREE_TYPE (ptrop);
3511
3512   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3513      in certain circumstance (when it's valid to do so).  So we need
3514      to make sure it's complete.  We don't need to check here, if we
3515      can actually complete it at all, as those checks will be done in
3516      pointer_int_sum() anyway.  */
3517   complete_type (TREE_TYPE (res_type));
3518
3519   return pointer_int_sum (resultcode, ptrop,
3520                           fold_if_not_in_template (intop));
3521 }
3522
3523 /* Return a tree for the difference of pointers OP0 and OP1.
3524    The resulting tree has type int.  */
3525
3526 static tree
3527 pointer_diff (tree op0, tree op1, tree ptrtype)
3528 {
3529   tree result;
3530   tree restype = ptrdiff_type_node;
3531   tree target_type = TREE_TYPE (ptrtype);
3532
3533   if (!complete_type_or_else (target_type, NULL_TREE))
3534     return error_mark_node;
3535
3536   if (pedantic || warn_pointer_arith)
3537     {
3538       if (TREE_CODE (target_type) == VOID_TYPE)
3539         pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
3540       if (TREE_CODE (target_type) == FUNCTION_TYPE)
3541         pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3542       if (TREE_CODE (target_type) == METHOD_TYPE)
3543         pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3544     }
3545
3546   /* First do the subtraction as integers;
3547      then drop through to build the divide operator.  */
3548
3549   op0 = cp_build_binary_op (MINUS_EXPR,
3550                             cp_convert (restype, op0),
3551                             cp_convert (restype, op1));
3552
3553   /* This generates an error if op1 is a pointer to an incomplete type.  */
3554   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3555     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3556
3557   op1 = (TYPE_PTROB_P (ptrtype)
3558          ? size_in_bytes (target_type)
3559          : integer_one_node);
3560
3561   /* Do the division.  */
3562
3563   result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3564   return fold_if_not_in_template (result);
3565 }
3566 \f
3567 /* Construct and perhaps optimize a tree representation
3568    for a unary operation.  CODE, a tree_code, specifies the operation
3569    and XARG is the operand.  */
3570
3571 tree
3572 build_x_unary_op (enum tree_code code, tree xarg)
3573 {
3574   tree orig_expr = xarg;
3575   tree exp;
3576   int ptrmem = 0;
3577
3578   if (processing_template_decl)
3579     {
3580       if (type_dependent_expression_p (xarg))
3581         return build_min_nt (code, xarg, NULL_TREE);
3582
3583       xarg = build_non_dependent_expr (xarg);
3584     }
3585
3586   exp = NULL_TREE;
3587
3588   /* [expr.unary.op] says:
3589
3590        The address of an object of incomplete type can be taken.
3591
3592      (And is just the ordinary address operator, not an overloaded
3593      "operator &".)  However, if the type is a template
3594      specialization, we must complete the type at this point so that
3595      an overloaded "operator &" will be available if required.  */
3596   if (code == ADDR_EXPR
3597       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3598       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3599            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3600           || (TREE_CODE (xarg) == OFFSET_REF)))
3601     /* Don't look for a function.  */;
3602   else
3603     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3604                         /*overloaded_p=*/NULL);
3605   if (!exp && code == ADDR_EXPR)
3606     {
3607       /*  A pointer to member-function can be formed only by saying
3608           &X::mf.  */
3609       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3610           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3611         {
3612           if (TREE_CODE (xarg) != OFFSET_REF)
3613             {
3614               error ("invalid use of %qE to form a pointer-to-member-function."
3615                      "  Use a qualified-id.",
3616                      xarg);
3617               return error_mark_node;
3618             }
3619           else
3620             {
3621               error ("parenthesis around %qE cannot be used to form a"
3622                      " pointer-to-member-function",
3623                      xarg);
3624               PTRMEM_OK_P (xarg) = 1;
3625             }
3626         }
3627
3628       if (TREE_CODE (xarg) == OFFSET_REF)
3629         {
3630           ptrmem = PTRMEM_OK_P (xarg);
3631
3632           if (!ptrmem && !flag_ms_extensions
3633               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3634             {
3635               /* A single non-static member, make sure we don't allow a
3636                  pointer-to-member.  */
3637               xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
3638                              TREE_OPERAND (xarg, 0),
3639                              ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3640               PTRMEM_OK_P (xarg) = ptrmem;
3641             }
3642         }
3643       else if (TREE_CODE (xarg) == TARGET_EXPR)
3644         warning (0, "taking address of temporary");
3645       exp = build_unary_op (ADDR_EXPR, xarg, 0);
3646     }
3647
3648   if (processing_template_decl && exp != error_mark_node)
3649     exp = build_min_non_dep (code, exp, orig_expr,
3650                              /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3651   if (TREE_CODE (exp) == ADDR_EXPR)
3652     PTRMEM_OK_P (exp) = ptrmem;
3653   return exp;
3654 }
3655
3656 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3657    constants, where a null value is represented by an INTEGER_CST of
3658    -1.  */
3659
3660 tree
3661 cp_truthvalue_conversion (tree expr)
3662 {
3663   tree type = TREE_TYPE (expr);
3664   if (TYPE_PTRMEM_P (type))
3665     return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3666   else
3667     return c_common_truthvalue_conversion (expr);
3668 }
3669
3670 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
3671
3672 tree
3673 condition_conversion (tree expr)
3674 {
3675   tree t;
3676   if (processing_template_decl)
3677     return expr;
3678   t = perform_implicit_conversion (boolean_type_node, expr);
3679   t = fold_build_cleanup_point_expr (boolean_type_node, t);
3680   return t;
3681 }
3682
3683 /* Return an ADDR_EXPR giving the address of T.  This function
3684    attempts no optimizations or simplifications; it is a low-level
3685    primitive.  */
3686
3687 tree
3688 build_address (tree t)
3689 {
3690   tree addr;
3691
3692   if (error_operand_p (t) || !cxx_mark_addressable (t))
3693     return error_mark_node;
3694
3695   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3696
3697   return addr;
3698 }
3699
3700 /* Return a NOP_EXPR converting EXPR to TYPE.  */
3701
3702 tree
3703 build_nop (tree type, tree expr)
3704 {
3705   if (type == error_mark_node || error_operand_p (expr))
3706     return expr;
3707   return build1 (NOP_EXPR, type, expr);
3708 }
3709
3710 /* C++: Must handle pointers to members.
3711
3712    Perhaps type instantiation should be extended to handle conversion
3713    from aggregates to types we don't yet know we want?  (Or are those
3714    cases typically errors which should be reported?)
3715
3716    NOCONVERT nonzero suppresses the default promotions
3717    (such as from short to int).  */
3718
3719 tree
3720 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3721 {
3722   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3723   tree arg = xarg;
3724   tree argtype = 0;
3725   const char *errstring = NULL;
3726   tree val;
3727
3728   if (arg == error_mark_node)
3729     return error_mark_node;
3730
3731   switch (code)
3732     {
3733     case UNARY_PLUS_EXPR:
3734     case NEGATE_EXPR:
3735       {
3736         int flags = WANT_ARITH | WANT_ENUM;
3737         /* Unary plus (but not unary minus) is allowed on pointers.  */
3738         if (code == UNARY_PLUS_EXPR)
3739           flags |= WANT_POINTER;
3740         arg = build_expr_type_conversion (flags, arg, true);
3741         if (!arg)
3742           errstring = (code == NEGATE_EXPR
3743                        ? "wrong type argument to unary minus"
3744                        : "wrong type argument to unary plus");
3745         else
3746           {
3747             if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3748               arg = perform_integral_promotions (arg);
3749
3750             /* Make sure the result is not a lvalue: a unary plus or minus
3751                expression is always a rvalue.  */
3752             if (real_lvalue_p (arg))
3753               arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3754           }
3755       }
3756       break;
3757
3758     case BIT_NOT_EXPR:
3759       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3760         {
3761           code = CONJ_EXPR;
3762           if (!noconvert)
3763             arg = default_conversion (arg);
3764         }
3765       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3766                                                    arg, true)))
3767         errstring = "wrong type argument to bit-complement";
3768       else if (!noconvert)
3769         arg = perform_integral_promotions (arg);
3770       break;
3771
3772     case ABS_EXPR:
3773       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3774         errstring = "wrong type argument to abs";
3775       else if (!noconvert)
3776         arg = default_conversion (arg);
3777       break;
3778
3779     case CONJ_EXPR:
3780       /* Conjugating a real value is a no-op, but allow it anyway.  */
3781       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3782         errstring = "wrong type argument to conjugation";
3783       else if (!noconvert)
3784         arg = default_conversion (arg);
3785       break;
3786
3787     case TRUTH_NOT_EXPR:
3788       arg = perform_implicit_conversion (boolean_type_node, arg);
3789       val = invert_truthvalue (arg);
3790       if (arg != error_mark_node)
3791         return val;
3792       errstring = "in argument to unary !";
3793       break;
3794
3795     case NOP_EXPR:
3796       break;
3797
3798     case REALPART_EXPR:
3799       if (TREE_CODE (arg) == COMPLEX_CST)
3800         return TREE_REALPART (arg);
3801       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3802         {
3803           arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3804           return fold_if_not_in_template (arg);
3805         }
3806       else
3807         return arg;
3808
3809     case IMAGPART_EXPR:
3810       if (TREE_CODE (arg) == COMPLEX_CST)
3811         return TREE_IMAGPART (arg);
3812       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3813         {
3814           arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3815           return fold_if_not_in_template (arg);
3816         }
3817       else
3818         return cp_convert (TREE_TYPE (arg), integer_zero_node);
3819
3820     case PREINCREMENT_EXPR:
3821     case POSTINCREMENT_EXPR:
3822     case PREDECREMENT_EXPR:
3823     case POSTDECREMENT_EXPR:
3824       /* Handle complex lvalues (when permitted)
3825          by reduction to simpler cases.  */
3826
3827       val = unary_complex_lvalue (code, arg);
3828       if (val != 0)
3829         return val;
3830
3831       /* Increment or decrement the real part of the value,
3832          and don't change the imaginary part.  */
3833       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3834         {
3835           tree real, imag;
3836
3837           arg = stabilize_reference (arg);
3838           real = build_unary_op (REALPART_EXPR, arg, 1);
3839           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3840           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3841                          build_unary_op (code, real, 1), imag);
3842         }
3843
3844       /* Report invalid types.  */
3845
3846       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3847                                               arg, true)))
3848         {
3849           if (code == PREINCREMENT_EXPR)
3850             errstring ="no pre-increment operator for type";
3851           else if (code == POSTINCREMENT_EXPR)
3852             errstring ="no post-increment operator for type";
3853           else if (code == PREDECREMENT_EXPR)
3854             errstring ="no pre-decrement operator for type";
3855           else
3856             errstring ="no post-decrement operator for type";
3857           break;
3858         }
3859
3860       /* Report something read-only.  */
3861
3862       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3863           || TREE_READONLY (arg))
3864         readonly_error (arg, ((code == PREINCREMENT_EXPR
3865                                || code == POSTINCREMENT_EXPR)
3866                               ? "increment" : "decrement"),
3867                         0);
3868
3869       {
3870         tree inc;
3871         tree result_type = TREE_TYPE (arg);
3872
3873         arg = get_unwidened (arg, 0);
3874         argtype = TREE_TYPE (arg);
3875
3876         /* ARM $5.2.5 last annotation says this should be forbidden.  */
3877         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3878           pedwarn ("ISO C++ forbids %sing an enum",
3879                    (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3880                    ? "increment" : "decrement");
3881
3882         /* Compute the increment.  */
3883
3884         if (TREE_CODE (argtype) == POINTER_TYPE)
3885           {
3886             tree type = complete_type (TREE_TYPE (argtype));
3887
3888             if (!COMPLETE_OR_VOID_TYPE_P (type))
3889               error ("cannot %s a pointer to incomplete type %qT",
3890                      ((code == PREINCREMENT_EXPR
3891                        || code == POSTINCREMENT_EXPR)
3892                       ? "increment" : "decrement"), TREE_TYPE (argtype));
3893             else if ((pedantic || warn_pointer_arith)
3894                      && !TYPE_PTROB_P (argtype))
3895               pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
3896                        ((code == PREINCREMENT_EXPR
3897                          || code == POSTINCREMENT_EXPR)
3898                         ? "increment" : "decrement"), argtype);
3899             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3900           }
3901         else
3902           inc = integer_one_node;
3903
3904         inc = cp_convert (argtype, inc);
3905
3906         /* Handle incrementing a cast-expression.  */
3907
3908         switch (TREE_CODE (arg))
3909           {
3910           case NOP_EXPR:
3911           case CONVERT_EXPR:
3912           case FLOAT_EXPR:
3913           case FIX_TRUNC_EXPR:
3914           case FIX_FLOOR_EXPR:
3915           case FIX_ROUND_EXPR:
3916           case FIX_CEIL_EXPR:
3917             {
3918               tree incremented, modify, value, compound;
3919               if (! lvalue_p (arg) && pedantic)
3920                 pedwarn ("cast to non-reference type used as lvalue");
3921               arg = stabilize_reference (arg);
3922               if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3923                 value = arg;
3924               else
3925                 value = save_expr (arg);
3926               incremented = build2 (((code == PREINCREMENT_EXPR
3927                                       || code == POSTINCREMENT_EXPR)
3928                                      ? PLUS_EXPR : MINUS_EXPR),
3929                                     argtype, value, inc);
3930
3931               modify = build_modify_expr (arg, NOP_EXPR, incremented);
3932               compound = build2 (COMPOUND_EXPR, TREE_TYPE (arg),
3933                                  modify, value);
3934
3935               /* Eliminate warning about unused result of + or -.  */
3936               TREE_NO_WARNING (compound) = 1;
3937               return compound;
3938             }
3939
3940           default:
3941             break;
3942           }
3943
3944         /* Complain about anything else that is not a true lvalue.  */
3945         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3946                                     || code == POSTINCREMENT_EXPR)
3947                                    ? lv_increment : lv_decrement)))
3948           return error_mark_node;
3949
3950         /* Forbid using -- on `bool'.  */
3951         if (TREE_TYPE (arg) == boolean_type_node)
3952           {
3953             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
3954               {
3955                 error ("invalid use of %<--%> on bool variable %qD", arg);
3956                 return error_mark_node;
3957               }
3958             val = boolean_increment (code, arg);
3959           }
3960         else
3961           val = build2 (code, TREE_TYPE (arg), arg, inc);
3962
3963         TREE_SIDE_EFFECTS (val) = 1;
3964         return cp_convert (result_type, val);
3965       }
3966
3967     case ADDR_EXPR:
3968       /* Note that this operation never does default_conversion
3969          regardless of NOCONVERT.  */
3970
3971       argtype = lvalue_type (arg);
3972
3973       if (TREE_CODE (arg) == OFFSET_REF)
3974         goto offset_ref;
3975
3976       if (TREE_CODE (argtype) == REFERENCE_TYPE)
3977         {
3978           tree type = build_pointer_type (TREE_TYPE (argtype));
3979           arg = build1 (CONVERT_EXPR, type, arg);
3980           return arg;
3981         }
3982       else if (pedantic && DECL_MAIN_P (arg))
3983         /* ARM $3.4 */
3984         pedwarn ("ISO C++ forbids taking address of function %<::main%>");
3985
3986       /* Let &* cancel out to simplify resulting code.  */
3987       if (TREE_CODE (arg) == INDIRECT_REF)
3988         {
3989           /* We don't need to have `current_class_ptr' wrapped in a
3990              NON_LVALUE_EXPR node.  */
3991           if (arg == current_class_ref)
3992             return current_class_ptr;
3993
3994           arg = TREE_OPERAND (arg, 0);
3995           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3996             {
3997               tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
3998               arg = build1 (CONVERT_EXPR, type, arg);
3999             }
4000           else if (lvalue_p (arg))
4001             /* Don't let this be an lvalue.  */
4002             return non_lvalue (arg);
4003           return arg;
4004         }
4005
4006       /* Uninstantiated types are all functions.  Taking the
4007          address of a function is a no-op, so just return the
4008          argument.  */
4009
4010       gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4011                   || !IDENTIFIER_OPNAME_P (arg));
4012
4013       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4014           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4015         {
4016           /* They're trying to take the address of a unique non-static
4017              member function.  This is ill-formed (except in MS-land),
4018              but let's try to DTRT.
4019              Note: We only handle unique functions here because we don't
4020              want to complain if there's a static overload; non-unique
4021              cases will be handled by instantiate_type.  But we need to
4022              handle this case here to allow casts on the resulting PMF.
4023              We could defer this in non-MS mode, but it's easier to give
4024              a useful error here.  */
4025
4026           /* Inside constant member functions, the `this' pointer
4027              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4028              is used here to remove this const from the diagnostics
4029              and the created OFFSET_REF.  */
4030           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4031           tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4032
4033           if (! flag_ms_extensions)
4034             {
4035               if (current_class_type
4036                   && TREE_OPERAND (arg, 0) == current_class_ref)
4037                 /* An expression like &memfn.  */
4038                 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4039                          " or parenthesized non-static member function to form"
4040                          " a pointer to member function.  Say %<&%T::%D%>",
4041                          base, name);
4042               else
4043                 pedwarn ("ISO C++ forbids taking the address of a bound member"
4044                          " function to form a pointer to member function."
4045                          "  Say %<&%T::%D%>",
4046                          base, name);
4047             }
4048           arg = build_offset_ref (base, name, /*address_p=*/true);
4049         }
4050
4051     offset_ref:
4052       if (type_unknown_p (arg))
4053         return build1 (ADDR_EXPR, unknown_type_node, arg);
4054
4055       /* Handle complex lvalues (when permitted)
4056          by reduction to simpler cases.  */
4057       val = unary_complex_lvalue (code, arg);
4058       if (val != 0)
4059         return val;
4060
4061       switch (TREE_CODE (arg))
4062         {
4063         case NOP_EXPR:
4064         case CONVERT_EXPR:
4065         case FLOAT_EXPR:
4066         case FIX_TRUNC_EXPR:
4067         case FIX_FLOOR_EXPR:
4068         case FIX_ROUND_EXPR:
4069         case FIX_CEIL_EXPR:
4070           if (! lvalue_p (arg) && pedantic)
4071             pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4072           break;
4073
4074         case OVERLOAD:
4075           arg = OVL_CURRENT (arg);
4076           break;
4077
4078         case OFFSET_REF:
4079           /* Turn a reference to a non-static data member into a
4080              pointer-to-member.  */
4081           {
4082             tree type;
4083             tree t;
4084
4085             if (!PTRMEM_OK_P (arg))
4086               return build_unary_op (code, arg, 0);
4087
4088             t = TREE_OPERAND (arg, 1);
4089             if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4090               {
4091                 error ("cannot create pointer to reference member %qD", t);
4092                 return error_mark_node;
4093               }
4094
4095             type = build_ptrmem_type (context_for_name_lookup (t),
4096                                       TREE_TYPE (t));
4097             t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4098             return t;
4099           }
4100
4101         default:
4102           break;
4103         }
4104
4105       /* Allow the address of a constructor if all the elements
4106          are constant.  */
4107       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4108           && TREE_CONSTANT (arg))
4109         ;
4110       /* Anything not already handled and not a true memory reference
4111          is an error.  */
4112       else if (TREE_CODE (argtype) != FUNCTION_TYPE
4113                && TREE_CODE (argtype) != METHOD_TYPE
4114                && TREE_CODE (arg) != OFFSET_REF
4115                && !lvalue_or_else (arg, lv_addressof))
4116         return error_mark_node;
4117
4118       if (argtype != error_mark_node)
4119         argtype = build_pointer_type (argtype);
4120
4121       {
4122         tree addr;
4123
4124         if (TREE_CODE (arg) != COMPONENT_REF
4125             /* Inside a template, we are processing a non-dependent
4126                expression so we can just form an ADDR_EXPR with the
4127                correct type.  */
4128             || processing_template_decl)
4129           {
4130             addr = build_address (arg);
4131             if (TREE_CODE (arg) == OFFSET_REF)
4132               PTRMEM_OK_P (addr) = PTRMEM_OK_P (arg);
4133           }
4134         else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4135           {
4136             tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4137
4138             /* We can only get here with a single static member
4139                function.  */
4140             gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4141                         && DECL_STATIC_FUNCTION_P (fn));
4142             mark_used (fn);
4143             addr = build_address (fn);
4144             if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4145               /* Do not lose object's side effects.  */
4146               addr = build2 (COMPOUND_EXPR, TREE_TYPE (addr),
4147                              TREE_OPERAND (arg, 0), addr);
4148           }
4149         else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4150           {
4151             error ("attempt to take address of bit-field structure member %qD",
4152                    TREE_OPERAND (arg, 1));
4153             return error_mark_node;
4154           }
4155         else
4156           {
4157             tree object = TREE_OPERAND (arg, 0);
4158             tree field = TREE_OPERAND (arg, 1);
4159             gcc_assert (same_type_ignoring_top_level_qualifiers_p
4160                         (TREE_TYPE (object), decl_type_context (field)));
4161             addr = build_address (arg);
4162           }
4163
4164         if (TREE_CODE (argtype) == POINTER_TYPE
4165             && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4166           {
4167             build_ptrmemfunc_type (argtype);
4168             addr = build_ptrmemfunc (argtype, addr, 0,
4169                                      /*c_cast_p=*/false);
4170           }
4171
4172         return addr;
4173       }
4174
4175     default:
4176       break;
4177     }
4178
4179   if (!errstring)
4180     {
4181       if (argtype == 0)
4182         argtype = TREE_TYPE (arg);
4183       return fold_if_not_in_template (build1 (code, argtype, arg));
4184     }
4185
4186   error ("%s", errstring);
4187   return error_mark_node;
4188 }
4189
4190 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4191    for certain kinds of expressions which are not really lvalues
4192    but which we can accept as lvalues.
4193
4194    If ARG is not a kind of expression we can handle, return
4195    NULL_TREE.  */
4196
4197 tree
4198 unary_complex_lvalue (enum tree_code code, tree arg)
4199 {
4200   /* Inside a template, making these kinds of adjustments is
4201      pointless; we are only concerned with the type of the
4202      expression.  */
4203   if (processing_template_decl)
4204     return NULL_TREE;
4205
4206   /* Handle (a, b) used as an "lvalue".  */
4207   if (TREE_CODE (arg) == COMPOUND_EXPR)
4208     {
4209       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4210       return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4211                      TREE_OPERAND (arg, 0), real_result);
4212     }
4213
4214   /* Handle (a ? b : c) used as an "lvalue".  */
4215   if (TREE_CODE (arg) == COND_EXPR
4216       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4217     return rationalize_conditional_expr (code, arg);
4218
4219   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4220   if (TREE_CODE (arg) == MODIFY_EXPR
4221       || TREE_CODE (arg) == PREINCREMENT_EXPR
4222       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4223     {
4224       tree lvalue = TREE_OPERAND (arg, 0);
4225       if (TREE_SIDE_EFFECTS (lvalue))
4226         {
4227           lvalue = stabilize_reference (lvalue);
4228           arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4229                         lvalue, TREE_OPERAND (arg, 1));
4230         }
4231       return unary_complex_lvalue
4232         (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4233     }
4234
4235   if (code != ADDR_EXPR)
4236     return 0;
4237
4238   /* Handle (a = b) used as an "lvalue" for `&'.  */
4239   if (TREE_CODE (arg) == MODIFY_EXPR
4240       || TREE_CODE (arg) == INIT_EXPR)
4241     {
4242       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4243       arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4244                     arg, real_result);
4245       TREE_NO_WARNING (arg) = 1;
4246       return arg;
4247     }
4248
4249   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4250       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4251       || TREE_CODE (arg) == OFFSET_REF)
4252     return NULL_TREE;
4253
4254   /* We permit compiler to make function calls returning
4255      objects of aggregate type look like lvalues.  */
4256   {
4257     tree targ = arg;
4258
4259     if (TREE_CODE (targ) == SAVE_EXPR)
4260       targ = TREE_OPERAND (targ, 0);
4261
4262     if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4263       {
4264         if (TREE_CODE (arg) == SAVE_EXPR)
4265           targ = arg;
4266         else
4267           targ = build_cplus_new (TREE_TYPE (arg), arg);
4268         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4269       }
4270
4271     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4272       return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4273                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4274   }
4275
4276   /* Don't let anything else be handled specially.  */
4277   return 0;
4278 }
4279 \f
4280 /* Mark EXP saying that we need to be able to take the
4281    address of it; it should not be allocated in a register.
4282    Value is true if successful.
4283
4284    C++: we do not allow `current_class_ptr' to be addressable.  */
4285
4286 bool
4287 cxx_mark_addressable (tree exp)
4288 {
4289   tree x = exp;
4290
4291   while (1)
4292     switch (TREE_CODE (x))
4293       {
4294       case ADDR_EXPR:
4295       case COMPONENT_REF:
4296       case ARRAY_REF:
4297       case REALPART_EXPR:
4298       case IMAGPART_EXPR:
4299         x = TREE_OPERAND (x, 0);
4300         break;
4301
4302       case PARM_DECL:
4303         if (x == current_class_ptr)
4304           {
4305             error ("cannot take the address of %<this%>, which is an rvalue expression");
4306             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4307             return true;
4308           }
4309         /* Fall through.  */
4310
4311       case VAR_DECL:
4312         /* Caller should not be trying to mark initialized
4313            constant fields addressable.  */
4314         gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4315                     || DECL_IN_AGGR_P (x) == 0
4316                     || TREE_STATIC (x)
4317                     || DECL_EXTERNAL (x));
4318         /* Fall through.  */
4319
4320       case CONST_DECL:
4321       case RESULT_DECL:
4322         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4323             && !DECL_ARTIFICIAL (x))
4324           {
4325             if (DECL_HARD_REGISTER (x) != 0)
4326               {
4327                 error
4328                   ("address of explicit register variable %qD requested", x);
4329                 return false;
4330               }
4331             else if (extra_warnings)
4332               warning
4333                 (0, "address requested for %qD, which is declared %<register%>", x);
4334           }
4335         TREE_ADDRESSABLE (x) = 1;
4336         return true;
4337
4338       case FUNCTION_DECL:
4339         TREE_ADDRESSABLE (x) = 1;
4340         return true;
4341
4342       case CONSTRUCTOR:
4343         TREE_ADDRESSABLE (x) = 1;
4344         return true;
4345
4346       case TARGET_EXPR:
4347         TREE_ADDRESSABLE (x) = 1;
4348         cxx_mark_addressable (TREE_OPERAND (x, 0));
4349         return true;
4350
4351       default:
4352         return true;
4353     }
4354 }
4355 \f
4356 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4357
4358 tree
4359 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4360 {
4361   tree orig_ifexp = ifexp;
4362   tree orig_op1 = op1;
4363   tree orig_op2 = op2;
4364   tree expr;
4365
4366   if (processing_template_decl)
4367     {
4368       /* The standard says that the expression is type-dependent if
4369          IFEXP is type-dependent, even though the eventual type of the
4370          expression doesn't dependent on IFEXP.  */
4371       if (type_dependent_expression_p (ifexp)
4372           /* As a GNU extension, the middle operand may be omitted.  */
4373           || (op1 && type_dependent_expression_p (op1))
4374           || type_dependent_expression_p (op2))
4375         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4376       ifexp = build_non_dependent_expr (ifexp);
4377       if (op1)
4378         op1 = build_non_dependent_expr (op1);
4379       op2 = build_non_dependent_expr (op2);
4380     }
4381
4382   expr = build_conditional_expr (ifexp, op1, op2);
4383   if (processing_template_decl && expr != error_mark_node)
4384     return build_min_non_dep (COND_EXPR, expr,
4385                               orig_ifexp, orig_op1, orig_op2);
4386   return expr;
4387 }
4388 \f
4389 /* Given a list of expressions, return a compound expression
4390    that performs them all and returns the value of the last of them.  */
4391
4392 tree build_x_compound_expr_from_list (tree list, const char *msg)
4393 {
4394   tree expr = TREE_VALUE (list);
4395
4396   if (TREE_CHAIN (list))
4397     {
4398       if (msg)
4399         pedwarn ("%s expression list treated as compound expression", msg);
4400
4401       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4402         expr = build_x_compound_expr (expr, TREE_VALUE (list));
4403     }
4404
4405   return expr;
4406 }
4407
4408 /* Handle overloading of the ',' operator when needed.  */
4409
4410 tree
4411 build_x_compound_expr (tree op1, tree op2)
4412 {
4413   tree result;
4414   tree orig_op1 = op1;
4415   tree orig_op2 = op2;
4416
4417   if (processing_template_decl)
4418     {
4419       if (type_dependent_expression_p (op1)
4420           || type_dependent_expression_p (op2))
4421         return build_min_nt (COMPOUND_EXPR, op1, op2);
4422       op1 = build_non_dependent_expr (op1);
4423       op2 = build_non_dependent_expr (op2);
4424     }
4425
4426   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4427                          /*overloaded_p=*/NULL);
4428   if (!result)
4429     result = build_compound_expr (op1, op2);
4430
4431   if (processing_template_decl && result != error_mark_node)
4432     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4433
4434   return result;
4435 }
4436
4437 /* Build a compound expression.  */
4438
4439 tree
4440 build_compound_expr (tree lhs, tree rhs)
4441 {
4442   lhs = convert_to_void (lhs, "left-hand operand of comma");
4443
4444   if (lhs == error_mark_node || rhs == error_mark_node)
4445     return error_mark_node;
4446
4447   if (TREE_CODE (rhs) == TARGET_EXPR)
4448     {
4449       /* If the rhs is a TARGET_EXPR, then build the compound
4450          expression inside the target_expr's initializer. This
4451          helps the compiler to eliminate unnecessary temporaries.  */
4452       tree init = TREE_OPERAND (rhs, 1);
4453
4454       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4455       TREE_OPERAND (rhs, 1) = init;
4456
4457       return rhs;
4458     }
4459
4460   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4461 }
4462
4463 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4464    casts away constness.  DIAG_FN gives the function to call if we
4465    need to issue a diagnostic; if it is NULL, no diagnostic will be
4466    issued.  DESCRIPTION explains what operation is taking place.  */
4467
4468 static void
4469 check_for_casting_away_constness (tree src_type, tree dest_type,
4470                                   void (*diag_fn)(const char *, ...),
4471                                   const char *description)
4472 {
4473   if (diag_fn && casts_away_constness (src_type, dest_type))
4474     error ("%s from type %qT to type %qT casts away constness",
4475            description, src_type, dest_type);
4476 }
4477
4478 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4479    (another pointer-to-member type in the same hierarchy) and return
4480    the converted expression.  If ALLOW_INVERSE_P is permitted, a
4481    pointer-to-derived may be converted to pointer-to-base; otherwise,
4482    only the other direction is permitted.  If C_CAST_P is true, this
4483    conversion is taking place as part of a C-style cast.  */
4484
4485 tree
4486 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
4487                 bool c_cast_p)
4488 {
4489   if (TYPE_PTRMEM_P (type))
4490     {
4491       tree delta;
4492
4493       if (TREE_CODE (expr) == PTRMEM_CST)
4494         expr = cplus_expand_constant (expr);
4495       delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
4496                                     TYPE_PTRMEM_CLASS_TYPE (type),
4497                                     allow_inverse_p,
4498                                     c_cast_p);
4499       if (!integer_zerop (delta))
4500         expr = cp_build_binary_op (PLUS_EXPR,
4501                                    build_nop (ptrdiff_type_node, expr),
4502                                    delta);
4503       return build_nop (type, expr);
4504     }
4505   else
4506     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4507                              allow_inverse_p, c_cast_p);
4508 }
4509
4510 /* Perform a static_cast from EXPR to TYPE.  When C_CAST_P is true,
4511    this static_cast is being attempted as one of the possible casts
4512    allowed by a C-style cast.  (In that case, accessibility of base
4513    classes is not considered, and it is OK to cast away
4514    constness.)  Return the result of the cast.  *VALID_P is set to
4515    indicate whether or not the cast was valid.  */
4516
4517 static tree
4518 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
4519                      bool *valid_p)
4520 {
4521   tree intype;
4522   tree result;
4523   tree orig;
4524   void (*diag_fn)(const char*, ...);
4525   const char *desc;
4526
4527   /* Assume the cast is valid.  */
4528   *valid_p = true;
4529
4530   intype = TREE_TYPE (expr);
4531
4532   /* Determine what to do when casting away constness.  */
4533   if (c_cast_p)
4534     {
4535       /* C-style casts are allowed to cast away constness.  With
4536          WARN_CAST_QUAL, we still want to issue a warning.  */
4537       diag_fn = warn_cast_qual ? warning0 : NULL;
4538       desc = "cast";
4539     }
4540   else
4541     {
4542       /* A static_cast may not cast away constness.  */
4543       diag_fn = error;
4544       desc = "static_cast";
4545     }
4546
4547   /* [expr.static.cast]
4548
4549      An lvalue of type "cv1 B", where B is a class type, can be cast
4550      to type "reference to cv2 D", where D is a class derived (clause
4551      _class.derived_) from B, if a valid standard conversion from
4552      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4553      same cv-qualification as, or greater cv-qualification than, cv1,
4554      and B is not a virtual base class of D.  */
4555   /* We check this case before checking the validity of "TYPE t =
4556      EXPR;" below because for this case:
4557
4558        struct B {};
4559        struct D : public B { D(const B&); };
4560        extern B& b;
4561        void f() { static_cast<const D&>(b); }
4562
4563      we want to avoid constructing a new D.  The standard is not
4564      completely clear about this issue, but our interpretation is
4565      consistent with other compilers.  */
4566   if (TREE_CODE (type) == REFERENCE_TYPE
4567       && CLASS_TYPE_P (TREE_TYPE (type))
4568       && CLASS_TYPE_P (intype)
4569       && real_lvalue_p (expr)
4570       && DERIVED_FROM_P (intype, TREE_TYPE (type))
4571       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4572                       build_pointer_type (TYPE_MAIN_VARIANT
4573                                           (TREE_TYPE (type))))
4574       && (c_cast_p
4575           || at_least_as_qualified_p (TREE_TYPE (type), intype)))
4576     {
4577       tree base;
4578
4579       /* There is a standard conversion from "D*" to "B*" even if "B"
4580          is ambiguous or inaccessible.  If this is really a
4581          static_cast, then we check both for inaccessibility and
4582          ambiguity.  However, if this is a static_cast being performed
4583          because the user wrote a C-style cast, then accessibility is
4584          not considered.  */
4585       base = lookup_base (TREE_TYPE (type), intype,
4586                           c_cast_p ? ba_unique : ba_check,
4587                           NULL);
4588
4589       /* Convert from "B*" to "D*".  This function will check that "B"
4590          is not a virtual base of "D".  */
4591       expr = build_base_path (MINUS_EXPR, build_address (expr),
4592                               base, /*nonnull=*/false);
4593       /* Convert the pointer to a reference -- but then remember that
4594          there are no expressions with reference type in C++.  */
4595       return convert_from_reference (build_nop (type, expr));
4596     }
4597
4598   orig = expr;
4599
4600   /* [expr.static.cast]
4601
4602      An expression e can be explicitly converted to a type T using a
4603      static_cast of the form static_cast<T>(e) if the declaration T
4604      t(e);" is well-formed, for some invented temporary variable
4605      t.  */
4606   result = perform_direct_initialization_if_possible (type, expr,
4607                                                       c_cast_p);
4608   if (result)
4609     {
4610       result = convert_from_reference (result);
4611
4612       /* Ignore any integer overflow caused by the cast.  */
4613       if (TREE_CODE (result) == INTEGER_CST
4614           && CONSTANT_CLASS_P (orig))
4615         {
4616           TREE_OVERFLOW (result) = TREE_OVERFLOW (orig);
4617           TREE_CONSTANT_OVERFLOW (result)
4618             = TREE_CONSTANT_OVERFLOW (orig);
4619         }
4620       /* [expr.static.cast]
4621
4622          If T is a reference type, the result is an lvalue; otherwise,
4623          the result is an rvalue.  */
4624       if (TREE_CODE (type) != REFERENCE_TYPE
4625           && real_lvalue_p (result))
4626         result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
4627       return result;
4628     }
4629
4630   /* [expr.static.cast]
4631
4632      Any expression can be explicitly converted to type cv void.  */
4633   if (TREE_CODE (type) == VOID_TYPE)
4634     return convert_to_void (expr, /*implicit=*/NULL);
4635
4636   /* [expr.static.cast]
4637
4638      The inverse of any standard conversion sequence (clause _conv_),
4639      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4640      (_conv.array_), function-to-pointer (_conv.func_), and boolean
4641      (_conv.bool_) conversions, can be performed explicitly using
4642      static_cast subject to the restriction that the explicit
4643      conversion does not cast away constness (_expr.const.cast_), and
4644      the following additional rules for specific cases:  */
4645   /* For reference, the conversions not excluded are: integral
4646      promotions, floating point promotion, integral conversions,
4647      floating point conversions, floating-integral conversions,
4648      pointer conversions, and pointer to member conversions.  */
4649   /* DR 128
4650
4651      A value of integral _or enumeration_ type can be explicitly
4652      converted to an enumeration type.  */
4653   /* The effect of all that is that any conversion between any two
4654      types which are integral, floating, or enumeration types can be
4655      performed.  */
4656   if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
4657       && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
4658     {
4659       expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
4660
4661       /* Ignore any integer overflow caused by the cast.  */
4662       if (TREE_CODE (expr) == INTEGER_CST
4663           && CONSTANT_CLASS_P (orig))
4664         {
4665           TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
4666           TREE_CONSTANT_OVERFLOW (expr) = TREE_CONSTANT_OVERFLOW (orig);
4667         }
4668       return expr;
4669     }
4670
4671   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4672       && CLASS_TYPE_P (TREE_TYPE (type))
4673       && CLASS_TYPE_P (TREE_TYPE (intype))
4674       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4675                                           (TREE_TYPE (intype))),
4676                       build_pointer_type (TYPE_MAIN_VARIANT
4677                                           (TREE_TYPE (type)))))
4678     {
4679       tree base;
4680
4681       if (!c_cast_p)
4682         check_for_casting_away_constness (intype, type, diag_fn, desc);
4683       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4684                           c_cast_p ? ba_unique : ba_check,
4685                           NULL);
4686       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4687     }
4688
4689   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4690       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4691     {
4692       tree c1;
4693       tree c2;
4694       tree t1;
4695       tree t2;
4696
4697       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4698       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4699
4700       if (TYPE_PTRMEM_P (type))
4701         {
4702           t1 = (build_ptrmem_type
4703                 (c1,
4704                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4705           t2 = (build_ptrmem_type
4706                 (c2,
4707                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4708         }
4709       else
4710         {
4711           t1 = intype;
4712           t2 = type;
4713         }
4714       if (can_convert (t1, t2))
4715         {
4716           if (!c_cast_p)
4717             check_for_casting_away_constness (intype, type, diag_fn,
4718                                               desc);
4719           return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
4720                                  c_cast_p);
4721         }
4722     }
4723
4724   /* [expr.static.cast]
4725
4726      An rvalue of type "pointer to cv void" can be explicitly
4727      converted to a pointer to object type.  A value of type pointer
4728      to object converted to "pointer to cv void" and back to the
4729      original pointer type will have its original value.  */
4730   if (TREE_CODE (intype) == POINTER_TYPE
4731       && VOID_TYPE_P (TREE_TYPE (intype))
4732       && TYPE_PTROB_P (type))
4733     {
4734       if (!c_cast_p)
4735         check_for_casting_away_constness (intype, type, diag_fn, desc);
4736       return build_nop (type, expr);
4737     }
4738
4739   *valid_p = false;
4740   return error_mark_node;
4741 }
4742
4743 /* Return an expression representing static_cast<TYPE>(EXPR).  */
4744
4745 tree
4746 build_static_cast (tree type, tree expr)
4747 {
4748   tree result;
4749   bool valid_p;
4750
4751   if (type == error_mark_node || expr == error_mark_node)
4752     return error_mark_node;
4753
4754   if (processing_template_decl)
4755     {
4756       expr = build_min (STATIC_CAST_EXPR, type, expr);
4757       /* We don't know if it will or will not have side effects.  */
4758       TREE_SIDE_EFFECTS (expr) = 1;
4759       return convert_from_reference (expr);
4760     }
4761
4762   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4763      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4764   if (TREE_CODE (type) != REFERENCE_TYPE
4765       && TREE_CODE (expr) == NOP_EXPR
4766       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4767     expr = TREE_OPERAND (expr, 0);
4768
4769   result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p);
4770   if (valid_p)
4771     return result;
4772
4773   error ("invalid static_cast from type %qT to type %qT",
4774          TREE_TYPE (expr), type);
4775   return error_mark_node;
4776 }
4777
4778 /* EXPR is an expression with member function or pointer-to-member
4779    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
4780    not permitted by ISO C++, but we accept it in some modes.  If we
4781    are not in one of those modes, issue a diagnostic.  Return the
4782    converted expression.  */
4783
4784 tree
4785 convert_member_func_to_ptr (tree type, tree expr)
4786 {
4787   tree intype;
4788   tree decl;
4789
4790   intype = TREE_TYPE (expr);
4791   gcc_assert (TYPE_PTRMEMFUNC_P (intype)
4792               || TREE_CODE (intype) == METHOD_TYPE);
4793
4794   if (pedantic || warn_pmf2ptr)
4795     pedwarn ("converting from %qT to %qT", intype, type);
4796
4797   if (TREE_CODE (intype) == METHOD_TYPE)
4798     expr = build_addr_func (expr);
4799   else if (TREE_CODE (expr) == PTRMEM_CST)
4800     expr = build_address (PTRMEM_CST_MEMBER (expr));
4801   else
4802     {
4803       decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
4804       decl = build_address (decl);
4805       expr = get_member_function_from_ptrfunc (&decl, expr);
4806     }
4807
4808   return build_nop (type, expr);
4809 }
4810
4811 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
4812    If C_CAST_P is true, this reinterpret cast is being done as part of
4813    a C-style cast.  If VALID_P is non-NULL, *VALID_P is set to
4814    indicate whether or not reinterpret_cast was valid.  */
4815
4816 static tree
4817 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
4818                           bool *valid_p)
4819 {
4820   tree intype;
4821
4822   /* Assume the cast is invalid.  */
4823   if (valid_p)
4824     *valid_p = true;
4825
4826   if (type == error_mark_node || error_operand_p (expr))
4827     return error_mark_node;
4828
4829   intype = TREE_TYPE (expr);
4830
4831   /* [expr.reinterpret.cast]
4832      An lvalue expression of type T1 can be cast to the type
4833      "reference to T2" if an expression of type "pointer to T1" can be
4834      explicitly converted to the type "pointer to T2" using a
4835      reinterpret_cast.  */
4836   if (TREE_CODE (type) == REFERENCE_TYPE)
4837     {
4838       if (! real_lvalue_p (expr))
4839         {
4840           error ("invalid cast of an rvalue expression of type "
4841                  "%qT to type %qT",
4842                  intype, type);
4843           return error_mark_node;
4844         }
4845
4846       /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
4847          "B" are related class types; the reinterpret_cast does not
4848          adjust the pointer.  */
4849       if (TYPE_PTR_P (intype)
4850           && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
4851                          COMPARE_BASE | COMPARE_DERIVED)))
4852         warning (0, "casting %qT to %qT does not dereference pointer",
4853                  intype, type);
4854
4855       expr = build_unary_op (ADDR_EXPR, expr, 0);
4856       if (expr != error_mark_node)
4857         expr = build_reinterpret_cast_1
4858           (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
4859            valid_p);
4860       if (expr != error_mark_node)
4861         expr = build_indirect_ref (expr, 0);
4862       return expr;
4863     }
4864
4865   /* As a G++ extension, we consider conversions from member
4866      functions, and pointers to member functions to
4867      pointer-to-function and pointer-to-void types.  If
4868      -Wno-pmf-conversions has not been specified,
4869      convert_member_func_to_ptr will issue an error message.  */
4870   if ((TYPE_PTRMEMFUNC_P (intype)
4871        || TREE_CODE (intype) == METHOD_TYPE)
4872       && TYPE_PTR_P (type)
4873       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
4874           || VOID_TYPE_P (TREE_TYPE (type))))
4875     return convert_member_func_to_ptr (type, expr);
4876
4877   /* If the cast is not to a reference type, the lvalue-to-rvalue,
4878      array-to-pointer, and function-to-pointer conversions are
4879      performed.  */
4880   expr = decay_conversion (expr);
4881
4882   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4883      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4884   if (TREE_CODE (expr) == NOP_EXPR
4885       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4886     expr = TREE_OPERAND (expr, 0);
4887
4888   if (error_operand_p (expr))
4889     return error_mark_node;
4890
4891   intype = TREE_TYPE (expr);
4892
4893   /* [expr.reinterpret.cast]
4894      A pointer can be converted to any integral type large enough to
4895      hold it.  */
4896   if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
4897     {
4898       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
4899         pedwarn ("cast from %qT to %qT loses precision",
4900                  intype, type);
4901     }
4902   /* [expr.reinterpret.cast]
4903      A value of integral or enumeration type can be explicitly
4904      converted to a pointer.  */
4905   else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
4906     /* OK */
4907     ;
4908   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
4909            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4910     return fold_if_not_in_template (build_nop (type, expr));
4911   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4912            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
4913     {
4914       if (!c_cast_p)
4915         check_for_casting_away_constness (intype, type, error,
4916                                           "reinterpret_cast");
4917       /* Warn about possible alignment problems.  */
4918       if (STRICT_ALIGNMENT && warn_cast_align
4919           && !VOID_TYPE_P (type)
4920           && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
4921           && COMPLETE_TYPE_P (TREE_TYPE (type))
4922           && COMPLETE_TYPE_P (TREE_TYPE (intype))
4923           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
4924         warning (0, "cast from %qT to %qT increases required alignment of "
4925                  "target type",
4926                  intype, type);
4927
4928       return fold_if_not_in_template (build_nop (type, expr));
4929     }
4930   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
4931            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
4932     {
4933       if (pedantic)
4934         /* Only issue a warning, as we have always supported this
4935            where possible, and it is necessary in some cases.  DR 195
4936            addresses this issue, but as of 2004/10/26 is still in
4937            drafting.  */
4938         warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
4939       return fold_if_not_in_template (build_nop (type, expr));
4940     }
4941   else if (TREE_CODE (type) == VECTOR_TYPE)
4942     return fold_if_not_in_template (convert_to_vector (type, expr));
4943   else if (TREE_CODE (intype) == VECTOR_TYPE)
4944     return fold_if_not_in_template (convert_to_integer (type, expr));
4945   else
4946     {
4947       if (valid_p)
4948         *valid_p = false;
4949       error ("invalid cast from type %qT to type %qT", intype, type);
4950       return error_mark_node;
4951     }
4952
4953   return cp_convert (type, expr);
4954 }
4955
4956 tree
4957 build_reinterpret_cast (tree type, tree expr)
4958 {
4959   if (type == error_mark_node || expr == error_mark_node)
4960     return error_mark_node;
4961
4962   if (processing_template_decl)
4963     {
4964       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4965
4966       if (!TREE_SIDE_EFFECTS (t)
4967           && type_dependent_expression_p (expr))
4968         /* There might turn out to be side effects inside expr.  */
4969         TREE_SIDE_EFFECTS (t) = 1;
4970       return convert_from_reference (t);
4971     }
4972
4973   return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
4974                                    /*valid_p=*/NULL);
4975 }
4976
4977 /* Perform a const_cast from EXPR to TYPE.  If the cast is valid,
4978    return an appropriate expression.  Otherwise, return
4979    error_mark_node.  If the cast is not valid, and COMPLAIN is true,
4980    then a diagnostic will be issued.  If VALID_P is non-NULL, its
4981    value upon return will indicate whether or not the conversion
4982    succeeded.  */
4983
4984 static tree
4985 build_const_cast_1 (tree dst_type, tree expr, bool complain,
4986                     bool *valid_p)
4987 {
4988   tree src_type;
4989   tree reference_type;
4990
4991   /* Callers are responsible for handling error_mark_node as a
4992      destination type.  */
4993   gcc_assert (dst_type != error_mark_node);
4994   /* In a template, callers should be building syntactic
4995      representations of casts, not using this machinery.  */
4996   gcc_assert (!processing_template_decl);
4997
4998   /* Assume the conversion is invalid.  */
4999   if (valid_p)
5000     *valid_p = false;
5001
5002   if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5003     {
5004       if (complain)
5005         error ("invalid use of const_cast with type %qT, "
5006                "which is not a pointer, "
5007                "reference, nor a pointer-to-data-member type", dst_type);
5008       return error_mark_node;
5009     }
5010
5011   if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5012     {
5013       if (complain)
5014         error ("invalid use of const_cast with type %qT, which is a pointer "
5015                "or reference to a function type", dst_type);
5016       return error_mark_node;
5017     }
5018
5019   src_type = TREE_TYPE (expr);
5020   /* Expressions do not really have reference types.  */
5021   if (TREE_CODE (src_type) == REFERENCE_TYPE)
5022     src_type = TREE_TYPE (src_type);
5023
5024   /* [expr.const.cast]
5025
5026      An lvalue of type T1 can be explicitly converted to an lvalue of
5027      type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5028      types) if a pointer to T1 can be explicitly converted to the type
5029      pointer to T2 using a const_cast.  */
5030   if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5031     {
5032       reference_type = dst_type;
5033       if (! real_lvalue_p (expr))
5034         {
5035           if (complain)
5036             error ("invalid const_cast of an rvalue of type %qT to type %qT",
5037                    src_type, dst_type);
5038           return error_mark_node;
5039         }
5040       dst_type = build_pointer_type (TREE_TYPE (dst_type));
5041       src_type = build_pointer_type (src_type);
5042     }
5043   else
5044     {
5045       reference_type = NULL_TREE;
5046       /* If the destination type is not a reference type, the
5047          lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5048          conversions are performed.  */
5049       src_type = type_decays_to (src_type);
5050       if (src_type == error_mark_node)
5051         return error_mark_node;
5052     }
5053
5054   if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5055       && comp_ptr_ttypes_const (dst_type, src_type))
5056     {
5057       if (valid_p)
5058         *valid_p = true;
5059       if (reference_type)
5060         {
5061           expr = build_unary_op (ADDR_EXPR, expr, 0);
5062           expr = build_nop (reference_type, expr);
5063           return convert_from_reference (expr);
5064         }
5065       else
5066         {
5067           expr = decay_conversion (expr);
5068           /* build_c_cast puts on a NOP_EXPR to make the result not an
5069              lvalue.  Strip such NOP_EXPRs if VALUE is being used in
5070              non-lvalue context.  */
5071           if (TREE_CODE (expr) == NOP_EXPR
5072               && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5073             expr = TREE_OPERAND (expr, 0);
5074           return build_nop (dst_type, expr);
5075         }
5076     }
5077
5078   if (complain)
5079     error ("invalid const_cast from type %qT to type %qT",
5080            src_type, dst_type);
5081   return error_mark_node;
5082 }
5083
5084 tree
5085 build_const_cast (tree type, tree expr)
5086 {
5087   if (type == error_mark_node || error_operand_p (expr))
5088     return error_mark_node;
5089
5090   if (processing_template_decl)
5091     {
5092       tree t = build_min (CONST_CAST_EXPR, type, expr);
5093
5094       if (!TREE_SIDE_EFFECTS (t)
5095           && type_dependent_expression_p (expr))
5096         /* There might turn out to be side effects inside expr.  */
5097         TREE_SIDE_EFFECTS (t) = 1;
5098       return convert_from_reference (t);
5099     }
5100
5101   return build_const_cast_1 (type, expr, /*complain=*/true,
5102                              /*valid_p=*/NULL);
5103 }
5104
5105 /* Build an expression representing an explicit C-style cast to type
5106    TYPE of expression EXPR.  */
5107
5108 tree
5109 build_c_cast (tree type, tree expr)
5110 {
5111   tree value = expr;
5112   tree result;
5113   bool valid_p;
5114
5115   if (type == error_mark_node || error_operand_p (expr))
5116     return error_mark_node;
5117
5118   if (processing_template_decl)
5119     {
5120       tree t = build_min (CAST_EXPR, type,
5121                           tree_cons (NULL_TREE, value, NULL_TREE));
5122       /* We don't know if it will or will not have side effects.  */
5123       TREE_SIDE_EFFECTS (t) = 1;
5124       return convert_from_reference (t);
5125     }
5126
5127   /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5128      'Class') should always be retained, because this information aids
5129      in method lookup.  */
5130   if (objc_is_object_ptr (type)
5131       && objc_is_object_ptr (TREE_TYPE (expr)))
5132     return build_nop (type, expr);
5133
5134   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5135      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5136   if (TREE_CODE (type) != REFERENCE_TYPE
5137       && TREE_CODE (value) == NOP_EXPR
5138       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5139     value = TREE_OPERAND (value, 0);
5140
5141   if (TREE_CODE (type) == ARRAY_TYPE)
5142     {
5143       /* Allow casting from T1* to T2[] because Cfront allows it.
5144          NIHCL uses it. It is not valid ISO C++ however.  */
5145       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5146         {
5147           pedwarn ("ISO C++ forbids casting to an array type %qT", type);
5148           type = build_pointer_type (TREE_TYPE (type));
5149         }
5150       else
5151         {
5152           error ("ISO C++ forbids casting to an array type %qT", type);
5153           return error_mark_node;
5154         }
5155     }
5156
5157   if (TREE_CODE (type) == FUNCTION_TYPE
5158       || TREE_CODE (type) == METHOD_TYPE)
5159     {
5160       error ("invalid cast to function type %qT", type);
5161       return error_mark_node;
5162     }
5163
5164   /* A C-style cast can be a const_cast.  */
5165   result = build_const_cast_1 (type, value, /*complain=*/false,
5166                                &valid_p);
5167   if (valid_p)
5168     return result;
5169
5170   /* Or a static cast.  */
5171   result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5172                                 &valid_p);
5173   /* Or a reinterpret_cast.  */
5174   if (!valid_p)
5175     result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5176                                        &valid_p);
5177   /* The static_cast or reinterpret_cast may be followed by a
5178      const_cast.  */
5179   if (valid_p
5180       /* A valid cast may result in errors if, for example, a
5181          conversion to am ambiguous base class is required.  */
5182       && !error_operand_p (result))
5183     {
5184       tree result_type;
5185
5186       /* Non-class rvalues always have cv-unqualified type.  */
5187       if (!CLASS_TYPE_P (type))
5188         type = TYPE_MAIN_VARIANT (type);
5189       result_type = TREE_TYPE (result);
5190       if (!CLASS_TYPE_P (result_type))
5191         result_type = TYPE_MAIN_VARIANT (result_type);
5192       /* If the type of RESULT does not match TYPE, perform a
5193          const_cast to make it match.  If the static_cast or
5194          reinterpret_cast succeeded, we will differ by at most
5195          cv-qualification, so the follow-on const_cast is guaranteed
5196          to succeed.  */
5197       if (!same_type_p (non_reference (type), non_reference (result_type)))
5198         {
5199           result = build_const_cast_1 (type, result, false, &valid_p);
5200           gcc_assert (valid_p);
5201         }
5202       return result;
5203     }
5204
5205   return error_mark_node;
5206 }
5207 \f
5208 /* Build an assignment expression of lvalue LHS from value RHS.
5209    MODIFYCODE is the code for a binary operator that we use
5210    to combine the old value of LHS with RHS to get the new value.
5211    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5212
5213    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5214
5215 tree
5216 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5217 {
5218   tree result;
5219   tree newrhs = rhs;
5220   tree lhstype = TREE_TYPE (lhs);
5221   tree olhstype = lhstype;
5222   tree olhs = NULL_TREE;
5223   bool plain_assign = (modifycode == NOP_EXPR);
5224
5225   /* Avoid duplicate error messages from operands that had errors.  */
5226   if (lhs == error_mark_node || rhs == error_mark_node)
5227     return error_mark_node;
5228
5229   /* Handle control structure constructs used as "lvalues".  */
5230   switch (TREE_CODE (lhs))
5231     {
5232       /* Handle --foo = 5; as these are valid constructs in C++.  */
5233     case PREDECREMENT_EXPR:
5234     case PREINCREMENT_EXPR:
5235       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5236         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5237                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5238                       TREE_OPERAND (lhs, 1));
5239       return build2 (COMPOUND_EXPR, lhstype,
5240                      lhs,
5241                      build_modify_expr (TREE_OPERAND (lhs, 0),
5242                                         modifycode, rhs));
5243
5244       /* Handle (a, b) used as an "lvalue".  */
5245     case COMPOUND_EXPR:
5246       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5247                                   modifycode, rhs);
5248       if (newrhs == error_mark_node)
5249         return error_mark_node;
5250       return build2 (COMPOUND_EXPR, lhstype,
5251                      TREE_OPERAND (lhs, 0), newrhs);
5252
5253     case MODIFY_EXPR:
5254       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5255         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5256                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5257                       TREE_OPERAND (lhs, 1));
5258       newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5259       if (newrhs == error_mark_node)
5260         return error_mark_node;
5261       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5262
5263     case MIN_EXPR:
5264     case MAX_EXPR:
5265       /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5266          when neither operand has side-effects.  */
5267       if (!lvalue_or_else (lhs, lv_assign))
5268         return error_mark_node;
5269
5270       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5271                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5272
5273       lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5274                     build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5275                             boolean_type_node,
5276                             TREE_OPERAND (lhs, 0),
5277                             TREE_OPERAND (lhs, 1)),
5278                     TREE_OPERAND (lhs, 0),
5279                     TREE_OPERAND (lhs, 1));
5280       /* Fall through.  */
5281
5282       /* Handle (a ? b : c) used as an "lvalue".  */
5283     case COND_EXPR:
5284       {
5285         /* Produce (a ? (b = rhs) : (c = rhs))
5286            except that the RHS goes through a save-expr
5287            so the code to compute it is only emitted once.  */
5288         tree cond;
5289         tree preeval = NULL_TREE;
5290
5291         rhs = stabilize_expr (rhs, &preeval);
5292
5293         /* Check this here to avoid odd errors when trying to convert
5294            a throw to the type of the COND_EXPR.  */
5295         if (!lvalue_or_else (lhs, lv_assign))
5296           return error_mark_node;
5297
5298         cond = build_conditional_expr
5299           (TREE_OPERAND (lhs, 0),
5300            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5301                                           TREE_OPERAND (lhs, 1)),
5302                               modifycode, rhs),
5303            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5304                                           TREE_OPERAND (lhs, 2)),
5305                               modifycode, rhs));
5306
5307         if (cond == error_mark_node)
5308           return cond;
5309         /* Make sure the code to compute the rhs comes out
5310            before the split.  */
5311         if (preeval)
5312           cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5313         return cond;
5314       }
5315
5316     default:
5317       break;
5318     }
5319
5320   if (modifycode == INIT_EXPR)
5321     {
5322       if (TREE_CODE (rhs) == CONSTRUCTOR)
5323         {
5324           if (! same_type_p (TREE_TYPE (rhs), lhstype))
5325             /* Call convert to generate an error; see PR 11063.  */
5326             rhs = convert (lhstype, rhs);
5327           result = build2 (INIT_EXPR, lhstype, lhs, rhs);
5328           TREE_SIDE_EFFECTS (result) = 1;
5329           return result;
5330         }
5331       else if (! IS_AGGR_TYPE (lhstype))
5332         /* Do the default thing.  */;
5333       else
5334         {
5335           result = build_special_member_call (lhs, complete_ctor_identifier,
5336                                               build_tree_list (NULL_TREE, rhs),
5337                                               lhstype, LOOKUP_NORMAL);
5338           if (result == NULL_TREE)
5339             return error_mark_node;
5340           return result;
5341         }
5342     }
5343   else
5344     {
5345       lhs = require_complete_type (lhs);
5346       if (lhs == error_mark_node)
5347         return error_mark_node;
5348
5349       if (modifycode == NOP_EXPR)
5350         {
5351           /* `operator=' is not an inheritable operator.  */
5352           if (! IS_AGGR_TYPE (lhstype))
5353             /* Do the default thing.  */;
5354           else
5355             {
5356               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5357                                      lhs, rhs, make_node (NOP_EXPR),
5358                                      /*overloaded_p=*/NULL);
5359               if (result == NULL_TREE)
5360                 return error_mark_node;
5361               return result;
5362             }
5363           lhstype = olhstype;
5364         }
5365       else
5366         {
5367           /* A binary op has been requested.  Combine the old LHS
5368              value with the RHS producing the value we should actually
5369              store into the LHS.  */
5370
5371           gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
5372           lhs = stabilize_reference (lhs);
5373           newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5374           if (newrhs == error_mark_node)
5375             {
5376               error ("  in evaluation of %<%Q(%#T, %#T)%>", modifycode,
5377                      TREE_TYPE (lhs), TREE_TYPE (rhs));
5378               return error_mark_node;
5379             }
5380
5381           /* Now it looks like a plain assignment.  */
5382           modifycode = NOP_EXPR;
5383         }
5384       gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
5385       gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
5386     }
5387
5388   /* The left-hand side must be an lvalue.  */
5389   if (!lvalue_or_else (lhs, lv_assign))
5390     return error_mark_node;
5391
5392   /* Warn about modifying something that is `const'.  Don't warn if
5393      this is initialization.  */
5394   if (modifycode != INIT_EXPR
5395       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5396           /* Functions are not modifiable, even though they are
5397              lvalues.  */
5398           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5399           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5400           /* If it's an aggregate and any field is const, then it is
5401              effectively const.  */
5402           || (CLASS_TYPE_P (lhstype)
5403               && C_TYPE_FIELDS_READONLY (lhstype))))
5404     readonly_error (lhs, "assignment", 0);
5405
5406   /* If storing into a structure or union member, it has probably been
5407      given type `int'.  Compute the type that would go with the actual
5408      amount of storage the member occupies.  */
5409
5410   if (TREE_CODE (lhs) == COMPONENT_REF
5411       && (TREE_CODE (lhstype) == INTEGER_TYPE
5412           || TREE_CODE (lhstype) == REAL_TYPE
5413           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5414     {
5415       lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5416
5417       /* If storing in a field that is in actuality a short or narrower
5418          than one, we must store in the field in its actual type.  */
5419
5420       if (lhstype != TREE_TYPE (lhs))
5421         {
5422           /* Avoid warnings converting integral types back into enums for
5423              enum bit fields.  */
5424           if (TREE_CODE (lhstype) == INTEGER_TYPE
5425               && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5426             {
5427               if (TREE_SIDE_EFFECTS (lhs))
5428                 lhs = stabilize_reference (lhs);
5429               olhs = lhs;
5430             }
5431           lhs = copy_node (lhs);
5432           TREE_TYPE (lhs) = lhstype;
5433         }
5434     }
5435
5436   /* Convert new value to destination type.  */
5437
5438   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5439     {
5440       int from_array;
5441
5442       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5443                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5444         {
5445           error ("incompatible types in assignment of %qT to %qT",
5446                  TREE_TYPE (rhs), lhstype);
5447           return error_mark_node;
5448         }
5449
5450       /* Allow array assignment in compiler-generated code.  */
5451       if (! DECL_ARTIFICIAL (current_function_decl))
5452         pedwarn ("ISO C++ forbids assignment of arrays");
5453
5454       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5455                    ? 1 + (modifycode != INIT_EXPR): 0;
5456       return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5457     }
5458
5459   if (modifycode == INIT_EXPR)
5460     newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5461                                          "initialization", NULL_TREE, 0);
5462   else
5463     {
5464       /* Avoid warnings on enum bit fields.  */
5465       if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5466           && TREE_CODE (lhstype) == INTEGER_TYPE)
5467         {
5468           newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5469                                            NULL_TREE, 0);
5470           newrhs = convert_force (lhstype, newrhs, 0);
5471         }
5472       else
5473         newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5474                                          NULL_TREE, 0);
5475       if (TREE_CODE (newrhs) == CALL_EXPR
5476           && TYPE_NEEDS_CONSTRUCTING (lhstype))
5477         newrhs = build_cplus_new (lhstype, newrhs);
5478
5479       /* Can't initialize directly from a TARGET_EXPR, since that would
5480          cause the lhs to be constructed twice, and possibly result in
5481          accidental self-initialization.  So we force the TARGET_EXPR to be
5482          expanded without a target.  */
5483       if (TREE_CODE (newrhs) == TARGET_EXPR)
5484         newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5485                          TREE_OPERAND (newrhs, 0));
5486     }
5487
5488   if (newrhs == error_mark_node)
5489     return error_mark_node;
5490
5491   if (c_dialect_objc () && flag_objc_gc)
5492     {
5493       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
5494
5495       if (result)
5496         return result;
5497     }
5498
5499   result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5500                    lhstype, lhs, newrhs);
5501
5502   TREE_SIDE_EFFECTS (result) = 1;
5503   if (!plain_assign)
5504     TREE_NO_WARNING (result) = 1;
5505
5506   /* If we got the LHS in a different type for storing in,
5507      convert the result back to the nominal type of LHS
5508      so that the value we return always has the same type
5509      as the LHS argument.  */
5510
5511   if (olhstype == TREE_TYPE (result))
5512     return result;
5513   if (olhs)
5514     {
5515       result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
5516       TREE_NO_WARNING (result) = 1;
5517       return result;
5518     }
5519   return convert_for_assignment (olhstype, result, "assignment",
5520                                  NULL_TREE, 0);
5521 }
5522
5523 tree
5524 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5525 {
5526   if (processing_template_decl)
5527     return build_min_nt (MODOP_EXPR, lhs,
5528                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5529
5530   if (modifycode != NOP_EXPR)
5531     {
5532       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5533                                 make_node (modifycode),
5534                                 /*overloaded_p=*/NULL);
5535       if (rval)
5536         {
5537           TREE_NO_WARNING (rval) = 1;
5538           return rval;
5539         }
5540     }
5541   return build_modify_expr (lhs, modifycode, rhs);
5542 }
5543
5544 \f
5545 /* Get difference in deltas for different pointer to member function
5546    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
5547    the conversion is invalid, the constant is zero.  If
5548    ALLOW_INVERSE_P is true, then allow reverse conversions as well.
5549    If C_CAST_P is true this conversion is taking place as part of a
5550    C-style cast.
5551
5552    Note that the naming of FROM and TO is kind of backwards; the return
5553    value is what we add to a TO in order to get a FROM.  They are named
5554    this way because we call this function to find out how to convert from
5555    a pointer to member of FROM to a pointer to member of TO.  */
5556
5557 static tree
5558 get_delta_difference (tree from, tree to,
5559                       bool allow_inverse_p,
5560                       bool c_cast_p)
5561 {
5562   tree binfo;
5563   base_kind kind;
5564   tree result;
5565
5566   /* Assume no conversion is required.  */
5567   result = integer_zero_node;
5568   binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
5569   if (kind == bk_inaccessible || kind == bk_ambig)
5570     error ("   in pointer to member function conversion");
5571   else if (binfo)
5572     {
5573       if (kind != bk_via_virtual)
5574         result = BINFO_OFFSET (binfo);
5575       else
5576         {
5577           tree virt_binfo = binfo_from_vbase (binfo);
5578
5579           /* This is a reinterpret cast, we choose to do nothing.  */
5580           if (allow_inverse_p)
5581             warning (0, "pointer to member cast via virtual base %qT",
5582                      BINFO_TYPE (virt_binfo));
5583           else
5584             error ("pointer to member conversion via virtual base %qT",
5585                    BINFO_TYPE (virt_binfo));
5586         }
5587     }
5588   else if (same_type_ignoring_top_level_qualifiers_p (from, to))
5589     /* Pointer to member of incomplete class is permitted*/;
5590   else if (!allow_inverse_p)
5591     {
5592       error_not_base_type (from, to);
5593       error ("   in pointer to member conversion");
5594     }
5595   else
5596     {
5597       binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind);
5598       if (binfo)
5599         {
5600           if (kind != bk_via_virtual)
5601             result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
5602           else
5603             {
5604               /* This is a reinterpret cast, we choose to do nothing.  */
5605               tree virt_binfo = binfo_from_vbase (binfo);
5606
5607               warning (0, "pointer to member cast via virtual base %qT",
5608                        BINFO_TYPE (virt_binfo));
5609             }
5610         }
5611     }
5612
5613   return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
5614                                                       result));
5615 }
5616
5617 /* Return a constructor for the pointer-to-member-function TYPE using
5618    the other components as specified.  */
5619
5620 tree
5621 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5622 {
5623   tree u = NULL_TREE;
5624   tree delta_field;
5625   tree pfn_field;
5626
5627   /* Pull the FIELD_DECLs out of the type.  */
5628   pfn_field = TYPE_FIELDS (type);
5629   delta_field = TREE_CHAIN (pfn_field);
5630
5631   /* Make sure DELTA has the type we want.  */
5632   delta = convert_and_check (delta_type_node, delta);
5633
5634   /* Finish creating the initializer.  */
5635   u = tree_cons (pfn_field, pfn,
5636                  build_tree_list (delta_field, delta));
5637   u = build_constructor (type, u);
5638   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
5639   TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta);
5640   TREE_STATIC (u) = (TREE_CONSTANT (u)
5641                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5642                          != NULL_TREE)
5643                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5644                          != NULL_TREE));
5645   return u;
5646 }
5647
5648 /* Build a constructor for a pointer to member function.  It can be
5649    used to initialize global variables, local variable, or used
5650    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
5651    want to be.
5652
5653    If FORCE is nonzero, then force this conversion, even if
5654    we would rather not do it.  Usually set when using an explicit
5655    cast.  A C-style cast is being processed iff C_CAST_P is true.
5656
5657    Return error_mark_node, if something goes wrong.  */
5658
5659 tree
5660 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
5661 {
5662   tree fn;
5663   tree pfn_type;
5664   tree to_type;
5665
5666   if (error_operand_p (pfn))
5667     return error_mark_node;
5668
5669   pfn_type = TREE_TYPE (pfn);
5670   to_type = build_ptrmemfunc_type (type);
5671
5672   /* Handle multiple conversions of pointer to member functions.  */
5673   if (TYPE_PTRMEMFUNC_P (pfn_type))
5674     {
5675       tree delta = NULL_TREE;
5676       tree npfn = NULL_TREE;
5677       tree n;
5678
5679       if (!force
5680           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5681         error ("invalid conversion to type %qT from type %qT",
5682                to_type, pfn_type);
5683
5684       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5685                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5686                                 force,
5687                                 c_cast_p);
5688
5689       /* We don't have to do any conversion to convert a
5690          pointer-to-member to its own type.  But, we don't want to
5691          just return a PTRMEM_CST if there's an explicit cast; that
5692          cast should make the expression an invalid template argument.  */
5693       if (TREE_CODE (pfn) != PTRMEM_CST)
5694         {
5695           if (same_type_p (to_type, pfn_type))
5696             return pfn;
5697           else if (integer_zerop (n))
5698             return build_reinterpret_cast (to_type, pfn);
5699         }
5700
5701       if (TREE_SIDE_EFFECTS (pfn))
5702         pfn = save_expr (pfn);
5703
5704       /* Obtain the function pointer and the current DELTA.  */
5705       if (TREE_CODE (pfn) == PTRMEM_CST)
5706         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5707       else
5708         {
5709           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5710           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5711         }
5712
5713       /* Just adjust the DELTA field.  */
5714       gcc_assert  (same_type_ignoring_top_level_qualifiers_p
5715                    (TREE_TYPE (delta), ptrdiff_type_node));
5716       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5717         n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5718       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5719       return build_ptrmemfunc1 (to_type, delta, npfn);
5720     }
5721
5722   /* Handle null pointer to member function conversions.  */
5723   if (integer_zerop (pfn))
5724     {
5725       pfn = build_c_cast (type, integer_zero_node);
5726       return build_ptrmemfunc1 (to_type,
5727                                 integer_zero_node,
5728                                 pfn);
5729     }
5730
5731   if (type_unknown_p (pfn))
5732     return instantiate_type (type, pfn, tf_error | tf_warning);
5733
5734   fn = TREE_OPERAND (pfn, 0);
5735   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
5736               /* In a template, we will have preserved the
5737                  OFFSET_REF.  */
5738               || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
5739   return make_ptrmem_cst (to_type, fn);
5740 }
5741
5742 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5743    given by CST.
5744
5745    ??? There is no consistency as to the types returned for the above
5746    values.  Some code acts as if it were a sizetype and some as if it were
5747    integer_type_node.  */
5748
5749 void
5750 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5751 {
5752   tree type = TREE_TYPE (cst);
5753   tree fn = PTRMEM_CST_MEMBER (cst);
5754   tree ptr_class, fn_class;
5755
5756   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5757
5758   /* The class that the function belongs to.  */
5759   fn_class = DECL_CONTEXT (fn);
5760
5761   /* The class that we're creating a pointer to member of.  */
5762   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5763
5764   /* First, calculate the adjustment to the function's class.  */
5765   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
5766                                  /*c_cast_p=*/0);
5767
5768   if (!DECL_VIRTUAL_P (fn))
5769     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5770   else
5771     {
5772       /* If we're dealing with a virtual function, we have to adjust 'this'
5773          again, to point to the base which provides the vtable entry for
5774          fn; the call will do the opposite adjustment.  */
5775       tree orig_class = DECL_CONTEXT (fn);
5776       tree binfo = binfo_or_else (orig_class, fn_class);
5777       *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5778                        *delta, BINFO_OFFSET (binfo));
5779       *delta = fold_if_not_in_template (*delta);
5780
5781       /* We set PFN to the vtable offset at which the function can be
5782          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5783          case delta is shifted left, and then incremented).  */
5784       *pfn = DECL_VINDEX (fn);
5785       *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
5786                      TYPE_SIZE_UNIT (vtable_entry_type));
5787       *pfn = fold_if_not_in_template (*pfn);
5788
5789       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5790         {
5791         case ptrmemfunc_vbit_in_pfn:
5792           *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
5793                          integer_one_node);
5794           *pfn = fold_if_not_in_template (*pfn);
5795           break;
5796
5797         case ptrmemfunc_vbit_in_delta:
5798           *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
5799                            *delta, integer_one_node);
5800           *delta = fold_if_not_in_template (*delta);
5801           *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5802                            *delta, integer_one_node);
5803           *delta = fold_if_not_in_template (*delta);
5804           break;
5805
5806         default:
5807           gcc_unreachable ();
5808         }
5809
5810       *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
5811       *pfn = fold_if_not_in_template (*pfn);
5812     }
5813 }
5814
5815 /* Return an expression for PFN from the pointer-to-member function
5816    given by T.  */
5817
5818 tree
5819 pfn_from_ptrmemfunc (tree t)
5820 {
5821   if (TREE_CODE (t) == PTRMEM_CST)
5822     {
5823       tree delta;
5824       tree pfn;
5825
5826       expand_ptrmemfunc_cst (t, &delta, &pfn);
5827       if (pfn)
5828         return pfn;
5829     }
5830
5831   return build_ptrmemfunc_access_expr (t, pfn_identifier);
5832 }
5833
5834 /* Convert value RHS to type TYPE as preparation for an assignment to
5835    an lvalue of type TYPE.  ERRTYPE is a string to use in error
5836    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
5837    are doing the conversion in order to pass the PARMNUMth argument of
5838    FNDECL.  */
5839
5840 static tree
5841 convert_for_assignment (tree type, tree rhs,
5842                         const char *errtype, tree fndecl, int parmnum)
5843 {
5844   tree rhstype;
5845   enum tree_code coder;
5846
5847   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
5848   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5849     rhs = TREE_OPERAND (rhs, 0);
5850
5851   rhstype = TREE_TYPE (rhs);
5852   coder = TREE_CODE (rhstype);
5853
5854   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
5855       && vector_types_convertible_p (type, rhstype))
5856     return convert (type, rhs);
5857
5858   if (rhs == error_mark_node || rhstype == error_mark_node)
5859     return error_mark_node;
5860   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
5861     return error_mark_node;
5862
5863   /* The RHS of an assignment cannot have void type.  */
5864   if (coder == VOID_TYPE)
5865     {
5866       error ("void value not ignored as it ought to be");
5867       return error_mark_node;
5868     }
5869
5870   /* Simplify the RHS if possible.  */
5871   if (TREE_CODE (rhs) == CONST_DECL)
5872     rhs = DECL_INITIAL (rhs);
5873
5874   if (c_dialect_objc ())
5875     {
5876       int parmno;
5877       tree rname = fndecl;
5878
5879       if (!strcmp (errtype, "assignment"))
5880         parmno = -1;
5881       else if (!strcmp (errtype, "initialization"))
5882         parmno = -2;
5883       else
5884         {
5885           tree selector = objc_message_selector ();
5886
5887           parmno = parmnum;
5888
5889           if (selector && parmno > 1)
5890             {
5891               rname = selector;
5892               parmno -= 1;
5893             }
5894         }
5895
5896       if (objc_compare_types (type, rhstype, parmno, rname))
5897         return convert (type, rhs);
5898     }
5899
5900   /* [expr.ass]
5901
5902      The expression is implicitly converted (clause _conv_) to the
5903      cv-unqualified type of the left operand.
5904
5905      We allow bad conversions here because by the time we get to this point
5906      we are committed to doing the conversion.  If we end up doing a bad
5907      conversion, convert_like will complain.  */
5908   if (!can_convert_arg_bad (type, rhstype, rhs))
5909     {
5910       /* When -Wno-pmf-conversions is use, we just silently allow
5911          conversions from pointers-to-members to plain pointers.  If
5912          the conversion doesn't work, cp_convert will complain.  */
5913       if (!warn_pmf2ptr
5914           && TYPE_PTR_P (type)
5915           && TYPE_PTRMEMFUNC_P (rhstype))
5916         rhs = cp_convert (strip_top_quals (type), rhs);
5917       else
5918         {
5919           /* If the right-hand side has unknown type, then it is an
5920              overloaded function.  Call instantiate_type to get error
5921              messages.  */
5922           if (rhstype == unknown_type_node)
5923             instantiate_type (type, rhs, tf_error | tf_warning);
5924           else if (fndecl)
5925             error ("cannot convert %qT to %qT for argument %qP to %qD",
5926                    rhstype, type, parmnum, fndecl);
5927           else
5928             error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
5929           return error_mark_node;
5930         }
5931     }
5932   return perform_implicit_conversion (strip_top_quals (type), rhs);
5933 }
5934
5935 /* Convert RHS to be of type TYPE.
5936    If EXP is nonzero, it is the target of the initialization.
5937    ERRTYPE is a string to use in error messages.
5938
5939    Two major differences between the behavior of
5940    `convert_for_assignment' and `convert_for_initialization'
5941    are that references are bashed in the former, while
5942    copied in the latter, and aggregates are assigned in
5943    the former (operator=) while initialized in the
5944    latter (X(X&)).
5945
5946    If using constructor make sure no conversion operator exists, if one does
5947    exist, an ambiguity exists.
5948
5949    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
5950
5951 tree
5952 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
5953                             const char *errtype, tree fndecl, int parmnum)
5954 {
5955   enum tree_code codel = TREE_CODE (type);
5956   tree rhstype;
5957   enum tree_code coder;
5958
5959   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5960      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
5961   if (TREE_CODE (rhs) == NOP_EXPR
5962       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
5963       && codel != REFERENCE_TYPE)
5964     rhs = TREE_OPERAND (rhs, 0);
5965
5966   if (rhs == error_mark_node
5967       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
5968     return error_mark_node;
5969
5970   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
5971        && TREE_CODE (type) != ARRAY_TYPE
5972        && (TREE_CODE (type) != REFERENCE_TYPE
5973            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
5974       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
5975           && (TREE_CODE (type) != REFERENCE_TYPE
5976               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
5977       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
5978     rhs = decay_conversion (rhs);
5979
5980   rhstype = TREE_TYPE (rhs);
5981   coder = TREE_CODE (rhstype);
5982
5983   if (coder == ERROR_MARK)
5984     return error_mark_node;
5985
5986   /* We accept references to incomplete types, so we can
5987      return here before checking if RHS is of complete type.  */
5988
5989   if (codel == REFERENCE_TYPE)
5990     {
5991       /* This should eventually happen in convert_arguments.  */
5992       int savew = 0, savee = 0;
5993
5994       if (fndecl)
5995         savew = warningcount, savee = errorcount;
5996       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
5997                                   /*cleanup=*/NULL);
5998       if (fndecl)
5999         {
6000           if (warningcount > savew)
6001             cp_warning_at ("in passing argument %P of %q+D", parmnum, fndecl);
6002           else if (errorcount > savee)
6003             cp_error_at ("in passing argument %P of %q+D", parmnum, fndecl);
6004         }
6005       return rhs;
6006     }
6007
6008   if (exp != 0)
6009     exp = require_complete_type (exp);
6010   if (exp == error_mark_node)
6011     return error_mark_node;
6012
6013   rhstype = non_reference (rhstype);
6014
6015   type = complete_type (type);
6016
6017   if (IS_AGGR_TYPE (type))
6018     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6019
6020   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
6021 }
6022 \f
6023 /* If RETVAL is the address of, or a reference to, a local variable or
6024    temporary give an appropriate warning.  */
6025
6026 static void
6027 maybe_warn_about_returning_address_of_local (tree retval)
6028 {
6029   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6030   tree whats_returned = retval;
6031
6032   for (;;)
6033     {
6034       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6035         whats_returned = TREE_OPERAND (whats_returned, 1);
6036       else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6037                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6038                || TREE_CODE (whats_returned) == NOP_EXPR)
6039         whats_returned = TREE_OPERAND (whats_returned, 0);
6040       else
6041         break;
6042     }
6043
6044   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6045     return;
6046   whats_returned = TREE_OPERAND (whats_returned, 0);
6047
6048   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6049     {
6050       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6051           || TREE_CODE (whats_returned) == TARGET_EXPR)
6052         {
6053           warning (0, "returning reference to temporary");
6054           return;
6055         }
6056       if (TREE_CODE (whats_returned) == VAR_DECL
6057           && DECL_NAME (whats_returned)
6058           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6059         {
6060           warning (0, "reference to non-lvalue returned");
6061           return;
6062         }
6063     }
6064
6065   if (DECL_P (whats_returned)
6066       && DECL_NAME (whats_returned)
6067       && DECL_FUNCTION_SCOPE_P (whats_returned)
6068       && !(TREE_STATIC (whats_returned)
6069            || TREE_PUBLIC (whats_returned)))
6070     {
6071       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6072         cp_warning_at ("reference to local variable %qD returned",
6073                        whats_returned);
6074       else
6075         cp_warning_at ("address of local variable %qD returned",
6076                        whats_returned);
6077       return;
6078     }
6079 }
6080
6081 /* Check that returning RETVAL from the current function is valid.
6082    Return an expression explicitly showing all conversions required to
6083    change RETVAL into the function return type, and to assign it to
6084    the DECL_RESULT for the function.  */
6085
6086 tree
6087 check_return_expr (tree retval)
6088 {
6089   tree result;
6090   /* The type actually returned by the function, after any
6091      promotions.  */
6092   tree valtype;
6093   int fn_returns_value_p;
6094
6095   /* A `volatile' function is one that isn't supposed to return, ever.
6096      (This is a G++ extension, used to get better code for functions
6097      that call the `volatile' function.)  */
6098   if (TREE_THIS_VOLATILE (current_function_decl))
6099     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6100
6101   /* Check for various simple errors.  */
6102   if (DECL_DESTRUCTOR_P (current_function_decl))
6103     {
6104       if (retval)
6105         error ("returning a value from a destructor");
6106       return NULL_TREE;
6107     }
6108   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6109     {
6110       if (in_function_try_handler)
6111         /* If a return statement appears in a handler of the
6112            function-try-block of a constructor, the program is ill-formed.  */
6113         error ("cannot return from a handler of a function-try-block of a constructor");
6114       else if (retval)
6115         /* You can't return a value from a constructor.  */
6116         error ("returning a value from a constructor");
6117       return NULL_TREE;
6118     }
6119
6120   if (processing_template_decl)
6121     {
6122       current_function_returns_value = 1;
6123       return retval;
6124     }
6125
6126   /* When no explicit return-value is given in a function with a named
6127      return value, the named return value is used.  */
6128   result = DECL_RESULT (current_function_decl);
6129   valtype = TREE_TYPE (result);
6130   gcc_assert (valtype != NULL_TREE);
6131   fn_returns_value_p = !VOID_TYPE_P (valtype);
6132   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6133     retval = result;
6134
6135   /* Check for a return statement with no return value in a function
6136      that's supposed to return a value.  */
6137   if (!retval && fn_returns_value_p)
6138     {
6139       pedwarn ("return-statement with no value, in function returning %qT",
6140                valtype);
6141       /* Clear this, so finish_function won't say that we reach the
6142          end of a non-void function (which we don't, we gave a
6143          return!).  */
6144       current_function_returns_null = 0;
6145     }
6146   /* Check for a return statement with a value in a function that
6147      isn't supposed to return a value.  */
6148   else if (retval && !fn_returns_value_p)
6149     {
6150       if (VOID_TYPE_P (TREE_TYPE (retval)))
6151         /* You can return a `void' value from a function of `void'
6152            type.  In that case, we have to evaluate the expression for
6153            its side-effects.  */
6154           finish_expr_stmt (retval);
6155       else
6156         pedwarn ("return-statement with a value, in function "
6157                  "returning 'void'");
6158
6159       current_function_returns_null = 1;
6160
6161       /* There's really no value to return, after all.  */
6162       return NULL_TREE;
6163     }
6164   else if (!retval)
6165     /* Remember that this function can sometimes return without a
6166        value.  */
6167     current_function_returns_null = 1;
6168   else
6169     /* Remember that this function did return a value.  */
6170     current_function_returns_value = 1;
6171
6172   /* Check for erroneous operands -- but after giving ourselves a
6173      chance to provide an error about returning a value from a void
6174      function.  */
6175   if (error_operand_p (retval))
6176     {
6177       current_function_return_value = error_mark_node;
6178       return error_mark_node;
6179     }
6180
6181   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6182   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6183        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6184       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6185       && ! flag_check_new
6186       && null_ptr_cst_p (retval))
6187     warning (0, "%<operator new%> must not return NULL unless it is "
6188              "declared %<throw()%> (or -fcheck-new is in effect)");
6189
6190   /* Effective C++ rule 15.  See also start_function.  */
6191   if (warn_ecpp
6192       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6193     {
6194       bool warn = true;
6195
6196       /* The function return type must be a reference to the current
6197         class.  */
6198       if (TREE_CODE (valtype) == REFERENCE_TYPE
6199           && same_type_ignoring_top_level_qualifiers_p
6200               (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6201         {
6202           /* Returning '*this' is obviously OK.  */
6203           if (retval == current_class_ref)
6204             warn = false;
6205           /* If we are calling a function whose return type is the same of
6206              the current class reference, it is ok.  */
6207           else if (TREE_CODE (retval) == INDIRECT_REF
6208                    && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6209             warn = false;
6210         }
6211
6212       if (warn)
6213         warning (0, "%<operator=%> should return a reference to %<*this%>");
6214     }
6215
6216   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6217
6218      [...]      For  a function with a class return type, if the expression
6219      in the return statement is the name of a local  object,  and  the  cv-
6220      unqualified  type  of  the  local  object  is the same as the function
6221      return type, an implementation is permitted to omit creating the  tem-
6222      porary  object  to  hold  the function return value [...]
6223
6224      So, if this is a value-returning function that always returns the same
6225      local variable, remember it.
6226
6227      It might be nice to be more flexible, and choose the first suitable
6228      variable even if the function sometimes returns something else, but
6229      then we run the risk of clobbering the variable we chose if the other
6230      returned expression uses the chosen variable somehow.  And people expect
6231      this restriction, anyway.  (jason 2000-11-19)
6232
6233      See finish_function and finalize_nrv for the rest of this optimization.  */
6234
6235   if (fn_returns_value_p && flag_elide_constructors)
6236     {
6237       if (retval != NULL_TREE
6238           && (current_function_return_value == NULL_TREE
6239               || current_function_return_value == retval)
6240           && TREE_CODE (retval) == VAR_DECL
6241           && DECL_CONTEXT (retval) == current_function_decl
6242           && ! TREE_STATIC (retval)
6243           && (DECL_ALIGN (retval)
6244               >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6245           && same_type_p ((TYPE_MAIN_VARIANT
6246                            (TREE_TYPE (retval))),
6247                           (TYPE_MAIN_VARIANT
6248                            (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6249         current_function_return_value = retval;
6250       else
6251         current_function_return_value = error_mark_node;
6252     }
6253
6254   /* We don't need to do any conversions when there's nothing being
6255      returned.  */
6256   if (!retval)
6257     return NULL_TREE;
6258
6259   /* Do any required conversions.  */
6260   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6261     /* No conversions are required.  */
6262     ;
6263   else
6264     {
6265       /* The type the function is declared to return.  */
6266       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6267
6268       /* First convert the value to the function's return type, then
6269          to the type of return value's location to handle the
6270          case that functype is smaller than the valtype.  */
6271       retval = convert_for_initialization
6272         (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6273          "return", NULL_TREE, 0);
6274       retval = convert (valtype, retval);
6275
6276       /* If the conversion failed, treat this just like `return;'.  */
6277       if (retval == error_mark_node)
6278         return retval;
6279       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6280       else if (! current_function_returns_struct
6281                && TREE_CODE (retval) == TARGET_EXPR
6282                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6283         retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6284                          TREE_OPERAND (retval, 0));
6285       else
6286         maybe_warn_about_returning_address_of_local (retval);
6287     }
6288
6289   /* Actually copy the value returned into the appropriate location.  */
6290   if (retval && retval != result)
6291     retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
6292
6293   return retval;
6294 }
6295
6296 \f
6297 /* Returns nonzero if the pointer-type FROM can be converted to the
6298    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6299    then we return nonzero if the pointers are similar, and the
6300    cv-qualification signature of FROM is a proper subset of that of TO.
6301
6302    If CONSTP is positive, then all outer pointers have been
6303    const-qualified.  */
6304
6305 static int
6306 comp_ptr_ttypes_real (tree to, tree from, int constp)
6307 {
6308   bool to_more_cv_qualified = false;
6309
6310   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6311     {
6312       if (TREE_CODE (to) != TREE_CODE (from))
6313         return 0;
6314
6315       if (TREE_CODE (from) == OFFSET_TYPE
6316           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6317                            TYPE_OFFSET_BASETYPE (to)))
6318         return 0;
6319
6320       /* Const and volatile mean something different for function types,
6321          so the usual checks are not appropriate.  */
6322       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6323         {
6324           /* In Objective-C++, some types may have been 'volatilized' by
6325              the compiler for EH; when comparing them here, the volatile
6326              qualification must be ignored.  */
6327           bool objc_quals_match = objc_type_quals_match (to, from);
6328
6329           if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
6330             return 0;
6331
6332           if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
6333             {
6334               if (constp == 0)
6335                 return 0;
6336               to_more_cv_qualified = true;
6337             }
6338
6339           if (constp > 0)
6340             constp &= TYPE_READONLY (to);
6341         }
6342
6343       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6344         return ((constp >= 0 || to_more_cv_qualified)
6345                 && same_type_ignoring_top_level_qualifiers_p (to, from));
6346     }
6347 }
6348
6349 /* When comparing, say, char ** to char const **, this function takes
6350    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
6351    types to this function.  */
6352
6353 int
6354 comp_ptr_ttypes (tree to, tree from)
6355 {
6356   return comp_ptr_ttypes_real (to, from, 1);
6357 }
6358
6359 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6360    type or inheritance-related types, regardless of cv-quals.  */
6361
6362 int
6363 ptr_reasonably_similar (tree to, tree from)
6364 {
6365   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6366     {
6367       /* Any target type is similar enough to void.  */
6368       if (TREE_CODE (to) == VOID_TYPE
6369           || TREE_CODE (from) == VOID_TYPE)
6370         return 1;
6371
6372       if (TREE_CODE (to) != TREE_CODE (from))
6373         return 0;
6374
6375       if (TREE_CODE (from) == OFFSET_TYPE
6376           && comptypes (TYPE_OFFSET_BASETYPE (to),
6377                         TYPE_OFFSET_BASETYPE (from),
6378                         COMPARE_BASE | COMPARE_DERIVED))
6379         continue;
6380
6381       if (TREE_CODE (to) == VECTOR_TYPE
6382           && vector_types_convertible_p (to, from))
6383         return 1;
6384
6385       if (TREE_CODE (to) == INTEGER_TYPE
6386           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6387         return 1;
6388
6389       if (TREE_CODE (to) == FUNCTION_TYPE)
6390         return 1;
6391
6392       if (TREE_CODE (to) != POINTER_TYPE)
6393         return comptypes
6394           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6395            COMPARE_BASE | COMPARE_DERIVED);
6396     }
6397 }
6398
6399 /* Like comp_ptr_ttypes, for const_cast.  */
6400
6401 static int
6402 comp_ptr_ttypes_const (tree to, tree from)
6403 {
6404   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6405     {
6406       if (TREE_CODE (to) != TREE_CODE (from))
6407         return 0;
6408
6409       if (TREE_CODE (from) == OFFSET_TYPE
6410           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6411                           TYPE_OFFSET_BASETYPE (to)))
6412           continue;
6413
6414       if (TREE_CODE (to) != POINTER_TYPE)
6415         return same_type_ignoring_top_level_qualifiers_p (to, from);
6416     }
6417 }
6418
6419 /* Returns the type qualifiers for this type, including the qualifiers on the
6420    elements for an array type.  */
6421
6422 int
6423 cp_type_quals (tree type)
6424 {
6425   type = strip_array_types (type);
6426   if (type == error_mark_node)
6427     return TYPE_UNQUALIFIED;
6428   return TYPE_QUALS (type);
6429 }
6430
6431 /* Returns nonzero if the TYPE contains a mutable member.  */
6432
6433 bool
6434 cp_has_mutable_p (tree type)
6435 {
6436   type = strip_array_types (type);
6437
6438   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6439 }
6440
6441 /* Apply the TYPE_QUALS to the new DECL.  */
6442 void
6443 cp_apply_type_quals_to_decl (int type_quals, tree decl)
6444 {
6445   tree type = TREE_TYPE (decl);
6446
6447   if (type == error_mark_node)
6448     return;
6449
6450   if (TREE_CODE (type) == FUNCTION_TYPE
6451       && type_quals != TYPE_UNQUALIFIED)
6452     {
6453       /* This was an error in C++98 (cv-qualifiers cannot be added to
6454          a function type), but DR 295 makes the code well-formed by
6455          dropping the extra qualifiers. */
6456       if (pedantic)
6457         {
6458           tree bad_type = build_qualified_type (type, type_quals);
6459           pedwarn ("ignoring %qV qualifiers added to function type %qT",
6460                    bad_type, type);
6461         }
6462
6463       TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
6464       return;
6465     }
6466
6467   /* Avoid setting TREE_READONLY incorrectly.  */
6468   if (/* If the object has a constructor, the constructor may modify
6469          the object.  */
6470       TYPE_NEEDS_CONSTRUCTING (type)
6471       /* If the type isn't complete, we don't know yet if it will need
6472          constructing.  */
6473       || !COMPLETE_TYPE_P (type)
6474       /* If the type has a mutable component, that component might be
6475          modified.  */
6476       || TYPE_HAS_MUTABLE_P (type))
6477     type_quals &= ~TYPE_QUAL_CONST;
6478
6479   c_apply_type_quals_to_decl (type_quals, decl);
6480 }
6481
6482 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
6483    exemplar types such that casting T1 to T2 is casting away constness
6484    if and only if there is no implicit conversion from T1 to T2.  */
6485
6486 static void
6487 casts_away_constness_r (tree *t1, tree *t2)
6488 {
6489   int quals1;
6490   int quals2;
6491
6492   /* [expr.const.cast]
6493
6494      For multi-level pointer to members and multi-level mixed pointers
6495      and pointers to members (conv.qual), the "member" aspect of a
6496      pointer to member level is ignored when determining if a const
6497      cv-qualifier has been cast away.  */
6498   /* [expr.const.cast]
6499
6500      For  two  pointer types:
6501
6502             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
6503             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
6504             K is min(N,M)
6505
6506      casting from X1 to X2 casts away constness if, for a non-pointer
6507      type T there does not exist an implicit conversion (clause
6508      _conv_) from:
6509
6510             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6511
6512      to
6513
6514             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
6515   if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
6516       || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
6517     {
6518       *t1 = cp_build_qualified_type (void_type_node,
6519                                      cp_type_quals (*t1));
6520       *t2 = cp_build_qualified_type (void_type_node,
6521                                      cp_type_quals (*t2));
6522       return;
6523     }
6524
6525   quals1 = cp_type_quals (*t1);
6526   quals2 = cp_type_quals (*t2);
6527
6528   if (TYPE_PTRMEM_P (*t1))
6529     *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
6530   else
6531     *t1 = TREE_TYPE (*t1);
6532   if (TYPE_PTRMEM_P (*t2))
6533     *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
6534   else
6535     *t2 = TREE_TYPE (*t2);
6536
6537   casts_away_constness_r (t1, t2);
6538   *t1 = build_pointer_type (*t1);
6539   *t2 = build_pointer_type (*t2);
6540   *t1 = cp_build_qualified_type (*t1, quals1);
6541   *t2 = cp_build_qualified_type (*t2, quals2);
6542 }
6543
6544 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6545    constness.  */
6546
6547 static bool
6548 casts_away_constness (tree t1, tree t2)
6549 {
6550   if (TREE_CODE (t2) == REFERENCE_TYPE)
6551     {
6552       /* [expr.const.cast]
6553
6554          Casting from an lvalue of type T1 to an lvalue of type T2
6555          using a reference cast casts away constness if a cast from an
6556          rvalue of type "pointer to T1" to the type "pointer to T2"
6557          casts away constness.  */
6558       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6559       return casts_away_constness (build_pointer_type (t1),
6560                                    build_pointer_type (TREE_TYPE (t2)));
6561     }
6562
6563   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6564     /* [expr.const.cast]
6565
6566        Casting from an rvalue of type "pointer to data member of X
6567        of type T1" to the type "pointer to data member of Y of type
6568        T2" casts away constness if a cast from an rvalue of type
6569        "pointer to T1" to the type "pointer to T2" casts away
6570        constness.  */
6571     return casts_away_constness
6572       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6573        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6574
6575   /* Casting away constness is only something that makes sense for
6576      pointer or reference types.  */
6577   if (TREE_CODE (t1) != POINTER_TYPE
6578       || TREE_CODE (t2) != POINTER_TYPE)
6579     return false;
6580
6581   /* Top-level qualifiers don't matter.  */
6582   t1 = TYPE_MAIN_VARIANT (t1);
6583   t2 = TYPE_MAIN_VARIANT (t2);
6584   casts_away_constness_r (&t1, &t2);
6585   if (!can_convert (t2, t1))
6586     return true;
6587
6588   return false;
6589 }
6590
6591 /* If T is a REFERENCE_TYPE return the type to which T refers.
6592    Otherwise, return T itself.  */
6593
6594 tree
6595 non_reference (tree t)
6596 {
6597   if (TREE_CODE (t) == REFERENCE_TYPE)
6598     t = TREE_TYPE (t);
6599   return t;
6600 }
6601
6602
6603 /* Return nonzero if REF is an lvalue valid for this language;
6604    otherwise, print an error message and return zero.  USE says
6605    how the lvalue is being used and so selects the error message.  */
6606
6607 int
6608 lvalue_or_else (tree ref, enum lvalue_use use)
6609 {
6610   int win = lvalue_p (ref);
6611
6612   if (!win)
6613     lvalue_error (use);
6614
6615   return win;
6616 }