gcc/cp/class.c

   1 /* Functions related to building classes and their related objects.
   2    Copyright (C) 1987, 92-99, 2000 Free Software Foundation, Inc.
   3    Contributed 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
  23 /* High-level class interface.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "tree.h"
  28 #include "cp-tree.h"
  29 #include "flags.h"
  30 #include "rtl.h"
  31 #include "output.h"
  32 #include "toplev.h"
  33 #include "ggc.h"
  34 #include "lex.h"
  35
  36 #include "obstack.h"
  37 #define obstack_chunk_alloc xmalloc
  38 #define obstack_chunk_free free
  39
  40 /* This is how we tell when two virtual member functions are really the
  41    same.  */
  42 #define SAME_FN(FN1DECL, FN2DECL) (DECL_ASSEMBLER_NAME (FN1DECL) == DECL_ASSEMBLER_NAME (FN2DECL))
  43
  44 extern void set_class_shadows PARAMS ((tree));
  45
  46 /* The number of nested classes being processed.  If we are not in the
  47    scope of any class, this is zero.  */
  48
  49 int current_class_depth;
  50
  51 /* In order to deal with nested classes, we keep a stack of classes.
  52    The topmost entry is the innermost class, and is the entry at index
  53    CURRENT_CLASS_DEPTH  */
  54
  55 typedef struct class_stack_node {
  56   /* The name of the class.  */
  57   tree name;
  58
  59   /* The _TYPE node for the class.  */
  60   tree type;
  61
  62   /* The access specifier pending for new declarations in the scope of
  63      this class.  */
  64   tree access;
  65
  66   /* If were defining TYPE, the names used in this class.  */
  67   splay_tree names_used;
  68 }* class_stack_node_t;
  69
  70 /* The stack itself.  This is an dynamically resized array.  The
  71    number of elements allocated is CURRENT_CLASS_STACK_SIZE.  */
  72 static int current_class_stack_size;
  73 static class_stack_node_t current_class_stack;
  74
  75 static tree get_vfield_name PARAMS ((tree));
  76 static void finish_struct_anon PARAMS ((tree));
  77 static tree build_vbase_pointer PARAMS ((tree, tree));
  78 static tree build_vtable_entry PARAMS ((tree, tree, tree));
  79 static tree get_vtable_name PARAMS ((tree));
  80 static tree get_derived_offset PARAMS ((tree, tree));
  81 static tree get_basefndecls PARAMS ((tree, tree));
  82 static void set_rtti_entry PARAMS ((tree, tree, tree));
  83 static int build_primary_vtable PARAMS ((tree, tree));
  84 static int build_secondary_vtable PARAMS ((tree, tree));
  85 static tree dfs_finish_vtbls PARAMS ((tree, void *));
  86 static void finish_vtbls PARAMS ((tree));
  87 static void modify_vtable_entry PARAMS ((tree, tree, tree, tree, tree *));
  88 static void add_virtual_function PARAMS ((tree *, tree *, int *, tree, tree));
  89 static tree delete_duplicate_fields_1 PARAMS ((tree, tree));
  90 static void delete_duplicate_fields PARAMS ((tree));
  91 static void finish_struct_bits PARAMS ((tree));
  92 static int alter_access PARAMS ((tree, tree, tree, tree));
  93 static void handle_using_decl PARAMS ((tree, tree));
  94 static int overrides PARAMS ((tree, tree));
  95 static int strictly_overrides PARAMS ((tree, tree));
  96 static void mark_overriders PARAMS ((tree, tree));
  97 static void check_for_override PARAMS ((tree, tree));
  98 static tree dfs_modify_vtables PARAMS ((tree, void *));
  99 static tree modify_all_vtables PARAMS ((tree, int *, tree));
 100 static void determine_primary_base PARAMS ((tree, int *));
 101 static void finish_struct_methods PARAMS ((tree));
 102 static void maybe_warn_about_overly_private_class PARAMS ((tree));
 103 static int field_decl_cmp PARAMS ((const tree *, const tree *));
 104 static int method_name_cmp PARAMS ((const tree *, const tree *));
 105 static tree add_implicitly_declared_members PARAMS ((tree, int, int, int));
 106 static tree fixed_type_or_null PARAMS ((tree, int *));
 107 static tree resolve_address_of_overloaded_function PARAMS ((tree, tree, int,
 108                                                           int, tree));
 109 static void build_vtable_entry_ref PARAMS ((tree, tree, tree));
 110 static tree build_vtbl_initializer PARAMS ((tree, tree));
 111 static int count_fields PARAMS ((tree));
 112 static int add_fields_to_vec PARAMS ((tree, tree, int));
 113 static void check_bitfield_decl PARAMS ((tree));
 114 static void check_field_decl PARAMS ((tree, tree, int *, int *, int *, int *));
 115 static void check_field_decls PARAMS ((tree, tree *, int *, int *, int *,
 116                                      int *));
 117 static int avoid_overlap PARAMS ((tree, tree, int *));
 118 static tree build_base_field PARAMS ((tree, tree, int *, int *, unsigned int *));
 119 static tree build_base_fields PARAMS ((tree, int *));
 120 static tree build_vbase_pointer_fields PARAMS ((tree, int *));
 121 static tree build_vtbl_or_vbase_field PARAMS ((tree, tree, tree, tree, tree,
 122                                                int *));
 123 static void check_methods PARAMS ((tree));
 124 static void remove_zero_width_bit_fields PARAMS ((tree));
 125 static void check_bases PARAMS ((tree, int *, int *, int *));
 126 static void check_bases_and_members PARAMS ((tree, int *));
 127 static void create_vtable_ptr PARAMS ((tree, int *, int *, tree *, tree *));
 128 static void layout_class_type PARAMS ((tree, int *, int *, tree *, tree *));
 129 static void fixup_pending_inline PARAMS ((struct pending_inline *));
 130 static void fixup_inline_methods PARAMS ((tree));
 131 static void set_primary_base PARAMS ((tree, int, int *));
 132 static tree dfs_propagate_binfo_offsets PARAMS ((tree, void *));
 133 static void propagate_binfo_offsets PARAMS ((tree, tree));
 134 static void layout_basetypes PARAMS ((tree));
 135 static void layout_virtual_bases PARAMS ((tree));
 136 static void remove_base_field PARAMS ((tree, tree, tree *));
 137 static void remove_base_fields PARAMS ((tree));
 138 static tree dfs_set_offset_for_shared_vbases PARAMS ((tree, void *));
 139 static tree dfs_set_offset_for_unshared_vbases PARAMS ((tree, void *));
 140 static tree dfs_build_vbase_offset_vtbl_entries PARAMS ((tree, void *));
 141 static tree build_vbase_offset_vtbl_entries PARAMS ((tree, tree));
 142 static tree dfs_vcall_offset_queue_p PARAMS ((tree, void *));
 143 static tree dfs_build_vcall_offset_vtbl_entries PARAMS ((tree, void *));
 144 static tree build_vcall_offset_vtbl_entries PARAMS ((tree, tree));
 145 static tree dfs_count_virtuals PARAMS ((tree, void *));
 146 static void start_vtable PARAMS ((tree, int *));
 147 static void layout_vtable_decl PARAMS ((tree, int));
 148 static int num_vfun_entries PARAMS ((tree));
 149 static tree dfs_find_final_overrider PARAMS ((tree, void *));
 150 static tree find_final_overrider PARAMS ((tree, tree, tree));
 151 static tree dfs_find_base PARAMS ((tree, void *));
 152 static int make_new_vtable PARAMS ((tree, tree));
 153 extern void dump_class_hierarchy PARAMS ((tree, int));
 154
 155 /* Variables shared between class.c and call.c.  */
 156
 157 #ifdef GATHER_STATISTICS
 158 int n_vtables = 0;
 159 int n_vtable_entries = 0;
 160 int n_vtable_searches = 0;
 161 int n_vtable_elems = 0;
 162 int n_convert_harshness = 0;
 163 int n_compute_conversion_costs = 0;
 164 int n_build_method_call = 0;
 165 int n_inner_fields_searched = 0;
 166 #endif
 167
 168 /* Virtual base class layout.  */
 169
 170 /* Returns a list of virtual base class pointers as a chain of
 171    FIELD_DECLS.  */
 172
 173 static tree
 174 build_vbase_pointer_fields (rec, empty_p)
 175      tree rec;
 176      int *empty_p;
 177 {
 178   /* Chain to hold all the new FIELD_DECLs which point at virtual
 179      base classes.  */
 180   tree vbase_decls = NULL_TREE;
 181   tree binfos = TYPE_BINFO_BASETYPES (rec);
 182   int n_baseclasses = CLASSTYPE_N_BASECLASSES (rec);
 183   tree decl;
 184   int i;
 185
 186   /* Under the new ABI, there are no vbase pointers in the object.
 187      Instead, the offsets are stored in the vtable.  */
 188   if (vbase_offsets_in_vtable_p ())
 189     return NULL_TREE;
 190
 191   /* Loop over the baseclasses, adding vbase pointers as needed.  */
 192   for (i = 0; i < n_baseclasses; i++)
 193     {
 194       register tree base_binfo = TREE_VEC_ELT (binfos, i);
 195       register tree basetype = BINFO_TYPE (base_binfo);
 196
 197       if (TYPE_SIZE (basetype) == 0)
 198         /* This error is now reported in xref_tag, thus giving better
 199            location information.  */
 200         continue;
 201
 202       /* All basetypes are recorded in the association list of the
 203          derived type.  */
 204
 205       if (TREE_VIA_VIRTUAL (base_binfo))
 206         {
 207           int j;
 208           const char *name;
 209
 210           /* The offset for a virtual base class is only used in computing
 211              virtual function tables and for initializing virtual base
 212              pointers.  It is built once `get_vbase_types' is called.  */
 213
 214           /* If this basetype can come from another vbase pointer
 215              without an additional indirection, we will share
 216              that pointer.  If an indirection is involved, we
 217              make our own pointer.  */
 218           for (j = 0; j < n_baseclasses; j++)
 219             {
 220               tree other_base_binfo = TREE_VEC_ELT (binfos, j);
 221               if (! TREE_VIA_VIRTUAL (other_base_binfo)
 222                   && BINFO_FOR_VBASE (basetype, BINFO_TYPE (other_base_binfo)))
 223                 goto got_it;
 224             }
 225           FORMAT_VBASE_NAME (name, basetype);
 226           decl = build_vtbl_or_vbase_field (get_identifier (name),
 227                                             get_identifier (VTABLE_BASE),
 228                                             build_pointer_type (basetype),
 229                                             rec,
 230                                             basetype,
 231                                             empty_p);
 232           BINFO_VPTR_FIELD (base_binfo) = decl;
 233           TREE_CHAIN (decl) = vbase_decls;
 234           vbase_decls = decl;
 235           *empty_p = 0;
 236
 237         got_it:
 238           /* The space this decl occupies has already been accounted for.  */
 239           ;
 240         }
 241     }
 242
 243   return vbase_decls;
 244 }
 245
 246 /* Called from build_vbase_offset_vtbl_entries via dfs_walk.  */
 247
 248 static tree
 249 dfs_build_vbase_offset_vtbl_entries (binfo, data)
 250      tree binfo;
 251      void *data;
 252 {
 253   tree list = (tree) data;
 254
 255   if (TREE_TYPE (list) == binfo)
 256     /* The TREE_TYPE of LIST is the base class from which we started
 257        walking.  If that BINFO is virtual it's not a virtual baseclass
 258        of itself.  */
 259     ;
 260   else if (TREE_VIA_VIRTUAL (binfo))
 261     {
 262       tree init;
 263       tree vbase;
 264
 265       /* Remember the index to the vbase offset for this virtual
 266          base.  */
 267       vbase = BINFO_FOR_VBASE (TREE_TYPE (binfo), TREE_PURPOSE (list));
 268       if (!TREE_VALUE (list))
 269         BINFO_VPTR_FIELD (vbase) = build_int_2 (-1, 0);
 270       else
 271         {
 272           BINFO_VPTR_FIELD (vbase) = TREE_PURPOSE (TREE_VALUE (list));
 273           BINFO_VPTR_FIELD (vbase) = ssize_binop (MINUS_EXPR,
 274                                                   BINFO_VPTR_FIELD (vbase),
 275                                                   integer_one_node);
 276         }
 277
 278       /* And record the offset at which this virtual base lies in the
 279          vtable.  */
 280       init = BINFO_OFFSET (binfo);
 281       TREE_VALUE (list) = tree_cons (BINFO_VPTR_FIELD (vbase),
 282                                      init,
 283                                      TREE_VALUE (list));
 284     }
 285
 286   SET_BINFO_VTABLE_PATH_MARKED (binfo);
 287
 288   return NULL_TREE;
 289 }
 290
 291 /* Returns the initializers for the vbase offset entries in the vtable
 292    for BINFO (which is part of the class hierarchy dominated by T), in
 293    reverse order.  */
 294
 295 static tree
 296 build_vbase_offset_vtbl_entries (binfo, t)
 297      tree binfo;
 298      tree t;
 299 {
 300   tree inits;
 301   tree init;
 302   tree list;
 303
 304   /* Under the old ABI, pointers to virtual bases are stored in each
 305      object.  */
 306   if (!vbase_offsets_in_vtable_p ())
 307     return NULL_TREE;
 308
 309   /* If there are no virtual baseclasses, then there is nothing to
 310      do.  */
 311   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
 312     return NULL_TREE;
 313
 314   inits = NULL_TREE;
 315
 316   /* The offsets are allocated in the reverse order of a
 317      depth-first left-to-right traversal of the hierarchy.  We use
 318      BINFO_VTABLE_PATH_MARKED because we are ourselves during a
 319      dfs_walk, and so BINFO_MARKED is already in use.  */
 320   list = build_tree_list (t, NULL_TREE);
 321   TREE_TYPE (list) = binfo;
 322   dfs_walk (binfo,
 323             dfs_build_vbase_offset_vtbl_entries,
 324             dfs_vtable_path_unmarked_real_bases_queue_p,
 325             list);
 326   dfs_walk (binfo,
 327             dfs_vtable_path_unmark,
 328             dfs_vtable_path_marked_real_bases_queue_p,
 329             list);
 330   inits = nreverse (TREE_VALUE (list));
 331
 332   /* We've now got offsets in the right order.  However, the offsets
 333      we've stored are offsets from the beginning of the complete
 334      object, and we need offsets from this BINFO.  */
 335   for (init = inits; init; init = TREE_CHAIN (init))
 336     {
 337       tree exp = TREE_VALUE (init);
 338
 339       exp = ssize_binop (MINUS_EXPR, exp, BINFO_OFFSET (binfo));
 340       exp = build1 (NOP_EXPR, vtable_entry_type, exp);
 341       exp = fold (exp);
 342       TREE_CONSTANT (exp) = 1;
 343       /* The dfs_build_vbase_offset_vtbl_entries routine uses the
 344          TREE_PURPOSE to scribble in.  But, we need to clear it now so
 345          that the values are not perceived as labeled initializers.  */
 346       TREE_PURPOSE (init) = NULL_TREE;
 347       TREE_VALUE (init) = exp;
 348     }
 349
 350   return inits;
 351 }
 352
 353 typedef struct vcall_offset_data_s
 354 {
 355   /* The binfo for the most-derived type.  */
 356   tree derived;
 357   /* The binfo for the virtual base for which we're building
 358      initializers.  */
 359   tree vbase;
 360   /* The vcall offset initializers built up so far.  */
 361   tree inits;
 362   /* The number of vcall offsets accumulated.  */
 363   int offsets;
 364 } vcall_offset_data;
 365
 366 /* Called from build_vcall_offset_vtbl_entries via dfs_walk.  */
 367
 368 static tree
 369 dfs_vcall_offset_queue_p (binfo, data)
 370      tree binfo;
 371      void *data;
 372 {
 373   vcall_offset_data* vod = (vcall_offset_data *) data;
 374
 375   return (binfo == vod->vbase) ? binfo : dfs_skip_vbases (binfo, NULL);
 376 }
 377
 378 /* Called from build_vcall_offset_vtbl_entries via dfs_walk.  */
 379
 380 static tree
 381 dfs_build_vcall_offset_vtbl_entries (binfo, data)
 382      tree binfo;
 383      void *data;
 384 {
 385   vcall_offset_data* vod;
 386   tree virtuals;
 387   tree binfo_inits;
 388
 389   /* Primary bases are not interesting; all of the virtual
 390      function table entries have been overridden.  */
 391   if (BINFO_PRIMARY_MARKED_P (binfo))
 392      return NULL_TREE;
 393
 394   vod = (vcall_offset_data *) data;
 395   binfo_inits = NULL_TREE;
 396
 397   /* We chain the offsets on in reverse order.  That's correct --
 398      build_vtbl_initializer will straighten them out.  */
 399   for (virtuals = skip_rtti_stuff (binfo,
 400                                    BINFO_TYPE (binfo),
 401                                    NULL);
 402        virtuals;
 403        virtuals = TREE_CHAIN (virtuals))
 404     {
 405       tree fn;
 406       tree base;
 407       tree base_binfo;
 408       tree offset;
 409
 410       /* Figure out what function we're looking at.  */
 411       fn = TREE_VALUE (virtuals);
 412       base = DECL_CLASS_CONTEXT (fn);
 413
 414       /* The FN is comes from BASE.  So, we must caculate the
 415          adjustment from the virtual base that derived from BINFO to
 416          BASE.  */
 417       base_binfo = get_binfo (base, vod->derived, /*protect=*/0);
 418       offset = ssize_binop (MINUS_EXPR,
 419                             BINFO_OFFSET (base_binfo),
 420                             BINFO_OFFSET (vod->vbase));
 421       offset = build1 (NOP_EXPR, vtable_entry_type, offset);
 422       offset = fold (offset);
 423       TREE_CONSTANT (offset) = 1;
 424       binfo_inits = tree_cons (NULL_TREE, offset, binfo_inits);
 425     }
 426
 427   /* Now add the initializers we've just created to the list that will
 428      be returned to our caller.  */
 429   vod->inits = chainon (vod->inits, binfo_inits);
 430
 431   return NULL_TREE;
 432 }
 433
 434 /* Returns the initializers for the vcall offset entries in the vtable
 435    for BINFO (which is part of the class hierarchy dominated by T), in
 436    reverse order.  */
 437
 438 static tree
 439 build_vcall_offset_vtbl_entries (binfo, t)
 440      tree binfo;
 441      tree t;
 442 {
 443   vcall_offset_data vod;
 444
 445   /* Under the old ABI, the adjustments to the `this' pointer were made
 446      elsewhere.  */
 447   if (!vcall_offsets_in_vtable_p ())
 448     return NULL_TREE;
 449
 450   /* We only need these entries if this base is a virtual base.  */
 451   if (!TREE_VIA_VIRTUAL (binfo))
 452     return NULL_TREE;
 453
 454   /* We need a vcall offset for each of the virtual functions in this
 455      vtable.  For example:
 456
 457        class A { virtual void f (); };
 458        class B : virtual public A { };
 459        class C: virtual public A, public B {};
 460
 461      Now imagine:
 462
 463        B* b = new C;
 464        b->f();
 465
 466      The location of `A' is not at a fixed offset relative to `B'; the
 467      offset depends on the complete object derived from `B'.  So,
 468      `B' vtable contains an entry for `f' that indicates by what
 469      amount the `this' pointer for `B' needs to be adjusted to arrive
 470      at `A'.
 471
 472      We need entries for all the functions in our primary vtable and
 473      in our non-virtual bases vtables.  For each base, the entries
 474      appear in the same order as in the base; but the bases themselves
 475      appear in reverse depth-first, left-to-right order.  */
 476   vod.derived = t;
 477   vod.vbase = binfo;
 478   vod.inits = NULL_TREE;
 479   dfs_walk (binfo,
 480             dfs_build_vcall_offset_vtbl_entries,
 481             dfs_vcall_offset_queue_p,
 482             &vod);
 483
 484   return vod.inits;
 485 }
 486
 487 /* Returns a pointer to the virtual base class of EXP that has the
 488    indicated TYPE.  EXP is of class type, not a pointer type.  */
 489
 490 static tree
 491 build_vbase_pointer (exp, type)
 492      tree exp, type;
 493 {
 494   if (vbase_offsets_in_vtable_p ())
 495     {
 496       tree vbase;
 497       tree vbase_ptr;
 498
 499       /* Find the shared copy of TYPE; that's where the vtable offset
 500          is recorded.  */
 501       vbase = BINFO_FOR_VBASE (type, TREE_TYPE (exp));
 502       /* Find the virtual function table pointer.  */
 503       vbase_ptr = build_vfield_ref (exp, TREE_TYPE (exp));
 504       /* Compute the location where the offset will lie.  */
 505       vbase_ptr = build_binary_op (PLUS_EXPR,
 506                                    vbase_ptr,
 507                                    BINFO_VPTR_FIELD (vbase));
 508       vbase_ptr = build1 (NOP_EXPR,
 509                           build_pointer_type (ptrdiff_type_node),
 510                           vbase_ptr);
 511       /* Add the contents of this location to EXP.  */
 512       return build (PLUS_EXPR,
 513                     build_pointer_type (type),
 514                     build_unary_op (ADDR_EXPR, exp, /*noconvert=*/0),
 515                     build1 (INDIRECT_REF, ptrdiff_type_node, vbase_ptr));
 516     }
 517   else
 518     {
 519       char *name;
 520       FORMAT_VBASE_NAME (name, type);
 521       return build_component_ref (exp, get_identifier (name), NULL_TREE, 0);
 522     }
 523 }
 524
 525 /* Build multi-level access to EXPR using hierarchy path PATH.
 526    CODE is PLUS_EXPR if we are going with the grain,
 527    and MINUS_EXPR if we are not (in which case, we cannot traverse
 528    virtual baseclass links).
 529
 530    TYPE is the type we want this path to have on exit.
 531
 532    NONNULL is non-zero if  we know (for any reason) that EXPR is
 533    not, in fact, zero.  */
 534
 535 tree
 536 build_vbase_path (code, type, expr, path, nonnull)
 537      enum tree_code code;
 538      tree type, expr, path;
 539      int nonnull;
 540 {
 541   register int changed = 0;
 542   tree last = NULL_TREE, last_virtual = NULL_TREE;
 543   int fixed_type_p;
 544   tree null_expr = 0, nonnull_expr;
 545   tree basetype;
 546   tree offset = integer_zero_node;
 547
 548   if (BINFO_INHERITANCE_CHAIN (path) == NULL_TREE)
 549     return build1 (NOP_EXPR, type, expr);
 550
 551   /* We could do better if we had additional logic to convert back to the
 552      unconverted type (the static type of the complete object), and then
 553      convert back to the type we want.  Until that is done, we only optimize
 554      if the complete type is the same type as expr has.  */
 555   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
 556
 557   if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
 558     expr = save_expr (expr);
 559   nonnull_expr = expr;
 560
 561   path = reverse_path (path);
 562
 563   basetype = BINFO_TYPE (path);
 564
 565   while (path)
 566     {
 567       if (TREE_VIA_VIRTUAL (TREE_VALUE (path)))
 568         {
 569           last_virtual = BINFO_TYPE (TREE_VALUE (path));
 570           if (code == PLUS_EXPR)
 571             {
 572               changed = ! fixed_type_p;
 573
 574               if (changed)
 575                 {
 576                   tree ind;
 577
 578                   /* We already check for ambiguous things in the caller, just
 579                      find a path.  */
 580                   if (last)
 581                     {
 582                       tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (nonnull_expr))), 0);
 583                       nonnull_expr = convert_pointer_to_real (binfo, nonnull_expr);
 584                     }
 585                   ind = build_indirect_ref (nonnull_expr, NULL_PTR);
 586                   nonnull_expr = build_vbase_pointer (ind, last_virtual);
 587                   if (nonnull == 0
 588                       && TREE_CODE (type) == POINTER_TYPE
 589                       && null_expr == NULL_TREE)
 590                     {
 591                       null_expr = build1 (NOP_EXPR, build_pointer_type (last_virtual), integer_zero_node);
 592                       expr = build (COND_EXPR, build_pointer_type (last_virtual),
 593                                     build (EQ_EXPR, boolean_type_node, expr,
 594                                            integer_zero_node),
 595                                     null_expr, nonnull_expr);
 596                     }
 597                 }
 598               /* else we'll figure out the offset below.  */
 599
 600               /* Happens in the case of parse errors.  */
 601               if (nonnull_expr == error_mark_node)
 602                 return error_mark_node;
 603             }
 604           else
 605             {
 606               cp_error ("cannot cast up from virtual baseclass `%T'",
 607                           last_virtual);
 608               return error_mark_node;
 609             }
 610         }
 611       last = TREE_VALUE (path);
 612       path = TREE_CHAIN (path);
 613     }
 614   /* LAST is now the last basetype assoc on the path.  */
 615
 616   /* A pointer to a virtual base member of a non-null object
 617      is non-null.  Therefore, we only need to test for zeroness once.
 618      Make EXPR the canonical expression to deal with here.  */
 619   if (null_expr)
 620     {
 621       TREE_OPERAND (expr, 2) = nonnull_expr;
 622       TREE_TYPE (expr) = TREE_TYPE (TREE_OPERAND (expr, 1))
 623         = TREE_TYPE (nonnull_expr);
 624     }
 625   else
 626     expr = nonnull_expr;
 627
 628   /* If we go through any virtual base pointers, make sure that
 629      casts to BASETYPE from the last virtual base class use
 630      the right value for BASETYPE.  */
 631   if (changed)
 632     {
 633       tree intype = TREE_TYPE (TREE_TYPE (expr));
 634       if (TYPE_MAIN_VARIANT (intype) != BINFO_TYPE (last))
 635         {
 636           tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
 637           offset = BINFO_OFFSET (binfo);
 638         }
 639     }
 640   else
 641     offset = BINFO_OFFSET (last);
 642
 643   if (TREE_INT_CST_LOW (offset))
 644     {
 645       /* Bash types to make the backend happy.  */
 646       offset = cp_convert (type, offset);
 647 #if 0
 648       /* This shouldn't be necessary.  (mrs) */
 649       expr = build1 (NOP_EXPR, type, expr);
 650 #endif
 651
 652       /* If expr might be 0, we need to preserve that zeroness.  */
 653       if (nonnull == 0)
 654         {
 655           if (null_expr)
 656             TREE_TYPE (null_expr) = type;
 657           else
 658             null_expr = build1 (NOP_EXPR, type, integer_zero_node);
 659           if (TREE_SIDE_EFFECTS (expr))
 660             expr = save_expr (expr);
 661
 662           return build (COND_EXPR, type,
 663                         build (EQ_EXPR, boolean_type_node, expr, integer_zero_node),
 664                         null_expr,
 665                         build (code, type, expr, offset));
 666         }
 667       else return build (code, type, expr, offset);
 668     }
 669
 670   /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
 671      be used multiple times in initialization of multiple inheritance.  */
 672   if (null_expr)
 673     {
 674       TREE_TYPE (expr) = type;
 675       return expr;
 676     }
 677   else
 678     return build1 (NOP_EXPR, type, expr);
 679 }
 680
 681 \f
 682 /* Virtual function things.  */
 683
 684 /* Build an entry in the virtual function table.  DELTA is the offset
 685    for the `this' pointer.  VCALL_INDEX is the vtable index containing
 686    the vcall offset; zero if none.  FNDECL is the virtual function
 687    itself.  */
 688
 689 static tree
 690 build_vtable_entry (delta, vcall_index, fndecl)
 691      tree delta;
 692      tree vcall_index;
 693      tree fndecl;
 694 {
 695   tree pfn;
 696
 697   /* Take the address of the function, considering it to be of an
 698      appropriate generic type.  */
 699   pfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
 700   /* The address of a function can't change.  */
 701   TREE_CONSTANT (pfn) = 1;
 702
 703   if (flag_vtable_thunks)
 704     {
 705       HOST_WIDE_INT idelta;
 706       HOST_WIDE_INT ivindex;
 707
 708       idelta = TREE_INT_CST_LOW (delta);
 709       ivindex = TREE_INT_CST_LOW (vcall_index);
 710       if ((idelta || ivindex)
 711           && ! DECL_PURE_VIRTUAL_P (TREE_OPERAND (pfn, 0)))
 712         {
 713           pfn = make_thunk (pfn, idelta, ivindex);
 714           pfn = build1 (ADDR_EXPR, vtable_entry_type, pfn);
 715           TREE_READONLY (pfn) = 1;
 716           TREE_CONSTANT (pfn) = 1;
 717         }
 718 #ifdef GATHER_STATISTICS
 719       n_vtable_entries += 1;
 720 #endif
 721       return pfn;
 722     }
 723   else
 724     {
 725       extern int flag_huge_objects;
 726       tree elems = tree_cons (NULL_TREE, delta,
 727                               tree_cons (NULL_TREE, integer_zero_node,
 728                                          build_tree_list (NULL_TREE, pfn)));
 729       tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
 730
 731       /* We don't use vcall offsets when not using vtable thunks.  */
 732       my_friendly_assert (integer_zerop (vcall_index), 20000125);
 733
 734       /* DELTA used to be constructed by `size_int' and/or size_binop,
 735          which caused overflow problems when it was negative.  That should
 736          be fixed now.  */
 737
 738       if (! int_fits_type_p (delta, delta_type_node))
 739         {
 740           if (flag_huge_objects)
 741             sorry ("object size exceeds built-in limit for virtual function table implementation");
 742           else
 743             sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
 744         }
 745
 746       TREE_CONSTANT (entry) = 1;
 747       TREE_STATIC (entry) = 1;
 748       TREE_READONLY (entry) = 1;
 749
 750 #ifdef GATHER_STATISTICS
 751       n_vtable_entries += 1;
 752 #endif
 753
 754       return entry;
 755     }
 756 }
 757
 758 /* We want to give the assembler the vtable identifier as well as
 759    the offset to the function pointer.  So we generate
 760
 761    __asm__ __volatile__ (".vtable_entry %c0, %c1"
 762       : : "s"(&class_vtable),
 763           "i"((long)&vtbl[idx].pfn - (long)&vtbl[0])); */
 764
 765 static void
 766 build_vtable_entry_ref (basetype, vtbl, idx)
 767      tree basetype, vtbl, idx;
 768 {
 769   static char asm_stmt[] = ".vtable_entry %c0, %c1";
 770   tree s, i, i2;
 771
 772   s = build_unary_op (ADDR_EXPR, TYPE_BINFO_VTABLE (basetype), 0);
 773   s = build_tree_list (build_string (1, "s"), s);
 774
 775   i = build_array_ref (vtbl, idx);
 776   if (!flag_vtable_thunks)
 777     i = build_component_ref (i, pfn_identifier, vtable_entry_type, 0);
 778   i = build_c_cast (ptrdiff_type_node, build_unary_op (ADDR_EXPR, i, 0));
 779   i2 = build_array_ref (vtbl, build_int_2(0,0));
 780   i2 = build_c_cast (ptrdiff_type_node, build_unary_op (ADDR_EXPR, i2, 0));
 781   i = build_binary_op (MINUS_EXPR, i, i2);
 782   i = build_tree_list (build_string (1, "i"), i);
 783
 784   finish_asm_stmt (ridpointers[RID_VOLATILE],
 785                    build_string (sizeof(asm_stmt)-1, asm_stmt),
 786                    NULL_TREE, chainon (s, i), NULL_TREE);
 787 }
 788
 789 /* Given an object INSTANCE, return an expression which yields the
 790    virtual function vtable element corresponding to INDEX.  There are
 791    many special cases for INSTANCE which we take care of here, mainly
 792    to avoid creating extra tree nodes when we don't have to.  */
 793
 794 tree
 795 build_vtbl_ref (instance, idx)
 796      tree instance, idx;
 797 {
 798   tree vtbl, aref;
 799   tree basetype = TREE_TYPE (instance);
 800
 801   if (TREE_CODE (basetype) == REFERENCE_TYPE)
 802     basetype = TREE_TYPE (basetype);
 803
 804   if (instance == current_class_ref)
 805     vtbl = build_vfield_ref (instance, basetype);
 806   else
 807     {
 808       if (optimize)
 809         {
 810           /* Try to figure out what a reference refers to, and
 811              access its virtual function table directly.  */
 812           tree ref = NULL_TREE;
 813
 814           if (TREE_CODE (instance) == INDIRECT_REF
 815               && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
 816             ref = TREE_OPERAND (instance, 0);
 817           else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
 818             ref = instance;
 819
 820           if (ref && TREE_CODE (ref) == VAR_DECL
 821               && DECL_INITIAL (ref))
 822             {
 823               tree init = DECL_INITIAL (ref);
 824
 825               while (TREE_CODE (init) == NOP_EXPR
 826                      || TREE_CODE (init) == NON_LVALUE_EXPR)
 827                 init = TREE_OPERAND (init, 0);
 828               if (TREE_CODE (init) == ADDR_EXPR)
 829                 {
 830                   init = TREE_OPERAND (init, 0);
 831                   if (IS_AGGR_TYPE (TREE_TYPE (init))
 832                       && (TREE_CODE (init) == PARM_DECL
 833                           || TREE_CODE (init) == VAR_DECL))
 834                     instance = init;
 835                 }
 836             }
 837         }
 838
 839       if (IS_AGGR_TYPE (TREE_TYPE (instance))
 840           && (TREE_CODE (instance) == RESULT_DECL
 841               || TREE_CODE (instance) == PARM_DECL
 842               || TREE_CODE (instance) == VAR_DECL))
 843         vtbl = TYPE_BINFO_VTABLE (basetype);
 844       else
 845         vtbl = build_vfield_ref (instance, basetype);
 846     }
 847
 848   assemble_external (vtbl);
 849
 850   if (flag_vtable_gc)
 851     build_vtable_entry_ref (basetype, vtbl, idx);
 852
 853   aref = build_array_ref (vtbl, idx);
 854
 855   return aref;
 856 }
 857
 858 /* Given an object INSTANCE, return an expression which yields the
 859    virtual function corresponding to INDEX.  There are many special
 860    cases for INSTANCE which we take care of here, mainly to avoid
 861    creating extra tree nodes when we don't have to.  */
 862
 863 tree
 864 build_vfn_ref (ptr_to_instptr, instance, idx)
 865      tree *ptr_to_instptr, instance;
 866      tree idx;
 867 {
 868   tree aref = build_vtbl_ref (instance, idx);
 869
 870   /* When using thunks, there is no extra delta, and we get the pfn
 871      directly.  */
 872   if (flag_vtable_thunks)
 873     return aref;
 874
 875   if (ptr_to_instptr)
 876     {
 877       /* Save the intermediate result in a SAVE_EXPR so we don't have to
 878          compute each component of the virtual function pointer twice.  */
 879       if (TREE_CODE (aref) == INDIRECT_REF)
 880         TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
 881
 882       *ptr_to_instptr
 883         = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
 884                  *ptr_to_instptr,
 885                  cp_convert (ptrdiff_type_node,
 886                              build_component_ref (aref, delta_identifier, NULL_TREE, 0)));
 887     }
 888
 889   return build_component_ref (aref, pfn_identifier, NULL_TREE, 0);
 890 }
 891
 892 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 893    for the given TYPE.  */
 894
 895 static tree
 896 get_vtable_name (type)
 897      tree type;
 898 {
 899   tree type_id = build_typename_overload (type);
 900   char *buf = (char *) alloca (strlen (VTABLE_NAME_PREFIX)
 901                                + IDENTIFIER_LENGTH (type_id) + 2);
 902   const char *ptr = IDENTIFIER_POINTER (type_id);
 903   int i;
 904   for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
 905 #if 0
 906   /* We don't take off the numbers; build_secondary_vtable uses the
 907      DECL_ASSEMBLER_NAME for the type, which includes the number
 908      in `3foo'.  If we were to pull them off here, we'd end up with
 909      something like `_vt.foo.3bar', instead of a uniform definition.  */
 910   while (ptr[i] >= '0' && ptr[i] <= '9')
 911     i += 1;
 912 #endif
 913   sprintf (buf, "%s%s", VTABLE_NAME_PREFIX, ptr+i);
 914   return get_identifier (buf);
 915 }
 916
 917 /* Return the offset to the main vtable for a given base BINFO.  */
 918
 919 tree
 920 get_vfield_offset (binfo)
 921      tree binfo;
 922 {
 923   tree tmp
 924     = size_binop (FLOOR_DIV_EXPR,
 925                   DECL_FIELD_BITPOS (TYPE_VFIELD (BINFO_TYPE (binfo))),
 926                   size_int (BITS_PER_UNIT));
 927   tmp = convert (sizetype, tmp);
 928   return size_binop (PLUS_EXPR, tmp, BINFO_OFFSET (binfo));
 929 }
 930
 931 /* Get the offset to the start of the original binfo that we derived
 932    this binfo from.  If we find TYPE first, return the offset only
 933    that far.  The shortened search is useful because the this pointer
 934    on method calling is expected to point to a DECL_CONTEXT (fndecl)
 935    object, and not a baseclass of it.  */
 936
 937 static tree
 938 get_derived_offset (binfo, type)
 939      tree binfo, type;
 940 {
 941   tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 942   tree offset2;
 943   int i;
 944   while (BINFO_BASETYPES (binfo)
 945          && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
 946     {
 947       tree binfos = BINFO_BASETYPES (binfo);
 948       if (BINFO_TYPE (binfo) == type)
 949         break;
 950       binfo = TREE_VEC_ELT (binfos, i);
 951     }
 952   offset2 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
 953   return size_binop (MINUS_EXPR, offset1, offset2);
 954 }
 955
 956 /* Update the rtti info for this class.  */
 957
 958 static void
 959 set_rtti_entry (virtuals, offset, type)
 960      tree virtuals, offset, type;
 961 {
 962   tree decl;
 963
 964   if (CLASSTYPE_COM_INTERFACE (type))
 965     return;
 966
 967   if (flag_rtti)
 968     decl = get_tinfo_decl (type);
 969   else if (!new_abi_rtti_p ())
 970     /* If someone tries to get RTTI information for a type compiled
 971        without RTTI, they're out of luck.  By calling __pure_virtual
 972        in this case, we give a small clue as to what went wrong.  We
 973        could consider having a __no_typeinfo function as well, for a
 974        more specific hint.  */
 975     decl = abort_fndecl;
 976   else
 977     /* For the new-abi, we just point to the type_info object.  */
 978     decl = NULL_TREE;
 979
 980   if (flag_vtable_thunks)
 981     {
 982       /* The first slot holds the offset.  */
 983       BV_DELTA (virtuals) = offset;
 984       BV_VCALL_INDEX (virtuals) = integer_zero_node;
 985
 986       /* The next node holds the decl.  */
 987       virtuals = TREE_CHAIN (virtuals);
 988       offset = integer_zero_node;
 989     }
 990
 991   /* This slot holds the function to call.  */
 992   BV_DELTA (virtuals) = offset;
 993   BV_VCALL_INDEX (virtuals) = integer_zero_node;
 994   BV_FN (virtuals) = decl;
 995 }
 996
 997 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
 998    or even complete.  If this does not exist, create it.  If COMPLETE is
 999    non-zero, then complete the definition of it -- that will render it
1000    impossible to actually build the vtable, but is useful to get at those
1001    which are known to exist in the runtime.  */
1002
1003 tree get_vtable_decl (type, complete)
1004      tree type;
1005      int complete;
1006 {
1007   tree name = get_vtable_name (type);
1008   tree decl = IDENTIFIER_GLOBAL_VALUE (name);
1009
1010   if (decl)
1011     {
1012       my_friendly_assert (TREE_CODE (decl) == VAR_DECL
1013                           && DECL_VIRTUAL_P (decl), 20000118);
1014       return decl;
1015     }
1016
1017   decl = build_lang_decl (VAR_DECL, name, void_type_node);
1018
1019   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
1020   import_export_vtable (decl, type, 0);
1021
1022   decl = pushdecl_top_level (decl);
1023   SET_IDENTIFIER_GLOBAL_VALUE (name, decl);
1024
1025   DECL_ARTIFICIAL (decl) = 1;
1026   TREE_STATIC (decl) = 1;
1027 #ifndef WRITABLE_VTABLES
1028   /* Make them READONLY by default. (mrs) */
1029   TREE_READONLY (decl) = 1;
1030 #endif
1031   /* At one time the vtable info was grabbed 2 words at a time.  This
1032      fails on sparc unless you have 8-byte alignment.  (tiemann) */
1033   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
1034                            DECL_ALIGN (decl));
1035
1036   DECL_VIRTUAL_P (decl) = 1;
1037
1038   if (complete)
1039     cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
1040
1041   DECL_CONTEXT (decl) = type;
1042   return decl;
1043 }
1044
1045 /* Build the primary virtual function table for TYPE.  If BINFO is
1046    non-NULL, build the vtable starting with the initial approximation
1047    that it is the same as the one which is the head of the association
1048    list.  Returns a non-zero value if a new vtable is actually
1049    created.  */
1050
1051 static int
1052 build_primary_vtable (binfo, type)
1053      tree binfo, type;
1054 {
1055   tree virtuals, decl;
1056
1057   decl = get_vtable_decl (type, /*complete=*/0);
1058
1059   if (binfo)
1060     {
1061       tree offset;
1062
1063       if (BINFO_NEW_VTABLE_MARKED (binfo))
1064         /* We have already created a vtable for this base, so there's
1065            no need to do it again.  */
1066         return 0;
1067
1068       virtuals = copy_list (BINFO_VIRTUALS (binfo));
1069       TREE_TYPE (decl) = TREE_TYPE (BINFO_VTABLE (binfo));
1070       DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (BINFO_VTABLE (binfo)));
1071
1072       /* Now do rtti stuff.  */
1073       offset = get_derived_offset (TYPE_BINFO (type), NULL_TREE);
1074       offset = ssize_binop (MINUS_EXPR, integer_zero_node, offset);
1075       set_rtti_entry (virtuals, offset, type);
1076     }
1077   else
1078     {
1079       my_friendly_assert (TREE_CODE (TREE_TYPE (decl)) == VOID_TYPE,
1080                           20000118);
1081       virtuals = NULL_TREE;
1082     }
1083
1084 #ifdef GATHER_STATISTICS
1085   n_vtables += 1;
1086   n_vtable_elems += list_length (virtuals);
1087 #endif
1088
1089   /* Initialize the association list for this type, based
1090      on our first approximation.  */
1091   TYPE_BINFO_VTABLE (type) = decl;
1092   TYPE_BINFO_VIRTUALS (type) = virtuals;
1093
1094   binfo = TYPE_BINFO (type);
1095   SET_BINFO_NEW_VTABLE_MARKED (binfo);
1096   return 1;
1097 }
1098
1099 /* Give TYPE a new virtual function table which is initialized
1100    with a skeleton-copy of its original initialization.  The only
1101    entry that changes is the `delta' entry, so we can really
1102    share a lot of structure.
1103
1104    FOR_TYPE is the derived type which caused this table to
1105    be needed.
1106
1107    BINFO is the type association which provided TYPE for FOR_TYPE.
1108
1109    The order in which vtables are built (by calling this function) for
1110    an object must remain the same, otherwise a binary incompatibility
1111    can result.  */
1112
1113 static int
1114 build_secondary_vtable (binfo, for_type)
1115      tree binfo, for_type;
1116 {
1117   tree basetype;
1118   tree orig_decl = BINFO_VTABLE (binfo);
1119   tree name;
1120   tree new_decl;
1121   tree offset;
1122   tree path = binfo;
1123   char *buf, *buf2;
1124   char joiner = '_';
1125   int i;
1126
1127 #ifdef JOINER
1128   joiner = JOINER;
1129 #endif
1130
1131   if (BINFO_NEW_VTABLE_MARKED (binfo))
1132     /* We already created a vtable for this base.  There's no need to
1133        do it again.  */
1134     return 0;
1135
1136   basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (binfo));
1137
1138   buf2 = TYPE_ASSEMBLER_NAME_STRING (basetype);
1139   i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1;
1140
1141   /* We know that the vtable that we are going to create doesn't exist
1142      yet in the global namespace, and when we finish, it will be
1143      pushed into the global namespace.  In complex MI hierarchies, we
1144      have to loop while the name we are thinking of adding is globally
1145      defined, adding more name components to the vtable name as we
1146      loop, until the name is unique.  This is because in complex MI
1147      cases, we might have the same base more than once.  This means
1148      that the order in which this function is called for vtables must
1149      remain the same, otherwise binary compatibility can be
1150      compromised.  */
1151
1152   while (1)
1153     {
1154       char *buf1 = (char *) alloca (TYPE_ASSEMBLER_NAME_LENGTH (for_type)
1155                                     + 1 + i);
1156       char *new_buf2;
1157
1158       sprintf (buf1, "%s%c%s", TYPE_ASSEMBLER_NAME_STRING (for_type), joiner,
1159                buf2);
1160       buf = (char *) alloca (strlen (VTABLE_NAME_PREFIX) + strlen (buf1) + 1);
1161       sprintf (buf, "%s%s", VTABLE_NAME_PREFIX, buf1);
1162       name = get_identifier (buf);
1163
1164       /* If this name doesn't clash, then we can use it, otherwise
1165          we add more to the name until it is unique.  */
1166
1167       if (! IDENTIFIER_GLOBAL_VALUE (name))
1168         break;
1169
1170       /* Set values for next loop through, if the name isn't unique.  */
1171
1172       path = BINFO_INHERITANCE_CHAIN (path);
1173
1174       /* We better not run out of stuff to make it unique.  */
1175       my_friendly_assert (path != NULL_TREE, 368);
1176
1177       basetype = TYPE_MAIN_VARIANT (BINFO_TYPE (path));
1178
1179       if (for_type == basetype)
1180         {
1181           /* If we run out of basetypes in the path, we have already
1182              found created a vtable with that name before, we now
1183              resort to tacking on _%d to distinguish them.  */
1184           int j = 2;
1185           i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i + 1 + 3;
1186           buf1 = (char *) alloca (i);
1187           do {
1188             sprintf (buf1, "%s%c%s%c%d",
1189                      TYPE_ASSEMBLER_NAME_STRING (basetype), joiner,
1190                      buf2, joiner, j);
1191             buf = (char *) alloca (strlen (VTABLE_NAME_PREFIX)
1192                                    + strlen (buf1) + 1);
1193             sprintf (buf, "%s%s", VTABLE_NAME_PREFIX, buf1);
1194             name = get_identifier (buf);
1195
1196             /* If this name doesn't clash, then we can use it,
1197                otherwise we add something different to the name until
1198                it is unique.  */
1199           } while (++j <= 999 && IDENTIFIER_GLOBAL_VALUE (name));
1200
1201           /* Hey, they really like MI don't they?  Increase the 3
1202              above to 6, and the 999 to 999999.  :-)  */
1203           my_friendly_assert (j <= 999, 369);
1204
1205           break;
1206         }
1207
1208       i = TYPE_ASSEMBLER_NAME_LENGTH (basetype) + 1 + i;
1209       new_buf2 = (char *) alloca (i);
1210       sprintf (new_buf2, "%s%c%s",
1211                TYPE_ASSEMBLER_NAME_STRING (basetype), joiner, buf2);
1212       buf2 = new_buf2;
1213     }
1214
1215   new_decl = build_lang_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
1216   /* Remember which class this vtable is really for.  */
1217   DECL_CONTEXT (new_decl) = for_type;
1218
1219   DECL_ARTIFICIAL (new_decl) = 1;
1220   TREE_STATIC (new_decl) = 1;
1221   BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
1222   DECL_VIRTUAL_P (new_decl) = 1;
1223 #ifndef WRITABLE_VTABLES
1224   /* Make them READONLY by default. (mrs) */
1225   TREE_READONLY (new_decl) = 1;
1226 #endif
1227   DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
1228
1229   /* Make fresh virtual list, so we can smash it later.  */
1230   BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
1231
1232   if (TREE_VIA_VIRTUAL (binfo))
1233     {
1234       tree binfo1 = BINFO_FOR_VBASE (BINFO_TYPE (binfo), for_type);
1235
1236       /* XXX - This should never happen, if it does, the caller should
1237          ensure that the binfo is from for_type's binfos, not from any
1238          base type's.  We can remove all this code after a while.  */
1239       if (binfo1 != binfo)
1240         warning ("internal inconsistency: binfo offset error for rtti");
1241
1242       offset = BINFO_OFFSET (binfo1);
1243     }
1244   else
1245     offset = BINFO_OFFSET (binfo);
1246
1247   set_rtti_entry (BINFO_VIRTUALS (binfo),
1248                   ssize_binop (MINUS_EXPR, integer_zero_node, offset),
1249                   for_type);
1250
1251 #ifdef GATHER_STATISTICS
1252   n_vtables += 1;
1253   n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
1254 #endif
1255
1256   /* Set TREE_PUBLIC and TREE_EXTERN as appropriate.  */
1257   import_export_vtable (new_decl, for_type, 0);
1258
1259   if (TREE_VIA_VIRTUAL (binfo))
1260     my_friendly_assert (binfo == BINFO_FOR_VBASE (BINFO_TYPE (binfo),
1261                                                   current_class_type),
1262                         170);
1263   SET_BINFO_NEW_VTABLE_MARKED (binfo);
1264   return 1;
1265 }
1266
1267 /* Create a new vtable for BINFO which is the hierarchy dominated by
1268    T.  */
1269
1270 static int
1271 make_new_vtable (t, binfo)
1272      tree t;
1273      tree binfo;
1274 {
1275   if (binfo == TYPE_BINFO (t))
1276     /* In this case, it is *type*'s vtable we are modifying.  We start
1277        with the approximation that it's vtable is that of the
1278        immediate base class.  */
1279     return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))),
1280                                  t);
1281   else
1282     /* This is our very own copy of `basetype' to play with.  Later,
1283        we will fill in all the virtual functions that override the
1284        virtual functions in these base classes which are not defined
1285        by the current type.  */
1286     return build_secondary_vtable (binfo, t);
1287 }
1288
1289 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
1290    (which is in the hierarchy dominated by T) list FNDECL as its
1291    BV_FN.  DELTA is the required adjustment from the `this' pointer
1292    where the vtable entry appears to the `this' required when the
1293    function is actually called.  */
1294
1295 static void
1296 modify_vtable_entry (t, binfo, fndecl, delta, virtuals)
1297      tree t;
1298      tree binfo;
1299      tree fndecl;
1300      tree delta;
1301      tree *virtuals;
1302 {
1303   tree vcall_index;
1304   tree v;
1305
1306   v = *virtuals;
1307   vcall_index = integer_zero_node;
1308
1309   if (fndecl != BV_FN (v)
1310       || !tree_int_cst_equal (delta, BV_DELTA (v))
1311       || !tree_int_cst_equal (vcall_index, BV_VCALL_INDEX (v)))
1312     {
1313       tree base_fndecl;
1314
1315       /* We need a new vtable for BINFO.  */
1316       if (make_new_vtable (t, binfo))
1317         {
1318           /* If we really did make a new vtable, we also made a copy
1319              of the BINFO_VIRTUALS list.  Now, we have to find the
1320              corresponding entry in that list.  */
1321           *virtuals = BINFO_VIRTUALS (binfo);
1322           while (BV_FN (*virtuals) != BV_FN (v))
1323             *virtuals = TREE_CHAIN (*virtuals);
1324           v = *virtuals;
1325         }
1326
1327       base_fndecl = BV_FN (v);
1328       BV_DELTA (v) = delta;
1329       BV_VCALL_INDEX (v) = vcall_index;
1330       BV_FN (v) = fndecl;
1331
1332       /* Now assign virtual dispatch information, if unset.  We can
1333          dispatch this, through any overridden base function.  */
1334       if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
1335         {
1336           DECL_VINDEX (fndecl) = DECL_VINDEX (base_fndecl);
1337           DECL_VIRTUAL_CONTEXT (fndecl) = DECL_VIRTUAL_CONTEXT (base_fndecl);
1338         }
1339     }
1340 }
1341
1342 /* Call this function whenever its known that a vtable for T is going
1343    to be needed.  It's safe to call it more than once.  *HAS_VIRTUAL_P
1344    is initialized to the number of slots that are reserved at the
1345    beginning of the vtable for RTTI information.  */
1346
1347 static void
1348 start_vtable (t, has_virtual_p)
1349      tree t;
1350      int *has_virtual_p;
1351 {
1352   if (*has_virtual_p == 0 && ! CLASSTYPE_COM_INTERFACE (t))
1353     {
1354       /* If we are using thunks, use two slots at the front, one
1355          for the offset pointer, one for the tdesc pointer.
1356          For ARM-style vtables, use the same slot for both.  */
1357       if (flag_vtable_thunks)
1358         *has_virtual_p = 2;
1359       else
1360         *has_virtual_p = 1;
1361     }
1362 }
1363
1364 /* Add a virtual function to all the appropriate vtables for the class
1365    T.  DECL_VINDEX(X) should be error_mark_node, if we want to
1366    allocate a new slot in our table.  If it is error_mark_node, we
1367    know that no other function from another vtable is overridden by X.
1368    HAS_VIRTUAL keeps track of how many virtuals there are in our main
1369    vtable for the type, and we build upon the NEW_VIRTUALS list
1370    and return it.  */
1371
1372 static void
1373 add_virtual_function (new_virtuals_p, overridden_virtuals_p,
1374                       has_virtual, fndecl, t)
1375      tree *new_virtuals_p;
1376      tree *overridden_virtuals_p;
1377      int *has_virtual;
1378      tree fndecl;
1379      tree t; /* Structure type.  */
1380 {
1381   tree new_virtual;
1382
1383   /* If this function doesn't override anything from a base class, we
1384      can just assign it a new DECL_VINDEX now.  Otherwise, if it does
1385      override something, we keep it around and assign its DECL_VINDEX
1386      later, in modify_all_vtables.  */
1387   if (TREE_CODE (DECL_VINDEX (fndecl)) == INTEGER_CST)
1388     /* We've already dealt with this function.  */
1389     return;
1390
1391   new_virtual = build_tree_list (integer_zero_node, fndecl);
1392   BV_VCALL_INDEX (new_virtual) = integer_zero_node;
1393
1394   if (DECL_VINDEX (fndecl) == error_mark_node)
1395     {
1396       /* FNDECL is a new virtual function; it doesn't override any
1397          virtual function in a base class.  */
1398
1399       /* We remember that this was the base sub-object for rtti.  */
1400       CLASSTYPE_RTTI (t) = t;
1401
1402       start_vtable (t, has_virtual);
1403
1404       /* Now assign virtual dispatch information.  */
1405       DECL_VINDEX (fndecl) = build_shared_int_cst ((*has_virtual)++);
1406       DECL_VIRTUAL_CONTEXT (fndecl) = t;
1407
1408       /* Save the state we've computed on the NEW_VIRTUALS list.  */
1409       TREE_CHAIN (new_virtual) = *new_virtuals_p;
1410       *new_virtuals_p = new_virtual;
1411     }
1412   else
1413     {
1414       /* FNDECL overrides a function from a base class.  */
1415       TREE_CHAIN (new_virtual) = *overridden_virtuals_p;
1416       *overridden_virtuals_p = new_virtual;
1417     }
1418 }
1419 \f
1420 extern struct obstack *current_obstack;
1421
1422 /* Add method METHOD to class TYPE.
1423
1424    If non-NULL, FIELDS is the entry in the METHOD_VEC vector entry of
1425    the class type where the method should be added.  */
1426
1427 void
1428 add_method (type, fields, method)
1429      tree type, *fields, method;
1430 {
1431   /* Setting the DECL_CONTEXT and DECL_CLASS_CONTEXT here is probably
1432      redundant.  */
1433   DECL_CONTEXT (method) = type;
1434   DECL_CLASS_CONTEXT (method) = type;
1435
1436   if (fields && *fields)
1437     *fields = build_overload (method, *fields);
1438   else
1439     {
1440       int len;
1441       int slot;
1442       tree method_vec;
1443
1444       if (!CLASSTYPE_METHOD_VEC (type))
1445         /* Make a new method vector.  We start with 8 entries.  We must
1446            allocate at least two (for constructors and destructors), and
1447            we're going to end up with an assignment operator at some
1448            point as well.
1449
1450            We could use a TREE_LIST for now, and convert it to a
1451            TREE_VEC in finish_struct, but we would probably waste more
1452            memory making the links in the list than we would by
1453            over-allocating the size of the vector here.  Furthermore,
1454            we would complicate all the code that expects this to be a
1455            vector.  */
1456         CLASSTYPE_METHOD_VEC (type) = make_tree_vec (8);
1457
1458       method_vec = CLASSTYPE_METHOD_VEC (type);
1459       len = TREE_VEC_LENGTH (method_vec);
1460
1461       if (DECL_NAME (method) == constructor_name (type))
1462         /* A new constructor or destructor.  Constructors go in
1463            slot 0; destructors go in slot 1.  */
1464         slot = DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (method)) ? 1 : 0;
1465       else
1466         {
1467           /* See if we already have an entry with this name.  */
1468           for (slot = 2; slot < len; ++slot)
1469             if (!TREE_VEC_ELT (method_vec, slot)
1470                 || (DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec,
1471                                                           slot)))
1472                     == DECL_NAME (method)))
1473               break;
1474
1475           if (slot == len)
1476             {
1477               /* We need a bigger method vector.  */
1478               tree new_vec = make_tree_vec (2 * len);
1479               bcopy ((PTR) &TREE_VEC_ELT (method_vec, 0),
1480                      (PTR) &TREE_VEC_ELT (new_vec, 0),
1481                      len * sizeof (tree));
1482               len = 2 * len;
1483               method_vec = CLASSTYPE_METHOD_VEC (type) = new_vec;
1484             }
1485
1486           if (DECL_CONV_FN_P (method) && !TREE_VEC_ELT (method_vec, slot))
1487             {
1488               /* Type conversion operators have to come before
1489                  ordinary methods; add_conversions depends on this to
1490                  speed up looking for conversion operators.  So, if
1491                  necessary, we slide some of the vector elements up.
1492                  In theory, this makes this algorithm O(N^2) but we
1493                  don't expect many conversion operators.  */
1494               for (slot = 2; slot < len; ++slot)
1495                 {
1496                   tree fn = TREE_VEC_ELT (method_vec, slot);
1497
1498                   if (!fn)
1499                     /* There are no more entries in the vector, so we
1500                        can insert the new conversion operator here.  */
1501                     break;
1502
1503                   if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1504                     /* We can insert the new function right at the
1505                        SLOTth position.  */
1506                     break;
1507                 }
1508
1509               if (!TREE_VEC_ELT (method_vec, slot))
1510                 /* There is nothing in the Ith slot, so we can avoid
1511                    moving anything.  */
1512                 ;
1513               else
1514                 {
1515                   /* We know the last slot in the vector is empty
1516                      because we know that at this point there's room
1517                      for a new function.  */
1518                   bcopy ((PTR) &TREE_VEC_ELT (method_vec, slot),
1519                          (PTR) &TREE_VEC_ELT (method_vec, slot + 1),
1520                          (len - slot - 1) * sizeof (tree));
1521                   TREE_VEC_ELT (method_vec, slot) = NULL_TREE;
1522                 }
1523             }
1524         }
1525
1526       if (template_class_depth (type))
1527         /* TYPE is a template class.  Don't issue any errors now; wait
1528            until instantiation time to complain.  */
1529           ;
1530       else
1531         {
1532           tree fns;
1533
1534           /* Check to see if we've already got this method.  */
1535           for (fns = TREE_VEC_ELT (method_vec, slot);
1536                fns;
1537                fns = OVL_NEXT (fns))
1538             {
1539               tree fn = OVL_CURRENT (fns);
1540
1541               if (TREE_CODE (fn) != TREE_CODE (method))
1542                 continue;
1543
1544               if (TREE_CODE (method) != TEMPLATE_DECL)
1545                 {
1546                   /* [over.load] Member function declarations with the
1547                      same name and the same parameter types cannot be
1548                      overloaded if any of them is a static member
1549                      function declaration.  */
1550                   if (DECL_STATIC_FUNCTION_P (fn)
1551                       != DECL_STATIC_FUNCTION_P (method))
1552                     {
1553                       tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (fn));
1554                       tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (method));
1555
1556                       if (! DECL_STATIC_FUNCTION_P (fn))
1557                         parms1 = TREE_CHAIN (parms1);
1558                       else
1559                         parms2 = TREE_CHAIN (parms2);
1560
1561                       if (compparms (parms1, parms2))
1562                         cp_error ("`%#D' and `%#D' cannot be overloaded",
1563                                   fn, method);
1564                     }
1565
1566                   /* Since this is an ordinary function in a
1567                      non-template class, it's mangled name can be used
1568                      as a unique identifier.  This technique is only
1569                      an optimization; we would get the same results if
1570                      we just used decls_match here.  */
1571                   if (DECL_ASSEMBLER_NAME (fn)
1572                       != DECL_ASSEMBLER_NAME (method))
1573                     continue;
1574                 }
1575               else if (!decls_match (fn, method))
1576                 continue;
1577
1578               /* There has already been a declaration of this method
1579                  or member template.  */
1580               cp_error_at ("`%D' has already been declared in `%T'",
1581                            method, type);
1582
1583               /* We don't call duplicate_decls here to merge the
1584                  declarations because that will confuse things if the
1585                  methods have inline definitions.  In particular, we
1586                  will crash while processing the definitions.  */
1587               return;
1588             }
1589         }
1590
1591       /* Actually insert the new method.  */
1592       TREE_VEC_ELT (method_vec, slot)
1593         = build_overload (method, TREE_VEC_ELT (method_vec, slot));
1594
1595       /* Add the new binding.  */
1596       if (!DECL_CONSTRUCTOR_P (method)
1597           && !DECL_DESTRUCTOR_P (method))
1598         push_class_level_binding (DECL_NAME (method),
1599                                   TREE_VEC_ELT (method_vec, slot));
1600     }
1601 }
1602
1603 /* Subroutines of finish_struct.  */
1604
1605 /* Look through the list of fields for this struct, deleting
1606    duplicates as we go.  This must be recursive to handle
1607    anonymous unions.
1608
1609    FIELD is the field which may not appear anywhere in FIELDS.
1610    FIELD_PTR, if non-null, is the starting point at which
1611    chained deletions may take place.
1612    The value returned is the first acceptable entry found
1613    in FIELDS.
1614
1615    Note that anonymous fields which are not of UNION_TYPE are
1616    not duplicates, they are just anonymous fields.  This happens
1617    when we have unnamed bitfields, for example.  */
1618
1619 static tree
1620 delete_duplicate_fields_1 (field, fields)
1621      tree field, fields;
1622 {
1623   tree x;
1624   tree prev = 0;
1625   if (DECL_NAME (field) == 0)
1626     {
1627       if (! ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1628         return fields;
1629
1630       for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
1631         fields = delete_duplicate_fields_1 (x, fields);
1632       return fields;
1633     }
1634   else
1635     {
1636       for (x = fields; x; prev = x, x = TREE_CHAIN (x))
1637         {
1638           if (DECL_NAME (x) == 0)
1639             {
1640               if (! ANON_AGGR_TYPE_P (TREE_TYPE (x)))
1641                 continue;
1642               TYPE_FIELDS (TREE_TYPE (x))
1643                 = delete_duplicate_fields_1 (field, TYPE_FIELDS (TREE_TYPE (x)));
1644               if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
1645                 {
1646                   if (prev == 0)
1647                     fields = TREE_CHAIN (fields);
1648                   else
1649                     TREE_CHAIN (prev) = TREE_CHAIN (x);
1650                 }
1651             }
1652           else if (TREE_CODE (field) == USING_DECL)
1653             /* A using declaration may is allowed to appear more than
1654                once.  We'll prune these from the field list later, and
1655                handle_using_decl will complain about invalid multiple
1656                uses.  */
1657             ;
1658           else if (DECL_NAME (field) == DECL_NAME (x))
1659             {
1660               if (TREE_CODE (field) == CONST_DECL
1661                   && TREE_CODE (x) == CONST_DECL)
1662                 cp_error_at ("duplicate enum value `%D'", x);
1663               else if (TREE_CODE (field) == CONST_DECL
1664                        || TREE_CODE (x) == CONST_DECL)
1665                 cp_error_at ("duplicate field `%D' (as enum and non-enum)",
1666                              x);
1667               else if (DECL_DECLARES_TYPE_P (field)
1668                        && DECL_DECLARES_TYPE_P (x))
1669                 {
1670                   if (same_type_p (TREE_TYPE (field), TREE_TYPE (x)))
1671                     continue;
1672                   cp_error_at ("duplicate nested type `%D'", x);
1673                 }
1674               else if (DECL_DECLARES_TYPE_P (field)
1675                        || DECL_DECLARES_TYPE_P (x))
1676                 {
1677                   /* Hide tag decls.  */
1678                   if ((TREE_CODE (field) == TYPE_DECL
1679                        && DECL_ARTIFICIAL (field))
1680                       || (TREE_CODE (x) == TYPE_DECL
1681                           && DECL_ARTIFICIAL (x)))
1682                     continue;
1683                   cp_error_at ("duplicate field `%D' (as type and non-type)",
1684                                x);
1685                 }
1686               else
1687                 cp_error_at ("duplicate member `%D'", x);
1688               if (prev == 0)
1689                 fields = TREE_CHAIN (fields);
1690               else
1691                 TREE_CHAIN (prev) = TREE_CHAIN (x);
1692             }
1693         }
1694     }
1695   return fields;
1696 }
1697
1698 static void
1699 delete_duplicate_fields (fields)
1700      tree fields;
1701 {
1702   tree x;
1703   for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
1704     TREE_CHAIN (x) = delete_duplicate_fields_1 (x, TREE_CHAIN (x));
1705 }
1706
1707 /* Change the access of FDECL to ACCESS in T.  The access to FDECL is
1708    along the path given by BINFO.  Return 1 if change was legit,
1709    otherwise return 0.  */
1710
1711 static int
1712 alter_access (t, binfo, fdecl, access)
1713      tree t;
1714      tree binfo;
1715      tree fdecl;
1716      tree access;
1717 {
1718   tree elem = purpose_member (t, DECL_ACCESS (fdecl));
1719   if (elem)
1720     {
1721       if (TREE_VALUE (elem) != access)
1722         {
1723           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1724             cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
1725           else
1726             error ("conflicting access specifications for field `%s', ignored",
1727                    IDENTIFIER_POINTER (DECL_NAME (fdecl)));
1728         }
1729       else
1730         {
1731           /* They're changing the access to the same thing they changed
1732              it to before.  That's OK.  */
1733           ;
1734         }
1735     }
1736   else
1737     {
1738       enforce_access (binfo, fdecl);
1739       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1740       return 1;
1741     }
1742   return 0;
1743 }
1744
1745 /* Process the USING_DECL, which is a member of T.  */
1746
1747 static void
1748 handle_using_decl (using_decl, t)
1749      tree using_decl;
1750      tree t;
1751 {
1752   tree ctype = DECL_INITIAL (using_decl);
1753   tree name = DECL_NAME (using_decl);
1754   tree access
1755     = TREE_PRIVATE (using_decl) ? access_private_node
1756     : TREE_PROTECTED (using_decl) ? access_protected_node
1757     : access_public_node;
1758   tree fdecl, binfo;
1759   tree flist = NULL_TREE;
1760   tree fields = TYPE_FIELDS (t);
1761   tree method_vec = CLASSTYPE_METHOD_VEC (t);
1762   tree tmp;
1763   int i;
1764   int n_methods;
1765
1766   binfo = binfo_or_else (ctype, t);
1767   if (! binfo)
1768     return;
1769
1770   if (name == constructor_name (ctype)
1771       || name == constructor_name_full (ctype))
1772     {
1773       cp_error_at ("using-declaration for constructor", using_decl);
1774       return;
1775     }
1776
1777   fdecl = lookup_member (binfo, name, 0, 0);
1778
1779   if (!fdecl)
1780     {
1781       cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype);
1782       return;
1783     }
1784
1785   /* Functions are represented as TREE_LIST, with the purpose
1786      being the type and the value the functions. Other members
1787      come as themselves. */
1788   if (TREE_CODE (fdecl) == TREE_LIST)
1789     /* Ignore base type this came from. */
1790     fdecl = TREE_VALUE (fdecl);
1791
1792   if (TREE_CODE (fdecl) == OVERLOAD)
1793     {
1794       /* We later iterate over all functions. */
1795       flist = fdecl;
1796       fdecl = OVL_FUNCTION (flist);
1797     }
1798
1799   name = DECL_NAME (fdecl);
1800   n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
1801   for (i = 2; i < n_methods && TREE_VEC_ELT (method_vec, i); i++)
1802     if (DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)))
1803         == name)
1804       {
1805         cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
1806         cp_error_at ("  because of local method `%#D' with same name",
1807                      OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
1808         return;
1809       }
1810
1811   if (! DECL_LANG_SPECIFIC (fdecl))
1812     /* We don't currently handle DECL_ACCESS for TYPE_DECLs; just return.  */
1813     return;
1814
1815   for (tmp = fields; tmp; tmp = TREE_CHAIN (tmp))
1816     if (DECL_NAME (tmp) == name)
1817       {
1818         cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
1819         cp_error_at ("  because of local field `%#D' with same name", tmp);
1820         return;
1821       }
1822
1823   /* Make type T see field decl FDECL with access ACCESS.*/
1824   if (flist)
1825     {
1826       while (flist)
1827         {
1828           if (alter_access (t, binfo, OVL_FUNCTION (flist),
1829                             access) == 0)
1830             return;
1831           flist = OVL_CHAIN (flist);
1832         }
1833     }
1834   else
1835     alter_access (t, binfo, fdecl, access);
1836 }
1837 \f
1838 /* Run through the base clases of T, updating
1839    CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1840    NO_CONST_ASN_REF_P.  Also set flag bits in T based on properties of
1841    the bases.  */
1842
1843 static void
1844 check_bases (t, cant_have_default_ctor_p, cant_have_const_ctor_p,
1845              no_const_asn_ref_p)
1846      tree t;
1847      int *cant_have_default_ctor_p;
1848      int *cant_have_const_ctor_p;
1849      int *no_const_asn_ref_p;
1850 {
1851   int n_baseclasses;
1852   int i;
1853   int seen_nearly_empty_base_p;
1854   tree binfos;
1855
1856   binfos = TYPE_BINFO_BASETYPES (t);
1857   n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1858   seen_nearly_empty_base_p = 0;
1859
1860   /* An aggregate cannot have baseclasses.  */
1861   CLASSTYPE_NON_AGGREGATE (t) |= (n_baseclasses != 0);
1862
1863   for (i = 0; i < n_baseclasses; ++i)
1864     {
1865       tree base_binfo;
1866       tree basetype;
1867
1868       /* Figure out what base we're looking at.  */
1869       base_binfo = TREE_VEC_ELT (binfos, i);
1870       basetype = TREE_TYPE (base_binfo);
1871
1872       /* If the type of basetype is incomplete, then we already
1873          complained about that fact (and we should have fixed it up as
1874          well).  */
1875       if (TYPE_SIZE (basetype) == 0)
1876         {
1877           int j;
1878           /* The base type is of incomplete type.  It is
1879              probably best to pretend that it does not
1880              exist.  */
1881           if (i == n_baseclasses-1)
1882             TREE_VEC_ELT (binfos, i) = NULL_TREE;
1883           TREE_VEC_LENGTH (binfos) -= 1;
1884           n_baseclasses -= 1;
1885           for (j = i; j+1 < n_baseclasses; j++)
1886             TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1887           continue;
1888         }
1889
1890       /* Effective C++ rule 14.  We only need to check TYPE_POLYMORPHIC_P
1891          here because the case of virtual functions but non-virtual
1892          dtor is handled in finish_struct_1.  */
1893       if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype)
1894           && TYPE_HAS_DESTRUCTOR (basetype))
1895         cp_warning ("base class `%#T' has a non-virtual destructor",
1896                     basetype);
1897
1898       /* If the base class doesn't have copy constructors or
1899          assignment operators that take const references, then the
1900          derived class cannot have such a member automatically
1901          generated.  */
1902       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1903         *cant_have_const_ctor_p = 1;
1904       if (TYPE_HAS_ASSIGN_REF (basetype)
1905           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1906         *no_const_asn_ref_p = 1;
1907       /* Similarly, if the base class doesn't have a default
1908          constructor, then the derived class won't have an
1909          automatically generated default constructor.  */
1910       if (TYPE_HAS_CONSTRUCTOR (basetype)
1911           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1912         {
1913           *cant_have_default_ctor_p = 1;
1914           if (! TYPE_HAS_CONSTRUCTOR (t))
1915             {
1916               cp_pedwarn ("base `%T' with only non-default constructor",
1917                           basetype);
1918               cp_pedwarn ("in class without a constructor");
1919             }
1920         }
1921
1922       /* If the base class is not empty or nearly empty, then this
1923          class cannot be nearly empty.  */
1924       if (!CLASSTYPE_NEARLY_EMPTY_P (basetype) && !is_empty_class (basetype))
1925         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1926       /* And if there is more than one nearly empty base, then the
1927          derived class is not nearly empty either.  */
1928       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype)
1929                && seen_nearly_empty_base_p)
1930         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1931       /* If this is the first nearly empty base class, then remember
1932          that we saw it.  */
1933       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1934         seen_nearly_empty_base_p = 1;
1935
1936       /* A lot of properties from the bases also apply to the derived
1937          class.  */
1938       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1939       TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
1940       TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1941         |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1942       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1943       TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
1944       TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
1945       TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
1946       TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1947
1948       /* Derived classes can implicitly become COMified if their bases
1949          are COM.  */
1950       if (CLASSTYPE_COM_INTERFACE (basetype))
1951         CLASSTYPE_COM_INTERFACE (t) = 1;
1952       else if (i == 0 && CLASSTYPE_COM_INTERFACE (t))
1953         {
1954           cp_error
1955             ("COM interface type `%T' with non-COM leftmost base class `%T'",
1956              t, basetype);
1957           CLASSTYPE_COM_INTERFACE (t) = 0;
1958         }
1959     }
1960 }
1961
1962 /* Make the Ith baseclass of T its primary base.  */
1963
1964 static void
1965 set_primary_base (t, i, has_virtual_p)
1966      tree t;
1967      int i;
1968      int *has_virtual_p;
1969 {
1970   tree basetype;
1971
1972   CLASSTYPE_VFIELD_PARENT (t) = i;
1973   basetype = BINFO_TYPE (CLASSTYPE_PRIMARY_BINFO (t));
1974   TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1975   TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1976   TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1977   CLASSTYPE_RTTI (t) = CLASSTYPE_RTTI (basetype);
1978   *has_virtual_p = CLASSTYPE_VSIZE (basetype);
1979 }
1980
1981 /* Determine the primary class for T.  */
1982
1983 static void
1984 determine_primary_base (t, has_virtual_p)
1985      tree t;
1986      int *has_virtual_p;
1987 {
1988   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1989
1990   /* If there are no baseclasses, there is certainly no primary base.  */
1991   if (n_baseclasses == 0)
1992     return;
1993
1994   *has_virtual_p = 0;
1995
1996   for (i = 0; i < n_baseclasses; i++)
1997     {
1998       tree base_binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), i);
1999       tree basetype = BINFO_TYPE (base_binfo);
2000
2001       if (TYPE_CONTAINS_VPTR_P (basetype))
2002         {
2003           /* Even a virtual baseclass can contain our RTTI
2004              information.  But, we prefer a non-virtual polymorphic
2005              baseclass.  */
2006           if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2007             CLASSTYPE_RTTI (t) = CLASSTYPE_RTTI (basetype);
2008
2009           /* A virtual baseclass can't be the primary base under the
2010              old ABI.  And under the new ABI we still prefer a
2011              non-virtual base.  */
2012           if (TREE_VIA_VIRTUAL (base_binfo))
2013             continue;
2014
2015           if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2016             {
2017               set_primary_base (t, i, has_virtual_p);
2018               CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype));
2019             }
2020           else
2021             {
2022               tree vfields;
2023
2024               /* Only add unique vfields, and flatten them out as we go.  */
2025               for (vfields = CLASSTYPE_VFIELDS (basetype);
2026                    vfields;
2027                    vfields = TREE_CHAIN (vfields))
2028                 if (VF_BINFO_VALUE (vfields) == NULL_TREE
2029                     || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
2030                   CLASSTYPE_VFIELDS (t)
2031                     = tree_cons (base_binfo,
2032                                  VF_BASETYPE_VALUE (vfields),
2033                                  CLASSTYPE_VFIELDS (t));
2034
2035               if (*has_virtual_p == 0)
2036                 set_primary_base (t, i, has_virtual_p);
2037             }
2038         }
2039     }
2040
2041   if (!TYPE_VFIELD (t))
2042     CLASSTYPE_VFIELD_PARENT (t) = -1;
2043
2044   /* The new ABI allows for the use of a "nearly-empty" virtual base
2045      class as the primary base class if no non-virtual polymorphic
2046      base can be found.  */
2047   if (flag_new_abi && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2048     for (i = 0; i < n_baseclasses; ++i)
2049       {
2050         tree base_binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), i);
2051         tree basetype = BINFO_TYPE (base_binfo);
2052
2053         if (TREE_VIA_VIRTUAL (base_binfo)
2054             && CLASSTYPE_NEARLY_EMPTY_P (basetype))
2055           {
2056             set_primary_base (t, i, has_virtual_p);
2057             CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype));
2058             break;
2059           }
2060       }
2061
2062   /* Mark the primary base classes at this point.  */
2063   mark_primary_bases (t);
2064 }
2065 \f
2066 /* Set memoizing fields and bits of T (and its variants) for later
2067    use.  */
2068
2069 static void
2070 finish_struct_bits (t)
2071      tree t;
2072 {
2073   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
2074
2075   /* Fix up variants (if any).  */
2076   tree variants = TYPE_NEXT_VARIANT (t);
2077   while (variants)
2078     {
2079       /* These fields are in the _TYPE part of the node, not in
2080          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
2081       TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
2082       TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
2083       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
2084       TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
2085
2086       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants)
2087         = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t);
2088       TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
2089       TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
2090       /* Copy whatever these are holding today.  */
2091       TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
2092       TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
2093       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
2094       TYPE_SIZE (variants) = TYPE_SIZE (t);
2095       TYPE_SIZE_UNIT (variants) = TYPE_SIZE_UNIT (t);
2096       variants = TYPE_NEXT_VARIANT (variants);
2097     }
2098
2099   if (n_baseclasses && TYPE_POLYMORPHIC_P (t))
2100     /* For a class w/o baseclasses, `finish_struct' has set
2101        CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
2102        definition). Similarly for a class whose base classes do not
2103        have vtables. When neither of these is true, we might have
2104        removed abstract virtuals (by providing a definition), added
2105        some (by declaring new ones), or redeclared ones from a base
2106        class. We need to recalculate what's really an abstract virtual
2107        at this point (by looking in the vtables).  */
2108       get_pure_virtuals (t);
2109
2110   if (n_baseclasses)
2111     {
2112       /* Notice whether this class has type conversion functions defined.  */
2113       tree binfo = TYPE_BINFO (t);
2114       tree binfos = BINFO_BASETYPES (binfo);
2115       tree basetype;
2116
2117       for (i = n_baseclasses-1; i >= 0; i--)
2118         {
2119           basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
2120
2121           TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype);
2122         }
2123     }
2124
2125   /* If this type has a copy constructor, force its mode to be BLKmode, and
2126      force its TREE_ADDRESSABLE bit to be nonzero.  This will cause it to
2127      be passed by invisible reference and prevent it from being returned in
2128      a register.
2129
2130      Also do this if the class has BLKmode but can still be returned in
2131      registers, since function_cannot_inline_p won't let us inline
2132      functions returning such a type.  This affects the HP-PA.  */
2133   if (! TYPE_HAS_TRIVIAL_INIT_REF (t)
2134       || (TYPE_MODE (t) == BLKmode && ! aggregate_value_p (t)
2135           && CLASSTYPE_NON_AGGREGATE (t)))
2136     {
2137       tree variants;
2138       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
2139       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
2140         {
2141           TYPE_MODE (variants) = BLKmode;
2142           TREE_ADDRESSABLE (variants) = 1;
2143         }
2144     }
2145 }
2146
2147 /* Issue warnings about T having private constructors, but no friends,
2148    and so forth.
2149
2150    HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
2151    static members.  HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
2152    non-private static member functions.  */
2153
2154 static void
2155 maybe_warn_about_overly_private_class (t)
2156      tree t;
2157 {
2158   int has_member_fn = 0;
2159   int has_nonprivate_method = 0;
2160   tree fn;
2161
2162   if (!warn_ctor_dtor_privacy
2163       /* If the class has friends, those entities might create and
2164          access instances, so we should not warn.  */
2165       || (CLASSTYPE_FRIEND_CLASSES (t)
2166           || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
2167       /* We will have warned when the template was declared; there's
2168          no need to warn on every instantiation.  */
2169       || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
2170     /* There's no reason to even consider warning about this
2171        class.  */
2172     return;
2173
2174   /* We only issue one warning, if more than one applies, because
2175      otherwise, on code like:
2176
2177      class A {
2178        // Oops - forgot `public:'
2179        A();
2180        A(const A&);
2181        ~A();
2182      };
2183
2184      we warn several times about essentially the same problem.  */
2185
2186   /* Check to see if all (non-constructor, non-destructor) member
2187      functions are private.  (Since there are no friends or
2188      non-private statics, we can't ever call any of the private member
2189      functions.)  */
2190   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
2191     /* We're not interested in compiler-generated methods; they don't
2192        provide any way to call private members.  */
2193     if (!DECL_ARTIFICIAL (fn))
2194       {
2195         if (!TREE_PRIVATE (fn))
2196           {
2197             if (DECL_STATIC_FUNCTION_P (fn))
2198               /* A non-private static member function is just like a
2199                  friend; it can create and invoke private member
2200                  functions, and be accessed without a class
2201                  instance.  */
2202               return;
2203
2204             has_nonprivate_method = 1;
2205             break;
2206           }
2207         else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
2208           has_member_fn = 1;
2209       }
2210
2211   if (!has_nonprivate_method && has_member_fn)
2212     {
2213       /* There are no non-private methods, and there's at least one
2214          private member function that isn't a constructor or
2215          destructor.  (If all the private members are
2216          constructors/destructors we want to use the code below that
2217          issues error messages specifically referring to
2218          constructors/destructors.)  */
2219       int i;
2220       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2221       for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); i++)
2222         if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
2223             || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
2224           {
2225             has_nonprivate_method = 1;
2226             break;
2227           }
2228       if (!has_nonprivate_method)
2229         {
2230           cp_warning ("all member functions in class `%T' are private", t);
2231           return;
2232         }
2233     }
2234
2235   /* Even if some of the member functions are non-private, the class
2236      won't be useful for much if all the constructors or destructors
2237      are private: such an object can never be created or destroyed.  */
2238   if (TYPE_HAS_DESTRUCTOR (t))
2239     {
2240       tree dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1);
2241
2242       if (TREE_PRIVATE (dtor))
2243         {
2244           cp_warning ("`%#T' only defines a private destructor and has no friends",
2245                       t);
2246           return;
2247         }
2248     }
2249
2250   if (TYPE_HAS_CONSTRUCTOR (t))
2251     {
2252       int nonprivate_ctor = 0;
2253
2254       /* If a non-template class does not define a copy
2255          constructor, one is defined for it, enabling it to avoid
2256          this warning.  For a template class, this does not
2257          happen, and so we would normally get a warning on:
2258
2259            template <class T> class C { private: C(); };
2260
2261          To avoid this asymmetry, we check TYPE_HAS_INIT_REF.  All
2262          complete non-template or fully instantiated classes have this
2263          flag set.  */
2264       if (!TYPE_HAS_INIT_REF (t))
2265         nonprivate_ctor = 1;
2266       else
2267         for (fn = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
2268              fn;
2269              fn = OVL_NEXT (fn))
2270           {
2271             tree ctor = OVL_CURRENT (fn);
2272             /* Ideally, we wouldn't count copy constructors (or, in
2273                fact, any constructor that takes an argument of the
2274                class type as a parameter) because such things cannot
2275                be used to construct an instance of the class unless
2276                you already have one.  But, for now at least, we're
2277                more generous.  */
2278             if (! TREE_PRIVATE (ctor))
2279               {
2280                 nonprivate_ctor = 1;
2281                 break;
2282               }
2283           }
2284
2285       if (nonprivate_ctor == 0)
2286         {
2287           cp_warning ("`%#T' only defines private constructors and has no friends",
2288                       t);
2289           return;
2290         }
2291     }
2292 }
2293
2294 /* Function to help qsort sort FIELD_DECLs by name order.  */
2295
2296 static int
2297 field_decl_cmp (x, y)
2298      const tree *x, *y;
2299 {
2300   if (DECL_NAME (*x) == DECL_NAME (*y))
2301     /* A nontype is "greater" than a type.  */
2302     return DECL_DECLARES_TYPE_P (*y) - DECL_DECLARES_TYPE_P (*x);
2303   if (DECL_NAME (*x) == NULL_TREE)
2304     return -1;
2305   if (DECL_NAME (*y) == NULL_TREE)
2306     return 1;
2307   if (DECL_NAME (*x) < DECL_NAME (*y))
2308     return -1;
2309   return 1;
2310 }
2311
2312 /* Comparison function to compare two TYPE_METHOD_VEC entries by name.  */
2313
2314 static int
2315 method_name_cmp (m1, m2)
2316      const tree *m1, *m2;
2317 {
2318   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
2319     return 0;
2320   if (*m1 == NULL_TREE)
2321     return -1;
2322   if (*m2 == NULL_TREE)
2323     return 1;
2324   if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
2325     return -1;
2326   return 1;
2327 }
2328
2329 /* Warn about duplicate methods in fn_fields.  Also compact method
2330    lists so that lookup can be made faster.
2331
2332    Data Structure: List of method lists.  The outer list is a
2333    TREE_LIST, whose TREE_PURPOSE field is the field name and the
2334    TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs.  TREE_CHAIN
2335    links the entire list of methods for TYPE_METHODS.  Friends are
2336    chained in the same way as member functions (? TREE_CHAIN or
2337    DECL_CHAIN), but they live in the TREE_TYPE field of the outer
2338    list.  That allows them to be quickly deleted, and requires no
2339    extra storage.
2340
2341    If there are any constructors/destructors, they are moved to the
2342    front of the list.  This makes pushclass more efficient.
2343
2344    @@ The above comment is obsolete.  It mostly describes what add_method
2345    @@ and add_implicitly_declared_members do.
2346
2347    Sort methods that are not special (i.e., constructors, destructors, and
2348    type conversion operators) so that we can find them faster in search.  */
2349
2350 static void
2351 finish_struct_methods (t)
2352      tree t;
2353 {
2354   tree fn_fields;
2355   tree method_vec;
2356   tree ctor_name = constructor_name (t);
2357   int slot, len;
2358
2359   if (!TYPE_METHODS (t))
2360     {
2361       /* Clear these for safety; perhaps some parsing error could set
2362          these incorrectly.  */
2363       TYPE_HAS_CONSTRUCTOR (t) = 0;
2364       TYPE_HAS_DESTRUCTOR (t) = 0;
2365       CLASSTYPE_METHOD_VEC (t) = NULL_TREE;
2366       return;
2367     }
2368
2369   method_vec = CLASSTYPE_METHOD_VEC (t);
2370   my_friendly_assert (method_vec != NULL_TREE, 19991215);
2371   len = TREE_VEC_LENGTH (method_vec);
2372
2373   /* First fill in entry 0 with the constructors, entry 1 with destructors,
2374      and the next few with type conversion operators (if any).  */
2375   for (fn_fields = TYPE_METHODS (t); fn_fields;
2376        fn_fields = TREE_CHAIN (fn_fields))
2377     {
2378       tree fn_name = DECL_NAME (fn_fields);
2379
2380       /* Clear out this flag.
2381
2382          @@ Doug may figure out how to break
2383          @@ this with nested classes and friends.  */
2384       DECL_IN_AGGR_P (fn_fields) = 0;
2385
2386       /* Note here that a copy ctor is private, so we don't dare generate
2387          a default copy constructor for a class that has a member
2388          of this type without making sure they have access to it.  */
2389       if (fn_name == ctor_name)
2390         {
2391           tree parmtypes = FUNCTION_ARG_CHAIN (fn_fields);
2392           tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
2393
2394           if (TREE_CODE (parmtype) == REFERENCE_TYPE
2395               && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
2396             {
2397               if (TREE_CHAIN (parmtypes) == NULL_TREE
2398                   || TREE_CHAIN (parmtypes) == void_list_node
2399                   || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
2400                 {
2401                   if (TREE_PROTECTED (fn_fields))
2402                     TYPE_HAS_NONPUBLIC_CTOR (t) = 1;
2403                   else if (TREE_PRIVATE (fn_fields))
2404                     TYPE_HAS_NONPUBLIC_CTOR (t) = 2;
2405                 }
2406             }
2407         }
2408       else if (fn_name == ansi_opname[(int) MODIFY_EXPR])
2409         {
2410           tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields));
2411
2412           if (copy_assignment_arg_p (parmtype, DECL_VIRTUAL_P (fn_fields)))
2413             {
2414               if (TREE_PROTECTED (fn_fields))
2415                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 1;
2416               else if (TREE_PRIVATE (fn_fields))
2417                 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 2;
2418             }
2419         }
2420     }
2421
2422   if (TYPE_HAS_DESTRUCTOR (t) && !TREE_VEC_ELT (method_vec, 1))
2423     /* We thought there was a destructor, but there wasn't.  Some
2424        parse errors cause this anomalous situation.  */
2425     TYPE_HAS_DESTRUCTOR (t) = 0;
2426
2427   /* Issue warnings about private constructors and such.  If there are
2428      no methods, then some public defaults are generated.  */
2429   maybe_warn_about_overly_private_class (t);
2430
2431   /* Now sort the methods.  */
2432   while (len > 2 && TREE_VEC_ELT (method_vec, len-1) == NULL_TREE)
2433     len--;
2434   TREE_VEC_LENGTH (method_vec) = len;
2435
2436   /* The type conversion ops have to live at the front of the vec, so we
2437      can't sort them.  */
2438   for (slot = 2; slot < len; ++slot)
2439     {
2440       tree fn = TREE_VEC_ELT (method_vec, slot);
2441
2442       if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
2443         break;
2444     }
2445   if (len - slot > 1)
2446     qsort (&TREE_VEC_ELT (method_vec, slot), len-slot, sizeof (tree),
2447            (int (*)(const void *, const void *))method_name_cmp);
2448 }
2449
2450 /* Emit error when a duplicate definition of a type is seen.  Patch up.  */
2451
2452 void
2453 duplicate_tag_error (t)
2454      tree t;
2455 {
2456   cp_error ("redefinition of `%#T'", t);
2457   cp_error_at ("previous definition here", t);
2458
2459   /* Pretend we haven't defined this type.  */
2460
2461   /* All of the component_decl's were TREE_CHAINed together in the parser.
2462      finish_struct_methods walks these chains and assembles all methods with
2463      the same base name into DECL_CHAINs. Now we don't need the parser chains
2464      anymore, so we unravel them.  */
2465
2466   /* This used to be in finish_struct, but it turns out that the
2467      TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2468      things...  */
2469   if (CLASSTYPE_METHOD_VEC (t))
2470     {
2471       tree method_vec = CLASSTYPE_METHOD_VEC (t);
2472       int i, len  = TREE_VEC_LENGTH (method_vec);
2473       for (i = 0; i < len; i++)
2474         {
2475           tree unchain = TREE_VEC_ELT (method_vec, i);
2476           while (unchain != NULL_TREE)
2477             {
2478               TREE_CHAIN (OVL_CURRENT (unchain)) = NULL_TREE;
2479               unchain = OVL_NEXT (unchain);
2480             }
2481         }
2482     }
2483
2484   if (TYPE_LANG_SPECIFIC (t))
2485     {
2486       tree binfo = TYPE_BINFO (t);
2487       int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
2488       int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
2489       tree template_info = CLASSTYPE_TEMPLATE_INFO (t);
2490       int use_template = CLASSTYPE_USE_TEMPLATE (t);
2491
2492       bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
2493       BINFO_BASETYPES(binfo) = NULL_TREE;
2494
2495       TYPE_BINFO (t) = binfo;
2496       CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2497       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2498       TYPE_REDEFINED (t) = 1;
2499       CLASSTYPE_TEMPLATE_INFO (t) = template_info;
2500       CLASSTYPE_USE_TEMPLATE (t) = use_template;
2501     }
2502   TYPE_SIZE (t) = NULL_TREE;
2503   TYPE_MODE (t) = VOIDmode;
2504   TYPE_FIELDS (t) = NULL_TREE;
2505   TYPE_METHODS (t) = NULL_TREE;
2506   TYPE_VFIELD (t) = NULL_TREE;
2507   TYPE_CONTEXT (t) = NULL_TREE;
2508   TYPE_NONCOPIED_PARTS (t) = NULL_TREE;
2509 }
2510
2511 /* Make the BINFO's vtablehave N entries, including RTTI entries, but
2512    not including vbase and vcall offsets.  Set its type and call the
2513    backend to lay it out.  */
2514
2515 static void
2516 layout_vtable_decl (binfo, n)
2517      tree binfo;
2518      int n;
2519 {
2520   tree itype;
2521   tree atype;
2522
2523   itype = size_int (n);
2524   itype = size_binop (PLUS_EXPR,
2525                       itype,
2526                       num_extra_vtbl_entries (binfo));
2527   atype = build_cplus_array_type (vtable_entry_type,
2528                                   build_index_type (itype));
2529   layout_type (atype);
2530
2531   /* We may have to grow the vtable.  */
2532   if (!same_type_p (TREE_TYPE (BINFO_VTABLE (binfo)), atype))
2533     {
2534       TREE_TYPE (BINFO_VTABLE (binfo)) = atype;
2535       DECL_SIZE (BINFO_VTABLE (binfo)) = 0;
2536       layout_decl (BINFO_VTABLE (binfo), 0);
2537       /* At one time the vtable info was grabbed 2 words at a time.  This
2538          fails on sparc unless you have 8-byte alignment.  (tiemann) */
2539       DECL_ALIGN (BINFO_VTABLE (binfo))
2540         = MAX (TYPE_ALIGN (double_type_node),
2541                DECL_ALIGN (BINFO_VTABLE (binfo)));
2542     }
2543 }
2544
2545 /* Returns the number of virtual function table entries (excluding
2546    RTTI information, vbase and vcall offests, etc.) in the vtable for
2547    BINFO.  */
2548
2549 static int
2550 num_vfun_entries (binfo)
2551      tree binfo;
2552 {
2553   return list_length (skip_rtti_stuff (binfo,
2554                                        BINFO_TYPE (binfo),
2555                                        NULL));
2556 }
2557
2558 /* Called from num_extra_vtbl_entries via dfs_walk.  */
2559
2560 static tree
2561 dfs_count_virtuals (binfo, data)
2562      tree binfo;
2563      void *data;
2564 {
2565   /* Non-primary bases are not interesting; all of the virtual
2566      function table entries have been overridden.  */
2567   if (!BINFO_PRIMARY_MARKED_P (binfo))
2568     ((vcall_offset_data *) data)->offsets += num_vfun_entries (binfo);
2569
2570   return NULL_TREE;
2571 }
2572
2573 /* Returns the number of extra entries (at negative indices) required
2574    for BINFO's vtable.  */
2575
2576 tree
2577 num_extra_vtbl_entries (binfo)
2578      tree binfo;
2579 {
2580   tree type;
2581   int entries;
2582
2583   type = BINFO_TYPE (binfo);
2584   entries = 0;
2585
2586   /* There is an entry for the offset to each virtual base.  */
2587   if (vbase_offsets_in_vtable_p ())
2588     entries += list_length (CLASSTYPE_VBASECLASSES (type));
2589
2590   /* If this is a virtual base, there are entries for each virtual
2591      function defined in this class or its bases.  */
2592   if (vcall_offsets_in_vtable_p () && TREE_VIA_VIRTUAL (binfo))
2593     {
2594       vcall_offset_data vod;
2595
2596       vod.vbase = binfo;
2597       vod.offsets = 0;
2598       dfs_walk (binfo,
2599                 dfs_count_virtuals,
2600                 dfs_vcall_offset_queue_p,
2601                 &vod);
2602       entries += vod.offsets;
2603     }
2604
2605   return entries ? size_int (entries) : size_zero_node;
2606 }
2607
2608 /* Returns the offset (in bytes) from the beginning of BINFO's vtable
2609    where the vptr should actually point.  */
2610
2611 tree
2612 size_extra_vtbl_entries (binfo)
2613      tree binfo;
2614 {
2615   tree offset;
2616
2617   offset = size_binop (EXACT_DIV_EXPR,
2618                        TYPE_SIZE (vtable_entry_type),
2619                        size_int (BITS_PER_UNIT));
2620   offset = size_binop (MULT_EXPR, offset, num_extra_vtbl_entries (binfo));
2621   return fold (offset);
2622 }
2623
2624 /* Construct the initializer for BINFOs virtual function table.  BINFO
2625    is part of the hierarchy dominated by T.  */
2626
2627 static tree
2628 build_vtbl_initializer (binfo, t)
2629      tree binfo;
2630      tree t;
2631 {
2632   tree v = BINFO_VIRTUALS (binfo);
2633   tree inits = NULL_TREE;
2634   tree type = BINFO_TYPE (binfo);
2635
2636   /* Add entries to the vtable that indicate how to adjust the this
2637      pointer when calling a virtual function in this class.  */
2638   inits = build_vcall_offset_vtbl_entries (binfo, t);
2639
2640   /* Add entries to the vtable for offsets to our virtual bases.  */
2641   inits = chainon (build_vbase_offset_vtbl_entries (binfo, t),
2642                    inits);
2643
2644   /* Process the RTTI stuff at the head of the list.  If we're not
2645      using vtable thunks, then the RTTI entry is just an ordinary
2646      function, and we can process it just like the other virtual
2647      function entries.  */
2648   if (!CLASSTYPE_COM_INTERFACE (type) && flag_vtable_thunks)
2649     {
2650       tree offset;
2651       tree init;
2652
2653       /* The first entry is an offset.  */
2654       offset = TREE_PURPOSE (v);
2655       my_friendly_assert (TREE_CODE (offset) == INTEGER_CST,
2656                           19990727);
2657
2658       /* Convert the offset to look like a function pointer, so that
2659          we can put it in the vtable.  */
2660       init = build1 (NOP_EXPR, vfunc_ptr_type_node, offset);
2661       TREE_CONSTANT (init) = 1;
2662       inits = tree_cons (NULL_TREE, init, inits);
2663
2664       v = TREE_CHAIN (v);
2665
2666       if (new_abi_rtti_p ())
2667         {
2668           tree decl = TREE_VALUE (v);
2669
2670           if (decl)
2671             decl = build_unary_op (ADDR_EXPR, decl, 0);
2672           else
2673             decl = integer_zero_node;
2674           decl = build1 (NOP_EXPR, vfunc_ptr_type_node, decl);
2675           TREE_CONSTANT (decl) = 1;
2676           decl = build_vtable_entry (integer_zero_node, integer_zero_node,
2677                                      decl);
2678           inits = tree_cons (NULL_TREE, decl, inits);
2679
2680           v = TREE_CHAIN (v);
2681         }
2682       /* In the old abi the second entry (the tdesc pointer) is
2683          just an ordinary function, so it can be dealt with like the
2684          virtual functions.  */
2685     }
2686
2687   /* Go through all the ordinary virtual functions, building up
2688      initializers.  */
2689   while (v)
2690     {
2691       tree delta;
2692       tree vcall_index;
2693       tree fn;
2694       tree init;
2695
2696       /* Pull the offset for `this', and the function to call, out of
2697          the list.  */
2698       delta = BV_DELTA (v);
2699       vcall_index = BV_VCALL_INDEX (v);
2700       fn = BV_FN (v);
2701       my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727);
2702       my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727);
2703
2704       /* You can't call an abstract virtual function; it's abstract.
2705          So, we replace these functions with __pure_virtual.  */
2706       if (DECL_PURE_VIRTUAL_P (fn))
2707         fn = abort_fndecl;
2708
2709       /* Package up that information for the vtable.  */
2710       init = build_vtable_entry (delta, vcall_index, fn);
2711       /* And add it to the chain of initializers.  */
2712       inits = tree_cons (NULL_TREE, init, inits);
2713
2714       /* Keep going.  */
2715       v = TREE_CHAIN (v);
2716     }
2717
2718   /* The initializers were built up in reverse order; straighten them
2719      out now.  */
2720   inits = nreverse (inits);
2721   /* Package all the initializers up as an array initializer.  */
2722   return build_nt (CONSTRUCTOR, NULL_TREE, inits);
2723 }
2724
2725 /* Called from finish_vtbls via dfs_walk.  */
2726
2727 static tree
2728 dfs_finish_vtbls (binfo, data)
2729      tree binfo;
2730      void *data;
2731 {
2732   if (!BINFO_PRIMARY_MARKED_P (binfo)
2733       && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo))
2734       && BINFO_NEW_VTABLE_MARKED (binfo))
2735     {
2736       tree decl;
2737       tree context;
2738
2739       layout_vtable_decl (binfo, list_length (BINFO_VIRTUALS (binfo)));
2740       decl = BINFO_VTABLE (binfo);
2741       context = DECL_CONTEXT (decl);
2742       DECL_CONTEXT (decl) = 0;
2743       DECL_INITIAL (decl) = build_vtbl_initializer (binfo, (tree) data);
2744       cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
2745       DECL_CONTEXT (decl) = context;
2746     }
2747
2748   CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
2749   SET_BINFO_MARKED (binfo);
2750
2751   return NULL_TREE;
2752 }
2753
2754 /* Create all the necessary vtables for T and its base classes.  */
2755
2756 static void
2757 finish_vtbls (t)
2758      tree t;
2759 {
2760   dfs_walk (TYPE_BINFO (t), dfs_finish_vtbls,
2761             dfs_unmarked_real_bases_queue_p, t);
2762   dfs_walk (TYPE_BINFO (t), dfs_unmark,
2763             dfs_marked_real_bases_queue_p, t);
2764 }
2765
2766 /* True if we should override the given BASE_FNDECL with the given
2767    FNDECL.  */
2768
2769 static int
2770 overrides (fndecl, base_fndecl)
2771      tree fndecl, base_fndecl;
2772 {
2773   /* Destructors have special names.  */
2774   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2775       && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2776     return 1;
2777   if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl))
2778       || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2779     return 0;
2780   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl))
2781     {
2782       tree types, base_types;
2783 #if 0
2784       retypes = TREE_TYPE (TREE_TYPE (fndecl));
2785       base_retypes = TREE_TYPE (TREE_TYPE (base_fndecl));
2786 #endif
2787       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2788       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
2789       if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
2790            == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
2791           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
2792         return 1;
2793     }
2794   return 0;
2795 }
2796
2797 typedef struct find_final_overrider_data_s {
2798   /* The function for which we are trying to find a final overrider.  */
2799   tree fn;
2800   /* The base class in which the function was declared.  */
2801   tree declaring_base;
2802   /* The most derived class in the hierarchy.  */
2803   tree most_derived_type;
2804   /* The final overriding function.  */
2805   tree overriding_fn;
2806   /* The BINFO for the class in which the final overriding function
2807      appears.  */
2808   tree overriding_base;
2809 } find_final_overrider_data;
2810
2811 /* Called from find_final_overrider via dfs_walk.  */
2812
2813 static tree
2814 dfs_find_final_overrider (binfo, data)
2815      tree binfo;
2816      void *data;
2817 {
2818   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
2819
2820   if (same_type_p (BINFO_TYPE (binfo),
2821                    BINFO_TYPE (ffod->declaring_base))
2822       && tree_int_cst_equal (BINFO_OFFSET (binfo),
2823                              BINFO_OFFSET (ffod->declaring_base)))
2824     {
2825       tree path;
2826       tree method;
2827
2828       /* We've found a path to the declaring base.  Walk down the path
2829          looking for an overrider for FN.  */
2830       for (path = reverse_path (binfo);
2831            path;
2832            path = TREE_CHAIN (path))
2833         {
2834           for (method = TYPE_METHODS (BINFO_TYPE (TREE_VALUE (path)));
2835                method;
2836                method = TREE_CHAIN (method))
2837             if (DECL_VIRTUAL_P (method) && overrides (method, ffod->fn))
2838               break;
2839
2840           if (method)
2841             break;
2842         }
2843
2844       /* If we found an overrider, record the overriding function, and
2845          the base from which it came.  */
2846       if (path)
2847         {
2848           if (ffod->overriding_fn && ffod->overriding_fn != method)
2849             {
2850               /* We've found a different overrider along a different
2851                  path.  That can be OK if the new one overrides the
2852                  old one.  Consider:
2853
2854                    struct S { virtual void f(); };
2855                    struct T : public virtual S { virtual void f(); };
2856                    struct U : public virtual S, public virtual T {};
2857
2858                  Here `T::f' is the final overrider for `S::f'.  */
2859               if (strictly_overrides (method, ffod->overriding_fn))
2860                 {
2861                   ffod->overriding_fn = method;
2862                   ffod->overriding_base = TREE_VALUE (path);
2863                 }
2864               else if (!strictly_overrides (ffod->overriding_fn, method))
2865                 {
2866                   cp_error ("no unique final overrider for `%D' in `%T'",
2867                             ffod->most_derived_type,
2868                             ffod->fn);
2869                   cp_error ("candidates are: `%#D'", ffod->overriding_fn);
2870                   cp_error ("                `%#D'", method);
2871                   return error_mark_node;
2872                 }
2873             }
2874           else if (ffod->overriding_base
2875                    && (!tree_int_cst_equal
2876                        (BINFO_OFFSET (TREE_VALUE (path)),
2877                         BINFO_OFFSET (ffod->overriding_base))))
2878             {
2879               /* We've found two instances of the same base that
2880                  provide overriders.  */
2881               cp_error ("no unique final overrider for `%D' since there two instances of `%T' in `%T'",
2882                         ffod->fn,
2883                         BINFO_TYPE (ffod->overriding_base),
2884                         ffod->most_derived_type);
2885               return error_mark_node;
2886             }
2887           else
2888             {
2889               ffod->overriding_fn = method;
2890               ffod->overriding_base = TREE_VALUE (path);
2891             }
2892         }
2893     }
2894
2895   return NULL_TREE;
2896 }
2897
2898 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2899    FN and whose TREE_VALUE is the binfo for the base where the
2900    overriding occurs.  BINFO (in the hierarchy dominated by T) is the
2901    base object in which FN is declared.  */
2902
2903 static tree
2904 find_final_overrider (t, binfo, fn)
2905      tree t;
2906      tree binfo;
2907      tree fn;
2908 {
2909   find_final_overrider_data ffod;
2910
2911   /* Getting this right is a little tricky.  This is legal:
2912
2913        struct S { virtual void f (); };
2914        struct T { virtual void f (); };
2915        struct U : public S, public T { };
2916
2917      even though calling `f' in `U' is ambiguous.  But,
2918
2919        struct R { virtual void f(); };
2920        struct S : virtual public R { virtual void f (); };
2921        struct T : virtual public R { virtual void f (); };
2922        struct U : public S, public T { };
2923
2924      is not -- there's no way  to decide whether to put `S::f' or
2925      `T::f' in the vtable for `R'.
2926
2927      The solution is to look at all paths to BINFO.  If we find
2928      different overriders along any two, then there is a problem.  */
2929   ffod.fn = fn;
2930   ffod.declaring_base = binfo;
2931   ffod.most_derived_type = t;
2932   ffod.overriding_fn = NULL_TREE;
2933   ffod.overriding_base = NULL_TREE;
2934
2935   if (dfs_walk (TYPE_BINFO (t),
2936                 dfs_find_final_overrider,
2937                 NULL,
2938                 &ffod))
2939     return error_mark_node;
2940
2941   return build_tree_list (ffod.overriding_fn, ffod.overriding_base);
2942 }
2943
2944 /* Return the BINFO_VIRTUALS list for BINFO, without the RTTI stuff at
2945    the front.  If non-NULL, N is set to the number of entries
2946    skipped.  */
2947
2948 tree
2949 skip_rtti_stuff (binfo, t, n)
2950      tree binfo;
2951      tree t;
2952      unsigned HOST_WIDE_INT *n;
2953 {
2954   tree virtuals;
2955
2956   if (CLASSTYPE_COM_INTERFACE (t))
2957     return 0;
2958
2959   if (n)
2960     *n = 0;
2961   virtuals = BINFO_VIRTUALS (binfo);
2962   if (virtuals)
2963     {
2964       /* We always reserve a slot for the offset/tdesc entry.  */
2965       if (n)
2966         ++*n;
2967       virtuals = TREE_CHAIN (virtuals);
2968     }
2969   if (flag_vtable_thunks && virtuals)
2970     {
2971       /* The second slot is reserved for the tdesc pointer when thunks
2972          are used.  */
2973       if (n)
2974         ++*n;
2975       virtuals = TREE_CHAIN (virtuals);
2976     }
2977
2978   return virtuals;
2979 }
2980
2981 /* Called via dfs_walk.  Returns BINFO if BINFO has the same type as
2982    DATA (which is really an _TYPE node).  */
2983
2984 static tree
2985 dfs_find_base (binfo, data)
2986      tree binfo;
2987      void *data;
2988 {
2989   return (same_type_p (BINFO_TYPE (binfo), (tree) data)
2990           ? binfo : NULL_TREE);
2991 }
2992
2993 /* Called from modify_all_vtables via dfs_walk.  */
2994
2995 static tree
2996 dfs_modify_vtables (binfo, data)
2997      tree binfo;
2998      void *data;
2999 {
3000   if (/* There's no need to modify the vtable for a primary base;
3001          we're not going to use that vtable anyhow.  */
3002       !BINFO_PRIMARY_MARKED_P (binfo)
3003       /* Similarly, a base without a vtable needs no modification.  */
3004       && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
3005     {
3006       tree t;
3007       tree virtuals;
3008       tree old_virtuals;
3009
3010       t = (tree) data;
3011
3012       /* If we're support RTTI then we always need a new vtable to point
3013          to the RTTI information.  Under the new ABI we may need a new
3014          vtable to contain vcall and vbase offsets.  */
3015       if (flag_rtti || flag_new_abi)
3016         make_new_vtable (t, binfo);
3017
3018       /* Now, go through each of the virtual functions in the virtual
3019          function table for BINFO.  Find the final overrider, and
3020          update the BINFO_VIRTUALS list appropriately.  */
3021       for (virtuals = skip_rtti_stuff (binfo, BINFO_TYPE (binfo), NULL),
3022              old_virtuals = skip_rtti_stuff (TYPE_BINFO (BINFO_TYPE (binfo)),
3023                                              BINFO_TYPE (binfo),
3024                                              NULL);
3025            virtuals;
3026            virtuals = TREE_CHAIN (virtuals),
3027              old_virtuals = TREE_CHAIN (old_virtuals))
3028         {
3029           tree b;
3030           tree fn;
3031           tree overrider;
3032           tree vindex;
3033           tree delta;
3034
3035           /* Find the function which originally caused this vtable
3036              entry to be present.  */
3037           fn = BV_FN (old_virtuals);
3038           vindex = DECL_VINDEX (fn);
3039           b = dfs_walk (binfo, dfs_find_base, NULL, DECL_VIRTUAL_CONTEXT (fn));
3040           fn = skip_rtti_stuff (TYPE_BINFO (BINFO_TYPE (b)),
3041                                 BINFO_TYPE (b),
3042                                 NULL);
3043           while (!tree_int_cst_equal (DECL_VINDEX (BV_FN (fn)), vindex))
3044             fn = TREE_CHAIN (fn);
3045           fn = BV_FN (fn);
3046
3047           /* Handle the case of a virtual function defined in BINFO
3048              itself.  */
3049           overrider = find_final_overrider (t, b, fn);
3050           if (overrider == error_mark_node)
3051             continue;
3052
3053           /* The `this' pointer needs to be adjusted from pointing to
3054              BINFO to pointing at the base where the final overrider
3055              appears.  */
3056           delta = size_binop (PLUS_EXPR,
3057                               get_derived_offset (binfo,
3058                                                   DECL_VIRTUAL_CONTEXT (fn)),
3059                               BINFO_OFFSET (binfo));
3060           delta = ssize_binop (MINUS_EXPR,
3061                                BINFO_OFFSET (TREE_VALUE (overrider)),
3062                                delta);
3063
3064           modify_vtable_entry (t,
3065                                binfo,
3066                                TREE_PURPOSE (overrider),
3067                                delta,
3068                                &virtuals);
3069         }
3070     }
3071
3072   SET_BINFO_MARKED (binfo);
3073
3074   return NULL_TREE;
3075 }
3076
3077 /* Update all of the primary and secondary vtables for T.  Create new
3078    vtables as required, and initialize their RTTI information.  Each
3079    of the functions in OVERRIDDEN_VIRTUALS overrides a virtual
3080    function from a base class; find and modify the appropriate entries
3081    to point to the overriding functions.  Returns a list, in
3082    declaration order, of the functions that are overridden in this
3083    class, but do not appear in the primary base class vtable, and
3084    which should therefore be appended to the end of the vtable for T.  */
3085
3086 static tree
3087 modify_all_vtables (t, has_virtual_p, overridden_virtuals)
3088      tree t;
3089      int *has_virtual_p;
3090      tree overridden_virtuals;
3091 {
3092   tree binfo;
3093
3094   binfo = TYPE_BINFO (t);
3095
3096   /* Update all of the vtables.  */
3097   dfs_walk (binfo,
3098             dfs_modify_vtables,
3099             dfs_unmarked_real_bases_queue_p,
3100             t);
3101   dfs_walk (binfo, dfs_unmark, dfs_marked_real_bases_queue_p, t);
3102
3103   /* If we should include overriding functions for secondary vtables
3104      in our primary vtable, add them now.  */
3105   if (all_overridden_vfuns_in_vtables_p ())
3106     {
3107       tree *fnsp = &overridden_virtuals;
3108
3109       while (*fnsp)
3110         {
3111           tree fn = TREE_VALUE (*fnsp);
3112
3113           if (BINFO_VIRTUALS (binfo)
3114               && !value_member (fn, BINFO_VIRTUALS (binfo)))
3115             {
3116               /* We know we need a vtable for this class now.  */
3117               start_vtable (t, has_virtual_p);
3118               /* Set the vtable index.  */
3119               DECL_VINDEX (fn)
3120                 = build_shared_int_cst ((*has_virtual_p)++);
3121               /* We don't need to convert to a base class when calling
3122                  this function.  */
3123               DECL_VIRTUAL_CONTEXT (fn) = t;
3124               /* We don't need to adjust the `this' pointer when
3125                  calling this function.  */
3126               BV_DELTA (*fnsp) = integer_zero_node;
3127               BV_VCALL_INDEX (*fnsp) = integer_zero_node;
3128
3129               /* This is an overridden function not already in our
3130                  vtable.  Keep it.  */
3131               fnsp = &TREE_CHAIN (*fnsp);
3132             }
3133           else
3134             /* We've already got an entry for this function.  Skip
3135                it.  */
3136             *fnsp = TREE_CHAIN (*fnsp);
3137         }
3138     }
3139   else
3140     overridden_virtuals = NULL_TREE;
3141
3142   return overridden_virtuals;
3143 }
3144
3145 /* Here, we already know that they match in every respect.
3146    All we have to check is where they had their declarations.  */
3147
3148 static int
3149 strictly_overrides (fndecl1, fndecl2)
3150      tree fndecl1, fndecl2;
3151 {
3152   int distance = get_base_distance (DECL_CLASS_CONTEXT (fndecl2),
3153                                     DECL_CLASS_CONTEXT (fndecl1),
3154                                     0, (tree *)0);
3155   if (distance == -2 || distance > 0)
3156     return 1;
3157   return 0;
3158 }
3159
3160 /* Get the base virtual function declarations in T that are either
3161    overridden or hidden by FNDECL as a list.  We set TREE_PURPOSE with
3162    the overrider/hider.  */
3163
3164 static tree
3165 get_basefndecls (fndecl, t)
3166      tree fndecl, t;
3167 {
3168   tree methods = TYPE_METHODS (t);
3169   tree base_fndecls = NULL_TREE;
3170   tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
3171   int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3172
3173   while (methods)
3174     {
3175       if (TREE_CODE (methods) == FUNCTION_DECL
3176           && DECL_VINDEX (methods) != NULL_TREE
3177           && DECL_NAME (fndecl) == DECL_NAME (methods))
3178         base_fndecls = tree_cons (fndecl, methods, base_fndecls);
3179
3180       methods = TREE_CHAIN (methods);
3181     }
3182
3183   if (base_fndecls)
3184     return base_fndecls;
3185
3186   for (i = 0; i < n_baseclasses; i++)
3187     {
3188       tree base_binfo = TREE_VEC_ELT (binfos, i);
3189       tree basetype = BINFO_TYPE (base_binfo);
3190
3191       base_fndecls = chainon (get_basefndecls (fndecl, basetype),
3192                               base_fndecls);
3193     }
3194
3195   return base_fndecls;
3196 }
3197
3198 /* Mark the functions that have been hidden with their overriders.
3199    Since we start out with all functions already marked with a hider,
3200    no need to mark functions that are just hidden.
3201
3202    Subroutine of warn_hidden.  */
3203
3204 static void
3205 mark_overriders (fndecl, base_fndecls)
3206      tree fndecl, base_fndecls;
3207 {
3208   for (; base_fndecls; base_fndecls = TREE_CHAIN (base_fndecls))
3209     {
3210       if (overrides (fndecl, TREE_VALUE (base_fndecls)))
3211         TREE_PURPOSE (base_fndecls) = fndecl;
3212     }
3213 }
3214
3215 /* If this declaration supersedes the declaration of
3216    a method declared virtual in the base class, then
3217    mark this field as being virtual as well.  */
3218
3219 static void
3220 check_for_override (decl, ctype)
3221      tree decl, ctype;
3222 {
3223   tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
3224   int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3225   int virtualp = DECL_VIRTUAL_P (decl);
3226   int found_overriden_fn = 0;
3227
3228   for (i = 0; i < n_baselinks; i++)
3229     {
3230       tree base_binfo = TREE_VEC_ELT (binfos, i);
3231       if (TYPE_POLYMORPHIC_P (BINFO_TYPE (base_binfo)))
3232         {
3233           tree tmp = get_matching_virtual
3234             (base_binfo, decl,
3235              DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
3236
3237           if (tmp && !found_overriden_fn)
3238             {
3239               /* If this function overrides some virtual in some base
3240                  class, then the function itself is also necessarily
3241                  virtual, even if the user didn't explicitly say so.  */
3242               DECL_VIRTUAL_P (decl) = 1;
3243
3244               /* The TMP we really want is the one from the deepest
3245                  baseclass on this path, taking care not to
3246                  duplicate if we have already found it (via another
3247                  path to its virtual baseclass.  */
3248               if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
3249                 {
3250                   cp_error_at ("`static %#D' cannot be declared", decl);
3251                   cp_error_at ("  since `virtual %#D' declared in base class",
3252                                tmp);
3253                   break;
3254                 }
3255               virtualp = 1;
3256
3257               /* Set DECL_VINDEX to a value that is neither an
3258                  INTEGER_CST nor the error_mark_node so that
3259                  add_virtual_function will realize this is an
3260                  overridden function.  */
3261               DECL_VINDEX (decl)
3262                 = tree_cons (tmp, NULL_TREE, DECL_VINDEX (decl));
3263
3264               /* We now know that DECL overrides something,
3265                  which is all that is important.  But, we must
3266                  continue to iterate through all the base-classes
3267                  in order to allow get_matching_virtual to check for
3268                  various illegal overrides.  */
3269               found_overriden_fn = 1;
3270             }
3271         }
3272     }
3273   if (virtualp)
3274     {
3275       if (DECL_VINDEX (decl) == NULL_TREE)
3276         DECL_VINDEX (decl) = error_mark_node;
3277       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
3278     }
3279 }
3280
3281 /* Warn about hidden virtual functions that are not overridden in t.
3282    We know that constructors and destructors don't apply.  */
3283
3284 void
3285 warn_hidden (t)
3286      tree t;
3287 {
3288   tree method_vec = CLASSTYPE_METHOD_VEC (t);
3289   int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
3290   int i;
3291
3292   /* We go through each separately named virtual function.  */
3293   for (i = 2; i < n_methods && TREE_VEC_ELT (method_vec, i); ++i)
3294     {
3295       tree fns = TREE_VEC_ELT (method_vec, i);
3296       tree fndecl = NULL_TREE;
3297
3298       tree base_fndecls = NULL_TREE;
3299       tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
3300       int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3301
3302       /* First see if we have any virtual functions in this batch.  */
3303       for (; fns; fns = OVL_NEXT (fns))
3304         {
3305           fndecl = OVL_CURRENT (fns);
3306           if (DECL_VINDEX (fndecl))
3307             break;
3308         }
3309
3310       if (fns == NULL_TREE)
3311         continue;
3312
3313       /* First we get a list of all possible functions that might be
3314          hidden from each base class.  */
3315       for (i = 0; i < n_baseclasses; i++)
3316         {
3317           tree base_binfo = TREE_VEC_ELT (binfos, i);
3318           tree basetype = BINFO_TYPE (base_binfo);
3319
3320           base_fndecls = chainon (get_basefndecls (fndecl, basetype),
3321                                   base_fndecls);
3322         }
3323
3324       fns = OVL_NEXT (fns);
3325
3326       /* ...then mark up all the base functions with overriders, preferring
3327          overriders to hiders.  */
3328       if (base_fndecls)
3329         for (; fns; fns = OVL_NEXT (fns))
3330           {
3331             fndecl = OVL_CURRENT (fns);
3332             if (DECL_VINDEX (fndecl))
3333               mark_overriders (fndecl, base_fndecls);
3334           }
3335
3336       /* Now give a warning for all base functions without overriders,
3337          as they are hidden.  */
3338       for (; base_fndecls; base_fndecls = TREE_CHAIN (base_fndecls))
3339         {
3340           if (! overrides (TREE_PURPOSE (base_fndecls),
3341                            TREE_VALUE (base_fndecls)))
3342             {
3343               /* Here we know it is a hider, and no overrider exists.  */
3344               cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
3345               cp_warning_at ("  by `%D'", TREE_PURPOSE (base_fndecls));
3346             }
3347         }
3348     }
3349 }
3350
3351 /* Check for things that are invalid.  There are probably plenty of other
3352    things we should check for also.  */
3353
3354 static void
3355 finish_struct_anon (t)
3356      tree t;
3357 {
3358   tree field;
3359
3360   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3361     {
3362       if (TREE_STATIC (field))
3363         continue;
3364       if (TREE_CODE (field) != FIELD_DECL)
3365         continue;
3366
3367       if (DECL_NAME (field) == NULL_TREE
3368           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
3369         {
3370           tree elt = TYPE_FIELDS (TREE_TYPE (field));
3371           for (; elt; elt = TREE_CHAIN (elt))
3372             {
3373               if (DECL_ARTIFICIAL (elt))
3374                 continue;
3375
3376               if (DECL_NAME (elt) == constructor_name (t))
3377                 cp_pedwarn_at ("ANSI C++ forbids member `%D' with same name as enclosing class",
3378                                elt);
3379
3380               if (TREE_CODE (elt) != FIELD_DECL)
3381                 {
3382                   cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
3383                                  elt);
3384                   continue;
3385                 }
3386
3387               if (TREE_PRIVATE (elt))
3388                 cp_pedwarn_at ("private member `%#D' in anonymous union",
3389                                elt);
3390               else if (TREE_PROTECTED (elt))
3391                 cp_pedwarn_at ("protected member `%#D' in anonymous union",
3392                                elt);
3393
3394               TREE_PRIVATE (elt) = TREE_PRIVATE (field);
3395               TREE_PROTECTED (elt) = TREE_PROTECTED (field);
3396             }
3397         }
3398     }
3399 }
3400
3401 extern int interface_only, interface_unknown;
3402
3403 /* Create default constructors, assignment operators, and so forth for
3404    the type indicated by T, if they are needed.
3405    CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
3406    CANT_HAVE_ASSIGNMENT are nonzero if, for whatever reason, the class
3407    cannot have a default constructor, copy constructor taking a const
3408    reference argument, or an assignment operator, respectively.  If a
3409    virtual destructor is created, its DECL is returned; otherwise the
3410    return value is NULL_TREE.  */
3411
3412 static tree
3413 add_implicitly_declared_members (t, cant_have_default_ctor,
3414                                  cant_have_const_cctor,
3415                                  cant_have_assignment)
3416      tree t;
3417      int cant_have_default_ctor;
3418      int cant_have_const_cctor;
3419      int cant_have_assignment;
3420 {
3421   tree default_fn;
3422   tree implicit_fns = NULL_TREE;
3423   tree name = TYPE_IDENTIFIER (t);
3424   tree virtual_dtor = NULL_TREE;
3425   tree *f;
3426
3427   /* Destructor.  */
3428   if (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t))
3429     {
3430       default_fn = cons_up_default_function (t, name, 0);
3431       check_for_override (default_fn, t);
3432
3433       /* If we couldn't make it work, then pretend we didn't need it.  */
3434       if (default_fn == void_type_node)
3435         TYPE_NEEDS_DESTRUCTOR (t) = 0;
3436       else
3437         {
3438           TREE_CHAIN (default_fn) = implicit_fns;
3439           implicit_fns = default_fn;
3440
3441           if (DECL_VINDEX (default_fn))
3442             virtual_dtor = default_fn;
3443         }
3444     }
3445   TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
3446
3447   /* Default constructor.  */
3448   if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor)
3449     {
3450       default_fn = cons_up_default_function (t, name, 2);
3451       TREE_CHAIN (default_fn) = implicit_fns;
3452       implicit_fns = default_fn;
3453     }
3454
3455   /* Copy constructor.  */
3456   if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
3457     {
3458       /* ARM 12.18: You get either X(X&) or X(const X&), but
3459          not both.  --Chip  */
3460       default_fn = cons_up_default_function (t, name,
3461                                              3 + cant_have_const_cctor);
3462       TREE_CHAIN (default_fn) = implicit_fns;
3463       implicit_fns = default_fn;
3464     }
3465
3466   /* Assignment operator.  */
3467   if (! TYPE_HAS_ASSIGN_REF (t) && ! TYPE_FOR_JAVA (t))
3468     {
3469       default_fn = cons_up_default_function (t, name,
3470                                              5 + cant_have_assignment);
3471       TREE_CHAIN (default_fn) = implicit_fns;
3472       implicit_fns = default_fn;
3473     }
3474
3475   /* Now, hook all of the new functions on to TYPE_METHODS,
3476      and add them to the CLASSTYPE_METHOD_VEC.  */
3477   for (f = &implicit_fns; *f; f = &TREE_CHAIN (*f))
3478     add_method (t, 0, *f);
3479   *f = TYPE_METHODS (t);
3480   TYPE_METHODS (t) = implicit_fns;
3481
3482   return virtual_dtor;
3483 }
3484
3485 /* Subroutine of finish_struct_1.  Recursively count the number of fields
3486    in TYPE, including anonymous union members.  */
3487
3488 static int
3489 count_fields (fields)
3490      tree fields;
3491 {
3492   tree x;
3493   int n_fields = 0;
3494   for (x = fields; x; x = TREE_CHAIN (x))
3495     {
3496       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
3497         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
3498       else
3499         n_fields += 1;
3500     }
3501   return n_fields;
3502 }
3503
3504 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
3505    TREE_LIST FIELDS to the TREE_VEC FIELD_VEC, starting at offset IDX.  */
3506
3507 static int
3508 add_fields_to_vec (fields, field_vec, idx)
3509      tree fields, field_vec;
3510      int idx;
3511 {
3512   tree x;
3513   for (x = fields; x; x = TREE_CHAIN (x))
3514     {
3515       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
3516         idx = add_fields_to_vec (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
3517       else
3518         TREE_VEC_ELT (field_vec, idx++) = x;
3519     }
3520   return idx;
3521 }
3522
3523 /* FIELD is a bit-field.  We are finishing the processing for its
3524    enclosing type.  Issue any appropriate messages and set appropriate
3525    flags.  */
3526
3527 static void
3528 check_bitfield_decl (field)
3529      tree field;
3530 {
3531   tree type = TREE_TYPE (field);
3532
3533   /* Invalid bit-field size done by grokfield.  */
3534   /* Detect invalid bit-field type. Simply checking if TYPE is
3535      integral is insufficient, as that is the array core of the field
3536      type. If TREE_TYPE (field) is integral, then TYPE must be the same.  */
3537   if (DECL_INITIAL (field)
3538       && ! INTEGRAL_TYPE_P (TREE_TYPE (field)))
3539     {
3540       cp_error_at ("bit-field `%#D' with non-integral type", field);
3541       DECL_INITIAL (field) = NULL;
3542     }
3543
3544   /* Detect and ignore out of range field width.  */
3545   if (DECL_INITIAL (field))
3546     {
3547       tree w = DECL_INITIAL (field);
3548       register int width = 0;
3549
3550       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
3551       STRIP_NOPS (w);
3552
3553       /* detect invalid field size.  */
3554       if (TREE_CODE (w) == CONST_DECL)
3555         w = DECL_INITIAL (w);
3556       else if (TREE_READONLY_DECL_P (w))
3557         w = decl_constant_value (w);
3558
3559       if (TREE_CODE (w) != INTEGER_CST)
3560         {
3561           cp_error_at ("bit-field `%D' width not an integer constant",
3562                        field);
3563           DECL_INITIAL (field) = NULL_TREE;
3564         }
3565       else if (width = TREE_INT_CST_LOW (w),
3566                width < 0)
3567         {
3568           DECL_INITIAL (field) = NULL;
3569           cp_error_at ("negative width in bit-field `%D'", field);
3570         }
3571       else if (width == 0 && DECL_NAME (field) != 0)
3572         {
3573           DECL_INITIAL (field) = NULL;
3574           cp_error_at ("zero width for bit-field `%D'", field);
3575         }
3576       else if (width
3577                > TYPE_PRECISION (long_long_unsigned_type_node))
3578         {
3579           /* The backend will dump if you try to use something too
3580              big; avoid that.  */
3581           DECL_INITIAL (field) = NULL;
3582           sorry ("bit-fields larger than %d bits",
3583                  TYPE_PRECISION (long_long_unsigned_type_node));
3584           cp_error_at ("  in declaration of `%D'", field);
3585         }
3586       else if (width > TYPE_PRECISION (type)
3587                && TREE_CODE (type) != ENUMERAL_TYPE
3588                && TREE_CODE (type) != BOOLEAN_TYPE)
3589         cp_warning_at ("width of `%D' exceeds its type", field);
3590       else if (TREE_CODE (type) == ENUMERAL_TYPE
3591                && ((min_precision (TYPE_MIN_VALUE (type),
3592                                    TREE_UNSIGNED (type)) > width)
3593                    || (min_precision (TYPE_MAX_VALUE (type),
3594                                       TREE_UNSIGNED (type)) > width)))
3595         cp_warning_at ("`%D' is too small to hold all values of `%#T'",
3596                        field, type);
3597
3598       if (DECL_INITIAL (field))
3599         {
3600           DECL_INITIAL (field) = NULL_TREE;
3601           DECL_FIELD_SIZE (field) = width;
3602           DECL_BIT_FIELD (field) = 1;
3603
3604           if (width == 0)
3605             {
3606 #ifdef EMPTY_FIELD_BOUNDARY
3607               DECL_ALIGN (field) = MAX (DECL_ALIGN (field),
3608                                         EMPTY_FIELD_BOUNDARY);
3609 #endif
3610 #ifdef PCC_BITFIELD_TYPE_MATTERS
3611               if (PCC_BITFIELD_TYPE_MATTERS)
3612                 DECL_ALIGN (field) = MAX (DECL_ALIGN (field),
3613                                           TYPE_ALIGN (type));
3614 #endif
3615             }
3616         }
3617     }
3618   else
3619     /* Non-bit-fields are aligned for their type.  */
3620     DECL_ALIGN (field) = MAX (DECL_ALIGN (field), TYPE_ALIGN (type));
3621 }
3622
3623 /* FIELD is a non bit-field.  We are finishing the processing for its
3624    enclosing type T.  Issue any appropriate messages and set appropriate
3625    flags.  */
3626
3627 static void
3628 check_field_decl (field, t, cant_have_const_ctor,
3629                   cant_have_default_ctor, no_const_asn_ref,
3630                   any_default_members)
3631      tree field;
3632      tree t;
3633      int *cant_have_const_ctor;
3634      int *cant_have_default_ctor;
3635      int *no_const_asn_ref;
3636      int *any_default_members;
3637 {
3638   tree type = strip_array_types (TREE_TYPE (field));
3639
3640   /* An anonymous union cannot contain any fields which would change
3641      the settings of CANT_HAVE_CONST_CTOR and friends.  */
3642   if (ANON_UNION_TYPE_P (type))
3643     ;
3644   /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
3645      structs.  So, we recurse through their fields here.  */
3646   else if (ANON_AGGR_TYPE_P (type))
3647     {
3648       tree fields;
3649
3650       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
3651         if (TREE_CODE (field) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
3652           check_field_decl (fields, t, cant_have_const_ctor,
3653                             cant_have_default_ctor, no_const_asn_ref,
3654                             any_default_members);
3655     }
3656   /* Check members with class type for constructors, destructors,
3657      etc.  */
3658   else if (CLASS_TYPE_P (type))
3659     {
3660       /* Never let anything with uninheritable virtuals
3661          make it through without complaint.  */
3662       abstract_virtuals_error (field, type);
3663
3664       if (TREE_CODE (t) == UNION_TYPE)
3665         {
3666           if (TYPE_NEEDS_CONSTRUCTING (type))
3667             cp_error_at ("member `%#D' with constructor not allowed in union",
3668                          field);
3669           if (TYPE_NEEDS_DESTRUCTOR (type))
3670             cp_error_at ("member `%#D' with destructor not allowed in union",
3671                          field);
3672           if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3673             cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
3674                          field);
3675         }
3676       else
3677         {
3678           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
3679           TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (type);
3680           TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
3681           TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
3682         }
3683
3684       if (!TYPE_HAS_CONST_INIT_REF (type))
3685         *cant_have_const_ctor = 1;
3686
3687       if (!TYPE_HAS_CONST_ASSIGN_REF (type))
3688         *no_const_asn_ref = 1;
3689
3690       if (TYPE_HAS_CONSTRUCTOR (type)
3691           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3692         *cant_have_default_ctor = 1;
3693     }
3694   if (DECL_INITIAL (field) != NULL_TREE)
3695     {
3696       /* `build_class_init_list' does not recognize
3697          non-FIELD_DECLs.  */
3698       if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
3699         cp_error_at ("multiple fields in union `%T' initialized");
3700       *any_default_members = 1;
3701     }
3702
3703   /* Non-bit-fields are aligned for their type, except packed fields
3704      which require only BITS_PER_UNIT alignment.  */
3705   DECL_ALIGN (field) = MAX (DECL_ALIGN (field),
3706                             (DECL_PACKED (field)
3707                              ? BITS_PER_UNIT
3708                              : TYPE_ALIGN (TREE_TYPE (field))));
3709 }
3710
3711 /* Check the data members (both static and non-static), class-scoped
3712    typedefs, etc., appearing in the declaration of T.  Issue
3713    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
3714    declaration order) of access declarations; each TREE_VALUE in this
3715    list is a USING_DECL.
3716
3717    In addition, set the following flags:
3718
3719      EMPTY_P
3720        The class is empty, i.e., contains no non-static data members.
3721
3722      CANT_HAVE_DEFAULT_CTOR_P
3723        This class cannot have an implicitly generated default
3724        constructor.
3725
3726      CANT_HAVE_CONST_CTOR_P
3727        This class cannot have an implicitly generated copy constructor
3728        taking a const reference.
3729
3730      CANT_HAVE_CONST_ASN_REF
3731        This class cannot have an implicitly generated assignment
3732        operator taking a const reference.
3733
3734    All of these flags should be initialized before calling this
3735    function.
3736
3737    Returns a pointer to the end of the TYPE_FIELDs chain; additional
3738    fields can be added by adding to this chain.  */
3739
3740 static void
3741 check_field_decls (t, access_decls, empty_p,
3742                    cant_have_default_ctor_p, cant_have_const_ctor_p,
3743                    no_const_asn_ref_p)
3744      tree t;
3745      tree *access_decls;
3746      int *empty_p;
3747      int *cant_have_default_ctor_p;
3748      int *cant_have_const_ctor_p;
3749      int *no_const_asn_ref_p;
3750 {
3751   tree *field;
3752   tree *next;
3753   int has_pointers;
3754   int any_default_members;
3755
3756   /* First, delete any duplicate fields.  */
3757   delete_duplicate_fields (TYPE_FIELDS (t));
3758
3759   /* Assume there are no access declarations.  */
3760   *access_decls = NULL_TREE;
3761   /* Assume this class has no pointer members.  */
3762   has_pointers = 0;
3763   /* Assume none of the members of this class have default
3764      initializations.  */
3765   any_default_members = 0;
3766
3767   for (field = &TYPE_FIELDS (t); *field; field = next)
3768     {
3769       tree x = *field;
3770       tree type = TREE_TYPE (x);
3771
3772       GNU_xref_member (current_class_name, x);
3773
3774       next = &TREE_CHAIN (x);
3775
3776       if (TREE_CODE (x) == FIELD_DECL)
3777         {
3778           DECL_PACKED (x) |= TYPE_PACKED (t);
3779
3780           if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3781             /* We don't treat zero-width bitfields as making a class
3782                non-empty.  */
3783             ;
3784           else
3785             {
3786               /* The class is non-empty.  */
3787               *empty_p = 0;
3788               /* The class is not even nearly empty.  */
3789               CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3790             }
3791         }
3792
3793       if (TREE_CODE (x) == USING_DECL)
3794         {
3795           /* Prune the access declaration from the list of fields.  */
3796           *field = TREE_CHAIN (x);
3797
3798           /* Save the access declarations for our caller.  */
3799           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
3800
3801           /* Since we've reset *FIELD there's no reason to skip to the
3802              next field.  */
3803           next = field;
3804           continue;
3805         }
3806
3807       if (TREE_CODE (x) == TYPE_DECL
3808           || TREE_CODE (x) == TEMPLATE_DECL)
3809         continue;
3810
3811       /* If we've gotten this far, it's a data member, possibly static,
3812          or an enumerator.  */
3813
3814       DECL_FIELD_CONTEXT (x) = t;
3815
3816       /* ``A local class cannot have static data members.'' ARM 9.4 */
3817       if (current_function_decl && TREE_STATIC (x))
3818         cp_error_at ("field `%D' in local class cannot be static", x);
3819
3820       /* Perform error checking that did not get done in
3821          grokdeclarator.  */
3822       if (TREE_CODE (type) == FUNCTION_TYPE)
3823         {
3824           cp_error_at ("field `%D' invalidly declared function type",
3825                        x);
3826           type = build_pointer_type (type);
3827           TREE_TYPE (x) = type;
3828         }
3829       else if (TREE_CODE (type) == METHOD_TYPE)
3830         {
3831           cp_error_at ("field `%D' invalidly declared method type", x);
3832           type = build_pointer_type (type);
3833           TREE_TYPE (x) = type;
3834         }
3835       else if (TREE_CODE (type) == OFFSET_TYPE)
3836         {
3837           cp_error_at ("field `%D' invalidly declared offset type", x);
3838           type = build_pointer_type (type);
3839           TREE_TYPE (x) = type;
3840         }
3841
3842       if (type == error_mark_node)
3843         continue;
3844
3845       DECL_SAVED_INSNS (x) = 0;
3846       DECL_FIELD_SIZE (x) = 0;
3847
3848       /* When this goes into scope, it will be a non-local reference.  */
3849       DECL_NONLOCAL (x) = 1;
3850
3851       if (TREE_CODE (x) == CONST_DECL)
3852         continue;
3853
3854       if (TREE_CODE (x) == VAR_DECL)
3855         {
3856           if (TREE_CODE (t) == UNION_TYPE)
3857             /* Unions cannot have static members.  */
3858             cp_error_at ("field `%D' declared static in union", x);
3859
3860           continue;
3861         }
3862
3863       /* Now it can only be a FIELD_DECL.  */
3864
3865       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3866         CLASSTYPE_NON_AGGREGATE (t) = 1;
3867
3868       /* If this is of reference type, check if it needs an init.
3869          Also do a little ANSI jig if necessary.  */
3870       if (TREE_CODE (type) == REFERENCE_TYPE)
3871         {
3872           CLASSTYPE_NON_POD_P (t) = 1;
3873           if (DECL_INITIAL (x) == NULL_TREE)
3874             CLASSTYPE_REF_FIELDS_NEED_INIT (t) = 1;
3875
3876           /* ARM $12.6.2: [A member initializer list] (or, for an
3877              aggregate, initialization by a brace-enclosed list) is the
3878              only way to initialize nonstatic const and reference
3879              members.  */
3880           *cant_have_default_ctor_p = 1;
3881           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3882
3883           if (! TYPE_HAS_CONSTRUCTOR (t) && extra_warnings)
3884             {
3885               if (DECL_NAME (x))
3886                 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3887               else
3888                 cp_warning_at ("non-static reference in class without a constructor", x);
3889             }
3890         }
3891
3892       type = strip_array_types (type);
3893
3894       if (TREE_CODE (type) == POINTER_TYPE)
3895         has_pointers = 1;
3896
3897       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3898         CLASSTYPE_HAS_MUTABLE (t) = 1;
3899
3900       if (! pod_type_p (type)
3901           /* For some reason, pointers to members are POD types themselves,
3902              but are not allowed in POD structs.  Silly.  */
3903           || TYPE_PTRMEM_P (type) || TYPE_PTRMEMFUNC_P (type))
3904         CLASSTYPE_NON_POD_P (t) = 1;
3905
3906       /* If any field is const, the structure type is pseudo-const.  */
3907       if (CP_TYPE_CONST_P (type))
3908         {
3909           C_TYPE_FIELDS_READONLY (t) = 1;
3910           if (DECL_INITIAL (x) == NULL_TREE)
3911             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = 1;
3912
3913           /* ARM $12.6.2: [A member initializer list] (or, for an
3914              aggregate, initialization by a brace-enclosed list) is the
3915              only way to initialize nonstatic const and reference
3916              members.  */
3917           *cant_have_default_ctor_p = 1;
3918           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3919
3920           if (! TYPE_HAS_CONSTRUCTOR (t) && extra_warnings)
3921             {
3922               if (DECL_NAME (x))
3923                 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3924               else
3925                 cp_warning_at ("non-static const member in class without a constructor", x);
3926             }
3927         }
3928       /* A field that is pseudo-const makes the structure likewise.  */
3929       else if (IS_AGGR_TYPE (type))
3930         {
3931           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3932           CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3933             |= CLASSTYPE_READONLY_FIELDS_NEED_INIT (type);
3934         }
3935
3936       /* We set DECL_C_BIT_FIELD in grokbitfield.
3937          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3938       if (DECL_C_BIT_FIELD (x))
3939         check_bitfield_decl (x);
3940       else
3941         check_field_decl (x, t,
3942                           cant_have_const_ctor_p,
3943                           cant_have_default_ctor_p,
3944                           no_const_asn_ref_p,
3945                           &any_default_members);
3946     }
3947
3948   /* Effective C++ rule 11.  */
3949   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3950       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3951     {
3952       cp_warning ("`%#T' has pointer data members", t);
3953
3954       if (! TYPE_HAS_INIT_REF (t))
3955         {
3956           cp_warning ("  but does not override `%T(const %T&)'", t, t);
3957           if (! TYPE_HAS_ASSIGN_REF (t))
3958             cp_warning ("  or `operator=(const %T&)'", t);
3959         }
3960       else if (! TYPE_HAS_ASSIGN_REF (t))
3961         cp_warning ("  but does not override `operator=(const %T&)'", t);
3962     }
3963
3964
3965   /* Check anonymous struct/anonymous union fields.  */
3966   finish_struct_anon (t);
3967
3968   /* We've built up the list of access declarations in reverse order.
3969      Fix that now.  */
3970   *access_decls = nreverse (*access_decls);
3971 }
3972
3973 /* Return a FIELD_DECL for a pointer-to-virtual-table or
3974    pointer-to-virtual-base.  The NAME, ASSEMBLER_NAME, and TYPE of the
3975    field are as indicated.  The CLASS_TYPE in which this field occurs
3976    is also indicated.  FCONTEXT is the type that is needed for the debug
3977    info output routines.  *EMPTY_P is set to a non-zero value by this
3978    function to indicate that a class containing this field is
3979    non-empty.  */
3980
3981 static tree
3982 build_vtbl_or_vbase_field (name, assembler_name, type, class_type, fcontext,
3983                            empty_p)
3984      tree name;
3985      tree assembler_name;
3986      tree type;
3987      tree class_type;
3988      tree fcontext;
3989      int *empty_p;
3990 {
3991   tree field;
3992
3993   /* This class is non-empty.  */
3994   *empty_p = 0;
3995
3996   /* Build the FIELD_DECL.  */
3997   field = build_lang_decl (FIELD_DECL, name, type);
3998   DECL_ASSEMBLER_NAME (field) = assembler_name;
3999   DECL_VIRTUAL_P (field) = 1;
4000   DECL_ARTIFICIAL (field) = 1;
4001   DECL_FIELD_CONTEXT (field) = class_type;
4002   DECL_CLASS_CONTEXT (field) = class_type;
4003   DECL_FCONTEXT (field) = fcontext;
4004   DECL_SAVED_INSNS (field) = 0;
4005   DECL_FIELD_SIZE (field) = 0;
4006   DECL_ALIGN (field) = TYPE_ALIGN (type);
4007
4008   /* Return it.  */
4009   return field;
4010 }
4011
4012 /* If the empty base field in DECL overlaps with a base of the same type in
4013    NEWDECL, which is either another base field or the first data field of
4014    the class, pad the base just before NEWDECL and return 1.  Otherwise,
4015    return 0.  */
4016
4017 static int
4018 avoid_overlap (decl, newdecl, empty_p)
4019      tree decl, newdecl;
4020      int *empty_p;
4021 {
4022   tree field;
4023
4024   if (newdecl == NULL_TREE
4025       || ! types_overlap_p (TREE_TYPE (decl), TREE_TYPE (newdecl)))
4026     return 0;
4027
4028   for (field = decl; TREE_CHAIN (field) && TREE_CHAIN (field) != newdecl;
4029        field = TREE_CHAIN (field))
4030     ;
4031
4032   DECL_SIZE (field) = integer_one_node;
4033   /* The containing class cannot be empty; this field takes up space.  */
4034   *empty_p = 0;
4035
4036   return 1;
4037 }
4038
4039 /* Build a FIELD_DECL for the base given by BINFO in T.  If the new
4040    object is non-empty, clear *EMPTY_P.  Otherwise, set *SAW_EMPTY_P.
4041    *BASE_ALIGN is a running maximum of the alignments of any base
4042    class.  */
4043
4044 static tree
4045 build_base_field (t, binfo, empty_p, saw_empty_p, base_align)
4046      tree t;
4047      tree binfo;
4048      int *empty_p;
4049      int *saw_empty_p;
4050      unsigned int *base_align;
4051 {
4052   tree basetype = BINFO_TYPE (binfo);
4053   tree decl;
4054
4055   if (TYPE_SIZE (basetype) == 0)
4056     /* This error is now reported in xref_tag, thus giving better
4057        location information.  */
4058     return NULL_TREE;
4059
4060   decl = build_lang_decl (FIELD_DECL, NULL_TREE, basetype);
4061   DECL_ARTIFICIAL (decl) = 1;
4062   DECL_FIELD_CONTEXT (decl) = DECL_CLASS_CONTEXT (decl) = t;
4063   DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
4064   DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
4065
4066   if (flag_new_abi && DECL_SIZE (decl) == integer_zero_node)
4067     {
4068       *saw_empty_p = 1;
4069       return decl;
4070     }
4071
4072   /* The containing class is non-empty because it has a non-empty base
4073      class.  */
4074   *empty_p = 0;
4075
4076   if (! flag_new_abi)
4077     {
4078       /* Brain damage for backwards compatibility.  For no good
4079          reason, the old layout_basetypes made every base at least
4080          as large as the alignment for the bases up to that point,
4081          gratuitously wasting space.  So we do the same thing
4082          here.  */
4083       *base_align = MAX (*base_align, DECL_ALIGN (decl));
4084       DECL_SIZE (decl)
4085         = size_int (MAX (TREE_INT_CST_LOW (DECL_SIZE (decl)),
4086                          (int) (*base_align)));
4087     }
4088
4089   return decl;
4090 }
4091
4092 /* Returns a list of fields to stand in for the base class subobjects
4093    of REC.  These fields are later removed by layout_basetypes.  */
4094
4095 static tree
4096 build_base_fields (rec, empty_p)
4097      tree rec;
4098      int *empty_p;
4099 {
4100   /* Chain to hold all the new FIELD_DECLs which stand in for base class
4101      subobjects.  */
4102   tree base_decls = NULL_TREE;
4103   int n_baseclasses = CLASSTYPE_N_BASECLASSES (rec);
4104   tree decl, nextdecl;
4105   int i, saw_empty = 0;
4106   unsigned int base_align = 0;
4107
4108   /* Under the new ABI, the primary base class is always allocated
4109      first.  */
4110   if (flag_new_abi && CLASSTYPE_HAS_PRIMARY_BASE_P (rec))
4111     {
4112       tree primary_base;
4113
4114       primary_base = CLASSTYPE_PRIMARY_BINFO (rec);
4115       base_decls = chainon (build_base_field (rec,
4116                                               primary_base,
4117                                               empty_p,
4118                                               &saw_empty,
4119                                               &base_align),
4120                             base_decls);
4121     }
4122
4123   /* Now allocate the rest of the bases.  */
4124   for (i = 0; i < n_baseclasses; ++i)
4125     {
4126       tree base_binfo;
4127
4128       /* Under the new ABI, the primary base was already allocated
4129          above, so we don't need to allocate it again here.  */
4130       if (flag_new_abi && i == CLASSTYPE_VFIELD_PARENT (rec))
4131         continue;
4132
4133       base_binfo = BINFO_BASETYPE (TYPE_BINFO (rec), i);
4134
4135       /* A primary virtual base class is allocated just like any other
4136          base class, but a non-primary virtual base is allocated
4137          later, in layout_basetypes.  */
4138       if (TREE_VIA_VIRTUAL (base_binfo)
4139           && !BINFO_PRIMARY_MARKED_P (base_binfo))
4140         continue;
4141
4142       base_decls = chainon (build_base_field (rec, base_binfo,
4143                                               empty_p,
4144                                               &saw_empty,
4145                                               &base_align),
4146                             base_decls);
4147     }
4148
4149   /* Reverse the list of fields so we allocate the bases in the proper
4150      order.  */
4151   base_decls = nreverse (base_decls);
4152
4153   /* In the presence of empty base classes, we run the risk of allocating
4154      two objects of the same class on top of one another.  Avoid that.  */
4155   if (flag_new_abi && saw_empty)
4156     for (decl = base_decls; decl; decl = TREE_CHAIN (decl))
4157       {
4158         if (DECL_SIZE (decl) == integer_zero_node)
4159           {
4160             /* First step through the following bases until we find
4161                an overlap or a non-empty base.  */
4162             for (nextdecl = TREE_CHAIN (decl); nextdecl;
4163                  nextdecl = TREE_CHAIN (nextdecl))
4164               {
4165                 if (avoid_overlap (decl, nextdecl, empty_p)
4166                     || DECL_SIZE (nextdecl) != integer_zero_node)
4167                   goto nextbase;
4168               }
4169
4170             /* If we're still looking, also check against the first
4171                field.  */
4172             for (nextdecl = TYPE_FIELDS (rec);
4173                  nextdecl && TREE_CODE (nextdecl) != FIELD_DECL;
4174                  nextdecl = TREE_CHAIN (nextdecl))
4175               /* keep looking */;
4176             avoid_overlap (decl, nextdecl, empty_p);
4177           }
4178       nextbase:;
4179       }
4180
4181   return base_decls;
4182 }
4183
4184 /* Go through the TYPE_METHODS of T issuing any appropriate
4185    diagnostics, figuring out which methods override which other
4186    methods, and so forth.  */
4187
4188 static void
4189 check_methods (t)
4190      tree t;
4191 {
4192   tree x;
4193
4194   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
4195     {
4196       GNU_xref_member (current_class_name, x);
4197
4198       /* If this was an evil function, don't keep it in class.  */
4199       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
4200         continue;
4201
4202       /* Do both of these, even though they're in the same union;
4203          if the insn `r' member and the size `i' member are
4204          different sizes, as on the alpha, the larger of the two
4205          will end up with garbage in it.  */
4206       DECL_SAVED_INSNS (x) = 0;
4207       DECL_FIELD_SIZE (x) = 0;
4208
4209       check_for_override (x, t);
4210       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
4211         cp_error_at ("initializer specified for non-virtual method `%D'", x);
4212
4213       /* The name of the field is the original field name
4214          Save this in auxiliary field for later overloading.  */
4215       if (DECL_VINDEX (x))
4216         {
4217           TYPE_POLYMORPHIC_P (t) = 1;
4218           if (DECL_PURE_VIRTUAL_P (x))
4219             CLASSTYPE_PURE_VIRTUALS (t)
4220               = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t));
4221         }
4222     }
4223 }
4224
4225 /* Remove all zero-width bit-fields from T.  */
4226
4227 static void
4228 remove_zero_width_bit_fields (t)
4229      tree t;
4230 {
4231   tree *fieldsp;
4232
4233   fieldsp = &TYPE_FIELDS (t);
4234   while (*fieldsp)
4235     {
4236       if (TREE_CODE (*fieldsp) == FIELD_DECL
4237           && DECL_C_BIT_FIELD (*fieldsp)
4238           && DECL_INITIAL (*fieldsp))
4239         *fieldsp = TREE_CHAIN (*fieldsp);
4240       else
4241         fieldsp = &TREE_CHAIN (*fieldsp);
4242     }
4243 }
4244
4245 /* Check the validity of the bases and members declared in T.  Add any
4246    implicitly-generated functions (like copy-constructors and
4247    assignment operators).  Compute various flag bits (like
4248    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4249    level: i.e., independently of the ABI in use.  */
4250
4251 static void
4252 check_bases_and_members (t, empty_p)
4253      tree t;
4254      int *empty_p;
4255 {
4256   /* Nonzero if we are not allowed to generate a default constructor
4257      for this case.  */
4258   int cant_have_default_ctor;
4259   /* Nonzero if the implicitly generated copy constructor should take
4260      a non-const reference argument.  */
4261   int cant_have_const_ctor;
4262   /* Nonzero if the the implicitly generated assignment operator
4263      should take a non-const reference argument.  */
4264   int no_const_asn_ref;
4265   tree access_decls;
4266
4267   /* By default, we use const reference arguments and generate default
4268      constructors.  */
4269   cant_have_default_ctor = 0;
4270   cant_have_const_ctor = 0;
4271   no_const_asn_ref = 0;
4272
4273   /* Assume that the class is nearly empty; we'll clear this flag if
4274      it turns out not to be nearly empty.  */
4275   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
4276
4277   /* Check all the base-classes. */
4278   check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor,
4279                &no_const_asn_ref);
4280
4281   /* Check all the data member declarations.  */
4282   check_field_decls (t, &access_decls, empty_p,
4283                      &cant_have_default_ctor,
4284                      &cant_have_const_ctor,
4285                      &no_const_asn_ref);
4286
4287   /* Check all the method declarations.  */
4288   check_methods (t);
4289
4290   /* A nearly-empty class has to be vptr-containing; a nearly empty
4291      class contains just a vptr.  */
4292   if (!TYPE_CONTAINS_VPTR_P (t))
4293     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4294
4295   /* Do some bookkeeping that will guide the generation of implicitly
4296      declared member functions.  */
4297   TYPE_HAS_COMPLEX_INIT_REF (t)
4298     |= (TYPE_HAS_INIT_REF (t)
4299         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4300         || TYPE_POLYMORPHIC_P (t));
4301   TYPE_NEEDS_CONSTRUCTING (t)
4302     |= (TYPE_HAS_CONSTRUCTOR (t)
4303         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4304         || TYPE_POLYMORPHIC_P (t));
4305   CLASSTYPE_NON_AGGREGATE (t) |= (TYPE_HAS_CONSTRUCTOR (t)
4306                                   || TYPE_POLYMORPHIC_P (t));
4307   CLASSTYPE_NON_POD_P (t)
4308     |= (CLASSTYPE_NON_AGGREGATE (t) || TYPE_HAS_DESTRUCTOR (t)
4309         || TYPE_HAS_ASSIGN_REF (t));
4310   TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
4311   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
4312     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t);
4313
4314   /* Synthesize any needed methods.  Note that methods will be synthesized
4315      for anonymous unions; grok_x_components undoes that.  */
4316   add_implicitly_declared_members (t, cant_have_default_ctor,
4317                                    cant_have_const_ctor,
4318                                    no_const_asn_ref);
4319
4320   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4321   finish_struct_methods (t);
4322
4323   /* Process the access-declarations.  We wait until now to do this
4324      because handle_using_decls requires that the CLASSTYPE_METHOD_VEC
4325      be set up correctly.  */
4326   while (access_decls)
4327     {
4328       handle_using_decl (TREE_VALUE (access_decls), t);
4329       access_decls = TREE_CHAIN (access_decls);
4330     }
4331 }
4332
4333 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4334    accordingly, and, if necessary, add the TYPE_VFIELD to the
4335    TYPE_FIELDS list.  */
4336
4337 static void
4338 create_vtable_ptr (t, empty_p, has_virtual_p,
4339                    new_virtuals_p, overridden_virtuals_p)
4340      tree t;
4341      int *empty_p;
4342      int *has_virtual_p;
4343      tree *new_virtuals_p;
4344      tree *overridden_virtuals_p;
4345 {
4346   tree fn;
4347
4348   /* Loop over the virtual functions, adding them to our various
4349      vtables.  */
4350   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4351     if (DECL_VINDEX (fn))
4352       add_virtual_function (new_virtuals_p, overridden_virtuals_p,
4353                             has_virtual_p, fn, t);
4354
4355   /* Even if there weren't any new virtual functions, we might need a
4356      new virtual function table if we're supposed to include vptrs in
4357      all classes that need them.  */
4358   if (TYPE_CONTAINS_VPTR_P (t) && vptrs_present_everywhere_p ())
4359     start_vtable (t, has_virtual_p);
4360
4361   /* If we couldn't find an appropriate base class, create a new field
4362      here.  */
4363   if (*has_virtual_p && !TYPE_VFIELD (t))
4364     {
4365       /* We build this decl with vtbl_ptr_type_node, which is a
4366          `vtable_entry_type*'.  It might seem more precise to use
4367          `vtable_entry_type (*)[N]' where N is the number of firtual
4368          functions.  However, that would require the vtable pointer in
4369          base classes to have a different type than the vtable pointer
4370          in derived classes.  We could make that happen, but that
4371          still wouldn't solve all the problems.  In particular, the
4372          type-based alias analysis code would decide that assignments
4373          to the base class vtable pointer can't alias assignments to
4374          the derived class vtable pointer, since they have different
4375          types.  Thus, in an derived class destructor, where the base
4376          class constructor was inlined, we could generate bad code for
4377          setting up the vtable pointer.
4378
4379          Therefore, we use one type for all vtable pointers.  We still
4380          use a type-correct type; it's just doesn't indicate the array
4381          bounds.  That's better than using `void*' or some such; it's
4382          cleaner, and it let's the alias analysis code know that these
4383          stores cannot alias stores to void*!  */
4384       TYPE_VFIELD (t)
4385         = build_vtbl_or_vbase_field (get_vfield_name (t),
4386                                      get_identifier (VFIELD_BASE),
4387                                      vtbl_ptr_type_node,
4388                                      t,
4389                                      t,
4390                                      empty_p);
4391
4392       /* Add the new field to the list of fields in this class.  */
4393       if (!flag_new_abi)
4394         /* In the old ABI, the vtable pointer goes at the end of the
4395            class.  */
4396         TYPE_FIELDS (t) = chainon (TYPE_FIELDS (t), TYPE_VFIELD (t));
4397       else
4398         {
4399           /* But in the new ABI, the vtable pointer is the first thing
4400              in the class.  */
4401           TYPE_FIELDS (t) = chainon (TYPE_VFIELD (t), TYPE_FIELDS (t));
4402           /* If there were any baseclasses, they can't possibly be at
4403              offset zero any more, because that's where the vtable
4404              pointer is.  So, converting to a base class is going to
4405              take work.  */
4406           if (CLASSTYPE_N_BASECLASSES (t))
4407             TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1;
4408         }
4409
4410       /* We can't yet add this new field to the list of all virtual
4411          function table pointers in this class.  The
4412          modify_all_vtables function depends on this not being done.
4413          So, it is done later, in finish_struct_1.  */
4414     }
4415 }
4416
4417 /* Fixup the inline function given by INFO now that the class is
4418    complete.  */
4419
4420 static void
4421 fixup_pending_inline (info)
4422      struct pending_inline *info;
4423 {
4424   if (info)
4425     {
4426       tree args;
4427       tree fn = info->fndecl;
4428
4429       args = DECL_ARGUMENTS (fn);
4430       while (args)
4431         {
4432           DECL_CONTEXT (args) = fn;
4433           args = TREE_CHAIN (args);
4434         }
4435     }
4436 }
4437
4438 /* Fixup the inline methods and friends in TYPE now that TYPE is
4439    complete.  */
4440
4441 static void
4442 fixup_inline_methods (type)
4443      tree type;
4444 {
4445   tree method = TYPE_METHODS (type);
4446
4447   if (method && TREE_CODE (method) == TREE_VEC)
4448     {
4449       if (TREE_VEC_ELT (method, 1))
4450         method = TREE_VEC_ELT (method, 1);
4451       else if (TREE_VEC_ELT (method, 0))
4452         method = TREE_VEC_ELT (method, 0);
4453       else
4454         method = TREE_VEC_ELT (method, 2);
4455     }
4456
4457   /* Do inline member functions.  */
4458   for (; method; method = TREE_CHAIN (method))
4459     fixup_pending_inline (DECL_PENDING_INLINE_INFO (method));
4460
4461   /* Do friends.  */
4462   for (method = CLASSTYPE_INLINE_FRIENDS (type);
4463        method;
4464        method = TREE_CHAIN (method))
4465     fixup_pending_inline (DECL_PENDING_INLINE_INFO (TREE_VALUE (method)));
4466   CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE;
4467 }
4468
4469 /* Called from propagate_binfo_offsets via dfs_walk.  */
4470
4471 static tree
4472 dfs_propagate_binfo_offsets (binfo, data)
4473      tree binfo;
4474      void *data;
4475 {
4476   tree offset = (tree) data;
4477
4478   /* Update the BINFO_OFFSET for this base.  */
4479   BINFO_OFFSET (binfo)
4480     = size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), offset);
4481
4482   SET_BINFO_MARKED (binfo);
4483
4484   return NULL_TREE;
4485 }
4486
4487 /* Add OFFSET to all base types of BINFO which is a base in the
4488    hierarchy dominated by T.
4489
4490    OFFSET, which is a type offset, is number of bytes.
4491
4492    Note that we don't have to worry about having two paths to the
4493    same base type, since this type owns its association list.  */
4494
4495 static void
4496 propagate_binfo_offsets (binfo, offset)
4497      tree binfo;
4498      tree offset;
4499 {
4500   dfs_walk (binfo,
4501             dfs_propagate_binfo_offsets,
4502             dfs_skip_nonprimary_vbases_unmarkedp,
4503             offset);
4504   dfs_walk (binfo,
4505             dfs_unmark,
4506             dfs_skip_nonprimary_vbases_markedp,
4507             NULL);
4508 }
4509
4510 /* Remove *FIELD (which corresponds to the base given by BINFO) from
4511    the field list for T.  */
4512
4513 static void
4514 remove_base_field (t, binfo, field)
4515      tree t;
4516      tree binfo;
4517      tree *field;
4518 {
4519   tree basetype = BINFO_TYPE (binfo);
4520   tree offset;
4521
4522   my_friendly_assert (TREE_TYPE (*field) == basetype, 23897);
4523
4524   if (get_base_distance (basetype, t, 0, (tree*)0) == -2)
4525     cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
4526                 basetype, t);
4527
4528   offset
4529     = size_int (CEIL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (*field)),
4530                       BITS_PER_UNIT));
4531   propagate_binfo_offsets (binfo, offset);
4532
4533   /* Remove this field.  */
4534   *field = TREE_CHAIN (*field);
4535 }
4536
4537 /* Remove the FIELD_DECLs created for T's base classes in
4538    build_base_fields.  Simultaneously, update BINFO_OFFSET for all the
4539    bases, except for non-primary virtual baseclasses.  */
4540
4541 static void
4542 remove_base_fields (t)
4543      tree t;
4544 {
4545   int i;
4546   tree *field;
4547
4548   /* Now propagate offset information throughout the lattice.
4549      Simultaneously, remove the temporary FIELD_DECLS we created in
4550      build_base_fields to refer to base types.  */
4551   field = &TYPE_FIELDS (t);
4552   if (TYPE_VFIELD (t) == *field)
4553     {
4554       /* If this class did not have a primary base, we create a
4555          virtual function table pointer.  It will be the first thing
4556          in the class, under the new ABI.  Skip it; the base fields
4557          will follow it.  */
4558       my_friendly_assert (flag_new_abi
4559                           && !CLASSTYPE_HAS_PRIMARY_BASE_P (t),
4560                           19991218);
4561       field = &TREE_CHAIN (*field);
4562     }
4563
4564   /* Under the new ABI, the primary base is always allocated first.  */
4565   if (flag_new_abi && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4566     remove_base_field (t, CLASSTYPE_PRIMARY_BINFO (t), field);
4567
4568   /* Now remove the rest of the bases.  */
4569   for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); i++)
4570     {
4571       tree binfo;
4572
4573       /* Under the new ABI, we've already removed the primary base
4574          above.  */
4575       if (flag_new_abi && i == CLASSTYPE_VFIELD_PARENT (t))
4576         continue;
4577
4578       binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
4579
4580       /* We treat a primary virtual base class just like an ordinary base
4581          class.  But, non-primary virtual bases are laid out later.  */
4582       if (TREE_VIA_VIRTUAL (binfo) && !BINFO_PRIMARY_MARKED_P (binfo))
4583         continue;
4584
4585       remove_base_field (t, binfo, field);
4586     }
4587 }
4588
4589 /* Called via dfs_walk from layout_virtual bases.  */
4590
4591 static tree
4592 dfs_set_offset_for_shared_vbases (binfo, data)
4593      tree binfo;
4594      void *data;
4595 {
4596   if (TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_MARKED_P (binfo))
4597     {
4598       /* Update the shared copy.  */
4599       tree shared_binfo;
4600
4601       shared_binfo = BINFO_FOR_VBASE (BINFO_TYPE (binfo), (tree) data);
4602       BINFO_OFFSET (shared_binfo) = BINFO_OFFSET (binfo);
4603     }
4604
4605   return NULL_TREE;
4606 }
4607
4608 /* Called via dfs_walk from layout_virtual bases.  */
4609
4610 static tree
4611 dfs_set_offset_for_unshared_vbases (binfo, data)
4612      tree binfo;
4613      void *data;
4614 {
4615   /* If this is a virtual base, make sure it has the same offset as
4616      the shared copy.  If it's a primary base, then we know it's
4617      correct.  */
4618   if (TREE_VIA_VIRTUAL (binfo) && !BINFO_PRIMARY_MARKED_P (binfo))
4619     {
4620       tree t = (tree) data;
4621       tree vbase;
4622       tree offset;
4623
4624       vbase = BINFO_FOR_VBASE (BINFO_TYPE (binfo), t);
4625       offset = ssize_binop (MINUS_EXPR,
4626                             BINFO_OFFSET (vbase),
4627                             BINFO_OFFSET (binfo));
4628       propagate_binfo_offsets (binfo, offset);
4629     }
4630
4631   return NULL_TREE;
4632 }
4633
4634 /* Set BINFO_OFFSET for all of the virtual bases for T.  Update
4635    TYPE_ALIGN and TYPE_SIZE for T.  */
4636
4637 static void
4638 layout_virtual_bases (t)
4639      tree t;
4640 {
4641   tree vbase;
4642   int dsize;
4643
4644   /* DSIZE is the size of the class without the virtual bases.  */
4645   dsize = TREE_INT_CST_LOW (TYPE_SIZE (t));
4646   /* Make every class have alignment of at least one.  */
4647   TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), BITS_PER_UNIT);
4648
4649   /* Go through the virtual bases, allocating space for each virtual
4650      base that is not already a primary base class.  */
4651   for (vbase = CLASSTYPE_VBASECLASSES (t);
4652        vbase;
4653        vbase = TREE_CHAIN (vbase))
4654     if (!BINFO_VBASE_PRIMARY_P (vbase))
4655       {
4656         /* This virtual base is not a primary base of any class in the
4657            hierarchy, so we have to add space for it.  */
4658         tree basetype;
4659         unsigned int desired_align;
4660
4661         basetype = BINFO_TYPE (vbase);
4662         desired_align = TYPE_ALIGN (basetype);
4663         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), desired_align);
4664
4665         /* Add padding so that we can put the virtual base class at an
4666            appropriately aligned offset.  */
4667         dsize = CEIL (dsize, desired_align) * desired_align;
4668         /* And compute the offset of the virtual base.  */
4669         propagate_binfo_offsets (vbase,
4670                                  size_int (CEIL (dsize, BITS_PER_UNIT)));
4671         /* Every virtual baseclass takes a least a UNIT, so that we can
4672            take it's address and get something different for each base.  */
4673         dsize += MAX (BITS_PER_UNIT,
4674                       TREE_INT_CST_LOW (CLASSTYPE_SIZE (basetype)));
4675       }
4676
4677   /* Make sure that all of the CLASSTYPE_VBASECLASSES have their
4678      BINFO_OFFSET set correctly.  Those we just allocated certainly
4679      will.  The others are primary baseclasses; we walk the hierarchy
4680      to find the primary copies and update the shared copy.  */
4681   dfs_walk (TYPE_BINFO (t),
4682             dfs_set_offset_for_shared_vbases,
4683             dfs_unmarked_real_bases_queue_p,
4684             t);
4685
4686   /* Now, go through the TYPE_BINFO hierarchy again, setting the
4687      BINFO_OFFSETs correctly for all non-primary copies of the virtual
4688      bases and their direct and indirect bases.  The ambiguity checks
4689      in get_base_distance depend on the BINFO_OFFSETs being set
4690      correctly.  */
4691   dfs_walk (TYPE_BINFO (t), dfs_set_offset_for_unshared_vbases, NULL, t);
4692   for (vbase = CLASSTYPE_VBASECLASSES (t);
4693        vbase;
4694        vbase = TREE_CHAIN (vbase))
4695     dfs_walk (vbase, dfs_set_offset_for_unshared_vbases, NULL, t);
4696
4697   /* Now, make sure that the total size of the type is a multiple of
4698      its alignment.  */
4699   dsize = CEIL (dsize, TYPE_ALIGN (t)) * TYPE_ALIGN (t);
4700   TYPE_SIZE (t) = size_int (dsize);
4701   TYPE_SIZE_UNIT (t) = size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (t),
4702                                    size_int (BITS_PER_UNIT));
4703 }
4704
4705 /* Finish the work of layout_record, now taking virtual bases into account.
4706    Also compute the actual offsets that our base classes will have.
4707    This must be performed after the fields are laid out, since virtual
4708    baseclasses must lay down at the end of the record.  */
4709
4710 static void
4711 layout_basetypes (rec)
4712      tree rec;
4713 {
4714   tree vbase_types;
4715
4716 #ifdef STRUCTURE_SIZE_BOUNDARY
4717   /* Packed structures don't need to have minimum size.  */
4718   if (! TYPE_PACKED (rec))
4719     TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), STRUCTURE_SIZE_BOUNDARY);
4720 #endif
4721
4722   /* Remove the FIELD_DECLs we created for baseclasses in
4723      build_base_fields.  Simultaneously, update the BINFO_OFFSETs for
4724      everything in the hierarcy except non-primary virtual bases.  */
4725   remove_base_fields (rec);
4726
4727   /* Allocate the virtual base classes.  */
4728   layout_virtual_bases (rec);
4729
4730   /* Get all the virtual base types that this type uses.  The
4731      TREE_VALUE slot holds the virtual baseclass type.  Note that
4732      get_vbase_types makes copies of the virtual base BINFOs, so that
4733      the vbase_types are unshared.  */
4734   for (vbase_types = CLASSTYPE_VBASECLASSES (rec); vbase_types;
4735        vbase_types = TREE_CHAIN (vbase_types))
4736     if (extra_warnings)
4737       {
4738         tree basetype = BINFO_TYPE (vbase_types);
4739         if (get_base_distance (basetype, rec, 0, (tree*)0) == -2)
4740           cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
4741                       basetype, rec);
4742       }
4743 }
4744
4745 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4746    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4747    pointer.  */
4748
4749 static void
4750 layout_class_type (t, empty_p, has_virtual_p,
4751                    new_virtuals_p, overridden_virtuals_p)
4752      tree t;
4753      int *empty_p;
4754      int *has_virtual_p;
4755      tree *new_virtuals_p;
4756      tree *overridden_virtuals_p;
4757 {
4758   tree padding = NULL_TREE;
4759
4760   /* If possible, we reuse the virtual function table pointer from one
4761      of our base classes.  */
4762   determine_primary_base (t, has_virtual_p);
4763
4764   /* Add pointers to all of our virtual base-classes.  */
4765   TYPE_FIELDS (t) = chainon (build_vbase_pointer_fields (t, empty_p),
4766                              TYPE_FIELDS (t));
4767   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4768   TYPE_FIELDS (t) = chainon (build_base_fields (t, empty_p),
4769                              TYPE_FIELDS (t));
4770
4771   /* Create a pointer to our virtual function table.  */
4772   create_vtable_ptr (t, empty_p, has_virtual_p,
4773                      new_virtuals_p, overridden_virtuals_p);
4774
4775   /* CLASSTYPE_INLINE_FRIENDS is really TYPE_NONCOPIED_PARTS.  Thus,
4776      we have to save this before we start modifying
4777      TYPE_NONCOPIED_PARTS.  */
4778   fixup_inline_methods (t);
4779
4780   /* We make all structures have at least one element, so that they
4781      have non-zero size.  The field that we add here is fake, in the
4782      sense that, for example, we don't want people to be able to
4783      initialize it later.  So, we add it just long enough to let the
4784      back-end lay out the type, and then remove it.  In the new ABI,
4785      the class may be empty even if it has basetypes.  Therefore, we
4786      add the fake field at the end of the fields list; if there are
4787      already FIELD_DECLs on the list, their offsets will not be
4788      disturbed.  */
4789   if (*empty_p)
4790     {
4791       padding = build_lang_decl (FIELD_DECL, NULL_TREE, char_type_node);
4792       TYPE_FIELDS (t) = chainon (TYPE_FIELDS (t), padding);
4793       TYPE_NONCOPIED_PARTS (t)
4794         = tree_cons (NULL_TREE, padding, TYPE_NONCOPIED_PARTS (t));
4795       TREE_STATIC (TYPE_NONCOPIED_PARTS (t)) = 1;
4796     }
4797
4798   /* Let the back-end lay out the type. Note that at this point we
4799      have only included non-virtual base-classes; we will lay out the
4800      virtual base classes later.  So, the TYPE_SIZE/TYPE_ALIGN after
4801      this call are not necessarily correct; they are just the size and
4802      alignment when no virtual base clases are used.  */
4803   layout_type (t);
4804
4805   /* If we added an extra field to make this class non-empty, remove
4806      it now.  */
4807   if (*empty_p)
4808     {
4809       tree *declp;
4810
4811       declp = &TYPE_FIELDS (t);
4812       while (*declp != padding)
4813         declp = &TREE_CHAIN (*declp);
4814       *declp = TREE_CHAIN (*declp);
4815     }
4816
4817   /* Delete all zero-width bit-fields from the list of fields.  Now
4818      that the type is laid out they are no longer important.  */
4819   remove_zero_width_bit_fields (t);
4820
4821   /* Remember the size and alignment of the class before adding
4822      the virtual bases.  */
4823   if (*empty_p && flag_new_abi)
4824     CLASSTYPE_SIZE (t) = integer_zero_node;
4825   else if (flag_new_abi && TYPE_HAS_COMPLEX_INIT_REF (t)
4826            && TYPE_HAS_COMPLEX_ASSIGN_REF (t))
4827     CLASSTYPE_SIZE (t) = TYPE_BINFO_SIZE (t);
4828   else
4829     CLASSTYPE_SIZE (t) = TYPE_SIZE (t);
4830   CLASSTYPE_ALIGN (t) = TYPE_ALIGN (t);
4831
4832   /* Set the TYPE_DECL for this type to contain the right
4833      value for DECL_OFFSET, so that we can use it as part
4834      of a COMPONENT_REF for multiple inheritance.  */
4835   layout_decl (TYPE_MAIN_DECL (t), 0);
4836
4837   /* Now fix up any virtual base class types that we left lying
4838      around.  We must get these done before we try to lay out the
4839      virtual function table.  */
4840   if (CLASSTYPE_N_BASECLASSES (t))
4841     /* layout_basetypes will remove the base subobject fields.  */
4842     layout_basetypes (t);
4843 }
4844
4845 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
4846    (or C++ class declaration).
4847
4848    For C++, we must handle the building of derived classes.
4849    Also, C++ allows static class members.  The way that this is
4850    handled is to keep the field name where it is (as the DECL_NAME
4851    of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
4852    of the field.  layout_record and layout_union will know about this.
4853
4854    More C++ hair: inline functions have text in their
4855    DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
4856    meaningful tree structure.  After the struct has been laid out, set
4857    things up so that this can happen.
4858
4859    And still more: virtual functions.  In the case of single inheritance,
4860    when a new virtual function is seen which redefines a virtual function
4861    from the base class, the new virtual function is placed into
4862    the virtual function table at exactly the same address that
4863    it had in the base class.  When this is extended to multiple
4864    inheritance, the same thing happens, except that multiple virtual
4865    function tables must be maintained.  The first virtual function
4866    table is treated in exactly the same way as in the case of single
4867    inheritance.  Additional virtual function tables have different
4868    DELTAs, which tell how to adjust `this' to point to the right thing.
4869
4870    ATTRIBUTES is the set of decl attributes to be applied, if any.  */
4871
4872 void
4873 finish_struct_1 (t)
4874      tree t;
4875 {
4876   tree x;
4877   int has_virtual;
4878   /* The NEW_VIRTUALS is a TREE_LIST.  The TREE_VALUE of each node is
4879      a FUNCTION_DECL.  Each of these functions is a virtual function
4880      declared in T that does not override any virtual function from a
4881      base class.  */
4882   tree new_virtuals = NULL_TREE;
4883   /* The OVERRIDDEN_VIRTUALS list is like the NEW_VIRTUALS list,
4884      except that each declaration here overrides the declaration from
4885      a base class.  */
4886   tree overridden_virtuals = NULL_TREE;
4887   int n_fields = 0;
4888   tree vfield;
4889   int empty = 1;
4890
4891   if (TYPE_SIZE (t))
4892     {
4893       if (IS_AGGR_TYPE (t))
4894         cp_error ("redefinition of `%#T'", t);
4895       else
4896         my_friendly_abort (172);
4897       popclass ();
4898       return;
4899     }
4900
4901   GNU_xref_decl (current_function_decl, t);
4902
4903   /* If this type was previously laid out as a forward reference,
4904      make sure we lay it out again.  */
4905   TYPE_SIZE (t) = NULL_TREE;
4906   CLASSTYPE_GOT_SEMICOLON (t) = 0;
4907   CLASSTYPE_VFIELD_PARENT (t) = -1;
4908   has_virtual = 0;
4909   CLASSTYPE_RTTI (t) = NULL_TREE;
4910
4911   /* Do end-of-class semantic processing: checking the validity of the
4912      bases and members and add implicitly generated methods.  */
4913   check_bases_and_members (t, &empty);
4914
4915   /* Layout the class itself.  */
4916   layout_class_type (t, &empty, &has_virtual,
4917                      &new_virtuals, &overridden_virtuals);
4918
4919   /* Set up the DECL_FIELD_BITPOS of the vfield if we need to, as we
4920      might need to know it for setting up the offsets in the vtable
4921      (or in thunks) below.  */
4922   vfield = TYPE_VFIELD (t);
4923   if (vfield != NULL_TREE
4924       && DECL_FIELD_CONTEXT (vfield) != t)
4925     {
4926       tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
4927       tree offset = BINFO_OFFSET (binfo);
4928
4929       vfield = copy_node (vfield);
4930       copy_lang_decl (vfield);
4931
4932       if (! integer_zerop (offset))
4933         offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
4934       DECL_FIELD_CONTEXT (vfield) = t;
4935       DECL_CLASS_CONTEXT (vfield) = t;
4936       DECL_FIELD_BITPOS (vfield)
4937         = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
4938       TYPE_VFIELD (t) = vfield;
4939     }
4940
4941   overridden_virtuals
4942     = modify_all_vtables (t, &has_virtual, nreverse (overridden_virtuals));
4943
4944   /* If necessary, create the primary vtable for this class.  */
4945   if (new_virtuals
4946       || overridden_virtuals
4947       || (TYPE_CONTAINS_VPTR_P (t) && vptrs_present_everywhere_p ()))
4948     {
4949       new_virtuals = nreverse (new_virtuals);
4950       /* We must enter these virtuals into the table.  */
4951       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4952         {
4953           if (! CLASSTYPE_COM_INTERFACE (t))
4954             {
4955               /* The second slot is for the tdesc pointer when thunks
4956                  are used.  */
4957               if (flag_vtable_thunks)
4958                 new_virtuals = tree_cons (NULL_TREE, NULL_TREE, new_virtuals);
4959
4960               /* The first slot is for the rtti offset.  */
4961               new_virtuals = tree_cons (NULL_TREE, NULL_TREE, new_virtuals);
4962
4963               set_rtti_entry (new_virtuals,
4964                               convert (ssizetype, integer_zero_node), t);
4965             }
4966           build_primary_vtable (NULL_TREE, t);
4967         }
4968       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
4969         /* Here we know enough to change the type of our virtual
4970            function table, but we will wait until later this function.  */
4971         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
4972
4973       /* If this type has basetypes with constructors, then those
4974          constructors might clobber the virtual function table.  But
4975          they don't if the derived class shares the exact vtable of the base
4976          class.  */
4977
4978       CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4979     }
4980   /* If we didn't need a new vtable, see if we should copy one from
4981      the base.  */
4982   else if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4983     {
4984       tree binfo = CLASSTYPE_PRIMARY_BINFO (t);
4985
4986       /* This class contributes nothing new to the virtual function
4987          table.  However, it may have declared functions which
4988          went into the virtual function table "inherited" from the
4989          base class.  If so, we grab a copy of those updated functions,
4990          and pretend they are ours.  */
4991
4992       /* See if we should steal the virtual info from base class.  */
4993       if (TYPE_BINFO_VTABLE (t) == NULL_TREE)
4994         TYPE_BINFO_VTABLE (t) = BINFO_VTABLE (binfo);
4995       if (TYPE_BINFO_VIRTUALS (t) == NULL_TREE)
4996         TYPE_BINFO_VIRTUALS (t) = BINFO_VIRTUALS (binfo);
4997       if (TYPE_BINFO_VTABLE (t) != BINFO_VTABLE (binfo))
4998         CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4999     }
5000
5001   if (TYPE_CONTAINS_VPTR_P (t))
5002     {
5003       if (TYPE_BINFO_VTABLE (t))
5004         my_friendly_assert (DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)),
5005                             20000116);
5006       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5007         my_friendly_assert (TYPE_BINFO_VIRTUALS (t) == NULL_TREE,
5008                             20000116);
5009
5010       CLASSTYPE_VSIZE (t) = has_virtual;
5011       /* Entries for virtual functions defined in the primary base are
5012          followed by entries for new functions unique to this class.  */
5013       TYPE_BINFO_VIRTUALS (t)
5014         = chainon (TYPE_BINFO_VIRTUALS (t), new_virtuals);
5015       /* Finally, add entries for functions that override virtuals
5016          from non-primary bases.  */
5017       TYPE_BINFO_VIRTUALS (t)
5018         = chainon (TYPE_BINFO_VIRTUALS (t), overridden_virtuals);
5019     }
5020
5021   /* Now lay out the virtual function table.  */
5022   if (has_virtual)
5023     layout_vtable_decl (TYPE_BINFO (t), has_virtual);
5024
5025   /* If we created a new vtbl pointer for this class, add it to the
5026      list.  */
5027   if (TYPE_VFIELD (t) && CLASSTYPE_VFIELD_PARENT (t) == -1)
5028     CLASSTYPE_VFIELDS (t)
5029       = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t));
5030
5031   finish_struct_bits (t);
5032
5033   /* Complete the rtl for any static member objects of the type we're
5034      working on.  */
5035   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5036     {
5037       if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5038           && TREE_TYPE (x) == t)
5039         {
5040           DECL_MODE (x) = TYPE_MODE (t);
5041           make_decl_rtl (x, NULL, 0);
5042         }
5043     }
5044
5045   /* Done with FIELDS...now decide whether to sort these for
5046      faster lookups later.
5047
5048      The C front-end only does this when n_fields > 15.  We use
5049      a smaller number because most searches fail (succeeding
5050      ultimately as the search bores through the inheritance
5051      hierarchy), and we want this failure to occur quickly.  */
5052
5053   n_fields = count_fields (TYPE_FIELDS (t));
5054   if (n_fields > 7)
5055     {
5056       tree field_vec = make_tree_vec (n_fields);
5057       add_fields_to_vec (TYPE_FIELDS (t), field_vec, 0);
5058       qsort (&TREE_VEC_ELT (field_vec, 0), n_fields, sizeof (tree),
5059              (int (*)(const void *, const void *))field_decl_cmp);
5060       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5061         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5062       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5063     }
5064
5065   if (TYPE_HAS_CONSTRUCTOR (t))
5066     {
5067       tree vfields = CLASSTYPE_VFIELDS (t);
5068
5069       while (vfields)
5070         {
5071           /* Mark the fact that constructor for T
5072              could affect anybody inheriting from T
5073              who wants to initialize vtables for VFIELDS's type.  */
5074           if (VF_DERIVED_VALUE (vfields))
5075             TREE_ADDRESSABLE (vfields) = 1;
5076           vfields = TREE_CHAIN (vfields);
5077         }
5078     }
5079
5080   if (CLASSTYPE_VSIZE (t) != 0)
5081     {
5082       /* In addition to this one, all the other vfields should be listed.  */
5083       /* Before that can be done, we have to have FIELD_DECLs for them, and
5084          a place to find them.  */
5085       TYPE_NONCOPIED_PARTS (t)
5086         = tree_cons (default_conversion (TYPE_BINFO_VTABLE (t)),
5087                      TYPE_VFIELD (t), TYPE_NONCOPIED_PARTS (t));
5088
5089       if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
5090           && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE)
5091         cp_warning ("`%#T' has virtual functions but non-virtual destructor",
5092                     t);
5093     }
5094
5095   /* Make the rtl for any new vtables we have created, and unmark
5096      the base types we marked.  */
5097   finish_vtbls (t);
5098   hack_incomplete_structures (t);
5099
5100   if (warn_overloaded_virtual)
5101     warn_hidden (t);
5102
5103   maybe_suppress_debug_info (t);
5104
5105   /* Finish debugging output for this type.  */
5106   rest_of_type_compilation (t, toplevel_bindings_p ());
5107 }
5108
5109 /* When T was built up, the member declarations were added in reverse
5110    order.  Rearrange them to declaration order.  */
5111
5112 void
5113 unreverse_member_declarations (t)
5114      tree t;
5115 {
5116   tree next;
5117   tree prev;
5118   tree x;
5119
5120   /* The TYPE_FIELDS, TYPE_METHODS, and CLASSTYPE_TAGS are all in
5121      reverse order.  Put them in declaration order now.  */
5122   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5123   CLASSTYPE_TAGS (t) = nreverse (CLASSTYPE_TAGS (t));
5124
5125   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5126      reverse order, so we can't just use nreverse.  */
5127   prev = NULL_TREE;
5128   for (x = TYPE_FIELDS (t);
5129        x && TREE_CODE (x) != TYPE_DECL;
5130        x = next)
5131     {
5132       next = TREE_CHAIN (x);
5133       TREE_CHAIN (x) = prev;
5134       prev = x;
5135     }
5136   if (prev)
5137     {
5138       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5139       if (prev)
5140         TYPE_FIELDS (t) = prev;
5141     }
5142 }
5143
5144 tree
5145 finish_struct (t, attributes)
5146      tree t, attributes;
5147 {
5148   /* Now that we've got all the field declarations, reverse everything
5149      as necessary.  */
5150   unreverse_member_declarations (t);
5151
5152   cplus_decl_attributes (t, attributes, NULL_TREE);
5153
5154   if (processing_template_decl)
5155     {
5156       finish_struct_methods (t);
5157       TYPE_SIZE (t) = integer_zero_node;
5158     }
5159   else
5160     finish_struct_1 (t);
5161
5162   TYPE_BEING_DEFINED (t) = 0;
5163
5164   if (current_class_type)
5165     popclass ();
5166   else
5167     error ("trying to finish struct, but kicked out due to previous parse errors.");
5168
5169   if (processing_template_decl)
5170     {
5171       tree scope = current_scope ();
5172       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
5173         add_tree (build_min (TAG_DEFN, t));
5174     }
5175
5176   return t;
5177 }
5178 \f
5179 /* Return the dynamic type of INSTANCE, if known.
5180    Used to determine whether the virtual function table is needed
5181    or not.
5182
5183    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5184    of our knowledge of its type.  *NONNULL should be initialized
5185    before this function is called.  */
5186
5187 static tree
5188 fixed_type_or_null (instance, nonnull)
5189      tree instance;
5190      int *nonnull;
5191 {
5192   switch (TREE_CODE (instance))
5193     {
5194     case INDIRECT_REF:
5195       /* Check that we are not going through a cast of some sort.  */
5196       if (TREE_TYPE (instance)
5197           == TREE_TYPE (TREE_TYPE (TREE_OPERAND (instance, 0))))
5198         instance = TREE_OPERAND (instance, 0);
5199       /* fall through...  */
5200     case CALL_EXPR:
5201       /* This is a call to a constructor, hence it's never zero.  */
5202       if (TREE_HAS_CONSTRUCTOR (instance))
5203         {
5204           if (nonnull)
5205             *nonnull = 1;
5206           return TREE_TYPE (instance);
5207         }
5208       return NULL_TREE;
5209
5210     case SAVE_EXPR:
5211       /* This is a call to a constructor, hence it's never zero.  */
5212       if (TREE_HAS_CONSTRUCTOR (instance))
5213         {
5214           if (nonnull)
5215             *nonnull = 1;
5216           return TREE_TYPE (instance);
5217         }
5218       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull);
5219
5220     case RTL_EXPR:
5221       return NULL_TREE;
5222
5223     case PLUS_EXPR:
5224     case MINUS_EXPR:
5225       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5226         /* Propagate nonnull.  */
5227         fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull);
5228       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5229         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull);
5230       return NULL_TREE;
5231
5232     case NOP_EXPR:
5233     case CONVERT_EXPR:
5234       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull);
5235
5236     case ADDR_EXPR:
5237       if (nonnull)
5238         *nonnull = 1;
5239       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull);
5240
5241     case COMPONENT_REF:
5242       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull);
5243
5244     case VAR_DECL:
5245     case FIELD_DECL:
5246       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5247           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5248         {
5249           if (nonnull)
5250             *nonnull = 1;
5251           return TREE_TYPE (TREE_TYPE (instance));
5252         }
5253       /* fall through...  */
5254     case TARGET_EXPR:
5255     case PARM_DECL:
5256       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5257         {
5258           if (nonnull)
5259             *nonnull = 1;
5260           return TREE_TYPE (instance);
5261         }
5262       else if (nonnull)
5263         {
5264           if (instance == current_class_ptr
5265               && flag_this_is_variable <= 0)
5266             {
5267               /* Normally, 'this' must be non-null.  */
5268               if (flag_this_is_variable == 0)
5269                 *nonnull = 1;
5270
5271               /* <0 means we're in a constructor and we know our type.  */
5272               if (flag_this_is_variable < 0)
5273                 return TREE_TYPE (TREE_TYPE (instance));
5274             }
5275           else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5276             /* Reference variables should be references to objects.  */
5277             *nonnull = 1;
5278         }
5279       return NULL_TREE;
5280
5281     default:
5282       return NULL_TREE;
5283     }
5284 }
5285
5286 /* Return non-zero if the dynamic type of INSTANCE is known, and equivalent
5287    to the static type.  We also handle the case where INSTANCE is really
5288    a pointer.
5289
5290    Used to determine whether the virtual function table is needed
5291    or not.
5292
5293    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5294    of our knowledge of its type.  *NONNULL should be initialized
5295    before this function is called.  */
5296
5297 int
5298 resolves_to_fixed_type_p (instance, nonnull)
5299      tree instance;
5300      int *nonnull;
5301 {
5302   tree t = TREE_TYPE (instance);
5303   tree fixed = fixed_type_or_null (instance, nonnull);
5304   if (fixed == NULL_TREE)
5305     return 0;
5306   if (POINTER_TYPE_P (t))
5307     t = TREE_TYPE (t);
5308   return same_type_p (TYPE_MAIN_VARIANT (t), TYPE_MAIN_VARIANT (fixed));
5309 }
5310
5311 \f
5312 void
5313 init_class_processing ()
5314 {
5315   current_class_depth = 0;
5316   current_class_stack_size = 10;
5317   current_class_stack
5318     = (class_stack_node_t) xmalloc (current_class_stack_size
5319                                     * sizeof (struct class_stack_node));
5320
5321   access_default_node = build_int_2 (0, 0);
5322   access_public_node = build_int_2 (1, 0);
5323   access_protected_node = build_int_2 (2, 0);
5324   access_private_node = build_int_2 (3, 0);
5325   access_default_virtual_node = build_int_2 (4, 0);
5326   access_public_virtual_node = build_int_2 (5, 0);
5327   access_protected_virtual_node = build_int_2 (6, 0);
5328   access_private_virtual_node = build_int_2 (7, 0);
5329 }
5330
5331 /* Set current scope to NAME. CODE tells us if this is a
5332    STRUCT, UNION, or ENUM environment.
5333
5334    NAME may end up being NULL_TREE if this is an anonymous or
5335    late-bound struct (as in "struct { ... } foo;")  */
5336
5337 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
5338    appropriate values, found by looking up the type definition of
5339    NAME (as a CODE).
5340
5341    If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
5342    which can be seen locally to the class.  They are shadowed by
5343    any subsequent local declaration (including parameter names).
5344
5345    If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
5346    which have static meaning (i.e., static members, static
5347    member functions, enum declarations, etc).
5348
5349    If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
5350    which can be seen locally to the class (as in 1), but
5351    know that we are doing this for declaration purposes
5352    (i.e. friend foo::bar (int)).
5353
5354    So that we may avoid calls to lookup_name, we cache the _TYPE
5355    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5356
5357    For multiple inheritance, we perform a two-pass depth-first search
5358    of the type lattice.  The first pass performs a pre-order search,
5359    marking types after the type has had its fields installed in
5360    the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
5361    unmarks the marked types.  If a field or member function name
5362    appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5363    that name becomes `error_mark_node'.  */
5364
5365 void
5366 pushclass (type, modify)
5367      tree type;
5368      int modify;
5369 {
5370   type = TYPE_MAIN_VARIANT (type);
5371
5372   /* Make sure there is enough room for the new entry on the stack.  */
5373   if (current_class_depth + 1 >= current_class_stack_size)
5374     {
5375       current_class_stack_size *= 2;
5376       current_class_stack
5377         = (class_stack_node_t) xrealloc (current_class_stack,
5378                                          current_class_stack_size
5379                                          * sizeof (struct class_stack_node));
5380     }
5381
5382   /* Insert a new entry on the class stack.  */
5383   current_class_stack[current_class_depth].name = current_class_name;
5384   current_class_stack[current_class_depth].type = current_class_type;
5385   current_class_stack[current_class_depth].access = current_access_specifier;
5386   current_class_stack[current_class_depth].names_used = 0;
5387   current_class_depth++;
5388
5389   /* Now set up the new type.  */
5390   current_class_name = TYPE_NAME (type);
5391   if (TREE_CODE (current_class_name) == TYPE_DECL)
5392     current_class_name = DECL_NAME (current_class_name);
5393   current_class_type = type;
5394
5395   /* By default, things in classes are private, while things in
5396      structures or unions are public.  */
5397   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5398                               ? access_private_node
5399                               : access_public_node);
5400
5401   if (previous_class_type != NULL_TREE
5402       && (type != previous_class_type
5403           || TYPE_SIZE (previous_class_type) == NULL_TREE)
5404       && current_class_depth == 1)
5405     {
5406       /* Forcibly remove any old class remnants.  */
5407       invalidate_class_lookup_cache ();
5408     }
5409
5410   /* If we're about to enter a nested class, clear
5411      IDENTIFIER_CLASS_VALUE for the enclosing classes.  */
5412   if (modify && current_class_depth > 1)
5413     clear_identifier_class_values ();
5414
5415   pushlevel_class ();
5416
5417 #if 0
5418   if (CLASSTYPE_TEMPLATE_INFO (type))
5419     overload_template_name (type);
5420 #endif
5421
5422   if (modify)
5423     {
5424       if (type != previous_class_type || current_class_depth > 1)
5425         push_class_decls (type);
5426       else
5427         {
5428           tree item;
5429
5430           /* We are re-entering the same class we just left, so we
5431              don't have to search the whole inheritance matrix to find
5432              all the decls to bind again.  Instead, we install the
5433              cached class_shadowed list, and walk through it binding
5434              names and setting up IDENTIFIER_TYPE_VALUEs.  */
5435           set_class_shadows (previous_class_values);
5436           for (item = previous_class_values; item; item = TREE_CHAIN (item))
5437             {
5438               tree id = TREE_PURPOSE (item);
5439               tree decl = TREE_TYPE (item);
5440
5441               push_class_binding (id, decl);
5442               if (TREE_CODE (decl) == TYPE_DECL)
5443                 set_identifier_type_value (id, TREE_TYPE (decl));
5444             }
5445           unuse_fields (type);
5446         }
5447
5448       storetags (CLASSTYPE_TAGS (type));
5449     }
5450 }
5451
5452 /* When we exit a toplevel class scope, we save the
5453    IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5454    reenter the class.  Here, we've entered some other class, so we
5455    must invalidate our cache.  */
5456
5457 void
5458 invalidate_class_lookup_cache ()
5459 {
5460   tree t;
5461
5462   /* This code can be seen as a cache miss.  When we've cached a
5463      class' scope's bindings and we can't use them, we need to reset
5464      them.  This is it!  */
5465   for (t = previous_class_values; t; t = TREE_CHAIN (t))
5466     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
5467
5468   previous_class_type = NULL_TREE;
5469 }
5470
5471 /* Get out of the current class scope. If we were in a class scope
5472    previously, that is the one popped to.  */
5473
5474 void
5475 popclass ()
5476 {
5477   poplevel_class ();
5478   /* Since poplevel_class does the popping of class decls nowadays,
5479      this really only frees the obstack used for these decls.  */
5480   pop_class_decls ();
5481
5482   current_class_depth--;
5483   current_class_name = current_class_stack[current_class_depth].name;
5484   current_class_type = current_class_stack[current_class_depth].type;
5485   current_access_specifier = current_class_stack[current_class_depth].access;
5486   if (current_class_stack[current_class_depth].names_used)
5487     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5488 }
5489
5490 /* Returns 1 if current_class_type is either T or a nested type of T.  */
5491
5492 int
5493 currently_open_class (t)
5494      tree t;
5495 {
5496   int i;
5497   if (t == current_class_type)
5498     return 1;
5499   for (i = 0; i < current_class_depth; ++i)
5500     if (current_class_stack [i].type == t)
5501       return 1;
5502   return 0;
5503 }
5504
5505 /* When entering a class scope, all enclosing class scopes' names with
5506    static meaning (static variables, static functions, types and enumerators)
5507    have to be visible.  This recursive function calls pushclass for all
5508    enclosing class contexts until global or a local scope is reached.
5509    TYPE is the enclosed class and MODIFY is equivalent with the pushclass
5510    formal of the same name.  */
5511
5512 void
5513 push_nested_class (type, modify)
5514      tree type;
5515      int modify;
5516 {
5517   tree context;
5518
5519   /* A namespace might be passed in error cases, like A::B:C.  */
5520   if (type == NULL_TREE
5521       || type == error_mark_node
5522       || TREE_CODE (type) == NAMESPACE_DECL
5523       || ! IS_AGGR_TYPE (type)
5524       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5525       || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
5526     return;
5527
5528   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5529
5530   if (context && CLASS_TYPE_P (context))
5531     push_nested_class (context, 2);
5532   pushclass (type, modify);
5533 }
5534
5535 /* Undoes a push_nested_class call.  MODIFY is passed on to popclass.  */
5536
5537 void
5538 pop_nested_class ()
5539 {
5540   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5541
5542   popclass ();
5543   if (context && CLASS_TYPE_P (context))
5544     pop_nested_class ();
5545 }
5546
5547 /* Set global variables CURRENT_LANG_NAME to appropriate value
5548    so that behavior of name-mangling machinery is correct.  */
5549
5550 void
5551 push_lang_context (name)
5552      tree name;
5553 {
5554   *current_lang_stack++ = current_lang_name;
5555   if (current_lang_stack - &VARRAY_TREE (current_lang_base, 0)
5556       >= (ptrdiff_t) VARRAY_SIZE (current_lang_base))
5557     {
5558       size_t old_size = VARRAY_SIZE (current_lang_base);
5559
5560       VARRAY_GROW (current_lang_base, old_size + 10);
5561       current_lang_stack = &VARRAY_TREE (current_lang_base, old_size);
5562     }
5563
5564   if (name == lang_name_cplusplus)
5565     {
5566       strict_prototype = strict_prototypes_lang_cplusplus;
5567       current_lang_name = name;
5568     }
5569   else if (name == lang_name_java)
5570     {
5571       strict_prototype = strict_prototypes_lang_cplusplus;
5572       current_lang_name = name;
5573       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5574          (See record_builtin_java_type in decl.c.)  However, that causes
5575          incorrect debug entries if these types are actually used.
5576          So we re-enable debug output after extern "Java". */
5577       DECL_IGNORED_P (java_byte_type_node) = 0;
5578       DECL_IGNORED_P (java_short_type_node) = 0;
5579       DECL_IGNORED_P (java_int_type_node) = 0;
5580       DECL_IGNORED_P (java_long_type_node) = 0;
5581       DECL_IGNORED_P (java_float_type_node) = 0;
5582       DECL_IGNORED_P (java_double_type_node) = 0;
5583       DECL_IGNORED_P (java_char_type_node) = 0;
5584       DECL_IGNORED_P (java_boolean_type_node) = 0;
5585     }
5586   else if (name == lang_name_c)
5587     {
5588       strict_prototype = strict_prototypes_lang_c;
5589       current_lang_name = name;
5590     }
5591   else
5592     error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
5593 }
5594
5595 /* Get out of the current language scope.  */
5596
5597 void
5598 pop_lang_context ()
5599 {
5600   /* Clear the current entry so that garbage collector won't hold on
5601      to it.  */
5602   *current_lang_stack = NULL_TREE;
5603   current_lang_name = *--current_lang_stack;
5604   if (current_lang_name == lang_name_cplusplus
5605       || current_lang_name == lang_name_java)
5606     strict_prototype = strict_prototypes_lang_cplusplus;
5607   else if (current_lang_name == lang_name_c)
5608     strict_prototype = strict_prototypes_lang_c;
5609 }
5610 \f
5611 /* Type instantiation routines.  */
5612
5613 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5614    matches the TARGET_TYPE.  If there is no satisfactory match, return
5615    error_mark_node, and issue an error message if COMPLAIN is
5616    non-zero.  If TEMPLATE_ONLY, the name of the overloaded function
5617    was a template-id, and EXPLICIT_TARGS are the explicitly provided
5618    template arguments.  */
5619
5620 static tree
5621 resolve_address_of_overloaded_function (target_type,
5622                                         overload,
5623                                         complain,
5624                                         template_only,
5625                                         explicit_targs)
5626      tree target_type;
5627      tree overload;
5628      int complain;
5629      int template_only;
5630      tree explicit_targs;
5631 {
5632   /* Here's what the standard says:
5633
5634        [over.over]
5635
5636        If the name is a function template, template argument deduction
5637        is done, and if the argument deduction succeeds, the deduced
5638        arguments are used to generate a single template function, which
5639        is added to the set of overloaded functions considered.
5640
5641        Non-member functions and static member functions match targets of
5642        type "pointer-to-function" or "reference-to-function."  Nonstatic
5643        member functions match targets of type "pointer-to-member
5644        function;" the function type of the pointer to member is used to
5645        select the member function from the set of overloaded member
5646        functions.  If a nonstatic member function is selected, the
5647        reference to the overloaded function name is required to have the
5648        form of a pointer to member as described in 5.3.1.
5649
5650        If more than one function is selected, any template functions in
5651        the set are eliminated if the set also contains a non-template
5652        function, and any given template function is eliminated if the
5653        set contains a second template function that is more specialized
5654        than the first according to the partial ordering rules 14.5.5.2.
5655        After such eliminations, if any, there shall remain exactly one
5656        selected function.  */
5657
5658   int is_ptrmem = 0;
5659   int is_reference = 0;
5660   /* We store the matches in a TREE_LIST rooted here.  The functions
5661      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5662      interoperability with most_specialized_instantiation.  */
5663   tree matches = NULL_TREE;
5664   tree fn;
5665
5666   /* By the time we get here, we should be seeing only real
5667      pointer-to-member types, not the internal POINTER_TYPE to
5668      METHOD_TYPE representation.  */
5669   my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE
5670                         && (TREE_CODE (TREE_TYPE (target_type))
5671                             == METHOD_TYPE)), 0);
5672
5673   /* Check that the TARGET_TYPE is reasonable.  */
5674   if (TYPE_PTRFN_P (target_type))
5675     /* This is OK.  */
5676     ;
5677   else if (TYPE_PTRMEMFUNC_P (target_type))
5678     /* This is OK, too.  */
5679     is_ptrmem = 1;
5680   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5681     {
5682       /* This is OK, too.  This comes from a conversion to reference
5683          type.  */
5684       target_type = build_reference_type (target_type);
5685       is_reference = 1;
5686     }
5687   else
5688     {
5689       if (complain)
5690         cp_error("cannot resolve overloaded function `%D' based on conversion to type `%T'",
5691                  DECL_NAME (OVL_FUNCTION (overload)), target_type);
5692       return error_mark_node;
5693     }
5694
5695   /* If we can find a non-template function that matches, we can just
5696      use it.  There's no point in generating template instantiations
5697      if we're just going to throw them out anyhow.  But, of course, we
5698      can only do this when we don't *need* a template function.  */
5699   if (!template_only)
5700     {
5701       tree fns;
5702
5703       for (fns = overload; fns; fns = OVL_CHAIN (fns))
5704         {
5705           tree fn = OVL_FUNCTION (fns);
5706           tree fntype;
5707
5708           if (TREE_CODE (fn) == TEMPLATE_DECL)
5709             /* We're not looking for templates just yet.  */
5710             continue;
5711
5712           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5713               != is_ptrmem)
5714             /* We're looking for a non-static member, and this isn't
5715                one, or vice versa.  */
5716             continue;
5717
5718           /* See if there's a match.  */
5719           fntype = TREE_TYPE (fn);
5720           if (is_ptrmem)
5721             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5722           else if (!is_reference)
5723             fntype = build_pointer_type (fntype);
5724
5725           if (can_convert_arg (target_type, fntype, fn))
5726             matches = tree_cons (fn, NULL_TREE, matches);
5727         }
5728     }
5729
5730   /* Now, if we've already got a match (or matches), there's no need
5731      to proceed to the template functions.  But, if we don't have a
5732      match we need to look at them, too.  */
5733   if (!matches)
5734     {
5735       tree target_fn_type;
5736       tree target_arg_types;
5737       tree fns;
5738
5739       if (is_ptrmem)
5740         target_fn_type
5741           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5742       else
5743         target_fn_type = TREE_TYPE (target_type);
5744       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5745
5746       for (fns = overload; fns; fns = OVL_CHAIN (fns))
5747         {
5748           tree fn = OVL_FUNCTION (fns);
5749           tree instantiation;
5750           tree instantiation_type;
5751           tree targs;
5752
5753           if (TREE_CODE (fn) != TEMPLATE_DECL)
5754             /* We're only looking for templates.  */
5755             continue;
5756
5757           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5758               != is_ptrmem)
5759             /* We're not looking for a non-static member, and this is
5760                one, or vice versa.  */
5761             continue;
5762
5763           /* Try to do argument deduction.  */
5764           targs = make_tree_vec (DECL_NTPARMS (fn));
5765           if (fn_type_unification (fn, explicit_targs, targs,
5766                                    target_arg_types, NULL_TREE,
5767                                    DEDUCE_EXACT) != 0)
5768             /* Argument deduction failed.  */
5769             continue;
5770
5771           /* Instantiate the template.  */
5772           instantiation = instantiate_template (fn, targs);
5773           if (instantiation == error_mark_node)
5774             /* Instantiation failed.  */
5775             continue;
5776
5777           /* See if there's a match.  */
5778           instantiation_type = TREE_TYPE (instantiation);
5779           if (is_ptrmem)
5780             instantiation_type =
5781               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5782           else if (!is_reference)
5783             instantiation_type = build_pointer_type (instantiation_type);
5784           if (can_convert_arg (target_type, instantiation_type, instantiation))
5785             matches = tree_cons (instantiation, fn, matches);
5786         }
5787
5788       /* Now, remove all but the most specialized of the matches.  */
5789       if (matches)
5790         {
5791           tree match = most_specialized_instantiation (matches,
5792                                                        explicit_targs);
5793
5794           if (match != error_mark_node)
5795             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5796         }
5797     }
5798
5799   /* Now we should have exactly one function in MATCHES.  */
5800   if (matches == NULL_TREE)
5801     {
5802       /* There were *no* matches.  */
5803       if (complain)
5804         {
5805           cp_error ("no matches converting function `%D' to type `%#T'",
5806                     DECL_NAME (OVL_FUNCTION (overload)),
5807                     target_type);
5808
5809           /* print_candidates expects a chain with the functions in
5810              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5811              so why be clever?).  */
5812           for (; overload; overload = OVL_NEXT (overload))
5813             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5814                                  matches);
5815
5816           print_candidates (matches);
5817         }
5818       return error_mark_node;
5819     }
5820   else if (TREE_CHAIN (matches))
5821     {
5822       /* There were too many matches.  */
5823
5824       if (complain)
5825         {
5826           tree match;
5827
5828           cp_error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5829                     DECL_NAME (OVL_FUNCTION (overload)),
5830                     target_type);
5831
5832           /* Since print_candidates expects the functions in the
5833              TREE_VALUE slot, we flip them here.  */
5834           for (match = matches; match; match = TREE_CHAIN (match))
5835             TREE_VALUE (match) = TREE_PURPOSE (match);
5836
5837           print_candidates (matches);
5838         }
5839
5840       return error_mark_node;
5841     }
5842
5843   /* Good, exactly one match.  Now, convert it to the correct type.  */
5844   fn = TREE_PURPOSE (matches);
5845
5846   mark_used (fn);
5847
5848   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5849     return build_unary_op (ADDR_EXPR, fn, 0);
5850   else
5851     {
5852       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5853          will mark the function as addressed, but here we must do it
5854          explicitly.  */
5855       mark_addressable (fn);
5856
5857       return fn;
5858     }
5859 }
5860
5861 /* This function will instantiate the type of the expression given in
5862    RHS to match the type of LHSTYPE.  If errors exist, then return
5863    error_mark_node.  We only complain is COMPLAIN is set.  If we are
5864    not complaining, never modify rhs, as overload resolution wants to
5865    try many possible instantiations, in hopes that at least one will
5866    work.
5867
5868    FLAGS is a bitmask, as we see at the top of the function.
5869
5870    For non-recursive calls, LHSTYPE should be a function, pointer to
5871    function, or a pointer to member function.  */
5872
5873 tree
5874 instantiate_type (lhstype, rhs, flags)
5875      tree lhstype, rhs;
5876      int flags;
5877 {
5878   int complain = (flags & 1);
5879   int strict = (flags & 2) ? COMPARE_NO_ATTRIBUTES : COMPARE_STRICT;
5880
5881   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
5882     {
5883       if (complain)
5884         error ("not enough type information");
5885       return error_mark_node;
5886     }
5887
5888   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
5889     {
5890       if (comptypes (lhstype, TREE_TYPE (rhs), strict))
5891         return rhs;
5892       if (complain)
5893         cp_error ("argument of type `%T' does not match `%T'",
5894                   TREE_TYPE (rhs), lhstype);
5895       return error_mark_node;
5896     }
5897
5898   /* We don't overwrite rhs if it is an overloaded function.
5899      Copying it would destroy the tree link.  */
5900   if (TREE_CODE (rhs) != OVERLOAD)
5901     rhs = copy_node (rhs);
5902
5903   /* This should really only be used when attempting to distinguish
5904      what sort of a pointer to function we have.  For now, any
5905      arithmetic operation which is not supported on pointers
5906      is rejected as an error.  */
5907
5908   switch (TREE_CODE (rhs))
5909     {
5910     case TYPE_EXPR:
5911     case CONVERT_EXPR:
5912     case SAVE_EXPR:
5913     case CONSTRUCTOR:
5914     case BUFFER_REF:
5915       my_friendly_abort (177);
5916       return error_mark_node;
5917
5918     case INDIRECT_REF:
5919     case ARRAY_REF:
5920       {
5921         tree new_rhs;
5922
5923         new_rhs = instantiate_type (build_pointer_type (lhstype),
5924                                     TREE_OPERAND (rhs, 0), flags);
5925         if (new_rhs == error_mark_node)
5926           return error_mark_node;
5927
5928         TREE_TYPE (rhs) = lhstype;
5929         TREE_OPERAND (rhs, 0) = new_rhs;
5930         return rhs;
5931       }
5932
5933     case NOP_EXPR:
5934       rhs = copy_node (TREE_OPERAND (rhs, 0));
5935       TREE_TYPE (rhs) = unknown_type_node;
5936       return instantiate_type (lhstype, rhs, flags);
5937
5938     case COMPONENT_REF:
5939       {
5940         tree r = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
5941
5942         if (r != error_mark_node && TYPE_PTRMEMFUNC_P (lhstype)
5943             && complain && !flag_ms_extensions)
5944           {
5945             /* Note: we check this after the recursive call to avoid
5946                complaining about cases where overload resolution fails.  */
5947
5948             tree t = TREE_TYPE (TREE_OPERAND (rhs, 0));
5949             tree fn = PTRMEM_CST_MEMBER (r);
5950
5951             my_friendly_assert (TREE_CODE (r) == PTRMEM_CST, 990811);
5952
5953             cp_pedwarn
5954               ("object-dependent reference to `%E' can only be used in a call",
5955                DECL_NAME (fn));
5956             cp_pedwarn
5957               ("  to form a pointer to member function, say `&%T::%E'",
5958                t, DECL_NAME (fn));
5959           }
5960
5961         return r;
5962       }
5963
5964     case OFFSET_REF:
5965       rhs = TREE_OPERAND (rhs, 1);
5966       if (BASELINK_P (rhs))
5967         return instantiate_type (lhstype, TREE_VALUE (rhs), flags);
5968
5969       /* This can happen if we are forming a pointer-to-member for a
5970          member template.  */
5971       my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
5972
5973       /* Fall through.  */
5974
5975     case TEMPLATE_ID_EXPR:
5976       return
5977         resolve_address_of_overloaded_function (lhstype,
5978                                                 TREE_OPERAND (rhs, 0),
5979                                                 complain,
5980                                                 /*template_only=*/1,
5981                                                 TREE_OPERAND (rhs, 1));
5982
5983     case OVERLOAD:
5984       return
5985         resolve_address_of_overloaded_function (lhstype,
5986                                                 rhs,
5987                                                 complain,
5988                                                 /*template_only=*/0,
5989                                                 /*explicit_targs=*/NULL_TREE);
5990
5991     case TREE_LIST:
5992       /* Now we should have a baselink. */
5993       my_friendly_assert (BASELINK_P (rhs), 990412);
5994
5995       return instantiate_type (lhstype, TREE_VALUE (rhs), flags);
5996
5997     case CALL_EXPR:
5998       /* This is too hard for now.  */
5999       my_friendly_abort (183);
6000       return error_mark_node;
6001
6002     case PLUS_EXPR:
6003     case MINUS_EXPR:
6004     case COMPOUND_EXPR:
6005       TREE_OPERAND (rhs, 0)
6006         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6007       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6008         return error_mark_node;
6009       TREE_OPERAND (rhs, 1)
6010         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6011       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6012         return error_mark_node;
6013
6014       TREE_TYPE (rhs) = lhstype;
6015       return rhs;
6016
6017     case MULT_EXPR:
6018     case TRUNC_DIV_EXPR:
6019     case FLOOR_DIV_EXPR:
6020     case CEIL_DIV_EXPR:
6021     case ROUND_DIV_EXPR:
6022     case RDIV_EXPR:
6023     case TRUNC_MOD_EXPR:
6024     case FLOOR_MOD_EXPR:
6025     case CEIL_MOD_EXPR:
6026     case ROUND_MOD_EXPR:
6027     case FIX_ROUND_EXPR:
6028     case FIX_FLOOR_EXPR:
6029     case FIX_CEIL_EXPR:
6030     case FIX_TRUNC_EXPR:
6031     case FLOAT_EXPR:
6032     case NEGATE_EXPR:
6033     case ABS_EXPR:
6034     case MAX_EXPR:
6035     case MIN_EXPR:
6036     case FFS_EXPR:
6037
6038     case BIT_AND_EXPR:
6039     case BIT_IOR_EXPR:
6040     case BIT_XOR_EXPR:
6041     case LSHIFT_EXPR:
6042     case RSHIFT_EXPR:
6043     case LROTATE_EXPR:
6044     case RROTATE_EXPR:
6045
6046     case PREINCREMENT_EXPR:
6047     case PREDECREMENT_EXPR:
6048     case POSTINCREMENT_EXPR:
6049     case POSTDECREMENT_EXPR:
6050       if (complain)
6051         error ("invalid operation on uninstantiated type");
6052       return error_mark_node;
6053
6054     case TRUTH_AND_EXPR:
6055     case TRUTH_OR_EXPR:
6056     case TRUTH_XOR_EXPR:
6057     case LT_EXPR:
6058     case LE_EXPR:
6059     case GT_EXPR:
6060     case GE_EXPR:
6061     case EQ_EXPR:
6062     case NE_EXPR:
6063     case TRUTH_ANDIF_EXPR:
6064     case TRUTH_ORIF_EXPR:
6065     case TRUTH_NOT_EXPR:
6066       if (complain)
6067         error ("not enough type information");
6068       return error_mark_node;
6069
6070     case COND_EXPR:
6071       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6072         {
6073           if (complain)
6074             error ("not enough type information");
6075           return error_mark_node;
6076         }
6077       TREE_OPERAND (rhs, 1)
6078         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6079       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6080         return error_mark_node;
6081       TREE_OPERAND (rhs, 2)
6082         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6083       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6084         return error_mark_node;
6085
6086       TREE_TYPE (rhs) = lhstype;
6087       return rhs;
6088
6089     case MODIFY_EXPR:
6090       TREE_OPERAND (rhs, 1)
6091         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6092       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6093         return error_mark_node;
6094
6095       TREE_TYPE (rhs) = lhstype;
6096       return rhs;
6097
6098     case ADDR_EXPR:
6099       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6100
6101     case ENTRY_VALUE_EXPR:
6102       my_friendly_abort (184);
6103       return error_mark_node;
6104
6105     case ERROR_MARK:
6106       return error_mark_node;
6107
6108     default:
6109       my_friendly_abort (185);
6110       return error_mark_node;
6111     }
6112 }
6113 \f
6114 /* Return the name of the virtual function pointer field
6115    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6116    this may have to look back through base types to find the
6117    ultimate field name.  (For single inheritance, these could
6118    all be the same name.  Who knows for multiple inheritance).  */
6119
6120 static tree
6121 get_vfield_name (type)
6122      tree type;
6123 {
6124   tree binfo = TYPE_BINFO (type);
6125   char *buf;
6126
6127   while (BINFO_BASETYPES (binfo)
6128          && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
6129          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
6130     binfo = BINFO_BASETYPE (binfo, 0);
6131
6132   type = BINFO_TYPE (binfo);
6133   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6134                          + TYPE_NAME_LENGTH (type) + 2);
6135   sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
6136   return get_identifier (buf);
6137 }
6138
6139 void
6140 print_class_statistics ()
6141 {
6142 #ifdef GATHER_STATISTICS
6143   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6144   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6145   fprintf (stderr, "build_method_call = %d (inner = %d)\n",
6146            n_build_method_call, n_inner_fields_searched);
6147   if (n_vtables)
6148     {
6149       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6150                n_vtables, n_vtable_searches);
6151       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6152                n_vtable_entries, n_vtable_elems);
6153     }
6154 #endif
6155 }
6156
6157 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6158    according to [class]:
6159                                           The class-name is also inserted
6160    into  the scope of the class itself.  For purposes of access checking,
6161    the inserted class name is treated as if it were a public member name.  */
6162
6163 void
6164 build_self_reference ()
6165 {
6166   tree name = constructor_name (current_class_type);
6167   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6168   tree saved_cas;
6169
6170   DECL_NONLOCAL (value) = 1;
6171   DECL_CONTEXT (value) = current_class_type;
6172   DECL_CLASS_CONTEXT (value) = current_class_type;
6173   DECL_ARTIFICIAL (value) = 1;
6174
6175   if (processing_template_decl)
6176     value = push_template_decl (value);
6177
6178   saved_cas = current_access_specifier;
6179   current_access_specifier = access_public_node;
6180   finish_member_declaration (value);
6181   current_access_specifier = saved_cas;
6182 }
6183
6184 /* Returns 1 if TYPE contains only padding bytes.  */
6185
6186 int
6187 is_empty_class (type)
6188      tree type;
6189 {
6190   tree t;
6191
6192   if (type == error_mark_node)
6193     return 0;
6194
6195   if (! IS_AGGR_TYPE (type))
6196     return 0;
6197
6198   if (flag_new_abi)
6199     return CLASSTYPE_SIZE (type) == integer_zero_node;
6200
6201   if (TYPE_BINFO_BASETYPES (type))
6202     return 0;
6203   t = TYPE_FIELDS (type);
6204   while (t && TREE_CODE (t) != FIELD_DECL)
6205     t = TREE_CHAIN (t);
6206   return (t == NULL_TREE);
6207 }
6208
6209 /* Find the enclosing class of the given NODE.  NODE can be a *_DECL or
6210    a *_TYPE node.  NODE can also be a local class.  */
6211
6212 tree
6213 get_enclosing_class (type)
6214      tree type;
6215 {
6216   tree node = type;
6217
6218   while (node && TREE_CODE (node) != NAMESPACE_DECL)
6219     {
6220       switch (TREE_CODE_CLASS (TREE_CODE (node)))
6221         {
6222         case 'd':
6223           node = DECL_CONTEXT (node);
6224           break;
6225
6226         case 't':
6227           if (node != type)
6228             return node;
6229           node = TYPE_CONTEXT (node);
6230           break;
6231
6232         default:
6233           my_friendly_abort (0);
6234         }
6235     }
6236   return NULL_TREE;
6237 }
6238
6239 /* Return 1 if TYPE or one of its enclosing classes is derived from BASE.  */
6240
6241 int
6242 is_base_of_enclosing_class (base, type)
6243      tree base, type;
6244 {
6245   while (type)
6246     {
6247       if (get_binfo (base, type, 0))
6248         return 1;
6249
6250       type = get_enclosing_class (type);
6251     }
6252   return 0;
6253 }
6254
6255 /* Note that NAME was looked up while the current class was being
6256    defined and that the result of that lookup was DECL.  */
6257
6258 void
6259 maybe_note_name_used_in_class (name, decl)
6260      tree name;
6261      tree decl;
6262 {
6263   splay_tree names_used;
6264
6265   /* If we're not defining a class, there's nothing to do.  */
6266   if (!current_class_type || !TYPE_BEING_DEFINED (current_class_type))
6267     return;
6268
6269   /* If there's already a binding for this NAME, then we don't have
6270      anything to worry about.  */
6271   if (IDENTIFIER_CLASS_VALUE (name))
6272     return;
6273
6274   if (!current_class_stack[current_class_depth - 1].names_used)
6275     current_class_stack[current_class_depth - 1].names_used
6276       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6277   names_used = current_class_stack[current_class_depth - 1].names_used;
6278
6279   splay_tree_insert (names_used,
6280                      (splay_tree_key) name,
6281                      (splay_tree_value) decl);
6282 }
6283
6284 /* Note that NAME was declared (as DECL) in the current class.  Check
6285    to see that the declaration is legal.  */
6286
6287 void
6288 note_name_declared_in_class (name, decl)
6289      tree name;
6290      tree decl;
6291 {
6292   splay_tree names_used;
6293   splay_tree_node n;
6294
6295   /* Look to see if we ever used this name.  */
6296   names_used
6297     = current_class_stack[current_class_depth - 1].names_used;
6298   if (!names_used)
6299     return;
6300
6301   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6302   if (n)
6303     {
6304       /* [basic.scope.class]
6305
6306          A name N used in a class S shall refer to the same declaration
6307          in its context and when re-evaluated in the completed scope of
6308          S.  */
6309       cp_error ("declaration of `%#D'", decl);
6310       cp_error_at ("changes meaning of `%s' from `%+#D'",
6311                    IDENTIFIER_POINTER (DECL_NAME (decl)),
6312                    (tree) n->value);
6313     }
6314 }
6315
6316 /* Dump the offsets of all the bases rooted at BINFO to stderr.
6317    INDENT should be zero when called from the top level; it is
6318    incremented recursively.  */
6319
6320 void
6321 dump_class_hierarchy (binfo, indent)
6322      tree binfo;
6323      int indent;
6324 {
6325   int i;
6326
6327   fprintf (stderr, "%*s0x%lx (%s) ", indent, "",
6328            (unsigned long) binfo,
6329            type_as_string (binfo, TS_PLAIN));
6330   fprintf (stderr, HOST_WIDE_INT_PRINT_DEC,
6331            TREE_INT_CST_LOW (BINFO_OFFSET (binfo)));
6332   fprintf (stderr, " %s\n",
6333            BINFO_PRIMARY_MARKED_P (binfo) ? "primary" : "");
6334
6335   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
6336     dump_class_hierarchy (BINFO_BASETYPE (binfo, i), indent + 2);
6337 }