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