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.  */
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 (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type)))
2121     {
2122       error ("the type being destroyed is %qT, but the destructor refers to %qT",
2123              TYPE_MAIN_VARIANT (object_type), dtor_type);
2124       return error_mark_node;
2125     }
2126   expr = lookup_member (dtor_type, complete_dtor_identifier,
2127                         /*protect=*/1, /*want_type=*/false);
2128   expr = (adjust_result_of_qualified_name_lookup
2129           (expr, dtor_type, object_type));
2130   return expr;
2131 }
2132
2133 /* An expression of the form "A::template B" has been resolved to
2134    DECL.  Issue a diagnostic if B is not a template or template
2135    specialization.  */
2136
2137 void
2138 check_template_keyword (tree decl)
2139 {
2140   /* The standard says:
2141
2142       [temp.names]
2143
2144       If a name prefixed by the keyword template is not a member
2145       template, the program is ill-formed.
2146
2147      DR 228 removed the restriction that the template be a member
2148      template.
2149
2150      DR 96, if accepted would add the further restriction that explicit
2151      template arguments must be provided if the template keyword is
2152      used, but, as of 2005-10-16, that DR is still in "drafting".  If
2153      this DR is accepted, then the semantic checks here can be
2154      simplified, as the entity named must in fact be a template
2155      specialization, rather than, as at present, a set of overloaded
2156      functions containing at least one template function.  */
2157   if (TREE_CODE (decl) != TEMPLATE_DECL
2158       && TREE_CODE (decl) != TEMPLATE_ID_EXPR)
2159     {
2160       if (!is_overloaded_fn (decl))
2161         permerror (input_location, "%qD is not a template", decl);
2162       else
2163         {
2164           tree fns;
2165           fns = decl;
2166           if (BASELINK_P (fns))
2167             fns = BASELINK_FUNCTIONS (fns);
2168           while (fns)
2169             {
2170               tree fn = OVL_CURRENT (fns);
2171               if (TREE_CODE (fn) == TEMPLATE_DECL
2172                   || TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2173                 break;
2174               if (TREE_CODE (fn) == FUNCTION_DECL
2175                   && DECL_USE_TEMPLATE (fn)
2176                   && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
2177                 break;
2178               fns = OVL_NEXT (fns);
2179             }
2180           if (!fns)
2181             permerror (input_location, "%qD is not a template", decl);
2182         }
2183     }
2184 }
2185
2186 /* This function is called by the parser to process a class member
2187    access expression of the form OBJECT.NAME.  NAME is a node used by
2188    the parser to represent a name; it is not yet a DECL.  It may,
2189    however, be a BASELINK where the BASELINK_FUNCTIONS is a
2190    TEMPLATE_ID_EXPR.  Templates must be looked up by the parser, and
2191    there is no reason to do the lookup twice, so the parser keeps the
2192    BASELINK.  TEMPLATE_P is true iff NAME was explicitly declared to
2193    be a template via the use of the "A::template B" syntax.  */
2194
2195 tree
2196 finish_class_member_access_expr (tree object, tree name, bool template_p,
2197                                  tsubst_flags_t complain)
2198 {
2199   tree expr;
2200   tree object_type;
2201   tree member;
2202   tree access_path = NULL_TREE;
2203   tree orig_object = object;
2204   tree orig_name = name;
2205
2206   if (object == error_mark_node || name == error_mark_node)
2207     return error_mark_node;
2208
2209   /* If OBJECT is an ObjC class instance, we must obey ObjC access rules.  */
2210   if (!objc_is_public (object, name))
2211     return error_mark_node;
2212
2213   object_type = TREE_TYPE (object);
2214
2215   if (processing_template_decl)
2216     {
2217       if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME.  */
2218           dependent_type_p (object_type)
2219           /* If NAME is just an IDENTIFIER_NODE, then the expression
2220              is dependent.  */
2221           || TREE_CODE (object) == IDENTIFIER_NODE
2222           /* If NAME is "f<args>", where either 'f' or 'args' is
2223              dependent, then the expression is dependent.  */
2224           || (TREE_CODE (name) == TEMPLATE_ID_EXPR
2225               && dependent_template_id_p (TREE_OPERAND (name, 0),
2226                                           TREE_OPERAND (name, 1)))
2227           /* If NAME is "T::X" where "T" is dependent, then the
2228              expression is dependent.  */
2229           || (TREE_CODE (name) == SCOPE_REF
2230               && TYPE_P (TREE_OPERAND (name, 0))
2231               && dependent_type_p (TREE_OPERAND (name, 0))))
2232         return build_min_nt (COMPONENT_REF, object, name, NULL_TREE);
2233       object = build_non_dependent_expr (object);
2234     }
2235
2236   /* [expr.ref]
2237
2238      The type of the first expression shall be "class object" (of a
2239      complete type).  */
2240   if (!currently_open_class (object_type)
2241       && !complete_type_or_else (object_type, object))
2242     return error_mark_node;
2243   if (!CLASS_TYPE_P (object_type))
2244     {
2245       if (complain & tf_error)
2246         error ("request for member %qD in %qE, which is of non-class type %qT",
2247                name, object, object_type);
2248       return error_mark_node;
2249     }
2250
2251   if (BASELINK_P (name))
2252     /* A member function that has already been looked up.  */
2253     member = name;
2254   else
2255     {
2256       bool is_template_id = false;
2257       tree template_args = NULL_TREE;
2258       tree scope;
2259
2260       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2261         {
2262           is_template_id = true;
2263           template_args = TREE_OPERAND (name, 1);
2264           name = TREE_OPERAND (name, 0);
2265
2266           if (TREE_CODE (name) == OVERLOAD)
2267             name = DECL_NAME (get_first_fn (name));
2268           else if (DECL_P (name))
2269             name = DECL_NAME (name);
2270         }
2271
2272       if (TREE_CODE (name) == SCOPE_REF)
2273         {
2274           /* A qualified name.  The qualifying class or namespace `S'
2275              has already been looked up; it is either a TYPE or a
2276              NAMESPACE_DECL.  */
2277           scope = TREE_OPERAND (name, 0);
2278           name = TREE_OPERAND (name, 1);
2279
2280           /* If SCOPE is a namespace, then the qualified name does not
2281              name a member of OBJECT_TYPE.  */
2282           if (TREE_CODE (scope) == NAMESPACE_DECL)
2283             {
2284               if (complain & tf_error)
2285                 error ("%<%D::%D%> is not a member of %qT",
2286                        scope, name, object_type);
2287               return error_mark_node;
2288             }
2289
2290           gcc_assert (CLASS_TYPE_P (scope));
2291           gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
2292                       || TREE_CODE (name) == BIT_NOT_EXPR);
2293
2294           /* Find the base of OBJECT_TYPE corresponding to SCOPE.  */
2295           access_path = lookup_base (object_type, scope, ba_check, NULL);
2296           if (access_path == error_mark_node)
2297             return error_mark_node;
2298           if (!access_path)
2299             {
2300               if (complain & tf_error)
2301                 error ("%qT is not a base of %qT", scope, object_type);
2302               return error_mark_node;
2303             }
2304         }
2305       else
2306         {
2307           scope = NULL_TREE;
2308           access_path = object_type;
2309         }
2310
2311       if (TREE_CODE (name) == BIT_NOT_EXPR)
2312         member = lookup_destructor (object, scope, name);
2313       else
2314         {
2315           /* Look up the member.  */
2316           member = lookup_member (access_path, name, /*protect=*/1,
2317                                   /*want_type=*/false);
2318           if (member == NULL_TREE)
2319             {
2320               if (complain & tf_error)
2321                 error ("%qD has no member named %qE", object_type, name);
2322               return error_mark_node;
2323             }
2324           if (member == error_mark_node)
2325             return error_mark_node;
2326         }
2327
2328       if (is_template_id)
2329         {
2330           tree templ = member;
2331
2332           if (BASELINK_P (templ))
2333             templ = lookup_template_function (templ, template_args);
2334           else
2335             {
2336               if (complain & tf_error)
2337                 error ("%qD is not a member template function", name);
2338               return error_mark_node;
2339             }
2340         }
2341     }
2342
2343   if (TREE_DEPRECATED (member))
2344     warn_deprecated_use (member);
2345
2346   if (template_p)
2347     check_template_keyword (member);
2348
2349   expr = build_class_member_access_expr (object, member, access_path,
2350                                          /*preserve_reference=*/false,
2351                                          complain);
2352   if (processing_template_decl && expr != error_mark_node)
2353     {
2354       if (BASELINK_P (member))
2355         {
2356           if (TREE_CODE (orig_name) == SCOPE_REF)
2357             BASELINK_QUALIFIED_P (member) = 1;
2358           orig_name = member;
2359         }
2360       return build_min_non_dep (COMPONENT_REF, expr,
2361                                 orig_object, orig_name,
2362                                 NULL_TREE);
2363     }
2364
2365   return expr;
2366 }
2367
2368 /* Return an expression for the MEMBER_NAME field in the internal
2369    representation of PTRMEM, a pointer-to-member function.  (Each
2370    pointer-to-member function type gets its own RECORD_TYPE so it is
2371    more convenient to access the fields by name than by FIELD_DECL.)
2372    This routine converts the NAME to a FIELD_DECL and then creates the
2373    node for the complete expression.  */
2374
2375 tree
2376 build_ptrmemfunc_access_expr (tree ptrmem, tree member_name)
2377 {
2378   tree ptrmem_type;
2379   tree member;
2380   tree member_type;
2381
2382   /* This code is a stripped down version of
2383      build_class_member_access_expr.  It does not work to use that
2384      routine directly because it expects the object to be of class
2385      type.  */
2386   ptrmem_type = TREE_TYPE (ptrmem);
2387   gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type));
2388   member = lookup_member (ptrmem_type, member_name, /*protect=*/0,
2389                           /*want_type=*/false);
2390   member_type = cp_build_qualified_type (TREE_TYPE (member),
2391                                          cp_type_quals (ptrmem_type));
2392   return fold_build3 (COMPONENT_REF, member_type,
2393                       ptrmem, member, NULL_TREE);
2394 }
2395
2396 /* Given an expression PTR for a pointer, return an expression
2397    for the value pointed to.
2398    ERRORSTRING is the name of the operator to appear in error messages.
2399
2400    This function may need to overload OPERATOR_FNNAME.
2401    Must also handle REFERENCE_TYPEs for C++.  */
2402
2403 tree
2404 build_x_indirect_ref (tree expr, const char *errorstring,
2405                       tsubst_flags_t complain)
2406 {
2407   tree orig_expr = expr;
2408   tree rval;
2409
2410   if (processing_template_decl)
2411     {
2412       if (type_dependent_expression_p (expr))
2413         return build_min_nt (INDIRECT_REF, expr);
2414       expr = build_non_dependent_expr (expr);
2415     }
2416
2417   rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE,
2418                        NULL_TREE, /*overloaded_p=*/NULL, complain);
2419   if (!rval)
2420     rval = cp_build_indirect_ref (expr, errorstring, complain);
2421
2422   if (processing_template_decl && rval != error_mark_node)
2423     return build_min_non_dep (INDIRECT_REF, rval, orig_expr);
2424   else
2425     return rval;
2426 }
2427
2428 /* Helper function called from c-common.  */
2429 tree
2430 build_indirect_ref (location_t loc __attribute__ ((__unused__)),
2431                     tree ptr, const char *errorstring)
2432 {
2433   return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
2434 }
2435
2436 tree
2437 cp_build_indirect_ref (tree ptr, const char *errorstring,
2438                        tsubst_flags_t complain)
2439 {
2440   tree pointer, type;
2441
2442   if (ptr == error_mark_node)
2443     return error_mark_node;
2444
2445   if (ptr == current_class_ptr)
2446     return current_class_ref;
2447
2448   pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE
2449              ? ptr : decay_conversion (ptr));
2450   type = TREE_TYPE (pointer);
2451
2452   if (POINTER_TYPE_P (type))
2453     {
2454       /* [expr.unary.op]
2455
2456          If the type of the expression is "pointer to T," the type
2457          of  the  result  is  "T."
2458
2459          We must use the canonical variant because certain parts of
2460          the back end, like fold, do pointer comparisons between
2461          types.  */
2462       tree t = canonical_type_variant (TREE_TYPE (type));
2463
2464       if (CONVERT_EXPR_P (ptr)
2465           || TREE_CODE (ptr) == VIEW_CONVERT_EXPR)
2466         {
2467           /* If a warning is issued, mark it to avoid duplicates from
2468              the backend.  This only needs to be done at
2469              warn_strict_aliasing > 2.  */
2470           if (warn_strict_aliasing > 2)
2471             if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (ptr, 0)),
2472                                          type, TREE_OPERAND (ptr, 0)))
2473               TREE_NO_WARNING (ptr) = 1;
2474         }
2475
2476       if (VOID_TYPE_P (t))
2477         {
2478           /* A pointer to incomplete type (other than cv void) can be
2479              dereferenced [expr.unary.op]/1  */
2480           if (complain & tf_error)
2481             error ("%qT is not a pointer-to-object type", type);
2482           return error_mark_node;
2483         }
2484       else if (TREE_CODE (pointer) == ADDR_EXPR
2485                && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0))))
2486         /* The POINTER was something like `&x'.  We simplify `*&x' to
2487            `x'.  */
2488         return TREE_OPERAND (pointer, 0);
2489       else
2490         {
2491           tree ref = build1 (INDIRECT_REF, t, pointer);
2492
2493           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2494              so that we get the proper error message if the result is used
2495              to assign to.  Also, &* is supposed to be a no-op.  */
2496           TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
2497           TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
2498           TREE_SIDE_EFFECTS (ref)
2499             = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer));
2500           return ref;
2501         }
2502     }
2503   else if (!(complain & tf_error))
2504     /* Don't emit any errors; we'll just return ERROR_MARK_NODE later.  */
2505     ;
2506   /* `pointer' won't be an error_mark_node if we were given a
2507      pointer to member, so it's cool to check for this here.  */
2508   else if (TYPE_PTR_TO_MEMBER_P (type))
2509     error ("invalid use of %qs on pointer to member", errorstring);
2510   else if (pointer != error_mark_node)
2511     {
2512       if (errorstring)
2513         error ("invalid type argument of %qs", errorstring);
2514       else
2515         error ("invalid type argument");
2516     }
2517   return error_mark_node;
2518 }
2519
2520 /* This handles expressions of the form "a[i]", which denotes
2521    an array reference.
2522
2523    This is logically equivalent in C to *(a+i), but we may do it differently.
2524    If A is a variable or a member, we generate a primitive ARRAY_REF.
2525    This avoids forcing the array out of registers, and can work on
2526    arrays that are not lvalues (for example, members of structures returned
2527    by functions).
2528
2529    If INDEX is of some user-defined type, it must be converted to
2530    integer type.  Otherwise, to make a compatible PLUS_EXPR, it
2531    will inherit the type of the array, which will be some pointer type.
2532
2533    LOC is the location to use in building the array reference.  */
2534
2535 tree
2536 build_array_ref (tree array, tree idx, location_t loc)
2537 {
2538   tree ret;
2539
2540   if (idx == 0)
2541     {
2542       error_at (loc, "subscript missing in array reference");
2543       return error_mark_node;
2544     }
2545
2546   if (TREE_TYPE (array) == error_mark_node
2547       || TREE_TYPE (idx) == error_mark_node)
2548     return error_mark_node;
2549
2550   /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference
2551      inside it.  */
2552   switch (TREE_CODE (array))
2553     {
2554     case COMPOUND_EXPR:
2555       {
2556         tree value = build_array_ref (TREE_OPERAND (array, 1), idx, loc);
2557         ret = build2 (COMPOUND_EXPR, TREE_TYPE (value),
2558                       TREE_OPERAND (array, 0), value);
2559         SET_EXPR_LOCATION (ret, loc);
2560         return ret;
2561       }
2562
2563     case COND_EXPR:
2564       ret = build_conditional_expr
2565               (TREE_OPERAND (array, 0),
2566               build_array_ref (TREE_OPERAND (array, 1), idx, loc),
2567               build_array_ref (TREE_OPERAND (array, 2), idx, loc),
2568               tf_warning_or_error);
2569       protected_set_expr_location (ret, loc);
2570       return ret;
2571
2572     default:
2573       break;
2574     }
2575
2576   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2577     {
2578       tree rval, type;
2579
2580       warn_array_subscript_with_type_char (idx);
2581
2582       if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2583         {
2584           error_at (loc, "array subscript is not an integer");
2585           return error_mark_node;
2586         }
2587
2588       /* Apply integral promotions *after* noticing character types.
2589          (It is unclear why we do these promotions -- the standard
2590          does not say that we should.  In fact, the natural thing would
2591          seem to be to convert IDX to ptrdiff_t; we're performing
2592          pointer arithmetic.)  */
2593       idx = perform_integral_promotions (idx);
2594
2595       /* An array that is indexed by a non-constant
2596          cannot be stored in a register; we must be able to do
2597          address arithmetic on its address.
2598          Likewise an array of elements of variable size.  */
2599       if (TREE_CODE (idx) != INTEGER_CST
2600           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2601               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2602                   != INTEGER_CST)))
2603         {
2604           if (!cxx_mark_addressable (array))
2605             return error_mark_node;
2606         }
2607
2608       /* An array that is indexed by a constant value which is not within
2609          the array bounds cannot be stored in a register either; because we
2610          would get a crash in store_bit_field/extract_bit_field when trying
2611          to access a non-existent part of the register.  */
2612       if (TREE_CODE (idx) == INTEGER_CST
2613           && TYPE_DOMAIN (TREE_TYPE (array))
2614           && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2615         {
2616           if (!cxx_mark_addressable (array))
2617             return error_mark_node;
2618         }
2619
2620       if (!lvalue_p (array))
2621         pedwarn (loc, OPT_pedantic,
2622                  "ISO C++ forbids subscripting non-lvalue array");
2623
2624       /* Note in C++ it is valid to subscript a `register' array, since
2625          it is valid to take the address of something with that
2626          storage specification.  */
2627       if (extra_warnings)
2628         {
2629           tree foo = array;
2630           while (TREE_CODE (foo) == COMPONENT_REF)
2631             foo = TREE_OPERAND (foo, 0);
2632           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2633             warning_at (loc, OPT_Wextra,
2634                         "subscripting array declared %<register%>");
2635         }
2636
2637       type = TREE_TYPE (TREE_TYPE (array));
2638       rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2639       /* Array ref is const/volatile if the array elements are
2640          or if the array is..  */
2641       TREE_READONLY (rval)
2642         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2643       TREE_SIDE_EFFECTS (rval)
2644         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2645       TREE_THIS_VOLATILE (rval)
2646         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2647       ret = require_complete_type (fold_if_not_in_template (rval));
2648       protected_set_expr_location (ret, loc);
2649       return ret;
2650     }
2651
2652   {
2653     tree ar = default_conversion (array);
2654     tree ind = default_conversion (idx);
2655
2656     /* Put the integer in IND to simplify error checking.  */
2657     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2658       {
2659         tree temp = ar;
2660         ar = ind;
2661         ind = temp;
2662       }
2663
2664     if (ar == error_mark_node)
2665       return ar;
2666
2667     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2668       {
2669         error_at (loc, "subscripted value is neither array nor pointer");
2670         return error_mark_node;
2671       }
2672     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2673       {
2674         error_at (loc, "array subscript is not an integer");
2675         return error_mark_node;
2676       }
2677
2678     warn_array_subscript_with_type_char (idx);
2679
2680     ret = cp_build_indirect_ref (cp_build_binary_op (input_location,
2681                                                      PLUS_EXPR, ar, ind,
2682                                                      tf_warning_or_error),
2683                                  "array indexing",
2684                                  tf_warning_or_error);
2685     protected_set_expr_location (ret, loc);
2686     return ret;
2687   }
2688 }
2689 \f
2690 /* Resolve a pointer to member function.  INSTANCE is the object
2691    instance to use, if the member points to a virtual member.
2692
2693    This used to avoid checking for virtual functions if basetype
2694    has no virtual functions, according to an earlier ANSI draft.
2695    With the final ISO C++ rules, such an optimization is
2696    incorrect: A pointer to a derived member can be static_cast
2697    to pointer-to-base-member, as long as the dynamic object
2698    later has the right member.  */
2699
2700 tree
2701 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2702 {
2703   if (TREE_CODE (function) == OFFSET_REF)
2704     function = TREE_OPERAND (function, 1);
2705
2706   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2707     {
2708       tree idx, delta, e1, e2, e3, vtbl, basetype;
2709       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2710
2711       tree instance_ptr = *instance_ptrptr;
2712       tree instance_save_expr = 0;
2713       if (instance_ptr == error_mark_node)
2714         {
2715           if (TREE_CODE (function) == PTRMEM_CST)
2716             {
2717               /* Extracting the function address from a pmf is only
2718                  allowed with -Wno-pmf-conversions. It only works for
2719                  pmf constants.  */
2720               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2721               e1 = convert (fntype, e1);
2722               return e1;
2723             }
2724           else
2725             {
2726               error ("object missing in use of %qE", function);
2727               return error_mark_node;
2728             }
2729         }
2730
2731       if (TREE_SIDE_EFFECTS (instance_ptr))
2732         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2733
2734       if (TREE_SIDE_EFFECTS (function))
2735         function = save_expr (function);
2736
2737       /* Start by extracting all the information from the PMF itself.  */
2738       e3 = pfn_from_ptrmemfunc (function);
2739       delta = delta_from_ptrmemfunc (function);
2740       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2741       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2742         {
2743         case ptrmemfunc_vbit_in_pfn:
2744           e1 = cp_build_binary_op (input_location,
2745                                    BIT_AND_EXPR, idx, integer_one_node,
2746                                    tf_warning_or_error);
2747           idx = cp_build_binary_op (input_location,
2748                                     MINUS_EXPR, idx, integer_one_node,
2749                                     tf_warning_or_error);
2750           break;
2751
2752         case ptrmemfunc_vbit_in_delta:
2753           e1 = cp_build_binary_op (input_location,
2754                                    BIT_AND_EXPR, delta, integer_one_node,
2755                                    tf_warning_or_error);
2756           delta = cp_build_binary_op (input_location,
2757                                       RSHIFT_EXPR, delta, integer_one_node,
2758                                       tf_warning_or_error);
2759           break;
2760
2761         default:
2762           gcc_unreachable ();
2763         }
2764
2765       /* Convert down to the right base before using the instance.  A
2766          special case is that in a pointer to member of class C, C may
2767          be incomplete.  In that case, the function will of course be
2768          a member of C, and no conversion is required.  In fact,
2769          lookup_base will fail in that case, because incomplete
2770          classes do not have BINFOs.  */
2771       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2772       if (!same_type_ignoring_top_level_qualifiers_p
2773           (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
2774         {
2775           basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2776                                   basetype, ba_check, NULL);
2777           instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
2778                                           1);
2779           if (instance_ptr == error_mark_node)
2780             return error_mark_node;
2781         }
2782       /* ...and then the delta in the PMF.  */
2783       instance_ptr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (instance_ptr),
2784                              instance_ptr, fold_convert (sizetype, delta));
2785
2786       /* Hand back the adjusted 'this' argument to our caller.  */
2787       *instance_ptrptr = instance_ptr;
2788
2789       /* Next extract the vtable pointer from the object.  */
2790       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2791                      instance_ptr);
2792       vtbl = cp_build_indirect_ref (vtbl, NULL, tf_warning_or_error);
2793       /* If the object is not dynamic the access invokes undefined
2794          behavior.  As it is not executed in this case silence the
2795          spurious warnings it may provoke.  */
2796       TREE_NO_WARNING (vtbl) = 1;
2797
2798       /* Finally, extract the function pointer from the vtable.  */
2799       e2 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl,
2800                         fold_convert (sizetype, idx));
2801       e2 = cp_build_indirect_ref (e2, NULL, tf_warning_or_error);
2802       TREE_CONSTANT (e2) = 1;
2803
2804       /* When using function descriptors, the address of the
2805          vtable entry is treated as a function pointer.  */
2806       if (TARGET_VTABLE_USES_DESCRIPTORS)
2807         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2808                      cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1,
2809                                      tf_warning_or_error));
2810
2811       e2 = fold_convert (TREE_TYPE (e3), e2);
2812       e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error);
2813
2814       /* Make sure this doesn't get evaluated first inside one of the
2815          branches of the COND_EXPR.  */
2816       if (instance_save_expr)
2817         e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
2818                      instance_save_expr, e1);
2819
2820       function = e1;
2821     }
2822   return function;
2823 }
2824
2825 /* Used by the C-common bits.  */
2826 tree
2827 build_function_call (tree function, tree params)
2828 {
2829   return cp_build_function_call (function, params, tf_warning_or_error);
2830 }
2831
2832 tree
2833 cp_build_function_call (tree function, tree params, tsubst_flags_t complain)
2834 {
2835   tree fntype, fndecl;
2836   tree name = NULL_TREE;
2837   int is_method;
2838   tree original = function;
2839   int nargs, parm_types_len;
2840   tree *argarray;
2841   tree parm_types;
2842
2843   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2844      expressions, like those used for ObjC messenger dispatches.  */
2845   function = objc_rewrite_function_call (function, params);
2846
2847   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2848      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2849   if (TREE_CODE (function) == NOP_EXPR
2850       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2851     function = TREE_OPERAND (function, 0);
2852
2853   if (TREE_CODE (function) == FUNCTION_DECL)
2854     {
2855       name = DECL_NAME (function);
2856
2857       mark_used (function);
2858       fndecl = function;
2859
2860       /* Convert anything with function type to a pointer-to-function.  */
2861       if (DECL_MAIN_P (function) && (complain & tf_error))
2862         pedwarn (input_location, OPT_pedantic,
2863                  "ISO C++ forbids calling %<::main%> from within program");
2864
2865       function = build_addr_func (function);
2866     }
2867   else
2868     {
2869       fndecl = NULL_TREE;
2870
2871       function = build_addr_func (function);
2872     }
2873
2874   if (function == error_mark_node)
2875     return error_mark_node;
2876
2877   fntype = TREE_TYPE (function);
2878
2879   if (TYPE_PTRMEMFUNC_P (fntype))
2880     {
2881       if (complain & tf_error)
2882         error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2883                "function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>",
2884                original, original);
2885       return error_mark_node;
2886     }
2887
2888   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2889                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2890
2891   if (!((TREE_CODE (fntype) == POINTER_TYPE
2892          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2893         || is_method
2894         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2895     {
2896       if (complain & tf_error)
2897         error ("%qE cannot be used as a function", original);
2898       return error_mark_node;
2899     }
2900
2901   /* fntype now gets the type of function pointed to.  */
2902   fntype = TREE_TYPE (fntype);
2903   parm_types = TYPE_ARG_TYPES (fntype);
2904
2905   /* Allocate storage for converted arguments.  */
2906   parm_types_len = list_length (parm_types);
2907   nargs = list_length (params);
2908   if (parm_types_len > nargs)
2909     nargs = parm_types_len;
2910   argarray = (tree *) alloca (nargs * sizeof (tree));
2911
2912   /* Convert the parameters to the types declared in the
2913      function prototype, or apply default promotions.  */
2914   nargs = convert_arguments (nargs, argarray, parm_types,
2915                              params, fndecl, LOOKUP_NORMAL,
2916                              complain);
2917   if (nargs < 0)
2918     return error_mark_node;
2919
2920   /* Check for errors in format strings and inappropriately
2921      null parameters.  */
2922   check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
2923                             parm_types);
2924
2925   return build_cxx_call (function, nargs, argarray);
2926 }
2927 \f
2928 /* Convert the actual parameter expressions in the list VALUES
2929    to the types in the list TYPELIST.
2930    If parmdecls is exhausted, or when an element has NULL as its type,
2931    perform the default conversions.
2932
2933    Store the converted arguments in ARGARRAY.  NARGS is the size of this array.
2934
2935    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2936
2937    This is also where warnings about wrong number of args are generated.
2938
2939    Returns the actual number of arguments processed (which might be less
2940    than NARGS), or -1 on error.
2941
2942    VALUES is a chain of TREE_LIST nodes with the elements of the list
2943    in the TREE_VALUE slots of those nodes.
2944
2945    In C++, unspecified trailing parameters can be filled in with their
2946    default arguments, if such were specified.  Do so here.  */
2947
2948 static int
2949 convert_arguments (int nargs, tree *argarray,
2950                    tree typelist, tree values, tree fndecl, int flags,
2951                    tsubst_flags_t complain)
2952 {
2953   tree typetail, valtail;
2954   const char *called_thing = 0;
2955   int i = 0;
2956
2957   /* Argument passing is always copy-initialization.  */
2958   flags |= LOOKUP_ONLYCONVERTING;
2959
2960   if (fndecl)
2961     {
2962       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2963         {
2964           if (DECL_NAME (fndecl) == NULL_TREE
2965               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2966             called_thing = "constructor";
2967           else
2968             called_thing = "member function";
2969         }
2970       else
2971         called_thing = "function";
2972     }
2973
2974   for (valtail = values, typetail = typelist;
2975        valtail;
2976        valtail = TREE_CHAIN (valtail), i++)
2977     {
2978       tree type = typetail ? TREE_VALUE (typetail) : 0;
2979       tree val = TREE_VALUE (valtail);
2980
2981       if (val == error_mark_node || type == error_mark_node)
2982         return -1;
2983
2984       if (type == void_type_node)
2985         {
2986           if (complain & tf_error)
2987             {
2988               if (fndecl)
2989                 {
2990                   error ("too many arguments to %s %q+#D",
2991                          called_thing, fndecl);
2992                   error ("at this point in file");
2993                 }
2994               else
2995                 error ("too many arguments to function");
2996               return i;
2997             }
2998           else
2999             return -1;
3000         }
3001
3002       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
3003          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
3004       if (TREE_CODE (val) == NOP_EXPR
3005           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
3006           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
3007         val = TREE_OPERAND (val, 0);
3008
3009       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
3010         {
3011           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
3012               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
3013               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
3014             val = decay_conversion (val);
3015         }
3016
3017       if (val == error_mark_node)
3018         return -1;
3019
3020       if (type != 0)
3021         {
3022           /* Formal parm type is specified by a function prototype.  */
3023           tree parmval;
3024
3025           if (!COMPLETE_TYPE_P (complete_type (type)))
3026             {
3027               if (complain & tf_error)
3028                 {
3029                   if (fndecl)
3030                     error ("parameter %P of %qD has incomplete type %qT",
3031                            i, fndecl, type);
3032                   else
3033                     error ("parameter %P has incomplete type %qT", i, type);
3034                 }
3035               parmval = error_mark_node;
3036             }
3037           else
3038             {
3039               parmval = convert_for_initialization
3040                 (NULL_TREE, type, val, flags,
3041                  "argument passing", fndecl, i, complain);
3042               parmval = convert_for_arg_passing (type, parmval);
3043             }
3044
3045           if (parmval == error_mark_node)
3046             return -1;
3047
3048           argarray[i] = parmval;
3049         }
3050       else
3051         {
3052           if (fndecl && DECL_BUILT_IN (fndecl)
3053               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
3054             /* Don't do ellipsis conversion for __built_in_constant_p
3055                as this will result in spurious warnings for non-POD
3056                types.  */
3057             val = require_complete_type (val);
3058           else
3059             val = convert_arg_to_ellipsis (val);
3060
3061           argarray[i] = val;
3062         }
3063
3064       if (typetail)
3065         typetail = TREE_CHAIN (typetail);
3066     }
3067
3068   if (typetail != 0 && typetail != void_list_node)
3069     {
3070       /* See if there are default arguments that can be used.  Because
3071          we hold default arguments in the FUNCTION_TYPE (which is so
3072          wrong), we can see default parameters here from deduced
3073          contexts (and via typeof) for indirect function calls.
3074          Fortunately we know whether we have a function decl to
3075          provide default arguments in a language conformant
3076          manner.  */
3077       if (fndecl && TREE_PURPOSE (typetail)
3078           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
3079         {
3080           for (; typetail != void_list_node; ++i)
3081             {
3082               tree parmval
3083                 = convert_default_arg (TREE_VALUE (typetail),
3084                                        TREE_PURPOSE (typetail),
3085                                        fndecl, i);
3086
3087               if (parmval == error_mark_node)
3088                 return -1;
3089
3090               argarray[i] = parmval;
3091               typetail = TREE_CHAIN (typetail);
3092               /* ends with `...'.  */
3093               if (typetail == NULL_TREE)
3094                 break;
3095             }
3096         }
3097       else
3098         {
3099           if (complain & tf_error)
3100             {
3101               if (fndecl)
3102                 {
3103                   error ("too few arguments to %s %q+#D",
3104                          called_thing, fndecl);
3105                   error ("at this point in file");
3106                 }
3107               else
3108                 error ("too few arguments to function");
3109             }
3110           return -1;
3111         }
3112     }
3113
3114   gcc_assert (i <= nargs);
3115   return i;
3116 }
3117 \f
3118 /* Build a binary-operation expression, after performing default
3119    conversions on the operands.  CODE is the kind of expression to
3120    build.  ARG1 and ARG2 are the arguments.  ARG1_CODE and ARG2_CODE
3121    are the tree codes which correspond to ARG1 and ARG2 when issuing
3122    warnings about possibly misplaced parentheses.  They may differ
3123    from the TREE_CODE of ARG1 and ARG2 if the parser has done constant
3124    folding (e.g., if the parser sees "a | 1 + 1", it may call this
3125    routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR).
3126    To avoid issuing any parentheses warnings, pass ARG1_CODE and/or
3127    ARG2_CODE as ERROR_MARK.  */
3128
3129 tree
3130 build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code,
3131                    tree arg2, enum tree_code arg2_code, bool *overloaded_p,
3132                    tsubst_flags_t complain)
3133 {
3134   tree orig_arg1;
3135   tree orig_arg2;
3136   tree expr;
3137
3138   orig_arg1 = arg1;
3139   orig_arg2 = arg2;
3140
3141   if (processing_template_decl)
3142     {
3143       if (type_dependent_expression_p (arg1)
3144           || type_dependent_expression_p (arg2))
3145         return build_min_nt (code, arg1, arg2);
3146       arg1 = build_non_dependent_expr (arg1);
3147       arg2 = build_non_dependent_expr (arg2);
3148     }
3149
3150   if (code == DOTSTAR_EXPR)
3151     expr = build_m_component_ref (arg1, arg2);
3152   else
3153     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
3154                          overloaded_p, complain);
3155
3156   /* Check for cases such as x+y<<z which users are likely to
3157      misinterpret.  But don't warn about obj << x + y, since that is a
3158      common idiom for I/O.  */
3159   if (warn_parentheses
3160       && !processing_template_decl
3161       && !error_operand_p (arg1)
3162       && !error_operand_p (arg2)
3163       && (code != LSHIFT_EXPR
3164           || !CLASS_TYPE_P (TREE_TYPE (arg1))))
3165     warn_about_parentheses (code, arg1_code, orig_arg1, arg2_code, orig_arg2);
3166
3167   if (processing_template_decl && expr != error_mark_node)
3168     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
3169
3170   return expr;
3171 }
3172
3173 /* For the c-common bits.  */
3174 tree
3175 build_binary_op (location_t location, enum tree_code code, tree op0, tree op1,
3176                  int convert_p ATTRIBUTE_UNUSED)
3177 {
3178   return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error);
3179 }
3180
3181
3182 /* Build a binary-operation expression without default conversions.
3183    CODE is the kind of expression to build.
3184    LOCATION is the location_t of the operator in the source code.
3185    This function differs from `build' in several ways:
3186    the data type of the result is computed and recorded in it,
3187    warnings are generated if arg data types are invalid,
3188    special handling for addition and subtraction of pointers is known,
3189    and some optimization is done (operations on narrow ints
3190    are done in the narrower type when that gives the same result).
3191    Constant folding is also done before the result is returned.
3192
3193    Note that the operands will never have enumeral types
3194    because either they have just had the default conversions performed
3195    or they have both just been converted to some other type in which
3196    the arithmetic is to be done.
3197
3198    C++: must do special pointer arithmetic when implementing
3199    multiple inheritance, and deal with pointer to member functions.  */
3200
3201 tree
3202 cp_build_binary_op (location_t location,
3203                     enum tree_code code, tree orig_op0, tree orig_op1,
3204                     tsubst_flags_t complain)
3205 {
3206   tree op0, op1;
3207   enum tree_code code0, code1;
3208   tree type0, type1;
3209   const char *invalid_op_diag;
3210
3211   /* Expression code to give to the expression when it is built.
3212      Normally this is CODE, which is what the caller asked for,
3213      but in some special cases we change it.  */
3214   enum tree_code resultcode = code;
3215
3216   /* Data type in which the computation is to be performed.
3217      In the simplest cases this is the common type of the arguments.  */
3218   tree result_type = NULL;
3219
3220   /* Nonzero means operands have already been type-converted
3221      in whatever way is necessary.
3222      Zero means they need to be converted to RESULT_TYPE.  */
3223   int converted = 0;
3224
3225   /* Nonzero means create the expression with this type, rather than
3226      RESULT_TYPE.  */
3227   tree build_type = 0;
3228
3229   /* Nonzero means after finally constructing the expression
3230      convert it to this type.  */
3231   tree final_type = 0;
3232
3233   tree result;
3234
3235   /* Nonzero if this is an operation like MIN or MAX which can
3236      safely be computed in short if both args are promoted shorts.
3237      Also implies COMMON.
3238      -1 indicates a bitwise operation; this makes a difference
3239      in the exact conditions for when it is safe to do the operation
3240      in a narrower mode.  */
3241   int shorten = 0;
3242
3243   /* Nonzero if this is a comparison operation;
3244      if both args are promoted shorts, compare the original shorts.
3245      Also implies COMMON.  */
3246   int short_compare = 0;
3247
3248   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
3249   int common = 0;
3250
3251   /* True if both operands have arithmetic type.  */
3252   bool arithmetic_types_p;
3253
3254   /* Apply default conversions.  */
3255   op0 = orig_op0;
3256   op1 = orig_op1;
3257
3258   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
3259       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
3260       || code == TRUTH_XOR_EXPR)
3261     {
3262       if (!really_overloaded_fn (op0))
3263         op0 = decay_conversion (op0);
3264       if (!really_overloaded_fn (op1))
3265         op1 = decay_conversion (op1);
3266     }
3267   else
3268     {
3269       if (!really_overloaded_fn (op0))
3270         op0 = default_conversion (op0);
3271       if (!really_overloaded_fn (op1))
3272         op1 = default_conversion (op1);
3273     }
3274
3275   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3276   STRIP_TYPE_NOPS (op0);
3277   STRIP_TYPE_NOPS (op1);
3278
3279   /* DTRT if one side is an overloaded function, but complain about it.  */
3280   if (type_unknown_p (op0))
3281     {
3282       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
3283       if (t != error_mark_node)
3284         {
3285           if (complain & tf_error)
3286             permerror (input_location, "assuming cast to type %qT from overloaded function",
3287                        TREE_TYPE (t));
3288           op0 = t;
3289         }
3290     }
3291   if (type_unknown_p (op1))
3292     {
3293       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
3294       if (t != error_mark_node)
3295         {
3296           if (complain & tf_error)
3297             permerror (input_location, "assuming cast to type %qT from overloaded function",
3298                        TREE_TYPE (t));
3299           op1 = t;
3300         }
3301     }
3302
3303   type0 = TREE_TYPE (op0);
3304   type1 = TREE_TYPE (op1);
3305
3306   /* The expression codes of the data types of the arguments tell us
3307      whether the arguments are integers, floating, pointers, etc.  */
3308   code0 = TREE_CODE (type0);
3309   code1 = TREE_CODE (type1);
3310
3311   /* If an error was already reported for one of the arguments,
3312      avoid reporting another error.  */
3313
3314   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
3315     return error_mark_node;
3316
3317   if ((invalid_op_diag
3318        = targetm.invalid_binary_op (code, type0, type1)))
3319     {
3320       error (invalid_op_diag);
3321       return error_mark_node;
3322     }
3323
3324   switch (code)
3325     {
3326     case MINUS_EXPR:
3327       /* Subtraction of two similar pointers.
3328          We must subtract them as integers, then divide by object size.  */
3329       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
3330           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
3331                                                         TREE_TYPE (type1)))
3332         return pointer_diff (op0, op1, common_pointer_type (type0, type1));
3333       /* In all other cases except pointer - int, the usual arithmetic
3334          rules apply.  */
3335       else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE))
3336         {
3337           common = 1;
3338           break;
3339         }
3340       /* The pointer - int case is just like pointer + int; fall
3341          through.  */
3342     case PLUS_EXPR:
3343       if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
3344           && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE))
3345         {
3346           tree ptr_operand;
3347           tree int_operand;
3348           ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1);
3349           int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1);
3350           if (processing_template_decl)
3351             {
3352               result_type = TREE_TYPE (ptr_operand);
3353               break;
3354             }
3355           return cp_pointer_int_sum (code,
3356                                      ptr_operand,
3357                                      int_operand);
3358         }
3359       common = 1;
3360       break;
3361
3362     case MULT_EXPR:
3363       common = 1;
3364       break;
3365
3366     case TRUNC_DIV_EXPR:
3367     case CEIL_DIV_EXPR:
3368     case FLOOR_DIV_EXPR:
3369     case ROUND_DIV_EXPR:
3370     case EXACT_DIV_EXPR:
3371       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3372            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
3373           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3374               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
3375         {
3376           enum tree_code tcode0 = code0, tcode1 = code1;
3377
3378           warn_for_div_by_zero (location, op1);
3379
3380           if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
3381             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
3382           if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE)
3383             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
3384
3385           if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
3386             resultcode = RDIV_EXPR;
3387           else
3388             /* When dividing two signed integers, we have to promote to int.
3389                unless we divide by a constant != -1.  Note that default
3390                conversion will have been performed on the operands at this
3391                point, so we have to dig out the original type to find out if
3392                it was unsigned.  */
3393             shorten = ((TREE_CODE (op0) == NOP_EXPR
3394                         && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3395                        || (TREE_CODE (op1) == INTEGER_CST
3396                            && ! integer_all_onesp (op1)));
3397
3398           common = 1;
3399         }
3400       break;
3401
3402     case BIT_AND_EXPR:
3403     case BIT_IOR_EXPR:
3404     case BIT_XOR_EXPR:
3405       if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3406           || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
3407               && !VECTOR_FLOAT_TYPE_P (type0)
3408               && !VECTOR_FLOAT_TYPE_P (type1)))
3409         shorten = -1;
3410       break;
3411
3412     case TRUNC_MOD_EXPR:
3413     case FLOOR_MOD_EXPR:
3414       warn_for_div_by_zero (location, op1);
3415
3416       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3417         {
3418           /* Although it would be tempting to shorten always here, that loses
3419              on some targets, since the modulo instruction is undefined if the
3420              quotient can't be represented in the computation mode.  We shorten
3421              only if unsigned or if dividing by something we know != -1.  */
3422           shorten = ((TREE_CODE (op0) == NOP_EXPR
3423                       && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3424                      || (TREE_CODE (op1) == INTEGER_CST
3425                          && ! integer_all_onesp (op1)));
3426           common = 1;
3427         }
3428       break;
3429
3430     case TRUTH_ANDIF_EXPR:
3431     case TRUTH_ORIF_EXPR:
3432     case TRUTH_AND_EXPR:
3433     case TRUTH_OR_EXPR:
3434       result_type = boolean_type_node;
3435       break;
3436
3437       /* Shift operations: result has same type as first operand;
3438          always convert second operand to int.
3439          Also set SHORT_SHIFT if shifting rightward.  */
3440
3441     case RSHIFT_EXPR:
3442       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3443         {
3444           result_type = type0;
3445           if (TREE_CODE (op1) == INTEGER_CST)
3446             {
3447               if (tree_int_cst_lt (op1, integer_zero_node))
3448                 {
3449                   if (complain & tf_warning)
3450                     warning (0, "right shift count is negative");
3451                 }
3452               else
3453                 {
3454                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0
3455                       && (complain & tf_warning))
3456                     warning (0, "right shift count >= width of type");
3457                 }
3458             }
3459           /* Convert the shift-count to an integer, regardless of
3460              size of value being shifted.  */
3461           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3462             op1 = cp_convert (integer_type_node, op1);
3463           /* Avoid converting op1 to result_type later.  */
3464           converted = 1;
3465         }
3466       break;
3467
3468     case LSHIFT_EXPR:
3469       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3470         {
3471           result_type = type0;
3472           if (TREE_CODE (op1) == INTEGER_CST)
3473             {
3474               if (tree_int_cst_lt (op1, integer_zero_node))
3475                 {
3476                   if (complain & tf_warning)
3477                     warning (0, "left shift count is negative");
3478                 }
3479               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3480                 {
3481                   if (complain & tf_warning)
3482                     warning (0, "left shift count >= width of type");
3483                 }
3484             }
3485           /* Convert the shift-count to an integer, regardless of
3486              size of value being shifted.  */
3487           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3488             op1 = cp_convert (integer_type_node, op1);
3489           /* Avoid converting op1 to result_type later.  */
3490           converted = 1;
3491         }
3492       break;
3493
3494     case RROTATE_EXPR:
3495     case LROTATE_EXPR:
3496       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3497         {
3498           result_type = type0;
3499           if (TREE_CODE (op1) == INTEGER_CST)
3500             {
3501               if (tree_int_cst_lt (op1, integer_zero_node))
3502                 {
3503                   if (complain & tf_warning)
3504                     warning (0, (code == LROTATE_EXPR)
3505                                   ? G_("left rotate count is negative")
3506                                   : G_("right rotate count is negative"));
3507                 }
3508               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3509                 {
3510                   if (complain & tf_warning)
3511                     warning (0, (code == LROTATE_EXPR)
3512                                   ? G_("left rotate count >= width of type")
3513                                   : G_("right rotate count >= width of type"));
3514                 }
3515             }
3516           /* Convert the shift-count to an integer, regardless of
3517              size of value being shifted.  */
3518           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3519             op1 = cp_convert (integer_type_node, op1);
3520         }
3521       break;
3522
3523     case EQ_EXPR:
3524     case NE_EXPR:
3525       if ((complain & tf_warning)
3526           && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)))
3527         warning (OPT_Wfloat_equal,
3528                  "comparing floating point with == or != is unsafe");
3529       if ((complain & tf_warning)
3530           && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3531               || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))))
3532         warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3533
3534       build_type = boolean_type_node;
3535       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3536            || code0 == COMPLEX_TYPE)
3537           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3538               || code1 == COMPLEX_TYPE))
3539         short_compare = 1;
3540       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3541                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3542         result_type = composite_pointer_type (type0, type1, op0, op1,
3543                                               "comparison", complain);
3544       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3545                && null_ptr_cst_p (op1))
3546         {
3547           if (TREE_CODE (op0) == ADDR_EXPR
3548               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
3549             {
3550               if (complain & tf_warning)
3551                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3552                          TREE_OPERAND (op0, 0));
3553             }
3554           result_type = type0;
3555         }
3556       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3557                && null_ptr_cst_p (op0))
3558         {
3559           if (TREE_CODE (op1) == ADDR_EXPR
3560               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
3561             {
3562               if (complain & tf_warning)
3563                 warning (OPT_Waddress, "the address of %qD will never be NULL",
3564                          TREE_OPERAND (op1, 0));
3565             }
3566           result_type = type1;
3567         }
3568       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3569         {
3570           result_type = type0;
3571           if (complain & tf_error)
3572             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3573           else
3574             return error_mark_node;
3575         }
3576       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3577         {
3578           result_type = type1;
3579           if (complain & tf_error)
3580             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3581           else
3582             return error_mark_node;
3583         }
3584       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3585         {
3586           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3587               == ptrmemfunc_vbit_in_delta)
3588             {
3589               tree pfn0 = pfn_from_ptrmemfunc (op0);
3590               tree delta0 = delta_from_ptrmemfunc (op0);
3591               tree e1 = cp_build_binary_op (location,
3592                                             EQ_EXPR,
3593                                             pfn0,
3594                                             fold_convert (TREE_TYPE (pfn0),
3595                                                           integer_zero_node),
3596                                             complain);
3597               tree e2 = cp_build_binary_op (location,
3598                                             BIT_AND_EXPR,
3599                                             delta0,
3600                                             integer_one_node,
3601                                             complain);
3602               e2 = cp_build_binary_op (location,
3603                                        EQ_EXPR, e2, integer_zero_node,
3604                                        complain);
3605               op0 = cp_build_binary_op (location,
3606                                         TRUTH_ANDIF_EXPR, e1, e2,
3607                                         complain);
3608               op1 = cp_convert (TREE_TYPE (op0), integer_one_node);
3609             }
3610           else
3611             {
3612               op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3613               op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3614             }
3615           result_type = TREE_TYPE (op0);
3616         }
3617       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3618         return cp_build_binary_op (location, code, op1, op0, complain);
3619       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1))
3620         {
3621           tree type;
3622           /* E will be the final comparison.  */
3623           tree e;
3624           /* E1 and E2 are for scratch.  */
3625           tree e1;
3626           tree e2;
3627           tree pfn0;
3628           tree pfn1;
3629           tree delta0;
3630           tree delta1;
3631
3632           type = composite_pointer_type (type0, type1, op0, op1, "comparison",
3633                                          complain);
3634
3635           if (!same_type_p (TREE_TYPE (op0), type))
3636             op0 = cp_convert_and_check (type, op0);
3637           if (!same_type_p (TREE_TYPE (op1), type))
3638             op1 = cp_convert_and_check (type, op1);
3639
3640           if (op0 == error_mark_node || op1 == error_mark_node)
3641             return error_mark_node;
3642
3643           if (TREE_SIDE_EFFECTS (op0))
3644             op0 = save_expr (op0);
3645           if (TREE_SIDE_EFFECTS (op1))
3646             op1 = save_expr (op1);
3647
3648           pfn0 = pfn_from_ptrmemfunc (op0);
3649           pfn1 = pfn_from_ptrmemfunc (op1);
3650           delta0 = delta_from_ptrmemfunc (op0);
3651           delta1 = delta_from_ptrmemfunc (op1);
3652           if (TARGET_PTRMEMFUNC_VBIT_LOCATION
3653               == ptrmemfunc_vbit_in_delta)
3654             {
3655               /* We generate:
3656
3657                  (op0.pfn == op1.pfn
3658                   && ((op0.delta == op1.delta)
3659                        || (!op0.pfn && op0.delta & 1 == 0
3660                            && op1.delta & 1 == 0))
3661
3662                  The reason for the `!op0.pfn' bit is that a NULL
3663                  pointer-to-member is any member with a zero PFN and
3664                  LSB of the DELTA field is 0.  */
3665
3666               e1 = cp_build_binary_op (location, BIT_AND_EXPR,
3667                                        delta0,
3668                                        integer_one_node,
3669                                        complain);
3670               e1 = cp_build_binary_op (location,
3671                                        EQ_EXPR, e1, integer_zero_node,
3672                                        complain);
3673               e2 = cp_build_binary_op (location, BIT_AND_EXPR,
3674                                        delta1,
3675                                        integer_one_node,
3676                                        complain);
3677               e2 = cp_build_binary_op (location,
3678                                        EQ_EXPR, e2, integer_zero_node,
3679                                        complain);
3680               e1 = cp_build_binary_op (location,
3681                                        TRUTH_ANDIF_EXPR, e2, e1,
3682                                        complain);
3683               e2 = cp_build_binary_op (location, EQ_EXPR,
3684                                        pfn0,
3685                                        fold_convert (TREE_TYPE (pfn0),
3686                                                      integer_zero_node),
3687                                        complain);
3688               e2 = cp_build_binary_op (location,
3689                                        TRUTH_ANDIF_EXPR, e2, e1, complain);
3690               e1 = cp_build_binary_op (location,
3691                                        EQ_EXPR, delta0, delta1, complain);
3692               e1 = cp_build_binary_op (location,
3693                                        TRUTH_ORIF_EXPR, e1, e2, complain);
3694             }
3695           else
3696             {
3697               /* We generate:
3698
3699                  (op0.pfn == op1.pfn
3700                  && (!op0.pfn || op0.delta == op1.delta))
3701
3702                  The reason for the `!op0.pfn' bit is that a NULL
3703                  pointer-to-member is any member with a zero PFN; the
3704                  DELTA field is unspecified.  */
3705
3706               e1 = cp_build_binary_op (location,
3707                                        EQ_EXPR, delta0, delta1, complain);
3708               e2 = cp_build_binary_op (location,
3709                                        EQ_EXPR,
3710                                        pfn0,
3711                                        fold_convert (TREE_TYPE (pfn0),
3712                                                      integer_zero_node),
3713                                        complain);
3714               e1 = cp_build_binary_op (location,
3715                                        TRUTH_ORIF_EXPR, e1, e2, complain);
3716             }
3717           e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3718           e = cp_build_binary_op (location,
3719                                   TRUTH_ANDIF_EXPR, e2, e1, complain);
3720           if (code == EQ_EXPR)
3721             return e;
3722           return cp_build_binary_op (location,
3723                                      EQ_EXPR, e, integer_zero_node, complain);
3724         }
3725       else
3726         {
3727           gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3728                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3729                                        type1));
3730           gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3731                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3732                                        type0));
3733         }
3734
3735       break;
3736
3737     case MAX_EXPR:
3738     case MIN_EXPR:
3739       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3740            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3741         shorten = 1;
3742       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3743         result_type = composite_pointer_type (type0, type1, op0, op1,
3744                                               "comparison", complain);
3745       break;
3746
3747     case LE_EXPR:
3748     case GE_EXPR:
3749     case LT_EXPR:
3750     case GT_EXPR:
3751       if (TREE_CODE (orig_op0) == STRING_CST
3752           || TREE_CODE (orig_op1) == STRING_CST)
3753         {
3754           if (complain & tf_warning)
3755             warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
3756         }
3757
3758       build_type = boolean_type_node;
3759       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3760            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3761         short_compare = 1;
3762       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3763         result_type = composite_pointer_type (type0, type1, op0, op1,
3764                                               "comparison", complain);
3765       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3766                && integer_zerop (op1))
3767         result_type = type0;
3768       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3769                && integer_zerop (op0))
3770         result_type = type1;
3771       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3772         {
3773           result_type = type0;
3774           if (complain & tf_error)
3775             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3776           else
3777             return error_mark_node;
3778         }
3779       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3780         {
3781           result_type = type1;
3782           if (complain & tf_error)
3783             permerror (input_location, "ISO C++ forbids comparison between pointer and integer");
3784           else
3785             return error_mark_node;
3786         }
3787       break;
3788
3789     case UNORDERED_EXPR:
3790     case ORDERED_EXPR:
3791     case UNLT_EXPR:
3792     case UNLE_EXPR:
3793     case UNGT_EXPR:
3794     case UNGE_EXPR:
3795     case UNEQ_EXPR:
3796       build_type = integer_type_node;
3797       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3798         {
3799           if (complain & tf_error)
3800             error ("unordered comparison on non-floating point argument");
3801           return error_mark_node;
3802         }
3803       common = 1;
3804       break;
3805
3806     default:
3807       break;
3808     }
3809
3810   if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3811        && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3812            || code1 == COMPLEX_TYPE)))
3813     arithmetic_types_p = 1;
3814   else
3815     {
3816       arithmetic_types_p = 0;
3817       /* Vector arithmetic is only allowed when both sides are vectors.  */
3818       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
3819         {
3820           if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
3821               || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
3822                                                         TREE_TYPE (type1)))
3823             {
3824               binary_op_error (location, code, type0, type1);
3825               return error_mark_node;
3826             }
3827           arithmetic_types_p = 1;
3828         }
3829     }
3830   /* Determine the RESULT_TYPE, if it is not already known.  */
3831   if (!result_type
3832       && arithmetic_types_p
3833       && (shorten || common || short_compare))
3834     result_type = cp_common_type (type0, type1);
3835
3836   if (!result_type)
3837     {
3838       if (complain & tf_error)
3839         error ("invalid operands of types %qT and %qT to binary %qO",
3840                TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3841       return error_mark_node;
3842     }
3843
3844   /* If we're in a template, the only thing we need to know is the
3845      RESULT_TYPE.  */
3846   if (processing_template_decl)
3847     {
3848       /* Since the middle-end checks the type when doing a build2, we
3849          need to build the tree in pieces.  This built tree will never
3850          get out of the front-end as we replace it when instantiating
3851          the template.  */
3852       tree tmp = build2 (resultcode,
3853                          build_type ? build_type : result_type,
3854                          NULL_TREE, op1);
3855       TREE_OPERAND (tmp, 0) = op0;
3856       return tmp;
3857     }
3858
3859   if (arithmetic_types_p)
3860     {
3861       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3862
3863       /* For certain operations (which identify themselves by shorten != 0)
3864          if both args were extended from the same smaller type,
3865          do the arithmetic in that type and then extend.
3866
3867          shorten !=0 and !=1 indicates a bitwise operation.
3868          For them, this optimization is safe only if
3869          both args are zero-extended or both are sign-extended.
3870          Otherwise, we might change the result.
3871          E.g., (short)-1 | (unsigned short)-1 is (int)-1
3872          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3873
3874       if (shorten && none_complex)
3875         {
3876           final_type = result_type;
3877           result_type = shorten_binary_op (result_type, op0, op1,
3878                                            shorten == -1);
3879         }
3880
3881       /* Comparison operations are shortened too but differently.
3882          They identify themselves by setting short_compare = 1.  */
3883
3884       if (short_compare)
3885         {
3886           /* Don't write &op0, etc., because that would prevent op0
3887              from being kept in a register.
3888              Instead, make copies of the our local variables and
3889              pass the copies by reference, then copy them back afterward.  */
3890           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3891           enum tree_code xresultcode = resultcode;
3892           tree val
3893             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3894           if (val != 0)
3895             return cp_convert (boolean_type_node, val);
3896           op0 = xop0, op1 = xop1;
3897           converted = 1;
3898           resultcode = xresultcode;
3899         }
3900
3901       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3902           && warn_sign_compare
3903           /* Do not warn until the template is instantiated; we cannot
3904              bound the ranges of the arguments until that point.  */
3905           && !processing_template_decl
3906           && (complain & tf_warning))
3907         {
3908           warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1,
3909                                  result_type, resultcode);
3910         }
3911     }
3912
3913   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3914   if ((orig_op0 == null_node || orig_op1 == null_node)
3915       /* It's reasonable to use pointer values as operands of &&
3916          and ||, so NULL is no exception.  */
3917       && code != TRUTH_ANDIF_EXPR && code != TRUTH_ORIF_EXPR
3918       && ( /* Both are NULL (or 0) and the operation was not a comparison.  */
3919           (null_ptr_cst_p (orig_op0) && null_ptr_cst_p (orig_op1)
3920            && code != EQ_EXPR && code != NE_EXPR)
3921           /* Or if one of OP0 or OP1 is neither a pointer nor NULL.  */
3922           || (!null_ptr_cst_p (orig_op0) && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3923           || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE))
3924       && (complain & tf_warning))
3925     /* Some sort of arithmetic operation involving NULL was
3926        performed.  Note that pointer-difference and pointer-addition
3927        have already been handled above, and so we don't end up here in
3928        that case.  */
3929     warning (OPT_Wpointer_arith, "NULL used in arithmetic");
3930
3931
3932   /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3933      Then the expression will be built.
3934      It will be given type FINAL_TYPE if that is nonzero;
3935      otherwise, it will be given type RESULT_TYPE.  */
3936   if (! converted)
3937     {
3938       if (TREE_TYPE (op0) != result_type)
3939         op0 = cp_convert_and_check (result_type, op0);
3940       if (TREE_TYPE (op1) != result_type)
3941         op1 = cp_convert_and_check (result_type, op1);
3942
3943       if (op0 == error_mark_node || op1 == error_mark_node)
3944         return error_mark_node;
3945     }
3946
3947   if (build_type == NULL_TREE)
3948     build_type = result_type;
3949
3950   result = build2 (resultcode, build_type, op0, op1);
3951   result = fold_if_not_in_template (result);
3952   if (final_type != 0)
3953     result = cp_convert (final_type, result);
3954
3955   if (TREE_OVERFLOW_P (result)
3956       && !TREE_OVERFLOW_P (op0)
3957       && !TREE_OVERFLOW_P (op1))
3958     overflow_warning (result);
3959
3960   return result;
3961 }
3962 \f
3963 /* Return a tree for the sum or difference (RESULTCODE says which)
3964    of pointer PTROP and integer INTOP.  */
3965
3966 static tree
3967 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3968 {
3969   tree res_type = TREE_TYPE (ptrop);
3970
3971   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3972      in certain circumstance (when it's valid to do so).  So we need
3973      to make sure it's complete.  We don't need to check here, if we
3974      can actually complete it at all, as those checks will be done in
3975      pointer_int_sum() anyway.  */
3976   complete_type (TREE_TYPE (res_type));
3977
3978   return pointer_int_sum (resultcode, ptrop,
3979                           fold_if_not_in_template (intop));
3980 }
3981
3982 /* Return a tree for the difference of pointers OP0 and OP1.
3983    The resulting tree has type int.  */
3984
3985 static tree
3986 pointer_diff (tree op0, tree op1, tree ptrtype)
3987 {
3988   tree result;
3989   tree restype = ptrdiff_type_node;
3990   tree target_type = TREE_TYPE (ptrtype);
3991
3992   if (!complete_type_or_else (target_type, NULL_TREE))
3993     return error_mark_node;
3994
3995   if (TREE_CODE (target_type) == VOID_TYPE)
3996     permerror (input_location, "ISO C++ forbids using pointer of type %<void *%> in subtraction");
3997   if (TREE_CODE (target_type) == FUNCTION_TYPE)
3998     permerror (input_location, "ISO C++ forbids using pointer to a function in subtraction");
3999   if (TREE_CODE (target_type) == METHOD_TYPE)
4000     permerror (input_location, "ISO C++ forbids using pointer to a method in subtraction");
4001
4002   /* First do the subtraction as integers;
4003      then drop through to build the divide operator.  */
4004
4005   op0 = cp_build_binary_op (input_location,
4006                             MINUS_EXPR,
4007                             cp_convert (restype, op0),
4008                             cp_convert (restype, op1),
4009                             tf_warning_or_error);
4010
4011   /* This generates an error if op1 is a pointer to an incomplete type.  */
4012   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
4013     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
4014
4015   op1 = (TYPE_PTROB_P (ptrtype)
4016          ? size_in_bytes (target_type)
4017          : integer_one_node);
4018
4019   /* Do the division.  */
4020
4021   result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
4022   return fold_if_not_in_template (result);
4023 }
4024 \f
4025 /* Construct and perhaps optimize a tree representation
4026    for a unary operation.  CODE, a tree_code, specifies the operation
4027    and XARG is the operand.  */
4028
4029 tree
4030 build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain)
4031 {
4032   tree orig_expr = xarg;
4033   tree exp;
4034   int ptrmem = 0;
4035
4036   if (processing_template_decl)
4037     {
4038       if (type_dependent_expression_p (xarg))
4039         return build_min_nt (code, xarg, NULL_TREE);
4040
4041       xarg = build_non_dependent_expr (xarg);
4042     }
4043
4044   exp = NULL_TREE;
4045
4046   /* [expr.unary.op] says:
4047
4048        The address of an object of incomplete type can be taken.
4049
4050      (And is just the ordinary address operator, not an overloaded
4051      "operator &".)  However, if the type is a template
4052      specialization, we must complete the type at this point so that
4053      an overloaded "operator &" will be available if required.  */
4054   if (code == ADDR_EXPR
4055       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
4056       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
4057            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
4058           || (TREE_CODE (xarg) == OFFSET_REF)))
4059     /* Don't look for a function.  */;
4060   else
4061     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
4062                         /*overloaded_p=*/NULL, complain);
4063   if (!exp && code == ADDR_EXPR)
4064     {
4065       /*  A pointer to member-function can be formed only by saying
4066           &X::mf.  */
4067       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
4068           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
4069         {
4070           if (TREE_CODE (xarg) != OFFSET_REF
4071               || !TYPE_P (TREE_OPERAND (xarg, 0)))
4072             {
4073               error ("invalid use of %qE to form a pointer-to-member-function",
4074                      xarg);
4075               if (TREE_CODE (xarg) != OFFSET_REF)
4076                 inform (input_location, "  a qualified-id is required");
4077               return error_mark_node;
4078             }
4079           else
4080             {
4081               error ("parentheses around %qE cannot be used to form a"
4082                      " pointer-to-member-function",
4083                      xarg);
4084               PTRMEM_OK_P (xarg) = 1;
4085             }
4086         }
4087
4088       if (TREE_CODE (xarg) == OFFSET_REF)
4089         {
4090           ptrmem = PTRMEM_OK_P (xarg);
4091
4092           if (!ptrmem && !flag_ms_extensions
4093               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
4094             {
4095               /* A single non-static member, make sure we don't allow a
4096                  pointer-to-member.  */
4097               xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
4098                              TREE_OPERAND (xarg, 0),
4099                              ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
4100               PTRMEM_OK_P (xarg) = ptrmem;
4101             }
4102         }
4103       else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning))
4104         warning (0, "taking address of temporary");
4105       exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain);
4106     }
4107
4108   if (processing_template_decl && exp != error_mark_node)
4109     exp = build_min_non_dep (code, exp, orig_expr,
4110                              /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
4111   if (TREE_CODE (exp) == ADDR_EXPR)
4112     PTRMEM_OK_P (exp) = ptrmem;
4113   return exp;
4114 }
4115
4116 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
4117    constants, where a null value is represented by an INTEGER_CST of
4118    -1.  */
4119
4120 tree
4121 cp_truthvalue_conversion (tree expr)
4122 {
4123   tree type = TREE_TYPE (expr);
4124   if (TYPE_PTRMEM_P (type))
4125     return build_binary_op (EXPR_LOCATION (expr),
4126                             NE_EXPR, expr, integer_zero_node, 1);
4127   else
4128     return c_common_truthvalue_conversion (input_location, expr);
4129 }
4130
4131 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
4132
4133 tree
4134 condition_conversion (tree expr)
4135 {
4136   tree t;
4137   if (processing_template_decl)
4138     return expr;
4139   t = perform_implicit_conversion (boolean_type_node, expr,
4140                                    tf_warning_or_error);
4141   t = fold_build_cleanup_point_expr (boolean_type_node, t);
4142   return t;
4143 }
4144
4145 /* Return an ADDR_EXPR giving the address of T.  This function
4146    attempts no optimizations or simplifications; it is a low-level
4147    primitive.  */
4148
4149 tree
4150 build_address (tree t)
4151 {
4152   tree addr;
4153
4154   if (error_operand_p (t) || !cxx_mark_addressable (t))
4155     return error_mark_node;
4156
4157   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
4158
4159   return addr;
4160 }
4161
4162 /* Return a NOP_EXPR converting EXPR to TYPE.  */
4163
4164 tree
4165 build_nop (tree type, tree expr)
4166 {
4167   if (type == error_mark_node || error_operand_p (expr))
4168     return expr;
4169   return build1 (NOP_EXPR, type, expr);
4170 }
4171
4172 /* C++: Must handle pointers to members.
4173
4174    Perhaps type instantiation should be extended to handle conversion
4175    from aggregates to types we don't yet know we want?  (Or are those
4176    cases typically errors which should be reported?)
4177
4178    NOCONVERT nonzero suppresses the default promotions
4179    (such as from short to int).  */
4180
4181 tree
4182 cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
4183                    tsubst_flags_t complain)
4184 {
4185   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
4186   tree arg = xarg;
4187   tree argtype = 0;
4188   const char *errstring = NULL;
4189   tree val;
4190   const char *invalid_op_diag;
4191
4192   if (error_operand_p (arg))
4193     return error_mark_node;
4194
4195   if ((invalid_op_diag
4196        = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
4197                                     ? CONVERT_EXPR
4198                                     : code),
4199                                    TREE_TYPE (xarg))))
4200     {
4201       error (invalid_op_diag);
4202       return error_mark_node;
4203     }
4204
4205   switch (code)
4206     {
4207     case UNARY_PLUS_EXPR:
4208     case NEGATE_EXPR:
4209       {
4210         int flags = WANT_ARITH | WANT_ENUM;
4211         /* Unary plus (but not unary minus) is allowed on pointers.  */
4212         if (code == UNARY_PLUS_EXPR)
4213           flags |= WANT_POINTER;
4214         arg = build_expr_type_conversion (flags, arg, true);
4215         if (!arg)
4216           errstring = (code == NEGATE_EXPR
4217                        ? "wrong type argument to unary minus"
4218                        : "wrong type argument to unary plus");
4219         else
4220           {
4221             if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4222               arg = perform_integral_promotions (arg);
4223
4224             /* Make sure the result is not an lvalue: a unary plus or minus
4225                expression is always a rvalue.  */
4226             arg = rvalue (arg);
4227           }
4228       }
4229       break;
4230
4231     case BIT_NOT_EXPR:
4232       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4233         {
4234           code = CONJ_EXPR;
4235           if (!noconvert)
4236             arg = default_conversion (arg);
4237         }
4238       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
4239                                                    | WANT_VECTOR,
4240                                                    arg, true)))
4241         errstring = "wrong type argument to bit-complement";
4242       else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4243         arg = perform_integral_promotions (arg);
4244       break;
4245
4246     case ABS_EXPR:
4247       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4248         errstring = "wrong type argument to abs";
4249       else if (!noconvert)
4250         arg = default_conversion (arg);
4251       break;
4252
4253     case CONJ_EXPR:
4254       /* Conjugating a real value is a no-op, but allow it anyway.  */
4255       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
4256         errstring = "wrong type argument to conjugation";
4257       else if (!noconvert)
4258         arg = default_conversion (arg);
4259       break;
4260
4261     case TRUTH_NOT_EXPR:
4262       arg = perform_implicit_conversion (boolean_type_node, arg,
4263                                          complain);
4264       val = invert_truthvalue (arg);
4265       if (arg != error_mark_node)
4266         return val;
4267       errstring = "in argument to unary !";
4268       break;
4269
4270     case NOP_EXPR:
4271       break;
4272
4273     case REALPART_EXPR:
4274       if (TREE_CODE (arg) == COMPLEX_CST)
4275         return TREE_REALPART (arg);
4276       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4277         {
4278           arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4279           return fold_if_not_in_template (arg);
4280         }
4281       else
4282         return arg;
4283
4284     case IMAGPART_EXPR:
4285       if (TREE_CODE (arg) == COMPLEX_CST)
4286         return TREE_IMAGPART (arg);
4287       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4288         {
4289           arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
4290           return fold_if_not_in_template (arg);
4291         }
4292       else
4293         return cp_convert (TREE_TYPE (arg), integer_zero_node);
4294
4295     case PREINCREMENT_EXPR:
4296     case POSTINCREMENT_EXPR:
4297     case PREDECREMENT_EXPR:
4298     case POSTDECREMENT_EXPR:
4299       /* Handle complex lvalues (when permitted)
4300          by reduction to simpler cases.  */
4301
4302       val = unary_complex_lvalue (code, arg);
4303       if (val != 0)
4304         return val;
4305
4306       /* Increment or decrement the real part of the value,
4307          and don't change the imaginary part.  */
4308       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
4309         {
4310           tree real, imag;
4311
4312           arg = stabilize_reference (arg);
4313           real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain);
4314           imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain);
4315           real = cp_build_unary_op (code, real, 1, complain);
4316           if (real == error_mark_node || imag == error_mark_node)
4317             return error_mark_node;
4318           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4319                          real, imag);
4320         }
4321
4322       /* Report invalid types.  */
4323
4324       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
4325                                               arg, true)))
4326         {
4327           if (code == PREINCREMENT_EXPR)
4328             errstring ="no pre-increment operator for type";
4329           else if (code == POSTINCREMENT_EXPR)
4330             errstring ="no post-increment operator for type";
4331           else if (code == PREDECREMENT_EXPR)
4332             errstring ="no pre-decrement operator for type";
4333           else
4334             errstring ="no post-decrement operator for type";
4335           break;
4336         }
4337       else if (arg == error_mark_node)
4338         return error_mark_node;
4339
4340       /* Report something read-only.  */
4341
4342       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
4343           || TREE_READONLY (arg))
4344         {
4345           if (complain & tf_error)
4346             readonly_error (arg, ((code == PREINCREMENT_EXPR
4347                                    || code == POSTINCREMENT_EXPR)
4348                                   ? "increment" : "decrement"));
4349           else
4350             return error_mark_node;
4351         }
4352
4353       {
4354         tree inc;
4355         tree declared_type = unlowered_expr_type (arg);
4356
4357         argtype = TREE_TYPE (arg);
4358
4359         /* ARM $5.2.5 last annotation says this should be forbidden.  */
4360         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
4361           {
4362             if (complain & tf_error)
4363               permerror (input_location, (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4364                          ? G_("ISO C++ forbids incrementing an enum")
4365                          : G_("ISO C++ forbids decrementing an enum"));
4366             else
4367               return error_mark_node;
4368           }
4369
4370         /* Compute the increment.  */
4371
4372         if (TREE_CODE (argtype) == POINTER_TYPE)
4373           {
4374             tree type = complete_type (TREE_TYPE (argtype));
4375
4376             if (!COMPLETE_OR_VOID_TYPE_P (type))
4377               {
4378                 if (complain & tf_error)
4379                   error (((code == PREINCREMENT_EXPR
4380                            || code == POSTINCREMENT_EXPR))
4381                          ? G_("cannot increment a pointer to incomplete type %qT")
4382                          : G_("cannot decrement a pointer to incomplete type %qT"),
4383                          TREE_TYPE (argtype));
4384                 else
4385                   return error_mark_node;
4386               }
4387             else if ((pedantic || warn_pointer_arith)
4388                      && !TYPE_PTROB_P (argtype))
4389               {
4390                 if (complain & tf_error)
4391                   permerror (input_location, (code == PREINCREMENT_EXPR
4392                               || code == POSTINCREMENT_EXPR)
4393                              ? G_("ISO C++ forbids incrementing a pointer of type %qT")
4394                              : G_("ISO C++ forbids decrementing a pointer of type %qT"),
4395                              argtype);
4396                 else
4397                   return error_mark_node;
4398               }
4399
4400             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
4401           }
4402         else
4403           inc = integer_one_node;
4404
4405         inc = cp_convert (argtype, inc);
4406
4407         /* Complain about anything else that is not a true lvalue.  */
4408         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4409                                     || code == POSTINCREMENT_EXPR)
4410                                    ? lv_increment : lv_decrement),
4411                              complain))
4412           return error_mark_node;
4413
4414         /* Forbid using -- on `bool'.  */
4415         if (same_type_p (declared_type, boolean_type_node))
4416           {
4417             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4418               {
4419                 if (complain & tf_error)
4420                   error ("invalid use of Boolean expression as operand "
4421                          "to %<operator--%>");
4422                 return error_mark_node;
4423               }
4424             val = boolean_increment (code, arg);
4425           }
4426         else
4427           val = build2 (code, TREE_TYPE (arg), arg, inc);
4428
4429         TREE_SIDE_EFFECTS (val) = 1;
4430         return val;
4431       }
4432
4433     case ADDR_EXPR:
4434       /* Note that this operation never does default_conversion
4435          regardless of NOCONVERT.  */
4436
4437       argtype = lvalue_type (arg);
4438
4439       if (TREE_CODE (arg) == OFFSET_REF)
4440         goto offset_ref;
4441
4442       if (TREE_CODE (argtype) == REFERENCE_TYPE)
4443         {
4444           tree type = build_pointer_type (TREE_TYPE (argtype));
4445           arg = build1 (CONVERT_EXPR, type, arg);
4446           return arg;
4447         }
4448       else if (DECL_MAIN_P (arg))
4449         {
4450           /* ARM $3.4 */
4451           if (complain & tf_error)
4452             permerror (input_location, "ISO C++ forbids taking address of function %<::main%>");
4453           else
4454             return error_mark_node;
4455         }
4456
4457       /* Let &* cancel out to simplify resulting code.  */
4458       if (TREE_CODE (arg) == INDIRECT_REF)
4459         {
4460           /* We don't need to have `current_class_ptr' wrapped in a
4461              NON_LVALUE_EXPR node.  */
4462           if (arg == current_class_ref)
4463             return current_class_ptr;
4464
4465           arg = TREE_OPERAND (arg, 0);
4466           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4467             {
4468               tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4469               arg = build1 (CONVERT_EXPR, type, arg);
4470             }
4471           else
4472             /* Don't let this be an lvalue.  */
4473             arg = rvalue (arg);
4474           return arg;
4475         }
4476
4477       /* Uninstantiated types are all functions.  Taking the
4478          address of a function is a no-op, so just return the
4479          argument.  */
4480
4481       gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4482                   || !IDENTIFIER_OPNAME_P (arg));
4483
4484       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4485           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4486         {
4487           /* They're trying to take the address of a unique non-static
4488              member function.  This is ill-formed (except in MS-land),
4489              but let's try to DTRT.
4490              Note: We only handle unique functions here because we don't
4491              want to complain if there's a static overload; non-unique
4492              cases will be handled by instantiate_type.  But we need to
4493              handle this case here to allow casts on the resulting PMF.
4494              We could defer this in non-MS mode, but it's easier to give
4495              a useful error here.  */
4496
4497           /* Inside constant member functions, the `this' pointer
4498              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4499              is used here to remove this const from the diagnostics
4500              and the created OFFSET_REF.  */
4501           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4502           tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4503           mark_used (fn);
4504
4505           if (! flag_ms_extensions)
4506             {
4507               tree name = DECL_NAME (fn);
4508               if (!(complain & tf_error))
4509                 return error_mark_node;
4510               else if (current_class_type
4511                        && TREE_OPERAND (arg, 0) == current_class_ref)
4512                   /* An expression like &memfn.  */
4513                 permerror (input_location, "ISO C++ forbids taking the address of an unqualified"
4514                            " or parenthesized non-static member function to form"
4515                            " a pointer to member function.  Say %<&%T::%D%>",
4516                            base, name);
4517               else
4518                 permerror (input_location, "ISO C++ forbids taking the address of a bound member"
4519                            " function to form a pointer to member function."
4520                            "  Say %<&%T::%D%>",
4521                            base, name);
4522             }
4523           arg = build_offset_ref (base, fn, /*address_p=*/true);
4524         }
4525
4526     offset_ref:
4527       if (type_unknown_p (arg))
4528         return build1 (ADDR_EXPR, unknown_type_node, arg);
4529
4530       /* Handle complex lvalues (when permitted)
4531          by reduction to simpler cases.  */
4532       val = unary_complex_lvalue (code, arg);
4533       if (val != 0)
4534         return val;
4535
4536       switch (TREE_CODE (arg))
4537         {
4538         CASE_CONVERT:
4539         case FLOAT_EXPR:
4540         case FIX_TRUNC_EXPR:
4541           /* Even if we're not being pedantic, we cannot allow this
4542              extension when we're instantiating in a SFINAE
4543              context.  */
4544           if (! lvalue_p (arg) && complain == tf_none)
4545             {
4546               if (complain & tf_error)
4547                 permerror (input_location, "ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4548               else
4549                 return error_mark_node;
4550             }
4551           break;
4552
4553         case BASELINK:
4554           arg = BASELINK_FUNCTIONS (arg);
4555           /* Fall through.  */
4556
4557         case OVERLOAD:
4558           arg = OVL_CURRENT (arg);
4559           break;
4560
4561         case OFFSET_REF:
4562           /* Turn a reference to a non-static data member into a
4563              pointer-to-member.  */
4564           {
4565             tree type;
4566             tree t;
4567
4568             if (!PTRMEM_OK_P (arg))
4569               return cp_build_unary_op (code, arg, 0, complain);
4570
4571             t = TREE_OPERAND (arg, 1);
4572             if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4573               {
4574                 if (complain & tf_error)
4575                   error ("cannot create pointer to reference member %qD", t);
4576                 return error_mark_node;
4577               }
4578
4579             type = build_ptrmem_type (context_for_name_lookup (t),
4580                                       TREE_TYPE (t));
4581             t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4582             return t;
4583           }
4584
4585         default:
4586           break;
4587         }
4588
4589       /* Anything not already handled and not a true memory reference
4590          is an error.  */
4591       if (TREE_CODE (argtype) != FUNCTION_TYPE
4592           && TREE_CODE (argtype) != METHOD_TYPE
4593           && TREE_CODE (arg) != OFFSET_REF
4594           && !lvalue_or_else (arg, lv_addressof, complain))
4595         return error_mark_node;
4596
4597       if (argtype != error_mark_node)
4598         argtype = build_pointer_type (argtype);
4599
4600       /* In a template, we are processing a non-dependent expression
4601          so we can just form an ADDR_EXPR with the correct type.  */
4602       if (processing_template_decl || TREE_CODE (arg) != COMPONENT_REF)
4603         {
4604           val = build_address (arg);
4605           if (TREE_CODE (arg) == OFFSET_REF)
4606             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4607         }
4608       else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4609         {
4610           tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4611
4612           /* We can only get here with a single static member
4613              function.  */
4614           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4615                       && DECL_STATIC_FUNCTION_P (fn));
4616           mark_used (fn);
4617           val = build_address (fn);
4618           if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4619             /* Do not lose object's side effects.  */
4620             val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4621                           TREE_OPERAND (arg, 0), val);
4622         }
4623       else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4624         {
4625           if (complain & tf_error)
4626             error ("attempt to take address of bit-field structure member %qD",
4627                    TREE_OPERAND (arg, 1));
4628           return error_mark_node;
4629         }
4630       else
4631         {
4632           tree object = TREE_OPERAND (arg, 0);
4633           tree field = TREE_OPERAND (arg, 1);
4634           gcc_assert (same_type_ignoring_top_level_qualifiers_p
4635                       (TREE_TYPE (object), decl_type_context (field)));
4636           val = build_address (arg);
4637         }
4638
4639       if (TREE_CODE (argtype) == POINTER_TYPE
4640           && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4641         {
4642           build_ptrmemfunc_type (argtype);
4643           val = build_ptrmemfunc (argtype, val, 0,
4644                                   /*c_cast_p=*/false);
4645         }
4646
4647       return val;
4648
4649     default:
4650       break;
4651     }
4652
4653   if (!errstring)
4654     {
4655       if (argtype == 0)
4656         argtype = TREE_TYPE (arg);
4657       return fold_if_not_in_template (build1 (code, argtype, arg));
4658     }
4659
4660   if (complain & tf_error)
4661     error ("%s", errstring);
4662   return error_mark_node;
4663 }
4664
4665 /* Hook for the c-common bits that build a unary op.  */
4666 tree
4667 build_unary_op (location_t location ATTRIBUTE_UNUSED,
4668                 enum tree_code code, tree xarg, int noconvert)
4669 {
4670   return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
4671 }
4672
4673 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4674    for certain kinds of expressions which are not really lvalues
4675    but which we can accept as lvalues.
4676
4677    If ARG is not a kind of expression we can handle, return
4678    NULL_TREE.  */
4679
4680 tree
4681 unary_complex_lvalue (enum tree_code code, tree arg)
4682 {
4683   /* Inside a template, making these kinds of adjustments is
4684      pointless; we are only concerned with the type of the
4685      expression.  */
4686   if (processing_template_decl)
4687     return NULL_TREE;
4688
4689   /* Handle (a, b) used as an "lvalue".  */
4690   if (TREE_CODE (arg) == COMPOUND_EXPR)
4691     {
4692       tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0,
4693                                             tf_warning_or_error);
4694       return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4695                      TREE_OPERAND (arg, 0), real_result);
4696     }
4697
4698   /* Handle (a ? b : c) used as an "lvalue".  */
4699   if (TREE_CODE (arg) == COND_EXPR
4700       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4701     return rationalize_conditional_expr (code, arg, tf_warning_or_error);
4702
4703   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4704   if (TREE_CODE (arg) == MODIFY_EXPR
4705       || TREE_CODE (arg) == PREINCREMENT_EXPR
4706       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4707     {
4708       tree lvalue = TREE_OPERAND (arg, 0);
4709       if (TREE_SIDE_EFFECTS (lvalue))
4710         {
4711           lvalue = stabilize_reference (lvalue);
4712           arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4713                         lvalue, TREE_OPERAND (arg, 1));
4714         }
4715       return unary_complex_lvalue
4716         (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4717     }
4718
4719   if (code != ADDR_EXPR)
4720     return NULL_TREE;
4721
4722   /* Handle (a = b) used as an "lvalue" for `&'.  */
4723   if (TREE_CODE (arg) == MODIFY_EXPR
4724       || TREE_CODE (arg) == INIT_EXPR)
4725     {
4726       tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0,
4727                                             tf_warning_or_error);
4728       arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4729                     arg, real_result);
4730       TREE_NO_WARNING (arg) = 1;
4731       return arg;
4732     }
4733
4734   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4735       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4736       || TREE_CODE (arg) == OFFSET_REF)
4737     return NULL_TREE;
4738
4739   /* We permit compiler to make function calls returning
4740      objects of aggregate type look like lvalues.  */
4741   {
4742     tree targ = arg;
4743
4744     if (TREE_CODE (targ) == SAVE_EXPR)
4745       targ = TREE_OPERAND (targ, 0);
4746
4747     if (TREE_CODE (targ) == CALL_EXPR && MAYBE_CLASS_TYPE_P (TREE_TYPE (targ)))
4748       {
4749         if (TREE_CODE (arg) == SAVE_EXPR)
4750           targ = arg;
4751         else
4752           targ = build_cplus_new (TREE_TYPE (arg), arg);
4753         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4754       }
4755
4756     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4757       return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4758                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4759   }
4760
4761   /* Don't let anything else be handled specially.  */
4762   return NULL_TREE;
4763 }
4764 \f
4765 /* Mark EXP saying that we need to be able to take the
4766    address of it; it should not be allocated in a register.
4767    Value is true if successful.
4768
4769    C++: we do not allow `current_class_ptr' to be addressable.  */
4770
4771 bool
4772 cxx_mark_addressable (tree exp)
4773 {
4774   tree x = exp;
4775
4776   while (1)
4777     switch (TREE_CODE (x))
4778       {
4779       case ADDR_EXPR:
4780       case COMPONENT_REF:
4781       case ARRAY_REF:
4782       case REALPART_EXPR:
4783       case IMAGPART_EXPR:
4784         x = TREE_OPERAND (x, 0);
4785         break;
4786
4787       case PARM_DECL:
4788         if (x == current_class_ptr)
4789           {
4790             error ("cannot take the address of %<this%>, which is an rvalue expression");
4791             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4792             return true;
4793           }
4794         /* Fall through.  */
4795
4796       case VAR_DECL:
4797         /* Caller should not be trying to mark initialized
4798            constant fields addressable.  */
4799         gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4800                     || DECL_IN_AGGR_P (x) == 0
4801                     || TREE_STATIC (x)
4802                     || DECL_EXTERNAL (x));
4803         /* Fall through.  */
4804
4805       case CONST_DECL:
4806       case RESULT_DECL:
4807         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4808             && !DECL_ARTIFICIAL (x))
4809           {
4810             if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
4811               {
4812                 error
4813                   ("address of explicit register variable %qD requested", x);
4814                 return false;
4815               }
4816             else if (extra_warnings)
4817               warning
4818                 (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x);
4819           }
4820         TREE_ADDRESSABLE (x) = 1;
4821         return true;
4822
4823       case FUNCTION_DECL:
4824         TREE_ADDRESSABLE (x) = 1;
4825         return true;
4826
4827       case CONSTRUCTOR:
4828         TREE_ADDRESSABLE (x) = 1;
4829         return true;
4830
4831       case TARGET_EXPR:
4832         TREE_ADDRESSABLE (x) = 1;
4833         cxx_mark_addressable (TREE_OPERAND (x, 0));
4834         return true;
4835
4836       default:
4837         return true;
4838     }
4839 }
4840 \f
4841 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4842
4843 tree
4844 build_x_conditional_expr (tree ifexp, tree op1, tree op2,
4845                           tsubst_flags_t complain)
4846 {
4847   tree orig_ifexp = ifexp;
4848   tree orig_op1 = op1;
4849   tree orig_op2 = op2;
4850   tree expr;
4851
4852   if (processing_template_decl)
4853     {
4854       /* The standard says that the expression is type-dependent if
4855          IFEXP is type-dependent, even though the eventual type of the
4856          expression doesn't dependent on IFEXP.  */
4857       if (type_dependent_expression_p (ifexp)
4858           /* As a GNU extension, the middle operand may be omitted.  */
4859           || (op1 && type_dependent_expression_p (op1))
4860           || type_dependent_expression_p (op2))
4861         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4862       ifexp = build_non_dependent_expr (ifexp);
4863       if (op1)
4864         op1 = build_non_dependent_expr (op1);
4865       op2 = build_non_dependent_expr (op2);
4866     }
4867
4868   expr = build_conditional_expr (ifexp, op1, op2, complain);
4869   if (processing_template_decl && expr != error_mark_node)
4870     return build_min_non_dep (COND_EXPR, expr,
4871                               orig_ifexp, orig_op1, orig_op2);
4872   return expr;
4873 }
4874 \f
4875 /* Given a list of expressions, return a compound expression
4876    that performs them all and returns the value of the last of them.  */
4877
4878 tree build_x_compound_expr_from_list (tree list, const char *msg)
4879 {
4880   tree expr = TREE_VALUE (list);
4881
4882   if (TREE_CHAIN (list))
4883     {
4884       if (msg)
4885         permerror (input_location, "%s expression list treated as compound expression", msg);
4886
4887       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4888         expr = build_x_compound_expr (expr, TREE_VALUE (list),
4889                                       tf_warning_or_error);
4890     }
4891
4892   return expr;
4893 }
4894
4895 /* Handle overloading of the ',' operator when needed.  */
4896
4897 tree
4898 build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain)
4899 {
4900   tree result;
4901   tree orig_op1 = op1;
4902   tree orig_op2 = op2;
4903
4904   if (processing_template_decl)
4905     {
4906       if (type_dependent_expression_p (op1)
4907           || type_dependent_expression_p (op2))
4908         return build_min_nt (COMPOUND_EXPR, op1, op2);
4909       op1 = build_non_dependent_expr (op1);
4910       op2 = build_non_dependent_expr (op2);
4911     }
4912
4913   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4914                          /*overloaded_p=*/NULL, complain);
4915   if (!result)
4916     result = cp_build_compound_expr (op1, op2, complain);
4917
4918   if (processing_template_decl && result != error_mark_node)
4919     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4920
4921   return result;
4922 }
4923
4924 /* Like cp_build_compound_expr, but for the c-common bits.  */
4925
4926 tree
4927 build_compound_expr (tree lhs, tree rhs)
4928 {
4929   return cp_build_compound_expr (lhs, rhs, tf_warning_or_error);
4930 }
4931
4932 /* Build a compound expression.  */
4933
4934 tree
4935 cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
4936 {
4937   lhs = convert_to_void (lhs, "left-hand operand of comma", complain);
4938
4939   if (lhs == error_mark_node || rhs == error_mark_node)
4940     return error_mark_node;
4941
4942   if (TREE_CODE (rhs) == TARGET_EXPR)
4943     {
4944       /* If the rhs is a TARGET_EXPR, then build the compound
4945          expression inside the target_expr's initializer. This
4946          helps the compiler to eliminate unnecessary temporaries.  */
4947       tree init = TREE_OPERAND (rhs, 1);
4948
4949       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4950       TREE_OPERAND (rhs, 1) = init;
4951
4952       return rhs;
4953     }
4954
4955   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4956 }
4957
4958 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4959    casts away constness.  CAST gives the type of cast.  */
4960
4961 static void
4962 check_for_casting_away_constness (tree src_type, tree dest_type,
4963                                   enum tree_code cast)
4964 {
4965   /* C-style casts are allowed to cast away constness.  With
4966      WARN_CAST_QUAL, we still want to issue a warning.  */
4967   if (cast == CAST_EXPR && !warn_cast_qual)
4968       return;
4969
4970   if (casts_away_constness (src_type, dest_type))
4971     switch (cast)
4972       {
4973       case CAST_EXPR:
4974         warning (OPT_Wcast_qual,
4975                  "cast from type %qT to type %qT casts away constness",
4976                  src_type, dest_type);
4977         return;
4978
4979       case STATIC_CAST_EXPR:
4980         error ("static_cast from type %qT to type %qT casts away constness",
4981                src_type, dest_type);
4982         return;
4983
4984       case REINTERPRET_CAST_EXPR:
4985         error ("reinterpret_cast from type %qT to type %qT casts away constness",
4986                src_type, dest_type);
4987         return;
4988       default:
4989         gcc_unreachable();
4990       }
4991 }
4992
4993 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4994    (another pointer-to-member type in the same hierarchy) and return
4995    the converted expression.  If ALLOW_INVERSE_P is permitted, a
4996    pointer-to-derived may be converted to pointer-to-base; otherwise,
4997    only the other direction is permitted.  If C_CAST_P is true, this
4998    conversion is taking place as part of a C-style cast.  */
4999
5000 tree
5001 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
5002                 bool c_cast_p)
5003 {
5004   if (TYPE_PTRMEM_P (type))
5005     {
5006       tree delta;
5007
5008       if (TREE_CODE (expr) == PTRMEM_CST)
5009         expr = cplus_expand_constant (expr);
5010       delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
5011                                     TYPE_PTRMEM_CLASS_TYPE (type),
5012                                     allow_inverse_p,
5013                                     c_cast_p);
5014       if (!integer_zerop (delta))
5015         {
5016           tree cond, op1, op2;
5017
5018           cond = cp_build_binary_op (input_location,
5019                                      EQ_EXPR,
5020                                      expr,
5021                                      build_int_cst (TREE_TYPE (expr), -1),
5022                                      tf_warning_or_error);
5023           op1 = build_nop (ptrdiff_type_node, expr);
5024           op2 = cp_build_binary_op (input_location,
5025                                     PLUS_EXPR, op1, delta,
5026                                     tf_warning_or_error);
5027
5028           expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2);
5029
5030         }
5031
5032       return build_nop (type, expr);
5033     }
5034   else
5035     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
5036                              allow_inverse_p, c_cast_p);
5037 }
5038
5039 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
5040    a version of EXPR that has TREE_OVERFLOW set if it is set in ORIG.
5041    Otherwise, return EXPR unchanged.  */
5042
5043 static tree
5044 ignore_overflows (tree expr, tree orig)
5045 {
5046   if (TREE_CODE (expr) == INTEGER_CST
5047       && CONSTANT_CLASS_P (orig)
5048       && TREE_CODE (orig) != STRING_CST
5049       && TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig))
5050     {
5051       if (!TREE_OVERFLOW (orig))
5052         /* Ensure constant sharing.  */
5053         expr = build_int_cst_wide (TREE_TYPE (expr),
5054                                    TREE_INT_CST_LOW (expr),
5055                                    TREE_INT_CST_HIGH (expr));
5056       else
5057         {
5058           /* Avoid clobbering a shared constant.  */
5059           expr = copy_node (expr);
5060           TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
5061         }
5062     }
5063   return expr;
5064 }
5065
5066 /* Perform a static_cast from EXPR to TYPE.  When C_CAST_P is true,
5067    this static_cast is being attempted as one of the possible casts
5068    allowed by a C-style cast.  (In that case, accessibility of base
5069    classes is not considered, and it is OK to cast away
5070    constness.)  Return the result of the cast.  *VALID_P is set to
5071    indicate whether or not the cast was valid.  */
5072
5073 static tree
5074 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
5075                      bool *valid_p, tsubst_flags_t complain)
5076 {
5077   tree intype;
5078   tree result;
5079   tree orig;
5080
5081   /* Assume the cast is valid.  */
5082   *valid_p = true;
5083
5084   intype = TREE_TYPE (expr);
5085
5086   /* Save casted types in the function's used types hash table.  */
5087   used_types_insert (type);
5088
5089   /* [expr.static.cast]
5090
5091      An lvalue of type "cv1 B", where B is a class type, can be cast
5092      to type "reference to cv2 D", where D is a class derived (clause
5093      _class.derived_) from B, if a valid standard conversion from
5094      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
5095      same cv-qualification as, or greater cv-qualification than, cv1,
5096      and B is not a virtual base class of D.  */
5097   /* We check this case before checking the validity of "TYPE t =
5098      EXPR;" below because for this case:
5099
5100        struct B {};
5101        struct D : public B { D(const B&); };
5102        extern B& b;
5103        void f() { static_cast<const D&>(b); }
5104
5105      we want to avoid constructing a new D.  The standard is not
5106      completely clear about this issue, but our interpretation is
5107      consistent with other compilers.  */
5108   if (TREE_CODE (type) == REFERENCE_TYPE
5109       && CLASS_TYPE_P (TREE_TYPE (type))
5110       && CLASS_TYPE_P (intype)
5111       && real_lvalue_p (expr)
5112       && DERIVED_FROM_P (intype, TREE_TYPE (type))
5113       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
5114                       build_pointer_type (TYPE_MAIN_VARIANT
5115                                           (TREE_TYPE (type))))
5116       && (c_cast_p
5117           || at_least_as_qualified_p (TREE_TYPE (type), intype)))
5118     {
5119       tree base;
5120
5121       /* There is a standard conversion from "D*" to "B*" even if "B"
5122          is ambiguous or inaccessible.  If this is really a
5123          static_cast, then we check both for inaccessibility and
5124          ambiguity.  However, if this is a static_cast being performed
5125          because the user wrote a C-style cast, then accessibility is
5126          not considered.  */
5127       base = lookup_base (TREE_TYPE (type), intype,
5128                           c_cast_p ? ba_unique : ba_check,
5129                           NULL);
5130
5131       /* Convert from "B*" to "D*".  This function will check that "B"
5132          is not a virtual base of "D".  */
5133       expr = build_base_path (MINUS_EXPR, build_address (expr),
5134                               base, /*nonnull=*/false);
5135       /* Convert the pointer to a reference -- but then remember that
5136          there are no expressions with reference type in C++.  */
5137       return convert_from_reference (build_nop (type, expr));
5138     }
5139
5140   orig = expr;
5141
5142   /* [expr.static.cast]
5143
5144      An expression e can be explicitly converted to a type T using a
5145      static_cast of the form static_cast<T>(e) if the declaration T
5146      t(e);" is well-formed, for some invented temporary variable
5147      t.  */
5148   result = perform_direct_initialization_if_possible (type, expr,
5149                                                       c_cast_p, complain);
5150   if (result)
5151     {
5152       result = convert_from_reference (result);
5153
5154       /* Ignore any integer overflow caused by the cast.  */
5155       result = ignore_overflows (result, orig);
5156
5157       /* [expr.static.cast]
5158
5159          If T is a reference type, the result is an lvalue; otherwise,
5160          the result is an rvalue.  */
5161       if (TREE_CODE (type) != REFERENCE_TYPE)
5162         result = rvalue (result);
5163       return result;
5164     }
5165
5166   /* [expr.static.cast]
5167
5168      Any expression can be explicitly converted to type cv void.  */
5169   if (TREE_CODE (type) == VOID_TYPE)
5170     return convert_to_void (expr, /*implicit=*/NULL, complain);
5171
5172   /* [expr.static.cast]
5173
5174      The inverse of any standard conversion sequence (clause _conv_),
5175      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
5176      (_conv.array_), function-to-pointer (_conv.func_), and boolean
5177      (_conv.bool_) conversions, can be performed explicitly using
5178      static_cast subject to the restriction that the explicit
5179      conversion does not cast away constness (_expr.const.cast_), and
5180      the following additional rules for specific cases:  */
5181   /* For reference, the conversions not excluded are: integral
5182      promotions, floating point promotion, integral conversions,
5183      floating point conversions, floating-integral conversions,
5184      pointer conversions, and pointer to member conversions.  */
5185   /* DR 128
5186
5187      A value of integral _or enumeration_ type can be explicitly
5188      converted to an enumeration type.  */
5189   /* The effect of all that is that any conversion between any two
5190      types which are integral, floating, or enumeration types can be
5191      performed.  */
5192   if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
5193       && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
5194     {
5195       expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
5196
5197       /* Ignore any integer overflow caused by the cast.  */
5198       expr = ignore_overflows (expr, orig);
5199       return expr;
5200     }
5201
5202   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
5203       && CLASS_TYPE_P (TREE_TYPE (type))
5204       && CLASS_TYPE_P (TREE_TYPE (intype))
5205       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
5206                                           (TREE_TYPE (intype))),
5207                       build_pointer_type (TYPE_MAIN_VARIANT
5208                                           (TREE_TYPE (type)))))
5209     {
5210       tree base;
5211
5212       if (!c_cast_p)
5213         check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5214       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
5215                           c_cast_p ? ba_unique : ba_check,
5216                           NULL);
5217       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
5218     }
5219
5220   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5221       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5222     {
5223       tree c1;
5224       tree c2;
5225       tree t1;
5226       tree t2;
5227
5228       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
5229       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
5230
5231       if (TYPE_PTRMEM_P (type))
5232         {
5233           t1 = (build_ptrmem_type
5234                 (c1,
5235                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
5236           t2 = (build_ptrmem_type
5237                 (c2,
5238                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
5239         }
5240       else
5241         {
5242           t1 = intype;
5243           t2 = type;
5244         }
5245       if (can_convert (t1, t2) || can_convert (t2, t1))
5246         {
5247           if (!c_cast_p)
5248             check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5249           return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
5250                                  c_cast_p);
5251         }
5252     }
5253
5254   /* [expr.static.cast]
5255
5256      An rvalue of type "pointer to cv void" can be explicitly
5257      converted to a pointer to object type.  A value of type pointer
5258      to object converted to "pointer to cv void" and back to the
5259      original pointer type will have its original value.  */
5260   if (TREE_CODE (intype) == POINTER_TYPE
5261       && VOID_TYPE_P (TREE_TYPE (intype))
5262       && TYPE_PTROB_P (type))
5263     {
5264       if (!c_cast_p)
5265         check_for_casting_away_constness (intype, type, STATIC_CAST_EXPR);
5266       return build_nop (type, expr);
5267     }
5268
5269   *valid_p = false;
5270   return error_mark_node;
5271 }
5272
5273 /* Return an expression representing static_cast<TYPE>(EXPR).  */
5274
5275 tree
5276 build_static_cast (tree type, tree expr, tsubst_flags_t complain)
5277 {
5278   tree result;
5279   bool valid_p;
5280
5281   if (type == error_mark_node || expr == error_mark_node)
5282     return error_mark_node;
5283
5284   if (processing_template_decl)
5285     {
5286       expr = build_min (STATIC_CAST_EXPR, type, expr);
5287       /* We don't know if it will or will not have side effects.  */
5288       TREE_SIDE_EFFECTS (expr) = 1;
5289       return convert_from_reference (expr);
5290     }
5291
5292   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5293      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5294   if (TREE_CODE (type) != REFERENCE_TYPE
5295       && TREE_CODE (expr) == NOP_EXPR
5296       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5297     expr = TREE_OPERAND (expr, 0);
5298
5299   result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p,
5300                                 complain);
5301   if (valid_p)
5302     return result;
5303
5304   if (complain & tf_error)
5305     error ("invalid static_cast from type %qT to type %qT",
5306            TREE_TYPE (expr), type);
5307   return error_mark_node;
5308 }
5309
5310 /* EXPR is an expression with member function or pointer-to-member
5311    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
5312    not permitted by ISO C++, but we accept it in some modes.  If we
5313    are not in one of those modes, issue a diagnostic.  Return the
5314    converted expression.  */
5315
5316 tree
5317 convert_member_func_to_ptr (tree type, tree expr)
5318 {
5319   tree intype;
5320   tree decl;
5321
5322   intype = TREE_TYPE (expr);
5323   gcc_assert (TYPE_PTRMEMFUNC_P (intype)
5324               || TREE_CODE (intype) == METHOD_TYPE);
5325
5326   if (pedantic || warn_pmf2ptr)
5327     pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpmf_conversions,
5328              "converting from %qT to %qT", intype, type);
5329
5330   if (TREE_CODE (intype) == METHOD_TYPE)
5331     expr = build_addr_func (expr);
5332   else if (TREE_CODE (expr) == PTRMEM_CST)
5333     expr = build_address (PTRMEM_CST_MEMBER (expr));
5334   else
5335     {
5336       decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
5337       decl = build_address (decl);
5338       expr = get_member_function_from_ptrfunc (&decl, expr);
5339     }
5340
5341   return build_nop (type, expr);
5342 }
5343
5344 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
5345    If C_CAST_P is true, this reinterpret cast is being done as part of
5346    a C-style cast.  If VALID_P is non-NULL, *VALID_P is set to
5347    indicate whether or not reinterpret_cast was valid.  */
5348
5349 static tree
5350 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
5351                           bool *valid_p, tsubst_flags_t complain)
5352 {
5353   tree intype;
5354
5355   /* Assume the cast is invalid.  */
5356   if (valid_p)
5357     *valid_p = true;
5358
5359   if (type == error_mark_node || error_operand_p (expr))
5360     return error_mark_node;
5361
5362   intype = TREE_TYPE (expr);
5363
5364   /* Save casted types in the function's used types hash table.  */
5365   used_types_insert (type);
5366
5367   /* [expr.reinterpret.cast]
5368      An lvalue expression of type T1 can be cast to the type
5369      "reference to T2" if an expression of type "pointer to T1" can be
5370      explicitly converted to the type "pointer to T2" using a
5371      reinterpret_cast.  */
5372   if (TREE_CODE (type) == REFERENCE_TYPE)
5373     {
5374       if (! real_lvalue_p (expr))
5375         {
5376           if (complain & tf_error)
5377             error ("invalid cast of an rvalue expression of type "
5378                    "%qT to type %qT",
5379                    intype, type);
5380           return error_mark_node;
5381         }
5382
5383       /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
5384          "B" are related class types; the reinterpret_cast does not
5385          adjust the pointer.  */
5386       if (TYPE_PTR_P (intype)
5387           && (complain & tf_warning)
5388           && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
5389                          COMPARE_BASE | COMPARE_DERIVED)))
5390         warning (0, "casting %qT to %qT does not dereference pointer",
5391                  intype, type);
5392
5393       expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain);
5394       if (expr != error_mark_node)
5395         expr = build_reinterpret_cast_1
5396           (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
5397            valid_p, complain);
5398       if (expr != error_mark_node)
5399         expr = cp_build_indirect_ref (expr, 0, complain);
5400       return expr;
5401     }
5402
5403   /* As a G++ extension, we consider conversions from member
5404      functions, and pointers to member functions to
5405      pointer-to-function and pointer-to-void types.  If
5406      -Wno-pmf-conversions has not been specified,
5407      convert_member_func_to_ptr will issue an error message.  */
5408   if ((TYPE_PTRMEMFUNC_P (intype)
5409        || TREE_CODE (intype) == METHOD_TYPE)
5410       && TYPE_PTR_P (type)
5411       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5412           || VOID_TYPE_P (TREE_TYPE (type))))
5413     return convert_member_func_to_ptr (type, expr);
5414
5415   /* If the cast is not to a reference type, the lvalue-to-rvalue,
5416      array-to-pointer, and function-to-pointer conversions are
5417      performed.  */
5418   expr = decay_conversion (expr);
5419
5420   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5421      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5422   if (TREE_CODE (expr) == NOP_EXPR
5423       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5424     expr = TREE_OPERAND (expr, 0);
5425
5426   if (error_operand_p (expr))
5427     return error_mark_node;
5428
5429   intype = TREE_TYPE (expr);
5430
5431   /* [expr.reinterpret.cast]
5432      A pointer can be converted to any integral type large enough to
5433      hold it.  */
5434   if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5435     {
5436       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5437         {
5438           if (complain & tf_error)
5439             permerror (input_location, "cast from %qT to %qT loses precision",
5440                        intype, type);
5441           else
5442             return error_mark_node;
5443         }
5444     }
5445   /* [expr.reinterpret.cast]
5446      A value of integral or enumeration type can be explicitly
5447      converted to a pointer.  */
5448   else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5449     /* OK */
5450     ;
5451   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5452            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5453     return fold_if_not_in_template (build_nop (type, expr));
5454   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5455            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5456     {
5457       tree sexpr = expr;
5458
5459       if (!c_cast_p)
5460         check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR);
5461       /* Warn about possible alignment problems.  */
5462       if (STRICT_ALIGNMENT && warn_cast_align
5463           && (complain & tf_warning)
5464           && !VOID_TYPE_P (type)
5465           && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5466           && COMPLETE_TYPE_P (TREE_TYPE (type))
5467           && COMPLETE_TYPE_P (TREE_TYPE (intype))
5468           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5469         warning (OPT_Wcast_align, "cast from %qT to %qT "
5470                  "increases required alignment of target type", intype, type);
5471
5472       /* We need to strip nops here, because the front end likes to
5473          create (int *)&a for array-to-pointer decay, instead of &a[0].  */
5474       STRIP_NOPS (sexpr);
5475       if (warn_strict_aliasing <= 2)
5476         strict_aliasing_warning (intype, type, sexpr);
5477
5478       return fold_if_not_in_template (build_nop (type, expr));
5479     }
5480   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5481            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5482     {
5483       if (pedantic && (complain & tf_warning))
5484         /* Only issue a warning, as we have always supported this
5485            where possible, and it is necessary in some cases.  DR 195
5486            addresses this issue, but as of 2004/10/26 is still in
5487            drafting.  */
5488         warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5489       return fold_if_not_in_template (build_nop (type, expr));
5490     }
5491   else if (TREE_CODE (type) == VECTOR_TYPE)
5492     return fold_if_not_in_template (convert_to_vector (type, expr));
5493   else if (TREE_CODE (intype) == VECTOR_TYPE && INTEGRAL_TYPE_P (type))
5494     return fold_if_not_in_template (convert_to_integer (type, expr));
5495   else
5496     {
5497       if (valid_p)
5498         *valid_p = false;
5499       if (complain & tf_error)
5500         error ("invalid cast from type %qT to type %qT", intype, type);
5501       return error_mark_node;
5502     }
5503
5504   return cp_convert (type, expr);
5505 }
5506
5507 tree
5508 build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain)
5509 {
5510   if (type == error_mark_node || expr == error_mark_node)
5511     return error_mark_node;
5512
5513   if (processing_template_decl)
5514     {
5515       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5516
5517       if (!TREE_SIDE_EFFECTS (t)
5518           && type_dependent_expression_p (expr))
5519         /* There might turn out to be side effects inside expr.  */
5520         TREE_SIDE_EFFECTS (t) = 1;
5521       return convert_from_reference (t);
5522     }
5523
5524   return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5525                                    /*valid_p=*/NULL, complain);
5526 }
5527
5528 /* Perform a const_cast from EXPR to TYPE.  If the cast is valid,
5529    return an appropriate expression.  Otherwise, return
5530    error_mark_node.  If the cast is not valid, and COMPLAIN is true,
5531    then a diagnostic will be issued.  If VALID_P is non-NULL, we are
5532    performing a C-style cast, its value upon return will indicate
5533    whether or not the conversion succeeded.  */
5534
5535 static tree
5536 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5537                     bool *valid_p)
5538 {
5539   tree src_type;
5540   tree reference_type;
5541
5542   /* Callers are responsible for handling error_mark_node as a
5543      destination type.  */
5544   gcc_assert (dst_type != error_mark_node);
5545   /* In a template, callers should be building syntactic
5546      representations of casts, not using this machinery.  */
5547   gcc_assert (!processing_template_decl);
5548
5549   /* Assume the conversion is invalid.  */
5550   if (valid_p)
5551     *valid_p = false;
5552
5553   if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5554     {
5555       if (complain)
5556         error ("invalid use of const_cast with type %qT, "
5557                "which is not a pointer, "
5558                "reference, nor a pointer-to-data-member type", dst_type);
5559       return error_mark_node;
5560     }
5561
5562   if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5563     {
5564       if (complain)
5565         error ("invalid use of const_cast with type %qT, which is a pointer "
5566                "or reference to a function type", dst_type);
5567       return error_mark_node;
5568     }
5569
5570   /* Save casted types in the function's used types hash table.  */
5571   used_types_insert (dst_type);
5572
5573   src_type = TREE_TYPE (expr);
5574   /* Expressions do not really have reference types.  */
5575   if (TREE_CODE (src_type) == REFERENCE_TYPE)
5576     src_type = TREE_TYPE (src_type);
5577
5578   /* [expr.const.cast]
5579
5580      An lvalue of type T1 can be explicitly converted to an lvalue of
5581      type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5582      types) if a pointer to T1 can be explicitly converted to the type
5583      pointer to T2 using a const_cast.  */
5584   if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5585     {
5586       reference_type = dst_type;
5587       if (! real_lvalue_p (expr))
5588         {
5589           if (complain)
5590             error ("invalid const_cast of an rvalue of type %qT to type %qT",
5591                    src_type, dst_type);
5592           return error_mark_node;
5593         }
5594       dst_type = build_pointer_type (TREE_TYPE (dst_type));
5595       src_type = build_pointer_type (src_type);
5596     }
5597   else
5598     {
5599       reference_type = NULL_TREE;
5600       /* If the destination type is not a reference type, the
5601          lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5602          conversions are performed.  */
5603       src_type = type_decays_to (src_type);
5604       if (src_type == error_mark_node)
5605         return error_mark_node;
5606     }
5607
5608   if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5609       && comp_ptr_ttypes_const (dst_type, src_type))
5610     {
5611       if (valid_p)
5612         {
5613           *valid_p = true;
5614           /* This cast is actually a C-style cast.  Issue a warning if
5615              the user is making a potentially unsafe cast.  */
5616           check_for_casting_away_constness (src_type, dst_type, CAST_EXPR);
5617         }
5618       if (reference_type)
5619         {
5620           expr = cp_build_unary_op (ADDR_EXPR, expr, 0,
5621                                     complain? tf_warning_or_error : tf_none);
5622           expr = build_nop (reference_type, expr);
5623           return convert_from_reference (expr);
5624         }
5625       else
5626         {
5627           expr = decay_conversion (expr);
5628           /* build_c_cast puts on a NOP_EXPR to make the result not an
5629              lvalue.  Strip such NOP_EXPRs if VALUE is being used in
5630              non-lvalue context.  */
5631           if (TREE_CODE (expr) == NOP_EXPR
5632               && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5633             expr = TREE_OPERAND (expr, 0);
5634           return build_nop (dst_type, expr);
5635         }
5636     }
5637
5638   if (complain)
5639     error ("invalid const_cast from type %qT to type %qT",
5640            src_type, dst_type);
5641   return error_mark_node;
5642 }
5643
5644 tree
5645 build_const_cast (tree type, tree expr, tsubst_flags_t complain)
5646 {
5647   if (type == error_mark_node || error_operand_p (expr))
5648     return error_mark_node;
5649
5650   if (processing_template_decl)
5651     {
5652       tree t = build_min (CONST_CAST_EXPR, type, expr);
5653
5654       if (!TREE_SIDE_EFFECTS (t)
5655           && type_dependent_expression_p (expr))
5656         /* There might turn out to be side effects inside expr.  */
5657         TREE_SIDE_EFFECTS (t) = 1;
5658       return convert_from_reference (t);
5659     }
5660
5661   return build_const_cast_1 (type, expr, complain & tf_error,
5662                              /*valid_p=*/NULL);
5663 }
5664
5665 /* Like cp_build_c_cast, but for the c-common bits.  */
5666
5667 tree
5668 build_c_cast (tree type, tree expr)
5669 {
5670   return cp_build_c_cast (type, expr, tf_warning_or_error);
5671 }
5672
5673 /* Build an expression representing an explicit C-style cast to type
5674    TYPE of expression EXPR.  */
5675
5676 tree
5677 cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
5678 {
5679   tree value = expr;
5680   tree result;
5681   bool valid_p;
5682
5683   if (type == error_mark_node || error_operand_p (expr))
5684     return error_mark_node;
5685
5686   if (processing_template_decl)
5687     {
5688       tree t = build_min (CAST_EXPR, type,
5689                           tree_cons (NULL_TREE, value, NULL_TREE));
5690       /* We don't know if it will or will not have side effects.  */
5691       TREE_SIDE_EFFECTS (t) = 1;
5692       return convert_from_reference (t);
5693     }
5694
5695   /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5696      'Class') should always be retained, because this information aids
5697      in method lookup.  */
5698   if (objc_is_object_ptr (type)
5699       && objc_is_object_ptr (TREE_TYPE (expr)))
5700     return build_nop (type, expr);
5701
5702   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5703      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5704   if (TREE_CODE (type) != REFERENCE_TYPE
5705       && TREE_CODE (value) == NOP_EXPR
5706       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5707     value = TREE_OPERAND (value, 0);
5708
5709   if (TREE_CODE (type) == ARRAY_TYPE)
5710     {
5711       /* Allow casting from T1* to T2[] because Cfront allows it.
5712          NIHCL uses it. It is not valid ISO C++ however.  */
5713       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5714         {
5715           if (complain & tf_error)
5716             permerror (input_location, "ISO C++ forbids casting to an array type %qT", type);
5717           else
5718             return error_mark_node;
5719           type = build_pointer_type (TREE_TYPE (type));
5720         }
5721       else
5722         {
5723           if (complain & tf_error)
5724             error ("ISO C++ forbids casting to an array type %qT", type);
5725           return error_mark_node;
5726         }
5727     }
5728
5729   if (TREE_CODE (type) == FUNCTION_TYPE
5730       || TREE_CODE (type) == METHOD_TYPE)
5731     {
5732       if (complain & tf_error)
5733         error ("invalid cast to function type %qT", type);
5734       return error_mark_node;
5735     }
5736
5737   /* A C-style cast can be a const_cast.  */
5738   result = build_const_cast_1 (type, value, /*complain=*/false,
5739                                &valid_p);
5740   if (valid_p)
5741     return result;
5742
5743   /* Or a static cast.  */
5744   result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5745                                 &valid_p, complain);
5746   /* Or a reinterpret_cast.  */
5747   if (!valid_p)
5748     result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5749                                        &valid_p, complain);
5750   /* The static_cast or reinterpret_cast may be followed by a
5751      const_cast.  */
5752   if (valid_p
5753       /* A valid cast may result in errors if, for example, a
5754          conversion to am ambiguous base class is required.  */
5755       && !error_operand_p (result))
5756     {
5757       tree result_type;
5758
5759       /* Non-class rvalues always have cv-unqualified type.  */
5760       if (!CLASS_TYPE_P (type))
5761         type = TYPE_MAIN_VARIANT (type);
5762       result_type = TREE_TYPE (result);
5763       if (!CLASS_TYPE_P (result_type))
5764         result_type = TYPE_MAIN_VARIANT (result_type);
5765       /* If the type of RESULT does not match TYPE, perform a
5766          const_cast to make it match.  If the static_cast or
5767          reinterpret_cast succeeded, we will differ by at most
5768          cv-qualification, so the follow-on const_cast is guaranteed
5769          to succeed.  */
5770       if (!same_type_p (non_reference (type), non_reference (result_type)))
5771         {
5772           result = build_const_cast_1 (type, result, false, &valid_p);
5773           gcc_assert (valid_p);
5774         }
5775       return result;
5776     }
5777
5778   return error_mark_node;
5779 }
5780 \f
5781 /* For use from the C common bits.  */
5782 tree
5783 build_modify_expr (location_t location ATTRIBUTE_UNUSED,
5784                    tree lhs, enum tree_code modifycode, tree rhs)
5785 {
5786   return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
5787 }
5788
5789 /* Build an assignment expression of lvalue LHS from value RHS.
5790    MODIFYCODE is the code for a binary operator that we use
5791    to combine the old value of LHS with RHS to get the new value.
5792    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5793
5794    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5795
5796 tree
5797 cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
5798                       tsubst_flags_t complain)
5799 {
5800   tree result;
5801   tree newrhs = rhs;
5802   tree lhstype = TREE_TYPE (lhs);
5803   tree olhstype = lhstype;
5804   bool plain_assign = (modifycode == NOP_EXPR);
5805
5806   /* Avoid duplicate error messages from operands that had errors.  */
5807   if (error_operand_p (lhs) || error_operand_p (rhs))
5808     return error_mark_node;
5809
5810   /* Handle control structure constructs used as "lvalues".  */
5811   switch (TREE_CODE (lhs))
5812     {
5813       /* Handle --foo = 5; as these are valid constructs in C++.  */
5814     case PREDECREMENT_EXPR:
5815     case PREINCREMENT_EXPR:
5816       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5817         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5818                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5819                       TREE_OPERAND (lhs, 1));
5820       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0),
5821                                      modifycode, rhs, complain);
5822       if (newrhs == error_mark_node)
5823         return error_mark_node;
5824       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5825
5826       /* Handle (a, b) used as an "lvalue".  */
5827     case COMPOUND_EXPR:
5828       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1),
5829                                      modifycode, rhs, complain);
5830       if (newrhs == error_mark_node)
5831         return error_mark_node;
5832       return build2 (COMPOUND_EXPR, lhstype,
5833                      TREE_OPERAND (lhs, 0), newrhs);
5834
5835     case MODIFY_EXPR:
5836       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5837         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5838                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5839                       TREE_OPERAND (lhs, 1));
5840       newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs,
5841                                      complain);
5842       if (newrhs == error_mark_node)
5843         return error_mark_node;
5844       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5845
5846     case MIN_EXPR:
5847     case MAX_EXPR:
5848       /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5849          when neither operand has side-effects.  */
5850       if (!lvalue_or_else (lhs, lv_assign, complain))
5851         return error_mark_node;
5852
5853       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5854                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5855
5856       lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5857                     build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5858                             boolean_type_node,
5859                             TREE_OPERAND (lhs, 0),
5860                             TREE_OPERAND (lhs, 1)),
5861                     TREE_OPERAND (lhs, 0),
5862                     TREE_OPERAND (lhs, 1));
5863       /* Fall through.  */
5864
5865       /* Handle (a ? b : c) used as an "lvalue".  */
5866     case COND_EXPR:
5867       {
5868         /* Produce (a ? (b = rhs) : (c = rhs))
5869            except that the RHS goes through a save-expr
5870            so the code to compute it is only emitted once.  */
5871         tree cond;
5872         tree preeval = NULL_TREE;
5873
5874         if (VOID_TYPE_P (TREE_TYPE (rhs)))
5875           {
5876             if (complain & tf_error)
5877               error ("void value not ignored as it ought to be");
5878             return error_mark_node;
5879           }
5880
5881         rhs = stabilize_expr (rhs, &preeval);
5882
5883         /* Check this here to avoid odd errors when trying to convert
5884            a throw to the type of the COND_EXPR.  */
5885         if (!lvalue_or_else (lhs, lv_assign, complain))
5886           return error_mark_node;
5887
5888         cond = build_conditional_expr
5889           (TREE_OPERAND (lhs, 0),
5890            cp_build_modify_expr (TREE_OPERAND (lhs, 1),
5891                                  modifycode, rhs, complain),
5892            cp_build_modify_expr (TREE_OPERAND (lhs, 2),
5893                                  modifycode, rhs, complain),
5894            complain);
5895
5896         if (cond == error_mark_node)
5897           return cond;
5898         /* Make sure the code to compute the rhs comes out
5899            before the split.  */
5900         if (preeval)
5901           cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5902         return cond;
5903       }
5904
5905     default:
5906       break;
5907     }
5908
5909   if (modifycode == INIT_EXPR)
5910     {
5911       if (TREE_CODE (rhs) == CONSTRUCTOR)
5912         {
5913           if (! same_type_p (TREE_TYPE (rhs), lhstype))
5914             /* Call convert to generate an error; see PR 11063.  */
5915             rhs = convert (lhstype, rhs);
5916           result = build2 (INIT_EXPR, lhstype, lhs, rhs);
5917           TREE_SIDE_EFFECTS (result) = 1;
5918           return result;
5919         }
5920       else if (! MAYBE_CLASS_TYPE_P (lhstype))
5921         /* Do the default thing.  */;
5922       else
5923         {
5924           result = build_special_member_call (lhs, complete_ctor_identifier,
5925                                               build_tree_list (NULL_TREE, rhs),
5926                                               lhstype, LOOKUP_NORMAL,
5927                                               complain);
5928           if (result == NULL_TREE)
5929             return error_mark_node;
5930           return result;
5931         }
5932     }
5933   else
5934     {
5935       lhs = require_complete_type (lhs);
5936       if (lhs == error_mark_node)
5937         return error_mark_node;
5938
5939       if (modifycode == NOP_EXPR)
5940         {
5941           /* `operator=' is not an inheritable operator.  */
5942           if (! MAYBE_CLASS_TYPE_P (lhstype))
5943             /* Do the default thing.  */;
5944           else
5945             {
5946               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5947                                      lhs, rhs, make_node (NOP_EXPR),
5948                                      /*overloaded_p=*/NULL,
5949                                      complain);
5950               if (result == NULL_TREE)
5951                 return error_mark_node;
5952               return result;
5953             }
5954           lhstype = olhstype;
5955         }
5956       else
5957         {
5958           /* A binary op has been requested.  Combine the old LHS
5959              value with the RHS producing the value we should actually
5960              store into the LHS.  */
5961           gcc_assert (!((TREE_CODE (lhstype) == REFERENCE_TYPE
5962                          && MAYBE_CLASS_TYPE_P (TREE_TYPE (lhstype)))
5963                         || MAYBE_CLASS_TYPE_P (lhstype)));
5964
5965           lhs = stabilize_reference (lhs);
5966           newrhs = cp_build_binary_op (input_location,
5967                                        modifycode, lhs, rhs,
5968                                        complain);
5969           if (newrhs == error_mark_node)
5970             {
5971               if (complain & tf_error)
5972                 error ("  in evaluation of %<%Q(%#T, %#T)%>", modifycode,
5973                        TREE_TYPE (lhs), TREE_TYPE (rhs));
5974               return error_mark_node;
5975             }
5976
5977           /* Now it looks like a plain assignment.  */
5978           modifycode = NOP_EXPR;
5979         }
5980       gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
5981       gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
5982     }
5983
5984   /* The left-hand side must be an lvalue.  */
5985   if (!lvalue_or_else (lhs, lv_assign, complain))
5986     return error_mark_node;
5987
5988   /* Warn about modifying something that is `const'.  Don't warn if
5989      this is initialization.  */
5990   if (modifycode != INIT_EXPR
5991       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5992           /* Functions are not modifiable, even though they are
5993              lvalues.  */
5994           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5995           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5996           /* If it's an aggregate and any field is const, then it is
5997              effectively const.  */
5998           || (CLASS_TYPE_P (lhstype)
5999               && C_TYPE_FIELDS_READONLY (lhstype))))
6000     {
6001       if (complain & tf_error)
6002         readonly_error (lhs, "assignment");
6003       else
6004         return error_mark_node;
6005     }
6006
6007   /* If storing into a structure or union member, it may have been given a
6008      lowered bitfield type.  We need to convert to the declared type first,
6009      so retrieve it now.  */
6010
6011   olhstype = unlowered_expr_type (lhs);
6012
6013   /* Convert new value to destination type.  */
6014
6015   if (TREE_CODE (lhstype) == ARRAY_TYPE)
6016     {
6017       int from_array;
6018
6019       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
6020                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
6021         {
6022           if (complain & tf_error)
6023             error ("incompatible types in assignment of %qT to %qT",
6024                    TREE_TYPE (rhs), lhstype);
6025           return error_mark_node;
6026         }
6027
6028       /* Allow array assignment in compiler-generated code.  */
6029       if (!current_function_decl || !DECL_ARTIFICIAL (current_function_decl))
6030         {
6031           /* This routine is used for both initialization and assignment.
6032              Make sure the diagnostic message differentiates the context.  */
6033           if (complain & tf_error)
6034             {
6035               if (modifycode == INIT_EXPR)
6036                 error ("array used as initializer");
6037               else
6038                 error ("invalid array assignment");
6039             }
6040           return error_mark_node;
6041         }
6042
6043       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
6044                    ? 1 + (modifycode != INIT_EXPR): 0;
6045       return build_vec_init (lhs, NULL_TREE, newrhs,
6046                              /*explicit_value_init_p=*/false,
6047                              from_array, complain);
6048     }
6049
6050   if (modifycode == INIT_EXPR)
6051     newrhs = convert_for_initialization (lhs, olhstype, newrhs, LOOKUP_NORMAL,
6052                                          "initialization", NULL_TREE, 0,
6053                                          complain);
6054   else
6055     newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
6056                                      NULL_TREE, 0, complain);
6057
6058   if (!same_type_p (lhstype, olhstype))
6059     newrhs = cp_convert_and_check (lhstype, newrhs);
6060
6061   if (modifycode != INIT_EXPR)
6062     {
6063       if (TREE_CODE (newrhs) == CALL_EXPR
6064           && TYPE_NEEDS_CONSTRUCTING (lhstype))
6065         newrhs = build_cplus_new (lhstype, newrhs);
6066
6067       /* Can't initialize directly from a TARGET_EXPR, since that would
6068          cause the lhs to be constructed twice, and possibly result in
6069          accidental self-initialization.  So we force the TARGET_EXPR to be
6070          expanded without a target.  */
6071       if (TREE_CODE (newrhs) == TARGET_EXPR)
6072         newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
6073                          TREE_OPERAND (newrhs, 0));
6074     }
6075
6076   if (newrhs == error_mark_node)
6077     return error_mark_node;
6078
6079   if (c_dialect_objc () && flag_objc_gc)
6080     {
6081       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6082
6083       if (result)
6084         return result;
6085     }
6086
6087   result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
6088                    lhstype, lhs, newrhs);
6089
6090   TREE_SIDE_EFFECTS (result) = 1;
6091   if (!plain_assign)
6092     TREE_NO_WARNING (result) = 1;
6093
6094   return result;
6095 }
6096
6097 tree
6098 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
6099                      tsubst_flags_t complain)
6100 {
6101   if (processing_template_decl)
6102     return build_min_nt (MODOP_EXPR, lhs,
6103                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
6104
6105   if (modifycode != NOP_EXPR)
6106     {
6107       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
6108                                 make_node (modifycode),
6109                                 /*overloaded_p=*/NULL,
6110                                 complain);
6111       if (rval)
6112         {
6113           TREE_NO_WARNING (rval) = 1;
6114           return rval;
6115         }
6116     }
6117   return cp_build_modify_expr (lhs, modifycode, rhs, complain);
6118 }
6119
6120 /* Helper function for get_delta_difference which assumes FROM is a base
6121    class of TO.  Returns a delta for the conversion of pointer-to-member
6122    of FROM to pointer-to-member of TO.  If the conversion is invalid,
6123    returns zero.  If FROM is not a base class of TO, returns NULL_TREE.
6124    If C_CAST_P is true, this conversion is taking place as part of a C-style
6125    cast.  */
6126
6127 static tree
6128 get_delta_difference_1 (tree from, tree to, bool c_cast_p)
6129 {
6130   tree binfo;
6131   base_kind kind;
6132
6133   binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
6134   if (kind == bk_inaccessible || kind == bk_ambig)
6135     {
6136       error ("   in pointer to member function conversion");
6137       return size_zero_node;
6138     }
6139   else if (binfo)
6140     {
6141       if (kind != bk_via_virtual)
6142         return BINFO_OFFSET (binfo);
6143       else
6144         /* FROM is a virtual base class of TO.  Issue an error or warning
6145            depending on whether or not this is a reinterpret cast.  */
6146         {
6147           error ("pointer to member conversion via virtual base %qT",
6148                  BINFO_TYPE (binfo_from_vbase (binfo)));
6149
6150           return size_zero_node;
6151         }
6152       }
6153     else
6154       return NULL_TREE;
6155 }
6156
6157 /* Get difference in deltas for different pointer to member function
6158    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
6159    the conversion is invalid, the constant is zero.  If
6160    ALLOW_INVERSE_P is true, then allow reverse conversions as well.
6161    If C_CAST_P is true this conversion is taking place as part of a
6162    C-style cast.
6163
6164    Note that the naming of FROM and TO is kind of backwards; the return
6165    value is what we add to a TO in order to get a FROM.  They are named
6166    this way because we call this function to find out how to convert from
6167    a pointer to member of FROM to a pointer to member of TO.  */
6168
6169 static tree
6170 get_delta_difference (tree from, tree to,
6171                       bool allow_inverse_p,
6172                       bool c_cast_p)
6173 {
6174   tree result;
6175
6176   if (same_type_ignoring_top_level_qualifiers_p (from, to))
6177     /* Pointer to member of incomplete class is permitted*/
6178     result = size_zero_node;
6179   else
6180     result = get_delta_difference_1 (from, to, c_cast_p);
6181
6182   if (!result)
6183   {
6184     if (!allow_inverse_p)
6185       {
6186         error_not_base_type (from, to);
6187         error ("   in pointer to member conversion");
6188         result = size_zero_node;
6189       }
6190     else
6191       {
6192         result = get_delta_difference_1 (to, from, c_cast_p);
6193
6194         if (result)
6195           result = size_diffop (size_zero_node, result);
6196         else
6197           {
6198             error_not_base_type (from, to);
6199             error ("   in pointer to member conversion");
6200             result = size_zero_node;
6201           }
6202       }
6203   }
6204
6205   return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
6206                                                       result));
6207 }
6208
6209 /* Return a constructor for the pointer-to-member-function TYPE using
6210    the other components as specified.  */
6211
6212 tree
6213 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
6214 {
6215   tree u = NULL_TREE;
6216   tree delta_field;
6217   tree pfn_field;
6218   VEC(constructor_elt, gc) *v;
6219
6220   /* Pull the FIELD_DECLs out of the type.  */
6221   pfn_field = TYPE_FIELDS (type);
6222   delta_field = TREE_CHAIN (pfn_field);
6223
6224   /* Make sure DELTA has the type we want.  */
6225   delta = convert_and_check (delta_type_node, delta);
6226
6227   /* Convert to the correct target type if necessary.  */
6228   pfn = fold_convert (TREE_TYPE (pfn_field), pfn);
6229
6230   /* Finish creating the initializer.  */
6231   v = VEC_alloc(constructor_elt, gc, 2);
6232   CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
6233   CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
6234   u = build_constructor (type, v);
6235   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
6236   TREE_STATIC (u) = (TREE_CONSTANT (u)
6237                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
6238                          != NULL_TREE)
6239                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
6240                          != NULL_TREE));
6241   return u;
6242 }
6243
6244 /* Build a constructor for a pointer to member function.  It can be
6245    used to initialize global variables, local variable, or used
6246    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
6247    want to be.
6248
6249    If FORCE is nonzero, then force this conversion, even if
6250    we would rather not do it.  Usually set when using an explicit
6251    cast.  A C-style cast is being processed iff C_CAST_P is true.
6252
6253    Return error_mark_node, if something goes wrong.  */
6254
6255 tree
6256 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
6257 {
6258   tree fn;
6259   tree pfn_type;
6260   tree to_type;
6261
6262   if (error_operand_p (pfn))
6263     return error_mark_node;
6264
6265   pfn_type = TREE_TYPE (pfn);
6266   to_type = build_ptrmemfunc_type (type);
6267
6268   /* Handle multiple conversions of pointer to member functions.  */
6269   if (TYPE_PTRMEMFUNC_P (pfn_type))
6270     {
6271       tree delta = NULL_TREE;
6272       tree npfn = NULL_TREE;
6273       tree n;
6274
6275       if (!force
6276           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
6277         error ("invalid conversion to type %qT from type %qT",
6278                to_type, pfn_type);
6279
6280       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
6281                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
6282                                 force,
6283                                 c_cast_p);
6284
6285       /* We don't have to do any conversion to convert a
6286          pointer-to-member to its own type.  But, we don't want to
6287          just return a PTRMEM_CST if there's an explicit cast; that
6288          cast should make the expression an invalid template argument.  */
6289       if (TREE_CODE (pfn) != PTRMEM_CST)
6290         {
6291           if (same_type_p (to_type, pfn_type))
6292             return pfn;
6293           else if (integer_zerop (n))
6294             return build_reinterpret_cast (to_type, pfn,
6295                                            tf_warning_or_error);
6296         }
6297
6298       if (TREE_SIDE_EFFECTS (pfn))
6299         pfn = save_expr (pfn);
6300
6301       /* Obtain the function pointer and the current DELTA.  */
6302       if (TREE_CODE (pfn) == PTRMEM_CST)
6303         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
6304       else
6305         {
6306           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
6307           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
6308         }
6309
6310       /* Just adjust the DELTA field.  */
6311       gcc_assert  (same_type_ignoring_top_level_qualifiers_p
6312                    (TREE_TYPE (delta), ptrdiff_type_node));
6313       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
6314         n = cp_build_binary_op (input_location,
6315                                 LSHIFT_EXPR, n, integer_one_node,
6316                                 tf_warning_or_error);
6317       delta = cp_build_binary_op (input_location,
6318                                   PLUS_EXPR, delta, n, tf_warning_or_error);
6319       return build_ptrmemfunc1 (to_type, delta, npfn);
6320     }
6321
6322   /* Handle null pointer to member function conversions.  */
6323   if (integer_zerop (pfn))
6324     {
6325       pfn = build_c_cast (type, integer_zero_node);
6326       return build_ptrmemfunc1 (to_type,
6327                                 integer_zero_node,
6328                                 pfn);
6329     }
6330
6331   if (type_unknown_p (pfn))
6332     return instantiate_type (type, pfn, tf_warning_or_error);
6333
6334   fn = TREE_OPERAND (pfn, 0);
6335   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
6336               /* In a template, we will have preserved the
6337                  OFFSET_REF.  */
6338               || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
6339   return make_ptrmem_cst (to_type, fn);
6340 }
6341
6342 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
6343    given by CST.
6344
6345    ??? There is no consistency as to the types returned for the above
6346    values.  Some code acts as if it were a sizetype and some as if it were
6347    integer_type_node.  */
6348
6349 void
6350 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
6351 {
6352   tree type = TREE_TYPE (cst);
6353   tree fn = PTRMEM_CST_MEMBER (cst);
6354   tree ptr_class, fn_class;
6355
6356   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
6357
6358   /* The class that the function belongs to.  */
6359   fn_class = DECL_CONTEXT (fn);
6360
6361   /* The class that we're creating a pointer to member of.  */
6362   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
6363
6364   /* First, calculate the adjustment to the function's class.  */
6365   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
6366                                  /*c_cast_p=*/0);
6367
6368   if (!DECL_VIRTUAL_P (fn))
6369     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
6370   else
6371     {
6372       /* If we're dealing with a virtual function, we have to adjust 'this'
6373          again, to point to the base which provides the vtable entry for
6374          fn; the call will do the opposite adjustment.  */
6375       tree orig_class = DECL_CONTEXT (fn);
6376       tree binfo = binfo_or_else (orig_class, fn_class);
6377       *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6378                        *delta, BINFO_OFFSET (binfo));
6379       *delta = fold_if_not_in_template (*delta);
6380
6381       /* We set PFN to the vtable offset at which the function can be
6382          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
6383          case delta is shifted left, and then incremented).  */
6384       *pfn = DECL_VINDEX (fn);
6385       *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
6386                      TYPE_SIZE_UNIT (vtable_entry_type));
6387       *pfn = fold_if_not_in_template (*pfn);
6388
6389       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
6390         {
6391         case ptrmemfunc_vbit_in_pfn:
6392           *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
6393                          integer_one_node);
6394           *pfn = fold_if_not_in_template (*pfn);
6395           break;
6396
6397         case ptrmemfunc_vbit_in_delta:
6398           *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
6399                            *delta, integer_one_node);
6400           *delta = fold_if_not_in_template (*delta);
6401           *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
6402                            *delta, integer_one_node);
6403           *delta = fold_if_not_in_template (*delta);
6404           break;
6405
6406         default:
6407           gcc_unreachable ();
6408         }
6409
6410       *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
6411       *pfn = fold_if_not_in_template (*pfn);
6412     }
6413 }
6414
6415 /* Return an expression for PFN from the pointer-to-member function
6416    given by T.  */
6417
6418 static tree
6419 pfn_from_ptrmemfunc (tree t)
6420 {
6421   if (TREE_CODE (t) == PTRMEM_CST)
6422     {
6423       tree delta;
6424       tree pfn;
6425
6426       expand_ptrmemfunc_cst (t, &delta, &pfn);
6427       if (pfn)
6428         return pfn;
6429     }
6430
6431   return build_ptrmemfunc_access_expr (t, pfn_identifier);
6432 }
6433
6434 /* Return an expression for DELTA from the pointer-to-member function
6435    given by T.  */
6436
6437 static tree
6438 delta_from_ptrmemfunc (tree t)
6439 {
6440   if (TREE_CODE (t) == PTRMEM_CST)
6441     {
6442       tree delta;
6443       tree pfn;
6444
6445       expand_ptrmemfunc_cst (t, &delta, &pfn);
6446       if (delta)
6447         return delta;
6448     }
6449
6450   return build_ptrmemfunc_access_expr (t, delta_identifier);
6451 }
6452
6453 /* Convert value RHS to type TYPE as preparation for an assignment to
6454    an lvalue of type TYPE.  ERRTYPE is a string to use in error
6455    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
6456    are doing the conversion in order to pass the PARMNUMth argument of
6457    FNDECL.  */
6458
6459 static tree
6460 convert_for_assignment (tree type, tree rhs,
6461                         const char *errtype, tree fndecl, int parmnum,
6462                         tsubst_flags_t complain)
6463 {
6464   tree rhstype;
6465   enum tree_code coder;
6466
6467   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
6468   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
6469     rhs = TREE_OPERAND (rhs, 0);
6470
6471   rhstype = TREE_TYPE (rhs);
6472   coder = TREE_CODE (rhstype);
6473
6474   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6475       && vector_types_convertible_p (type, rhstype, true))
6476     return convert (type, rhs);
6477
6478   if (rhs == error_mark_node || rhstype == error_mark_node)
6479     return error_mark_node;
6480   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6481     return error_mark_node;
6482
6483   /* The RHS of an assignment cannot have void type.  */
6484   if (coder == VOID_TYPE)
6485     {
6486       if (complain & tf_error)
6487         error ("void value not ignored as it ought to be");
6488       return error_mark_node;
6489     }
6490
6491   /* Simplify the RHS if possible.  */
6492   if (TREE_CODE (rhs) == CONST_DECL)
6493     rhs = DECL_INITIAL (rhs);
6494
6495   if (c_dialect_objc ())
6496     {
6497       int parmno;
6498       tree rname = fndecl;
6499
6500       if (!strcmp (errtype, "assignment"))
6501         parmno = -1;
6502       else if (!strcmp (errtype, "initialization"))
6503         parmno = -2;
6504       else
6505         {
6506           tree selector = objc_message_selector ();
6507
6508           parmno = parmnum;
6509
6510           if (selector && parmno > 1)
6511             {
6512               rname = selector;
6513               parmno -= 1;
6514             }
6515         }
6516
6517       if (objc_compare_types (type, rhstype, parmno, rname))
6518         return convert (type, rhs);
6519     }
6520
6521   /* [expr.ass]
6522
6523      The expression is implicitly converted (clause _conv_) to the
6524      cv-unqualified type of the left operand.
6525
6526      We allow bad conversions here because by the time we get to this point
6527      we are committed to doing the conversion.  If we end up doing a bad
6528      conversion, convert_like will complain.  */
6529   if (!can_convert_arg_bad (type, rhstype, rhs))
6530     {
6531       /* When -Wno-pmf-conversions is use, we just silently allow
6532          conversions from pointers-to-members to plain pointers.  If
6533          the conversion doesn't work, cp_convert will complain.  */
6534       if (!warn_pmf2ptr
6535           && TYPE_PTR_P (type)
6536           && TYPE_PTRMEMFUNC_P (rhstype))
6537         rhs = cp_convert (strip_top_quals (type), rhs);
6538       else
6539         {
6540           if (complain & tf_error)
6541             {
6542               /* If the right-hand side has unknown type, then it is an
6543                  overloaded function.  Call instantiate_type to get error
6544                  messages.  */
6545               if (rhstype == unknown_type_node)
6546                 instantiate_type (type, rhs, tf_warning_or_error);
6547               else if (fndecl)
6548                 error ("cannot convert %qT to %qT for argument %qP to %qD",
6549                        rhstype, type, parmnum, fndecl);
6550               else
6551                 error ("cannot convert %qT to %qT in %s", rhstype, type,
6552                        errtype);
6553             }
6554           return error_mark_node;
6555         }
6556     }
6557   if (warn_missing_format_attribute)
6558     {
6559       const enum tree_code codel = TREE_CODE (type);
6560       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6561           && coder == codel
6562           && check_missing_format_attribute (type, rhstype)
6563           && (complain & tf_warning))
6564         warning (OPT_Wmissing_format_attribute,
6565                  "%s might be a candidate for a format attribute",
6566                  errtype);
6567     }
6568
6569   /* If -Wparentheses, warn about a = b = c when a has type bool and b
6570      does not.  */
6571   if (warn_parentheses
6572       && type == boolean_type_node
6573       && TREE_CODE (rhs) == MODIFY_EXPR
6574       && !TREE_NO_WARNING (rhs)
6575       && TREE_TYPE (rhs) != boolean_type_node
6576       && (complain & tf_warning))
6577     {
6578       warning (OPT_Wparentheses,
6579                "suggest parentheses around assignment used as truth value");
6580       TREE_NO_WARNING (rhs) = 1;
6581     }
6582
6583   return perform_implicit_conversion (strip_top_quals (type), rhs, complain);
6584 }
6585
6586 /* Convert RHS to be of type TYPE.
6587    If EXP is nonzero, it is the target of the initialization.
6588    ERRTYPE is a string to use in error messages.
6589
6590    Two major differences between the behavior of
6591    `convert_for_assignment' and `convert_for_initialization'
6592    are that references are bashed in the former, while
6593    copied in the latter, and aggregates are assigned in
6594    the former (operator=) while initialized in the
6595    latter (X(X&)).
6596
6597    If using constructor make sure no conversion operator exists, if one does
6598    exist, an ambiguity exists.
6599
6600    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
6601
6602 tree
6603 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
6604                             const char *errtype, tree fndecl, int parmnum,
6605                             tsubst_flags_t complain)
6606 {
6607   enum tree_code codel = TREE_CODE (type);
6608   tree rhstype;
6609   enum tree_code coder;
6610
6611   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6612      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
6613   if (TREE_CODE (rhs) == NOP_EXPR
6614       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6615       && codel != REFERENCE_TYPE)
6616     rhs = TREE_OPERAND (rhs, 0);
6617
6618   if (type == error_mark_node
6619       || rhs == error_mark_node
6620       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6621     return error_mark_node;
6622
6623   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6624        && TREE_CODE (type) != ARRAY_TYPE
6625        && (TREE_CODE (type) != REFERENCE_TYPE
6626            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6627       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6628           && (TREE_CODE (type) != REFERENCE_TYPE
6629               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6630       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6631     rhs = decay_conversion (rhs);
6632
6633   rhstype = TREE_TYPE (rhs);
6634   coder = TREE_CODE (rhstype);
6635
6636   if (coder == ERROR_MARK)
6637     return error_mark_node;
6638
6639   /* We accept references to incomplete types, so we can
6640      return here before checking if RHS is of complete type.  */
6641
6642   if (codel == REFERENCE_TYPE)
6643     {
6644       /* This should eventually happen in convert_arguments.  */
6645       int savew = 0, savee = 0;
6646
6647       if (fndecl)
6648         savew = warningcount, savee = errorcount;
6649       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
6650                                   /*cleanup=*/NULL);
6651       if (fndecl)
6652         {
6653           if (warningcount > savew)
6654             warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
6655           else if (errorcount > savee)
6656             error ("in passing argument %P of %q+D", parmnum, fndecl);
6657         }
6658       return rhs;
6659     }
6660
6661   if (exp != 0)
6662     exp = require_complete_type (exp);
6663   if (exp == error_mark_node)
6664     return error_mark_node;
6665
6666   rhstype = non_reference (rhstype);
6667
6668   type = complete_type (type);
6669
6670   if (MAYBE_CLASS_TYPE_P (type))
6671     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6672
6673   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum,
6674                                  complain);
6675 }
6676 \f
6677 /* If RETVAL is the address of, or a reference to, a local variable or
6678    temporary give an appropriate warning.  */
6679
6680 static void
6681 maybe_warn_about_returning_address_of_local (tree retval)
6682 {
6683   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6684   tree whats_returned = retval;
6685
6686   for (;;)
6687     {
6688       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6689         whats_returned = TREE_OPERAND (whats_returned, 1);
6690       else if (CONVERT_EXPR_P (whats_returned)
6691                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR)
6692         whats_returned = TREE_OPERAND (whats_returned, 0);
6693       else
6694         break;
6695     }
6696
6697   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6698     return;
6699   whats_returned = TREE_OPERAND (whats_returned, 0);
6700
6701   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6702     {
6703       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6704           || TREE_CODE (whats_returned) == TARGET_EXPR)
6705         {
6706           warning (0, "returning reference to temporary");
6707           return;
6708         }
6709       if (TREE_CODE (whats_returned) == VAR_DECL
6710           && DECL_NAME (whats_returned)
6711           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6712         {
6713           warning (0, "reference to non-lvalue returned");
6714           return;
6715         }
6716     }
6717
6718   while (TREE_CODE (whats_returned) == COMPONENT_REF
6719          || TREE_CODE (whats_returned) == ARRAY_REF)
6720     whats_returned = TREE_OPERAND (whats_returned, 0);
6721
6722   if (DECL_P (whats_returned)
6723       && DECL_NAME (whats_returned)
6724       && DECL_FUNCTION_SCOPE_P (whats_returned)
6725       && !(TREE_STATIC (whats_returned)
6726            || TREE_PUBLIC (whats_returned)))
6727     {
6728       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6729         warning (0, "reference to local variable %q+D returned",
6730                  whats_returned);
6731       else
6732         warning (0, "address of local variable %q+D returned",
6733                  whats_returned);
6734       return;
6735     }
6736 }
6737
6738 /* Check that returning RETVAL from the current function is valid.
6739    Return an expression explicitly showing all conversions required to
6740    change RETVAL into the function return type, and to assign it to
6741    the DECL_RESULT for the function.  Set *NO_WARNING to true if
6742    code reaches end of non-void function warning shouldn't be issued
6743    on this RETURN_EXPR.  */
6744
6745 tree
6746 check_return_expr (tree retval, bool *no_warning)
6747 {
6748   tree result;
6749   /* The type actually returned by the function, after any
6750      promotions.  */
6751   tree valtype;
6752   int fn_returns_value_p;
6753   bool named_return_value_okay_p;
6754
6755   *no_warning = false;
6756
6757   /* A `volatile' function is one that isn't supposed to return, ever.
6758      (This is a G++ extension, used to get better code for functions
6759      that call the `volatile' function.)  */
6760   if (TREE_THIS_VOLATILE (current_function_decl))
6761     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6762
6763   /* Check for various simple errors.  */
6764   if (DECL_DESTRUCTOR_P (current_function_decl))
6765     {
6766       if (retval)
6767         error ("returning a value from a destructor");
6768       return NULL_TREE;
6769     }
6770   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6771     {
6772       if (in_function_try_handler)
6773         /* If a return statement appears in a handler of the
6774            function-try-block of a constructor, the program is ill-formed.  */
6775         error ("cannot return from a handler of a function-try-block of a constructor");
6776       else if (retval)
6777         /* You can't return a value from a constructor.  */
6778         error ("returning a value from a constructor");
6779       return NULL_TREE;
6780     }
6781
6782   if (processing_template_decl)
6783     {
6784       current_function_returns_value = 1;
6785       if (check_for_bare_parameter_packs (retval))
6786         retval = error_mark_node;
6787       return retval;
6788     }
6789
6790   /* When no explicit return-value is given in a function with a named
6791      return value, the named return value is used.  */
6792   result = DECL_RESULT (current_function_decl);
6793   valtype = TREE_TYPE (result);
6794   gcc_assert (valtype != NULL_TREE);
6795   fn_returns_value_p = !VOID_TYPE_P (valtype);
6796   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6797     retval = result;
6798
6799   /* Check for a return statement with no return value in a function
6800      that's supposed to return a value.  */
6801   if (!retval && fn_returns_value_p)
6802     {
6803       permerror (input_location, "return-statement with no value, in function returning %qT",
6804                  valtype);
6805       /* Clear this, so finish_function won't say that we reach the
6806          end of a non-void function (which we don't, we gave a
6807          return!).  */
6808       current_function_returns_null = 0;
6809       /* And signal caller that TREE_NO_WARNING should be set on the
6810          RETURN_EXPR to avoid control reaches end of non-void function
6811          warnings in tree-cfg.c.  */
6812       *no_warning = true;
6813     }
6814   /* Check for a return statement with a value in a function that
6815      isn't supposed to return a value.  */
6816   else if (retval && !fn_returns_value_p)
6817     {
6818       if (VOID_TYPE_P (TREE_TYPE (retval)))
6819         /* You can return a `void' value from a function of `void'
6820            type.  In that case, we have to evaluate the expression for
6821            its side-effects.  */
6822           finish_expr_stmt (retval);
6823       else
6824         permerror (input_location, "return-statement with a value, in function "
6825                    "returning 'void'");
6826       current_function_returns_null = 1;
6827
6828       /* There's really no value to return, after all.  */
6829       return NULL_TREE;
6830     }
6831   else if (!retval)
6832     /* Remember that this function can sometimes return without a
6833        value.  */
6834     current_function_returns_null = 1;
6835   else
6836     /* Remember that this function did return a value.  */
6837     current_function_returns_value = 1;
6838
6839   /* Check for erroneous operands -- but after giving ourselves a
6840      chance to provide an error about returning a value from a void
6841      function.  */
6842   if (error_operand_p (retval))
6843     {
6844       current_function_return_value = error_mark_node;
6845       return error_mark_node;
6846     }
6847
6848   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6849   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6850        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6851       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6852       && ! flag_check_new
6853       && retval && null_ptr_cst_p (retval))
6854     warning (0, "%<operator new%> must not return NULL unless it is "
6855              "declared %<throw()%> (or -fcheck-new is in effect)");
6856
6857   /* Effective C++ rule 15.  See also start_function.  */
6858   if (warn_ecpp
6859       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6860     {
6861       bool warn = true;
6862
6863       /* The function return type must be a reference to the current
6864         class.  */
6865       if (TREE_CODE (valtype) == REFERENCE_TYPE
6866           && same_type_ignoring_top_level_qualifiers_p
6867               (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6868         {
6869           /* Returning '*this' is obviously OK.  */
6870           if (retval == current_class_ref)
6871             warn = false;
6872           /* If we are calling a function whose return type is the same of
6873              the current class reference, it is ok.  */
6874           else if (TREE_CODE (retval) == INDIRECT_REF
6875                    && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6876             warn = false;
6877         }
6878
6879       if (warn)
6880         warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
6881     }
6882
6883   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6884
6885      [...]      For  a function with a class return type, if the expression
6886      in the return statement is the name of a local  object,  and  the  cv-
6887      unqualified  type  of  the  local  object  is the same as the function
6888      return type, an implementation is permitted to omit creating the  tem-
6889      porary  object  to  hold  the function return value [...]
6890
6891      So, if this is a value-returning function that always returns the same
6892      local variable, remember it.
6893
6894      It might be nice to be more flexible, and choose the first suitable
6895      variable even if the function sometimes returns something else, but
6896      then we run the risk of clobbering the variable we chose if the other
6897      returned expression uses the chosen variable somehow.  And people expect
6898      this restriction, anyway.  (jason 2000-11-19)
6899
6900      See finish_function and finalize_nrv for the rest of this optimization.  */
6901
6902   named_return_value_okay_p =
6903     (retval != NULL_TREE
6904      /* Must be a local, automatic variable.  */
6905      && TREE_CODE (retval) == VAR_DECL
6906      && DECL_CONTEXT (retval) == current_function_decl
6907      && ! TREE_STATIC (retval)
6908      && ! DECL_ANON_UNION_VAR_P (retval)
6909      && (DECL_ALIGN (retval)
6910          >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6911      /* The cv-unqualified type of the returned value must be the
6912         same as the cv-unqualified return type of the
6913         function.  */
6914      && same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
6915                      (TYPE_MAIN_VARIANT
6916                       (TREE_TYPE (TREE_TYPE (current_function_decl)))))
6917      /* And the returned value must be non-volatile.  */
6918      && ! TYPE_VOLATILE (TREE_TYPE (retval)));
6919
6920   if (fn_returns_value_p && flag_elide_constructors)
6921     {
6922       if (named_return_value_okay_p
6923           && (current_function_return_value == NULL_TREE
6924               || current_function_return_value == retval))
6925         current_function_return_value = retval;
6926       else
6927         current_function_return_value = error_mark_node;
6928     }
6929
6930   /* We don't need to do any conversions when there's nothing being
6931      returned.  */
6932   if (!retval)
6933     return NULL_TREE;
6934
6935   /* Do any required conversions.  */
6936   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6937     /* No conversions are required.  */
6938     ;
6939   else
6940     {
6941       /* The type the function is declared to return.  */
6942       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6943       int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
6944
6945       /* The functype's return type will have been set to void, if it
6946          was an incomplete type.  Just treat this as 'return;' */
6947       if (VOID_TYPE_P (functype))
6948         return error_mark_node;
6949
6950       /* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
6951          treated as an rvalue for the purposes of overload resolution to
6952          favor move constructors over copy constructors.  */
6953       if ((cxx_dialect != cxx98)
6954           && named_return_value_okay_p
6955           /* The variable must not have the `volatile' qualifier.  */
6956           && !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
6957           /* The return type must be a class type.  */
6958           && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
6959         flags = flags | LOOKUP_PREFER_RVALUE;
6960
6961       /* First convert the value to the function's return type, then
6962          to the type of return value's location to handle the
6963          case that functype is smaller than the valtype.  */
6964       retval = convert_for_initialization
6965         (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0,
6966          tf_warning_or_error);
6967       retval = convert (valtype, retval);
6968
6969       /* If the conversion failed, treat this just like `return;'.  */
6970       if (retval == error_mark_node)
6971         return retval;
6972       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6973       else if (! cfun->returns_struct
6974                && TREE_CODE (retval) == TARGET_EXPR
6975                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6976         retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6977                          TREE_OPERAND (retval, 0));
6978       else
6979         maybe_warn_about_returning_address_of_local (retval);
6980     }
6981
6982   /* Actually copy the value returned into the appropriate location.  */
6983   if (retval && retval != result)
6984     retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
6985
6986   return retval;
6987 }
6988
6989 \f
6990 /* Returns nonzero if the pointer-type FROM can be converted to the
6991    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6992    then we return nonzero if the pointers are similar, and the
6993    cv-qualification signature of FROM is a proper subset of that of TO.
6994
6995    If CONSTP is positive, then all outer pointers have been
6996    const-qualified.  */
6997
6998 static int
6999 comp_ptr_ttypes_real (tree to, tree from, int constp)
7000 {
7001   bool to_more_cv_qualified = false;
7002   bool is_opaque_pointer = false;
7003
7004   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7005     {
7006       if (TREE_CODE (to) != TREE_CODE (from))
7007         return 0;
7008
7009       if (TREE_CODE (from) == OFFSET_TYPE
7010           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
7011                            TYPE_OFFSET_BASETYPE (to)))
7012         return 0;
7013
7014       /* Const and volatile mean something different for function types,
7015          so the usual checks are not appropriate.  */
7016       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
7017         {
7018           /* In Objective-C++, some types may have been 'volatilized' by
7019              the compiler for EH; when comparing them here, the volatile
7020              qualification must be ignored.  */
7021           bool objc_quals_match = objc_type_quals_match (to, from);
7022
7023           if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
7024             return 0;
7025
7026           if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
7027             {
7028               if (constp == 0)
7029                 return 0;
7030               to_more_cv_qualified = true;
7031             }
7032
7033           if (constp > 0)
7034             constp &= TYPE_READONLY (to);
7035         }
7036
7037       if (TREE_CODE (to) == VECTOR_TYPE)
7038         is_opaque_pointer = vector_targets_convertible_p (to, from);
7039
7040       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
7041         return ((constp >= 0 || to_more_cv_qualified)
7042                 && (is_opaque_pointer
7043                     || same_type_ignoring_top_level_qualifiers_p (to, from)));
7044     }
7045 }
7046
7047 /* When comparing, say, char ** to char const **, this function takes
7048    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
7049    types to this function.  */
7050
7051 int
7052 comp_ptr_ttypes (tree to, tree from)
7053 {
7054   return comp_ptr_ttypes_real (to, from, 1);
7055 }
7056
7057 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
7058    type or inheritance-related types, regardless of cv-quals.  */
7059
7060 int
7061 ptr_reasonably_similar (const_tree to, const_tree from)
7062 {
7063   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7064     {
7065       /* Any target type is similar enough to void.  */
7066       if (TREE_CODE (to) == VOID_TYPE
7067           || TREE_CODE (from) == VOID_TYPE)
7068         return 1;
7069
7070       if (TREE_CODE (to) != TREE_CODE (from))
7071         return 0;
7072
7073       if (TREE_CODE (from) == OFFSET_TYPE
7074           && comptypes (TYPE_OFFSET_BASETYPE (to),
7075                         TYPE_OFFSET_BASETYPE (from),
7076                         COMPARE_BASE | COMPARE_DERIVED))
7077         continue;
7078
7079       if (TREE_CODE (to) == VECTOR_TYPE
7080           && vector_types_convertible_p (to, from, false))
7081         return 1;
7082
7083       if (TREE_CODE (to) == INTEGER_TYPE
7084           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
7085         return 1;
7086
7087       if (TREE_CODE (to) == FUNCTION_TYPE)
7088         return 1;
7089
7090       if (TREE_CODE (to) != POINTER_TYPE)
7091         return comptypes
7092           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
7093            COMPARE_BASE | COMPARE_DERIVED);
7094     }
7095 }
7096
7097 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
7098    pointer-to-member types) are the same, ignoring cv-qualification at
7099    all levels.  */
7100
7101 bool
7102 comp_ptr_ttypes_const (tree to, tree from)
7103 {
7104   bool is_opaque_pointer = false;
7105
7106   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
7107     {
7108       if (TREE_CODE (to) != TREE_CODE (from))
7109         return false;
7110
7111       if (TREE_CODE (from) == OFFSET_TYPE
7112           && same_type_p (TYPE_OFFSET_BASETYPE (from),
7113                           TYPE_OFFSET_BASETYPE (to)))
7114           continue;
7115
7116       if (TREE_CODE (to) == VECTOR_TYPE)
7117         is_opaque_pointer = vector_targets_convertible_p (to, from);
7118
7119       if (TREE_CODE (to) != POINTER_TYPE)
7120         return (is_opaque_pointer
7121                 || same_type_ignoring_top_level_qualifiers_p (to, from));
7122     }
7123 }
7124
7125 /* Returns the type qualifiers for this type, including the qualifiers on the
7126    elements for an array type.  */
7127
7128 int
7129 cp_type_quals (const_tree type)
7130 {
7131   /* This CONST_CAST is okay because strip_array_types returns its
7132      argument unmodified and we assign it to a const_tree.  */
7133   type = strip_array_types (CONST_CAST_TREE(type));
7134   if (type == error_mark_node)
7135     return TYPE_UNQUALIFIED;
7136   return TYPE_QUALS (type);
7137 }
7138
7139 /* Returns nonzero if the TYPE is const from a C++ perspective: look inside
7140    arrays.  */
7141
7142 bool
7143 cp_type_readonly (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   return TYPE_READONLY (type);
7149 }
7150
7151 /* Returns nonzero if the TYPE contains a mutable member.  */
7152
7153 bool
7154 cp_has_mutable_p (const_tree type)
7155 {
7156   /* This CONST_CAST is okay because strip_array_types returns its
7157      argument unmodified and we assign it to a const_tree.  */
7158   type = strip_array_types (CONST_CAST_TREE(type));
7159
7160   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
7161 }
7162
7163 /* Set TREE_READONLY and TREE_VOLATILE on DECL as indicated by the
7164    TYPE_QUALS.  For a VAR_DECL, this may be an optimistic
7165    approximation.  In particular, consider:
7166
7167      int f();
7168      struct S { int i; };
7169      const S s = { f(); }
7170
7171    Here, we will make "s" as TREE_READONLY (because it is declared
7172    "const") -- only to reverse ourselves upon seeing that the
7173    initializer is non-constant.  */
7174
7175 void
7176 cp_apply_type_quals_to_decl (int type_quals, tree decl)
7177 {
7178   tree type = TREE_TYPE (decl);
7179
7180   if (type == error_mark_node)
7181     return;
7182
7183   if (TREE_CODE (type) == FUNCTION_TYPE
7184       && type_quals != TYPE_UNQUALIFIED)
7185     {
7186       /* This was an error in C++98 (cv-qualifiers cannot be added to
7187          a function type), but DR 295 makes the code well-formed by
7188          dropping the extra qualifiers. */
7189       if (pedantic)
7190         {
7191           tree bad_type = build_qualified_type (type, type_quals);
7192           pedwarn (input_location, OPT_pedantic,
7193                    "ignoring %qV qualifiers added to function type %qT",
7194                    bad_type, type);
7195         }
7196
7197       TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
7198       return;
7199     }
7200
7201   /* Avoid setting TREE_READONLY incorrectly.  */
7202   if (/* If the object has a constructor, the constructor may modify
7203          the object.  */
7204       TYPE_NEEDS_CONSTRUCTING (type)
7205       /* If the type isn't complete, we don't know yet if it will need
7206          constructing.  */
7207       || !COMPLETE_TYPE_P (type)
7208       /* If the type has a mutable component, that component might be
7209          modified.  */
7210       || TYPE_HAS_MUTABLE_P (type))
7211     type_quals &= ~TYPE_QUAL_CONST;
7212
7213   c_apply_type_quals_to_decl (type_quals, decl);
7214 }
7215
7216 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
7217    exemplar types such that casting T1 to T2 is casting away constness
7218    if and only if there is no implicit conversion from T1 to T2.  */
7219
7220 static void
7221 casts_away_constness_r (tree *t1, tree *t2)
7222 {
7223   int quals1;
7224   int quals2;
7225
7226   /* [expr.const.cast]
7227
7228      For multi-level pointer to members and multi-level mixed pointers
7229      and pointers to members (conv.qual), the "member" aspect of a
7230      pointer to member level is ignored when determining if a const
7231      cv-qualifier has been cast away.  */
7232   /* [expr.const.cast]
7233
7234      For  two  pointer types:
7235
7236             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
7237             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
7238             K is min(N,M)
7239
7240      casting from X1 to X2 casts away constness if, for a non-pointer
7241      type T there does not exist an implicit conversion (clause
7242      _conv_) from:
7243
7244             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
7245
7246      to
7247
7248             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
7249   if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
7250       || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
7251     {
7252       *t1 = cp_build_qualified_type (void_type_node,
7253                                      cp_type_quals (*t1));
7254       *t2 = cp_build_qualified_type (void_type_node,
7255                                      cp_type_quals (*t2));
7256       return;
7257     }
7258
7259   quals1 = cp_type_quals (*t1);
7260   quals2 = cp_type_quals (*t2);
7261
7262   if (TYPE_PTRMEM_P (*t1))
7263     *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
7264   else
7265     *t1 = TREE_TYPE (*t1);
7266   if (TYPE_PTRMEM_P (*t2))
7267     *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
7268   else
7269     *t2 = TREE_TYPE (*t2);
7270
7271   casts_away_constness_r (t1, t2);
7272   *t1 = build_pointer_type (*t1);
7273   *t2 = build_pointer_type (*t2);
7274   *t1 = cp_build_qualified_type (*t1, quals1);
7275   *t2 = cp_build_qualified_type (*t2, quals2);
7276 }
7277
7278 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
7279    constness.  */
7280
7281 static bool
7282 casts_away_constness (tree t1, tree t2)
7283 {
7284   if (TREE_CODE (t2) == REFERENCE_TYPE)
7285     {
7286       /* [expr.const.cast]
7287
7288          Casting from an lvalue of type T1 to an lvalue of type T2
7289          using a reference cast casts away constness if a cast from an
7290          rvalue of type "pointer to T1" to the type "pointer to T2"
7291          casts away constness.  */
7292       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
7293       return casts_away_constness (build_pointer_type (t1),
7294                                    build_pointer_type (TREE_TYPE (t2)));
7295     }
7296
7297   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
7298     /* [expr.const.cast]
7299
7300        Casting from an rvalue of type "pointer to data member of X
7301        of type T1" to the type "pointer to data member of Y of type
7302        T2" casts away constness if a cast from an rvalue of type
7303        "pointer to T1" to the type "pointer to T2" casts away
7304        constness.  */
7305     return casts_away_constness
7306       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
7307        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
7308
7309   /* Casting away constness is only something that makes sense for
7310      pointer or reference types.  */
7311   if (TREE_CODE (t1) != POINTER_TYPE
7312       || TREE_CODE (t2) != POINTER_TYPE)
7313     return false;
7314
7315   /* Top-level qualifiers don't matter.  */
7316   t1 = TYPE_MAIN_VARIANT (t1);
7317   t2 = TYPE_MAIN_VARIANT (t2);
7318   casts_away_constness_r (&t1, &t2);
7319   if (!can_convert (t2, t1))
7320     return true;
7321
7322   return false;
7323 }
7324
7325 /* If T is a REFERENCE_TYPE return the type to which T refers.
7326    Otherwise, return T itself.  */
7327
7328 tree
7329 non_reference (tree t)
7330 {
7331   if (TREE_CODE (t) == REFERENCE_TYPE)
7332     t = TREE_TYPE (t);
7333   return t;
7334 }
7335
7336
7337 /* Return nonzero if REF is an lvalue valid for this language;
7338    otherwise, print an error message and return zero.  USE says
7339    how the lvalue is being used and so selects the error message.  */
7340
7341 int
7342 lvalue_or_else (const_tree ref, enum lvalue_use use, tsubst_flags_t complain)
7343 {
7344   int win = lvalue_p (ref);
7345
7346   if (!win && (complain & tf_error))
7347     lvalue_error (use);
7348
7349   return win;
7350 }