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