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