gcc/cp/tree.c

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