gcc/cp/typeck.c

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