gcc/cp/typeck.c

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