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