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