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