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