gcc/cp/typeck.c

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