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