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