gcc/cp/typeck.c

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