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