gcc/cp/typeck.c

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