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