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