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