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