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
3552       /* For non-dependent pointer-to-member, the SCOPE_REF will be
3553          processed during template substitution.  Just compute the
3554          right type here and build an ADDR_EXPR around it for
3555          diagnostics.  */
3556       if (code == ADDR_EXPR && TREE_CODE (xarg) == SCOPE_REF)
3557         {
3558           tree type;
3559           if (TREE_TYPE (xarg) == unknown_type_node)
3560             type = unknown_type_node;
3561           else if (TREE_CODE (TREE_TYPE (xarg)) == FUNCTION_TYPE)
3562             type = build_pointer_type (TREE_TYPE (xarg));
3563           else
3564             type = build_ptrmem_type (TREE_OPERAND (xarg, 0),
3565                                       TREE_TYPE (xarg));
3566           return build_min (code, type, xarg, NULL_TREE);
3567         }
3568
3569       xarg = build_non_dependent_expr (xarg);
3570     }
3571
3572   exp = NULL_TREE;
3573
3574   /* [expr.unary.op] says:
3575
3576        The address of an object of incomplete type can be taken.
3577
3578      (And is just the ordinary address operator, not an overloaded
3579      "operator &".)  However, if the type is a template
3580      specialization, we must complete the type at this point so that
3581      an overloaded "operator &" will be available if required.  */
3582   if (code == ADDR_EXPR
3583       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3584       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3585            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3586           || (TREE_CODE (xarg) == OFFSET_REF)))
3587     /* Don't look for a function.  */;
3588   else
3589     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3590                         /*overloaded_p=*/NULL);
3591   if (!exp && code == ADDR_EXPR)
3592     {
3593       /*  A pointer to member-function can be formed only by saying
3594           &X::mf.  */
3595       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3596           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3597         {
3598           if (TREE_CODE (xarg) != OFFSET_REF)
3599             {
3600               error ("invalid use of '%E' to form a pointer-to-member-function.  Use a qualified-id.",
3601                      xarg);
3602               return error_mark_node;
3603             }
3604           else
3605             {
3606               error ("parenthesis around '%E' cannot be used to form a pointer-to-member-function",
3607                      xarg);
3608               PTRMEM_OK_P (xarg) = 1;
3609             }
3610         }
3611
3612       if (TREE_CODE (xarg) == OFFSET_REF)
3613         {
3614           ptrmem = PTRMEM_OK_P (xarg);
3615
3616           if (!ptrmem && !flag_ms_extensions
3617               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3618             {
3619               /* A single non-static member, make sure we don't allow a
3620                  pointer-to-member.  */
3621               xarg = build (OFFSET_REF, TREE_TYPE (xarg),
3622                             TREE_OPERAND (xarg, 0),
3623                             ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3624               PTRMEM_OK_P (xarg) = ptrmem;
3625             }
3626         }
3627       else if (TREE_CODE (xarg) == TARGET_EXPR)
3628         warning ("taking address of temporary");
3629       exp = build_unary_op (ADDR_EXPR, xarg, 0);
3630       if (TREE_CODE (exp) == ADDR_EXPR)
3631         PTRMEM_OK_P (exp) = ptrmem;
3632     }
3633
3634   if (processing_template_decl && exp != error_mark_node)
3635     return build_min_non_dep (code, exp, orig_expr,
3636                               /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3637   return exp;
3638 }
3639
3640 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3641    constants, where a null value is represented by an INTEGER_CST of
3642    -1.  */
3643
3644 tree
3645 cp_truthvalue_conversion (tree expr)
3646 {
3647   tree type = TREE_TYPE (expr);
3648   if (TYPE_PTRMEM_P (type))
3649     return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3650   else
3651     return c_common_truthvalue_conversion (expr);
3652 }
3653
3654 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
3655
3656 tree
3657 condition_conversion (tree expr)
3658 {
3659   tree t;
3660   if (processing_template_decl)
3661     return expr;
3662   t = perform_implicit_conversion (boolean_type_node, expr);
3663   t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
3664   return t;
3665 }
3666
3667 /* Return an ADDR_EXPR giving the address of T.  This function
3668    attempts no optimizations or simplifications; it is a low-level
3669    primitive.  */
3670
3671 tree
3672 build_address (tree t)
3673 {
3674   tree addr;
3675
3676   if (error_operand_p (t) || !cxx_mark_addressable (t))
3677     return error_mark_node;
3678
3679   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3680   if (staticp (t))
3681     TREE_CONSTANT (addr) = 1;
3682
3683   return addr;
3684 }
3685
3686 /* Return a NOP_EXPR converting EXPR to TYPE.  */
3687
3688 tree
3689 build_nop (tree type, tree expr)
3690 {
3691   tree nop;
3692
3693   if (type == error_mark_node || error_operand_p (expr))
3694     return expr;
3695
3696   nop = build1 (NOP_EXPR, type, expr);
3697   if (TREE_CONSTANT (expr))
3698     TREE_CONSTANT (nop) = 1;
3699
3700   return nop;
3701 }
3702
3703 /* C++: Must handle pointers to members.
3704
3705    Perhaps type instantiation should be extended to handle conversion
3706    from aggregates to types we don't yet know we want?  (Or are those
3707    cases typically errors which should be reported?)
3708
3709    NOCONVERT nonzero suppresses the default promotions
3710    (such as from short to int).  */
3711
3712 tree
3713 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3714 {
3715   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3716   tree arg = xarg;
3717   tree argtype = 0;
3718   const char *errstring = NULL;
3719   tree val;
3720
3721   if (arg == error_mark_node)
3722     return error_mark_node;
3723
3724   switch (code)
3725     {
3726     case CONVERT_EXPR:
3727       /* This is used for unary plus, because a CONVERT_EXPR
3728          is enough to prevent anybody from looking inside for
3729          associativity, but won't generate any code.  */
3730       if (!(arg = build_expr_type_conversion
3731             (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, true)))
3732         errstring = "wrong type argument to unary plus";
3733       else
3734         {
3735           if (!noconvert)
3736            arg = default_conversion (arg);
3737           arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg);
3738           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3739         }
3740       break;
3741
3742     case NEGATE_EXPR:
3743       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3744         errstring = "wrong type argument to unary minus";
3745       else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3746         arg = perform_integral_promotions (arg);
3747       break;
3748
3749     case BIT_NOT_EXPR:
3750       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3751         {
3752           code = CONJ_EXPR;
3753           if (!noconvert)
3754             arg = default_conversion (arg);
3755         }
3756       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3757                                                    arg, true)))
3758         errstring = "wrong type argument to bit-complement";
3759       else if (!noconvert)
3760         arg = perform_integral_promotions (arg);
3761       break;
3762
3763     case ABS_EXPR:
3764       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3765         errstring = "wrong type argument to abs";
3766       else if (!noconvert)
3767         arg = default_conversion (arg);
3768       break;
3769
3770     case CONJ_EXPR:
3771       /* Conjugating a real value is a no-op, but allow it anyway.  */
3772       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3773         errstring = "wrong type argument to conjugation";
3774       else if (!noconvert)
3775         arg = default_conversion (arg);
3776       break;
3777
3778     case TRUTH_NOT_EXPR:
3779       arg = perform_implicit_conversion (boolean_type_node, arg);
3780       val = invert_truthvalue (arg);
3781       if (arg != error_mark_node)
3782         return val;
3783       errstring = "in argument to unary !";
3784       break;
3785
3786     case NOP_EXPR:
3787       break;
3788
3789     case REALPART_EXPR:
3790       if (TREE_CODE (arg) == COMPLEX_CST)
3791         return TREE_REALPART (arg);
3792       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3793         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3794       else
3795         return arg;
3796
3797     case IMAGPART_EXPR:
3798       if (TREE_CODE (arg) == COMPLEX_CST)
3799         return TREE_IMAGPART (arg);
3800       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3801         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
3802       else
3803         return cp_convert (TREE_TYPE (arg), integer_zero_node);
3804
3805     case PREINCREMENT_EXPR:
3806     case POSTINCREMENT_EXPR:
3807     case PREDECREMENT_EXPR:
3808     case POSTDECREMENT_EXPR:
3809       /* Handle complex lvalues (when permitted)
3810          by reduction to simpler cases.  */
3811
3812       val = unary_complex_lvalue (code, arg);
3813       if (val != 0)
3814         return val;
3815
3816       /* Increment or decrement the real part of the value,
3817          and don't change the imaginary part.  */
3818       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3819         {
3820           tree real, imag;
3821
3822           arg = stabilize_reference (arg);
3823           real = build_unary_op (REALPART_EXPR, arg, 1);
3824           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3825           return build (COMPLEX_EXPR, TREE_TYPE (arg),
3826                         build_unary_op (code, real, 1), imag);
3827         }
3828
3829       /* Report invalid types.  */
3830
3831       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3832                                               arg, true)))
3833         {
3834           if (code == PREINCREMENT_EXPR)
3835             errstring ="no pre-increment operator for type";
3836           else if (code == POSTINCREMENT_EXPR)
3837             errstring ="no post-increment operator for type";
3838           else if (code == PREDECREMENT_EXPR)
3839             errstring ="no pre-decrement operator for type";
3840           else
3841             errstring ="no post-decrement operator for type";
3842           break;
3843         }
3844
3845       /* Report something read-only.  */
3846
3847       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3848           || TREE_READONLY (arg))
3849         readonly_error (arg, ((code == PREINCREMENT_EXPR
3850                                || code == POSTINCREMENT_EXPR)
3851                               ? "increment" : "decrement"),
3852                         0);
3853
3854       {
3855         tree inc;
3856         tree result_type = TREE_TYPE (arg);
3857
3858         arg = get_unwidened (arg, 0);
3859         argtype = TREE_TYPE (arg);
3860
3861         /* ARM $5.2.5 last annotation says this should be forbidden.  */
3862         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3863           pedwarn ("ISO C++ forbids %sing an enum",
3864                    (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3865                    ? "increment" : "decrement");
3866
3867         /* Compute the increment.  */
3868
3869         if (TREE_CODE (argtype) == POINTER_TYPE)
3870           {
3871             tree type = complete_type (TREE_TYPE (argtype));
3872
3873             if (!COMPLETE_OR_VOID_TYPE_P (type))
3874               error ("cannot %s a pointer to incomplete type `%T'",
3875                         ((code == PREINCREMENT_EXPR
3876                           || code == POSTINCREMENT_EXPR)
3877                          ? "increment" : "decrement"), TREE_TYPE (argtype));
3878             else if ((pedantic || warn_pointer_arith)
3879                      && !TYPE_PTROB_P (argtype))
3880               pedwarn ("ISO C++ forbids %sing a pointer of type `%T'",
3881                           ((code == PREINCREMENT_EXPR
3882                             || code == POSTINCREMENT_EXPR)
3883                            ? "increment" : "decrement"), argtype);
3884             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3885           }
3886         else
3887           inc = integer_one_node;
3888
3889         inc = cp_convert (argtype, inc);
3890
3891         /* Handle incrementing a cast-expression.  */
3892
3893         switch (TREE_CODE (arg))
3894           {
3895           case NOP_EXPR:
3896           case CONVERT_EXPR:
3897           case FLOAT_EXPR:
3898           case FIX_TRUNC_EXPR:
3899           case FIX_FLOOR_EXPR:
3900           case FIX_ROUND_EXPR:
3901           case FIX_CEIL_EXPR:
3902             {
3903               tree incremented, modify, value, compound;
3904               if (! lvalue_p (arg) && pedantic)
3905                 pedwarn ("cast to non-reference type used as lvalue");
3906               arg = stabilize_reference (arg);
3907               if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
3908                 value = arg;
3909               else
3910                 value = save_expr (arg);
3911               incremented = build (((code == PREINCREMENT_EXPR
3912                                      || code == POSTINCREMENT_EXPR)
3913                                     ? PLUS_EXPR : MINUS_EXPR),
3914                                    argtype, value, inc);
3915
3916               modify = build_modify_expr (arg, NOP_EXPR, incremented);
3917               compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3918
3919               /* Eliminate warning about unused result of + or -.  */
3920               TREE_NO_UNUSED_WARNING (compound) = 1;
3921               return compound;
3922             }
3923
3924           default:
3925             break;
3926           }
3927
3928         /* Complain about anything else that is not a true lvalue.  */
3929         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3930                                     || code == POSTINCREMENT_EXPR)
3931                                    ? "increment" : "decrement")))
3932           return error_mark_node;
3933
3934         /* Forbid using -- on `bool'.  */
3935         if (TREE_TYPE (arg) == boolean_type_node)
3936           {
3937             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
3938               {
3939                 error ("invalid use of `--' on bool variable `%D'", arg);
3940                 return error_mark_node;
3941               }
3942             val = boolean_increment (code, arg);
3943           }
3944         else
3945           val = build (code, TREE_TYPE (arg), arg, inc);
3946
3947         TREE_SIDE_EFFECTS (val) = 1;
3948         return cp_convert (result_type, val);
3949       }
3950
3951     case ADDR_EXPR:
3952       /* Note that this operation never does default_conversion
3953          regardless of NOCONVERT.  */
3954
3955       argtype = lvalue_type (arg);
3956
3957       if (TREE_CODE (arg) == OFFSET_REF)
3958         goto offset_ref;
3959
3960       if (TREE_CODE (argtype) == REFERENCE_TYPE)
3961         {
3962           arg = build1
3963             (CONVERT_EXPR,
3964              build_pointer_type (TREE_TYPE (argtype)), arg);
3965           TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3966           return arg;
3967         }
3968       else if (pedantic && DECL_MAIN_P (arg))
3969         /* ARM $3.4 */
3970         pedwarn ("ISO C++ forbids taking address of function `::main'");
3971
3972       /* Let &* cancel out to simplify resulting code.  */
3973       if (TREE_CODE (arg) == INDIRECT_REF)
3974         {
3975           /* We don't need to have `current_class_ptr' wrapped in a
3976              NON_LVALUE_EXPR node.  */
3977           if (arg == current_class_ref)
3978             return current_class_ptr;
3979
3980           arg = TREE_OPERAND (arg, 0);
3981           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
3982             {
3983               arg = build1
3984                 (CONVERT_EXPR,
3985                  build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg);
3986               TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0));
3987             }
3988           else if (lvalue_p (arg))
3989             /* Don't let this be an lvalue.  */
3990             return non_lvalue (arg);
3991           return arg;
3992         }
3993
3994       /* For &x[y], return x+y.  But, in a template, ARG may be an
3995          ARRAY_REF representing a non-dependent expression.  In that
3996          case, there may be an overloaded "operator []" that will be
3997          chosen at instantiation time; we must not try to optimize
3998          here.  */
3999       if (TREE_CODE (arg) == ARRAY_REF && !processing_template_decl)
4000         {
4001           if (!cxx_mark_addressable (TREE_OPERAND (arg, 0)))
4002             return error_mark_node;
4003           return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
4004                                      TREE_OPERAND (arg, 1));
4005         }
4006
4007       /* Uninstantiated types are all functions.  Taking the
4008          address of a function is a no-op, so just return the
4009          argument.  */
4010
4011       if (TREE_CODE (arg) == IDENTIFIER_NODE
4012           && IDENTIFIER_OPNAME_P (arg))
4013         {
4014           abort ();
4015           /* We don't know the type yet, so just work around the problem.
4016              We know that this will resolve to an lvalue.  */
4017           return build1 (ADDR_EXPR, unknown_type_node, arg);
4018         }
4019
4020       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4021           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4022         {
4023           /* They're trying to take the address of a unique non-static
4024              member function.  This is ill-formed (except in MS-land),
4025              but let's try to DTRT.
4026              Note: We only handle unique functions here because we don't
4027              want to complain if there's a static overload; non-unique
4028              cases will be handled by instantiate_type.  But we need to
4029              handle this case here to allow casts on the resulting PMF.
4030              We could defer this in non-MS mode, but it's easier to give
4031              a useful error here.  */
4032
4033           /* Inside constant member functions, the `this' pointer
4034              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4035              is used here to remove this const from the diagnostics
4036              and the created OFFSET_REF.  */
4037           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4038           tree name = DECL_NAME (get_first_fn (TREE_OPERAND (arg, 1)));
4039
4040           if (! flag_ms_extensions)
4041             {
4042               if (current_class_type
4043                   && TREE_OPERAND (arg, 0) == current_class_ref)
4044                 /* An expression like &memfn.  */
4045                 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4046                          " or parenthesized non-static member function to form"
4047                          " a pointer to member function.  Say `&%T::%D'",
4048                          base, name);
4049               else
4050                 pedwarn ("ISO C++ forbids taking the address of a bound member"
4051                          " function to form a pointer to member function."
4052                          "  Say `&%T::%D'",
4053                          base, name);
4054             }
4055           arg = build_offset_ref (base, name, /*address_p=*/true);
4056         }
4057
4058     offset_ref:
4059       if (type_unknown_p (arg))
4060         return build1 (ADDR_EXPR, unknown_type_node, arg);
4061
4062       /* Handle complex lvalues (when permitted)
4063          by reduction to simpler cases.  */
4064       val = unary_complex_lvalue (code, arg);
4065       if (val != 0)
4066         return val;
4067
4068       switch (TREE_CODE (arg))
4069         {
4070         case NOP_EXPR:
4071         case CONVERT_EXPR:
4072         case FLOAT_EXPR:
4073         case FIX_TRUNC_EXPR:
4074         case FIX_FLOOR_EXPR:
4075         case FIX_ROUND_EXPR:
4076         case FIX_CEIL_EXPR:
4077           if (! lvalue_p (arg) && pedantic)
4078             pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4079           break;
4080
4081         case OVERLOAD:
4082           arg = OVL_CURRENT (arg);
4083           break;
4084
4085         default:
4086           break;
4087         }
4088
4089       /* Allow the address of a constructor if all the elements
4090          are constant.  */
4091       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg)
4092           && TREE_CONSTANT (arg))
4093         ;
4094       /* Anything not already handled and not a true memory reference
4095          is an error.  */
4096       else if (TREE_CODE (argtype) != FUNCTION_TYPE
4097                && TREE_CODE (argtype) != METHOD_TYPE
4098                && !lvalue_or_else (arg, "unary `&'"))
4099         return error_mark_node;
4100
4101       if (argtype != error_mark_node)
4102         argtype = build_pointer_type (argtype);
4103
4104       {
4105         tree addr;
4106
4107         if (TREE_CODE (arg) != COMPONENT_REF
4108             /* Inside a template, we are processing a non-dependent
4109                expression so we can just form an ADDR_EXPR with the
4110                correct type.  */
4111             || processing_template_decl)
4112           addr = build_address (arg);
4113         else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4114           {
4115             tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4116
4117             /* We can only get here with a single static member
4118                function.  */
4119             my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL
4120                                 && DECL_STATIC_FUNCTION_P (fn),
4121                                 20030906);
4122             mark_used (fn);
4123             addr = build_address (fn);
4124             if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4125               /* Do not lose object's side effects.  */
4126               addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
4127                             TREE_OPERAND (arg, 0), addr);
4128           }
4129         else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4130           {
4131             error ("attempt to take address of bit-field structure member `%D'",
4132                    TREE_OPERAND (arg, 1));
4133             return error_mark_node;
4134           }
4135         else
4136           {
4137             /* Unfortunately we cannot just build an address
4138                expression here, because we would not handle
4139                address-constant-expressions or offsetof correctly.  */
4140             tree field = TREE_OPERAND (arg, 1);
4141             tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
4142             tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
4143                                       decl_type_context (field),
4144                                       ba_check, NULL);
4145
4146             rval = build_base_path (PLUS_EXPR, rval, binfo, 1);
4147             rval = build_nop (argtype, rval);
4148             addr = fold (build (PLUS_EXPR, argtype, rval,
4149                                 cp_convert (argtype, byte_position (field))));
4150           }
4151
4152         if (TREE_CODE (argtype) == POINTER_TYPE
4153             && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4154           {
4155             build_ptrmemfunc_type (argtype);
4156             addr = build_ptrmemfunc (argtype, addr, 0);
4157           }
4158
4159         return addr;
4160       }
4161
4162     default:
4163       break;
4164     }
4165
4166   if (!errstring)
4167     {
4168       if (argtype == 0)
4169         argtype = TREE_TYPE (arg);
4170       return fold (build1 (code, argtype, arg));
4171     }
4172
4173   error ("%s", errstring);
4174   return error_mark_node;
4175 }
4176
4177 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4178    for certain kinds of expressions which are not really lvalues
4179    but which we can accept as lvalues.
4180
4181    If ARG is not a kind of expression we can handle, return zero.  */
4182
4183 tree
4184 unary_complex_lvalue (enum tree_code code, tree arg)
4185 {
4186   /* Handle (a, b) used as an "lvalue".  */
4187   if (TREE_CODE (arg) == COMPOUND_EXPR)
4188     {
4189       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4190       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
4191                     TREE_OPERAND (arg, 0), real_result);
4192     }
4193
4194   /* Handle (a ? b : c) used as an "lvalue".  */
4195   if (TREE_CODE (arg) == COND_EXPR
4196       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4197     return rationalize_conditional_expr (code, arg);
4198
4199   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4200   if (TREE_CODE (arg) == MODIFY_EXPR
4201       || TREE_CODE (arg) == PREINCREMENT_EXPR
4202       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4203     {
4204       tree lvalue = TREE_OPERAND (arg, 0);
4205       if (TREE_SIDE_EFFECTS (lvalue))
4206         {
4207           lvalue = stabilize_reference (lvalue);
4208           arg = build (TREE_CODE (arg), TREE_TYPE (arg),
4209                        lvalue, TREE_OPERAND (arg, 1));
4210         }
4211       return unary_complex_lvalue
4212         (code, build (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4213     }
4214
4215   if (code != ADDR_EXPR)
4216     return 0;
4217
4218   /* Handle (a = b) used as an "lvalue" for `&'.  */
4219   if (TREE_CODE (arg) == MODIFY_EXPR
4220       || TREE_CODE (arg) == INIT_EXPR)
4221     {
4222       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4223       arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result);
4224       TREE_NO_UNUSED_WARNING (arg) = 1;
4225       return arg;
4226     }
4227
4228   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4229       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4230       || TREE_CODE (arg) == OFFSET_REF)
4231     {
4232       tree t;
4233
4234       my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
4235
4236       if (TREE_CODE (arg) != OFFSET_REF)
4237         return 0;
4238
4239       t = TREE_OPERAND (arg, 1);
4240
4241       /* Check all this code for right semantics.  */
4242       if (TREE_CODE (t) == FUNCTION_DECL)
4243         {
4244           if (DECL_DESTRUCTOR_P (t))
4245             error ("taking address of destructor");
4246           return build_unary_op (ADDR_EXPR, t, 0);
4247         }
4248       if (TREE_CODE (t) == VAR_DECL)
4249         return build_unary_op (ADDR_EXPR, t, 0);
4250       else
4251         {
4252           tree type;
4253
4254           if (TREE_OPERAND (arg, 0)
4255               && ! is_dummy_object (TREE_OPERAND (arg, 0))
4256               && TREE_CODE (t) != FIELD_DECL)
4257             {
4258               error ("taking address of bound pointer-to-member expression");
4259               return error_mark_node;
4260             }
4261           if (!PTRMEM_OK_P (arg))
4262             return build_unary_op (code, arg, 0);
4263
4264           if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4265             {
4266               error ("cannot create pointer to reference member `%D'", t);
4267               return error_mark_node;
4268             }
4269
4270           type = build_ptrmem_type (context_for_name_lookup (t),
4271                                     TREE_TYPE (t));
4272           t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4273           return t;
4274         }
4275     }
4276
4277
4278   /* We permit compiler to make function calls returning
4279      objects of aggregate type look like lvalues.  */
4280   {
4281     tree targ = arg;
4282
4283     if (TREE_CODE (targ) == SAVE_EXPR)
4284       targ = TREE_OPERAND (targ, 0);
4285
4286     if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4287       {
4288         if (TREE_CODE (arg) == SAVE_EXPR)
4289           targ = arg;
4290         else
4291           targ = build_cplus_new (TREE_TYPE (arg), arg);
4292         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4293       }
4294
4295     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4296       return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4297                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4298   }
4299
4300   /* Don't let anything else be handled specially.  */
4301   return 0;
4302 }
4303 \f
4304 /* Mark EXP saying that we need to be able to take the
4305    address of it; it should not be allocated in a register.
4306    Value is true if successful.
4307
4308    C++: we do not allow `current_class_ptr' to be addressable.  */
4309
4310 bool
4311 cxx_mark_addressable (tree exp)
4312 {
4313   tree x = exp;
4314
4315   while (1)
4316     switch (TREE_CODE (x))
4317       {
4318       case ADDR_EXPR:
4319       case COMPONENT_REF:
4320       case ARRAY_REF:
4321       case REALPART_EXPR:
4322       case IMAGPART_EXPR:
4323         x = TREE_OPERAND (x, 0);
4324         break;
4325
4326       case PARM_DECL:
4327         if (x == current_class_ptr)
4328           {
4329             error ("cannot take the address of `this', which is an rvalue expression");
4330             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4331             return true;
4332           }
4333         /* Fall through.  */
4334
4335       case VAR_DECL:
4336         /* Caller should not be trying to mark initialized
4337            constant fields addressable.  */
4338         my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0
4339                             || DECL_IN_AGGR_P (x) == 0
4340                             || TREE_STATIC (x)
4341                             || DECL_EXTERNAL (x), 314);
4342         /* Fall through.  */
4343
4344       case CONST_DECL:
4345       case RESULT_DECL:
4346         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4347             && !DECL_ARTIFICIAL (x) && extra_warnings)
4348           warning ("address requested for `%D', which is declared `register'",
4349                       x);
4350         TREE_ADDRESSABLE (x) = 1;
4351         put_var_into_stack (x, /*rescan=*/true);
4352         return true;
4353
4354       case FUNCTION_DECL:
4355         TREE_ADDRESSABLE (x) = 1;
4356         TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
4357         return true;
4358
4359       case CONSTRUCTOR:
4360         TREE_ADDRESSABLE (x) = 1;
4361         return true;
4362
4363       case TARGET_EXPR:
4364         TREE_ADDRESSABLE (x) = 1;
4365         cxx_mark_addressable (TREE_OPERAND (x, 0));
4366         return true;
4367
4368       default:
4369         return true;
4370     }
4371 }
4372 \f
4373 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4374
4375 tree
4376 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4377 {
4378   tree orig_ifexp = ifexp;
4379   tree orig_op1 = op1;
4380   tree orig_op2 = op2;
4381   tree expr;
4382
4383   if (processing_template_decl)
4384     {
4385       /* The standard says that the expression is type-dependent if
4386          IFEXP is type-dependent, even though the eventual type of the
4387          expression doesn't dependent on IFEXP.  */
4388       if (type_dependent_expression_p (ifexp)
4389           /* As a GNU extension, the middle operand may be omitted.  */
4390           || (op1 && type_dependent_expression_p (op1))
4391           || type_dependent_expression_p (op2))
4392         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4393       ifexp = build_non_dependent_expr (ifexp);
4394       if (op1)
4395         op1 = build_non_dependent_expr (op1);
4396       op2 = build_non_dependent_expr (op2);
4397     }
4398
4399   expr = build_conditional_expr (ifexp, op1, op2);
4400   if (processing_template_decl && expr != error_mark_node)
4401     return build_min_non_dep (COND_EXPR, expr,
4402                               orig_ifexp, orig_op1, orig_op2);
4403   return expr;
4404 }
4405 \f
4406 /* Given a list of expressions, return a compound expression
4407    that performs them all and returns the value of the last of them.  */
4408
4409 tree build_x_compound_expr_from_list (tree list, const char *msg)
4410 {
4411   tree expr = TREE_VALUE (list);
4412
4413   if (TREE_CHAIN (list))
4414     {
4415       if (msg)
4416         pedwarn ("%s expression list treated as compound expression", msg);
4417
4418       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4419         expr = build_x_compound_expr (expr, TREE_VALUE (list));
4420     }
4421
4422   return expr;
4423 }
4424
4425 /* Handle overloading of the ',' operator when needed.  */
4426
4427 tree
4428 build_x_compound_expr (tree op1, tree op2)
4429 {
4430   tree result;
4431   tree orig_op1 = op1;
4432   tree orig_op2 = op2;
4433
4434   if (processing_template_decl)
4435     {
4436       if (type_dependent_expression_p (op1)
4437           || type_dependent_expression_p (op2))
4438         return build_min_nt (COMPOUND_EXPR, op1, op2);
4439       op1 = build_non_dependent_expr (op1);
4440       op2 = build_non_dependent_expr (op2);
4441     }
4442
4443   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4444                          /*overloaded_p=*/NULL);
4445   if (!result)
4446     result = build_compound_expr (op1, op2);
4447
4448   if (processing_template_decl && result != error_mark_node)
4449     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4450
4451   return result;
4452 }
4453
4454 /* Build a compound expression.  */
4455
4456 tree
4457 build_compound_expr (tree lhs, tree rhs)
4458 {
4459   lhs = decl_constant_value (lhs);
4460   lhs = convert_to_void (lhs, "left-hand operand of comma");
4461
4462   if (lhs == error_mark_node || rhs == error_mark_node)
4463     return error_mark_node;
4464
4465   if (TREE_CODE (rhs) == TARGET_EXPR)
4466     {
4467       /* If the rhs is a TARGET_EXPR, then build the compound
4468          expression inside the target_expr's initializer. This
4469          helps the compiler to eliminate unnecessary temporaries.  */
4470       tree init = TREE_OPERAND (rhs, 1);
4471
4472       init = build (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4473       TREE_OPERAND (rhs, 1) = init;
4474
4475       return rhs;
4476     }
4477
4478   return build (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4479 }
4480
4481 /* Issue an error message if casting from SRC_TYPE to DEST_TYPE casts
4482    away constness.  DESCRIPTION explains what operation is taking
4483    place.  */
4484
4485 static void
4486 check_for_casting_away_constness (tree src_type, tree dest_type,
4487                                   const char *description)
4488 {
4489   if (casts_away_constness (src_type, dest_type))
4490     error ("%s from type `%T' to type `%T' casts away constness",
4491            description, src_type, dest_type);
4492 }
4493
4494 /* Return an expression representing static_cast<TYPE>(EXPR).  */
4495
4496 tree
4497 build_static_cast (tree type, tree expr)
4498 {
4499   tree intype;
4500   tree result;
4501
4502   if (type == error_mark_node || expr == error_mark_node)
4503     return error_mark_node;
4504
4505   if (processing_template_decl)
4506     {
4507       expr = build_min (STATIC_CAST_EXPR, type, expr);
4508       /* We don't know if it will or will not have side effects.  */
4509       TREE_SIDE_EFFECTS (expr) = 1;
4510       return expr;
4511     }
4512
4513   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4514      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4515   if (TREE_CODE (type) != REFERENCE_TYPE
4516       && TREE_CODE (expr) == NOP_EXPR
4517       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4518     expr = TREE_OPERAND (expr, 0);
4519
4520   intype = TREE_TYPE (expr);
4521
4522   /* [expr.static.cast]
4523
4524      An lvalue of type "cv1 B", where B is a class type, can be cast
4525      to type "reference to cv2 D", where D is a class derived (clause
4526      _class.derived_) from B, if a valid standard conversion from
4527      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4528      same cv-qualification as, or greater cv-qualification than, cv1,
4529      and B is not a virtual base class of D.  */
4530   /* We check this case before checking the validity of "TYPE t =
4531      EXPR;" below because for this case:
4532
4533        struct B {};
4534        struct D : public B { D(const B&); };
4535        extern B& b;
4536        void f() { static_cast<const D&>(b); }
4537
4538      we want to avoid constructing a new D.  The standard is not
4539      completely clear about this issue, but our interpretation is
4540      consistent with other compilers.  */
4541   if (TREE_CODE (type) == REFERENCE_TYPE
4542       && CLASS_TYPE_P (TREE_TYPE (type))
4543       && CLASS_TYPE_P (intype)
4544       && real_lvalue_p (expr)
4545       && DERIVED_FROM_P (intype, TREE_TYPE (type))
4546       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4547                       build_pointer_type (TYPE_MAIN_VARIANT
4548                                           (TREE_TYPE (type))))
4549       && at_least_as_qualified_p (TREE_TYPE (type), intype))
4550     {
4551       /* There is a standard conversion from "D*" to "B*" even if "B"
4552          is ambiguous or inaccessible.  Therefore, we ask lookup_base
4553          to check these conditions.  */
4554       tree base = lookup_base (TREE_TYPE (type), intype, ba_check, NULL);
4555
4556       /* Convert from "B*" to "D*".  This function will check that "B"
4557          is not a virtual base of "D".  */
4558       expr = build_base_path (MINUS_EXPR, build_address (expr),
4559                               base, /*nonnull=*/false);
4560       /* Convert the pointer to a reference -- but then remember that
4561          there are no expressions with reference type in C++.  */
4562       return convert_from_reference (build_nop (type, expr));
4563     }
4564
4565   /* [expr.static.cast]
4566
4567      An expression e can be explicitly converted to a type T using a
4568      static_cast of the form static_cast<T>(e) if the declaration T
4569      t(e);" is well-formed, for some invented temporary variable
4570      t.  */
4571   result = perform_direct_initialization_if_possible (type, expr);
4572   if (result)
4573     {
4574       result = convert_from_reference (result);
4575       /* [expr.static.cast]
4576
4577          If T is a reference type, the result is an lvalue; otherwise,
4578          the result is an rvalue.  */
4579       if (TREE_CODE (type) != REFERENCE_TYPE
4580           && real_lvalue_p (result))
4581         result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
4582       return result;
4583     }
4584
4585   /* [expr.static.cast]
4586
4587      Any expression can be explicitly converted to type cv void.  */
4588   if (TREE_CODE (type) == VOID_TYPE)
4589     return convert_to_void (expr, /*implicit=*/NULL);
4590
4591   /* [expr.static.cast]
4592
4593      The inverse of any standard conversion sequence (clause _conv_),
4594      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4595      (_conv.array_), function-to-pointer (_conv.func_), and boolean
4596      (_conv.bool_) conversions, can be performed explicitly using
4597      static_cast subject to the restriction that the explicit
4598      conversion does not cast away constness (_expr.const.cast_), and
4599      the following additional rules for specific cases:  */
4600   /* For reference, the conversions not excluded are: integral
4601      promotions, floating point promotion, integral conversions,
4602      floating point conversions, floating-integral conversions,
4603      pointer conversions, and pointer to member conversions.  */
4604   if ((ARITHMETIC_TYPE_P (type) && ARITHMETIC_TYPE_P (intype))
4605       /* DR 128
4606
4607          A value of integral _or enumeration_ type can be explicitly
4608          converted to an enumeration type.  */
4609       || (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
4610           && INTEGRAL_OR_ENUMERATION_TYPE_P (intype)))
4611     /* Really, build_c_cast should defer to this function rather
4612        than the other way around.  */
4613     return build_c_cast (type, expr);
4614
4615   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4616       && CLASS_TYPE_P (TREE_TYPE (type))
4617       && CLASS_TYPE_P (TREE_TYPE (intype))
4618       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4619                                           (TREE_TYPE (intype))),
4620                       build_pointer_type (TYPE_MAIN_VARIANT
4621                                           (TREE_TYPE (type)))))
4622     {
4623       tree base;
4624
4625       check_for_casting_away_constness (intype, type, "static_cast");
4626       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), ba_check,
4627                           NULL);
4628       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4629     }
4630
4631   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4632       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4633     {
4634       tree c1;
4635       tree c2;
4636       tree t1;
4637       tree t2;
4638
4639       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4640       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4641
4642       if (TYPE_PTRMEM_P (type))
4643         {
4644           t1 = (build_ptrmem_type
4645                 (c1,
4646                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4647           t2 = (build_ptrmem_type
4648                 (c2,
4649                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4650         }
4651       else
4652         {
4653           t1 = intype;
4654           t2 = type;
4655         }
4656       if (can_convert (t1, t2))
4657         {
4658           check_for_casting_away_constness (intype, type, "static_cast");
4659           if (TYPE_PTRMEM_P (type))
4660             {
4661               tree delta;
4662
4663               if (TREE_CODE (expr) == PTRMEM_CST)
4664                 expr = cplus_expand_constant (expr);
4665               delta = get_delta_difference (c1, c2, /*force=*/1);
4666               if (!integer_zerop (delta))
4667                 expr = cp_build_binary_op (PLUS_EXPR,
4668                                            build_nop (ptrdiff_type_node, expr),
4669                                            delta);
4670               return build_nop (type, expr);
4671             }
4672           else
4673             return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4674                                      /*force=*/1);
4675         }
4676     }
4677
4678   /* [expr.static.cast]
4679
4680      An rvalue of type "pointer to cv void" can be explicitly
4681      converted to a pointer to object type.  A value of type pointer
4682      to object converted to "pointer to cv void" and back to the
4683      original pointer type will have its original value.  */
4684   if (TREE_CODE (intype) == POINTER_TYPE
4685       && VOID_TYPE_P (TREE_TYPE (intype))
4686       && TYPE_PTROB_P (type))
4687     {
4688       check_for_casting_away_constness (intype, type, "static_cast");
4689       return build_nop (type, expr);
4690     }
4691
4692   error ("invalid static_cast from type `%T' to type `%T'", intype, type);
4693   return error_mark_node;
4694 }
4695
4696 tree
4697 build_reinterpret_cast (tree type, tree expr)
4698 {
4699   tree intype;
4700
4701   if (type == error_mark_node || expr == error_mark_node)
4702     return error_mark_node;
4703
4704   if (processing_template_decl)
4705     {
4706       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
4707
4708       if (!TREE_SIDE_EFFECTS (t)
4709           && type_dependent_expression_p (expr))
4710         /* There might turn out to be side effects inside expr.  */
4711         TREE_SIDE_EFFECTS (t) = 1;
4712       return t;
4713     }
4714
4715   if (TREE_CODE (type) != REFERENCE_TYPE)
4716     {
4717       expr = decay_conversion (expr);
4718
4719       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4720          Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4721       if (TREE_CODE (expr) == NOP_EXPR
4722           && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4723         expr = TREE_OPERAND (expr, 0);
4724     }
4725
4726   intype = TREE_TYPE (expr);
4727
4728   if (TREE_CODE (type) == REFERENCE_TYPE)
4729     {
4730       if (! real_lvalue_p (expr))
4731         {
4732           error ("invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'", intype, type);
4733           return error_mark_node;
4734         }
4735       expr = build_unary_op (ADDR_EXPR, expr, 0);
4736       if (expr != error_mark_node)
4737         expr = build_reinterpret_cast
4738           (build_pointer_type (TREE_TYPE (type)), expr);
4739       if (expr != error_mark_node)
4740         expr = build_indirect_ref (expr, 0);
4741       return expr;
4742     }
4743   else if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4744     return build_static_cast (type, expr);
4745
4746   if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE
4747                             || TREE_CODE (intype) == ENUMERAL_TYPE))
4748     /* OK */;
4749   else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype))
4750     {
4751       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
4752         pedwarn ("reinterpret_cast from `%T' to `%T' loses precision",
4753                     intype, type);
4754     }
4755   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
4756            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4757     {
4758       expr = decl_constant_value (expr);
4759       return fold (build1 (NOP_EXPR, type, expr));
4760     }
4761   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4762            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
4763     {
4764       check_for_casting_away_constness (intype, type, "reinterpret_cast");
4765       expr = decl_constant_value (expr);
4766       return fold (build1 (NOP_EXPR, type, expr));
4767     }
4768   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
4769            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
4770     {
4771       pedwarn ("ISO C++ forbids casting between pointer-to-function and pointer-to-object");
4772       expr = decl_constant_value (expr);
4773       return fold (build1 (NOP_EXPR, type, expr));
4774     }
4775   else
4776     {
4777       error ("invalid reinterpret_cast from type `%T' to type `%T'",
4778                 intype, type);
4779       return error_mark_node;
4780     }
4781
4782   return cp_convert (type, expr);
4783 }
4784
4785 tree
4786 build_const_cast (tree type, tree expr)
4787 {
4788   tree intype;
4789
4790   if (type == error_mark_node || expr == error_mark_node)
4791     return error_mark_node;
4792
4793   if (processing_template_decl)
4794     {
4795       tree t = build_min (CONST_CAST_EXPR, type, expr);
4796
4797       if (!TREE_SIDE_EFFECTS (t)
4798           && type_dependent_expression_p (expr))
4799         /* There might turn out to be side effects inside expr.  */
4800         TREE_SIDE_EFFECTS (t) = 1;
4801       return t;
4802     }
4803
4804   if (!POINTER_TYPE_P (type) && !TYPE_PTRMEM_P (type))
4805     error ("invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type", type);
4806   else if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4807     {
4808       error ("invalid use of const_cast with type `%T', which is a pointer or reference to a function type", type);
4809       return error_mark_node;
4810     }
4811
4812   if (TREE_CODE (type) != REFERENCE_TYPE)
4813     {
4814       expr = decay_conversion (expr);
4815
4816       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4817          Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4818       if (TREE_CODE (expr) == NOP_EXPR
4819           && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4820         expr = TREE_OPERAND (expr, 0);
4821     }
4822
4823   intype = TREE_TYPE (expr);
4824
4825   if (same_type_ignoring_top_level_qualifiers_p (intype, type))
4826     return build_static_cast (type, expr);
4827   else if (TREE_CODE (type) == REFERENCE_TYPE)
4828     {
4829       if (! real_lvalue_p (expr))
4830         {
4831           error ("invalid const_cast of an rvalue of type `%T' to type `%T'", intype, type);
4832           return error_mark_node;
4833         }
4834
4835       if (comp_ptr_ttypes_const (TREE_TYPE (type), intype))
4836         {
4837           expr = build_unary_op (ADDR_EXPR, expr, 0);
4838           expr = build1 (NOP_EXPR, type, expr);
4839           return convert_from_reference (expr);
4840         }
4841     }
4842   else if (((TREE_CODE (type) == POINTER_TYPE
4843              && TREE_CODE (intype) == POINTER_TYPE)
4844             || (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)))
4845            && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype)))
4846     return cp_convert (type, expr);
4847
4848   error ("invalid const_cast from type `%T' to type `%T'", intype, type);
4849   return error_mark_node;
4850 }
4851
4852 /* Build an expression representing a cast to type TYPE of expression EXPR.
4853
4854    ALLOW_NONCONVERTING is true if we should allow non-converting constructors
4855    when doing the cast.  */
4856
4857 tree
4858 build_c_cast (tree type, tree expr)
4859 {
4860   tree value = expr;
4861   tree otype;
4862
4863   if (type == error_mark_node || expr == error_mark_node)
4864     return error_mark_node;
4865
4866   if (processing_template_decl)
4867     {
4868       tree t = build_min (CAST_EXPR, type,
4869                           tree_cons (NULL_TREE, value, NULL_TREE));
4870       /* We don't know if it will or will not have side effects.  */
4871       TREE_SIDE_EFFECTS (t) = 1;
4872       return t;
4873     }
4874
4875   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4876      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4877   if (TREE_CODE (type) != REFERENCE_TYPE
4878       && TREE_CODE (value) == NOP_EXPR
4879       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
4880     value = TREE_OPERAND (value, 0);
4881
4882   if (TREE_CODE (type) == ARRAY_TYPE)
4883     {
4884       /* Allow casting from T1* to T2[] because Cfront allows it.
4885          NIHCL uses it. It is not valid ISO C++ however.  */
4886       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
4887         {
4888           pedwarn ("ISO C++ forbids casting to an array type `%T'", type);
4889           type = build_pointer_type (TREE_TYPE (type));
4890         }
4891       else
4892         {
4893           error ("ISO C++ forbids casting to an array type `%T'", type);
4894           return error_mark_node;
4895         }
4896     }
4897
4898   if (TREE_CODE (type) == FUNCTION_TYPE
4899       || TREE_CODE (type) == METHOD_TYPE)
4900     {
4901       error ("invalid cast to function type `%T'", type);
4902       return error_mark_node;
4903     }
4904
4905   if (TREE_CODE (type) == VOID_TYPE)
4906     {
4907       /* Conversion to void does not cause any of the normal function to
4908        * pointer, array to pointer and lvalue to rvalue decays.  */
4909
4910       value = convert_to_void (value, /*implicit=*/NULL);
4911       return value;
4912     }
4913
4914   if (!complete_type_or_else (type, NULL_TREE))
4915     return error_mark_node;
4916
4917   /* Convert functions and arrays to pointers and
4918      convert references to their expanded types,
4919      but don't convert any other types.  If, however, we are
4920      casting to a class type, there's no reason to do this: the
4921      cast will only succeed if there is a converting constructor,
4922      and the default conversions will be done at that point.  In
4923      fact, doing the default conversion here is actually harmful
4924      in cases like this:
4925
4926      typedef int A[2];
4927      struct S { S(const A&); };
4928
4929      since we don't want the array-to-pointer conversion done.  */
4930   if (!IS_AGGR_TYPE (type))
4931     {
4932       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
4933           || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE
4934               /* Don't do the default conversion on a ->* expression.  */
4935               && ! (TREE_CODE (type) == POINTER_TYPE
4936                     && bound_pmf_p (value)))
4937           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
4938           || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
4939         value = decay_conversion (value);
4940     }
4941   else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE)
4942     /* However, even for class types, we still need to strip away
4943        the reference type, since the call to convert_force below
4944        does not expect the input expression to be of reference
4945        type.  */
4946     value = convert_from_reference (value);
4947
4948   otype = TREE_TYPE (value);
4949
4950   /* Optionally warn about potentially worrisome casts.  */
4951
4952   if (warn_cast_qual
4953       && TREE_CODE (type) == POINTER_TYPE
4954       && TREE_CODE (otype) == POINTER_TYPE
4955       && !at_least_as_qualified_p (TREE_TYPE (type),
4956                                    TREE_TYPE (otype)))
4957     warning ("cast from `%T' to `%T' discards qualifiers from pointer target type",
4958                 otype, type);
4959
4960   if (TREE_CODE (type) == INTEGER_TYPE
4961       && TYPE_PTR_P (otype)
4962       && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4963     warning ("cast from pointer to integer of different size");
4964
4965   if (TYPE_PTR_P (type)
4966       && TREE_CODE (otype) == INTEGER_TYPE
4967       && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4968       /* Don't warn about converting any constant.  */
4969       && !TREE_CONSTANT (value))
4970     warning ("cast to pointer from integer of different size");
4971
4972   if (TREE_CODE (type) == REFERENCE_TYPE)
4973     value = (convert_from_reference
4974              (convert_to_reference (type, value, CONV_C_CAST,
4975                                     LOOKUP_COMPLAIN, NULL_TREE)));
4976   else
4977     {
4978       tree ovalue;
4979
4980       value = decl_constant_value (value);
4981
4982       ovalue = value;
4983       value = convert_force (type, value, CONV_C_CAST);
4984
4985       /* Ignore any integer overflow caused by the cast.  */
4986       if (TREE_CODE (value) == INTEGER_CST)
4987         {
4988           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4989           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
4990         }
4991     }
4992
4993   /* Warn about possible alignment problems.  Do this here when we will have
4994      instantiated any necessary template types.  */
4995   if (STRICT_ALIGNMENT && warn_cast_align
4996       && TREE_CODE (type) == POINTER_TYPE
4997       && TREE_CODE (otype) == POINTER_TYPE
4998       && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
4999       && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5000       && COMPLETE_TYPE_P (TREE_TYPE (otype))
5001       && COMPLETE_TYPE_P (TREE_TYPE (type))
5002       && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
5003     warning ("cast from `%T' to `%T' increases required alignment of target type",
5004                 otype, type);
5005
5006     /* Always produce some operator for an explicit cast,
5007        so we can tell (for -pedantic) that the cast is no lvalue.  */
5008   if (TREE_CODE (type) != REFERENCE_TYPE && value == expr
5009       && real_lvalue_p (value))
5010     value = non_lvalue (value);
5011
5012   return value;
5013 }
5014 \f
5015 /* Build an assignment expression of lvalue LHS from value RHS.
5016    MODIFYCODE is the code for a binary operator that we use
5017    to combine the old value of LHS with RHS to get the new value.
5018    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5019
5020    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5021
5022 tree
5023 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5024 {
5025   tree result;
5026   tree newrhs = rhs;
5027   tree lhstype = TREE_TYPE (lhs);
5028   tree olhstype = lhstype;
5029   tree olhs = NULL_TREE;
5030
5031   /* Avoid duplicate error messages from operands that had errors.  */
5032   if (lhs == error_mark_node || rhs == error_mark_node)
5033     return error_mark_node;
5034
5035   /* Handle control structure constructs used as "lvalues".  */
5036   switch (TREE_CODE (lhs))
5037     {
5038       /* Handle --foo = 5; as these are valid constructs in C++.  */
5039     case PREDECREMENT_EXPR:
5040     case PREINCREMENT_EXPR:
5041       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5042         lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5043                      stabilize_reference (TREE_OPERAND (lhs, 0)),
5044                      TREE_OPERAND (lhs, 1));
5045       return build (COMPOUND_EXPR, lhstype,
5046                     lhs,
5047                     build_modify_expr (TREE_OPERAND (lhs, 0),
5048                                        modifycode, rhs));
5049
5050       /* Handle (a, b) used as an "lvalue".  */
5051     case COMPOUND_EXPR:
5052       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5053                                   modifycode, rhs);
5054       if (newrhs == error_mark_node)
5055         return error_mark_node;
5056       return build (COMPOUND_EXPR, lhstype,
5057                     TREE_OPERAND (lhs, 0), newrhs);
5058
5059     case MODIFY_EXPR:
5060       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5061         lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs),
5062                      stabilize_reference (TREE_OPERAND (lhs, 0)),
5063                      TREE_OPERAND (lhs, 1));
5064       newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5065       if (newrhs == error_mark_node)
5066         return error_mark_node;
5067       return build (COMPOUND_EXPR, lhstype, lhs, newrhs);
5068
5069       /* Handle (a ? b : c) used as an "lvalue".  */
5070     case COND_EXPR:
5071       {
5072         /* Produce (a ? (b = rhs) : (c = rhs))
5073            except that the RHS goes through a save-expr
5074            so the code to compute it is only emitted once.  */
5075         tree cond;
5076         tree preeval = NULL_TREE;
5077
5078         rhs = stabilize_expr (rhs, &preeval);
5079
5080         /* Check this here to avoid odd errors when trying to convert
5081            a throw to the type of the COND_EXPR.  */
5082         if (!lvalue_or_else (lhs, "assignment"))
5083           return error_mark_node;
5084
5085         cond = build_conditional_expr
5086           (TREE_OPERAND (lhs, 0),
5087            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5088                                           TREE_OPERAND (lhs, 1)),
5089                               modifycode, rhs),
5090            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5091                                           TREE_OPERAND (lhs, 2)),
5092                               modifycode, rhs));
5093
5094         if (cond == error_mark_node)
5095           return cond;
5096         /* Make sure the code to compute the rhs comes out
5097            before the split.  */
5098         if (preeval)
5099           cond = build (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5100         return cond;
5101       }
5102
5103     default:
5104       break;
5105     }
5106
5107   if (modifycode == INIT_EXPR)
5108     {
5109       if (TREE_CODE (rhs) == CONSTRUCTOR)
5110         {
5111           if (! same_type_p (TREE_TYPE (rhs), lhstype))
5112             /* Call convert to generate an error; see PR 11063.  */
5113             rhs = convert (lhstype, rhs);
5114           result = build (INIT_EXPR, lhstype, lhs, rhs);
5115           TREE_SIDE_EFFECTS (result) = 1;
5116           return result;
5117         }
5118       else if (! IS_AGGR_TYPE (lhstype))
5119         /* Do the default thing.  */;
5120       else
5121         {
5122           result = build_special_member_call (lhs, complete_ctor_identifier,
5123                                               build_tree_list (NULL_TREE, rhs),
5124                                               TYPE_BINFO (lhstype),
5125                                               LOOKUP_NORMAL);
5126           if (result == NULL_TREE)
5127             return error_mark_node;
5128           return result;
5129         }
5130     }
5131   else
5132     {
5133       if (TREE_CODE (lhstype) == REFERENCE_TYPE)
5134         {
5135           lhs = convert_from_reference (lhs);
5136           olhstype = lhstype = TREE_TYPE (lhs);
5137         }
5138       lhs = require_complete_type (lhs);
5139       if (lhs == error_mark_node)
5140         return error_mark_node;
5141
5142       if (modifycode == NOP_EXPR)
5143         {
5144           /* `operator=' is not an inheritable operator.  */
5145           if (! IS_AGGR_TYPE (lhstype))
5146             /* Do the default thing.  */;
5147           else
5148             {
5149               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5150                                      lhs, rhs, make_node (NOP_EXPR),
5151                                      /*overloaded_p=*/NULL);
5152               if (result == NULL_TREE)
5153                 return error_mark_node;
5154               return result;
5155             }
5156           lhstype = olhstype;
5157         }
5158       else
5159         {
5160           /* A binary op has been requested.  Combine the old LHS
5161              value with the RHS producing the value we should actually
5162              store into the LHS.  */
5163
5164           my_friendly_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE),
5165                               978652);
5166           lhs = stabilize_reference (lhs);
5167           newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5168           if (newrhs == error_mark_node)
5169             {
5170               error ("  in evaluation of `%Q(%#T, %#T)'", modifycode,
5171                      TREE_TYPE (lhs), TREE_TYPE (rhs));
5172               return error_mark_node;
5173             }
5174
5175           /* Now it looks like a plain assignment.  */
5176           modifycode = NOP_EXPR;
5177         }
5178       my_friendly_assert (TREE_CODE (lhstype) != REFERENCE_TYPE, 20011220);
5179       my_friendly_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE,
5180                           20011220);
5181     }
5182
5183   /* Handle a cast used as an "lvalue".
5184      We have already performed any binary operator using the value as cast.
5185      Now convert the result to the cast type of the lhs,
5186      and then true type of the lhs and store it there;
5187      then convert result back to the cast type to be the value
5188      of the assignment.  */
5189
5190   switch (TREE_CODE (lhs))
5191     {
5192     case NOP_EXPR:
5193     case CONVERT_EXPR:
5194     case FLOAT_EXPR:
5195     case FIX_TRUNC_EXPR:
5196     case FIX_FLOOR_EXPR:
5197     case FIX_ROUND_EXPR:
5198     case FIX_CEIL_EXPR:
5199       {
5200         tree inner_lhs = TREE_OPERAND (lhs, 0);
5201         tree result;
5202
5203         if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5204             || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE
5205             || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE
5206             || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE)
5207           newrhs = decay_conversion (newrhs);
5208
5209         /* ISO C++ 5.4/1: The result is an lvalue if T is a reference
5210            type, otherwise the result is an rvalue.  */
5211         if (! lvalue_p (lhs))
5212           pedwarn ("ISO C++ forbids cast to non-reference type used as lvalue");
5213
5214         result = build_modify_expr (inner_lhs, NOP_EXPR,
5215                                     cp_convert (TREE_TYPE (inner_lhs),
5216                                                 cp_convert (lhstype, newrhs)));
5217         if (result == error_mark_node)
5218           return result;
5219         return cp_convert (TREE_TYPE (lhs), result);
5220       }
5221
5222     default:
5223       break;
5224     }
5225
5226   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
5227      Reject anything strange now.  */
5228
5229   if (!lvalue_or_else (lhs, "assignment"))
5230     return error_mark_node;
5231
5232   /* Warn about modifying something that is `const'.  Don't warn if
5233      this is initialization.  */
5234   if (modifycode != INIT_EXPR
5235       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5236           /* Functions are not modifiable, even though they are
5237              lvalues.  */
5238           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5239           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5240           /* If it's an aggregate and any field is const, then it is
5241              effectively const.  */
5242           || (CLASS_TYPE_P (lhstype)
5243               && C_TYPE_FIELDS_READONLY (lhstype))))
5244     readonly_error (lhs, "assignment", 0);
5245
5246   /* If storing into a structure or union member, it has probably been
5247      given type `int'.  Compute the type that would go with the actual
5248      amount of storage the member occupies.  */
5249
5250   if (TREE_CODE (lhs) == COMPONENT_REF
5251       && (TREE_CODE (lhstype) == INTEGER_TYPE
5252           || TREE_CODE (lhstype) == REAL_TYPE
5253           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5254     {
5255       lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5256
5257       /* If storing in a field that is in actuality a short or narrower
5258          than one, we must store in the field in its actual type.  */
5259
5260       if (lhstype != TREE_TYPE (lhs))
5261         {
5262           /* Avoid warnings converting integral types back into enums for
5263              enum bit fields.  */
5264           if (TREE_CODE (lhstype) == INTEGER_TYPE
5265               && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5266             {
5267               if (TREE_SIDE_EFFECTS (lhs))
5268                 lhs = stabilize_reference (lhs);
5269               olhs = lhs;
5270             }
5271           lhs = copy_node (lhs);
5272           TREE_TYPE (lhs) = lhstype;
5273         }
5274     }
5275
5276   /* Convert new value to destination type.  */
5277
5278   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5279     {
5280       int from_array;
5281
5282       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5283                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5284         {
5285           error ("incompatible types in assignment of `%T' to `%T'",
5286                  TREE_TYPE (rhs), lhstype);
5287           return error_mark_node;
5288         }
5289
5290       /* Allow array assignment in compiler-generated code.  */
5291       if (! DECL_ARTIFICIAL (current_function_decl))
5292         pedwarn ("ISO C++ forbids assignment of arrays");
5293
5294       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5295                    ? 1 + (modifycode != INIT_EXPR): 0;
5296       return build_vec_init (lhs, NULL_TREE, newrhs, from_array);
5297     }
5298
5299   if (modifycode == INIT_EXPR)
5300     newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5301                                          "initialization", NULL_TREE, 0);
5302   else
5303     {
5304       /* Avoid warnings on enum bit fields.  */
5305       if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5306           && TREE_CODE (lhstype) == INTEGER_TYPE)
5307         {
5308           newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5309                                            NULL_TREE, 0);
5310           newrhs = convert_force (lhstype, newrhs, 0);
5311         }
5312       else
5313         newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5314                                          NULL_TREE, 0);
5315       if (TREE_CODE (newrhs) == CALL_EXPR
5316           && TYPE_NEEDS_CONSTRUCTING (lhstype))
5317         newrhs = build_cplus_new (lhstype, newrhs);
5318
5319       /* Can't initialize directly from a TARGET_EXPR, since that would
5320          cause the lhs to be constructed twice, and possibly result in
5321          accidental self-initialization.  So we force the TARGET_EXPR to be
5322          expanded without a target.  */
5323       if (TREE_CODE (newrhs) == TARGET_EXPR)
5324         newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5325                         TREE_OPERAND (newrhs, 0));
5326     }
5327
5328   if (newrhs == error_mark_node)
5329     return error_mark_node;
5330
5331   result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5332                   lhstype, lhs, newrhs);
5333
5334   TREE_SIDE_EFFECTS (result) = 1;
5335
5336   /* If we got the LHS in a different type for storing in,
5337      convert the result back to the nominal type of LHS
5338      so that the value we return always has the same type
5339      as the LHS argument.  */
5340
5341   if (olhstype == TREE_TYPE (result))
5342     return result;
5343   if (olhs)
5344     {
5345       result = build (COMPOUND_EXPR, olhstype, result, olhs);
5346       TREE_NO_UNUSED_WARNING (result) = 1;
5347       return result;
5348     }
5349   return convert_for_assignment (olhstype, result, "assignment",
5350                                  NULL_TREE, 0);
5351 }
5352
5353 tree
5354 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5355 {
5356   if (processing_template_decl)
5357     return build_min_nt (MODOP_EXPR, lhs,
5358                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5359
5360   if (modifycode != NOP_EXPR)
5361     {
5362       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5363                                 make_node (modifycode),
5364                                 /*overloaded_p=*/NULL);
5365       if (rval)
5366         return rval;
5367     }
5368   return build_modify_expr (lhs, modifycode, rhs);
5369 }
5370
5371 \f
5372 /* Get difference in deltas for different pointer to member function
5373    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
5374    the conversion is invalid, the constant is zero.  If FORCE is true,
5375    then allow reverse conversions as well.
5376
5377    Note that the naming of FROM and TO is kind of backwards; the return
5378    value is what we add to a TO in order to get a FROM.  They are named
5379    this way because we call this function to find out how to convert from
5380    a pointer to member of FROM to a pointer to member of TO.  */
5381
5382 static tree
5383 get_delta_difference (tree from, tree to, int force)
5384 {
5385   tree binfo;
5386   tree virt_binfo;
5387   base_kind kind;
5388
5389   binfo = lookup_base (to, from, ba_check, &kind);
5390   if (kind == bk_inaccessible || kind == bk_ambig)
5391     {
5392       error ("   in pointer to member function conversion");
5393       goto error;
5394     }
5395   if (!binfo)
5396     {
5397       if (!force)
5398         {
5399           error_not_base_type (from, to);
5400           error ("   in pointer to member conversion");
5401           goto error;
5402         }
5403       binfo = lookup_base (from, to, ba_check, &kind);
5404       if (!binfo)
5405         goto error;
5406       virt_binfo = binfo_from_vbase (binfo);
5407       if (virt_binfo)
5408         {
5409           /* This is a reinterpret cast, we choose to do nothing.  */
5410           warning ("pointer to member cast via virtual base `%T'",
5411                    BINFO_TYPE (virt_binfo));
5412           goto error;
5413         }
5414       return fold (convert_to_integer (ptrdiff_type_node,
5415                                        size_diffop (size_zero_node,
5416                                                     BINFO_OFFSET (binfo))));
5417     }
5418
5419   virt_binfo = binfo_from_vbase (binfo);
5420   if (!virt_binfo)
5421     return fold (convert_to_integer (ptrdiff_type_node, BINFO_OFFSET (binfo)));
5422
5423   /* This is a reinterpret cast, we choose to do nothing.  */
5424   if (force)
5425     warning ("pointer to member cast via virtual base `%T'",
5426              BINFO_TYPE (virt_binfo));
5427   else
5428     error ("pointer to member conversion via virtual base `%T'",
5429            BINFO_TYPE (virt_binfo));
5430
5431  error:
5432   return fold (convert_to_integer(ptrdiff_type_node, integer_zero_node));
5433 }
5434
5435 /* Return a constructor for the pointer-to-member-function TYPE using
5436    the other components as specified.  */
5437
5438 tree
5439 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5440 {
5441   tree u = NULL_TREE;
5442   tree delta_field;
5443   tree pfn_field;
5444
5445   /* Pull the FIELD_DECLs out of the type.  */
5446   pfn_field = TYPE_FIELDS (type);
5447   delta_field = TREE_CHAIN (pfn_field);
5448
5449   /* Make sure DELTA has the type we want.  */
5450   delta = convert_and_check (delta_type_node, delta);
5451
5452   /* Finish creating the initializer.  */
5453   u = tree_cons (pfn_field, pfn,
5454                  build_tree_list (delta_field, delta));
5455   u = build_constructor (type, u);
5456   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) && TREE_CONSTANT (delta);
5457   TREE_STATIC (u) = (TREE_CONSTANT (u)
5458                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5459                          != NULL_TREE)
5460                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5461                          != NULL_TREE));
5462   return u;
5463 }
5464
5465 /* Build a constructor for a pointer to member function.  It can be
5466    used to initialize global variables, local variable, or used
5467    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
5468    want to be.
5469
5470    If FORCE is nonzero, then force this conversion, even if
5471    we would rather not do it.  Usually set when using an explicit
5472    cast.
5473
5474    Return error_mark_node, if something goes wrong.  */
5475
5476 tree
5477 build_ptrmemfunc (tree type, tree pfn, int force)
5478 {
5479   tree fn;
5480   tree pfn_type;
5481   tree to_type;
5482
5483   if (error_operand_p (pfn))
5484     return error_mark_node;
5485
5486   pfn_type = TREE_TYPE (pfn);
5487   to_type = build_ptrmemfunc_type (type);
5488
5489   /* Handle multiple conversions of pointer to member functions.  */
5490   if (TYPE_PTRMEMFUNC_P (pfn_type))
5491     {
5492       tree delta = NULL_TREE;
5493       tree npfn = NULL_TREE;
5494       tree n;
5495
5496       if (!force
5497           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn))
5498         error ("invalid conversion to type `%T' from type `%T'",
5499                   to_type, pfn_type);
5500
5501       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5502                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5503                                 force);
5504
5505       /* We don't have to do any conversion to convert a
5506          pointer-to-member to its own type.  But, we don't want to
5507          just return a PTRMEM_CST if there's an explicit cast; that
5508          cast should make the expression an invalid template argument.  */
5509       if (TREE_CODE (pfn) != PTRMEM_CST)
5510         {
5511           if (same_type_p (to_type, pfn_type))
5512             return pfn;
5513           else if (integer_zerop (n))
5514             return build_reinterpret_cast (to_type, pfn);
5515         }
5516
5517       if (TREE_SIDE_EFFECTS (pfn))
5518         pfn = save_expr (pfn);
5519
5520       /* Obtain the function pointer and the current DELTA.  */
5521       if (TREE_CODE (pfn) == PTRMEM_CST)
5522         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5523       else
5524         {
5525           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5526           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5527         }
5528
5529       /* Just adjust the DELTA field.  */
5530       my_friendly_assert
5531         (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (delta),
5532                                                     ptrdiff_type_node),
5533          20030727);
5534       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5535         n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5536       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5537       return build_ptrmemfunc1 (to_type, delta, npfn);
5538     }
5539
5540   /* Handle null pointer to member function conversions.  */
5541   if (integer_zerop (pfn))
5542     {
5543       pfn = build_c_cast (type, integer_zero_node);
5544       return build_ptrmemfunc1 (to_type,
5545                                 integer_zero_node,
5546                                 pfn);
5547     }
5548
5549   if (type_unknown_p (pfn))
5550     return instantiate_type (type, pfn, tf_error | tf_warning);
5551
5552   fn = TREE_OPERAND (pfn, 0);
5553   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5554   return make_ptrmem_cst (to_type, fn);
5555 }
5556
5557 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5558    given by CST.
5559
5560    ??? There is no consistency as to the types returned for the above
5561    values.  Some code acts as if its a sizetype and some as if its
5562    integer_type_node.  */
5563
5564 void
5565 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5566 {
5567   tree type = TREE_TYPE (cst);
5568   tree fn = PTRMEM_CST_MEMBER (cst);
5569   tree ptr_class, fn_class;
5570
5571   my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 0);
5572
5573   /* The class that the function belongs to.  */
5574   fn_class = DECL_CONTEXT (fn);
5575
5576   /* The class that we're creating a pointer to member of.  */
5577   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5578
5579   /* First, calculate the adjustment to the function's class.  */
5580   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0);
5581
5582   if (!DECL_VIRTUAL_P (fn))
5583     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5584   else
5585     {
5586       /* If we're dealing with a virtual function, we have to adjust 'this'
5587          again, to point to the base which provides the vtable entry for
5588          fn; the call will do the opposite adjustment.  */
5589       tree orig_class = DECL_CONTEXT (fn);
5590       tree binfo = binfo_or_else (orig_class, fn_class);
5591       *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5592                             *delta, BINFO_OFFSET (binfo)));
5593
5594       /* We set PFN to the vtable offset at which the function can be
5595          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5596          case delta is shifted left, and then incremented).  */
5597       *pfn = DECL_VINDEX (fn);
5598       *pfn = fold (build (MULT_EXPR, integer_type_node, *pfn,
5599                           TYPE_SIZE_UNIT (vtable_entry_type)));
5600
5601       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5602         {
5603         case ptrmemfunc_vbit_in_pfn:
5604           *pfn = fold (build (PLUS_EXPR, integer_type_node, *pfn,
5605                               integer_one_node));
5606           break;
5607
5608         case ptrmemfunc_vbit_in_delta:
5609           *delta = fold (build (LSHIFT_EXPR, TREE_TYPE (*delta),
5610                                 *delta, integer_one_node));
5611           *delta = fold (build (PLUS_EXPR, TREE_TYPE (*delta),
5612                                 *delta, integer_one_node));
5613           break;
5614
5615         default:
5616           abort ();
5617         }
5618
5619       *pfn = fold (build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type),
5620                            *pfn));
5621     }
5622 }
5623
5624 /* Return an expression for PFN from the pointer-to-member function
5625    given by T.  */
5626
5627 tree
5628 pfn_from_ptrmemfunc (tree t)
5629 {
5630   if (TREE_CODE (t) == PTRMEM_CST)
5631     {
5632       tree delta;
5633       tree pfn;
5634
5635       expand_ptrmemfunc_cst (t, &delta, &pfn);
5636       if (pfn)
5637         return pfn;
5638     }
5639
5640   return build_ptrmemfunc_access_expr (t, pfn_identifier);
5641 }
5642
5643 /* Expression EXPR is about to be implicitly converted to TYPE.  Warn
5644    if this is a potentially dangerous thing to do.  Returns a possibly
5645    marked EXPR.  */
5646
5647 tree
5648 dubious_conversion_warnings (tree type, tree expr,
5649                              const char *errtype, tree fndecl, int parmnum)
5650 {
5651   type = non_reference (type);
5652
5653   /* Issue warnings about peculiar, but valid, uses of NULL.  */
5654   if (ARITHMETIC_TYPE_P (type) && expr == null_node)
5655     {
5656       if (fndecl)
5657         warning ("passing NULL used for non-pointer %s %P of `%D'",
5658                     errtype, parmnum, fndecl);
5659       else
5660         warning ("%s to non-pointer type `%T' from NULL", errtype, type);
5661     }
5662
5663   /* Warn about assigning a floating-point type to an integer type.  */
5664   if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
5665       && TREE_CODE (type) == INTEGER_TYPE)
5666     {
5667       if (fndecl)
5668         warning ("passing `%T' for %s %P of `%D'",
5669                     TREE_TYPE (expr), errtype, parmnum, fndecl);
5670       else
5671         warning ("%s to `%T' from `%T'", errtype, type, TREE_TYPE (expr));
5672     }
5673   /* And warn about assigning a negative value to an unsigned
5674      variable.  */
5675   else if (TREE_UNSIGNED (type) && TREE_CODE (type) != BOOLEAN_TYPE)
5676     {
5677       if (TREE_CODE (expr) == INTEGER_CST
5678           && TREE_NEGATED_INT (expr))
5679         {
5680           if (fndecl)
5681             warning ("passing negative value `%E' for %s %P of `%D'",
5682                         expr, errtype, parmnum, fndecl);
5683           else
5684             warning ("%s of negative value `%E' to `%T'",
5685                         errtype, expr, type);
5686         }
5687
5688       overflow_warning (expr);
5689
5690       if (TREE_CONSTANT (expr))
5691         expr = fold (expr);
5692     }
5693   return expr;
5694 }
5695
5696 /* Convert value RHS to type TYPE as preparation for an assignment to
5697    an lvalue of type TYPE.  ERRTYPE is a string to use in error
5698    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
5699    are doing the conversion in order to pass the PARMNUMth argument of
5700    FNDECL.  */
5701
5702 static tree
5703 convert_for_assignment (tree type, tree rhs,
5704                         const char *errtype, tree fndecl, int parmnum)
5705 {
5706   tree rhstype;
5707   enum tree_code coder;
5708
5709   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
5710   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5711     rhs = TREE_OPERAND (rhs, 0);
5712
5713   rhstype = TREE_TYPE (rhs);
5714   coder = TREE_CODE (rhstype);
5715
5716   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
5717       && ((*targetm.vector_opaque_p) (type)
5718           || (*targetm.vector_opaque_p) (rhstype)))
5719     return convert (type, rhs);
5720
5721   if (rhs == error_mark_node || rhstype == error_mark_node)
5722     return error_mark_node;
5723   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
5724     return error_mark_node;
5725
5726   /* The RHS of an assignment cannot have void type.  */
5727   if (coder == VOID_TYPE)
5728     {
5729       error ("void value not ignored as it ought to be");
5730       return error_mark_node;
5731     }
5732
5733   /* Simplify the RHS if possible.  */
5734   if (TREE_CODE (rhs) == CONST_DECL)
5735     rhs = DECL_INITIAL (rhs);
5736
5737   /* We do not use decl_constant_value here because of this case:
5738
5739        const char* const s = "s";
5740
5741      The conversion rules for a string literal are more lax than for a
5742      variable; in particular, a string literal can be converted to a
5743      "char *" but the variable "s" cannot be converted in the same
5744      way.  If the conversion is allowed, the optimization should be
5745      performed while creating the converted expression.  */
5746
5747   /* [expr.ass]
5748
5749      The expression is implicitly converted (clause _conv_) to the
5750      cv-unqualified type of the left operand.
5751
5752      We allow bad conversions here because by the time we get to this point
5753      we are committed to doing the conversion.  If we end up doing a bad
5754      conversion, convert_like will complain.  */
5755   if (!can_convert_arg_bad (type, rhstype, rhs))
5756     {
5757       /* When -Wno-pmf-conversions is use, we just silently allow
5758          conversions from pointers-to-members to plain pointers.  If
5759          the conversion doesn't work, cp_convert will complain.  */
5760       if (!warn_pmf2ptr
5761           && TYPE_PTR_P (type)
5762           && TYPE_PTRMEMFUNC_P (rhstype))
5763         rhs = cp_convert (strip_top_quals (type), rhs);
5764       else
5765         {
5766           /* If the right-hand side has unknown type, then it is an
5767              overloaded function.  Call instantiate_type to get error
5768              messages.  */
5769           if (rhstype == unknown_type_node)
5770             instantiate_type (type, rhs, tf_error | tf_warning);
5771           else if (fndecl)
5772             error ("cannot convert `%T' to `%T' for argument `%P' to `%D'",
5773                       rhstype, type, parmnum, fndecl);
5774           else
5775             error ("cannot convert `%T' to `%T' in %s", rhstype, type,
5776                       errtype);
5777           return error_mark_node;
5778         }
5779     }
5780   return perform_implicit_conversion (strip_top_quals (type), rhs);
5781 }
5782
5783 /* Convert RHS to be of type TYPE.
5784    If EXP is nonzero, it is the target of the initialization.
5785    ERRTYPE is a string to use in error messages.
5786
5787    Two major differences between the behavior of
5788    `convert_for_assignment' and `convert_for_initialization'
5789    are that references are bashed in the former, while
5790    copied in the latter, and aggregates are assigned in
5791    the former (operator=) while initialized in the
5792    latter (X(X&)).
5793
5794    If using constructor make sure no conversion operator exists, if one does
5795    exist, an ambiguity exists.
5796
5797    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
5798
5799 tree
5800 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
5801                             const char *errtype, tree fndecl, int parmnum)
5802 {
5803   enum tree_code codel = TREE_CODE (type);
5804   tree rhstype;
5805   enum tree_code coder;
5806
5807   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5808      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
5809   if (TREE_CODE (rhs) == NOP_EXPR
5810       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
5811       && codel != REFERENCE_TYPE)
5812     rhs = TREE_OPERAND (rhs, 0);
5813
5814   if (rhs == error_mark_node
5815       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
5816     return error_mark_node;
5817
5818   if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE)
5819     rhs = convert_from_reference (rhs);
5820
5821   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
5822        && TREE_CODE (type) != ARRAY_TYPE
5823        && (TREE_CODE (type) != REFERENCE_TYPE
5824            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
5825       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
5826           && (TREE_CODE (type) != REFERENCE_TYPE
5827               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
5828       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
5829     rhs = decay_conversion (rhs);
5830
5831   rhstype = TREE_TYPE (rhs);
5832   coder = TREE_CODE (rhstype);
5833
5834   if (coder == ERROR_MARK)
5835     return error_mark_node;
5836
5837   /* We accept references to incomplete types, so we can
5838      return here before checking if RHS is of complete type.  */
5839
5840   if (codel == REFERENCE_TYPE)
5841     {
5842       /* This should eventually happen in convert_arguments.  */
5843       int savew = 0, savee = 0;
5844
5845       if (fndecl)
5846         savew = warningcount, savee = errorcount;
5847       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
5848                                   /*cleanup=*/NULL);
5849       if (fndecl)
5850         {
5851           if (warningcount > savew)
5852             cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5853           else if (errorcount > savee)
5854             cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl);
5855         }
5856       return rhs;
5857     }
5858
5859   if (exp != 0)
5860     exp = require_complete_type (exp);
5861   if (exp == error_mark_node)
5862     return error_mark_node;
5863
5864   rhstype = non_reference (rhstype);
5865
5866   type = complete_type (type);
5867
5868   if (IS_AGGR_TYPE (type))
5869     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
5870
5871   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
5872 }
5873 \f
5874 /* Expand an ASM statement with operands, handling output operands
5875    that are not variables or INDIRECT_REFS by transforming such
5876    cases into cases that expand_asm_operands can handle.
5877
5878    Arguments are same as for expand_asm_operands.
5879
5880    We don't do default conversions on all inputs, because it can screw
5881    up operands that are expected to be in memory.  */
5882
5883 void
5884 c_expand_asm_operands (tree string, tree outputs, tree inputs, tree clobbers,
5885                        int vol, location_t locus)
5886 {
5887   int noutputs = list_length (outputs);
5888   int i;
5889   /* o[I] is the place that output number I should be written.  */
5890   tree *o = alloca (noutputs * sizeof (tree));
5891   tree tail;
5892
5893   /* Record the contents of OUTPUTS before it is modified.  */
5894   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5895     o[i] = TREE_VALUE (tail);
5896
5897   /* Generate the ASM_OPERANDS insn;
5898      store into the TREE_VALUEs of OUTPUTS some trees for
5899      where the values were actually stored.  */
5900   expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
5901
5902   /* Copy all the intermediate outputs into the specified outputs.  */
5903   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
5904     {
5905       if (o[i] != TREE_VALUE (tail))
5906         {
5907           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
5908                        const0_rtx, VOIDmode, EXPAND_NORMAL);
5909           free_temp_slots ();
5910
5911           /* Restore the original value so that it's correct the next
5912              time we expand this function.  */
5913           TREE_VALUE (tail) = o[i];
5914         }
5915       /* Detect modification of read-only values.
5916          (Otherwise done by build_modify_expr.)  */
5917       else
5918         {
5919           tree type = TREE_TYPE (o[i]);
5920           if (type != error_mark_node
5921               && (CP_TYPE_CONST_P (type)
5922                   || (CLASS_TYPE_P (type) && C_TYPE_FIELDS_READONLY (type))))
5923             readonly_error (o[i], "modification by `asm'", 1);
5924         }
5925     }
5926
5927   /* Those MODIFY_EXPRs could do autoincrements.  */
5928   emit_queue ();
5929 }
5930 \f
5931 /* If RETVAL is the address of, or a reference to, a local variable or
5932    temporary give an appropriate warning.  */
5933
5934 static void
5935 maybe_warn_about_returning_address_of_local (tree retval)
5936 {
5937   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
5938   tree whats_returned = retval;
5939
5940   for (;;)
5941     {
5942       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
5943         whats_returned = TREE_OPERAND (whats_returned, 1);
5944       else if (TREE_CODE (whats_returned) == CONVERT_EXPR
5945                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
5946                || TREE_CODE (whats_returned) == NOP_EXPR)
5947         whats_returned = TREE_OPERAND (whats_returned, 0);
5948       else
5949         break;
5950     }
5951
5952   if (TREE_CODE (whats_returned) != ADDR_EXPR)
5953     return;
5954   whats_returned = TREE_OPERAND (whats_returned, 0);
5955
5956   if (TREE_CODE (valtype) == REFERENCE_TYPE)
5957     {
5958       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
5959           || TREE_CODE (whats_returned) == TARGET_EXPR)
5960         {
5961           warning ("returning reference to temporary");
5962           return;
5963         }
5964       if (TREE_CODE (whats_returned) == VAR_DECL
5965           && DECL_NAME (whats_returned)
5966           && TEMP_NAME_P (DECL_NAME (whats_returned)))
5967         {
5968           warning ("reference to non-lvalue returned");
5969           return;
5970         }
5971     }
5972
5973   if (TREE_CODE (whats_returned) == VAR_DECL
5974       && DECL_NAME (whats_returned)
5975       && DECL_FUNCTION_SCOPE_P (whats_returned)
5976       && !(TREE_STATIC (whats_returned)
5977            || TREE_PUBLIC (whats_returned)))
5978     {
5979       if (TREE_CODE (valtype) == REFERENCE_TYPE)
5980         cp_warning_at ("reference to local variable `%D' returned",
5981                        whats_returned);
5982       else
5983         cp_warning_at ("address of local variable `%D' returned",
5984                        whats_returned);
5985       return;
5986     }
5987 }
5988
5989 /* Check that returning RETVAL from the current function is valid.
5990    Return an expression explicitly showing all conversions required to
5991    change RETVAL into the function return type, and to assign it to
5992    the DECL_RESULT for the function.  */
5993
5994 tree
5995 check_return_expr (tree retval)
5996 {
5997   tree result;
5998   /* The type actually returned by the function, after any
5999      promotions.  */
6000   tree valtype;
6001   int fn_returns_value_p;
6002
6003   /* A `volatile' function is one that isn't supposed to return, ever.
6004      (This is a G++ extension, used to get better code for functions
6005      that call the `volatile' function.)  */
6006   if (TREE_THIS_VOLATILE (current_function_decl))
6007     warning ("function declared `noreturn' has a `return' statement");
6008
6009   /* Check for various simple errors.  */
6010   if (DECL_DESTRUCTOR_P (current_function_decl))
6011     {
6012       if (retval)
6013         error ("returning a value from a destructor");
6014       return NULL_TREE;
6015     }
6016   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6017     {
6018       if (in_function_try_handler)
6019         /* If a return statement appears in a handler of the
6020            function-try-block of a constructor, the program is ill-formed.  */
6021         error ("cannot return from a handler of a function-try-block of a constructor");
6022       else if (retval)
6023         /* You can't return a value from a constructor.  */
6024         error ("returning a value from a constructor");
6025       return NULL_TREE;
6026     }
6027
6028   if (processing_template_decl)
6029     {
6030       current_function_returns_value = 1;
6031       return retval;
6032     }
6033
6034   /* When no explicit return-value is given in a function with a named
6035      return value, the named return value is used.  */
6036   result = DECL_RESULT (current_function_decl);
6037   valtype = TREE_TYPE (result);
6038   my_friendly_assert (valtype != NULL_TREE, 19990924);
6039   fn_returns_value_p = !VOID_TYPE_P (valtype);
6040   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6041     retval = result;
6042
6043   /* Check for a return statement with no return value in a function
6044      that's supposed to return a value.  */
6045   if (!retval && fn_returns_value_p)
6046     {
6047       pedwarn ("return-statement with no value, in function returning '%T'",
6048                valtype);
6049       /* Clear this, so finish_function won't say that we reach the
6050          end of a non-void function (which we don't, we gave a
6051          return!).  */
6052       current_function_returns_null = 0;
6053     }
6054   /* Check for a return statement with a value in a function that
6055      isn't supposed to return a value.  */
6056   else if (retval && !fn_returns_value_p)
6057     {
6058       if (VOID_TYPE_P (TREE_TYPE (retval)))
6059         /* You can return a `void' value from a function of `void'
6060            type.  In that case, we have to evaluate the expression for
6061            its side-effects.  */
6062           finish_expr_stmt (retval);
6063       else
6064         pedwarn ("return-statement with a value, in function "
6065                  "returning 'void'");
6066
6067       current_function_returns_null = 1;
6068
6069       /* There's really no value to return, after all.  */
6070       return NULL_TREE;
6071     }
6072   else if (!retval)
6073     /* Remember that this function can sometimes return without a
6074        value.  */
6075     current_function_returns_null = 1;
6076   else
6077     /* Remember that this function did return a value.  */
6078     current_function_returns_value = 1;
6079
6080   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6081   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6082        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6083       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6084       && ! flag_check_new
6085       && null_ptr_cst_p (retval))
6086     warning ("`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)");
6087
6088   /* Effective C++ rule 15.  See also start_function.  */
6089   if (warn_ecpp
6090       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)
6091       && retval != current_class_ref)
6092     warning ("`operator=' should return a reference to `*this'");
6093
6094   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6095
6096      [...]      For  a function with a class return type, if the expression
6097      in the return statement is the name of a local  object,  and  the  cv-
6098      unqualified  type  of  the  local  object  is the same as the function
6099      return type, an implementation is permitted to omit creating the  tem-
6100      porary  object  to  hold  the function return value [...]
6101
6102      So, if this is a value-returning function that always returns the same
6103      local variable, remember it.
6104
6105      It might be nice to be more flexible, and choose the first suitable
6106      variable even if the function sometimes returns something else, but
6107      then we run the risk of clobbering the variable we chose if the other
6108      returned expression uses the chosen variable somehow.  And people expect
6109      this restriction, anyway.  (jason 2000-11-19)
6110
6111      See finish_function, cxx_expand_function_start, and
6112      cp_copy_res_decl_for_inlining for other pieces of this
6113      optimization.  */
6114
6115   if (fn_returns_value_p && flag_elide_constructors)
6116     {
6117       if (retval != NULL_TREE
6118           && (current_function_return_value == NULL_TREE
6119               || current_function_return_value == retval)
6120           && TREE_CODE (retval) == VAR_DECL
6121           && DECL_CONTEXT (retval) == current_function_decl
6122           && ! TREE_STATIC (retval)
6123           && (DECL_ALIGN (retval)
6124               >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6125           && same_type_p ((TYPE_MAIN_VARIANT
6126                            (TREE_TYPE (retval))),
6127                           (TYPE_MAIN_VARIANT
6128                            (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6129         current_function_return_value = retval;
6130       else
6131         current_function_return_value = error_mark_node;
6132     }
6133
6134   /* We don't need to do any conversions when there's nothing being
6135      returned.  */
6136   if (!retval || retval == error_mark_node)
6137     return retval;
6138
6139   /* Do any required conversions.  */
6140   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6141     /* No conversions are required.  */
6142     ;
6143   else
6144     {
6145       /* The type the function is declared to return.  */
6146       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6147
6148       /* First convert the value to the function's return type, then
6149          to the type of return value's location to handle the
6150          case that functype is smaller than the valtype.  */
6151       retval = convert_for_initialization
6152         (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6153          "return", NULL_TREE, 0);
6154       retval = convert (valtype, retval);
6155
6156       /* If the conversion failed, treat this just like `return;'.  */
6157       if (retval == error_mark_node)
6158         return retval;
6159       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6160       else if (! current_function_returns_struct
6161                && TREE_CODE (retval) == TARGET_EXPR
6162                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6163         retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6164                         TREE_OPERAND (retval, 0));
6165       else
6166         maybe_warn_about_returning_address_of_local (retval);
6167     }
6168
6169   /* Actually copy the value returned into the appropriate location.  */
6170   if (retval && retval != result)
6171     retval = build (INIT_EXPR, TREE_TYPE (result), result, retval);
6172
6173   return retval;
6174 }
6175
6176 \f
6177 /* Returns nonzero if the pointer-type FROM can be converted to the
6178    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6179    then we return nonzero if the pointers are similar, and the
6180    cv-qualification signature of FROM is a proper subset of that of TO.
6181
6182    If CONSTP is positive, then all outer pointers have been
6183    const-qualified.  */
6184
6185 static int
6186 comp_ptr_ttypes_real (tree to, tree from, int constp)
6187 {
6188   bool to_more_cv_qualified = false;
6189
6190   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6191     {
6192       if (TREE_CODE (to) != TREE_CODE (from))
6193         return 0;
6194
6195       if (TREE_CODE (from) == OFFSET_TYPE
6196           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6197                            TYPE_OFFSET_BASETYPE (to)))
6198         return 0;
6199
6200       /* Const and volatile mean something different for function types,
6201          so the usual checks are not appropriate.  */
6202       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6203         {
6204           if (!at_least_as_qualified_p (to, from))
6205             return 0;
6206
6207           if (!at_least_as_qualified_p (from, to))
6208             {
6209               if (constp == 0)
6210                 return 0;
6211               to_more_cv_qualified = true;
6212             }
6213
6214           if (constp > 0)
6215             constp &= TYPE_READONLY (to);
6216         }
6217
6218       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6219         return ((constp >= 0 || to_more_cv_qualified)
6220                 && same_type_ignoring_top_level_qualifiers_p (to, from));
6221     }
6222 }
6223
6224 /* When comparing, say, char ** to char const **, this function takes
6225    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
6226    types to this function.  */
6227
6228 int
6229 comp_ptr_ttypes (tree to, tree from)
6230 {
6231   return comp_ptr_ttypes_real (to, from, 1);
6232 }
6233
6234 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6235    type or inheritance-related types, regardless of cv-quals.  */
6236
6237 int
6238 ptr_reasonably_similar (tree to, tree from)
6239 {
6240   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6241     {
6242       /* Any target type is similar enough to void.  */
6243       if (TREE_CODE (to) == VOID_TYPE
6244           || TREE_CODE (from) == VOID_TYPE)
6245         return 1;
6246
6247       if (TREE_CODE (to) != TREE_CODE (from))
6248         return 0;
6249
6250       if (TREE_CODE (from) == OFFSET_TYPE
6251           && comptypes (TYPE_OFFSET_BASETYPE (to),
6252                         TYPE_OFFSET_BASETYPE (from),
6253                         COMPARE_BASE | COMPARE_DERIVED))
6254         continue;
6255
6256       if (TREE_CODE (to) == INTEGER_TYPE
6257           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6258         return 1;
6259
6260       if (TREE_CODE (to) == FUNCTION_TYPE)
6261         return 1;
6262
6263       if (TREE_CODE (to) != POINTER_TYPE)
6264         return comptypes
6265           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6266            COMPARE_BASE | COMPARE_DERIVED);
6267     }
6268 }
6269
6270 /* Like comp_ptr_ttypes, for const_cast.  */
6271
6272 static int
6273 comp_ptr_ttypes_const (tree to, tree from)
6274 {
6275   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6276     {
6277       if (TREE_CODE (to) != TREE_CODE (from))
6278         return 0;
6279
6280       if (TREE_CODE (from) == OFFSET_TYPE
6281           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6282                           TYPE_OFFSET_BASETYPE (to)))
6283           continue;
6284
6285       if (TREE_CODE (to) != POINTER_TYPE)
6286         return same_type_ignoring_top_level_qualifiers_p (to, from);
6287     }
6288 }
6289
6290 /* Returns the type qualifiers for this type, including the qualifiers on the
6291    elements for an array type.  */
6292
6293 int
6294 cp_type_quals (tree type)
6295 {
6296   type = strip_array_types (type);
6297   if (type == error_mark_node)
6298     return TYPE_UNQUALIFIED;
6299   return TYPE_QUALS (type);
6300 }
6301
6302 /* Returns nonzero if the TYPE contains a mutable member.  */
6303
6304 bool
6305 cp_has_mutable_p (tree type)
6306 {
6307   type = strip_array_types (type);
6308
6309   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6310 }
6311
6312 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
6313    exemplar types such that casting T1 to T2 is casting away castness
6314    if and only if there is no implicit conversion from T1 to T2.  */
6315
6316 static void
6317 casts_away_constness_r (tree *t1, tree *t2)
6318 {
6319   int quals1;
6320   int quals2;
6321
6322   /* [expr.const.cast]
6323
6324      For multi-level pointer to members and multi-level mixed pointers
6325      and pointers to members (conv.qual), the "member" aspect of a
6326      pointer to member level is ignored when determining if a const
6327      cv-qualifier has been cast away.  */
6328   if (TYPE_PTRMEM_P (*t1))
6329     *t1 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t1));
6330   if (TYPE_PTRMEM_P (*t2))
6331     *t2 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t2));
6332
6333   /* [expr.const.cast]
6334
6335      For  two  pointer types:
6336
6337             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
6338             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
6339             K is min(N,M)
6340
6341      casting from X1 to X2 casts away constness if, for a non-pointer
6342      type T there does not exist an implicit conversion (clause
6343      _conv_) from:
6344
6345             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6346
6347      to
6348
6349             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
6350
6351   if (TREE_CODE (*t1) != POINTER_TYPE
6352       || TREE_CODE (*t2) != POINTER_TYPE)
6353     {
6354       *t1 = cp_build_qualified_type (void_type_node,
6355                                      cp_type_quals (*t1));
6356       *t2 = cp_build_qualified_type (void_type_node,
6357                                      cp_type_quals (*t2));
6358       return;
6359     }
6360
6361   quals1 = cp_type_quals (*t1);
6362   quals2 = cp_type_quals (*t2);
6363   *t1 = TREE_TYPE (*t1);
6364   *t2 = TREE_TYPE (*t2);
6365   casts_away_constness_r (t1, t2);
6366   *t1 = build_pointer_type (*t1);
6367   *t2 = build_pointer_type (*t2);
6368   *t1 = cp_build_qualified_type (*t1, quals1);
6369   *t2 = cp_build_qualified_type (*t2, quals2);
6370 }
6371
6372 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6373    constness.  */
6374
6375 static bool
6376 casts_away_constness (tree t1, tree t2)
6377 {
6378   if (TREE_CODE (t2) == REFERENCE_TYPE)
6379     {
6380       /* [expr.const.cast]
6381
6382          Casting from an lvalue of type T1 to an lvalue of type T2
6383          using a reference cast casts away constness if a cast from an
6384          rvalue of type "pointer to T1" to the type "pointer to T2"
6385          casts away constness.  */
6386       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6387       return casts_away_constness (build_pointer_type (t1),
6388                                    build_pointer_type (TREE_TYPE (t2)));
6389     }
6390
6391   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6392     /* [expr.const.cast]
6393
6394        Casting from an rvalue of type "pointer to data member of X
6395        of type T1" to the type "pointer to data member of Y of type
6396        T2" casts away constness if a cast from an rvalue of type
6397        "pointer to T1" to the type "pointer to T2" casts away
6398        constness.  */
6399     return casts_away_constness
6400       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6401        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6402
6403   /* Casting away constness is only something that makes sense for
6404      pointer or reference types.  */
6405   if (TREE_CODE (t1) != POINTER_TYPE
6406       || TREE_CODE (t2) != POINTER_TYPE)
6407     return false;
6408
6409   /* Top-level qualifiers don't matter.  */
6410   t1 = TYPE_MAIN_VARIANT (t1);
6411   t2 = TYPE_MAIN_VARIANT (t2);
6412   casts_away_constness_r (&t1, &t2);
6413   if (!can_convert (t2, t1))
6414     return true;
6415
6416   return false;
6417 }
6418
6419 /* If T is a REFERENCE_TYPE return the type to which T refers.
6420    Otherwise, return T itself.  */
6421
6422 tree
6423 non_reference (tree t)
6424 {
6425   if (TREE_CODE (t) == REFERENCE_TYPE)
6426     t = TREE_TYPE (t);
6427   return t;
6428 }