gcc/cp/typeck.c

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