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