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