gcc/cp/typeck.c

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