gcc/cp/typeck.c

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