gcc/cp/tree.c

   1 /* Language-dependent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 88, 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 #include "config.h"
  23 #include "system.h"
  24 #include "obstack.h"
  25 #include "tree.h"
  26 #include "cp-tree.h"
  27 #include "flags.h"
  28 #include "rtl.h"
  29 #include "toplev.h"
  30
  31 static tree bot_manip PROTO((tree));
  32 static tree perm_manip PROTO((tree));
  33 static tree build_cplus_array_type_1 PROTO((tree, tree));
  34 static void list_hash_add PROTO((int, tree));
  35 static int list_hash PROTO((tree, tree, tree));
  36 static tree list_hash_lookup PROTO((int, tree, tree, tree));
  37 static void propagate_binfo_offsets PROTO((tree, tree));
  38 static int avoid_overlap PROTO((tree, tree));
  39 static cp_lvalue_kind lvalue_p_1 PROTO((tree, int));
  40 static int equal_functions PROTO((tree, tree));
  41 static tree no_linkage_helper PROTO((tree));
  42 static tree build_srcloc PROTO((char *, int));
  43
  44 #define CEIL(x,y) (((x) + (y) - 1) / (y))
  45
  46 /* If REF is an lvalue, returns the kind of lvalue that REF is.
  47    Otherwise, returns clk_none.  If TREAT_CLASS_RVALUES_AS_LVALUES is
  48    non-zero, rvalues of class type are considered lvalues.  */
  49
  50 static cp_lvalue_kind
  51 lvalue_p_1 (ref, treat_class_rvalues_as_lvalues)
  52      tree ref;
  53      int treat_class_rvalues_as_lvalues;
  54 {
  55   cp_lvalue_kind op1_lvalue_kind = clk_none;
  56   cp_lvalue_kind op2_lvalue_kind = clk_none;
  57
  58   if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
  59     return clk_ordinary;
  60
  61   if (ref == current_class_ptr && flag_this_is_variable <= 0)
  62     return clk_none;
  63
  64   switch (TREE_CODE (ref))
  65     {
  66       /* preincrements and predecrements are valid lvals, provided
  67          what they refer to are valid lvals.  */
  68     case PREINCREMENT_EXPR:
  69     case PREDECREMENT_EXPR:
  70     case SAVE_EXPR:
  71     case UNSAVE_EXPR:
  72     case TRY_CATCH_EXPR:
  73     case WITH_CLEANUP_EXPR:
  74     case REALPART_EXPR:
  75     case IMAGPART_EXPR:
  76     case NOP_EXPR:
  77       return lvalue_p_1 (TREE_OPERAND (ref, 0),
  78                          treat_class_rvalues_as_lvalues);
  79
  80     case COMPONENT_REF:
  81       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
  82                                     treat_class_rvalues_as_lvalues);
  83       if (op1_lvalue_kind
  84           /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
  85              situations.  */
  86           && TREE_CODE (TREE_OPERAND (ref, 1)) == FIELD_DECL
  87           && DECL_BIT_FIELD (TREE_OPERAND (ref, 1)))
  88         {
  89           /* Clear the ordinary bit.  If this object was a class
  90              rvalue we want to preserve that information.  */
  91           op1_lvalue_kind &= ~clk_ordinary;
  92           /* The lvalue is for a btifield.  */
  93           op1_lvalue_kind |= clk_bitfield;
  94         }
  95       return op1_lvalue_kind;
  96
  97     case STRING_CST:
  98       return clk_ordinary;
  99
 100     case VAR_DECL:
 101       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
 102           && DECL_LANG_SPECIFIC (ref)
 103           && DECL_IN_AGGR_P (ref))
 104         return clk_none;
 105     case INDIRECT_REF:
 106     case ARRAY_REF:
 107     case PARM_DECL:
 108     case RESULT_DECL:
 109       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
 110         return clk_ordinary;
 111       break;
 112
 113       /* A currently unresolved scope ref.  */
 114     case SCOPE_REF:
 115       my_friendly_abort (103);
 116     case OFFSET_REF:
 117       if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL)
 118         return clk_ordinary;
 119       /* Fall through.  */
 120     case MAX_EXPR:
 121     case MIN_EXPR:
 122       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
 123                                     treat_class_rvalues_as_lvalues);
 124       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 125                                     treat_class_rvalues_as_lvalues);
 126       break;
 127
 128     case COND_EXPR:
 129       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
 130                                     treat_class_rvalues_as_lvalues);
 131       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
 132                                     treat_class_rvalues_as_lvalues);
 133       break;
 134
 135     case MODIFY_EXPR:
 136       return clk_ordinary;
 137
 138     case COMPOUND_EXPR:
 139       return lvalue_p_1 (TREE_OPERAND (ref, 1),
 140                          treat_class_rvalues_as_lvalues);
 141
 142     case TARGET_EXPR:
 143       return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
 144
 145     case CALL_EXPR:
 146       return ((treat_class_rvalues_as_lvalues
 147                && IS_AGGR_TYPE (TREE_TYPE (ref)))
 148               ? clk_class : clk_none);
 149
 150     case FUNCTION_DECL:
 151       /* All functions (except non-static-member functions) are
 152          lvalues.  */
 153       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
 154               ? clk_none : clk_ordinary);
 155
 156     default:
 157       break;
 158     }
 159
 160   /* If one operand is not an lvalue at all, then this expression is
 161      not an lvalue.  */
 162   if (!op1_lvalue_kind || !op2_lvalue_kind)
 163     return clk_none;
 164
 165   /* Otherwise, it's an lvalue, and it has all the odd properties
 166      contributed by either operand.  */
 167   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
 168   /* It's not an ordinary lvalue if it involves either a bit-field or
 169      a class rvalue.  */
 170   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
 171     op1_lvalue_kind &= ~clk_ordinary;
 172   return op1_lvalue_kind;
 173 }
 174
 175 /* If REF is an lvalue, returns the kind of lvalue that REF is.
 176    Otherwise, returns clk_none.  Lvalues can be assigned, unless they
 177    have TREE_READONLY, or unless they are FUNCTION_DECLs.  Lvalues can
 178    have their address taken, unless they have DECL_REGISTER.  */
 179
 180 cp_lvalue_kind
 181 real_lvalue_p (ref)
 182      tree ref;
 183 {
 184   return lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/0);
 185 }
 186
 187 /* This differs from real_lvalue_p in that class rvalues are
 188    considered lvalues.  */
 189
 190 int
 191 lvalue_p (ref)
 192      tree ref;
 193 {
 194   return
 195     (lvalue_p_1 (ref, /*treat_class_rvalues_as_lvalues=*/1) != clk_none);
 196 }
 197
 198 /* Return nonzero if REF is an lvalue valid for this language;
 199    otherwise, print an error message and return zero.  */
 200
 201 int
 202 lvalue_or_else (ref, string)
 203      tree ref;
 204      const char *string;
 205 {
 206   int win = lvalue_p (ref);
 207   if (! win)
 208     error ("non-lvalue in %s", string);
 209   return win;
 210 }
 211
 212 /* INIT is a CALL_EXPR which needs info about its target.
 213    TYPE is the type that this initialization should appear to have.
 214
 215    Build an encapsulation of the initialization to perform
 216    and return it so that it can be processed by language-independent
 217    and language-specific expression expanders.  */
 218
 219 tree
 220 build_cplus_new (type, init)
 221      tree type;
 222      tree init;
 223 {
 224   tree slot;
 225   tree rval;
 226
 227   /* Make sure that we're not trying to create an instance of an
 228      abstract class.  */
 229   abstract_virtuals_error (NULL_TREE, type);
 230
 231   if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
 232     return convert (type, init);
 233
 234   slot = build (VAR_DECL, type);
 235   DECL_ARTIFICIAL (slot) = 1;
 236   layout_decl (slot, 0);
 237   rval = build (AGGR_INIT_EXPR, type,
 238                 TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), slot);
 239   TREE_SIDE_EFFECTS (rval) = 1;
 240   rval = build (TARGET_EXPR, type, slot, rval, NULL_TREE, NULL_TREE);
 241   TREE_SIDE_EFFECTS (rval) = 1;
 242
 243   return rval;
 244 }
 245
 246 /* Encapsulate the expression INIT in a TARGET_EXPR.  */
 247
 248 tree
 249 get_target_expr (init)
 250      tree init;
 251 {
 252   tree slot;
 253   tree rval;
 254
 255   slot = build (VAR_DECL, TREE_TYPE (init));
 256   DECL_ARTIFICIAL (slot) = 1;
 257   layout_decl (slot, 0);
 258   rval = build (TARGET_EXPR, TREE_TYPE (init), slot, init,
 259                 NULL_TREE, NULL_TREE);
 260   TREE_SIDE_EFFECTS (rval) = 1;
 261
 262   return rval;
 263 }
 264
 265 /* Recursively search EXP for CALL_EXPRs that need cleanups and replace
 266    these CALL_EXPRs with tree nodes that will perform the cleanups.  */
 267
 268 tree
 269 break_out_cleanups (exp)
 270      tree exp;
 271 {
 272   tree tmp = exp;
 273
 274   if (TREE_CODE (tmp) == CALL_EXPR
 275       && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (tmp)))
 276     return build_cplus_new (TREE_TYPE (tmp), tmp);
 277
 278   while (TREE_CODE (tmp) == NOP_EXPR
 279          || TREE_CODE (tmp) == CONVERT_EXPR
 280          || TREE_CODE (tmp) == NON_LVALUE_EXPR)
 281     {
 282       if (TREE_CODE (TREE_OPERAND (tmp, 0)) == CALL_EXPR
 283           && TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (TREE_OPERAND (tmp, 0))))
 284         {
 285           TREE_OPERAND (tmp, 0)
 286             = build_cplus_new (TREE_TYPE (TREE_OPERAND (tmp, 0)),
 287                                TREE_OPERAND (tmp, 0));
 288           break;
 289         }
 290       else
 291         tmp = TREE_OPERAND (tmp, 0);
 292     }
 293   return exp;
 294 }
 295
 296 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
 297    copies where they are found.  Returns a deep copy all nodes transitively
 298    containing CALL_EXPRs.  */
 299
 300 tree
 301 break_out_calls (exp)
 302      tree exp;
 303 {
 304   register tree t1, t2 = NULL_TREE;
 305   register enum tree_code code;
 306   register int changed = 0;
 307   register int i;
 308
 309   if (exp == NULL_TREE)
 310     return exp;
 311
 312   code = TREE_CODE (exp);
 313
 314   if (code == CALL_EXPR)
 315     return copy_node (exp);
 316
 317   /* Don't try and defeat a save_expr, as it should only be done once.  */
 318     if (code == SAVE_EXPR)
 319        return exp;
 320
 321   switch (TREE_CODE_CLASS (code))
 322     {
 323     default:
 324       abort ();
 325
 326     case 'c':  /* a constant */
 327     case 't':  /* a type node */
 328     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
 329       return exp;
 330
 331     case 'd':  /* A decl node */
 332 #if 0                               /* This is bogus.  jason 9/21/94 */
 333
 334       t1 = break_out_calls (DECL_INITIAL (exp));
 335       if (t1 != DECL_INITIAL (exp))
 336         {
 337           exp = copy_node (exp);
 338           DECL_INITIAL (exp) = t1;
 339         }
 340 #endif
 341       return exp;
 342
 343     case 'b':  /* A block node */
 344       {
 345         /* Don't know how to handle these correctly yet.   Must do a
 346            break_out_calls on all DECL_INITIAL values for local variables,
 347            and also break_out_calls on all sub-blocks and sub-statements.  */
 348         abort ();
 349       }
 350       return exp;
 351
 352     case 'e':  /* an expression */
 353     case 'r':  /* a reference */
 354     case 's':  /* an expression with side effects */
 355       for (i = tree_code_length[(int) code] - 1; i >= 0; i--)
 356         {
 357           t1 = break_out_calls (TREE_OPERAND (exp, i));
 358           if (t1 != TREE_OPERAND (exp, i))
 359             {
 360               exp = copy_node (exp);
 361               TREE_OPERAND (exp, i) = t1;
 362             }
 363         }
 364       return exp;
 365
 366     case '<':  /* a comparison expression */
 367     case '2':  /* a binary arithmetic expression */
 368       t2 = break_out_calls (TREE_OPERAND (exp, 1));
 369       if (t2 != TREE_OPERAND (exp, 1))
 370         changed = 1;
 371     case '1':  /* a unary arithmetic expression */
 372       t1 = break_out_calls (TREE_OPERAND (exp, 0));
 373       if (t1 != TREE_OPERAND (exp, 0))
 374         changed = 1;
 375       if (changed)
 376         {
 377           if (tree_code_length[(int) code] == 1)
 378             return build1 (code, TREE_TYPE (exp), t1);
 379           else
 380             return build (code, TREE_TYPE (exp), t1, t2);
 381         }
 382       return exp;
 383     }
 384
 385 }
 386 \f
 387 extern struct obstack *current_obstack;
 388 extern struct obstack permanent_obstack, class_obstack;
 389 extern struct obstack *saveable_obstack;
 390 extern struct obstack *expression_obstack;
 391
 392 /* Here is how primitive or already-canonicalized types' hash
 393    codes are made.  MUST BE CONSISTENT WITH tree.c !!! */
 394 #define TYPE_HASH(TYPE) ((HOST_WIDE_INT) (TYPE) & 0777777)
 395
 396 /* Construct, lay out and return the type of methods belonging to class
 397    BASETYPE and whose arguments are described by ARGTYPES and whose values
 398    are described by RETTYPE.  If each type exists already, reuse it.  */
 399
 400 tree
 401 build_cplus_method_type (basetype, rettype, argtypes)
 402      tree basetype, rettype, argtypes;
 403 {
 404   register tree t;
 405   tree ptype;
 406   int hashcode;
 407
 408   /* Make a node of the sort we want.  */
 409   t = make_node (METHOD_TYPE);
 410
 411   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
 412   TREE_TYPE (t) = rettype;
 413   if (IS_SIGNATURE (basetype))
 414     ptype = build_signature_pointer_type (basetype);
 415   else
 416     ptype = build_pointer_type (basetype);
 417
 418   /* The actual arglist for this function includes a "hidden" argument
 419      which is "this".  Put it into the list of argument types.  */
 420
 421   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
 422   TYPE_ARG_TYPES (t) = argtypes;
 423   TREE_SIDE_EFFECTS (argtypes) = 1;  /* Mark first argtype as "artificial".  */
 424
 425   /* If we already have such a type, use the old one and free this one.
 426      Note that it also frees up the above cons cell if found.  */
 427   hashcode = TYPE_HASH (basetype) + TYPE_HASH (rettype) + type_hash_list (argtypes);
 428   t = type_hash_canon (hashcode, t);
 429
 430   if (TYPE_SIZE (t) == 0)
 431     layout_type (t);
 432
 433   return t;
 434 }
 435
 436 static tree
 437 build_cplus_array_type_1 (elt_type, index_type)
 438      tree elt_type;
 439      tree index_type;
 440 {
 441   tree t;
 442
 443   if (elt_type == error_mark_node || index_type == error_mark_node)
 444     return error_mark_node;
 445
 446   push_obstacks_nochange ();
 447
 448   /* We need a new one.  If both ELT_TYPE and INDEX_TYPE are permanent,
 449      make this permanent too.  */
 450   if (TREE_PERMANENT (elt_type)
 451       && (index_type == 0 || TREE_PERMANENT (index_type)))
 452     end_temporary_allocation ();
 453
 454   if (processing_template_decl
 455       || uses_template_parms (elt_type)
 456       || uses_template_parms (index_type))
 457     {
 458       t = make_node (ARRAY_TYPE);
 459       TREE_TYPE (t) = elt_type;
 460       TYPE_DOMAIN (t) = index_type;
 461     }
 462   else
 463     t = build_array_type (elt_type, index_type);
 464
 465   /* Push these needs up so that initialization takes place
 466      more easily.  */
 467   TYPE_NEEDS_CONSTRUCTING (t)
 468     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
 469   TYPE_NEEDS_DESTRUCTOR (t)
 470     = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
 471   pop_obstacks ();
 472   return t;
 473 }
 474
 475 tree
 476 build_cplus_array_type (elt_type, index_type)
 477      tree elt_type;
 478      tree index_type;
 479 {
 480   tree t;
 481   int type_quals = CP_TYPE_QUALS (elt_type);
 482
 483   elt_type = TYPE_MAIN_VARIANT (elt_type);
 484
 485   t = build_cplus_array_type_1 (elt_type, index_type);
 486
 487   if (type_quals != TYPE_UNQUALIFIED)
 488     t = cp_build_qualified_type (t, type_quals);
 489
 490   return t;
 491 }
 492 \f
 493 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
 494    arrays correctly.  In particular, if TYPE is an array of T's, and
 495    TYPE_QUALS is non-empty, returns an array of qualified T's.  If
 496    at attempt is made to qualify a type illegally, and COMPLAIN is
 497    non-zero, an error is issued.  If COMPLAIN is zero, error_mark_node
 498    is returned.  */
 499
 500 tree
 501 cp_build_qualified_type_real (type, type_quals, complain)
 502      tree type;
 503      int type_quals;
 504      int complain;
 505 {
 506   tree result;
 507
 508   if (type == error_mark_node)
 509     return type;
 510
 511   /* A restrict-qualified pointer type must be a pointer (or reference)
 512      to object or incomplete type.  */
 513   if ((type_quals & TYPE_QUAL_RESTRICT)
 514       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
 515       && (!POINTER_TYPE_P (type)
 516           || TYPE_PTRMEM_P (type)
 517           || TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE))
 518     {
 519       if (complain)
 520         cp_error ("`%T' cannot be `restrict'-qualified", type);
 521       else
 522         return error_mark_node;
 523
 524       type_quals &= ~TYPE_QUAL_RESTRICT;
 525     }
 526
 527   if (type_quals != TYPE_UNQUALIFIED
 528       && TREE_CODE (type) == FUNCTION_TYPE)
 529     {
 530       if (complain)
 531         cp_error ("`%T' cannot be `const'-, `volatile'-, or `restrict'-qualified", type);
 532       else
 533         return error_mark_node;
 534       type_quals = TYPE_UNQUALIFIED;
 535     }
 536   else if (TREE_CODE (type) == ARRAY_TYPE)
 537     {
 538       /* In C++, the qualification really applies to the array element
 539          type.  Obtain the appropriately qualified element type.  */
 540       tree t;
 541       tree element_type
 542         = cp_build_qualified_type_real (TREE_TYPE (type),
 543                                         type_quals,
 544                                         complain);
 545
 546       if (element_type == error_mark_node)
 547         return error_mark_node;
 548
 549       /* See if we already have an identically qualified type.  */
 550       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
 551         if (CP_TYPE_QUALS (t) == type_quals)
 552           break;
 553
 554       /* If we didn't already have it, create it now.  */
 555       if (!t)
 556         {
 557           /* Make a new array type, just like the old one, but with the
 558              appropriately qualified element type.  */
 559           t = build_type_copy (type);
 560           TREE_TYPE (t) = element_type;
 561         }
 562
 563       /* Even if we already had this variant, we update
 564          TYPE_NEEDS_CONSTRUCTING and TYPE_NEEDS_DESTRUCTOR in case
 565          they changed since the variant was originally created.
 566
 567          This seems hokey; if there is some way to use a previous
 568          variant *without* coming through here,
 569          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
 570       TYPE_NEEDS_CONSTRUCTING (t)
 571         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
 572       TYPE_NEEDS_DESTRUCTOR (t)
 573         = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
 574       return t;
 575     }
 576   else if (TYPE_PTRMEMFUNC_P (type))
 577     {
 578       /* For a pointer-to-member type, we can't just return a
 579          cv-qualified version of the RECORD_TYPE.  If we do, we
 580          haven't change the field that contains the actual pointer to
 581          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
 582       tree t;
 583
 584       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
 585       t = cp_build_qualified_type_real (t, type_quals, complain);
 586       return build_ptrmemfunc_type (t);
 587     }
 588
 589   /* Retrieve (or create) the appropriately qualified variant.  */
 590   result = build_qualified_type (type, type_quals);
 591
 592   /* If this was a pointer-to-method type, and we just made a copy,
 593      then we need to clear the cached associated
 594      pointer-to-member-function type; it is not valid for the new
 595      type.  */
 596   if (result != type
 597       && TREE_CODE (type) == POINTER_TYPE
 598       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
 599     TYPE_SET_PTRMEMFUNC_TYPE (result, NULL_TREE);
 600
 601   return result;
 602 }
 603
 604 /* Returns the canonical version of TYPE.  In other words, if TYPE is
 605    a typedef, returns the underlying type.  The cv-qualification of
 606    the type returned matches the type input; they will always be
 607    compatible types.  */
 608
 609 tree
 610 canonical_type_variant (t)
 611      tree t;
 612 {
 613   return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), CP_TYPE_QUALS (t));
 614 }
 615 \f
 616 /* Add OFFSET to all base types of T.
 617
 618    OFFSET, which is a type offset, is number of bytes.
 619
 620    Note that we don't have to worry about having two paths to the
 621    same base type, since this type owns its association list.  */
 622
 623 static void
 624 propagate_binfo_offsets (binfo, offset)
 625      tree binfo;
 626      tree offset;
 627 {
 628   tree binfos = BINFO_BASETYPES (binfo);
 629   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 630
 631   for (i = 0; i < n_baselinks; /* note increment is done in the loop.  */)
 632     {
 633       tree base_binfo = TREE_VEC_ELT (binfos, i);
 634
 635       if (TREE_VIA_VIRTUAL (base_binfo))
 636         i += 1;
 637       else
 638         {
 639           int j;
 640           tree delta = NULL_TREE;
 641
 642           for (j = i+1; j < n_baselinks; j++)
 643             if (! TREE_VIA_VIRTUAL (TREE_VEC_ELT (binfos, j)))
 644               {
 645                 /* The next basetype offset must take into account the space
 646                    between the classes, not just the size of each class.  */
 647                 delta = size_binop (MINUS_EXPR,
 648                                     BINFO_OFFSET (TREE_VEC_ELT (binfos, j)),
 649                                     BINFO_OFFSET (base_binfo));
 650                 break;
 651               }
 652
 653 #if 0
 654           if (BINFO_OFFSET_ZEROP (base_binfo))
 655             BINFO_OFFSET (base_binfo) = offset;
 656           else
 657             BINFO_OFFSET (base_binfo)
 658               = size_binop (PLUS_EXPR, BINFO_OFFSET (base_binfo), offset);
 659 #else
 660           BINFO_OFFSET (base_binfo) = offset;
 661 #endif
 662
 663           propagate_binfo_offsets (base_binfo, offset);
 664
 665           /* Go to our next class that counts for offset propagation.  */
 666           i = j;
 667           if (i < n_baselinks)
 668             offset = size_binop (PLUS_EXPR, offset, delta);
 669         }
 670     }
 671 }
 672
 673 /* Makes new binfos for the indirect bases under BINFO, and updates
 674    BINFO_OFFSET for them and their bases.  */
 675
 676 void
 677 unshare_base_binfos (binfo)
 678      tree binfo;
 679 {
 680   tree binfos = BINFO_BASETYPES (binfo);
 681   tree new_binfo;
 682   int j;
 683
 684   if (binfos == NULL_TREE)
 685     return;
 686
 687   /* Now unshare the structure beneath BINFO.  */
 688   for (j = TREE_VEC_LENGTH (binfos)-1;
 689        j >= 0; j--)
 690     {
 691       tree base_binfo = TREE_VEC_ELT (binfos, j);
 692       new_binfo = TREE_VEC_ELT (binfos, j)
 693         = make_binfo (BINFO_OFFSET (base_binfo),
 694                       base_binfo,
 695                       BINFO_VTABLE (base_binfo),
 696                       BINFO_VIRTUALS (base_binfo));
 697       TREE_VIA_PUBLIC (new_binfo) = TREE_VIA_PUBLIC (base_binfo);
 698       TREE_VIA_PROTECTED (new_binfo) = TREE_VIA_PROTECTED (base_binfo);
 699       TREE_VIA_VIRTUAL (new_binfo) = TREE_VIA_VIRTUAL (base_binfo);
 700       BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;
 701       unshare_base_binfos (new_binfo);
 702     }
 703 }
 704
 705 /* Finish the work of layout_record, now taking virtual bases into account.
 706    Also compute the actual offsets that our base classes will have.
 707    This must be performed after the fields are laid out, since virtual
 708    baseclasses must lay down at the end of the record.
 709
 710    Returns the maximum number of virtual functions any of the
 711    baseclasses provide.  */
 712
 713 int
 714 layout_basetypes (rec, max)
 715      tree rec;
 716      int max;
 717 {
 718   tree binfos = TYPE_BINFO_BASETYPES (rec);
 719   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 720
 721   tree vbase_types;
 722
 723   unsigned int record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
 724   unsigned int desired_align;
 725
 726   /* Record size so far is CONST_SIZE bits, where CONST_SIZE is an integer.  */
 727   register unsigned int const_size = 0;
 728   unsigned int nonvirtual_const_size;
 729
 730 #ifdef STRUCTURE_SIZE_BOUNDARY
 731   /* Packed structures don't need to have minimum size.  */
 732   if (! TYPE_PACKED (rec))
 733     record_align = MAX (record_align, STRUCTURE_SIZE_BOUNDARY);
 734 #endif
 735
 736   /* Get all the virtual base types that this type uses.  The
 737      TREE_VALUE slot holds the virtual baseclass type.  Note that
 738      get_vbase_types makes copies of the virtual base BINFOs, so that
 739      the vbase_types are unshared.  */
 740   vbase_types = CLASSTYPE_VBASECLASSES (rec);
 741
 742   my_friendly_assert (TREE_CODE (TYPE_SIZE (rec)) == INTEGER_CST, 19970302);
 743   const_size = TREE_INT_CST_LOW (TYPE_SIZE (rec));
 744
 745   nonvirtual_const_size = const_size;
 746
 747   while (vbase_types)
 748     {
 749       tree basetype = BINFO_TYPE (vbase_types);
 750       tree offset;
 751
 752       desired_align = TYPE_ALIGN (basetype);
 753       record_align = MAX (record_align, desired_align);
 754
 755       if (const_size == 0)
 756         offset = integer_zero_node;
 757       else
 758         {
 759           /* Give each virtual base type the alignment it wants.  */
 760           const_size = CEIL (const_size, desired_align) * desired_align;
 761           offset = size_int (CEIL (const_size, BITS_PER_UNIT));
 762         }
 763
 764       if (CLASSTYPE_VSIZE (basetype) > max)
 765         max = CLASSTYPE_VSIZE (basetype);
 766       BINFO_OFFSET (vbase_types) = offset;
 767
 768       /* Every virtual baseclass takes a least a UNIT, so that we can
 769          take it's address and get something different for each base.  */
 770       const_size += MAX (BITS_PER_UNIT,
 771                          TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype)));
 772
 773       vbase_types = TREE_CHAIN (vbase_types);
 774     }
 775
 776   if (const_size)
 777     {
 778       /* Because a virtual base might take a single byte above,
 779          we have to re-adjust the total size to make sure it is
 780          a multiple of the alignment.  */
 781       /* Give the whole object the alignment it wants.  */
 782       const_size = CEIL (const_size, record_align) * record_align;
 783     }
 784
 785   /* Set the alignment in the complete type.  We don't set CLASSTYPE_ALIGN
 786    here, as that is for this class, without any virtual base classes.  */
 787   TYPE_ALIGN (rec) = record_align;
 788   if (const_size != nonvirtual_const_size)
 789     {
 790       TYPE_SIZE (rec) = size_int (const_size);
 791       TYPE_SIZE_UNIT (rec) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rec),
 792                                          size_int (BITS_PER_UNIT));
 793     }
 794
 795   /* Now propagate offset information throughout the lattice.  */
 796   for (i = 0; i < n_baseclasses; i++)
 797     {
 798       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 799       register tree basetype = BINFO_TYPE (base_binfo);
 800       tree field = TYPE_FIELDS (rec);
 801
 802       if (TREE_VIA_VIRTUAL (base_binfo))
 803         continue;
 804
 805       my_friendly_assert (TREE_TYPE (field) == basetype, 23897);
 806
 807       if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
 808         cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
 809                     basetype, rec);
 810
 811       BINFO_OFFSET (base_binfo)
 812         = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)),
 813                           BITS_PER_UNIT));
 814       propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
 815       TYPE_FIELDS (rec) = TREE_CHAIN (field);
 816     }
 817
 818   for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
 819        vbase_types = TREE_CHAIN (vbase_types))
 820     {
 821       BINFO_INHERITANCE_CHAIN (vbase_types) = TYPE_BINFO (rec);
 822       unshare_base_binfos (vbase_types);
 823       propagate_binfo_offsets (vbase_types, BINFO_OFFSET (vbase_types));
 824
 825       if (extra_warnings)
 826         {
 827           tree basetype = BINFO_TYPE (vbase_types);
 828           if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
 829             cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
 830                         basetype, rec);
 831         }
 832     }
 833
 834   return max;
 835 }
 836
 837 /* If the empty base field in DECL overlaps with a base of the same type in
 838    NEWDECL, which is either another base field or the first data field of
 839    the class, pad the base just before NEWDECL and return 1.  Otherwise,
 840    return 0.  */
 841
 842 static int
 843 avoid_overlap (decl, newdecl)
 844      tree decl, newdecl;
 845 {
 846   tree field;
 847
 848   if (newdecl == NULL_TREE
 849       || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl)))
 850     return 0;
 851
 852   for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl;
 853        field = TREE_CHAIN (field))
 854     ;
 855
 856   DECL_SIZE (field) = integer_one_node;
 857
 858   return 1;
 859 }
 860
 861 /* Returns a list of fields to stand in for the base class subobjects
 862    of REC.  These fields are later removed by layout_basetypes.  */
 863
 864 tree
 865 build_base_fields (rec)
 866      tree rec;
 867 {
 868   /* Chain to hold all the new FIELD_DECLs which stand in for base class
 869      subobjects.  */
 870   tree base_decls = NULL_TREE;
 871   tree binfos = TYPE_BINFO_BASETYPES (rec);
 872   int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 873   tree decl, nextdecl;
 874   int i, saw_empty = 0;
 875   unsigned int base_align = 0;
 876
 877   for (i = 0; i < n_baseclasses; ++i)
 878     {
 879       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 880       register tree basetype = BINFO_TYPE (base_binfo);
 881
 882       if (TYPE_SIZE (basetype) == 0)
 883         /* This error is now reported in xref_tag, thus giving better
 884            location information.  */
 885         continue;
 886
 887       if (TREE_VIA_VIRTUAL (base_binfo))
 888         continue;
 889
 890       decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, basetype);
 891       DECL_ARTIFICIAL (decl) = 1;
 892       DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = rec;
 893       DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
 894       DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
 895       TREE_CHAIN (decl) = base_decls;
 896       base_decls = decl;
 897
 898       if (! flag_new_abi)
 899         {
 900           /* Brain damage for backwards compatibility.  For no good reason,
 901              the old layout_basetypes made every base at least as large as
 902              the alignment for the bases up to that point, gratuitously
 903              wasting space.  So we do the same thing here.  */
 904           base_align = MAX (base_align, DECL_ALIGN (decl));
 905           DECL_SIZE (decl)
 906             = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
 907                              (int) base_align));
 908         }
 909       else if (DECL_SIZE (decl) == integer_zero_node)
 910         saw_empty = 1;
 911     }
 912
 913   /* Reverse the list of fields so we allocate the bases in the proper
 914      order.  */
 915   base_decls = nreverse (base_decls);
 916
 917   /* In the presence of empty base classes, we run the risk of allocating
 918      two objects of the same class on top of one another.  Avoid that.  */
 919   if (flag_new_abi && saw_empty)
 920     for (decl = base_decls; decl; decl = TREE_CHAIN (decl))
 921       {
 922         if (DECL_SIZE (decl) == integer_zero_node)
 923           {
 924             /* First step through the following bases until we find
 925                an overlap or a non-empty base.  */
 926             for (nextdecl = TREE_CHAIN (decl); nextdecl;
 927                  nextdecl = TREE_CHAIN (nextdecl))
 928               {
 929                 if (avoid_overlap (decl, nextdecl)
 930                     || DECL_SIZE (nextdecl) != integer_zero_node)
 931                   goto nextbase;
 932               }
 933
 934             /* If we're still looking, also check against the first
 935                field.  */
 936             for (nextdecl = TYPE_FIELDS (rec);
 937                  nextdecl && TREE_CODE (nextdecl) != FIELD_DECL;
 938                  nextdecl = TREE_CHAIN (nextdecl))
 939               /* keep looking */;
 940             avoid_overlap (decl, nextdecl);
 941           }
 942       nextbase:;
 943       }
 944
 945   return base_decls;
 946 }
 947
 948 /* Returns list of virtual base class pointers in a FIELD_DECL chain.  */
 949
 950 tree
 951 build_vbase_pointer_fields (rec)
 952      tree rec;
 953 {
 954   /* Chain to hold all the new FIELD_DECLs which point at virtual
 955      base classes.  */
 956   tree vbase_decls = NULL_TREE;
 957   tree binfos = TYPE_BINFO_BASETYPES (rec);
 958   int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
 959   tree decl;
 960   int i;
 961
 962   /* Handle basetypes almost like fields, but record their
 963      offsets differently.  */
 964
 965   for (i = 0; i < n_baseclasses; i++)
 966     {
 967       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 968       register tree basetype = BINFO_TYPE (base_binfo);
 969
 970       if (TYPE_SIZE (basetype) == 0)
 971         /* This error is now reported in xref_tag, thus giving better
 972            location information.  */
 973         continue;
 974
 975       /* All basetypes are recorded in the association list of the
 976          derived type.  */
 977
 978       if (TREE_VIA_VIRTUAL (base_binfo))
 979         {
 980           int j;
 981           const char *name;
 982
 983           /* The offset for a virtual base class is only used in computing
 984              virtual function tables and for initializing virtual base
 985              pointers.  It is built once `get_vbase_types' is called.  */
 986
 987           /* If this basetype can come from another vbase pointer
 988              without an additional indirection, we will share
 989              that pointer.  If an indirection is involved, we
 990              make our own pointer.  */
 991           for (j = 0; j < n_baseclasses; j++)
 992             {
 993               tree other_base_binfo = TREE_VEC_ELT (binfos, j);
 994               if (! TREE_VIA_VIRTUAL (other_base_binfo)
 995                   && binfo_member (basetype,
 996                                    CLASSTYPE_VBASECLASSES (BINFO_TYPE
 997                                                            (other_base_binfo))
 998                                    ))
 999                 goto got_it;
1000             }
1001           FORMAT_VBASE_NAME (name, basetype);
1002           decl = build_lang_field_decl (FIELD_DECL, get_identifier (name),
1003                                         build_pointer_type (basetype));
1004           /* If you change any of the below, take a look at all the
1005              other VFIELD_BASEs and VTABLE_BASEs in the code, and change
1006              them too.  */
1007           DECL_ASSEMBLER_NAME (decl) = get_identifier (VTABLE_BASE);
1008           DECL_VIRTUAL_P (decl) = 1;
1009           DECL_ARTIFICIAL (decl) = 1;
1010           DECL_FIELD_CONTEXT (decl) = rec;
1011           DECL_CLASS_CONTEXT (decl) = rec;
1012           DECL_FCONTEXT (decl) = basetype;
1013           DECL_SAVED_INSNS (decl) = NULL_RTX;
1014           DECL_FIELD_SIZE (decl) = 0;
1015           DECL_ALIGN (decl) = TYPE_ALIGN (ptr_type_node);
1016           TREE_CHAIN (decl) = vbase_decls;
1017           BINFO_VPTR_FIELD (base_binfo) = decl;
1018           vbase_decls = decl;
1019
1020         got_it:
1021           /* The space this decl occupies has already been accounted for.  */
1022           ;
1023         }
1024     }
1025
1026   return vbase_decls;
1027 }
1028 \f
1029 /* Hashing of lists so that we don't make duplicates.
1030    The entry point is `list_hash_canon'.  */
1031
1032 /* Each hash table slot is a bucket containing a chain
1033    of these structures.  */
1034
1035 struct list_hash
1036 {
1037   struct list_hash *next;       /* Next structure in the bucket.  */
1038   int hashcode;                 /* Hash code of this list.  */
1039   tree list;                    /* The list recorded here.  */
1040 };
1041
1042 /* Now here is the hash table.  When recording a list, it is added
1043    to the slot whose index is the hash code mod the table size.
1044    Note that the hash table is used for several kinds of lists.
1045    While all these live in the same table, they are completely independent,
1046    and the hash code is computed differently for each of these.  */
1047
1048 #define TYPE_HASH_SIZE 59
1049 static struct list_hash *list_hash_table[TYPE_HASH_SIZE];
1050
1051 /* Compute a hash code for a list (chain of TREE_LIST nodes
1052    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1053    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
1054
1055 static int
1056 list_hash (purpose, value, chain)
1057      tree purpose, value, chain;
1058 {
1059   register int hashcode = 0;
1060
1061   if (chain)
1062     hashcode += TYPE_HASH (chain);
1063
1064   if (value)
1065     hashcode += TYPE_HASH (value);
1066   else
1067     hashcode += 1007;
1068   if (purpose)
1069     hashcode += TYPE_HASH (purpose);
1070   else
1071     hashcode += 1009;
1072   return hashcode;
1073 }
1074
1075 /* Look in the type hash table for a type isomorphic to TYPE.
1076    If one is found, return it.  Otherwise return 0.  */
1077
1078 static tree
1079 list_hash_lookup (hashcode, purpose, value, chain)
1080      int hashcode;
1081      tree purpose, value, chain;
1082 {
1083   register struct list_hash *h;
1084
1085   for (h = list_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
1086     if (h->hashcode == hashcode
1087         && TREE_PURPOSE (h->list) == purpose
1088         && TREE_VALUE (h->list) == value
1089         && TREE_CHAIN (h->list) == chain)
1090       return h->list;
1091   return 0;
1092 }
1093
1094 /* Add an entry to the list-hash-table
1095    for a list TYPE whose hash code is HASHCODE.  */
1096
1097 static void
1098 list_hash_add (hashcode, list)
1099      int hashcode;
1100      tree list;
1101 {
1102   register struct list_hash *h;
1103
1104   h = (struct list_hash *) obstack_alloc (&class_obstack, sizeof (struct list_hash));
1105   h->hashcode = hashcode;
1106   h->list = list;
1107   h->next = list_hash_table[hashcode % TYPE_HASH_SIZE];
1108   list_hash_table[hashcode % TYPE_HASH_SIZE] = h;
1109 }
1110
1111 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1112    object for an identical list if one already exists.  Otherwise, build a
1113    new one, and record it as the canonical object.  */
1114
1115 /* Set to 1 to debug without canonicalization.  Never set by program.  */
1116
1117 static int debug_no_list_hash = 0;
1118
1119 tree
1120 hash_tree_cons (purpose, value, chain)
1121      tree purpose, value, chain;
1122 {
1123   struct obstack *ambient_obstack = current_obstack;
1124   tree t;
1125   int hashcode = 0;
1126
1127   if (! debug_no_list_hash)
1128     {
1129       hashcode = list_hash (purpose, value, chain);
1130       t = list_hash_lookup (hashcode, purpose, value, chain);
1131       if (t)
1132         return t;
1133     }
1134
1135   current_obstack = &class_obstack;
1136
1137   t = tree_cons (purpose, value, chain);
1138
1139   /* If this is a new list, record it for later reuse.  */
1140   if (! debug_no_list_hash)
1141     list_hash_add (hashcode, t);
1142
1143   current_obstack = ambient_obstack;
1144   return t;
1145 }
1146
1147 /* Constructor for hashed lists.  */
1148
1149 tree
1150 hash_tree_chain (value, chain)
1151      tree value, chain;
1152 {
1153   return hash_tree_cons (NULL_TREE, value, chain);
1154 }
1155
1156 /* Similar, but used for concatenating two lists.  */
1157
1158 tree
1159 hash_chainon (list1, list2)
1160      tree list1, list2;
1161 {
1162   if (list2 == 0)
1163     return list1;
1164   if (list1 == 0)
1165     return list2;
1166   if (TREE_CHAIN (list1) == NULL_TREE)
1167     return hash_tree_chain (TREE_VALUE (list1), list2);
1168   return hash_tree_chain (TREE_VALUE (list1),
1169                           hash_chainon (TREE_CHAIN (list1), list2));
1170 }
1171 \f
1172 /* Build an association between TYPE and some parameters:
1173
1174    OFFSET is the offset added to `this' to convert it to a pointer
1175    of type `TYPE *'
1176
1177    BINFO is the base binfo to use, if we are deriving from one.  This
1178    is necessary, as we want specialized parent binfos from base
1179    classes, so that the VTABLE_NAMEs of bases are for the most derived
1180    type, instead of the simple type.
1181
1182    VTABLE is the virtual function table with which to initialize
1183    sub-objects of type TYPE.
1184
1185    VIRTUALS are the virtual functions sitting in VTABLE.  */
1186
1187 tree
1188 make_binfo (offset, binfo, vtable, virtuals)
1189      tree offset, binfo;
1190      tree vtable, virtuals;
1191 {
1192   tree new_binfo = make_tree_vec (7);
1193   tree type;
1194
1195   if (TREE_CODE (binfo) == TREE_VEC)
1196     type = BINFO_TYPE (binfo);
1197   else
1198     {
1199       type = binfo;
1200       binfo = CLASS_TYPE_P (type) ? TYPE_BINFO (binfo) : NULL_TREE;
1201     }
1202
1203   TREE_TYPE (new_binfo) = TYPE_MAIN_VARIANT (type);
1204   BINFO_OFFSET (new_binfo) = offset;
1205   BINFO_VTABLE (new_binfo) = vtable;
1206   BINFO_VIRTUALS (new_binfo) = virtuals;
1207   BINFO_VPTR_FIELD (new_binfo) = NULL_TREE;
1208
1209   if (binfo && BINFO_BASETYPES (binfo) != NULL_TREE)
1210     BINFO_BASETYPES (new_binfo) = copy_node (BINFO_BASETYPES (binfo));
1211   return new_binfo;
1212 }
1213
1214 /* Return the binfo value for ELEM in TYPE.  */
1215
1216 tree
1217 binfo_value (elem, type)
1218      tree elem;
1219      tree type;
1220 {
1221   if (get_base_distance (elem, type, 0, (tree *)0) == -2)
1222     compiler_error ("base class `%s' ambiguous in binfo_value",
1223                     TYPE_NAME_STRING (elem));
1224   if (elem == type)
1225     return TYPE_BINFO (type);
1226   if (TREE_CODE (elem) == RECORD_TYPE && TYPE_BINFO (elem) == type)
1227     return type;
1228   return get_binfo (elem, type, 0);
1229 }
1230
1231 /* Return a reversed copy of the BINFO-chain given by PATH.  (If the
1232    BINFO_INHERITANCE_CHAIN points from base classes to derived
1233    classes, it will instead point from derived classes to base
1234    classes.)  Returns the first node in the reversed chain.  */
1235
1236 tree
1237 reverse_path (path)
1238      tree path;
1239 {
1240   register tree prev = NULL_TREE, cur;
1241   push_expression_obstack ();
1242   for (cur = path; cur; cur = BINFO_INHERITANCE_CHAIN (cur))
1243     {
1244       tree r = copy_node (cur);
1245       BINFO_INHERITANCE_CHAIN (r) = prev;
1246       prev = r;
1247     }
1248   pop_obstacks ();
1249   return prev;
1250 }
1251
1252 void
1253 debug_binfo (elem)
1254      tree elem;
1255 {
1256   unsigned HOST_WIDE_INT n;
1257   tree virtuals;
1258
1259   fprintf (stderr, "type \"%s\"; offset = %ld\n",
1260            TYPE_NAME_STRING (BINFO_TYPE (elem)),
1261            (long) TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1262   fprintf (stderr, "vtable type:\n");
1263   debug_tree (BINFO_TYPE (elem));
1264   if (BINFO_VTABLE (elem))
1265     fprintf (stderr, "vtable decl \"%s\"\n", IDENTIFIER_POINTER (DECL_NAME (BINFO_VTABLE (elem))));
1266   else
1267     fprintf (stderr, "no vtable decl yet\n");
1268   fprintf (stderr, "virtuals:\n");
1269   virtuals = BINFO_VIRTUALS (elem);
1270
1271   n = skip_rtti_stuff (&virtuals, BINFO_TYPE (elem));
1272
1273   while (virtuals)
1274     {
1275       tree fndecl = TREE_VALUE (virtuals);
1276       fprintf (stderr, "%s [%ld =? %ld]\n",
1277                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1278                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1279       ++n;
1280       virtuals = TREE_CHAIN (virtuals);
1281     }
1282 }
1283
1284 /* Initialize an CPLUS_BINDING node that does not live on an obstack. */
1285
1286 tree
1287 binding_init (node)
1288      struct tree_binding* node;
1289 {
1290   static struct tree_binding* source;
1291   if (!source)
1292     {
1293       extern struct obstack permanent_obstack;
1294       push_obstacks (&permanent_obstack, &permanent_obstack);
1295       source = (struct tree_binding*)make_node (CPLUS_BINDING);
1296       pop_obstacks ();
1297     }
1298   *node = *source;
1299   TREE_PERMANENT ((tree)node) = 0;
1300   return (tree)node;
1301 }
1302
1303 int
1304 count_functions (t)
1305      tree t;
1306 {
1307   int i;
1308   if (TREE_CODE (t) == FUNCTION_DECL)
1309     return 1;
1310   else if (TREE_CODE (t) == OVERLOAD)
1311     {
1312       for (i=0; t; t = OVL_CHAIN (t))
1313         i++;
1314       return i;
1315     }
1316
1317   my_friendly_abort (359);
1318   return 0;
1319 }
1320
1321 int
1322 is_overloaded_fn (x)
1323      tree x;
1324 {
1325   /* A baselink is also considered an overloaded function.  */
1326   if (TREE_CODE (x) == OFFSET_REF)
1327     x = TREE_OPERAND (x, 1);
1328   if (BASELINK_P (x))
1329     x = TREE_VALUE (x);
1330   return (TREE_CODE (x) == FUNCTION_DECL
1331           || TREE_CODE (x) == TEMPLATE_ID_EXPR
1332           || DECL_FUNCTION_TEMPLATE_P (x)
1333           || TREE_CODE (x) == OVERLOAD);
1334 }
1335
1336 int
1337 really_overloaded_fn (x)
1338      tree x;
1339 {
1340   /* A baselink is also considered an overloaded function.  */
1341   if (TREE_CODE (x) == OFFSET_REF)
1342     x = TREE_OPERAND (x, 1);
1343   if (BASELINK_P (x))
1344     x = TREE_VALUE (x);
1345   return (TREE_CODE (x) == OVERLOAD
1346           && (TREE_CHAIN (x) != NULL_TREE
1347               || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x))));
1348 }
1349
1350 tree
1351 get_first_fn (from)
1352      tree from;
1353 {
1354   my_friendly_assert (is_overloaded_fn (from), 9);
1355   /* A baselink is also considered an overloaded function. */
1356   if (BASELINK_P (from))
1357     from = TREE_VALUE (from);
1358   return OVL_CURRENT (from);
1359 }
1360
1361 /* Returns nonzero if T is a ->* or .* expression that refers to a
1362    member function.  */
1363
1364 int
1365 bound_pmf_p (t)
1366      tree t;
1367 {
1368   return (TREE_CODE (t) == OFFSET_REF
1369           && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
1370 }
1371
1372 /* Return a new OVL node, concatenating it with the old one. */
1373
1374 tree
1375 ovl_cons (decl, chain)
1376      tree decl;
1377      tree chain;
1378 {
1379   tree result = make_node (OVERLOAD);
1380   TREE_TYPE (result) = unknown_type_node;
1381   OVL_FUNCTION (result) = decl;
1382   TREE_CHAIN (result) = chain;
1383
1384   return result;
1385 }
1386
1387 /* Same as ovl_cons, but on the scratch_obstack. */
1388
1389 tree
1390 scratch_ovl_cons (value, chain)
1391      tree value, chain;
1392 {
1393   register tree node;
1394   register struct obstack *ambient_obstack = current_obstack;
1395   extern struct obstack *expression_obstack;
1396   current_obstack = expression_obstack;
1397   node = ovl_cons (value, chain);
1398   current_obstack = ambient_obstack;
1399   return node;
1400 }
1401
1402 /* Build a new overloaded function. If this is the first one,
1403    just return it; otherwise, ovl_cons the _DECLs */
1404
1405 tree
1406 build_overload (decl, chain)
1407      tree decl;
1408      tree chain;
1409 {
1410   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1411     return decl;
1412   if (chain && TREE_CODE (chain) != OVERLOAD)
1413     chain = ovl_cons (chain, NULL_TREE);
1414   return ovl_cons (decl, chain);
1415 }
1416
1417 /* Returns true iff functions are equivalent. Equivalent functions are
1418    not identical only if one is a function-local extern function.
1419    This assumes that function-locals don't have TREE_PERMANENT.  */
1420
1421 static int
1422 equal_functions (fn1, fn2)
1423      tree fn1;
1424      tree fn2;
1425 {
1426   if (!TREE_PERMANENT (fn1) || !TREE_PERMANENT (fn2))
1427     return decls_match (fn1, fn2);
1428   return fn1 == fn2;
1429 }
1430
1431 /* True if fn is in ovl. */
1432
1433 int
1434 ovl_member (fn, ovl)
1435      tree fn;
1436      tree ovl;
1437 {
1438   if (ovl == NULL_TREE)
1439     return 0;
1440   if (TREE_CODE (ovl) != OVERLOAD)
1441     return equal_functions (ovl, fn);
1442   for (; ovl; ovl = OVL_CHAIN (ovl))
1443     if (equal_functions (OVL_FUNCTION (ovl), fn))
1444       return 1;
1445   return 0;
1446 }
1447
1448 int
1449 is_aggr_type_2 (t1, t2)
1450      tree t1, t2;
1451 {
1452   if (TREE_CODE (t1) != TREE_CODE (t2))
1453     return 0;
1454   return IS_AGGR_TYPE (t1) && IS_AGGR_TYPE (t2);
1455 }
1456 \f
1457 #define PRINT_RING_SIZE 4
1458
1459 char *
1460 lang_printable_name (decl, v)
1461      tree decl;
1462      int v;
1463 {
1464   static tree decl_ring[PRINT_RING_SIZE];
1465   static char *print_ring[PRINT_RING_SIZE];
1466   static int ring_counter;
1467   int i;
1468
1469   /* Only cache functions.  */
1470   if (v < 2
1471       || TREE_CODE (decl) != FUNCTION_DECL
1472       || DECL_LANG_SPECIFIC (decl) == 0)
1473     return lang_decl_name (decl, v);
1474
1475   /* See if this print name is lying around.  */
1476   for (i = 0; i < PRINT_RING_SIZE; i++)
1477     if (decl_ring[i] == decl)
1478       /* yes, so return it.  */
1479       return print_ring[i];
1480
1481   if (++ring_counter == PRINT_RING_SIZE)
1482     ring_counter = 0;
1483
1484   if (current_function_decl != NULL_TREE)
1485     {
1486       if (decl_ring[ring_counter] == current_function_decl)
1487         ring_counter += 1;
1488       if (ring_counter == PRINT_RING_SIZE)
1489         ring_counter = 0;
1490       if (decl_ring[ring_counter] == current_function_decl)
1491         my_friendly_abort (106);
1492     }
1493
1494   if (print_ring[ring_counter])
1495     free (print_ring[ring_counter]);
1496
1497   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
1498   decl_ring[ring_counter] = decl;
1499   return print_ring[ring_counter];
1500 }
1501 \f
1502 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1503    listed in RAISES.  */
1504
1505 tree
1506 build_exception_variant (type, raises)
1507      tree type;
1508      tree raises;
1509 {
1510   tree v = TYPE_MAIN_VARIANT (type);
1511   int type_quals = TYPE_QUALS (type);
1512
1513   for (; v; v = TYPE_NEXT_VARIANT (v))
1514     if (TYPE_QUALS (v) == type_quals
1515         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1516       return v;
1517
1518   /* Need to build a new variant.  */
1519   v = build_type_copy (type);
1520
1521   if (raises && ! TREE_PERMANENT (raises))
1522     raises = copy_to_permanent (raises);
1523
1524   TYPE_RAISES_EXCEPTIONS (v) = raises;
1525   return v;
1526 }
1527
1528 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new one together with its
1529    lang_specific field and its corresponding TEMPLATE_DECL node */
1530
1531 tree
1532 copy_template_template_parm (t)
1533      tree t;
1534 {
1535   tree template = TYPE_NAME (t);
1536   tree t2;
1537
1538   /* Make sure these end up on the permanent_obstack.  */
1539   push_obstacks_nochange ();
1540   end_temporary_allocation ();
1541
1542   t2 = make_lang_type (TEMPLATE_TEMPLATE_PARM);
1543   template = copy_node (template);
1544   copy_lang_decl (template);
1545
1546   pop_obstacks ();
1547
1548   TREE_TYPE (template) = t2;
1549   TYPE_NAME (t2) = template;
1550   TYPE_STUB_DECL (t2) = template;
1551
1552   /* No need to copy these */
1553   TYPE_FIELDS (t2) = TYPE_FIELDS (t);
1554   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1555     = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
1556   return t2;
1557 }
1558
1559 /* Walk through the tree structure T, applying func.  If func ever returns
1560    non-null, return that value.  */
1561
1562 tree
1563 search_tree (t, func)
1564      tree t;
1565      tree (*func) PROTO((tree));
1566 {
1567 #define TRY(ARG) if (tmp=search_tree (ARG, func), tmp != NULL_TREE) return tmp
1568
1569   tree tmp;
1570   enum tree_code code;
1571
1572   if (t == NULL_TREE)
1573     return t;
1574
1575   tmp = func (t);
1576   if (tmp)
1577     return tmp;
1578
1579   /* Handle some common cases up front.  */
1580   code = TREE_CODE (t);
1581   if (TREE_CODE_CLASS (code) == '1')
1582     {
1583       TRY (TREE_OPERAND (t, 0));
1584       return NULL_TREE;
1585     }
1586   else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
1587     {
1588       TRY (TREE_OPERAND (t, 0));
1589       TRY (TREE_OPERAND (t, 1));
1590       return NULL_TREE;
1591     }
1592
1593   switch (code)
1594     {
1595     case ERROR_MARK:
1596       break;
1597
1598     case IDENTIFIER_NODE:
1599       break;
1600
1601     case VAR_DECL:
1602     case FUNCTION_DECL:
1603     case CONST_DECL:
1604     case TEMPLATE_DECL:
1605     case NAMESPACE_DECL:
1606       break;
1607
1608     case TYPE_DECL:
1609       TRY (TREE_TYPE (t));
1610       break;
1611
1612     case PARM_DECL:
1613       TRY (TREE_TYPE (t));
1614       TRY (TREE_CHAIN (t));
1615       break;
1616
1617     case TREE_LIST:
1618       TRY (TREE_PURPOSE (t));
1619       TRY (TREE_VALUE (t));
1620       TRY (TREE_CHAIN (t));
1621       break;
1622
1623     case OVERLOAD:
1624       TRY (OVL_FUNCTION (t));
1625       TRY (OVL_CHAIN (t));
1626       break;
1627
1628     case TREE_VEC:
1629       {
1630         int len = TREE_VEC_LENGTH (t);
1631
1632         t = copy_node (t);
1633         while (len--)
1634           TRY (TREE_VEC_ELT (t, len));
1635       }
1636       break;
1637
1638     case INTEGER_CST:
1639     case REAL_CST:
1640     case STRING_CST:
1641     case DEFAULT_ARG:
1642       break;
1643
1644     case PTRMEM_CST:
1645       TRY (TREE_TYPE (t));
1646       break;
1647
1648     case COND_EXPR:
1649     case TARGET_EXPR:
1650     case AGGR_INIT_EXPR:
1651     case NEW_EXPR:
1652       TRY (TREE_OPERAND (t, 0));
1653       TRY (TREE_OPERAND (t, 1));
1654       TRY (TREE_OPERAND (t, 2));
1655       break;
1656
1657     case TRUTH_ANDIF_EXPR:
1658     case TRUTH_ORIF_EXPR:
1659     case PREDECREMENT_EXPR:
1660     case PREINCREMENT_EXPR:
1661     case POSTDECREMENT_EXPR:
1662     case POSTINCREMENT_EXPR:
1663     case ARRAY_REF:
1664     case SCOPE_REF:
1665     case TRY_CATCH_EXPR:
1666     case WITH_CLEANUP_EXPR:
1667     case CALL_EXPR:
1668       TRY (TREE_OPERAND (t, 0));
1669       TRY (TREE_OPERAND (t, 1));
1670       break;
1671
1672     case SAVE_EXPR:
1673     case ADDR_EXPR:
1674     case INDIRECT_REF:
1675     case TRUTH_NOT_EXPR:
1676     case COMPONENT_REF:
1677     case CLEANUP_POINT_EXPR:
1678     case LOOKUP_EXPR:
1679       TRY (TREE_OPERAND (t, 0));
1680       break;
1681
1682     case MODOP_EXPR:
1683     case ARROW_EXPR:
1684     case DOTSTAR_EXPR:
1685     case TYPEID_EXPR:
1686       break;
1687
1688     case COMPLEX_CST:
1689       TRY (TREE_REALPART (t));
1690       TRY (TREE_IMAGPART (t));
1691       break;
1692
1693     case CONSTRUCTOR:
1694       TRY (CONSTRUCTOR_ELTS (t));
1695       break;
1696
1697     case TEMPLATE_TEMPLATE_PARM:
1698     case TEMPLATE_PARM_INDEX:
1699     case TEMPLATE_TYPE_PARM:
1700       break;
1701
1702     case BIND_EXPR:
1703       break;
1704
1705     case REAL_TYPE:
1706     case COMPLEX_TYPE:
1707     case VOID_TYPE:
1708     case BOOLEAN_TYPE:
1709     case TYPENAME_TYPE:
1710     case UNION_TYPE:
1711     case ENUMERAL_TYPE:
1712     case TYPEOF_TYPE:
1713       break;
1714
1715     case POINTER_TYPE:
1716     case REFERENCE_TYPE:
1717       TRY (TREE_TYPE (t));
1718       break;
1719
1720     case FUNCTION_TYPE:
1721     case METHOD_TYPE:
1722       TRY (TREE_TYPE (t));
1723       TRY (TYPE_ARG_TYPES (t));
1724       break;
1725
1726     case ARRAY_TYPE:
1727       TRY (TREE_TYPE (t));
1728       TRY (TYPE_DOMAIN (t));
1729       break;
1730
1731     case INTEGER_TYPE:
1732       TRY (TYPE_MAX_VALUE (t));
1733       break;
1734
1735     case OFFSET_TYPE:
1736       TRY (TREE_TYPE (t));
1737       TRY (TYPE_OFFSET_BASETYPE (t));
1738       break;
1739
1740     case RECORD_TYPE:
1741       if (TYPE_PTRMEMFUNC_P (t))
1742         TRY (TYPE_PTRMEMFUNC_FN_TYPE (t));
1743       break;
1744
1745     default:
1746       my_friendly_abort (19990803);
1747     }
1748
1749   return NULL_TREE;
1750
1751 #undef TRY
1752 }
1753
1754 /* Passed to search_tree.  Checks for the use of types with no linkage.  */
1755
1756 static tree
1757 no_linkage_helper (t)
1758      tree t;
1759 {
1760   if (TYPE_P (t)
1761       && (IS_AGGR_TYPE (t) || TREE_CODE (t) == ENUMERAL_TYPE)
1762       && (decl_function_context (TYPE_MAIN_DECL (t))
1763           || ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
1764     return t;
1765   return NULL_TREE;
1766 }
1767
1768 /* Check if the type T depends on a type with no linkage and if so, return
1769    it.  */
1770
1771 tree
1772 no_linkage_check (t)
1773      tree t;
1774 {
1775   /* There's no point in checking linkage on template functions; we
1776      can't know their complete types.  */
1777   if (processing_template_decl)
1778     return NULL_TREE;
1779
1780   t = search_tree (t, no_linkage_helper);
1781   if (t != error_mark_node)
1782     return t;
1783   return NULL_TREE;
1784 }
1785
1786
1787 /* Make copies of all the nodes below T.  If FUNC is non-NULL, call it
1788    for each node.  */
1789
1790 tree
1791 mapcar (t, func)
1792      tree t;
1793      tree (*func) PROTO((tree));
1794 {
1795   tree tmp;
1796
1797   if (t == NULL_TREE)
1798     return t;
1799
1800   if (func)
1801     {
1802       tmp = func (t);
1803       if (tmp)
1804         return tmp;
1805     }
1806
1807   switch (TREE_CODE (t))
1808     {
1809     case ERROR_MARK:
1810       return error_mark_node;
1811
1812     case VAR_DECL:
1813     case FUNCTION_DECL:
1814     case CONST_DECL:
1815       /* Rather than aborting, return error_mark_node.  This allows us
1816          to report a sensible error message on code like this:
1817
1818          void g() { int i; f<i>(7); }
1819
1820          In a case like:
1821
1822            void g() { const int i = 7; f<i>(7); }
1823
1824          however, we must actually return the constant initializer.  */
1825       if (TREE_READONLY_DECL_P (t))
1826         {
1827           tmp = decl_constant_value (t);
1828           if (tmp != t)
1829             return mapcar (tmp, func);
1830         }
1831       return error_mark_node;
1832
1833     case PARM_DECL:
1834       {
1835         tree chain = TREE_CHAIN (t);
1836         t = copy_node (t);
1837         TREE_CHAIN (t) = mapcar (chain, func);
1838         TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1839         DECL_INITIAL (t) = mapcar (DECL_INITIAL (t), func);
1840         DECL_SIZE (t) = mapcar (DECL_SIZE (t), func);
1841         return t;
1842       }
1843
1844     case TREE_LIST:
1845       {
1846         tree chain = TREE_CHAIN (t);
1847         t = copy_node (t);
1848         TREE_PURPOSE (t) = mapcar (TREE_PURPOSE (t), func);
1849         TREE_VALUE (t) = mapcar (TREE_VALUE (t), func);
1850         TREE_CHAIN (t) = mapcar (chain, func);
1851         return t;
1852       }
1853
1854     case OVERLOAD:
1855       {
1856         tree chain = OVL_CHAIN (t);
1857         t = copy_node (t);
1858         OVL_FUNCTION (t) = mapcar (OVL_FUNCTION (t), func);
1859         OVL_CHAIN (t) = mapcar (chain, func);
1860         return t;
1861       }
1862
1863     case TREE_VEC:
1864       {
1865         int len = TREE_VEC_LENGTH (t);
1866
1867         t = copy_node (t);
1868         while (len--)
1869           TREE_VEC_ELT (t, len) = mapcar (TREE_VEC_ELT (t, len), func);
1870         return t;
1871       }
1872
1873     case INTEGER_CST:
1874     case REAL_CST:
1875     case STRING_CST:
1876       return copy_node (t);
1877
1878     case PTRMEM_CST:
1879       t = copy_node (t);
1880       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1881       PTRMEM_CST_MEMBER (t) = mapcar (PTRMEM_CST_MEMBER (t), func);
1882       return t;
1883
1884     case COND_EXPR:
1885     case TARGET_EXPR:
1886     case AGGR_INIT_EXPR:
1887       t = copy_node (t);
1888       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1889       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1890       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1891       return t;
1892
1893     case SAVE_EXPR:
1894       t = copy_node (t);
1895       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1896       return t;
1897
1898     case MODIFY_EXPR:
1899     case PLUS_EXPR:
1900     case MINUS_EXPR:
1901     case MULT_EXPR:
1902     case TRUNC_DIV_EXPR:
1903     case TRUNC_MOD_EXPR:
1904     case MIN_EXPR:
1905     case MAX_EXPR:
1906     case LSHIFT_EXPR:
1907     case RSHIFT_EXPR:
1908     case BIT_IOR_EXPR:
1909     case BIT_XOR_EXPR:
1910     case BIT_AND_EXPR:
1911     case BIT_ANDTC_EXPR:
1912     case TRUTH_ANDIF_EXPR:
1913     case TRUTH_ORIF_EXPR:
1914     case LT_EXPR:
1915     case LE_EXPR:
1916     case GT_EXPR:
1917     case GE_EXPR:
1918     case EQ_EXPR:
1919     case NE_EXPR:
1920     case CEIL_DIV_EXPR:
1921     case FLOOR_DIV_EXPR:
1922     case ROUND_DIV_EXPR:
1923     case CEIL_MOD_EXPR:
1924     case FLOOR_MOD_EXPR:
1925     case ROUND_MOD_EXPR:
1926     case COMPOUND_EXPR:
1927     case PREDECREMENT_EXPR:
1928     case PREINCREMENT_EXPR:
1929     case POSTDECREMENT_EXPR:
1930     case POSTINCREMENT_EXPR:
1931     case ARRAY_REF:
1932     case SCOPE_REF:
1933     case TRY_CATCH_EXPR:
1934     case WITH_CLEANUP_EXPR:
1935       t = copy_node (t);
1936       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1937       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1938       return t;
1939
1940     case CALL_EXPR:
1941       t = copy_node (t);
1942       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1943       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1944       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
1945
1946       /* tree.def says that operand two is RTL, but
1947          make_call_declarator puts trees in there.  */
1948       if (TREE_OPERAND (t, 2)
1949           && TREE_CODE (TREE_OPERAND (t, 2)) == TREE_LIST)
1950         TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
1951       else
1952         TREE_OPERAND (t, 2) = NULL_TREE;
1953       return t;
1954
1955     case CONVERT_EXPR:
1956     case ADDR_EXPR:
1957     case INDIRECT_REF:
1958     case NEGATE_EXPR:
1959     case BIT_NOT_EXPR:
1960     case TRUTH_NOT_EXPR:
1961     case NOP_EXPR:
1962     case COMPONENT_REF:
1963     case CLEANUP_POINT_EXPR:
1964     case NON_LVALUE_EXPR:
1965       t = copy_node (t);
1966       TREE_TYPE (t) = mapcar (TREE_TYPE (t), func);
1967       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
1968       return t;
1969
1970     case POINTER_TYPE:
1971       tmp = build_pointer_type (mapcar (TREE_TYPE (t), func));
1972       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1973     case REFERENCE_TYPE:
1974       tmp = build_reference_type (mapcar (TREE_TYPE (t), func));
1975       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1976     case FUNCTION_TYPE:
1977       tmp = build_function_type (mapcar (TREE_TYPE (t), func),
1978                                  mapcar (TYPE_ARG_TYPES (t), func));
1979       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1980     case ARRAY_TYPE:
1981       tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
1982                                     mapcar (TYPE_DOMAIN (t), func));
1983       return cp_build_qualified_type (tmp, CP_TYPE_QUALS (t));
1984     case INTEGER_TYPE:
1985       tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
1986       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1987     case OFFSET_TYPE:
1988       tmp = build_offset_type (mapcar (TYPE_OFFSET_BASETYPE (t), func),
1989                                mapcar (TREE_TYPE (t), func));
1990       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1991     case METHOD_TYPE:
1992       tmp = build_cplus_method_type
1993         (mapcar (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))), func),
1994          mapcar (TREE_TYPE (t), func),
1995          mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
1996       return cp_build_qualified_type (tmp, TYPE_QUALS (t));
1997
1998     case COMPLEX_CST:
1999       t = copy_node (t);
2000       TREE_REALPART (t) = mapcar (TREE_REALPART (t), func);
2001       TREE_IMAGPART (t) = mapcar (TREE_REALPART (t), func);
2002       return t;
2003
2004     case CONSTRUCTOR:
2005       t = copy_node (t);
2006       CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
2007       return t;
2008
2009     case TEMPLATE_TEMPLATE_PARM:
2010       return copy_template_template_parm (t);
2011
2012     case BIND_EXPR:
2013       t = copy_node (t);
2014       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2015       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
2016       TREE_OPERAND (t, 2) = NULL_TREE;
2017       return t;
2018
2019     case NEW_EXPR:
2020       t = copy_node (t);
2021       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2022       TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
2023       TREE_OPERAND (t, 2) = mapcar (TREE_OPERAND (t, 2), func);
2024       return t;
2025
2026     case LOOKUP_EXPR:
2027       t = copy_node (t);
2028       TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
2029       return t;
2030
2031     case RECORD_TYPE:
2032       if (TYPE_PTRMEMFUNC_P (t))
2033         return build_ptrmemfunc_type
2034           (mapcar (TYPE_PTRMEMFUNC_FN_TYPE (t), func));
2035       /* else fall through */
2036
2037       /*  This list is incomplete, but should suffice for now.
2038           It is very important that `sorry' not call
2039           `report_error_function'.  That could cause an infinite loop.  */
2040     default:
2041       sorry ("initializer contains unrecognized tree code");
2042       return error_mark_node;
2043
2044     }
2045   my_friendly_abort (107);
2046   /* NOTREACHED */
2047   return NULL_TREE;
2048 }
2049
2050 /* Returns T if T is allocated on the permanent obstack, NULL_TREE
2051    otherwise.  */
2052
2053 tree
2054 permanent_p (t)
2055      tree t;
2056 {
2057   return TREE_PERMANENT (t) ? t : NULL_TREE;
2058 }
2059
2060 static tree
2061 perm_manip (t)
2062      tree t;
2063 {
2064   if (TREE_PERMANENT (t))
2065     return t;
2066
2067   /* Support `void f () { extern int i; A<&i> a; }' */
2068   if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
2069       && TREE_PUBLIC (t))
2070     {
2071       t = copy_node (t);
2072
2073       /* copy_rtx won't make a new SYMBOL_REF, so call make_decl_rtl again.  */
2074       DECL_RTL (t) = 0;
2075       make_decl_rtl (t, NULL_PTR, 1);
2076
2077       return t;
2078     }
2079   return NULL_TREE;
2080 }
2081
2082 /* Assuming T is a node built bottom-up, make it all exist on
2083    permanent obstack, if it is not permanent already.  */
2084
2085 tree
2086 copy_to_permanent (t)
2087      tree t;
2088 {
2089   if (t == NULL_TREE || TREE_PERMANENT (t))
2090     return t;
2091
2092   push_obstacks_nochange ();
2093   end_temporary_allocation ();
2094
2095   t = mapcar (t, perm_manip);
2096
2097   pop_obstacks ();
2098
2099   return t;
2100 }
2101
2102 #ifdef GATHER_STATISTICS
2103 extern int depth_reached;
2104 #endif
2105
2106 void
2107 print_lang_statistics ()
2108 {
2109   extern struct obstack decl_obstack;
2110   print_obstack_statistics ("class_obstack", &class_obstack);
2111   print_obstack_statistics ("decl_obstack", &decl_obstack);
2112   print_search_statistics ();
2113   print_class_statistics ();
2114 #ifdef GATHER_STATISTICS
2115   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
2116            depth_reached);
2117 #endif
2118 }
2119
2120 /* This is used by the `assert' macro.  It is provided in libgcc.a,
2121    which `cc' doesn't know how to link.  Note that the C++ front-end
2122    no longer actually uses the `assert' macro (instead, it calls
2123    my_friendly_assert).  But all of the back-end files still need this.  */
2124
2125 void
2126 __eprintf (string, expression, line, filename)
2127      const char *string;
2128      const char *expression;
2129      unsigned line;
2130      const char *filename;
2131 {
2132   fprintf (stderr, string, expression, line, filename);
2133   fflush (stderr);
2134   abort ();
2135 }
2136
2137 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2138    (which is an ARRAY_TYPE).  This counts only elements of the top
2139    array.  */
2140
2141 tree
2142 array_type_nelts_top (type)
2143      tree type;
2144 {
2145   return fold (build (PLUS_EXPR, sizetype,
2146                       array_type_nelts (type),
2147                       integer_one_node));
2148 }
2149
2150 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2151    (which is an ARRAY_TYPE).  This one is a recursive count of all
2152    ARRAY_TYPEs that are clumped together.  */
2153
2154 tree
2155 array_type_nelts_total (type)
2156      tree type;
2157 {
2158   tree sz = array_type_nelts_top (type);
2159   type = TREE_TYPE (type);
2160   while (TREE_CODE (type) == ARRAY_TYPE)
2161     {
2162       tree n = array_type_nelts_top (type);
2163       sz = fold (build (MULT_EXPR, sizetype, sz, n));
2164       type = TREE_TYPE (type);
2165     }
2166   return sz;
2167 }
2168
2169 static
2170 tree
2171 bot_manip (t)
2172      tree t;
2173 {
2174   if (TREE_CODE (t) != TREE_LIST && ! TREE_SIDE_EFFECTS (t))
2175     return t;
2176   else if (TREE_CODE (t) == TARGET_EXPR)
2177     {
2178       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
2179         {
2180           mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));
2181           return build_cplus_new
2182             (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
2183         }
2184       t = copy_node (t);
2185       TREE_OPERAND (t, 0) = build (VAR_DECL, TREE_TYPE (t));
2186       layout_decl (TREE_OPERAND (t, 0), 0);
2187       return t;
2188     }
2189   else if (TREE_CODE (t) == CALL_EXPR)
2190     mark_used (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2191
2192   return NULL_TREE;
2193 }
2194
2195 /* Actually, we'll just clean out the target exprs for the moment.  */
2196
2197 tree
2198 break_out_target_exprs (t)
2199      tree t;
2200 {
2201   return mapcar (t, bot_manip);
2202 }
2203
2204 /* Obstack used for allocating nodes in template function and variable
2205    definitions.  */
2206
2207 /* Similar to `build_nt', except we build
2208    on the permanent_obstack, regardless.  */
2209
2210 tree
2211 build_min_nt VPROTO((enum tree_code code, ...))
2212 {
2213 #ifndef __STDC__
2214   enum tree_code code;
2215 #endif
2216   register struct obstack *ambient_obstack = expression_obstack;
2217   va_list p;
2218   register tree t;
2219   register int length;
2220   register int i;
2221
2222   VA_START (p, code);
2223
2224 #ifndef __STDC__
2225   code = va_arg (p, enum tree_code);
2226 #endif
2227
2228   expression_obstack = &permanent_obstack;
2229
2230   t = make_node (code);
2231   length = tree_code_length[(int) code];
2232   TREE_COMPLEXITY (t) = lineno;
2233
2234   for (i = 0; i < length; i++)
2235     {
2236       tree x = va_arg (p, tree);
2237       TREE_OPERAND (t, i) = copy_to_permanent (x);
2238     }
2239
2240   va_end (p);
2241   expression_obstack = ambient_obstack;
2242   return t;
2243 }
2244
2245 /* Similar to `build', except we build
2246    on the permanent_obstack, regardless.  */
2247
2248 tree
2249 build_min VPROTO((enum tree_code code, tree tt, ...))
2250 {
2251 #ifndef __STDC__
2252   enum tree_code code;
2253   tree tt;
2254 #endif
2255   register struct obstack *ambient_obstack = expression_obstack;
2256   va_list p;
2257   register tree t;
2258   register int length;
2259   register int i;
2260
2261   VA_START (p, tt);
2262
2263 #ifndef __STDC__
2264   code = va_arg (p, enum tree_code);
2265   tt = va_arg (p, tree);
2266 #endif
2267
2268   expression_obstack = &permanent_obstack;
2269
2270   t = make_node (code);
2271   length = tree_code_length[(int) code];
2272   TREE_TYPE (t) = copy_to_permanent (tt);
2273   TREE_COMPLEXITY (t) = lineno;
2274
2275   for (i = 0; i < length; i++)
2276     {
2277       tree x = va_arg (p, tree);
2278       TREE_OPERAND (t, i) = copy_to_permanent (x);
2279     }
2280
2281   va_end (p);
2282   expression_obstack = ambient_obstack;
2283   return t;
2284 }
2285
2286 /* Same as `tree_cons' but make a permanent object.  */
2287
2288 tree
2289 min_tree_cons (purpose, value, chain)
2290      tree purpose, value, chain;
2291 {
2292   register tree node;
2293   register struct obstack *ambient_obstack = current_obstack;
2294   current_obstack = &permanent_obstack;
2295
2296   node = tree_cons (copy_to_permanent (purpose),
2297                     copy_to_permanent (value), chain);
2298   current_obstack = ambient_obstack;
2299   return node;
2300 }
2301
2302 tree
2303 get_type_decl (t)
2304      tree t;
2305 {
2306   if (TREE_CODE (t) == TYPE_DECL)
2307     return t;
2308   if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
2309     return TYPE_STUB_DECL (t);
2310
2311   my_friendly_abort (42);
2312
2313   /* Stop compiler from complaining control reaches end of non-void function.  */
2314   return 0;
2315 }
2316
2317 int
2318 can_free (obstack, t)
2319      struct obstack *obstack;
2320      tree t;
2321 {
2322   int size = 0;
2323
2324   if (TREE_CODE (t) == TREE_VEC)
2325     size = (TREE_VEC_LENGTH (t)-1) * sizeof (tree) + sizeof (struct tree_vec);
2326   else
2327     my_friendly_abort (42);
2328
2329 #define ROUND(x) ((x + obstack_alignment_mask (obstack)) \
2330                   & ~ obstack_alignment_mask (obstack))
2331   if ((char *)t + ROUND (size) == obstack_next_free (obstack))
2332     return 1;
2333 #undef ROUND
2334
2335   return 0;
2336 }
2337
2338 /* Return first vector element whose BINFO_TYPE is ELEM.
2339    Return 0 if ELEM is not in VEC.  VEC may be NULL_TREE.  */
2340
2341 tree
2342 vec_binfo_member (elem, vec)
2343      tree elem, vec;
2344 {
2345   int i;
2346
2347   if (vec)
2348     for (i = 0; i < TREE_VEC_LENGTH (vec); ++i)
2349       if (same_type_p (elem, BINFO_TYPE (TREE_VEC_ELT (vec, i))))
2350         return TREE_VEC_ELT (vec, i);
2351
2352   return NULL_TREE;
2353 }
2354
2355 /* Kludge around the fact that DECL_CONTEXT for virtual functions returns
2356    the wrong thing for decl_function_context.  Hopefully the uses in the
2357    backend won't matter, since we don't need a static chain for local class
2358    methods.  FIXME!  */
2359
2360 tree
2361 hack_decl_function_context (decl)
2362      tree decl;
2363 {
2364   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FUNCTION_MEMBER_P (decl))
2365     return decl_function_context (TYPE_MAIN_DECL (DECL_CLASS_CONTEXT (decl)));
2366   return decl_function_context (decl);
2367 }
2368
2369 /* Returns the namespace that contains DECL, whether directly or
2370    indirectly.  */
2371
2372 tree
2373 decl_namespace_context (decl)
2374      tree decl;
2375 {
2376   while (1)
2377     {
2378       if (TREE_CODE (decl) == NAMESPACE_DECL)
2379         return decl;
2380       else if (TYPE_P (decl))
2381         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2382       else
2383         decl = CP_DECL_CONTEXT (decl);
2384     }
2385 }
2386
2387 /* Return truthvalue of whether T1 is the same tree structure as T2.
2388    Return 1 if they are the same.
2389    Return 0 if they are understandably different.
2390    Return -1 if either contains tree structure not understood by
2391    this function.  */
2392
2393 int
2394 cp_tree_equal (t1, t2)
2395      tree t1, t2;
2396 {
2397   register enum tree_code code1, code2;
2398   int cmp;
2399
2400   if (t1 == t2)
2401     return 1;
2402   if (t1 == 0 || t2 == 0)
2403     return 0;
2404
2405   code1 = TREE_CODE (t1);
2406   code2 = TREE_CODE (t2);
2407
2408   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2409     {
2410       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2411         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2412       else
2413         return cp_tree_equal (TREE_OPERAND (t1, 0), t2);
2414     }
2415   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2416            || code2 == NON_LVALUE_EXPR)
2417     return cp_tree_equal (t1, TREE_OPERAND (t2, 0));
2418
2419   if (code1 != code2)
2420     return 0;
2421
2422   switch (code1)
2423     {
2424     case INTEGER_CST:
2425       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2426         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2427
2428     case REAL_CST:
2429       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2430
2431     case STRING_CST:
2432       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2433         && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2434                   TREE_STRING_LENGTH (t1));
2435
2436     case CONSTRUCTOR:
2437       /* We need to do this when determining whether or not two
2438          non-type pointer to member function template arguments
2439          are the same.  */
2440       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2441             /* The first operand is RTL.  */
2442             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2443         return 0;
2444       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2445
2446     case TREE_LIST:
2447       cmp = cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2448       if (cmp <= 0)
2449         return cmp;
2450       cmp = cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2));
2451       if (cmp <= 0)
2452         return cmp;
2453       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2454
2455     case SAVE_EXPR:
2456       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2457
2458     case CALL_EXPR:
2459       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2460       if (cmp <= 0)
2461         return cmp;
2462       return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2463
2464     case TARGET_EXPR:
2465       /* Special case: if either target is an unallocated VAR_DECL,
2466          it means that it's going to be unified with whatever the
2467          TARGET_EXPR is really supposed to initialize, so treat it
2468          as being equivalent to anything.  */
2469       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2470            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2471            && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2472           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2473               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2474               && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2475         cmp = 1;
2476       else
2477         cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2478       if (cmp <= 0)
2479         return cmp;
2480       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2481
2482     case WITH_CLEANUP_EXPR:
2483       cmp = cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2484       if (cmp <= 0)
2485         return cmp;
2486       return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2487
2488     case COMPONENT_REF:
2489       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2490         return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2491       return 0;
2492
2493     case VAR_DECL:
2494     case PARM_DECL:
2495     case CONST_DECL:
2496     case FUNCTION_DECL:
2497       return 0;
2498
2499     case TEMPLATE_PARM_INDEX:
2500       return TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2501         && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2);
2502
2503     case SIZEOF_EXPR:
2504     case ALIGNOF_EXPR:
2505       if (TREE_CODE (TREE_OPERAND (t1, 0)) != TREE_CODE (TREE_OPERAND (t2, 0)))
2506         return 0;
2507       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t1, 0))) == 't')
2508         return same_type_p (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2509       break;
2510
2511     case PTRMEM_CST:
2512       /* Two pointer-to-members are the same if they point to the same
2513          field or function in the same class.  */
2514       return (PTRMEM_CST_MEMBER (t1) == PTRMEM_CST_MEMBER (t2)
2515               && same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2)));
2516
2517     default:
2518       break;
2519     }
2520
2521   switch (TREE_CODE_CLASS (code1))
2522     {
2523       int i;
2524     case '1':
2525     case '2':
2526     case '<':
2527     case 'e':
2528     case 'r':
2529     case 's':
2530       cmp = 1;
2531       for (i=0; i<tree_code_length[(int) code1]; ++i)
2532         {
2533           cmp = cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
2534           if (cmp <= 0)
2535             return cmp;
2536         }
2537       return cmp;
2538     }
2539
2540   return -1;
2541 }
2542
2543 /* Similar to make_tree_vec, but build on the momentary_obstack.
2544    Thus, these vectors are really and truly temporary.  */
2545
2546 tree
2547 make_temp_vec (len)
2548      int len;
2549 {
2550   register tree node;
2551   push_expression_obstack ();
2552   node = make_tree_vec (len);
2553   pop_obstacks ();
2554   return node;
2555 }
2556
2557 /* Build a wrapper around some pointer PTR so we can use it as a tree.  */
2558
2559 tree
2560 build_ptr_wrapper (ptr)
2561      void *ptr;
2562 {
2563   tree t = make_node (WRAPPER);
2564   WRAPPER_PTR (t) = ptr;
2565   return t;
2566 }
2567
2568 /* Same, but on the expression_obstack.  */
2569
2570 tree
2571 build_expr_ptr_wrapper (ptr)
2572      void *ptr;
2573 {
2574   tree t;
2575   push_expression_obstack ();
2576   t = build_ptr_wrapper (ptr);
2577   pop_obstacks ();
2578   return t;
2579 }
2580
2581 /* Build a wrapper around some integer I so we can use it as a tree.  */
2582
2583 tree
2584 build_int_wrapper (i)
2585      int i;
2586 {
2587   tree t = make_node (WRAPPER);
2588   WRAPPER_INT (t) = i;
2589   return t;
2590 }
2591
2592 static tree
2593 build_srcloc (file, line)
2594      char *file;
2595      int line;
2596 {
2597   tree t;
2598
2599   /* Make sure that we put these on the permanent obstack; up in
2600      add_pending_template, we pass this return value into perm_tree_cons,
2601      which also puts it on the permanent_obstack.  However, this wasn't
2602      explicitly doing the same.  */
2603   register struct obstack *ambient_obstack = current_obstack;
2604   current_obstack = &permanent_obstack;
2605
2606   t = make_node (SRCLOC);
2607   SRCLOC_FILE (t) = file;
2608   SRCLOC_LINE (t) = line;
2609
2610   current_obstack = ambient_obstack;
2611
2612   return t;
2613 }
2614
2615 tree
2616 build_srcloc_here ()
2617 {
2618   return build_srcloc (input_filename, lineno);
2619 }
2620
2621 void
2622 push_expression_obstack ()
2623 {
2624   push_obstacks_nochange ();
2625   current_obstack = expression_obstack;
2626 }
2627
2628 /* The type of ARG when used as an lvalue.  */
2629
2630 tree
2631 lvalue_type (arg)
2632      tree arg;
2633 {
2634   tree type = TREE_TYPE (arg);
2635   if (TREE_CODE (arg) == OVERLOAD)
2636     type = unknown_type_node;
2637   return type;
2638 }
2639
2640 /* The type of ARG for printing error messages; denote lvalues with
2641    reference types.  */
2642
2643 tree
2644 error_type (arg)
2645      tree arg;
2646 {
2647   tree type = TREE_TYPE (arg);
2648   if (TREE_CODE (type) == ARRAY_TYPE)
2649     ;
2650   else if (real_lvalue_p (arg))
2651     type = build_reference_type (lvalue_type (arg));
2652   else if (IS_AGGR_TYPE (type))
2653     type = lvalue_type (arg);
2654
2655   return type;
2656 }
2657
2658 /* Does FUNCTION use a variable-length argument list?  */
2659
2660 int
2661 varargs_function_p (function)
2662      tree function;
2663 {
2664   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2665   for (; parm; parm = TREE_CHAIN (parm))
2666     if (TREE_VALUE (parm) == void_type_node)
2667       return 0;
2668   return 1;
2669 }
2670
2671 /* Returns 1 if decl is a member of a class.  */
2672
2673 int
2674 member_p (decl)
2675      tree decl;
2676 {
2677   tree ctx = DECL_CONTEXT (decl);
2678   return (ctx && TREE_CODE_CLASS (TREE_CODE (ctx)) == 't');
2679 }
2680
2681 /* Create a placeholder for member access where we don't actually have an
2682    object that the access is against.  */
2683
2684 tree
2685 build_dummy_object (type)
2686      tree type;
2687 {
2688   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2689   return build_indirect_ref (decl, NULL_PTR);
2690 }
2691
2692 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2693    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2694    binfo path from current_class_type to TYPE, or 0.  */
2695
2696 tree
2697 maybe_dummy_object (type, binfop)
2698      tree type;
2699      tree *binfop;
2700 {
2701   tree decl, context;
2702
2703   if (current_class_type
2704       && get_base_distance (type, current_class_type, 0, binfop) != -1)
2705     context = current_class_type;
2706   else
2707     {
2708       /* Reference from a nested class member function.  */
2709       context = type;
2710       if (binfop)
2711         *binfop = TYPE_BINFO (type);
2712     }
2713
2714   if (current_class_ref && context == current_class_type)
2715     decl = current_class_ref;
2716   else
2717     decl = build_dummy_object (context);
2718
2719   return decl;
2720 }
2721
2722 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2723
2724 int
2725 is_dummy_object (ob)
2726      tree ob;
2727 {
2728   if (TREE_CODE (ob) == INDIRECT_REF)
2729     ob = TREE_OPERAND (ob, 0);
2730   return (TREE_CODE (ob) == NOP_EXPR
2731           && TREE_OPERAND (ob, 0) == void_zero_node);
2732 }
2733
2734 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2735
2736 int
2737 pod_type_p (t)
2738      tree t;
2739 {
2740   while (TREE_CODE (t) == ARRAY_TYPE)
2741     t = TREE_TYPE (t);
2742
2743   if (INTEGRAL_TYPE_P (t))
2744     return 1;  /* integral, character or enumeral type */
2745   if (FLOAT_TYPE_P (t))
2746     return 1;
2747   if (TYPE_PTR_P (t))
2748     return 1; /* pointer to non-member */
2749   if (TYPE_PTRMEM_P (t))
2750     return 1; /* pointer to member object */
2751   if (TYPE_PTRMEMFUNC_P (t))
2752     return 1; /* pointer to member function */
2753
2754   if (! CLASS_TYPE_P (t))
2755     return 0; /* other non-class type (reference or function) */
2756   if (CLASSTYPE_NON_POD_P (t))
2757     return 0;
2758   return 1;
2759 }
2760
2761 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid C++-specific
2762    attribute for either declaration DECL or type TYPE and 0 otherwise.
2763    Plugged into valid_lang_attribute.  */
2764
2765 int
2766 cp_valid_lang_attribute (attr_name, attr_args, decl, type)
2767   tree attr_name;
2768   tree attr_args ATTRIBUTE_UNUSED;
2769   tree decl ATTRIBUTE_UNUSED;
2770   tree type ATTRIBUTE_UNUSED;
2771 {
2772   if (is_attribute_p ("com_interface", attr_name))
2773     {
2774       if (! flag_vtable_thunks)
2775         {
2776           error ("`com_interface' only supported with -fvtable-thunks");
2777           return 0;
2778         }
2779
2780       if (attr_args != NULL_TREE
2781           || decl != NULL_TREE
2782           || ! CLASS_TYPE_P (type)
2783           || type != TYPE_MAIN_VARIANT (type))
2784         {
2785           warning ("`com_interface' attribute can only be applied to class definitions");
2786           return 0;
2787         }
2788
2789       CLASSTYPE_COM_INTERFACE (type) = 1;
2790       return 1;
2791     }
2792   else if (is_attribute_p ("init_priority", attr_name))
2793     {
2794       tree initp_expr = (attr_args ? TREE_VALUE (attr_args): NULL_TREE);
2795       int pri;
2796
2797       if (initp_expr)
2798         STRIP_NOPS (initp_expr);
2799
2800       if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2801         {
2802           error ("requested init_priority is not an integer constant");
2803           return 0;
2804         }
2805
2806       pri = TREE_INT_CST_LOW (initp_expr);
2807
2808       while (TREE_CODE (type) == ARRAY_TYPE)
2809         type = TREE_TYPE (type);
2810
2811       if (decl == NULL_TREE
2812           || TREE_CODE (decl) != VAR_DECL
2813           || ! TREE_STATIC (decl)
2814           || DECL_EXTERNAL (decl)
2815           || (TREE_CODE (type) != RECORD_TYPE
2816               && TREE_CODE (type) != UNION_TYPE)
2817           /* Static objects in functions are initialized the
2818              first time control passes through that
2819              function. This is not precise enough to pin down an
2820              init_priority value, so don't allow it. */
2821           || current_function_decl)
2822         {
2823           error ("can only use init_priority attribute on file-scope definitions of objects of class type");
2824           return 0;
2825         }
2826
2827       if (pri > MAX_INIT_PRIORITY || pri <= 0)
2828         {
2829           error ("requested init_priority is out of range");
2830           return 0;
2831         }
2832
2833       /* Check for init_priorities that are reserved for
2834          language and runtime support implementations.*/
2835       if (pri <= MAX_RESERVED_INIT_PRIORITY)
2836         {
2837           warning
2838             ("requested init_priority is reserved for internal use");
2839         }
2840
2841       DECL_INIT_PRIORITY (decl) = pri;
2842       return 1;
2843     }
2844
2845   return 0;
2846 }
2847
2848 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2849    thing pointed to by the constant.  */
2850
2851 tree
2852 make_ptrmem_cst (type, member)
2853      tree type;
2854      tree member;
2855 {
2856   tree ptrmem_cst = make_node (PTRMEM_CST);
2857   /* If would seem a great convenience if make_node would set
2858      TREE_CONSTANT for things of class `c', but it does not.  */
2859   TREE_CONSTANT (ptrmem_cst) = 1;
2860   TREE_TYPE (ptrmem_cst) = type;
2861   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2862   return ptrmem_cst;
2863 }
2864