contrib/gcc-3.4/gcc/cp/typeck.c

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