gcc/cp/typeck.c

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