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