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