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