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