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       warn_array_subscript_with_type_char (idx);
2257
2258       if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx)))
2259         {
2260           error ("array subscript is not an integer");
2261           return error_mark_node;
2262         }
2263
2264       /* Apply integral promotions *after* noticing character types.
2265          (It is unclear why we do these promotions -- the standard
2266          does not say that we should.  In fact, the natural thing would
2267          seem to be to convert IDX to ptrdiff_t; we're performing
2268          pointer arithmetic.)  */
2269       idx = perform_integral_promotions (idx);
2270
2271       /* An array that is indexed by a non-constant
2272          cannot be stored in a register; we must be able to do
2273          address arithmetic on its address.
2274          Likewise an array of elements of variable size.  */
2275       if (TREE_CODE (idx) != INTEGER_CST
2276           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2277               && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
2278                   != INTEGER_CST)))
2279         {
2280           if (!cxx_mark_addressable (array))
2281             return error_mark_node;
2282         }
2283
2284       /* An array that is indexed by a constant value which is not within
2285          the array bounds cannot be stored in a register either; because we
2286          would get a crash in store_bit_field/extract_bit_field when trying
2287          to access a non-existent part of the register.  */
2288       if (TREE_CODE (idx) == INTEGER_CST
2289           && TYPE_DOMAIN (TREE_TYPE (array))
2290           && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array))))
2291         {
2292           if (!cxx_mark_addressable (array))
2293             return error_mark_node;
2294         }
2295
2296       if (pedantic && !lvalue_p (array))
2297         pedwarn ("ISO C++ forbids subscripting non-lvalue array");
2298
2299       /* Note in C++ it is valid to subscript a `register' array, since
2300          it is valid to take the address of something with that
2301          storage specification.  */
2302       if (extra_warnings)
2303         {
2304           tree foo = array;
2305           while (TREE_CODE (foo) == COMPONENT_REF)
2306             foo = TREE_OPERAND (foo, 0);
2307           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
2308             warning (0, "subscripting array declared %<register%>");
2309         }
2310
2311       type = TREE_TYPE (TREE_TYPE (array));
2312       rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE);
2313       /* Array ref is const/volatile if the array elements are
2314          or if the array is..  */
2315       TREE_READONLY (rval)
2316         |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array));
2317       TREE_SIDE_EFFECTS (rval)
2318         |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array));
2319       TREE_THIS_VOLATILE (rval)
2320         |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array));
2321       return require_complete_type (fold_if_not_in_template (rval));
2322     }
2323
2324   {
2325     tree ar = default_conversion (array);
2326     tree ind = default_conversion (idx);
2327
2328     /* Put the integer in IND to simplify error checking.  */
2329     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
2330       {
2331         tree temp = ar;
2332         ar = ind;
2333         ind = temp;
2334       }
2335
2336     if (ar == error_mark_node)
2337       return ar;
2338
2339     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
2340       {
2341         error ("subscripted value is neither array nor pointer");
2342         return error_mark_node;
2343       }
2344     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
2345       {
2346         error ("array subscript is not an integer");
2347         return error_mark_node;
2348       }
2349
2350     return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
2351                                "array indexing");
2352   }
2353 }
2354 \f
2355 /* Resolve a pointer to member function.  INSTANCE is the object
2356    instance to use, if the member points to a virtual member.
2357
2358    This used to avoid checking for virtual functions if basetype
2359    has no virtual functions, according to an earlier ANSI draft.
2360    With the final ISO C++ rules, such an optimization is
2361    incorrect: A pointer to a derived member can be static_cast
2362    to pointer-to-base-member, as long as the dynamic object
2363    later has the right member.  */
2364
2365 tree
2366 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2367 {
2368   if (TREE_CODE (function) == OFFSET_REF)
2369     function = TREE_OPERAND (function, 1);
2370
2371   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2372     {
2373       tree idx, delta, e1, e2, e3, vtbl, basetype;
2374       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2375
2376       tree instance_ptr = *instance_ptrptr;
2377       tree instance_save_expr = 0;
2378       if (instance_ptr == error_mark_node)
2379         {
2380           if (TREE_CODE (function) == PTRMEM_CST)
2381             {
2382               /* Extracting the function address from a pmf is only
2383                  allowed with -Wno-pmf-conversions. It only works for
2384                  pmf constants.  */
2385               e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2386               e1 = convert (fntype, e1);
2387               return e1;
2388             }
2389           else
2390             {
2391               error ("object missing in use of %qE", function);
2392               return error_mark_node;
2393             }
2394         }
2395
2396       if (TREE_SIDE_EFFECTS (instance_ptr))
2397         instance_ptr = instance_save_expr = save_expr (instance_ptr);
2398
2399       if (TREE_SIDE_EFFECTS (function))
2400         function = save_expr (function);
2401
2402       /* Start by extracting all the information from the PMF itself.  */
2403       e3 = pfn_from_ptrmemfunc (function);
2404       delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2405       idx = build1 (NOP_EXPR, vtable_index_type, e3);
2406       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
2407         {
2408         case ptrmemfunc_vbit_in_pfn:
2409           e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node);
2410           idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
2411           break;
2412
2413         case ptrmemfunc_vbit_in_delta:
2414           e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node);
2415           delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node);
2416           break;
2417
2418         default:
2419           gcc_unreachable ();
2420         }
2421
2422       /* Convert down to the right base before using the instance.  A
2423          special case is that in a pointer to member of class C, C may
2424          be incomplete.  In that case, the function will of course be
2425          a member of C, and no conversion is required.  In fact,
2426          lookup_base will fail in that case, because incomplete
2427          classes do not have BINFOs.  */
2428       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
2429       if (!same_type_ignoring_top_level_qualifiers_p
2430           (basetype, TREE_TYPE (TREE_TYPE (instance_ptr))))
2431         {
2432           basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
2433                                   basetype, ba_check, NULL);
2434           instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype,
2435                                           1);
2436           if (instance_ptr == error_mark_node)
2437             return error_mark_node;
2438         }
2439       /* ...and then the delta in the PMF.  */
2440       instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr),
2441                              instance_ptr, delta);
2442
2443       /* Hand back the adjusted 'this' argument to our caller.  */
2444       *instance_ptrptr = instance_ptr;
2445
2446       /* Next extract the vtable pointer from the object.  */
2447       vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node),
2448                      instance_ptr);
2449       vtbl = build_indirect_ref (vtbl, NULL);
2450
2451       /* Finally, extract the function pointer from the vtable.  */
2452       e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx);
2453       e2 = build_indirect_ref (e2, NULL);
2454       TREE_CONSTANT (e2) = 1;
2455       TREE_INVARIANT (e2) = 1;
2456
2457       /* When using function descriptors, the address of the
2458          vtable entry is treated as a function pointer.  */
2459       if (TARGET_VTABLE_USES_DESCRIPTORS)
2460         e2 = build1 (NOP_EXPR, TREE_TYPE (e2),
2461                      build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1));
2462
2463       TREE_TYPE (e2) = TREE_TYPE (e3);
2464       e1 = build_conditional_expr (e1, e2, e3);
2465
2466       /* Make sure this doesn't get evaluated first inside one of the
2467          branches of the COND_EXPR.  */
2468       if (instance_save_expr)
2469         e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1),
2470                      instance_save_expr, e1);
2471
2472       function = e1;
2473     }
2474   return function;
2475 }
2476
2477 tree
2478 build_function_call (tree function, tree params)
2479 {
2480   tree fntype, fndecl;
2481   tree coerced_params;
2482   tree name = NULL_TREE;
2483   int is_method;
2484   tree original = function;
2485
2486   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2487      expressions, like those used for ObjC messenger dispatches.  */
2488   function = objc_rewrite_function_call (function, params);
2489
2490   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2491      Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context.  */
2492   if (TREE_CODE (function) == NOP_EXPR
2493       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2494     function = TREE_OPERAND (function, 0);
2495
2496   if (TREE_CODE (function) == FUNCTION_DECL)
2497     {
2498       name = DECL_NAME (function);
2499
2500       mark_used (function);
2501       fndecl = function;
2502
2503       /* Convert anything with function type to a pointer-to-function.  */
2504       if (pedantic && DECL_MAIN_P (function))
2505         pedwarn ("ISO C++ forbids calling %<::main%> from within program");
2506
2507       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
2508          (because calling an inline function does not mean the function
2509          needs to be separately compiled).  */
2510
2511       if (DECL_INLINE (function))
2512         function = inline_conversion (function);
2513       else
2514         function = build_addr_func (function);
2515     }
2516   else
2517     {
2518       fndecl = NULL_TREE;
2519
2520       function = build_addr_func (function);
2521     }
2522
2523   if (function == error_mark_node)
2524     return error_mark_node;
2525
2526   fntype = TREE_TYPE (function);
2527
2528   if (TYPE_PTRMEMFUNC_P (fntype))
2529     {
2530       error ("must use %<.*%> or %<->*%> to call pointer-to-member "
2531              "function in %<%E (...)%>",
2532              original);
2533       return error_mark_node;
2534     }
2535
2536   is_method = (TREE_CODE (fntype) == POINTER_TYPE
2537                && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE);
2538
2539   if (!((TREE_CODE (fntype) == POINTER_TYPE
2540          && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)
2541         || is_method
2542         || TREE_CODE (function) == TEMPLATE_ID_EXPR))
2543     {
2544       error ("%qE cannot be used as a function", original);
2545       return error_mark_node;
2546     }
2547
2548   /* fntype now gets the type of function pointed to.  */
2549   fntype = TREE_TYPE (fntype);
2550
2551   /* Convert the parameters to the types declared in the
2552      function prototype, or apply default promotions.  */
2553
2554   coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype),
2555                                       params, fndecl, LOOKUP_NORMAL);
2556   if (coerced_params == error_mark_node)
2557     return error_mark_node;
2558
2559   /* Check for errors in format strings and inappropriately
2560      null parameters.  */
2561
2562   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
2563                             TYPE_ARG_TYPES (fntype));
2564
2565   return build_cxx_call (function, coerced_params);
2566 }
2567 \f
2568 /* Convert the actual parameter expressions in the list VALUES
2569    to the types in the list TYPELIST.
2570    If parmdecls is exhausted, or when an element has NULL as its type,
2571    perform the default conversions.
2572
2573    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
2574
2575    This is also where warnings about wrong number of args are generated.
2576
2577    Return a list of expressions for the parameters as converted.
2578
2579    Both VALUES and the returned value are chains of TREE_LIST nodes
2580    with the elements of the list in the TREE_VALUE slots of those nodes.
2581
2582    In C++, unspecified trailing parameters can be filled in with their
2583    default arguments, if such were specified.  Do so here.  */
2584
2585 static tree
2586 convert_arguments (tree typelist, tree values, tree fndecl, int flags)
2587 {
2588   tree typetail, valtail;
2589   tree result = NULL_TREE;
2590   const char *called_thing = 0;
2591   int i = 0;
2592
2593   /* Argument passing is always copy-initialization.  */
2594   flags |= LOOKUP_ONLYCONVERTING;
2595
2596   if (fndecl)
2597     {
2598       if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
2599         {
2600           if (DECL_NAME (fndecl) == NULL_TREE
2601               || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl)))
2602             called_thing = "constructor";
2603           else
2604             called_thing = "member function";
2605         }
2606       else
2607         called_thing = "function";
2608     }
2609
2610   for (valtail = values, typetail = typelist;
2611        valtail;
2612        valtail = TREE_CHAIN (valtail), i++)
2613     {
2614       tree type = typetail ? TREE_VALUE (typetail) : 0;
2615       tree val = TREE_VALUE (valtail);
2616
2617       if (val == error_mark_node)
2618         return error_mark_node;
2619
2620       if (type == void_type_node)
2621         {
2622           if (fndecl)
2623             {
2624               error ("too many arguments to %s %q+#D", called_thing, fndecl);
2625               error ("at this point in file");
2626             }
2627           else
2628             error ("too many arguments to function");
2629           /* In case anybody wants to know if this argument
2630              list is valid.  */
2631           if (result)
2632             TREE_TYPE (tree_last (result)) = error_mark_node;
2633           break;
2634         }
2635
2636       /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
2637          Strip such NOP_EXPRs, since VAL is used in non-lvalue context.  */
2638       if (TREE_CODE (val) == NOP_EXPR
2639           && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))
2640           && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE))
2641         val = TREE_OPERAND (val, 0);
2642
2643       if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)
2644         {
2645           if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
2646               || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE
2647               || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)
2648             val = decay_conversion (val);
2649         }
2650
2651       if (val == error_mark_node)
2652         return error_mark_node;
2653
2654       if (type != 0)
2655         {
2656           /* Formal parm type is specified by a function prototype.  */
2657           tree parmval;
2658
2659           if (!COMPLETE_TYPE_P (complete_type (type)))
2660             {
2661               if (fndecl)
2662                 error ("parameter %P of %qD has incomplete type %qT",
2663                        i, fndecl, type);
2664               else
2665                 error ("parameter %P has incomplete type %qT", i, type);
2666               parmval = error_mark_node;
2667             }
2668           else
2669             {
2670               parmval = convert_for_initialization
2671                 (NULL_TREE, type, val, flags,
2672                  "argument passing", fndecl, i);
2673               parmval = convert_for_arg_passing (type, parmval);
2674             }
2675
2676           if (parmval == error_mark_node)
2677             return error_mark_node;
2678
2679           result = tree_cons (NULL_TREE, parmval, result);
2680         }
2681       else
2682         {
2683           if (fndecl && DECL_BUILT_IN (fndecl)
2684               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P)
2685             /* Don't do ellipsis conversion for __built_in_constant_p
2686                as this will result in spurious warnings for non-POD
2687                types.  */
2688             val = require_complete_type (val);
2689           else
2690             val = convert_arg_to_ellipsis (val);
2691
2692           result = tree_cons (NULL_TREE, val, result);
2693         }
2694
2695       if (typetail)
2696         typetail = TREE_CHAIN (typetail);
2697     }
2698
2699   if (typetail != 0 && typetail != void_list_node)
2700     {
2701       /* See if there are default arguments that can be used.  */
2702       if (TREE_PURPOSE (typetail)
2703           && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG)
2704         {
2705           for (; typetail != void_list_node; ++i)
2706             {
2707               tree parmval
2708                 = convert_default_arg (TREE_VALUE (typetail),
2709                                        TREE_PURPOSE (typetail),
2710                                        fndecl, i);
2711
2712               if (parmval == error_mark_node)
2713                 return error_mark_node;
2714
2715               result = tree_cons (0, parmval, result);
2716               typetail = TREE_CHAIN (typetail);
2717               /* ends with `...'.  */
2718               if (typetail == NULL_TREE)
2719                 break;
2720             }
2721         }
2722       else
2723         {
2724           if (fndecl)
2725             {
2726               error ("too few arguments to %s %q+#D", called_thing, fndecl);
2727               error ("at this point in file");
2728             }
2729           else
2730             error ("too few arguments to function");
2731           return error_mark_list;
2732         }
2733     }
2734
2735   return nreverse (result);
2736 }
2737 \f
2738 /* Build a binary-operation expression, after performing default
2739    conversions on the operands.  CODE is the kind of expression to build.  */
2740
2741 tree
2742 build_x_binary_op (enum tree_code code, tree arg1, tree arg2,
2743                    bool *overloaded_p)
2744 {
2745   tree orig_arg1;
2746   tree orig_arg2;
2747   tree expr;
2748
2749   orig_arg1 = arg1;
2750   orig_arg2 = arg2;
2751
2752   if (processing_template_decl)
2753     {
2754       if (type_dependent_expression_p (arg1)
2755           || type_dependent_expression_p (arg2))
2756         return build_min_nt (code, arg1, arg2);
2757       arg1 = build_non_dependent_expr (arg1);
2758       arg2 = build_non_dependent_expr (arg2);
2759     }
2760
2761   if (code == DOTSTAR_EXPR)
2762     expr = build_m_component_ref (arg1, arg2);
2763   else
2764     expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE,
2765                          overloaded_p);
2766
2767   if (processing_template_decl && expr != error_mark_node)
2768     return build_min_non_dep (code, expr, orig_arg1, orig_arg2);
2769
2770   return expr;
2771 }
2772
2773 /* Build a binary-operation expression without default conversions.
2774    CODE is the kind of expression to build.
2775    This function differs from `build' in several ways:
2776    the data type of the result is computed and recorded in it,
2777    warnings are generated if arg data types are invalid,
2778    special handling for addition and subtraction of pointers is known,
2779    and some optimization is done (operations on narrow ints
2780    are done in the narrower type when that gives the same result).
2781    Constant folding is also done before the result is returned.
2782
2783    Note that the operands will never have enumeral types
2784    because either they have just had the default conversions performed
2785    or they have both just been converted to some other type in which
2786    the arithmetic is to be done.
2787
2788    C++: must do special pointer arithmetic when implementing
2789    multiple inheritance, and deal with pointer to member functions.  */
2790
2791 tree
2792 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
2793                  int convert_p ATTRIBUTE_UNUSED)
2794 {
2795   tree op0, op1;
2796   enum tree_code code0, code1;
2797   tree type0, type1;
2798   const char *invalid_op_diag;
2799
2800   /* Expression code to give to the expression when it is built.
2801      Normally this is CODE, which is what the caller asked for,
2802      but in some special cases we change it.  */
2803   enum tree_code resultcode = code;
2804
2805   /* Data type in which the computation is to be performed.
2806      In the simplest cases this is the common type of the arguments.  */
2807   tree result_type = NULL;
2808
2809   /* Nonzero means operands have already been type-converted
2810      in whatever way is necessary.
2811      Zero means they need to be converted to RESULT_TYPE.  */
2812   int converted = 0;
2813
2814   /* Nonzero means create the expression with this type, rather than
2815      RESULT_TYPE.  */
2816   tree build_type = 0;
2817
2818   /* Nonzero means after finally constructing the expression
2819      convert it to this type.  */
2820   tree final_type = 0;
2821
2822   tree result;
2823
2824   /* Nonzero if this is an operation like MIN or MAX which can
2825      safely be computed in short if both args are promoted shorts.
2826      Also implies COMMON.
2827      -1 indicates a bitwise operation; this makes a difference
2828      in the exact conditions for when it is safe to do the operation
2829      in a narrower mode.  */
2830   int shorten = 0;
2831
2832   /* Nonzero if this is a comparison operation;
2833      if both args are promoted shorts, compare the original shorts.
2834      Also implies COMMON.  */
2835   int short_compare = 0;
2836
2837   /* Nonzero if this is a right-shift operation, which can be computed on the
2838      original short and then promoted if the operand is a promoted short.  */
2839   int short_shift = 0;
2840
2841   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
2842   int common = 0;
2843
2844   /* True if both operands have arithmetic type.  */
2845   bool arithmetic_types_p;
2846
2847   /* Apply default conversions.  */
2848   op0 = orig_op0;
2849   op1 = orig_op1;
2850
2851   if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2852       || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2853       || code == TRUTH_XOR_EXPR)
2854     {
2855       if (!really_overloaded_fn (op0))
2856         op0 = decay_conversion (op0);
2857       if (!really_overloaded_fn (op1))
2858         op1 = decay_conversion (op1);
2859     }
2860   else
2861     {
2862       if (!really_overloaded_fn (op0))
2863         op0 = default_conversion (op0);
2864       if (!really_overloaded_fn (op1))
2865         op1 = default_conversion (op1);
2866     }
2867
2868   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
2869   STRIP_TYPE_NOPS (op0);
2870   STRIP_TYPE_NOPS (op1);
2871
2872   /* DTRT if one side is an overloaded function, but complain about it.  */
2873   if (type_unknown_p (op0))
2874     {
2875       tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none);
2876       if (t != error_mark_node)
2877         {
2878           pedwarn ("assuming cast to type %qT from overloaded function",
2879                    TREE_TYPE (t));
2880           op0 = t;
2881         }
2882     }
2883   if (type_unknown_p (op1))
2884     {
2885       tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none);
2886       if (t != error_mark_node)
2887         {
2888           pedwarn ("assuming cast to type %qT from overloaded function",
2889                    TREE_TYPE (t));
2890           op1 = t;
2891         }
2892     }
2893
2894   type0 = TREE_TYPE (op0);
2895   type1 = TREE_TYPE (op1);
2896
2897   /* The expression codes of the data types of the arguments tell us
2898      whether the arguments are integers, floating, pointers, etc.  */
2899   code0 = TREE_CODE (type0);
2900   code1 = TREE_CODE (type1);
2901
2902   /* If an error was already reported for one of the arguments,
2903      avoid reporting another error.  */
2904
2905   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2906     return error_mark_node;
2907
2908   if ((invalid_op_diag
2909        = targetm.invalid_binary_op (code, type0, type1)))
2910     {
2911       error (invalid_op_diag);
2912       return error_mark_node;
2913     }
2914
2915   switch (code)
2916     {
2917     case PLUS_EXPR:
2918       /* Handle the pointer + int case.  */
2919       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2920         return cp_pointer_int_sum (PLUS_EXPR, op0, op1);
2921       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2922         return cp_pointer_int_sum (PLUS_EXPR, op1, op0);
2923       else
2924         common = 1;
2925       break;
2926
2927     case MINUS_EXPR:
2928       /* Subtraction of two similar pointers.
2929          We must subtract them as integers, then divide by object size.  */
2930       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2931           && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0),
2932                                                         TREE_TYPE (type1)))
2933         return pointer_diff (op0, op1, common_type (type0, type1));
2934       /* Handle pointer minus int.  Just like pointer plus int.  */
2935       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2936         return cp_pointer_int_sum (MINUS_EXPR, op0, op1);
2937       else
2938         common = 1;
2939       break;
2940
2941     case MULT_EXPR:
2942       common = 1;
2943       break;
2944
2945     case TRUNC_DIV_EXPR:
2946     case CEIL_DIV_EXPR:
2947     case FLOOR_DIV_EXPR:
2948     case ROUND_DIV_EXPR:
2949     case EXACT_DIV_EXPR:
2950       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2951            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2952           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2953               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
2954         {
2955           if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1))
2956             warning (0, "division by zero in %<%E / 0%>", op0);
2957           else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1))
2958             warning (0, "division by zero in %<%E / 0.%>", op0);
2959
2960           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
2961             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
2962           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
2963             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
2964
2965           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2966             resultcode = RDIV_EXPR;
2967           else
2968             /* When dividing two signed integers, we have to promote to int.
2969                unless we divide by a constant != -1.  Note that default
2970                conversion will have been performed on the operands at this
2971                point, so we have to dig out the original type to find out if
2972                it was unsigned.  */
2973             shorten = ((TREE_CODE (op0) == NOP_EXPR
2974                         && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2975                        || (TREE_CODE (op1) == INTEGER_CST
2976                            && ! integer_all_onesp (op1)));
2977
2978           common = 1;
2979         }
2980       break;
2981
2982     case BIT_AND_EXPR:
2983     case BIT_IOR_EXPR:
2984     case BIT_XOR_EXPR:
2985       if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2986           || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE))
2987         shorten = -1;
2988       break;
2989
2990     case TRUNC_MOD_EXPR:
2991     case FLOOR_MOD_EXPR:
2992       if (code1 == INTEGER_TYPE && integer_zerop (op1))
2993         warning (0, "division by zero in %<%E %% 0%>", op0);
2994       else if (code1 == REAL_TYPE && real_zerop (op1))
2995         warning (0, "division by zero in %<%E %% 0.%>", op0);
2996
2997       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2998         {
2999           /* Although it would be tempting to shorten always here, that loses
3000              on some targets, since the modulo instruction is undefined if the
3001              quotient can't be represented in the computation mode.  We shorten
3002              only if unsigned or if dividing by something we know != -1.  */
3003           shorten = ((TREE_CODE (op0) == NOP_EXPR
3004                       && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
3005                      || (TREE_CODE (op1) == INTEGER_CST
3006                          && ! integer_all_onesp (op1)));
3007           common = 1;
3008         }
3009       break;
3010
3011     case TRUTH_ANDIF_EXPR:
3012     case TRUTH_ORIF_EXPR:
3013     case TRUTH_AND_EXPR:
3014     case TRUTH_OR_EXPR:
3015       result_type = boolean_type_node;
3016       break;
3017
3018       /* Shift operations: result has same type as first operand;
3019          always convert second operand to int.
3020          Also set SHORT_SHIFT if shifting rightward.  */
3021
3022     case RSHIFT_EXPR:
3023       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3024         {
3025           result_type = type0;
3026           if (TREE_CODE (op1) == INTEGER_CST)
3027             {
3028               if (tree_int_cst_lt (op1, integer_zero_node))
3029                 warning (0, "right shift count is negative");
3030               else
3031                 {
3032                   if (! integer_zerop (op1))
3033                     short_shift = 1;
3034                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3035                     warning (0, "right shift count >= width of type");
3036                 }
3037             }
3038           /* Convert the shift-count to an integer, regardless of
3039              size of value being shifted.  */
3040           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3041             op1 = cp_convert (integer_type_node, op1);
3042           /* Avoid converting op1 to result_type later.  */
3043           converted = 1;
3044         }
3045       break;
3046
3047     case LSHIFT_EXPR:
3048       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3049         {
3050           result_type = type0;
3051           if (TREE_CODE (op1) == INTEGER_CST)
3052             {
3053               if (tree_int_cst_lt (op1, integer_zero_node))
3054                 warning (0, "left shift count is negative");
3055               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3056                 warning (0, "left shift count >= width of type");
3057             }
3058           /* Convert the shift-count to an integer, regardless of
3059              size of value being shifted.  */
3060           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3061             op1 = cp_convert (integer_type_node, op1);
3062           /* Avoid converting op1 to result_type later.  */
3063           converted = 1;
3064         }
3065       break;
3066
3067     case RROTATE_EXPR:
3068     case LROTATE_EXPR:
3069       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
3070         {
3071           result_type = type0;
3072           if (TREE_CODE (op1) == INTEGER_CST)
3073             {
3074               if (tree_int_cst_lt (op1, integer_zero_node))
3075                 warning (0, "%s rotate count is negative",
3076                          (code == LROTATE_EXPR) ? "left" : "right");
3077               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
3078                 warning (0, "%s rotate count >= width of type",
3079                          (code == LROTATE_EXPR) ? "left" : "right");
3080             }
3081           /* Convert the shift-count to an integer, regardless of
3082              size of value being shifted.  */
3083           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
3084             op1 = cp_convert (integer_type_node, op1);
3085         }
3086       break;
3087
3088     case EQ_EXPR:
3089     case NE_EXPR:
3090       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
3091         warning (0, "comparing floating point with == or != is unsafe");
3092       if ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1))
3093           || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0)))
3094         warning (OPT_Wstring_literal_comparison,
3095                  "comparison with string literal");
3096
3097       build_type = boolean_type_node;
3098       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
3099            || code0 == COMPLEX_TYPE)
3100           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3101               || code1 == COMPLEX_TYPE))
3102         short_compare = 1;
3103       else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3104                || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1)))
3105         result_type = composite_pointer_type (type0, type1, op0, op1,
3106                                               "comparison");
3107       else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0))
3108                && null_ptr_cst_p (op1))
3109         result_type = type0;
3110       else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1))
3111                && null_ptr_cst_p (op0))
3112         result_type = type1;
3113       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3114         {
3115           result_type = type0;
3116           error ("ISO C++ forbids comparison between pointer and integer");
3117         }
3118       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3119         {
3120           result_type = type1;
3121           error ("ISO C++ forbids comparison between pointer and integer");
3122         }
3123       else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
3124         {
3125           op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
3126           op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
3127           result_type = TREE_TYPE (op0);
3128         }
3129       else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
3130         return cp_build_binary_op (code, op1, op0);
3131       else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
3132                && same_type_p (type0, type1))
3133         {
3134           /* E will be the final comparison.  */
3135           tree e;
3136           /* E1 and E2 are for scratch.  */
3137           tree e1;
3138           tree e2;
3139           tree pfn0;
3140           tree pfn1;
3141           tree delta0;
3142           tree delta1;
3143
3144           if (TREE_SIDE_EFFECTS (op0))
3145             op0 = save_expr (op0);
3146           if (TREE_SIDE_EFFECTS (op1))
3147             op1 = save_expr (op1);
3148
3149           /* We generate:
3150
3151              (op0.pfn == op1.pfn
3152               && (!op0.pfn || op0.delta == op1.delta))
3153
3154              The reason for the `!op0.pfn' bit is that a NULL
3155              pointer-to-member is any member with a zero PFN; the
3156              DELTA field is unspecified.  */
3157           pfn0 = pfn_from_ptrmemfunc (op0);
3158           pfn1 = pfn_from_ptrmemfunc (op1);
3159           delta0 = build_ptrmemfunc_access_expr (op0,
3160                                                  delta_identifier);
3161           delta1 = build_ptrmemfunc_access_expr (op1,
3162                                                  delta_identifier);
3163           e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
3164           e2 = cp_build_binary_op (EQ_EXPR,
3165                                    pfn0,
3166                                    cp_convert (TREE_TYPE (pfn0),
3167                                                integer_zero_node));
3168           e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
3169           e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1);
3170           e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
3171           if (code == EQ_EXPR)
3172             return e;
3173           return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
3174         }
3175       else
3176         {
3177           gcc_assert (!TYPE_PTRMEMFUNC_P (type0)
3178                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0),
3179                                        type1));
3180           gcc_assert (!TYPE_PTRMEMFUNC_P (type1)
3181                       || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1),
3182                                        type0));
3183         }
3184
3185       break;
3186
3187     case MAX_EXPR:
3188     case MIN_EXPR:
3189       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3190            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3191         shorten = 1;
3192       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3193         result_type = composite_pointer_type (type0, type1, op0, op1,
3194                                               "comparison");
3195       break;
3196
3197     case LE_EXPR:
3198     case GE_EXPR:
3199     case LT_EXPR:
3200     case GT_EXPR:
3201       if (TREE_CODE (orig_op0) == STRING_CST
3202           || TREE_CODE (orig_op1) == STRING_CST)
3203         warning (OPT_Wstring_literal_comparison,
3204                  "comparison with string literal");
3205
3206       build_type = boolean_type_node;
3207       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3208            && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3209         short_compare = 1;
3210       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
3211         result_type = composite_pointer_type (type0, type1, op0, op1,
3212                                               "comparison");
3213       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
3214                && integer_zerop (op1))
3215         result_type = type0;
3216       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
3217                && integer_zerop (op0))
3218         result_type = type1;
3219       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
3220         {
3221           result_type = type0;
3222           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3223         }
3224       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
3225         {
3226           result_type = type1;
3227           pedwarn ("ISO C++ forbids comparison between pointer and integer");
3228         }
3229       break;
3230
3231     case UNORDERED_EXPR:
3232     case ORDERED_EXPR:
3233     case UNLT_EXPR:
3234     case UNLE_EXPR:
3235     case UNGT_EXPR:
3236     case UNGE_EXPR:
3237     case UNEQ_EXPR:
3238       build_type = integer_type_node;
3239       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
3240         {
3241           error ("unordered comparison on non-floating point argument");
3242           return error_mark_node;
3243         }
3244       common = 1;
3245       break;
3246
3247     default:
3248       break;
3249     }
3250
3251   if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
3252        && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
3253            || code1 == COMPLEX_TYPE)))
3254     arithmetic_types_p = 1;
3255   else
3256     {
3257       arithmetic_types_p = 0;
3258       /* Vector arithmetic is only allowed when both sides are vectors.  */
3259       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
3260         {
3261           if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
3262               || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
3263                                                         TREE_TYPE (type1)))
3264             {
3265               binary_op_error (code);
3266               return error_mark_node;
3267             }
3268           arithmetic_types_p = 1;
3269         }
3270     }
3271   /* Determine the RESULT_TYPE, if it is not already known.  */
3272   if (!result_type
3273       && arithmetic_types_p
3274       && (shorten || common || short_compare))
3275     result_type = common_type (type0, type1);
3276
3277   if (!result_type)
3278     {
3279       error ("invalid operands of types %qT and %qT to binary %qO",
3280              TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code);
3281       return error_mark_node;
3282     }
3283
3284   /* If we're in a template, the only thing we need to know is the
3285      RESULT_TYPE.  */
3286   if (processing_template_decl)
3287     return build2 (resultcode,
3288                    build_type ? build_type : result_type,
3289                    op0, op1);
3290
3291   if (arithmetic_types_p)
3292     {
3293       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
3294
3295       /* For certain operations (which identify themselves by shorten != 0)
3296          if both args were extended from the same smaller type,
3297          do the arithmetic in that type and then extend.
3298
3299          shorten !=0 and !=1 indicates a bitwise operation.
3300          For them, this optimization is safe only if
3301          both args are zero-extended or both are sign-extended.
3302          Otherwise, we might change the result.
3303          Eg, (short)-1 | (unsigned short)-1 is (int)-1
3304          but calculated in (unsigned short) it would be (unsigned short)-1.  */
3305
3306       if (shorten && none_complex)
3307         {
3308           int unsigned0, unsigned1;
3309           tree arg0 = get_narrower (op0, &unsigned0);
3310           tree arg1 = get_narrower (op1, &unsigned1);
3311           /* UNS is 1 if the operation to be done is an unsigned one.  */
3312           int uns = TYPE_UNSIGNED (result_type);
3313           tree type;
3314
3315           final_type = result_type;
3316
3317           /* Handle the case that OP0 does not *contain* a conversion
3318              but it *requires* conversion to FINAL_TYPE.  */
3319
3320           if (op0 == arg0 && TREE_TYPE (op0) != final_type)
3321             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3322           if (op1 == arg1 && TREE_TYPE (op1) != final_type)
3323             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3324
3325           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
3326
3327           /* For bitwise operations, signedness of nominal type
3328              does not matter.  Consider only how operands were extended.  */
3329           if (shorten == -1)
3330             uns = unsigned0;
3331
3332           /* Note that in all three cases below we refrain from optimizing
3333              an unsigned operation on sign-extended args.
3334              That would not be valid.  */
3335
3336           /* Both args variable: if both extended in same way
3337              from same width, do it in that width.
3338              Do it unsigned if args were zero-extended.  */
3339           if ((TYPE_PRECISION (TREE_TYPE (arg0))
3340                < TYPE_PRECISION (result_type))
3341               && (TYPE_PRECISION (TREE_TYPE (arg1))
3342                   == TYPE_PRECISION (TREE_TYPE (arg0)))
3343               && unsigned0 == unsigned1
3344               && (unsigned0 || !uns))
3345             result_type = c_common_signed_or_unsigned_type
3346               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
3347           else if (TREE_CODE (arg0) == INTEGER_CST
3348                    && (unsigned1 || !uns)
3349                    && (TYPE_PRECISION (TREE_TYPE (arg1))
3350                        < TYPE_PRECISION (result_type))
3351                    && (type = c_common_signed_or_unsigned_type
3352                        (unsigned1, TREE_TYPE (arg1)),
3353                        int_fits_type_p (arg0, type)))
3354             result_type = type;
3355           else if (TREE_CODE (arg1) == INTEGER_CST
3356                    && (unsigned0 || !uns)
3357                    && (TYPE_PRECISION (TREE_TYPE (arg0))
3358                        < TYPE_PRECISION (result_type))
3359                    && (type = c_common_signed_or_unsigned_type
3360                        (unsigned0, TREE_TYPE (arg0)),
3361                        int_fits_type_p (arg1, type)))
3362             result_type = type;
3363         }
3364
3365       /* Shifts can be shortened if shifting right.  */
3366
3367       if (short_shift)
3368         {
3369           int unsigned_arg;
3370           tree arg0 = get_narrower (op0, &unsigned_arg);
3371
3372           final_type = result_type;
3373
3374           if (arg0 == op0 && final_type == TREE_TYPE (op0))
3375             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
3376
3377           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
3378               /* We can shorten only if the shift count is less than the
3379                  number of bits in the smaller type size.  */
3380               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
3381               /* If arg is sign-extended and then unsigned-shifted,
3382                  we can simulate this with a signed shift in arg's type
3383                  only if the extended result is at least twice as wide
3384                  as the arg.  Otherwise, the shift could use up all the
3385                  ones made by sign-extension and bring in zeros.
3386                  We can't optimize that case at all, but in most machines
3387                  it never happens because available widths are 2**N.  */
3388               && (!TYPE_UNSIGNED (final_type)
3389                   || unsigned_arg
3390                   || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0)))
3391                       <= TYPE_PRECISION (result_type))))
3392             {
3393               /* Do an unsigned shift if the operand was zero-extended.  */
3394               result_type
3395                 = c_common_signed_or_unsigned_type (unsigned_arg,
3396                                                     TREE_TYPE (arg0));
3397               /* Convert value-to-be-shifted to that type.  */
3398               if (TREE_TYPE (op0) != result_type)
3399                 op0 = cp_convert (result_type, op0);
3400               converted = 1;
3401             }
3402         }
3403
3404       /* Comparison operations are shortened too but differently.
3405          They identify themselves by setting short_compare = 1.  */
3406
3407       if (short_compare)
3408         {
3409           /* Don't write &op0, etc., because that would prevent op0
3410              from being kept in a register.
3411              Instead, make copies of the our local variables and
3412              pass the copies by reference, then copy them back afterward.  */
3413           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
3414           enum tree_code xresultcode = resultcode;
3415           tree val
3416             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
3417           if (val != 0)
3418             return cp_convert (boolean_type_node, val);
3419           op0 = xop0, op1 = xop1;
3420           converted = 1;
3421           resultcode = xresultcode;
3422         }
3423
3424       if ((short_compare || code == MIN_EXPR || code == MAX_EXPR)
3425           && warn_sign_compare
3426           /* Do not warn until the template is instantiated; we cannot
3427              bound the ranges of the arguments until that point.  */
3428           && !processing_template_decl)
3429         {
3430           int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
3431           int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3432
3433           int unsignedp0, unsignedp1;
3434           tree primop0 = get_narrower (op0, &unsignedp0);
3435           tree primop1 = get_narrower (op1, &unsignedp1);
3436
3437           /* Check for comparison of different enum types.  */
3438           if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
3439               && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
3440               && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
3441                  != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
3442             {
3443               warning (0, "comparison between types %q#T and %q#T",
3444                        TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
3445             }
3446
3447           /* Give warnings for comparisons between signed and unsigned
3448              quantities that may fail.  */
3449           /* Do the checking based on the original operand trees, so that
3450              casts will be considered, but default promotions won't be.  */
3451
3452           /* Do not warn if the comparison is being done in a signed type,
3453              since the signed type will only be chosen if it can represent
3454              all the values of the unsigned type.  */
3455           if (!TYPE_UNSIGNED (result_type))
3456             /* OK */;
3457           /* Do not warn if both operands are unsigned.  */
3458           else if (op0_signed == op1_signed)
3459             /* OK */;
3460           /* Do not warn if the signed quantity is an unsuffixed
3461              integer literal (or some static constant expression
3462              involving such literals or a conditional expression
3463              involving such literals) and it is non-negative.  */
3464           else if ((op0_signed && tree_expr_nonnegative_p (orig_op0))
3465                    || (op1_signed && tree_expr_nonnegative_p (orig_op1)))
3466             /* OK */;
3467           /* Do not warn if the comparison is an equality operation,
3468              the unsigned quantity is an integral constant and it does
3469              not use the most significant bit of result_type.  */
3470           else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
3471                    && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
3472                         && int_fits_type_p (orig_op1, c_common_signed_type
3473                                             (result_type)))
3474                         || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
3475                             && int_fits_type_p (orig_op0, c_common_signed_type
3476                                                 (result_type)))))
3477             /* OK */;
3478           else
3479             warning (0, "comparison between signed and unsigned integer expressions");
3480
3481           /* Warn if two unsigned values are being compared in a size
3482              larger than their original size, and one (and only one) is the
3483              result of a `~' operator.  This comparison will always fail.
3484
3485              Also warn if one operand is a constant, and the constant does not
3486              have all bits set that are set in the ~ operand when it is
3487              extended.  */
3488
3489           if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
3490               ^ (TREE_CODE (primop1) == BIT_NOT_EXPR))
3491             {
3492               if (TREE_CODE (primop0) == BIT_NOT_EXPR)
3493                 primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
3494               if (TREE_CODE (primop1) == BIT_NOT_EXPR)
3495                 primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
3496
3497               if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
3498                 {
3499                   tree primop;
3500                   HOST_WIDE_INT constant, mask;
3501                   int unsignedp;
3502                   unsigned int bits;
3503
3504                   if (host_integerp (primop0, 0))
3505                     {
3506                       primop = primop1;
3507                       unsignedp = unsignedp1;
3508                       constant = tree_low_cst (primop0, 0);
3509                     }
3510                   else
3511                     {
3512                       primop = primop0;
3513                       unsignedp = unsignedp0;
3514                       constant = tree_low_cst (primop1, 0);
3515                     }
3516
3517                   bits = TYPE_PRECISION (TREE_TYPE (primop));
3518                   if (bits < TYPE_PRECISION (result_type)
3519                       && bits < HOST_BITS_PER_LONG && unsignedp)
3520                     {
3521                       mask = (~ (HOST_WIDE_INT) 0) << bits;
3522                       if ((mask & constant) != mask)
3523                         warning (0, "comparison of promoted ~unsigned with constant");
3524                     }
3525                 }
3526               else if (unsignedp0 && unsignedp1
3527                        && (TYPE_PRECISION (TREE_TYPE (primop0))
3528                            < TYPE_PRECISION (result_type))
3529                        && (TYPE_PRECISION (TREE_TYPE (primop1))
3530                            < TYPE_PRECISION (result_type)))
3531                 warning (0, "comparison of promoted ~unsigned with unsigned");
3532             }
3533         }
3534     }
3535
3536   /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
3537      Then the expression will be built.
3538      It will be given type FINAL_TYPE if that is nonzero;
3539      otherwise, it will be given type RESULT_TYPE.  */
3540
3541   /* Issue warnings about peculiar, but valid, uses of NULL.  */
3542   if (/* It's reasonable to use pointer values as operands of &&
3543          and ||, so NULL is no exception.  */
3544       !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
3545       && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa.  */
3546           (orig_op0 == null_node
3547            && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)
3548           /* Or vice versa.  */
3549           || (orig_op1 == null_node
3550               && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE)
3551           /* Or, both are NULL and the operation was not a comparison.  */
3552           || (orig_op0 == null_node && orig_op1 == null_node
3553               && code != EQ_EXPR && code != NE_EXPR)))
3554     /* Some sort of arithmetic operation involving NULL was
3555        performed.  Note that pointer-difference and pointer-addition
3556        have already been handled above, and so we don't end up here in
3557        that case.  */
3558     warning (0, "NULL used in arithmetic");
3559
3560   if (! converted)
3561     {
3562       if (TREE_TYPE (op0) != result_type)
3563         op0 = cp_convert (result_type, op0);
3564       if (TREE_TYPE (op1) != result_type)
3565         op1 = cp_convert (result_type, op1);
3566
3567       if (op0 == error_mark_node || op1 == error_mark_node)
3568         return error_mark_node;
3569     }
3570
3571   if (build_type == NULL_TREE)
3572     build_type = result_type;
3573
3574   result = build2 (resultcode, build_type, op0, op1);
3575   result = fold_if_not_in_template (result);
3576   if (final_type != 0)
3577     result = cp_convert (final_type, result);
3578   return result;
3579 }
3580 \f
3581 /* Return a tree for the sum or difference (RESULTCODE says which)
3582    of pointer PTROP and integer INTOP.  */
3583
3584 static tree
3585 cp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3586 {
3587   tree res_type = TREE_TYPE (ptrop);
3588
3589   /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type)
3590      in certain circumstance (when it's valid to do so).  So we need
3591      to make sure it's complete.  We don't need to check here, if we
3592      can actually complete it at all, as those checks will be done in
3593      pointer_int_sum() anyway.  */
3594   complete_type (TREE_TYPE (res_type));
3595
3596   return pointer_int_sum (resultcode, ptrop,
3597                           fold_if_not_in_template (intop));
3598 }
3599
3600 /* Return a tree for the difference of pointers OP0 and OP1.
3601    The resulting tree has type int.  */
3602
3603 static tree
3604 pointer_diff (tree op0, tree op1, tree ptrtype)
3605 {
3606   tree result;
3607   tree restype = ptrdiff_type_node;
3608   tree target_type = TREE_TYPE (ptrtype);
3609
3610   if (!complete_type_or_else (target_type, NULL_TREE))
3611     return error_mark_node;
3612
3613   if (pedantic || warn_pointer_arith)
3614     {
3615       if (TREE_CODE (target_type) == VOID_TYPE)
3616         pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction");
3617       if (TREE_CODE (target_type) == FUNCTION_TYPE)
3618         pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
3619       if (TREE_CODE (target_type) == METHOD_TYPE)
3620         pedwarn ("ISO C++ forbids using pointer to a method in subtraction");
3621     }
3622
3623   /* First do the subtraction as integers;
3624      then drop through to build the divide operator.  */
3625
3626   op0 = cp_build_binary_op (MINUS_EXPR,
3627                             cp_convert (restype, op0),
3628                             cp_convert (restype, op1));
3629
3630   /* This generates an error if op1 is a pointer to an incomplete type.  */
3631   if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
3632     error ("invalid use of a pointer to an incomplete type in pointer arithmetic");
3633
3634   op1 = (TYPE_PTROB_P (ptrtype)
3635          ? size_in_bytes (target_type)
3636          : integer_one_node);
3637
3638   /* Do the division.  */
3639
3640   result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1));
3641   return fold_if_not_in_template (result);
3642 }
3643 \f
3644 /* Construct and perhaps optimize a tree representation
3645    for a unary operation.  CODE, a tree_code, specifies the operation
3646    and XARG is the operand.  */
3647
3648 tree
3649 build_x_unary_op (enum tree_code code, tree xarg)
3650 {
3651   tree orig_expr = xarg;
3652   tree exp;
3653   int ptrmem = 0;
3654
3655   if (processing_template_decl)
3656     {
3657       if (type_dependent_expression_p (xarg))
3658         return build_min_nt (code, xarg, NULL_TREE);
3659
3660       xarg = build_non_dependent_expr (xarg);
3661     }
3662
3663   exp = NULL_TREE;
3664
3665   /* [expr.unary.op] says:
3666
3667        The address of an object of incomplete type can be taken.
3668
3669      (And is just the ordinary address operator, not an overloaded
3670      "operator &".)  However, if the type is a template
3671      specialization, we must complete the type at this point so that
3672      an overloaded "operator &" will be available if required.  */
3673   if (code == ADDR_EXPR
3674       && TREE_CODE (xarg) != TEMPLATE_ID_EXPR
3675       && ((CLASS_TYPE_P (TREE_TYPE (xarg))
3676            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg))))
3677           || (TREE_CODE (xarg) == OFFSET_REF)))
3678     /* Don't look for a function.  */;
3679   else
3680     exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE,
3681                         /*overloaded_p=*/NULL);
3682   if (!exp && code == ADDR_EXPR)
3683     {
3684       /*  A pointer to member-function can be formed only by saying
3685           &X::mf.  */
3686       if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE
3687           && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg)))
3688         {
3689           if (TREE_CODE (xarg) != OFFSET_REF
3690               || !TYPE_P (TREE_OPERAND (xarg, 0)))
3691             {
3692               error ("invalid use of %qE to form a pointer-to-member-function",
3693                      xarg);
3694               if (TREE_CODE (xarg) != OFFSET_REF)
3695                 inform ("  a qualified-id is required");
3696               return error_mark_node;
3697             }
3698           else
3699             {
3700               error ("parentheses around %qE cannot be used to form a"
3701                      " pointer-to-member-function",
3702                      xarg);
3703               PTRMEM_OK_P (xarg) = 1;
3704             }
3705         }
3706
3707       if (TREE_CODE (xarg) == OFFSET_REF)
3708         {
3709           ptrmem = PTRMEM_OK_P (xarg);
3710
3711           if (!ptrmem && !flag_ms_extensions
3712               && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE)
3713             {
3714               /* A single non-static member, make sure we don't allow a
3715                  pointer-to-member.  */
3716               xarg = build2 (OFFSET_REF, TREE_TYPE (xarg),
3717                              TREE_OPERAND (xarg, 0),
3718                              ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE));
3719               PTRMEM_OK_P (xarg) = ptrmem;
3720             }
3721         }
3722       else if (TREE_CODE (xarg) == TARGET_EXPR)
3723         warning (0, "taking address of temporary");
3724       exp = build_unary_op (ADDR_EXPR, xarg, 0);
3725     }
3726
3727   if (processing_template_decl && exp != error_mark_node)
3728     exp = build_min_non_dep (code, exp, orig_expr,
3729                              /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE);
3730   if (TREE_CODE (exp) == ADDR_EXPR)
3731     PTRMEM_OK_P (exp) = ptrmem;
3732   return exp;
3733 }
3734
3735 /* Like c_common_truthvalue_conversion, but handle pointer-to-member
3736    constants, where a null value is represented by an INTEGER_CST of
3737    -1.  */
3738
3739 tree
3740 cp_truthvalue_conversion (tree expr)
3741 {
3742   tree type = TREE_TYPE (expr);
3743   if (TYPE_PTRMEM_P (type))
3744     return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3745   else
3746     return c_common_truthvalue_conversion (expr);
3747 }
3748
3749 /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR.  */
3750
3751 tree
3752 condition_conversion (tree expr)
3753 {
3754   tree t;
3755   if (processing_template_decl)
3756     return expr;
3757   t = perform_implicit_conversion (boolean_type_node, expr);
3758   t = fold_build_cleanup_point_expr (boolean_type_node, t);
3759   return t;
3760 }
3761
3762 /* Return an ADDR_EXPR giving the address of T.  This function
3763    attempts no optimizations or simplifications; it is a low-level
3764    primitive.  */
3765
3766 tree
3767 build_address (tree t)
3768 {
3769   tree addr;
3770
3771   if (error_operand_p (t) || !cxx_mark_addressable (t))
3772     return error_mark_node;
3773
3774   addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t);
3775
3776   return addr;
3777 }
3778
3779 /* Return a NOP_EXPR converting EXPR to TYPE.  */
3780
3781 tree
3782 build_nop (tree type, tree expr)
3783 {
3784   if (type == error_mark_node || error_operand_p (expr))
3785     return expr;
3786   return build1 (NOP_EXPR, type, expr);
3787 }
3788
3789 /* C++: Must handle pointers to members.
3790
3791    Perhaps type instantiation should be extended to handle conversion
3792    from aggregates to types we don't yet know we want?  (Or are those
3793    cases typically errors which should be reported?)
3794
3795    NOCONVERT nonzero suppresses the default promotions
3796    (such as from short to int).  */
3797
3798 tree
3799 build_unary_op (enum tree_code code, tree xarg, int noconvert)
3800 {
3801   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3802   tree arg = xarg;
3803   tree argtype = 0;
3804   const char *errstring = NULL;
3805   tree val;
3806   const char *invalid_op_diag;
3807
3808   if (arg == error_mark_node)
3809     return error_mark_node;
3810
3811   if ((invalid_op_diag
3812        = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR
3813                                     ? CONVERT_EXPR
3814                                     : code),
3815                                    TREE_TYPE (xarg))))
3816     {
3817       error (invalid_op_diag);
3818       return error_mark_node;
3819     }
3820
3821   switch (code)
3822     {
3823     case UNARY_PLUS_EXPR:
3824     case NEGATE_EXPR:
3825       {
3826         int flags = WANT_ARITH | WANT_ENUM;
3827         /* Unary plus (but not unary minus) is allowed on pointers.  */
3828         if (code == UNARY_PLUS_EXPR)
3829           flags |= WANT_POINTER;
3830         arg = build_expr_type_conversion (flags, arg, true);
3831         if (!arg)
3832           errstring = (code == NEGATE_EXPR
3833                        ? "wrong type argument to unary minus"
3834                        : "wrong type argument to unary plus");
3835         else
3836           {
3837             if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
3838               arg = perform_integral_promotions (arg);
3839
3840             /* Make sure the result is not an lvalue: a unary plus or minus
3841                expression is always a rvalue.  */
3842             arg = rvalue (arg);
3843           }
3844       }
3845       break;
3846
3847     case BIT_NOT_EXPR:
3848       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3849         {
3850           code = CONJ_EXPR;
3851           if (!noconvert)
3852             arg = default_conversion (arg);
3853         }
3854       else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM,
3855                                                    arg, true)))
3856         errstring = "wrong type argument to bit-complement";
3857       else if (!noconvert)
3858         arg = perform_integral_promotions (arg);
3859       break;
3860
3861     case ABS_EXPR:
3862       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3863         errstring = "wrong type argument to abs";
3864       else if (!noconvert)
3865         arg = default_conversion (arg);
3866       break;
3867
3868     case CONJ_EXPR:
3869       /* Conjugating a real value is a no-op, but allow it anyway.  */
3870       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
3871         errstring = "wrong type argument to conjugation";
3872       else if (!noconvert)
3873         arg = default_conversion (arg);
3874       break;
3875
3876     case TRUTH_NOT_EXPR:
3877       arg = perform_implicit_conversion (boolean_type_node, arg);
3878       val = invert_truthvalue (arg);
3879       if (arg != error_mark_node)
3880         return val;
3881       errstring = "in argument to unary !";
3882       break;
3883
3884     case NOP_EXPR:
3885       break;
3886
3887     case REALPART_EXPR:
3888       if (TREE_CODE (arg) == COMPLEX_CST)
3889         return TREE_REALPART (arg);
3890       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3891         {
3892           arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3893           return fold_if_not_in_template (arg);
3894         }
3895       else
3896         return arg;
3897
3898     case IMAGPART_EXPR:
3899       if (TREE_CODE (arg) == COMPLEX_CST)
3900         return TREE_IMAGPART (arg);
3901       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3902         {
3903           arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
3904           return fold_if_not_in_template (arg);
3905         }
3906       else
3907         return cp_convert (TREE_TYPE (arg), integer_zero_node);
3908
3909     case PREINCREMENT_EXPR:
3910     case POSTINCREMENT_EXPR:
3911     case PREDECREMENT_EXPR:
3912     case POSTDECREMENT_EXPR:
3913       /* Handle complex lvalues (when permitted)
3914          by reduction to simpler cases.  */
3915
3916       val = unary_complex_lvalue (code, arg);
3917       if (val != 0)
3918         return val;
3919
3920       /* Increment or decrement the real part of the value,
3921          and don't change the imaginary part.  */
3922       if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
3923         {
3924           tree real, imag;
3925
3926           arg = stabilize_reference (arg);
3927           real = build_unary_op (REALPART_EXPR, arg, 1);
3928           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
3929           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3930                          build_unary_op (code, real, 1), imag);
3931         }
3932
3933       /* Report invalid types.  */
3934
3935       if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER,
3936                                               arg, true)))
3937         {
3938           if (code == PREINCREMENT_EXPR)
3939             errstring ="no pre-increment operator for type";
3940           else if (code == POSTINCREMENT_EXPR)
3941             errstring ="no post-increment operator for type";
3942           else if (code == PREDECREMENT_EXPR)
3943             errstring ="no pre-decrement operator for type";
3944           else
3945             errstring ="no post-decrement operator for type";
3946           break;
3947         }
3948
3949       /* Report something read-only.  */
3950
3951       if (CP_TYPE_CONST_P (TREE_TYPE (arg))
3952           || TREE_READONLY (arg))
3953         readonly_error (arg, ((code == PREINCREMENT_EXPR
3954                                || code == POSTINCREMENT_EXPR)
3955                               ? "increment" : "decrement"),
3956                         0);
3957
3958       {
3959         tree inc;
3960         tree result_type = TREE_TYPE (arg);
3961
3962         arg = get_unwidened (arg, 0);
3963         argtype = TREE_TYPE (arg);
3964
3965         /* ARM $5.2.5 last annotation says this should be forbidden.  */
3966         if (TREE_CODE (argtype) == ENUMERAL_TYPE)
3967           pedwarn ("ISO C++ forbids %sing an enum",
3968                    (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3969                    ? "increment" : "decrement");
3970
3971         /* Compute the increment.  */
3972
3973         if (TREE_CODE (argtype) == POINTER_TYPE)
3974           {
3975             tree type = complete_type (TREE_TYPE (argtype));
3976
3977             if (!COMPLETE_OR_VOID_TYPE_P (type))
3978               error ("cannot %s a pointer to incomplete type %qT",
3979                      ((code == PREINCREMENT_EXPR
3980                        || code == POSTINCREMENT_EXPR)
3981                       ? "increment" : "decrement"), TREE_TYPE (argtype));
3982             else if ((pedantic || warn_pointer_arith)
3983                      && !TYPE_PTROB_P (argtype))
3984               pedwarn ("ISO C++ forbids %sing a pointer of type %qT",
3985                        ((code == PREINCREMENT_EXPR
3986                          || code == POSTINCREMENT_EXPR)
3987                         ? "increment" : "decrement"), argtype);
3988             inc = cxx_sizeof_nowarn (TREE_TYPE (argtype));
3989           }
3990         else
3991           inc = integer_one_node;
3992
3993         inc = cp_convert (argtype, inc);
3994
3995         /* Handle incrementing a cast-expression.  */
3996
3997         switch (TREE_CODE (arg))
3998           {
3999           case NOP_EXPR:
4000           case CONVERT_EXPR:
4001           case FLOAT_EXPR:
4002           case FIX_TRUNC_EXPR:
4003           case FIX_FLOOR_EXPR:
4004           case FIX_ROUND_EXPR:
4005           case FIX_CEIL_EXPR:
4006             {
4007               tree incremented, modify, value, compound;
4008               if (! lvalue_p (arg) && pedantic)
4009                 pedwarn ("cast to non-reference type used as lvalue");
4010               arg = stabilize_reference (arg);
4011               if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
4012                 value = arg;
4013               else
4014                 value = save_expr (arg);
4015               incremented = build2 (((code == PREINCREMENT_EXPR
4016                                       || code == POSTINCREMENT_EXPR)
4017                                      ? PLUS_EXPR : MINUS_EXPR),
4018                                     argtype, value, inc);
4019
4020               modify = build_modify_expr (arg, NOP_EXPR, incremented);
4021               compound = build2 (COMPOUND_EXPR, TREE_TYPE (arg),
4022                                  modify, value);
4023
4024               /* Eliminate warning about unused result of + or -.  */
4025               TREE_NO_WARNING (compound) = 1;
4026               return compound;
4027             }
4028
4029           default:
4030             break;
4031           }
4032
4033         /* Complain about anything else that is not a true lvalue.  */
4034         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
4035                                     || code == POSTINCREMENT_EXPR)
4036                                    ? lv_increment : lv_decrement)))
4037           return error_mark_node;
4038
4039         /* Forbid using -- on `bool'.  */
4040         if (TREE_TYPE (arg) == boolean_type_node)
4041           {
4042             if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR)
4043               {
4044                 error ("invalid use of %<--%> on bool variable %qD", arg);
4045                 return error_mark_node;
4046               }
4047             val = boolean_increment (code, arg);
4048           }
4049         else
4050           val = build2 (code, TREE_TYPE (arg), arg, inc);
4051
4052         TREE_SIDE_EFFECTS (val) = 1;
4053         return cp_convert (result_type, val);
4054       }
4055
4056     case ADDR_EXPR:
4057       /* Note that this operation never does default_conversion
4058          regardless of NOCONVERT.  */
4059
4060       argtype = lvalue_type (arg);
4061
4062       if (TREE_CODE (arg) == OFFSET_REF)
4063         goto offset_ref;
4064
4065       if (TREE_CODE (argtype) == REFERENCE_TYPE)
4066         {
4067           tree type = build_pointer_type (TREE_TYPE (argtype));
4068           arg = build1 (CONVERT_EXPR, type, arg);
4069           return arg;
4070         }
4071       else if (pedantic && DECL_MAIN_P (arg))
4072         /* ARM $3.4 */
4073         pedwarn ("ISO C++ forbids taking address of function %<::main%>");
4074
4075       /* Let &* cancel out to simplify resulting code.  */
4076       if (TREE_CODE (arg) == INDIRECT_REF)
4077         {
4078           /* We don't need to have `current_class_ptr' wrapped in a
4079              NON_LVALUE_EXPR node.  */
4080           if (arg == current_class_ref)
4081             return current_class_ptr;
4082
4083           arg = TREE_OPERAND (arg, 0);
4084           if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE)
4085             {
4086               tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg)));
4087               arg = build1 (CONVERT_EXPR, type, arg);
4088             }
4089           else
4090             /* Don't let this be an lvalue.  */
4091             arg = rvalue (arg);
4092           return arg;
4093         }
4094
4095       /* Uninstantiated types are all functions.  Taking the
4096          address of a function is a no-op, so just return the
4097          argument.  */
4098
4099       gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
4100                   || !IDENTIFIER_OPNAME_P (arg));
4101
4102       if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
4103           && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
4104         {
4105           /* They're trying to take the address of a unique non-static
4106              member function.  This is ill-formed (except in MS-land),
4107              but let's try to DTRT.
4108              Note: We only handle unique functions here because we don't
4109              want to complain if there's a static overload; non-unique
4110              cases will be handled by instantiate_type.  But we need to
4111              handle this case here to allow casts on the resulting PMF.
4112              We could defer this in non-MS mode, but it's easier to give
4113              a useful error here.  */
4114
4115           /* Inside constant member functions, the `this' pointer
4116              contains an extra const qualifier.  TYPE_MAIN_VARIANT
4117              is used here to remove this const from the diagnostics
4118              and the created OFFSET_REF.  */
4119           tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0)));
4120           tree fn = get_first_fn (TREE_OPERAND (arg, 1));
4121
4122           if (! flag_ms_extensions)
4123             {
4124               tree name = DECL_NAME (fn);
4125               if (current_class_type
4126                   && TREE_OPERAND (arg, 0) == current_class_ref)
4127                 /* An expression like &memfn.  */
4128                 pedwarn ("ISO C++ forbids taking the address of an unqualified"
4129                          " or parenthesized non-static member function to form"
4130                          " a pointer to member function.  Say %<&%T::%D%>",
4131                          base, name);
4132               else
4133                 pedwarn ("ISO C++ forbids taking the address of a bound member"
4134                          " function to form a pointer to member function."
4135                          "  Say %<&%T::%D%>",
4136                          base, name);
4137             }
4138           arg = build_offset_ref (base, fn, /*address_p=*/true);
4139         }
4140
4141     offset_ref:
4142       if (type_unknown_p (arg))
4143         return build1 (ADDR_EXPR, unknown_type_node, arg);
4144
4145       /* Handle complex lvalues (when permitted)
4146          by reduction to simpler cases.  */
4147       val = unary_complex_lvalue (code, arg);
4148       if (val != 0)
4149         return val;
4150
4151       switch (TREE_CODE (arg))
4152         {
4153         case NOP_EXPR:
4154         case CONVERT_EXPR:
4155         case FLOAT_EXPR:
4156         case FIX_TRUNC_EXPR:
4157         case FIX_FLOOR_EXPR:
4158         case FIX_ROUND_EXPR:
4159         case FIX_CEIL_EXPR:
4160           if (! lvalue_p (arg) && pedantic)
4161             pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression");
4162           break;
4163
4164         case OVERLOAD:
4165           arg = OVL_CURRENT (arg);
4166           break;
4167
4168         case OFFSET_REF:
4169           /* Turn a reference to a non-static data member into a
4170              pointer-to-member.  */
4171           {
4172             tree type;
4173             tree t;
4174
4175             if (!PTRMEM_OK_P (arg))
4176               return build_unary_op (code, arg, 0);
4177
4178             t = TREE_OPERAND (arg, 1);
4179             if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE)
4180               {
4181                 error ("cannot create pointer to reference member %qD", t);
4182                 return error_mark_node;
4183               }
4184
4185             type = build_ptrmem_type (context_for_name_lookup (t),
4186                                       TREE_TYPE (t));
4187             t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1));
4188             return t;
4189           }
4190
4191         default:
4192           break;
4193         }
4194
4195       /* Anything not already handled and not a true memory reference
4196          is an error.  */
4197       if (TREE_CODE (argtype) != FUNCTION_TYPE
4198           && TREE_CODE (argtype) != METHOD_TYPE
4199           && TREE_CODE (arg) != OFFSET_REF
4200           /* Permit users to take the address of a compound-literal
4201              with sufficient simple elements.  */
4202           && !(COMPOUND_LITERAL_P (arg) && TREE_STATIC (arg))
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       /* In a template, we are processing a non-dependent expression
4210          so we can just form an ADDR_EXPR with the correct type.  */
4211       if (processing_template_decl)
4212         {
4213           val = build_address (arg);
4214           if (TREE_CODE (arg) == OFFSET_REF)
4215             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4216           return val;
4217         }
4218
4219       /* If the user has taken the address of the compound literal,
4220          create a variable to contain the value of the literal and
4221          then return the address of that variable.  */
4222       if (COMPOUND_LITERAL_P (arg))
4223         {
4224           tree var;
4225           gcc_assert (TREE_STATIC (arg));
4226           var = create_temporary_var (TREE_TYPE (arg));
4227           TREE_STATIC (var) = 1;
4228           set_compound_literal_name (var);
4229           initialize_artificial_var (var, arg);
4230           arg = pushdecl (var);
4231           /* Since each compound literal is unique, pushdecl should
4232              never find a pre-existing variable with the same
4233              name.  */
4234           gcc_assert (arg == var);
4235         }
4236
4237       if (TREE_CODE (arg) != COMPONENT_REF)
4238         {
4239           val = build_address (arg);
4240           if (TREE_CODE (arg) == OFFSET_REF)
4241             PTRMEM_OK_P (val) = PTRMEM_OK_P (arg);
4242         }
4243       else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK)
4244         {
4245           tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1));
4246
4247           /* We can only get here with a single static member
4248              function.  */
4249           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
4250                       && DECL_STATIC_FUNCTION_P (fn));
4251           mark_used (fn);
4252           val = build_address (fn);
4253           if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
4254             /* Do not lose object's side effects.  */
4255             val = build2 (COMPOUND_EXPR, TREE_TYPE (val),
4256                           TREE_OPERAND (arg, 0), val);
4257         }
4258       else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4259         {
4260           error ("attempt to take address of bit-field structure member %qD",
4261                  TREE_OPERAND (arg, 1));
4262           return error_mark_node;
4263         }
4264       else
4265         {
4266           tree object = TREE_OPERAND (arg, 0);
4267           tree field = TREE_OPERAND (arg, 1);
4268           gcc_assert (same_type_ignoring_top_level_qualifiers_p
4269                       (TREE_TYPE (object), decl_type_context (field)));
4270           val = build_address (arg);
4271         }
4272
4273       if (TREE_CODE (argtype) == POINTER_TYPE
4274           && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE)
4275         {
4276           build_ptrmemfunc_type (argtype);
4277           val = build_ptrmemfunc (argtype, val, 0,
4278                                   /*c_cast_p=*/false);
4279         }
4280
4281       return val;
4282
4283     default:
4284       break;
4285     }
4286
4287   if (!errstring)
4288     {
4289       if (argtype == 0)
4290         argtype = TREE_TYPE (arg);
4291       return fold_if_not_in_template (build1 (code, argtype, arg));
4292     }
4293
4294   error ("%s", errstring);
4295   return error_mark_node;
4296 }
4297
4298 /* Apply unary lvalue-demanding operator CODE to the expression ARG
4299    for certain kinds of expressions which are not really lvalues
4300    but which we can accept as lvalues.
4301
4302    If ARG is not a kind of expression we can handle, return
4303    NULL_TREE.  */
4304
4305 tree
4306 unary_complex_lvalue (enum tree_code code, tree arg)
4307 {
4308   /* Inside a template, making these kinds of adjustments is
4309      pointless; we are only concerned with the type of the
4310      expression.  */
4311   if (processing_template_decl)
4312     return NULL_TREE;
4313
4314   /* Handle (a, b) used as an "lvalue".  */
4315   if (TREE_CODE (arg) == COMPOUND_EXPR)
4316     {
4317       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
4318       return build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4319                      TREE_OPERAND (arg, 0), real_result);
4320     }
4321
4322   /* Handle (a ? b : c) used as an "lvalue".  */
4323   if (TREE_CODE (arg) == COND_EXPR
4324       || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR)
4325     return rationalize_conditional_expr (code, arg);
4326
4327   /* Handle (a = b), (++a), and (--a) used as an "lvalue".  */
4328   if (TREE_CODE (arg) == MODIFY_EXPR
4329       || TREE_CODE (arg) == PREINCREMENT_EXPR
4330       || TREE_CODE (arg) == PREDECREMENT_EXPR)
4331     {
4332       tree lvalue = TREE_OPERAND (arg, 0);
4333       if (TREE_SIDE_EFFECTS (lvalue))
4334         {
4335           lvalue = stabilize_reference (lvalue);
4336           arg = build2 (TREE_CODE (arg), TREE_TYPE (arg),
4337                         lvalue, TREE_OPERAND (arg, 1));
4338         }
4339       return unary_complex_lvalue
4340         (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue));
4341     }
4342
4343   if (code != ADDR_EXPR)
4344     return 0;
4345
4346   /* Handle (a = b) used as an "lvalue" for `&'.  */
4347   if (TREE_CODE (arg) == MODIFY_EXPR
4348       || TREE_CODE (arg) == INIT_EXPR)
4349     {
4350       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0);
4351       arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result),
4352                     arg, real_result);
4353       TREE_NO_WARNING (arg) = 1;
4354       return arg;
4355     }
4356
4357   if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE
4358       || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE
4359       || TREE_CODE (arg) == OFFSET_REF)
4360     return NULL_TREE;
4361
4362   /* We permit compiler to make function calls returning
4363      objects of aggregate type look like lvalues.  */
4364   {
4365     tree targ = arg;
4366
4367     if (TREE_CODE (targ) == SAVE_EXPR)
4368       targ = TREE_OPERAND (targ, 0);
4369
4370     if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ)))
4371       {
4372         if (TREE_CODE (arg) == SAVE_EXPR)
4373           targ = arg;
4374         else
4375           targ = build_cplus_new (TREE_TYPE (arg), arg);
4376         return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ);
4377       }
4378
4379     if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF)
4380       return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)),
4381                      TREE_OPERAND (targ, 0), current_function_decl, NULL);
4382   }
4383
4384   /* Don't let anything else be handled specially.  */
4385   return 0;
4386 }
4387 \f
4388 /* Mark EXP saying that we need to be able to take the
4389    address of it; it should not be allocated in a register.
4390    Value is true if successful.
4391
4392    C++: we do not allow `current_class_ptr' to be addressable.  */
4393
4394 bool
4395 cxx_mark_addressable (tree exp)
4396 {
4397   tree x = exp;
4398
4399   while (1)
4400     switch (TREE_CODE (x))
4401       {
4402       case ADDR_EXPR:
4403       case COMPONENT_REF:
4404       case ARRAY_REF:
4405       case REALPART_EXPR:
4406       case IMAGPART_EXPR:
4407         x = TREE_OPERAND (x, 0);
4408         break;
4409
4410       case PARM_DECL:
4411         if (x == current_class_ptr)
4412           {
4413             error ("cannot take the address of %<this%>, which is an rvalue expression");
4414             TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later.  */
4415             return true;
4416           }
4417         /* Fall through.  */
4418
4419       case VAR_DECL:
4420         /* Caller should not be trying to mark initialized
4421            constant fields addressable.  */
4422         gcc_assert (DECL_LANG_SPECIFIC (x) == 0
4423                     || DECL_IN_AGGR_P (x) == 0
4424                     || TREE_STATIC (x)
4425                     || DECL_EXTERNAL (x));
4426         /* Fall through.  */
4427
4428       case CONST_DECL:
4429       case RESULT_DECL:
4430         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
4431             && !DECL_ARTIFICIAL (x))
4432           {
4433             if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x))
4434               {
4435                 error
4436                   ("address of explicit register variable %qD requested", x);
4437                 return false;
4438               }
4439             else if (extra_warnings)
4440               warning
4441                 (0, "address requested for %qD, which is declared %<register%>", x);
4442           }
4443         TREE_ADDRESSABLE (x) = 1;
4444         return true;
4445
4446       case FUNCTION_DECL:
4447         TREE_ADDRESSABLE (x) = 1;
4448         return true;
4449
4450       case CONSTRUCTOR:
4451         TREE_ADDRESSABLE (x) = 1;
4452         return true;
4453
4454       case TARGET_EXPR:
4455         TREE_ADDRESSABLE (x) = 1;
4456         cxx_mark_addressable (TREE_OPERAND (x, 0));
4457         return true;
4458
4459       default:
4460         return true;
4461     }
4462 }
4463 \f
4464 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
4465
4466 tree
4467 build_x_conditional_expr (tree ifexp, tree op1, tree op2)
4468 {
4469   tree orig_ifexp = ifexp;
4470   tree orig_op1 = op1;
4471   tree orig_op2 = op2;
4472   tree expr;
4473
4474   if (processing_template_decl)
4475     {
4476       /* The standard says that the expression is type-dependent if
4477          IFEXP is type-dependent, even though the eventual type of the
4478          expression doesn't dependent on IFEXP.  */
4479       if (type_dependent_expression_p (ifexp)
4480           /* As a GNU extension, the middle operand may be omitted.  */
4481           || (op1 && type_dependent_expression_p (op1))
4482           || type_dependent_expression_p (op2))
4483         return build_min_nt (COND_EXPR, ifexp, op1, op2);
4484       ifexp = build_non_dependent_expr (ifexp);
4485       if (op1)
4486         op1 = build_non_dependent_expr (op1);
4487       op2 = build_non_dependent_expr (op2);
4488     }
4489
4490   expr = build_conditional_expr (ifexp, op1, op2);
4491   if (processing_template_decl && expr != error_mark_node)
4492     return build_min_non_dep (COND_EXPR, expr,
4493                               orig_ifexp, orig_op1, orig_op2);
4494   return expr;
4495 }
4496 \f
4497 /* Given a list of expressions, return a compound expression
4498    that performs them all and returns the value of the last of them.  */
4499
4500 tree build_x_compound_expr_from_list (tree list, const char *msg)
4501 {
4502   tree expr = TREE_VALUE (list);
4503
4504   if (TREE_CHAIN (list))
4505     {
4506       if (msg)
4507         pedwarn ("%s expression list treated as compound expression", msg);
4508
4509       for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list))
4510         expr = build_x_compound_expr (expr, TREE_VALUE (list));
4511     }
4512
4513   return expr;
4514 }
4515
4516 /* Handle overloading of the ',' operator when needed.  */
4517
4518 tree
4519 build_x_compound_expr (tree op1, tree op2)
4520 {
4521   tree result;
4522   tree orig_op1 = op1;
4523   tree orig_op2 = op2;
4524
4525   if (processing_template_decl)
4526     {
4527       if (type_dependent_expression_p (op1)
4528           || type_dependent_expression_p (op2))
4529         return build_min_nt (COMPOUND_EXPR, op1, op2);
4530       op1 = build_non_dependent_expr (op1);
4531       op2 = build_non_dependent_expr (op2);
4532     }
4533
4534   result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE,
4535                          /*overloaded_p=*/NULL);
4536   if (!result)
4537     result = build_compound_expr (op1, op2);
4538
4539   if (processing_template_decl && result != error_mark_node)
4540     return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2);
4541
4542   return result;
4543 }
4544
4545 /* Build a compound expression.  */
4546
4547 tree
4548 build_compound_expr (tree lhs, tree rhs)
4549 {
4550   lhs = convert_to_void (lhs, "left-hand operand of comma");
4551
4552   if (lhs == error_mark_node || rhs == error_mark_node)
4553     return error_mark_node;
4554
4555   if (TREE_CODE (rhs) == TARGET_EXPR)
4556     {
4557       /* If the rhs is a TARGET_EXPR, then build the compound
4558          expression inside the target_expr's initializer. This
4559          helps the compiler to eliminate unnecessary temporaries.  */
4560       tree init = TREE_OPERAND (rhs, 1);
4561
4562       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
4563       TREE_OPERAND (rhs, 1) = init;
4564
4565       return rhs;
4566     }
4567
4568   return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs);
4569 }
4570
4571 /* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE
4572    casts away constness.  DIAG_FN gives the function to call if we
4573    need to issue a diagnostic; if it is NULL, no diagnostic will be
4574    issued.  DESCRIPTION explains what operation is taking place.  */
4575
4576 static void
4577 check_for_casting_away_constness (tree src_type, tree dest_type,
4578                                   void (*diag_fn)(const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2),
4579                                   const char *description)
4580 {
4581   if (diag_fn && casts_away_constness (src_type, dest_type))
4582     diag_fn ("%s from type %qT to type %qT casts away constness",
4583              description, src_type, dest_type);
4584 }
4585
4586 /* Convert EXPR (an expression with pointer-to-member type) to TYPE
4587    (another pointer-to-member type in the same hierarchy) and return
4588    the converted expression.  If ALLOW_INVERSE_P is permitted, a
4589    pointer-to-derived may be converted to pointer-to-base; otherwise,
4590    only the other direction is permitted.  If C_CAST_P is true, this
4591    conversion is taking place as part of a C-style cast.  */
4592
4593 tree
4594 convert_ptrmem (tree type, tree expr, bool allow_inverse_p,
4595                 bool c_cast_p)
4596 {
4597   if (TYPE_PTRMEM_P (type))
4598     {
4599       tree delta;
4600
4601       if (TREE_CODE (expr) == PTRMEM_CST)
4602         expr = cplus_expand_constant (expr);
4603       delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)),
4604                                     TYPE_PTRMEM_CLASS_TYPE (type),
4605                                     allow_inverse_p,
4606                                     c_cast_p);
4607       if (!integer_zerop (delta))
4608         expr = cp_build_binary_op (PLUS_EXPR,
4609                                    build_nop (ptrdiff_type_node, expr),
4610                                    delta);
4611       return build_nop (type, expr);
4612     }
4613   else
4614     return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr,
4615                              allow_inverse_p, c_cast_p);
4616 }
4617
4618 /* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return
4619    a version of EXPR that has TREE_OVERFLOW and/or TREE_CONSTANT_OVERFLOW
4620    set iff they are set in ORIG.  Otherwise, return EXPR unchanged.  */
4621
4622 static tree
4623 ignore_overflows (tree expr, tree orig)
4624 {
4625   if (TREE_CODE (expr) == INTEGER_CST
4626       && CONSTANT_CLASS_P (orig)
4627       && TREE_CODE (orig) != STRING_CST
4628       && (TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig)
4629           || TREE_CONSTANT_OVERFLOW (expr)
4630              != TREE_CONSTANT_OVERFLOW (orig)))
4631     {
4632       if (!TREE_OVERFLOW (orig) && !TREE_CONSTANT_OVERFLOW (orig))
4633         /* Ensure constant sharing.  */
4634         expr = build_int_cst_wide (TREE_TYPE (expr),
4635                                    TREE_INT_CST_LOW (expr),
4636                                    TREE_INT_CST_HIGH (expr));
4637       else
4638         {
4639           /* Avoid clobbering a shared constant.  */
4640           expr = copy_node (expr);
4641           TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig);
4642           TREE_CONSTANT_OVERFLOW (expr)
4643             = TREE_CONSTANT_OVERFLOW (orig);
4644         }
4645     }
4646   return expr;
4647 }
4648
4649 /* Perform a static_cast from EXPR to TYPE.  When C_CAST_P is true,
4650    this static_cast is being attempted as one of the possible casts
4651    allowed by a C-style cast.  (In that case, accessibility of base
4652    classes is not considered, and it is OK to cast away
4653    constness.)  Return the result of the cast.  *VALID_P is set to
4654    indicate whether or not the cast was valid.  */
4655
4656 static tree
4657 build_static_cast_1 (tree type, tree expr, bool c_cast_p,
4658                      bool *valid_p)
4659 {
4660   tree intype;
4661   tree result;
4662   tree orig;
4663   void (*diag_fn)(const char*, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
4664   const char *desc;
4665
4666   /* Assume the cast is valid.  */
4667   *valid_p = true;
4668
4669   intype = TREE_TYPE (expr);
4670
4671   /* Determine what to do when casting away constness.  */
4672   if (c_cast_p)
4673     {
4674       /* C-style casts are allowed to cast away constness.  With
4675          WARN_CAST_QUAL, we still want to issue a warning.  */
4676       diag_fn = warn_cast_qual ? warning0 : NULL;
4677       desc = "cast";
4678     }
4679   else
4680     {
4681       /* A static_cast may not cast away constness.  */
4682       diag_fn = error;
4683       desc = "static_cast";
4684     }
4685
4686   /* [expr.static.cast]
4687
4688      An lvalue of type "cv1 B", where B is a class type, can be cast
4689      to type "reference to cv2 D", where D is a class derived (clause
4690      _class.derived_) from B, if a valid standard conversion from
4691      "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the
4692      same cv-qualification as, or greater cv-qualification than, cv1,
4693      and B is not a virtual base class of D.  */
4694   /* We check this case before checking the validity of "TYPE t =
4695      EXPR;" below because for this case:
4696
4697        struct B {};
4698        struct D : public B { D(const B&); };
4699        extern B& b;
4700        void f() { static_cast<const D&>(b); }
4701
4702      we want to avoid constructing a new D.  The standard is not
4703      completely clear about this issue, but our interpretation is
4704      consistent with other compilers.  */
4705   if (TREE_CODE (type) == REFERENCE_TYPE
4706       && CLASS_TYPE_P (TREE_TYPE (type))
4707       && CLASS_TYPE_P (intype)
4708       && real_lvalue_p (expr)
4709       && DERIVED_FROM_P (intype, TREE_TYPE (type))
4710       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)),
4711                       build_pointer_type (TYPE_MAIN_VARIANT
4712                                           (TREE_TYPE (type))))
4713       && (c_cast_p
4714           || at_least_as_qualified_p (TREE_TYPE (type), intype)))
4715     {
4716       tree base;
4717
4718       /* There is a standard conversion from "D*" to "B*" even if "B"
4719          is ambiguous or inaccessible.  If this is really a
4720          static_cast, then we check both for inaccessibility and
4721          ambiguity.  However, if this is a static_cast being performed
4722          because the user wrote a C-style cast, then accessibility is
4723          not considered.  */
4724       base = lookup_base (TREE_TYPE (type), intype,
4725                           c_cast_p ? ba_unique : ba_check,
4726                           NULL);
4727
4728       /* Convert from "B*" to "D*".  This function will check that "B"
4729          is not a virtual base of "D".  */
4730       expr = build_base_path (MINUS_EXPR, build_address (expr),
4731                               base, /*nonnull=*/false);
4732       /* Convert the pointer to a reference -- but then remember that
4733          there are no expressions with reference type in C++.  */
4734       return convert_from_reference (build_nop (type, expr));
4735     }
4736
4737   orig = expr;
4738
4739   /* [expr.static.cast]
4740
4741      An expression e can be explicitly converted to a type T using a
4742      static_cast of the form static_cast<T>(e) if the declaration T
4743      t(e);" is well-formed, for some invented temporary variable
4744      t.  */
4745   result = perform_direct_initialization_if_possible (type, expr,
4746                                                       c_cast_p);
4747   if (result)
4748     {
4749       result = convert_from_reference (result);
4750
4751       /* Ignore any integer overflow caused by the cast.  */
4752       result = ignore_overflows (result, orig);
4753
4754       /* [expr.static.cast]
4755
4756          If T is a reference type, the result is an lvalue; otherwise,
4757          the result is an rvalue.  */
4758       if (TREE_CODE (type) != REFERENCE_TYPE)
4759         result = rvalue (result);
4760       return result;
4761     }
4762
4763   /* [expr.static.cast]
4764
4765      Any expression can be explicitly converted to type cv void.  */
4766   if (TREE_CODE (type) == VOID_TYPE)
4767     return convert_to_void (expr, /*implicit=*/NULL);
4768
4769   /* [expr.static.cast]
4770
4771      The inverse of any standard conversion sequence (clause _conv_),
4772      other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer
4773      (_conv.array_), function-to-pointer (_conv.func_), and boolean
4774      (_conv.bool_) conversions, can be performed explicitly using
4775      static_cast subject to the restriction that the explicit
4776      conversion does not cast away constness (_expr.const.cast_), and
4777      the following additional rules for specific cases:  */
4778   /* For reference, the conversions not excluded are: integral
4779      promotions, floating point promotion, integral conversions,
4780      floating point conversions, floating-integral conversions,
4781      pointer conversions, and pointer to member conversions.  */
4782   /* DR 128
4783
4784      A value of integral _or enumeration_ type can be explicitly
4785      converted to an enumeration type.  */
4786   /* The effect of all that is that any conversion between any two
4787      types which are integral, floating, or enumeration types can be
4788      performed.  */
4789   if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
4790       && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype)))
4791     {
4792       expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL);
4793
4794       /* Ignore any integer overflow caused by the cast.  */
4795       expr = ignore_overflows (expr, orig);
4796       return expr;
4797     }
4798
4799   if (TYPE_PTR_P (type) && TYPE_PTR_P (intype)
4800       && CLASS_TYPE_P (TREE_TYPE (type))
4801       && CLASS_TYPE_P (TREE_TYPE (intype))
4802       && can_convert (build_pointer_type (TYPE_MAIN_VARIANT
4803                                           (TREE_TYPE (intype))),
4804                       build_pointer_type (TYPE_MAIN_VARIANT
4805                                           (TREE_TYPE (type)))))
4806     {
4807       tree base;
4808
4809       if (!c_cast_p)
4810         check_for_casting_away_constness (intype, type, diag_fn, desc);
4811       base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
4812                           c_cast_p ? ba_unique : ba_check,
4813                           NULL);
4814       return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false);
4815     }
4816
4817   if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
4818       || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
4819     {
4820       tree c1;
4821       tree c2;
4822       tree t1;
4823       tree t2;
4824
4825       c1 = TYPE_PTRMEM_CLASS_TYPE (intype);
4826       c2 = TYPE_PTRMEM_CLASS_TYPE (type);
4827
4828       if (TYPE_PTRMEM_P (type))
4829         {
4830           t1 = (build_ptrmem_type
4831                 (c1,
4832                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype))));
4833           t2 = (build_ptrmem_type
4834                 (c2,
4835                  TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
4836         }
4837       else
4838         {
4839           t1 = intype;
4840           t2 = type;
4841         }
4842       if (can_convert (t1, t2))
4843         {
4844           if (!c_cast_p)
4845             check_for_casting_away_constness (intype, type, diag_fn,
4846                                               desc);
4847           return convert_ptrmem (type, expr, /*allow_inverse_p=*/1,
4848                                  c_cast_p);
4849         }
4850     }
4851
4852   /* [expr.static.cast]
4853
4854      An rvalue of type "pointer to cv void" can be explicitly
4855      converted to a pointer to object type.  A value of type pointer
4856      to object converted to "pointer to cv void" and back to the
4857      original pointer type will have its original value.  */
4858   if (TREE_CODE (intype) == POINTER_TYPE
4859       && VOID_TYPE_P (TREE_TYPE (intype))
4860       && TYPE_PTROB_P (type))
4861     {
4862       if (!c_cast_p)
4863         check_for_casting_away_constness (intype, type, diag_fn, desc);
4864       return build_nop (type, expr);
4865     }
4866
4867   *valid_p = false;
4868   return error_mark_node;
4869 }
4870
4871 /* Return an expression representing static_cast<TYPE>(EXPR).  */
4872
4873 tree
4874 build_static_cast (tree type, tree expr)
4875 {
4876   tree result;
4877   bool valid_p;
4878
4879   if (type == error_mark_node || expr == error_mark_node)
4880     return error_mark_node;
4881
4882   if (processing_template_decl)
4883     {
4884       expr = build_min (STATIC_CAST_EXPR, type, expr);
4885       /* We don't know if it will or will not have side effects.  */
4886       TREE_SIDE_EFFECTS (expr) = 1;
4887       return convert_from_reference (expr);
4888     }
4889
4890   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
4891      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
4892   if (TREE_CODE (type) != REFERENCE_TYPE
4893       && TREE_CODE (expr) == NOP_EXPR
4894       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
4895     expr = TREE_OPERAND (expr, 0);
4896
4897   result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p);
4898   if (valid_p)
4899     return result;
4900
4901   error ("invalid static_cast from type %qT to type %qT",
4902          TREE_TYPE (expr), type);
4903   return error_mark_node;
4904 }
4905
4906 /* EXPR is an expression with member function or pointer-to-member
4907    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
4908    not permitted by ISO C++, but we accept it in some modes.  If we
4909    are not in one of those modes, issue a diagnostic.  Return the
4910    converted expression.  */
4911
4912 tree
4913 convert_member_func_to_ptr (tree type, tree expr)
4914 {
4915   tree intype;
4916   tree decl;
4917
4918   intype = TREE_TYPE (expr);
4919   gcc_assert (TYPE_PTRMEMFUNC_P (intype)
4920               || TREE_CODE (intype) == METHOD_TYPE);
4921
4922   if (pedantic || warn_pmf2ptr)
4923     pedwarn ("converting from %qT to %qT", intype, type);
4924
4925   if (TREE_CODE (intype) == METHOD_TYPE)
4926     expr = build_addr_func (expr);
4927   else if (TREE_CODE (expr) == PTRMEM_CST)
4928     expr = build_address (PTRMEM_CST_MEMBER (expr));
4929   else
4930     {
4931       decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0);
4932       decl = build_address (decl);
4933       expr = get_member_function_from_ptrfunc (&decl, expr);
4934     }
4935
4936   return build_nop (type, expr);
4937 }
4938
4939 /* Return a representation for a reinterpret_cast from EXPR to TYPE.
4940    If C_CAST_P is true, this reinterpret cast is being done as part of
4941    a C-style cast.  If VALID_P is non-NULL, *VALID_P is set to
4942    indicate whether or not reinterpret_cast was valid.  */
4943
4944 static tree
4945 build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p,
4946                           bool *valid_p)
4947 {
4948   tree intype;
4949
4950   /* Assume the cast is invalid.  */
4951   if (valid_p)
4952     *valid_p = true;
4953
4954   if (type == error_mark_node || error_operand_p (expr))
4955     return error_mark_node;
4956
4957   intype = TREE_TYPE (expr);
4958
4959   /* [expr.reinterpret.cast]
4960      An lvalue expression of type T1 can be cast to the type
4961      "reference to T2" if an expression of type "pointer to T1" can be
4962      explicitly converted to the type "pointer to T2" using a
4963      reinterpret_cast.  */
4964   if (TREE_CODE (type) == REFERENCE_TYPE)
4965     {
4966       if (! real_lvalue_p (expr))
4967         {
4968           error ("invalid cast of an rvalue expression of type "
4969                  "%qT to type %qT",
4970                  intype, type);
4971           return error_mark_node;
4972         }
4973
4974       /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and
4975          "B" are related class types; the reinterpret_cast does not
4976          adjust the pointer.  */
4977       if (TYPE_PTR_P (intype)
4978           && (comptypes (TREE_TYPE (intype), TREE_TYPE (type),
4979                          COMPARE_BASE | COMPARE_DERIVED)))
4980         warning (0, "casting %qT to %qT does not dereference pointer",
4981                  intype, type);
4982
4983       expr = build_unary_op (ADDR_EXPR, expr, 0);
4984       if (expr != error_mark_node)
4985         expr = build_reinterpret_cast_1
4986           (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p,
4987            valid_p);
4988       if (expr != error_mark_node)
4989         expr = build_indirect_ref (expr, 0);
4990       return expr;
4991     }
4992
4993   /* As a G++ extension, we consider conversions from member
4994      functions, and pointers to member functions to
4995      pointer-to-function and pointer-to-void types.  If
4996      -Wno-pmf-conversions has not been specified,
4997      convert_member_func_to_ptr will issue an error message.  */
4998   if ((TYPE_PTRMEMFUNC_P (intype)
4999        || TREE_CODE (intype) == METHOD_TYPE)
5000       && TYPE_PTR_P (type)
5001       && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5002           || VOID_TYPE_P (TREE_TYPE (type))))
5003     return convert_member_func_to_ptr (type, expr);
5004
5005   /* If the cast is not to a reference type, the lvalue-to-rvalue,
5006      array-to-pointer, and function-to-pointer conversions are
5007      performed.  */
5008   expr = decay_conversion (expr);
5009
5010   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5011      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5012   if (TREE_CODE (expr) == NOP_EXPR
5013       && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5014     expr = TREE_OPERAND (expr, 0);
5015
5016   if (error_operand_p (expr))
5017     return error_mark_node;
5018
5019   intype = TREE_TYPE (expr);
5020
5021   /* [expr.reinterpret.cast]
5022      A pointer can be converted to any integral type large enough to
5023      hold it.  */
5024   if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype))
5025     {
5026       if (TYPE_PRECISION (type) < TYPE_PRECISION (intype))
5027         pedwarn ("cast from %qT to %qT loses precision",
5028                  intype, type);
5029     }
5030   /* [expr.reinterpret.cast]
5031      A value of integral or enumeration type can be explicitly
5032      converted to a pointer.  */
5033   else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype))
5034     /* OK */
5035     ;
5036   else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype))
5037            || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
5038     return fold_if_not_in_template (build_nop (type, expr));
5039   else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype))
5040            || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype)))
5041     {
5042       tree sexpr = expr;
5043
5044       if (!c_cast_p)
5045         check_for_casting_away_constness (intype, type, error,
5046                                           "reinterpret_cast");
5047       /* Warn about possible alignment problems.  */
5048       if (STRICT_ALIGNMENT && warn_cast_align
5049           && !VOID_TYPE_P (type)
5050           && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE
5051           && COMPLETE_TYPE_P (TREE_TYPE (type))
5052           && COMPLETE_TYPE_P (TREE_TYPE (intype))
5053           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype)))
5054         warning (0, "cast from %qT to %qT increases required alignment of "
5055                  "target type",
5056                  intype, type);
5057
5058       /* We need to strip nops here, because the frontend likes to
5059          create (int *)&a for array-to-pointer decay, instead of &a[0].  */
5060       STRIP_NOPS (sexpr);
5061       strict_aliasing_warning (intype, type, sexpr);
5062
5063       return fold_if_not_in_template (build_nop (type, expr));
5064     }
5065   else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype))
5066            || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type)))
5067     {
5068       if (pedantic)
5069         /* Only issue a warning, as we have always supported this
5070            where possible, and it is necessary in some cases.  DR 195
5071            addresses this issue, but as of 2004/10/26 is still in
5072            drafting.  */
5073         warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5074       return fold_if_not_in_template (build_nop (type, expr));
5075     }
5076   else if (TREE_CODE (type) == VECTOR_TYPE)
5077     return fold_if_not_in_template (convert_to_vector (type, expr));
5078   else if (TREE_CODE (intype) == VECTOR_TYPE)
5079     return fold_if_not_in_template (convert_to_integer (type, expr));
5080   else
5081     {
5082       if (valid_p)
5083         *valid_p = false;
5084       error ("invalid cast from type %qT to type %qT", intype, type);
5085       return error_mark_node;
5086     }
5087
5088   return cp_convert (type, expr);
5089 }
5090
5091 tree
5092 build_reinterpret_cast (tree type, tree expr)
5093 {
5094   if (type == error_mark_node || expr == error_mark_node)
5095     return error_mark_node;
5096
5097   if (processing_template_decl)
5098     {
5099       tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
5100
5101       if (!TREE_SIDE_EFFECTS (t)
5102           && type_dependent_expression_p (expr))
5103         /* There might turn out to be side effects inside expr.  */
5104         TREE_SIDE_EFFECTS (t) = 1;
5105       return convert_from_reference (t);
5106     }
5107
5108   return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false,
5109                                    /*valid_p=*/NULL);
5110 }
5111
5112 /* Perform a const_cast from EXPR to TYPE.  If the cast is valid,
5113    return an appropriate expression.  Otherwise, return
5114    error_mark_node.  If the cast is not valid, and COMPLAIN is true,
5115    then a diagnostic will be issued.  If VALID_P is non-NULL, we are
5116    performing a C-style cast, its value upon return will indicate
5117    whether or not the conversion succeeded.  */
5118
5119 static tree
5120 build_const_cast_1 (tree dst_type, tree expr, bool complain,
5121                     bool *valid_p)
5122 {
5123   tree src_type;
5124   tree reference_type;
5125
5126   /* Callers are responsible for handling error_mark_node as a
5127      destination type.  */
5128   gcc_assert (dst_type != error_mark_node);
5129   /* In a template, callers should be building syntactic
5130      representations of casts, not using this machinery.  */
5131   gcc_assert (!processing_template_decl);
5132
5133   /* Assume the conversion is invalid.  */
5134   if (valid_p)
5135     *valid_p = false;
5136
5137   if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type))
5138     {
5139       if (complain)
5140         error ("invalid use of const_cast with type %qT, "
5141                "which is not a pointer, "
5142                "reference, nor a pointer-to-data-member type", dst_type);
5143       return error_mark_node;
5144     }
5145
5146   if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE)
5147     {
5148       if (complain)
5149         error ("invalid use of const_cast with type %qT, which is a pointer "
5150                "or reference to a function type", dst_type);
5151       return error_mark_node;
5152     }
5153
5154   src_type = TREE_TYPE (expr);
5155   /* Expressions do not really have reference types.  */
5156   if (TREE_CODE (src_type) == REFERENCE_TYPE)
5157     src_type = TREE_TYPE (src_type);
5158
5159   /* [expr.const.cast]
5160
5161      An lvalue of type T1 can be explicitly converted to an lvalue of
5162      type T2 using the cast const_cast<T2&> (where T1 and T2 are object
5163      types) if a pointer to T1 can be explicitly converted to the type
5164      pointer to T2 using a const_cast.  */
5165   if (TREE_CODE (dst_type) == REFERENCE_TYPE)
5166     {
5167       reference_type = dst_type;
5168       if (! real_lvalue_p (expr))
5169         {
5170           if (complain)
5171             error ("invalid const_cast of an rvalue of type %qT to type %qT",
5172                    src_type, dst_type);
5173           return error_mark_node;
5174         }
5175       dst_type = build_pointer_type (TREE_TYPE (dst_type));
5176       src_type = build_pointer_type (src_type);
5177     }
5178   else
5179     {
5180       reference_type = NULL_TREE;
5181       /* If the destination type is not a reference type, the
5182          lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5183          conversions are performed.  */
5184       src_type = type_decays_to (src_type);
5185       if (src_type == error_mark_node)
5186         return error_mark_node;
5187     }
5188
5189   if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type))
5190       && comp_ptr_ttypes_const (dst_type, src_type))
5191     {
5192       if (valid_p)
5193         {
5194           *valid_p = true;
5195           /* This cast is actually a C-style cast.  Issue a warning if
5196              the user is making a potentially unsafe cast.  */
5197           if (warn_cast_qual)
5198             check_for_casting_away_constness (src_type, dst_type,
5199                                               warning0,
5200                                               "cast");
5201         }
5202       if (reference_type)
5203         {
5204           expr = build_unary_op (ADDR_EXPR, expr, 0);
5205           expr = build_nop (reference_type, expr);
5206           return convert_from_reference (expr);
5207         }
5208       else
5209         {
5210           expr = decay_conversion (expr);
5211           /* build_c_cast puts on a NOP_EXPR to make the result not an
5212              lvalue.  Strip such NOP_EXPRs if VALUE is being used in
5213              non-lvalue context.  */
5214           if (TREE_CODE (expr) == NOP_EXPR
5215               && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0)))
5216             expr = TREE_OPERAND (expr, 0);
5217           return build_nop (dst_type, expr);
5218         }
5219     }
5220
5221   if (complain)
5222     error ("invalid const_cast from type %qT to type %qT",
5223            src_type, dst_type);
5224   return error_mark_node;
5225 }
5226
5227 tree
5228 build_const_cast (tree type, tree expr)
5229 {
5230   if (type == error_mark_node || error_operand_p (expr))
5231     return error_mark_node;
5232
5233   if (processing_template_decl)
5234     {
5235       tree t = build_min (CONST_CAST_EXPR, type, expr);
5236
5237       if (!TREE_SIDE_EFFECTS (t)
5238           && type_dependent_expression_p (expr))
5239         /* There might turn out to be side effects inside expr.  */
5240         TREE_SIDE_EFFECTS (t) = 1;
5241       return convert_from_reference (t);
5242     }
5243
5244   return build_const_cast_1 (type, expr, /*complain=*/true,
5245                              /*valid_p=*/NULL);
5246 }
5247
5248 /* Build an expression representing an explicit C-style cast to type
5249    TYPE of expression EXPR.  */
5250
5251 tree
5252 build_c_cast (tree type, tree expr)
5253 {
5254   tree value = expr;
5255   tree result;
5256   bool valid_p;
5257
5258   if (type == error_mark_node || error_operand_p (expr))
5259     return error_mark_node;
5260
5261   if (processing_template_decl)
5262     {
5263       tree t = build_min (CAST_EXPR, type,
5264                           tree_cons (NULL_TREE, value, NULL_TREE));
5265       /* We don't know if it will or will not have side effects.  */
5266       TREE_SIDE_EFFECTS (t) = 1;
5267       return convert_from_reference (t);
5268     }
5269
5270   /* Casts to a (pointer to a) specific ObjC class (or 'id' or
5271      'Class') should always be retained, because this information aids
5272      in method lookup.  */
5273   if (objc_is_object_ptr (type)
5274       && objc_is_object_ptr (TREE_TYPE (expr)))
5275     return build_nop (type, expr);
5276
5277   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
5278      Strip such NOP_EXPRs if VALUE is being used in non-lvalue context.  */
5279   if (TREE_CODE (type) != REFERENCE_TYPE
5280       && TREE_CODE (value) == NOP_EXPR
5281       && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
5282     value = TREE_OPERAND (value, 0);
5283
5284   if (TREE_CODE (type) == ARRAY_TYPE)
5285     {
5286       /* Allow casting from T1* to T2[] because Cfront allows it.
5287          NIHCL uses it. It is not valid ISO C++ however.  */
5288       if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5289         {
5290           pedwarn ("ISO C++ forbids casting to an array type %qT", type);
5291           type = build_pointer_type (TREE_TYPE (type));
5292         }
5293       else
5294         {
5295           error ("ISO C++ forbids casting to an array type %qT", type);
5296           return error_mark_node;
5297         }
5298     }
5299
5300   if (TREE_CODE (type) == FUNCTION_TYPE
5301       || TREE_CODE (type) == METHOD_TYPE)
5302     {
5303       error ("invalid cast to function type %qT", type);
5304       return error_mark_node;
5305     }
5306
5307   /* A C-style cast can be a const_cast.  */
5308   result = build_const_cast_1 (type, value, /*complain=*/false,
5309                                &valid_p);
5310   if (valid_p)
5311     return result;
5312
5313   /* Or a static cast.  */
5314   result = build_static_cast_1 (type, value, /*c_cast_p=*/true,
5315                                 &valid_p);
5316   /* Or a reinterpret_cast.  */
5317   if (!valid_p)
5318     result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true,
5319                                        &valid_p);
5320   /* The static_cast or reinterpret_cast may be followed by a
5321      const_cast.  */
5322   if (valid_p
5323       /* A valid cast may result in errors if, for example, a
5324          conversion to am ambiguous base class is required.  */
5325       && !error_operand_p (result))
5326     {
5327       tree result_type;
5328
5329       /* Non-class rvalues always have cv-unqualified type.  */
5330       if (!CLASS_TYPE_P (type))
5331         type = TYPE_MAIN_VARIANT (type);
5332       result_type = TREE_TYPE (result);
5333       if (!CLASS_TYPE_P (result_type))
5334         result_type = TYPE_MAIN_VARIANT (result_type);
5335       /* If the type of RESULT does not match TYPE, perform a
5336          const_cast to make it match.  If the static_cast or
5337          reinterpret_cast succeeded, we will differ by at most
5338          cv-qualification, so the follow-on const_cast is guaranteed
5339          to succeed.  */
5340       if (!same_type_p (non_reference (type), non_reference (result_type)))
5341         {
5342           result = build_const_cast_1 (type, result, false, &valid_p);
5343           gcc_assert (valid_p);
5344         }
5345       return result;
5346     }
5347
5348   return error_mark_node;
5349 }
5350 \f
5351 /* Build an assignment expression of lvalue LHS from value RHS.
5352    MODIFYCODE is the code for a binary operator that we use
5353    to combine the old value of LHS with RHS to get the new value.
5354    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5355
5356    C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed.  */
5357
5358 tree
5359 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5360 {
5361   tree result;
5362   tree newrhs = rhs;
5363   tree lhstype = TREE_TYPE (lhs);
5364   tree olhstype = lhstype;
5365   tree olhs = NULL_TREE;
5366   bool plain_assign = (modifycode == NOP_EXPR);
5367
5368   /* Avoid duplicate error messages from operands that had errors.  */
5369   if (lhs == error_mark_node || rhs == error_mark_node)
5370     return error_mark_node;
5371
5372   /* Handle control structure constructs used as "lvalues".  */
5373   switch (TREE_CODE (lhs))
5374     {
5375       /* Handle --foo = 5; as these are valid constructs in C++.  */
5376     case PREDECREMENT_EXPR:
5377     case PREINCREMENT_EXPR:
5378       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5379         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5380                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5381                       TREE_OPERAND (lhs, 1));
5382       return build2 (COMPOUND_EXPR, lhstype,
5383                      lhs,
5384                      build_modify_expr (TREE_OPERAND (lhs, 0),
5385                                         modifycode, rhs));
5386
5387       /* Handle (a, b) used as an "lvalue".  */
5388     case COMPOUND_EXPR:
5389       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
5390                                   modifycode, rhs);
5391       if (newrhs == error_mark_node)
5392         return error_mark_node;
5393       return build2 (COMPOUND_EXPR, lhstype,
5394                      TREE_OPERAND (lhs, 0), newrhs);
5395
5396     case MODIFY_EXPR:
5397       if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)))
5398         lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs),
5399                       stabilize_reference (TREE_OPERAND (lhs, 0)),
5400                       TREE_OPERAND (lhs, 1));
5401       newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs);
5402       if (newrhs == error_mark_node)
5403         return error_mark_node;
5404       return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs);
5405
5406     case MIN_EXPR:
5407     case MAX_EXPR:
5408       /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues,
5409          when neither operand has side-effects.  */
5410       if (!lvalue_or_else (lhs, lv_assign))
5411         return error_mark_node;
5412
5413       gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))
5414                   && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1)));
5415
5416       lhs = build3 (COND_EXPR, TREE_TYPE (lhs),
5417                     build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR,
5418                             boolean_type_node,
5419                             TREE_OPERAND (lhs, 0),
5420                             TREE_OPERAND (lhs, 1)),
5421                     TREE_OPERAND (lhs, 0),
5422                     TREE_OPERAND (lhs, 1));
5423       /* Fall through.  */
5424
5425       /* Handle (a ? b : c) used as an "lvalue".  */
5426     case COND_EXPR:
5427       {
5428         /* Produce (a ? (b = rhs) : (c = rhs))
5429            except that the RHS goes through a save-expr
5430            so the code to compute it is only emitted once.  */
5431         tree cond;
5432         tree preeval = NULL_TREE;
5433
5434         rhs = stabilize_expr (rhs, &preeval);
5435
5436         /* Check this here to avoid odd errors when trying to convert
5437            a throw to the type of the COND_EXPR.  */
5438         if (!lvalue_or_else (lhs, lv_assign))
5439           return error_mark_node;
5440
5441         cond = build_conditional_expr
5442           (TREE_OPERAND (lhs, 0),
5443            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5444                                           TREE_OPERAND (lhs, 1)),
5445                               modifycode, rhs),
5446            build_modify_expr (cp_convert (TREE_TYPE (lhs),
5447                                           TREE_OPERAND (lhs, 2)),
5448                               modifycode, rhs));
5449
5450         if (cond == error_mark_node)
5451           return cond;
5452         /* Make sure the code to compute the rhs comes out
5453            before the split.  */
5454         if (preeval)
5455           cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond);
5456         return cond;
5457       }
5458
5459     default:
5460       break;
5461     }
5462
5463   if (modifycode == INIT_EXPR)
5464     {
5465       if (TREE_CODE (rhs) == CONSTRUCTOR)
5466         {
5467           if (! same_type_p (TREE_TYPE (rhs), lhstype))
5468             /* Call convert to generate an error; see PR 11063.  */
5469             rhs = convert (lhstype, rhs);
5470           result = build2 (INIT_EXPR, lhstype, lhs, rhs);
5471           TREE_SIDE_EFFECTS (result) = 1;
5472           return result;
5473         }
5474       else if (! IS_AGGR_TYPE (lhstype))
5475         /* Do the default thing.  */;
5476       else
5477         {
5478           result = build_special_member_call (lhs, complete_ctor_identifier,
5479                                               build_tree_list (NULL_TREE, rhs),
5480                                               lhstype, LOOKUP_NORMAL);
5481           if (result == NULL_TREE)
5482             return error_mark_node;
5483           return result;
5484         }
5485     }
5486   else
5487     {
5488       lhs = require_complete_type (lhs);
5489       if (lhs == error_mark_node)
5490         return error_mark_node;
5491
5492       if (modifycode == NOP_EXPR)
5493         {
5494           /* `operator=' is not an inheritable operator.  */
5495           if (! IS_AGGR_TYPE (lhstype))
5496             /* Do the default thing.  */;
5497           else
5498             {
5499               result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL,
5500                                      lhs, rhs, make_node (NOP_EXPR),
5501                                      /*overloaded_p=*/NULL);
5502               if (result == NULL_TREE)
5503                 return error_mark_node;
5504               return result;
5505             }
5506           lhstype = olhstype;
5507         }
5508       else
5509         {
5510           /* A binary op has been requested.  Combine the old LHS
5511              value with the RHS producing the value we should actually
5512              store into the LHS.  */
5513
5514           gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE));
5515           lhs = stabilize_reference (lhs);
5516           newrhs = cp_build_binary_op (modifycode, lhs, rhs);
5517           if (newrhs == error_mark_node)
5518             {
5519               error ("  in evaluation of %<%Q(%#T, %#T)%>", modifycode,
5520                      TREE_TYPE (lhs), TREE_TYPE (rhs));
5521               return error_mark_node;
5522             }
5523
5524           /* Now it looks like a plain assignment.  */
5525           modifycode = NOP_EXPR;
5526         }
5527       gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE);
5528       gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE);
5529     }
5530
5531   /* The left-hand side must be an lvalue.  */
5532   if (!lvalue_or_else (lhs, lv_assign))
5533     return error_mark_node;
5534
5535   /* Warn about modifying something that is `const'.  Don't warn if
5536      this is initialization.  */
5537   if (modifycode != INIT_EXPR
5538       && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype)
5539           /* Functions are not modifiable, even though they are
5540              lvalues.  */
5541           || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE
5542           || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE
5543           /* If it's an aggregate and any field is const, then it is
5544              effectively const.  */
5545           || (CLASS_TYPE_P (lhstype)
5546               && C_TYPE_FIELDS_READONLY (lhstype))))
5547     readonly_error (lhs, "assignment", 0);
5548
5549   /* If storing into a structure or union member, it has probably been
5550      given type `int'.  Compute the type that would go with the actual
5551      amount of storage the member occupies.  */
5552
5553   if (TREE_CODE (lhs) == COMPONENT_REF
5554       && (TREE_CODE (lhstype) == INTEGER_TYPE
5555           || TREE_CODE (lhstype) == REAL_TYPE
5556           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5557     {
5558       lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5559
5560       /* If storing in a field that is in actuality a short or narrower
5561          than one, we must store in the field in its actual type.  */
5562
5563       if (lhstype != TREE_TYPE (lhs))
5564         {
5565           /* Avoid warnings converting integral types back into enums for
5566              enum bit fields.  */
5567           if (TREE_CODE (lhstype) == INTEGER_TYPE
5568               && TREE_CODE (olhstype) == ENUMERAL_TYPE)
5569             {
5570               if (TREE_SIDE_EFFECTS (lhs))
5571                 lhs = stabilize_reference (lhs);
5572               olhs = lhs;
5573             }
5574           lhs = copy_node (lhs);
5575           TREE_TYPE (lhs) = lhstype;
5576         }
5577     }
5578
5579   /* Convert new value to destination type.  */
5580
5581   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5582     {
5583       int from_array;
5584
5585       if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype),
5586                                 TYPE_MAIN_VARIANT (TREE_TYPE (rhs))))
5587         {
5588           error ("incompatible types in assignment of %qT to %qT",
5589                  TREE_TYPE (rhs), lhstype);
5590           return error_mark_node;
5591         }
5592
5593       /* Allow array assignment in compiler-generated code.  */
5594       if (! DECL_ARTIFICIAL (current_function_decl))
5595         pedwarn ("ISO C++ forbids assignment of arrays");
5596
5597       from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
5598                    ? 1 + (modifycode != INIT_EXPR): 0;
5599       return build_vec_init (lhs, NULL_TREE, newrhs,
5600                              /*explicit_default_init_p=*/false,
5601                              from_array);
5602     }
5603
5604   if (modifycode == INIT_EXPR)
5605     newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL,
5606                                          "initialization", NULL_TREE, 0);
5607   else
5608     {
5609       /* Avoid warnings on enum bit fields.  */
5610       if (TREE_CODE (olhstype) == ENUMERAL_TYPE
5611           && TREE_CODE (lhstype) == INTEGER_TYPE)
5612         {
5613           newrhs = convert_for_assignment (olhstype, newrhs, "assignment",
5614                                            NULL_TREE, 0);
5615           newrhs = convert_force (lhstype, newrhs, 0);
5616         }
5617       else
5618         newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
5619                                          NULL_TREE, 0);
5620       if (TREE_CODE (newrhs) == CALL_EXPR
5621           && TYPE_NEEDS_CONSTRUCTING (lhstype))
5622         newrhs = build_cplus_new (lhstype, newrhs);
5623
5624       /* Can't initialize directly from a TARGET_EXPR, since that would
5625          cause the lhs to be constructed twice, and possibly result in
5626          accidental self-initialization.  So we force the TARGET_EXPR to be
5627          expanded without a target.  */
5628       if (TREE_CODE (newrhs) == TARGET_EXPR)
5629         newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
5630                          TREE_OPERAND (newrhs, 0));
5631     }
5632
5633   if (newrhs == error_mark_node)
5634     return error_mark_node;
5635
5636   if (c_dialect_objc () && flag_objc_gc)
5637     {
5638       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
5639
5640       if (result)
5641         return result;
5642     }
5643
5644   result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR,
5645                    lhstype, lhs, newrhs);
5646
5647   TREE_SIDE_EFFECTS (result) = 1;
5648   if (!plain_assign)
5649     TREE_NO_WARNING (result) = 1;
5650
5651   /* If we got the LHS in a different type for storing in,
5652      convert the result back to the nominal type of LHS
5653      so that the value we return always has the same type
5654      as the LHS argument.  */
5655
5656   if (olhstype == TREE_TYPE (result))
5657     return result;
5658   if (olhs)
5659     {
5660       result = build2 (COMPOUND_EXPR, olhstype, result, olhs);
5661       TREE_NO_WARNING (result) = 1;
5662       return result;
5663     }
5664   return convert_for_assignment (olhstype, result, "assignment",
5665                                  NULL_TREE, 0);
5666 }
5667
5668 tree
5669 build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
5670 {
5671   if (processing_template_decl)
5672     return build_min_nt (MODOP_EXPR, lhs,
5673                          build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
5674
5675   if (modifycode != NOP_EXPR)
5676     {
5677       tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs,
5678                                 make_node (modifycode),
5679                                 /*overloaded_p=*/NULL);
5680       if (rval)
5681         {
5682           TREE_NO_WARNING (rval) = 1;
5683           return rval;
5684         }
5685     }
5686   return build_modify_expr (lhs, modifycode, rhs);
5687 }
5688
5689 \f
5690 /* Get difference in deltas for different pointer to member function
5691    types.  Returns an integer constant of type PTRDIFF_TYPE_NODE.  If
5692    the conversion is invalid, the constant is zero.  If
5693    ALLOW_INVERSE_P is true, then allow reverse conversions as well.
5694    If C_CAST_P is true this conversion is taking place as part of a
5695    C-style cast.
5696
5697    Note that the naming of FROM and TO is kind of backwards; the return
5698    value is what we add to a TO in order to get a FROM.  They are named
5699    this way because we call this function to find out how to convert from
5700    a pointer to member of FROM to a pointer to member of TO.  */
5701
5702 static tree
5703 get_delta_difference (tree from, tree to,
5704                       bool allow_inverse_p,
5705                       bool c_cast_p)
5706 {
5707   tree binfo;
5708   base_kind kind;
5709   tree result;
5710
5711   /* Assume no conversion is required.  */
5712   result = integer_zero_node;
5713   binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind);
5714   if (kind == bk_inaccessible || kind == bk_ambig)
5715     error ("   in pointer to member function conversion");
5716   else if (binfo)
5717     {
5718       if (kind != bk_via_virtual)
5719         result = BINFO_OFFSET (binfo);
5720       else
5721         {
5722           tree virt_binfo = binfo_from_vbase (binfo);
5723
5724           /* This is a reinterpret cast, we choose to do nothing.  */
5725           if (allow_inverse_p)
5726             warning (0, "pointer to member cast via virtual base %qT",
5727                      BINFO_TYPE (virt_binfo));
5728           else
5729             error ("pointer to member conversion via virtual base %qT",
5730                    BINFO_TYPE (virt_binfo));
5731         }
5732     }
5733   else if (same_type_ignoring_top_level_qualifiers_p (from, to))
5734     /* Pointer to member of incomplete class is permitted*/;
5735   else if (!allow_inverse_p)
5736     {
5737       error_not_base_type (from, to);
5738       error ("   in pointer to member conversion");
5739     }
5740   else
5741     {
5742       binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind);
5743       if (binfo)
5744         {
5745           if (kind != bk_via_virtual)
5746             result = size_diffop (size_zero_node, BINFO_OFFSET (binfo));
5747           else
5748             {
5749               /* This is a reinterpret cast, we choose to do nothing.  */
5750               tree virt_binfo = binfo_from_vbase (binfo);
5751
5752               warning (0, "pointer to member cast via virtual base %qT",
5753                        BINFO_TYPE (virt_binfo));
5754             }
5755         }
5756     }
5757
5758   return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node,
5759                                                       result));
5760 }
5761
5762 /* Return a constructor for the pointer-to-member-function TYPE using
5763    the other components as specified.  */
5764
5765 tree
5766 build_ptrmemfunc1 (tree type, tree delta, tree pfn)
5767 {
5768   tree u = NULL_TREE;
5769   tree delta_field;
5770   tree pfn_field;
5771   VEC(constructor_elt, gc) *v;
5772
5773   /* Pull the FIELD_DECLs out of the type.  */
5774   pfn_field = TYPE_FIELDS (type);
5775   delta_field = TREE_CHAIN (pfn_field);
5776
5777   /* Make sure DELTA has the type we want.  */
5778   delta = convert_and_check (delta_type_node, delta);
5779
5780   /* Finish creating the initializer.  */
5781   v = VEC_alloc(constructor_elt, gc, 2);
5782   CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn);
5783   CONSTRUCTOR_APPEND_ELT(v, delta_field, delta);
5784   u = build_constructor (type, v);
5785   TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta);
5786   TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta);
5787   TREE_STATIC (u) = (TREE_CONSTANT (u)
5788                      && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn))
5789                          != NULL_TREE)
5790                      && (initializer_constant_valid_p (delta, TREE_TYPE (delta))
5791                          != NULL_TREE));
5792   return u;
5793 }
5794
5795 /* Build a constructor for a pointer to member function.  It can be
5796    used to initialize global variables, local variable, or used
5797    as a value in expressions.  TYPE is the POINTER to METHOD_TYPE we
5798    want to be.
5799
5800    If FORCE is nonzero, then force this conversion, even if
5801    we would rather not do it.  Usually set when using an explicit
5802    cast.  A C-style cast is being processed iff C_CAST_P is true.
5803
5804    Return error_mark_node, if something goes wrong.  */
5805
5806 tree
5807 build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p)
5808 {
5809   tree fn;
5810   tree pfn_type;
5811   tree to_type;
5812
5813   if (error_operand_p (pfn))
5814     return error_mark_node;
5815
5816   pfn_type = TREE_TYPE (pfn);
5817   to_type = build_ptrmemfunc_type (type);
5818
5819   /* Handle multiple conversions of pointer to member functions.  */
5820   if (TYPE_PTRMEMFUNC_P (pfn_type))
5821     {
5822       tree delta = NULL_TREE;
5823       tree npfn = NULL_TREE;
5824       tree n;
5825
5826       if (!force
5827           && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL))
5828         error ("invalid conversion to type %qT from type %qT",
5829                to_type, pfn_type);
5830
5831       n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
5832                                 TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
5833                                 force,
5834                                 c_cast_p);
5835
5836       /* We don't have to do any conversion to convert a
5837          pointer-to-member to its own type.  But, we don't want to
5838          just return a PTRMEM_CST if there's an explicit cast; that
5839          cast should make the expression an invalid template argument.  */
5840       if (TREE_CODE (pfn) != PTRMEM_CST)
5841         {
5842           if (same_type_p (to_type, pfn_type))
5843             return pfn;
5844           else if (integer_zerop (n))
5845             return build_reinterpret_cast (to_type, pfn);
5846         }
5847
5848       if (TREE_SIDE_EFFECTS (pfn))
5849         pfn = save_expr (pfn);
5850
5851       /* Obtain the function pointer and the current DELTA.  */
5852       if (TREE_CODE (pfn) == PTRMEM_CST)
5853         expand_ptrmemfunc_cst (pfn, &delta, &npfn);
5854       else
5855         {
5856           npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier);
5857           delta = build_ptrmemfunc_access_expr (pfn, delta_identifier);
5858         }
5859
5860       /* Just adjust the DELTA field.  */
5861       gcc_assert  (same_type_ignoring_top_level_qualifiers_p
5862                    (TREE_TYPE (delta), ptrdiff_type_node));
5863       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta)
5864         n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node);
5865       delta = cp_build_binary_op (PLUS_EXPR, delta, n);
5866       return build_ptrmemfunc1 (to_type, delta, npfn);
5867     }
5868
5869   /* Handle null pointer to member function conversions.  */
5870   if (integer_zerop (pfn))
5871     {
5872       pfn = build_c_cast (type, integer_zero_node);
5873       return build_ptrmemfunc1 (to_type,
5874                                 integer_zero_node,
5875                                 pfn);
5876     }
5877
5878   if (type_unknown_p (pfn))
5879     return instantiate_type (type, pfn, tf_error | tf_warning);
5880
5881   fn = TREE_OPERAND (pfn, 0);
5882   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
5883               /* In a template, we will have preserved the
5884                  OFFSET_REF.  */
5885               || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF));
5886   return make_ptrmem_cst (to_type, fn);
5887 }
5888
5889 /* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST
5890    given by CST.
5891
5892    ??? There is no consistency as to the types returned for the above
5893    values.  Some code acts as if it were a sizetype and some as if it were
5894    integer_type_node.  */
5895
5896 void
5897 expand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn)
5898 {
5899   tree type = TREE_TYPE (cst);
5900   tree fn = PTRMEM_CST_MEMBER (cst);
5901   tree ptr_class, fn_class;
5902
5903   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
5904
5905   /* The class that the function belongs to.  */
5906   fn_class = DECL_CONTEXT (fn);
5907
5908   /* The class that we're creating a pointer to member of.  */
5909   ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type);
5910
5911   /* First, calculate the adjustment to the function's class.  */
5912   *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0,
5913                                  /*c_cast_p=*/0);
5914
5915   if (!DECL_VIRTUAL_P (fn))
5916     *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
5917   else
5918     {
5919       /* If we're dealing with a virtual function, we have to adjust 'this'
5920          again, to point to the base which provides the vtable entry for
5921          fn; the call will do the opposite adjustment.  */
5922       tree orig_class = DECL_CONTEXT (fn);
5923       tree binfo = binfo_or_else (orig_class, fn_class);
5924       *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5925                        *delta, BINFO_OFFSET (binfo));
5926       *delta = fold_if_not_in_template (*delta);
5927
5928       /* We set PFN to the vtable offset at which the function can be
5929          found, plus one (unless ptrmemfunc_vbit_in_delta, in which
5930          case delta is shifted left, and then incremented).  */
5931       *pfn = DECL_VINDEX (fn);
5932       *pfn = build2 (MULT_EXPR, integer_type_node, *pfn,
5933                      TYPE_SIZE_UNIT (vtable_entry_type));
5934       *pfn = fold_if_not_in_template (*pfn);
5935
5936       switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
5937         {
5938         case ptrmemfunc_vbit_in_pfn:
5939           *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn,
5940                          integer_one_node);
5941           *pfn = fold_if_not_in_template (*pfn);
5942           break;
5943
5944         case ptrmemfunc_vbit_in_delta:
5945           *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta),
5946                            *delta, integer_one_node);
5947           *delta = fold_if_not_in_template (*delta);
5948           *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta),
5949                            *delta, integer_one_node);
5950           *delta = fold_if_not_in_template (*delta);
5951           break;
5952
5953         default:
5954           gcc_unreachable ();
5955         }
5956
5957       *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn);
5958       *pfn = fold_if_not_in_template (*pfn);
5959     }
5960 }
5961
5962 /* Return an expression for PFN from the pointer-to-member function
5963    given by T.  */
5964
5965 tree
5966 pfn_from_ptrmemfunc (tree t)
5967 {
5968   if (TREE_CODE (t) == PTRMEM_CST)
5969     {
5970       tree delta;
5971       tree pfn;
5972
5973       expand_ptrmemfunc_cst (t, &delta, &pfn);
5974       if (pfn)
5975         return pfn;
5976     }
5977
5978   return build_ptrmemfunc_access_expr (t, pfn_identifier);
5979 }
5980
5981 /* Convert value RHS to type TYPE as preparation for an assignment to
5982    an lvalue of type TYPE.  ERRTYPE is a string to use in error
5983    messages: "assignment", "return", etc.  If FNDECL is non-NULL, we
5984    are doing the conversion in order to pass the PARMNUMth argument of
5985    FNDECL.  */
5986
5987 static tree
5988 convert_for_assignment (tree type, tree rhs,
5989                         const char *errtype, tree fndecl, int parmnum)
5990 {
5991   tree rhstype;
5992   enum tree_code coder;
5993
5994   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
5995   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
5996     rhs = TREE_OPERAND (rhs, 0);
5997
5998   rhstype = TREE_TYPE (rhs);
5999   coder = TREE_CODE (rhstype);
6000
6001   if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
6002       && vector_types_convertible_p (type, rhstype))
6003     return convert (type, rhs);
6004
6005   if (rhs == error_mark_node || rhstype == error_mark_node)
6006     return error_mark_node;
6007   if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)
6008     return error_mark_node;
6009
6010   /* The RHS of an assignment cannot have void type.  */
6011   if (coder == VOID_TYPE)
6012     {
6013       error ("void value not ignored as it ought to be");
6014       return error_mark_node;
6015     }
6016
6017   /* Simplify the RHS if possible.  */
6018   if (TREE_CODE (rhs) == CONST_DECL)
6019     rhs = DECL_INITIAL (rhs);
6020
6021   if (c_dialect_objc ())
6022     {
6023       int parmno;
6024       tree rname = fndecl;
6025
6026       if (!strcmp (errtype, "assignment"))
6027         parmno = -1;
6028       else if (!strcmp (errtype, "initialization"))
6029         parmno = -2;
6030       else
6031         {
6032           tree selector = objc_message_selector ();
6033
6034           parmno = parmnum;
6035
6036           if (selector && parmno > 1)
6037             {
6038               rname = selector;
6039               parmno -= 1;
6040             }
6041         }
6042
6043       if (objc_compare_types (type, rhstype, parmno, rname))
6044         return convert (type, rhs);
6045     }
6046
6047   /* [expr.ass]
6048
6049      The expression is implicitly converted (clause _conv_) to the
6050      cv-unqualified type of the left operand.
6051
6052      We allow bad conversions here because by the time we get to this point
6053      we are committed to doing the conversion.  If we end up doing a bad
6054      conversion, convert_like will complain.  */
6055   if (!can_convert_arg_bad (type, rhstype, rhs))
6056     {
6057       /* When -Wno-pmf-conversions is use, we just silently allow
6058          conversions from pointers-to-members to plain pointers.  If
6059          the conversion doesn't work, cp_convert will complain.  */
6060       if (!warn_pmf2ptr
6061           && TYPE_PTR_P (type)
6062           && TYPE_PTRMEMFUNC_P (rhstype))
6063         rhs = cp_convert (strip_top_quals (type), rhs);
6064       else
6065         {
6066           /* If the right-hand side has unknown type, then it is an
6067              overloaded function.  Call instantiate_type to get error
6068              messages.  */
6069           if (rhstype == unknown_type_node)
6070             instantiate_type (type, rhs, tf_error | tf_warning);
6071           else if (fndecl)
6072             error ("cannot convert %qT to %qT for argument %qP to %qD",
6073                    rhstype, type, parmnum, fndecl);
6074           else
6075             error ("cannot convert %qT to %qT in %s", rhstype, type, errtype);
6076           return error_mark_node;
6077         }
6078     }
6079   if (warn_missing_format_attribute)
6080     {
6081       const enum tree_code codel = TREE_CODE (type);
6082       if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6083           && coder == codel
6084           && check_missing_format_attribute (type, rhstype))
6085         warning (OPT_Wmissing_format_attribute,
6086                  "%s might be a candidate for a format attribute",
6087                  errtype);
6088     }
6089
6090   return perform_implicit_conversion (strip_top_quals (type), rhs);
6091 }
6092
6093 /* Convert RHS to be of type TYPE.
6094    If EXP is nonzero, it is the target of the initialization.
6095    ERRTYPE is a string to use in error messages.
6096
6097    Two major differences between the behavior of
6098    `convert_for_assignment' and `convert_for_initialization'
6099    are that references are bashed in the former, while
6100    copied in the latter, and aggregates are assigned in
6101    the former (operator=) while initialized in the
6102    latter (X(X&)).
6103
6104    If using constructor make sure no conversion operator exists, if one does
6105    exist, an ambiguity exists.
6106
6107    If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything.  */
6108
6109 tree
6110 convert_for_initialization (tree exp, tree type, tree rhs, int flags,
6111                             const char *errtype, tree fndecl, int parmnum)
6112 {
6113   enum tree_code codel = TREE_CODE (type);
6114   tree rhstype;
6115   enum tree_code coder;
6116
6117   /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
6118      Strip such NOP_EXPRs, since RHS is used in non-lvalue context.  */
6119   if (TREE_CODE (rhs) == NOP_EXPR
6120       && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0))
6121       && codel != REFERENCE_TYPE)
6122     rhs = TREE_OPERAND (rhs, 0);
6123
6124   if (rhs == error_mark_node
6125       || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node))
6126     return error_mark_node;
6127
6128   if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
6129        && TREE_CODE (type) != ARRAY_TYPE
6130        && (TREE_CODE (type) != REFERENCE_TYPE
6131            || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
6132       || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE
6133           && (TREE_CODE (type) != REFERENCE_TYPE
6134               || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE))
6135       || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE)
6136     rhs = decay_conversion (rhs);
6137
6138   rhstype = TREE_TYPE (rhs);
6139   coder = TREE_CODE (rhstype);
6140
6141   if (coder == ERROR_MARK)
6142     return error_mark_node;
6143
6144   /* We accept references to incomplete types, so we can
6145      return here before checking if RHS is of complete type.  */
6146
6147   if (codel == REFERENCE_TYPE)
6148     {
6149       /* This should eventually happen in convert_arguments.  */
6150       int savew = 0, savee = 0;
6151
6152       if (fndecl)
6153         savew = warningcount, savee = errorcount;
6154       rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE,
6155                                   /*cleanup=*/NULL);
6156       if (fndecl)
6157         {
6158           if (warningcount > savew)
6159             warning (0, "in passing argument %P of %q+D", parmnum, fndecl);
6160           else if (errorcount > savee)
6161             error ("in passing argument %P of %q+D", parmnum, fndecl);
6162         }
6163       return rhs;
6164     }
6165
6166   if (exp != 0)
6167     exp = require_complete_type (exp);
6168   if (exp == error_mark_node)
6169     return error_mark_node;
6170
6171   rhstype = non_reference (rhstype);
6172
6173   type = complete_type (type);
6174
6175   if (IS_AGGR_TYPE (type))
6176     return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
6177
6178   return convert_for_assignment (type, rhs, errtype, fndecl, parmnum);
6179 }
6180 \f
6181 /* If RETVAL is the address of, or a reference to, a local variable or
6182    temporary give an appropriate warning.  */
6183
6184 static void
6185 maybe_warn_about_returning_address_of_local (tree retval)
6186 {
6187   tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl));
6188   tree whats_returned = retval;
6189
6190   for (;;)
6191     {
6192       if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
6193         whats_returned = TREE_OPERAND (whats_returned, 1);
6194       else if (TREE_CODE (whats_returned) == CONVERT_EXPR
6195                || TREE_CODE (whats_returned) == NON_LVALUE_EXPR
6196                || TREE_CODE (whats_returned) == NOP_EXPR)
6197         whats_returned = TREE_OPERAND (whats_returned, 0);
6198       else
6199         break;
6200     }
6201
6202   if (TREE_CODE (whats_returned) != ADDR_EXPR)
6203     return;
6204   whats_returned = TREE_OPERAND (whats_returned, 0);
6205
6206   if (TREE_CODE (valtype) == REFERENCE_TYPE)
6207     {
6208       if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR
6209           || TREE_CODE (whats_returned) == TARGET_EXPR)
6210         {
6211           warning (0, "returning reference to temporary");
6212           return;
6213         }
6214       if (TREE_CODE (whats_returned) == VAR_DECL
6215           && DECL_NAME (whats_returned)
6216           && TEMP_NAME_P (DECL_NAME (whats_returned)))
6217         {
6218           warning (0, "reference to non-lvalue returned");
6219           return;
6220         }
6221     }
6222
6223   if (DECL_P (whats_returned)
6224       && DECL_NAME (whats_returned)
6225       && DECL_FUNCTION_SCOPE_P (whats_returned)
6226       && !(TREE_STATIC (whats_returned)
6227            || TREE_PUBLIC (whats_returned)))
6228     {
6229       if (TREE_CODE (valtype) == REFERENCE_TYPE)
6230         warning (0, "reference to local variable %q+D returned",
6231                  whats_returned);
6232       else
6233         warning (0, "address of local variable %q+D returned",
6234                  whats_returned);
6235       return;
6236     }
6237 }
6238
6239 /* Check that returning RETVAL from the current function is valid.
6240    Return an expression explicitly showing all conversions required to
6241    change RETVAL into the function return type, and to assign it to
6242    the DECL_RESULT for the function.  Set *NO_WARNING to true if
6243    code reaches end of non-void function warning shouldn't be issued
6244    on this RETURN_EXPR.  */
6245
6246 tree
6247 check_return_expr (tree retval, bool *no_warning)
6248 {
6249   tree result;
6250   /* The type actually returned by the function, after any
6251      promotions.  */
6252   tree valtype;
6253   int fn_returns_value_p;
6254
6255   *no_warning = false;
6256
6257   /* A `volatile' function is one that isn't supposed to return, ever.
6258      (This is a G++ extension, used to get better code for functions
6259      that call the `volatile' function.)  */
6260   if (TREE_THIS_VOLATILE (current_function_decl))
6261     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6262
6263   /* Check for various simple errors.  */
6264   if (DECL_DESTRUCTOR_P (current_function_decl))
6265     {
6266       if (retval)
6267         error ("returning a value from a destructor");
6268       return NULL_TREE;
6269     }
6270   else if (DECL_CONSTRUCTOR_P (current_function_decl))
6271     {
6272       if (in_function_try_handler)
6273         /* If a return statement appears in a handler of the
6274            function-try-block of a constructor, the program is ill-formed.  */
6275         error ("cannot return from a handler of a function-try-block of a constructor");
6276       else if (retval)
6277         /* You can't return a value from a constructor.  */
6278         error ("returning a value from a constructor");
6279       return NULL_TREE;
6280     }
6281
6282   if (processing_template_decl)
6283     {
6284       current_function_returns_value = 1;
6285       return retval;
6286     }
6287
6288   /* When no explicit return-value is given in a function with a named
6289      return value, the named return value is used.  */
6290   result = DECL_RESULT (current_function_decl);
6291   valtype = TREE_TYPE (result);
6292   gcc_assert (valtype != NULL_TREE);
6293   fn_returns_value_p = !VOID_TYPE_P (valtype);
6294   if (!retval && DECL_NAME (result) && fn_returns_value_p)
6295     retval = result;
6296
6297   /* Check for a return statement with no return value in a function
6298      that's supposed to return a value.  */
6299   if (!retval && fn_returns_value_p)
6300     {
6301       pedwarn ("return-statement with no value, in function returning %qT",
6302                valtype);
6303       /* Clear this, so finish_function won't say that we reach the
6304          end of a non-void function (which we don't, we gave a
6305          return!).  */
6306       current_function_returns_null = 0;
6307       /* And signal caller that TREE_NO_WARNING should be set on the
6308          RETURN_EXPR to avoid control reaches end of non-void function
6309          warnings in tree-cfg.c.  */
6310       *no_warning = true;
6311     }
6312   /* Check for a return statement with a value in a function that
6313      isn't supposed to return a value.  */
6314   else if (retval && !fn_returns_value_p)
6315     {
6316       if (VOID_TYPE_P (TREE_TYPE (retval)))
6317         /* You can return a `void' value from a function of `void'
6318            type.  In that case, we have to evaluate the expression for
6319            its side-effects.  */
6320           finish_expr_stmt (retval);
6321       else
6322         pedwarn ("return-statement with a value, in function "
6323                  "returning 'void'");
6324
6325       current_function_returns_null = 1;
6326
6327       /* There's really no value to return, after all.  */
6328       return NULL_TREE;
6329     }
6330   else if (!retval)
6331     /* Remember that this function can sometimes return without a
6332        value.  */
6333     current_function_returns_null = 1;
6334   else
6335     /* Remember that this function did return a value.  */
6336     current_function_returns_value = 1;
6337
6338   /* Check for erroneous operands -- but after giving ourselves a
6339      chance to provide an error about returning a value from a void
6340      function.  */
6341   if (error_operand_p (retval))
6342     {
6343       current_function_return_value = error_mark_node;
6344       return error_mark_node;
6345     }
6346
6347   /* Only operator new(...) throw(), can return NULL [expr.new/13].  */
6348   if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR
6349        || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR)
6350       && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl))
6351       && ! flag_check_new
6352       && null_ptr_cst_p (retval))
6353     warning (0, "%<operator new%> must not return NULL unless it is "
6354              "declared %<throw()%> (or -fcheck-new is in effect)");
6355
6356   /* Effective C++ rule 15.  See also start_function.  */
6357   if (warn_ecpp
6358       && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR))
6359     {
6360       bool warn = true;
6361
6362       /* The function return type must be a reference to the current
6363         class.  */
6364       if (TREE_CODE (valtype) == REFERENCE_TYPE
6365           && same_type_ignoring_top_level_qualifiers_p
6366               (TREE_TYPE (valtype), TREE_TYPE (current_class_ref)))
6367         {
6368           /* Returning '*this' is obviously OK.  */
6369           if (retval == current_class_ref)
6370             warn = false;
6371           /* If we are calling a function whose return type is the same of
6372              the current class reference, it is ok.  */
6373           else if (TREE_CODE (retval) == INDIRECT_REF
6374                    && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR)
6375             warn = false;
6376         }
6377
6378       if (warn)
6379         warning (0, "%<operator=%> should return a reference to %<*this%>");
6380     }
6381
6382   /* The fabled Named Return Value optimization, as per [class.copy]/15:
6383
6384      [...]      For  a function with a class return type, if the expression
6385      in the return statement is the name of a local  object,  and  the  cv-
6386      unqualified  type  of  the  local  object  is the same as the function
6387      return type, an implementation is permitted to omit creating the  tem-
6388      porary  object  to  hold  the function return value [...]
6389
6390      So, if this is a value-returning function that always returns the same
6391      local variable, remember it.
6392
6393      It might be nice to be more flexible, and choose the first suitable
6394      variable even if the function sometimes returns something else, but
6395      then we run the risk of clobbering the variable we chose if the other
6396      returned expression uses the chosen variable somehow.  And people expect
6397      this restriction, anyway.  (jason 2000-11-19)
6398
6399      See finish_function and finalize_nrv for the rest of this optimization.  */
6400
6401   if (fn_returns_value_p && flag_elide_constructors)
6402     {
6403       if (retval != NULL_TREE
6404           && (current_function_return_value == NULL_TREE
6405               || current_function_return_value == retval)
6406           && TREE_CODE (retval) == VAR_DECL
6407           && DECL_CONTEXT (retval) == current_function_decl
6408           && ! TREE_STATIC (retval)
6409           && (DECL_ALIGN (retval)
6410               >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
6411           && same_type_p ((TYPE_MAIN_VARIANT
6412                            (TREE_TYPE (retval))),
6413                           (TYPE_MAIN_VARIANT
6414                            (TREE_TYPE (TREE_TYPE (current_function_decl))))))
6415         current_function_return_value = retval;
6416       else
6417         current_function_return_value = error_mark_node;
6418     }
6419
6420   /* We don't need to do any conversions when there's nothing being
6421      returned.  */
6422   if (!retval)
6423     return NULL_TREE;
6424
6425   /* Do any required conversions.  */
6426   if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl))
6427     /* No conversions are required.  */
6428     ;
6429   else
6430     {
6431       /* The type the function is declared to return.  */
6432       tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
6433
6434       /* The functype's return type will have been set to void, if it
6435          was an incomplete type.  Just treat this as 'return;' */
6436       if (VOID_TYPE_P (functype))
6437         return error_mark_node;
6438
6439       /* First convert the value to the function's return type, then
6440          to the type of return value's location to handle the
6441          case that functype is smaller than the valtype.  */
6442       retval = convert_for_initialization
6443         (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
6444          "return", NULL_TREE, 0);
6445       retval = convert (valtype, retval);
6446
6447       /* If the conversion failed, treat this just like `return;'.  */
6448       if (retval == error_mark_node)
6449         return retval;
6450       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
6451       else if (! current_function_returns_struct
6452                && TREE_CODE (retval) == TARGET_EXPR
6453                && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
6454         retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
6455                          TREE_OPERAND (retval, 0));
6456       else
6457         maybe_warn_about_returning_address_of_local (retval);
6458     }
6459
6460   /* Actually copy the value returned into the appropriate location.  */
6461   if (retval && retval != result)
6462     retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval);
6463
6464   return retval;
6465 }
6466
6467 \f
6468 /* Returns nonzero if the pointer-type FROM can be converted to the
6469    pointer-type TO via a qualification conversion.  If CONSTP is -1,
6470    then we return nonzero if the pointers are similar, and the
6471    cv-qualification signature of FROM is a proper subset of that of TO.
6472
6473    If CONSTP is positive, then all outer pointers have been
6474    const-qualified.  */
6475
6476 static int
6477 comp_ptr_ttypes_real (tree to, tree from, int constp)
6478 {
6479   bool to_more_cv_qualified = false;
6480
6481   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6482     {
6483       if (TREE_CODE (to) != TREE_CODE (from))
6484         return 0;
6485
6486       if (TREE_CODE (from) == OFFSET_TYPE
6487           && !same_type_p (TYPE_OFFSET_BASETYPE (from),
6488                            TYPE_OFFSET_BASETYPE (to)))
6489         return 0;
6490
6491       /* Const and volatile mean something different for function types,
6492          so the usual checks are not appropriate.  */
6493       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
6494         {
6495           /* In Objective-C++, some types may have been 'volatilized' by
6496              the compiler for EH; when comparing them here, the volatile
6497              qualification must be ignored.  */
6498           bool objc_quals_match = objc_type_quals_match (to, from);
6499
6500           if (!at_least_as_qualified_p (to, from) && !objc_quals_match)
6501             return 0;
6502
6503           if (!at_least_as_qualified_p (from, to) && !objc_quals_match)
6504             {
6505               if (constp == 0)
6506                 return 0;
6507               to_more_cv_qualified = true;
6508             }
6509
6510           if (constp > 0)
6511             constp &= TYPE_READONLY (to);
6512         }
6513
6514       if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to))
6515         return ((constp >= 0 || to_more_cv_qualified)
6516                 && same_type_ignoring_top_level_qualifiers_p (to, from));
6517     }
6518 }
6519
6520 /* When comparing, say, char ** to char const **, this function takes
6521    the 'char *' and 'char const *'.  Do not pass non-pointer/reference
6522    types to this function.  */
6523
6524 int
6525 comp_ptr_ttypes (tree to, tree from)
6526 {
6527   return comp_ptr_ttypes_real (to, from, 1);
6528 }
6529
6530 /* Returns 1 if to and from are (possibly multi-level) pointers to the same
6531    type or inheritance-related types, regardless of cv-quals.  */
6532
6533 int
6534 ptr_reasonably_similar (tree to, tree from)
6535 {
6536   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6537     {
6538       /* Any target type is similar enough to void.  */
6539       if (TREE_CODE (to) == VOID_TYPE
6540           || TREE_CODE (from) == VOID_TYPE)
6541         return 1;
6542
6543       if (TREE_CODE (to) != TREE_CODE (from))
6544         return 0;
6545
6546       if (TREE_CODE (from) == OFFSET_TYPE
6547           && comptypes (TYPE_OFFSET_BASETYPE (to),
6548                         TYPE_OFFSET_BASETYPE (from),
6549                         COMPARE_BASE | COMPARE_DERIVED))
6550         continue;
6551
6552       if (TREE_CODE (to) == VECTOR_TYPE
6553           && vector_types_convertible_p (to, from))
6554         return 1;
6555
6556       if (TREE_CODE (to) == INTEGER_TYPE
6557           && TYPE_PRECISION (to) == TYPE_PRECISION (from))
6558         return 1;
6559
6560       if (TREE_CODE (to) == FUNCTION_TYPE)
6561         return 1;
6562
6563       if (TREE_CODE (to) != POINTER_TYPE)
6564         return comptypes
6565           (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
6566            COMPARE_BASE | COMPARE_DERIVED);
6567     }
6568 }
6569
6570 /* Return true if TO and FROM (both of which are POINTER_TYPEs or
6571    pointer-to-member types) are the same, ignoring cv-qualification at
6572    all levels.  */
6573
6574 bool
6575 comp_ptr_ttypes_const (tree to, tree from)
6576 {
6577   for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
6578     {
6579       if (TREE_CODE (to) != TREE_CODE (from))
6580         return false;
6581
6582       if (TREE_CODE (from) == OFFSET_TYPE
6583           && same_type_p (TYPE_OFFSET_BASETYPE (from),
6584                           TYPE_OFFSET_BASETYPE (to)))
6585           continue;
6586
6587       if (TREE_CODE (to) != POINTER_TYPE)
6588         return same_type_ignoring_top_level_qualifiers_p (to, from);
6589     }
6590 }
6591
6592 /* Returns the type qualifiers for this type, including the qualifiers on the
6593    elements for an array type.  */
6594
6595 int
6596 cp_type_quals (tree type)
6597 {
6598   type = strip_array_types (type);
6599   if (type == error_mark_node)
6600     return TYPE_UNQUALIFIED;
6601   return TYPE_QUALS (type);
6602 }
6603
6604 /* Returns nonzero if the TYPE contains a mutable member.  */
6605
6606 bool
6607 cp_has_mutable_p (tree type)
6608 {
6609   type = strip_array_types (type);
6610
6611   return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type);
6612 }
6613
6614 /* Apply the TYPE_QUALS to the new DECL.  */
6615 void
6616 cp_apply_type_quals_to_decl (int type_quals, tree decl)
6617 {
6618   tree type = TREE_TYPE (decl);
6619
6620   if (type == error_mark_node)
6621     return;
6622
6623   if (TREE_CODE (type) == FUNCTION_TYPE
6624       && type_quals != TYPE_UNQUALIFIED)
6625     {
6626       /* This was an error in C++98 (cv-qualifiers cannot be added to
6627          a function type), but DR 295 makes the code well-formed by
6628          dropping the extra qualifiers. */
6629       if (pedantic)
6630         {
6631           tree bad_type = build_qualified_type (type, type_quals);
6632           pedwarn ("ignoring %qV qualifiers added to function type %qT",
6633                    bad_type, type);
6634         }
6635
6636       TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type);
6637       return;
6638     }
6639
6640   /* Avoid setting TREE_READONLY incorrectly.  */
6641   if (/* If the object has a constructor, the constructor may modify
6642          the object.  */
6643       TYPE_NEEDS_CONSTRUCTING (type)
6644       /* If the type isn't complete, we don't know yet if it will need
6645          constructing.  */
6646       || !COMPLETE_TYPE_P (type)
6647       /* If the type has a mutable component, that component might be
6648          modified.  */
6649       || TYPE_HAS_MUTABLE_P (type))
6650     type_quals &= ~TYPE_QUAL_CONST;
6651
6652   c_apply_type_quals_to_decl (type_quals, decl);
6653 }
6654
6655 /* Subroutine of casts_away_constness.  Make T1 and T2 point at
6656    exemplar types such that casting T1 to T2 is casting away constness
6657    if and only if there is no implicit conversion from T1 to T2.  */
6658
6659 static void
6660 casts_away_constness_r (tree *t1, tree *t2)
6661 {
6662   int quals1;
6663   int quals2;
6664
6665   /* [expr.const.cast]
6666
6667      For multi-level pointer to members and multi-level mixed pointers
6668      and pointers to members (conv.qual), the "member" aspect of a
6669      pointer to member level is ignored when determining if a const
6670      cv-qualifier has been cast away.  */
6671   /* [expr.const.cast]
6672
6673      For  two  pointer types:
6674
6675             X1 is T1cv1,1 * ... cv1,N *   where T1 is not a pointer type
6676             X2 is T2cv2,1 * ... cv2,M *   where T2 is not a pointer type
6677             K is min(N,M)
6678
6679      casting from X1 to X2 casts away constness if, for a non-pointer
6680      type T there does not exist an implicit conversion (clause
6681      _conv_) from:
6682
6683             Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N *
6684
6685      to
6686
6687             Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *.  */
6688   if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1))
6689       || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2)))
6690     {
6691       *t1 = cp_build_qualified_type (void_type_node,
6692                                      cp_type_quals (*t1));
6693       *t2 = cp_build_qualified_type (void_type_node,
6694                                      cp_type_quals (*t2));
6695       return;
6696     }
6697
6698   quals1 = cp_type_quals (*t1);
6699   quals2 = cp_type_quals (*t2);
6700
6701   if (TYPE_PTRMEM_P (*t1))
6702     *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1);
6703   else
6704     *t1 = TREE_TYPE (*t1);
6705   if (TYPE_PTRMEM_P (*t2))
6706     *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2);
6707   else
6708     *t2 = TREE_TYPE (*t2);
6709
6710   casts_away_constness_r (t1, t2);
6711   *t1 = build_pointer_type (*t1);
6712   *t2 = build_pointer_type (*t2);
6713   *t1 = cp_build_qualified_type (*t1, quals1);
6714   *t2 = cp_build_qualified_type (*t2, quals2);
6715 }
6716
6717 /* Returns nonzero if casting from TYPE1 to TYPE2 casts away
6718    constness.  */
6719
6720 static bool
6721 casts_away_constness (tree t1, tree t2)
6722 {
6723   if (TREE_CODE (t2) == REFERENCE_TYPE)
6724     {
6725       /* [expr.const.cast]
6726
6727          Casting from an lvalue of type T1 to an lvalue of type T2
6728          using a reference cast casts away constness if a cast from an
6729          rvalue of type "pointer to T1" to the type "pointer to T2"
6730          casts away constness.  */
6731       t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1);
6732       return casts_away_constness (build_pointer_type (t1),
6733                                    build_pointer_type (TREE_TYPE (t2)));
6734     }
6735
6736   if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2))
6737     /* [expr.const.cast]
6738
6739        Casting from an rvalue of type "pointer to data member of X
6740        of type T1" to the type "pointer to data member of Y of type
6741        T2" casts away constness if a cast from an rvalue of type
6742        "pointer to T1" to the type "pointer to T2" casts away
6743        constness.  */
6744     return casts_away_constness
6745       (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)),
6746        build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2)));
6747
6748   /* Casting away constness is only something that makes sense for
6749      pointer or reference types.  */
6750   if (TREE_CODE (t1) != POINTER_TYPE
6751       || TREE_CODE (t2) != POINTER_TYPE)
6752     return false;
6753
6754   /* Top-level qualifiers don't matter.  */
6755   t1 = TYPE_MAIN_VARIANT (t1);
6756   t2 = TYPE_MAIN_VARIANT (t2);
6757   casts_away_constness_r (&t1, &t2);
6758   if (!can_convert (t2, t1))
6759     return true;
6760
6761   return false;
6762 }
6763
6764 /* If T is a REFERENCE_TYPE return the type to which T refers.
6765    Otherwise, return T itself.  */
6766
6767 tree
6768 non_reference (tree t)
6769 {
6770   if (TREE_CODE (t) == REFERENCE_TYPE)
6771     t = TREE_TYPE (t);
6772   return t;
6773 }
6774
6775
6776 /* Return nonzero if REF is an lvalue valid for this language;
6777    otherwise, print an error message and return zero.  USE says
6778    how the lvalue is being used and so selects the error message.  */
6779
6780 int
6781 lvalue_or_else (tree ref, enum lvalue_use use)
6782 {
6783   int win = lvalue_p (ref);
6784
6785   if (!win)
6786     lvalue_error (use);
6787
6788   return win;
6789 }