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