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