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