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