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