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