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