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