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