contrib/gcc-3.4/gcc/cp/class.c

   1 /* Functions related to building classes and their related objects.
   2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005
   4      Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 /* High-level class interface.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "tree.h"
  32 #include "cp-tree.h"
  33 #include "flags.h"
  34 #include "rtl.h"
  35 #include "output.h"
  36 #include "toplev.h"
  37 #include "lex.h"
  38 #include "target.h"
  39 #include "convert.h"
  40
  41 /* The number of nested classes being processed.  If we are not in the
  42    scope of any class, this is zero.  */
  43
  44 int current_class_depth;
  45
  46 /* In order to deal with nested classes, we keep a stack of classes.
  47    The topmost entry is the innermost class, and is the entry at index
  48    CURRENT_CLASS_DEPTH  */
  49
  50 typedef struct class_stack_node {
  51   /* The name of the class.  */
  52   tree name;
  53
  54   /* The _TYPE node for the class.  */
  55   tree type;
  56
  57   /* The access specifier pending for new declarations in the scope of
  58      this class.  */
  59   tree access;
  60
  61   /* If were defining TYPE, the names used in this class.  */
  62   splay_tree names_used;
  63 }* class_stack_node_t;
  64
  65 typedef struct vtbl_init_data_s
  66 {
  67   /* The base for which we're building initializers.  */
  68   tree binfo;
  69   /* The type of the most-derived type.  */
  70   tree derived;
  71   /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
  72      unless ctor_vtbl_p is true.  */
  73   tree rtti_binfo;
  74   /* The negative-index vtable initializers built up so far.  These
  75      are in order from least negative index to most negative index.  */
  76   tree inits;
  77   /* The last (i.e., most negative) entry in INITS.  */
  78   tree* last_init;
  79   /* The binfo for the virtual base for which we're building
  80      vcall offset initializers.  */
  81   tree vbase;
  82   /* The functions in vbase for which we have already provided vcall
  83      offsets.  */
  84   varray_type fns;
  85   /* The vtable index of the next vcall or vbase offset.  */
  86   tree index;
  87   /* Nonzero if we are building the initializer for the primary
  88      vtable.  */
  89   int primary_vtbl_p;
  90   /* Nonzero if we are building the initializer for a construction
  91      vtable.  */
  92   int ctor_vtbl_p;
  93   /* True when adding vcall offset entries to the vtable.  False when
  94      merely computing the indices.  */
  95   bool generate_vcall_entries;
  96 } vtbl_init_data;
  97
  98 /* The type of a function passed to walk_subobject_offsets.  */
  99 typedef int (*subobject_offset_fn) (tree, tree, splay_tree);
 100
 101 /* The stack itself.  This is a dynamically resized array.  The
 102    number of elements allocated is CURRENT_CLASS_STACK_SIZE.  */
 103 static int current_class_stack_size;
 104 static class_stack_node_t current_class_stack;
 105
 106 /* An array of all local classes present in this translation unit, in
 107    declaration order.  */
 108 varray_type local_classes;
 109
 110 static tree get_vfield_name (tree);
 111 static void finish_struct_anon (tree);
 112 static tree get_vtable_name (tree);
 113 static tree get_basefndecls (tree, tree);
 114 static int build_primary_vtable (tree, tree);
 115 static int build_secondary_vtable (tree);
 116 static void finish_vtbls (tree);
 117 static void modify_vtable_entry (tree, tree, tree, tree, tree *);
 118 static void finish_struct_bits (tree);
 119 static int alter_access (tree, tree, tree);
 120 static void handle_using_decl (tree, tree);
 121 static void check_for_override (tree, tree);
 122 static tree dfs_modify_vtables (tree, void *);
 123 static tree modify_all_vtables (tree, tree);
 124 static void determine_primary_base (tree);
 125 static void finish_struct_methods (tree);
 126 static void maybe_warn_about_overly_private_class (tree);
 127 static int method_name_cmp (const void *, const void *);
 128 static int resort_method_name_cmp (const void *, const void *);
 129 static void add_implicitly_declared_members (tree, int, int, int);
 130 static tree fixed_type_or_null (tree, int *, int *);
 131 static tree resolve_address_of_overloaded_function (tree, tree, tsubst_flags_t,
 132                                                     bool, tree);
 133 static tree build_vtbl_ref_1 (tree, tree);
 134 static tree build_vtbl_initializer (tree, tree, tree, tree, int *);
 135 static int count_fields (tree);
 136 static int add_fields_to_record_type (tree, struct sorted_fields_type*, int);
 137 static void check_bitfield_decl (tree);
 138 static void check_field_decl (tree, tree, int *, int *, int *, int *);
 139 static void check_field_decls (tree, tree *, int *, int *, int *);
 140 static tree *build_base_field (record_layout_info, tree, splay_tree, tree *);
 141 static void build_base_fields (record_layout_info, splay_tree, tree *);
 142 static void check_methods (tree);
 143 static void remove_zero_width_bit_fields (tree);
 144 static void check_bases (tree, int *, int *, int *);
 145 static void check_bases_and_members (tree);
 146 static tree create_vtable_ptr (tree, tree *);
 147 static void include_empty_classes (record_layout_info);
 148 static void layout_class_type (tree, tree *);
 149 static void fixup_pending_inline (tree);
 150 static void fixup_inline_methods (tree);
 151 static void set_primary_base (tree, tree);
 152 static void propagate_binfo_offsets (tree, tree);
 153 static void layout_virtual_bases (record_layout_info, splay_tree);
 154 static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *);
 155 static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *);
 156 static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *);
 157 static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *);
 158 static void add_vcall_offset (tree, tree, vtbl_init_data *);
 159 static void layout_vtable_decl (tree, int);
 160 static tree dfs_find_final_overrider (tree, void *);
 161 static tree dfs_find_final_overrider_post (tree, void *);
 162 static tree dfs_find_final_overrider_q (tree, int, void *);
 163 static tree find_final_overrider (tree, tree, tree);
 164 static int make_new_vtable (tree, tree);
 165 static int maybe_indent_hierarchy (FILE *, int, int);
 166 static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int);
 167 static void dump_class_hierarchy (tree);
 168 static void dump_class_hierarchy_1 (FILE *, int, tree);
 169 static void dump_array (FILE *, tree);
 170 static void dump_vtable (tree, tree, tree);
 171 static void dump_vtt (tree, tree);
 172 static void dump_thunk (FILE *, int, tree);
 173 static tree build_vtable (tree, tree, tree);
 174 static void initialize_vtable (tree, tree);
 175 static void initialize_array (tree, tree);
 176 static void layout_nonempty_base_or_field (record_layout_info,
 177                                                    tree, tree, splay_tree);
 178 static tree end_of_class (tree, int);
 179 static bool layout_empty_base (tree, tree, splay_tree);
 180 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree);
 181 static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree,
 182                                                tree);
 183 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
 184 static void build_vcall_and_vbase_vtbl_entries (tree,
 185                                                         vtbl_init_data *);
 186 static void mark_primary_bases (tree);
 187 static void clone_constructors_and_destructors (tree);
 188 static tree build_clone (tree, tree);
 189 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
 190 static tree copy_virtuals (tree);
 191 static void build_ctor_vtbl_group (tree, tree);
 192 static void build_vtt (tree);
 193 static tree binfo_ctor_vtable (tree);
 194 static tree *build_vtt_inits (tree, tree, tree *, tree *);
 195 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
 196 static tree dfs_ctor_vtable_bases_queue_p (tree, int, void *data);
 197 static tree dfs_fixup_binfo_vtbls (tree, void *);
 198 static int record_subobject_offset (tree, tree, splay_tree);
 199 static int check_subobject_offset (tree, tree, splay_tree);
 200 static int walk_subobject_offsets (tree, subobject_offset_fn,
 201                                            tree, splay_tree, tree, int);
 202 static void record_subobject_offsets (tree, tree, splay_tree, int);
 203 static int layout_conflict_p (tree, tree, splay_tree, int);
 204 static int splay_tree_compare_integer_csts (splay_tree_key k1,
 205                                                     splay_tree_key k2);
 206 static void warn_about_ambiguous_bases (tree);
 207 static bool type_requires_array_cookie (tree);
 208 static bool contains_empty_class_p (tree);
 209 static bool base_derived_from (tree, tree);
 210 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
 211 static tree end_of_base (tree);
 212 static tree get_vcall_index (tree, tree);
 213
 214 /* Macros for dfs walking during vtt construction. See
 215    dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
 216    and dfs_fixup_binfo_vtbls.  */
 217 #define VTT_TOP_LEVEL_P(NODE) TREE_UNSIGNED (NODE)
 218 #define VTT_MARKED_BINFO_P(NODE) TREE_USED (NODE)
 219
 220 /* Variables shared between class.c and call.c.  */
 221
 222 #ifdef GATHER_STATISTICS
 223 int n_vtables = 0;
 224 int n_vtable_entries = 0;
 225 int n_vtable_searches = 0;
 226 int n_vtable_elems = 0;
 227 int n_convert_harshness = 0;
 228 int n_compute_conversion_costs = 0;
 229 int n_inner_fields_searched = 0;
 230 #endif
 231
 232 /* Convert to or from a base subobject.  EXPR is an expression of type
 233    `A' or `A*', an expression of type `B' or `B*' is returned.  To
 234    convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
 235    the B base instance within A.  To convert base A to derived B, CODE
 236    is MINUS_EXPR and BINFO is the binfo for the A instance within B.
 237    In this latter case, A must not be a morally virtual base of B.
 238    NONNULL is true if EXPR is known to be non-NULL (this is only
 239    needed when EXPR is of pointer type).  CV qualifiers are preserved
 240    from EXPR.  */
 241
 242 tree
 243 build_base_path (enum tree_code code,
 244                  tree expr,
 245                  tree binfo,
 246                  int nonnull)
 247 {
 248   tree v_binfo = NULL_TREE;
 249   tree d_binfo = NULL_TREE;
 250   tree probe;
 251   tree offset;
 252   tree target_type;
 253   tree null_test = NULL;
 254   tree ptr_target_type;
 255   int fixed_type_p;
 256   int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
 257
 258   if (expr == error_mark_node || binfo == error_mark_node || !binfo)
 259     return error_mark_node;
 260
 261   for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
 262     {
 263       d_binfo = probe;
 264       if (!v_binfo && TREE_VIA_VIRTUAL (probe))
 265         v_binfo = probe;
 266     }
 267
 268   probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
 269   if (want_pointer)
 270     probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
 271
 272   my_friendly_assert (code == MINUS_EXPR
 273                       ? same_type_p (BINFO_TYPE (binfo), probe)
 274                       : code == PLUS_EXPR
 275                       ? same_type_p (BINFO_TYPE (d_binfo), probe)
 276                       : false, 20010723);
 277
 278   if (code == MINUS_EXPR && v_binfo)
 279     {
 280       error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
 281              BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
 282       return error_mark_node;
 283     }
 284
 285   if (!want_pointer)
 286     /* This must happen before the call to save_expr.  */
 287     expr = build_unary_op (ADDR_EXPR, expr, 0);
 288
 289   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
 290   if (fixed_type_p <= 0 && TREE_SIDE_EFFECTS (expr))
 291     expr = save_expr (expr);
 292
 293   if (want_pointer && !nonnull)
 294     null_test = build (EQ_EXPR, boolean_type_node, expr, integer_zero_node);
 295
 296   offset = BINFO_OFFSET (binfo);
 297
 298   if (v_binfo && fixed_type_p <= 0)
 299     {
 300       /* Going via virtual base V_BINFO.  We need the static offset
 301          from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
 302          V_BINFO.  That offset is an entry in D_BINFO's vtable.  */
 303       tree v_offset;
 304
 305       if (fixed_type_p < 0 && in_base_initializer)
 306         {
 307           /* In a base member initializer, we cannot rely on
 308              the vtable being set up. We have to use the vtt_parm.  */
 309           tree derived = BINFO_INHERITANCE_CHAIN (v_binfo);
 310
 311           v_offset = build (PLUS_EXPR, TREE_TYPE (current_vtt_parm),
 312                             current_vtt_parm, BINFO_VPTR_INDEX (derived));
 313
 314           v_offset = build1 (INDIRECT_REF,
 315                              TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived))),
 316                              v_offset);
 317
 318         }
 319       else
 320         v_offset = build_vfield_ref (build_indirect_ref (expr, NULL),
 321                                      TREE_TYPE (TREE_TYPE (expr)));
 322
 323       v_offset = build (PLUS_EXPR, TREE_TYPE (v_offset),
 324                         v_offset,  BINFO_VPTR_FIELD (v_binfo));
 325       v_offset = build1 (NOP_EXPR,
 326                          build_pointer_type (ptrdiff_type_node),
 327                          v_offset);
 328       v_offset = build_indirect_ref (v_offset, NULL);
 329
 330       offset = convert_to_integer (ptrdiff_type_node,
 331                                    size_diffop (offset,
 332                                                 BINFO_OFFSET (v_binfo)));
 333
 334       if (!integer_zerop (offset))
 335         v_offset = build (code, ptrdiff_type_node, v_offset, offset);
 336
 337       if (fixed_type_p < 0)
 338         /* Negative fixed_type_p means this is a constructor or destructor;
 339            virtual base layout is fixed in in-charge [cd]tors, but not in
 340            base [cd]tors.  */
 341         offset = build (COND_EXPR, ptrdiff_type_node,
 342                         build (EQ_EXPR, boolean_type_node,
 343                                current_in_charge_parm, integer_zero_node),
 344                         v_offset,
 345                         BINFO_OFFSET (binfo));
 346       else
 347         offset = v_offset;
 348     }
 349
 350   target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
 351
 352   target_type = cp_build_qualified_type
 353     (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
 354   ptr_target_type = build_pointer_type (target_type);
 355   if (want_pointer)
 356     target_type = ptr_target_type;
 357
 358   expr = build1 (NOP_EXPR, ptr_target_type, expr);
 359
 360   if (!integer_zerop (offset))
 361     expr = build (code, ptr_target_type, expr, offset);
 362   else
 363     null_test = NULL;
 364
 365   if (!want_pointer)
 366     expr = build_indirect_ref (expr, NULL);
 367
 368   if (null_test)
 369     expr = build (COND_EXPR, target_type, null_test,
 370                   build1 (NOP_EXPR, target_type, integer_zero_node),
 371                   expr);
 372
 373   return expr;
 374 }
 375
 376 /* Convert OBJECT to the base TYPE.  If CHECK_ACCESS is true, an error
 377    message is emitted if TYPE is inaccessible.  OBJECT is assumed to
 378    be non-NULL.  */
 379
 380 tree
 381 convert_to_base (tree object, tree type, bool check_access)
 382 {
 383   tree binfo;
 384
 385   binfo = lookup_base (TREE_TYPE (object), type,
 386                        check_access ? ba_check : ba_ignore,
 387                        NULL);
 388   if (!binfo || binfo == error_mark_node)
 389     return error_mark_node;
 390
 391   return build_base_path (PLUS_EXPR, object, binfo, /*nonnull=*/1);
 392 }
 393
 394 /* EXPR is an expression with class type.  BASE is a base class (a
 395    BINFO) of that class type.  Returns EXPR, converted to the BASE
 396    type.  This function assumes that EXPR is the most derived class;
 397    therefore virtual bases can be found at their static offsets.  */
 398
 399 tree
 400 convert_to_base_statically (tree expr, tree base)
 401 {
 402   tree expr_type;
 403
 404   expr_type = TREE_TYPE (expr);
 405   if (!same_type_p (expr_type, BINFO_TYPE (base)))
 406     {
 407       tree pointer_type;
 408
 409       pointer_type = build_pointer_type (expr_type);
 410       expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1);
 411       if (!integer_zerop (BINFO_OFFSET (base)))
 412           expr = build (PLUS_EXPR, pointer_type, expr,
 413                         build_nop (pointer_type, BINFO_OFFSET (base)));
 414       expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr);
 415       expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr);
 416     }
 417
 418   return expr;
 419 }
 420
 421 \f
 422 /* Given an object INSTANCE, return an expression which yields the
 423    vtable element corresponding to INDEX.  There are many special
 424    cases for INSTANCE which we take care of here, mainly to avoid
 425    creating extra tree nodes when we don't have to.  */
 426
 427 static tree
 428 build_vtbl_ref_1 (tree instance, tree idx)
 429 {
 430   tree aref;
 431   tree vtbl = NULL_TREE;
 432
 433   /* Try to figure out what a reference refers to, and
 434      access its virtual function table directly.  */
 435
 436   int cdtorp = 0;
 437   tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
 438
 439   tree basetype = non_reference (TREE_TYPE (instance));
 440
 441   if (fixed_type && !cdtorp)
 442     {
 443       tree binfo = lookup_base (fixed_type, basetype,
 444                                 ba_ignore|ba_quiet, NULL);
 445       if (binfo)
 446         vtbl = BINFO_VTABLE (binfo);
 447     }
 448
 449   if (!vtbl)
 450     vtbl = build_vfield_ref (instance, basetype);
 451
 452   assemble_external (vtbl);
 453
 454   aref = build_array_ref (vtbl, idx);
 455
 456   return aref;
 457 }
 458
 459 tree
 460 build_vtbl_ref (tree instance, tree idx)
 461 {
 462   tree aref = build_vtbl_ref_1 (instance, idx);
 463
 464   return aref;
 465 }
 466
 467 /* Given an object INSTANCE, return an expression which yields a
 468    function pointer corresponding to vtable element INDEX.  */
 469
 470 tree
 471 build_vfn_ref (tree instance, tree idx)
 472 {
 473   tree aref = build_vtbl_ref_1 (instance, idx);
 474
 475   /* When using function descriptors, the address of the
 476      vtable entry is treated as a function pointer.  */
 477   if (TARGET_VTABLE_USES_DESCRIPTORS)
 478     aref = build1 (NOP_EXPR, TREE_TYPE (aref),
 479                    build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1));
 480
 481   return aref;
 482 }
 483
 484 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
 485    for the given TYPE.  */
 486
 487 static tree
 488 get_vtable_name (tree type)
 489 {
 490   return mangle_vtbl_for_type (type);
 491 }
 492
 493 /* Return an IDENTIFIER_NODE for the name of the virtual table table
 494    for TYPE.  */
 495
 496 tree
 497 get_vtt_name (tree type)
 498 {
 499   return mangle_vtt_for_type (type);
 500 }
 501
 502 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
 503    (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
 504    Use NAME for the name of the vtable, and VTABLE_TYPE for its type.  */
 505
 506 static tree
 507 build_vtable (tree class_type, tree name, tree vtable_type)
 508 {
 509   tree decl;
 510
 511   decl = build_lang_decl (VAR_DECL, name, vtable_type);
 512   /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
 513      now to avoid confusion in mangle_decl.  */
 514   SET_DECL_ASSEMBLER_NAME (decl, name);
 515   DECL_CONTEXT (decl) = class_type;
 516   DECL_ARTIFICIAL (decl) = 1;
 517   TREE_STATIC (decl) = 1;
 518   TREE_READONLY (decl) = 1;
 519   DECL_VIRTUAL_P (decl) = 1;
 520   DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
 521   DECL_VTABLE_OR_VTT_P (decl) = 1;
 522
 523   /* At one time the vtable info was grabbed 2 words at a time.  This
 524      fails on sparc unless you have 8-byte alignment.  (tiemann) */
 525   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
 526                            DECL_ALIGN (decl));
 527
 528   import_export_vtable (decl, class_type, 0);
 529
 530   return decl;
 531 }
 532
 533 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
 534    or even complete.  If this does not exist, create it.  If COMPLETE is
 535    nonzero, then complete the definition of it -- that will render it
 536    impossible to actually build the vtable, but is useful to get at those
 537    which are known to exist in the runtime.  */
 538
 539 tree
 540 get_vtable_decl (tree type, int complete)
 541 {
 542   tree decl;
 543
 544   if (CLASSTYPE_VTABLES (type))
 545     return CLASSTYPE_VTABLES (type);
 546
 547   decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
 548   CLASSTYPE_VTABLES (type) = decl;
 549
 550   if (complete)
 551     {
 552       DECL_EXTERNAL (decl) = 1;
 553       cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
 554     }
 555
 556   return decl;
 557 }
 558
 559 /* Returns a copy of the BINFO_VIRTUALS list in BINFO.  The
 560    BV_VCALL_INDEX for each entry is cleared.  */
 561
 562 static tree
 563 copy_virtuals (tree binfo)
 564 {
 565   tree copies;
 566   tree t;
 567
 568   copies = copy_list (BINFO_VIRTUALS (binfo));
 569   for (t = copies; t; t = TREE_CHAIN (t))
 570     BV_VCALL_INDEX (t) = NULL_TREE;
 571
 572   return copies;
 573 }
 574
 575 /* Build the primary virtual function table for TYPE.  If BINFO is
 576    non-NULL, build the vtable starting with the initial approximation
 577    that it is the same as the one which is the head of the association
 578    list.  Returns a nonzero value if a new vtable is actually
 579    created.  */
 580
 581 static int
 582 build_primary_vtable (tree binfo, tree type)
 583 {
 584   tree decl;
 585   tree virtuals;
 586
 587   decl = get_vtable_decl (type, /*complete=*/0);
 588
 589   if (binfo)
 590     {
 591       if (BINFO_NEW_VTABLE_MARKED (binfo))
 592         /* We have already created a vtable for this base, so there's
 593            no need to do it again.  */
 594         return 0;
 595
 596       virtuals = copy_virtuals (binfo);
 597       TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
 598       DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
 599       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
 600     }
 601   else
 602     {
 603       my_friendly_assert (TREE_TYPE (decl) == vtbl_type_node, 20000118);
 604       virtuals = NULL_TREE;
 605     }
 606
 607 #ifdef GATHER_STATISTICS
 608   n_vtables += 1;
 609   n_vtable_elems += list_length (virtuals);
 610 #endif
 611
 612   /* Initialize the association list for this type, based
 613      on our first approximation.  */
 614   TYPE_BINFO_VTABLE (type) = decl;
 615   TYPE_BINFO_VIRTUALS (type) = virtuals;
 616   SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
 617   return 1;
 618 }
 619
 620 /* Give BINFO a new virtual function table which is initialized
 621    with a skeleton-copy of its original initialization.  The only
 622    entry that changes is the `delta' entry, so we can really
 623    share a lot of structure.
 624
 625    FOR_TYPE is the most derived type which caused this table to
 626    be needed.
 627
 628    Returns nonzero if we haven't met BINFO before.
 629
 630    The order in which vtables are built (by calling this function) for
 631    an object must remain the same, otherwise a binary incompatibility
 632    can result.  */
 633
 634 static int
 635 build_secondary_vtable (tree binfo)
 636 {
 637   if (BINFO_NEW_VTABLE_MARKED (binfo))
 638     /* We already created a vtable for this base.  There's no need to
 639        do it again.  */
 640     return 0;
 641
 642   /* Remember that we've created a vtable for this BINFO, so that we
 643      don't try to do so again.  */
 644   SET_BINFO_NEW_VTABLE_MARKED (binfo);
 645
 646   /* Make fresh virtual list, so we can smash it later.  */
 647   BINFO_VIRTUALS (binfo) = copy_virtuals (binfo);
 648
 649   /* Secondary vtables are laid out as part of the same structure as
 650      the primary vtable.  */
 651   BINFO_VTABLE (binfo) = NULL_TREE;
 652   return 1;
 653 }
 654
 655 /* Create a new vtable for BINFO which is the hierarchy dominated by
 656    T. Return nonzero if we actually created a new vtable.  */
 657
 658 static int
 659 make_new_vtable (tree t, tree binfo)
 660 {
 661   if (binfo == TYPE_BINFO (t))
 662     /* In this case, it is *type*'s vtable we are modifying.  We start
 663        with the approximation that its vtable is that of the
 664        immediate base class.  */
 665     /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
 666        since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now.  */
 667     return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))),
 668                                  t);
 669   else
 670     /* This is our very own copy of `basetype' to play with.  Later,
 671        we will fill in all the virtual functions that override the
 672        virtual functions in these base classes which are not defined
 673        by the current type.  */
 674     return build_secondary_vtable (binfo);
 675 }
 676
 677 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
 678    (which is in the hierarchy dominated by T) list FNDECL as its
 679    BV_FN.  DELTA is the required constant adjustment from the `this'
 680    pointer where the vtable entry appears to the `this' required when
 681    the function is actually called.  */
 682
 683 static void
 684 modify_vtable_entry (tree t,
 685                      tree binfo,
 686                      tree fndecl,
 687                      tree delta,
 688                      tree *virtuals)
 689 {
 690   tree v;
 691
 692   v = *virtuals;
 693
 694   if (fndecl != BV_FN (v)
 695       || !tree_int_cst_equal (delta, BV_DELTA (v)))
 696     {
 697       /* We need a new vtable for BINFO.  */
 698       if (make_new_vtable (t, binfo))
 699         {
 700           /* If we really did make a new vtable, we also made a copy
 701              of the BINFO_VIRTUALS list.  Now, we have to find the
 702              corresponding entry in that list.  */
 703           *virtuals = BINFO_VIRTUALS (binfo);
 704           while (BV_FN (*virtuals) != BV_FN (v))
 705             *virtuals = TREE_CHAIN (*virtuals);
 706           v = *virtuals;
 707         }
 708
 709       BV_DELTA (v) = delta;
 710       BV_VCALL_INDEX (v) = NULL_TREE;
 711       BV_FN (v) = fndecl;
 712     }
 713 }
 714
 715 \f
 716 /* Add method METHOD to class TYPE.  If ERROR_P is true, we are adding
 717    the method after the class has already been defined because a
 718    declaration for it was seen.  (Even though that is erroneous, we
 719    add the method for improved error recovery.)  */
 720
 721 void
 722 add_method (tree type, tree method, int error_p)
 723 {
 724   int using;
 725   int len;
 726   int slot;
 727   tree method_vec;
 728   int template_conv_p;
 729
 730   if (method == error_mark_node)
 731     return;
 732
 733   using = (DECL_CONTEXT (method) != type);
 734   template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
 735                      && DECL_TEMPLATE_CONV_FN_P (method));
 736
 737   if (!CLASSTYPE_METHOD_VEC (type))
 738     /* Make a new method vector.  We start with 8 entries.  We must
 739        allocate at least two (for constructors and destructors), and
 740        we're going to end up with an assignment operator at some point
 741        as well.
 742
 743        We could use a TREE_LIST for now, and convert it to a TREE_VEC
 744        in finish_struct, but we would probably waste more memory
 745        making the links in the list than we would by over-allocating
 746        the size of the vector here.  Furthermore, we would complicate
 747        all the code that expects this to be a vector.  */
 748     CLASSTYPE_METHOD_VEC (type) = make_tree_vec (8);
 749
 750   method_vec = CLASSTYPE_METHOD_VEC (type);
 751   len = TREE_VEC_LENGTH (method_vec);
 752
 753   /* Constructors and destructors go in special slots.  */
 754   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
 755     slot = CLASSTYPE_CONSTRUCTOR_SLOT;
 756   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
 757     {
 758       slot = CLASSTYPE_DESTRUCTOR_SLOT;
 759       TYPE_HAS_DESTRUCTOR (type) = 1;
 760
 761       if (TYPE_FOR_JAVA (type))
 762         error (DECL_ARTIFICIAL (method)
 763                ? "Java class '%T' cannot have an implicit non-trivial destructor"
 764                : "Java class '%T' cannot have a destructor",
 765                DECL_CONTEXT (method));
 766     }
 767   else
 768     {
 769       int have_template_convs_p = 0;
 770
 771       /* See if we already have an entry with this name.  */
 772       for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot)
 773         {
 774           tree m = TREE_VEC_ELT (method_vec, slot);
 775
 776           if (!m)
 777             break;
 778           m = OVL_CURRENT (m);
 779
 780           if (template_conv_p)
 781             {
 782               have_template_convs_p = (TREE_CODE (m) == TEMPLATE_DECL
 783                                        && DECL_TEMPLATE_CONV_FN_P (m));
 784
 785               /* If we need to move things up, see if there's
 786                  space.  */
 787               if (!have_template_convs_p)
 788                 {
 789                   slot = len - 1;
 790                   if (TREE_VEC_ELT (method_vec, slot))
 791                     slot++;
 792                 }
 793               break;
 794             }
 795           if (DECL_NAME (m) == DECL_NAME (method))
 796             break;
 797         }
 798
 799       if (slot == len)
 800         {
 801           /* We need a bigger method vector.  */
 802           int new_len;
 803           tree new_vec;
 804
 805           /* In the non-error case, we are processing a class
 806              definition.  Double the size of the vector to give room
 807              for new methods.  */
 808           if (!error_p)
 809             new_len = 2 * len;
 810           /* In the error case, the vector is already complete.  We
 811              don't expect many errors, and the rest of the front-end
 812              will get confused if there are empty slots in the vector.  */
 813           else
 814             new_len = len + 1;
 815
 816           new_vec = make_tree_vec (new_len);
 817           memcpy (&TREE_VEC_ELT (new_vec, 0), &TREE_VEC_ELT (method_vec, 0),
 818                   len * sizeof (tree));
 819           len = new_len;
 820           method_vec = CLASSTYPE_METHOD_VEC (type) = new_vec;
 821         }
 822
 823       if (DECL_CONV_FN_P (method) && !TREE_VEC_ELT (method_vec, slot))
 824         {
 825           /* Type conversion operators have to come before ordinary
 826              methods; add_conversions depends on this to speed up
 827              looking for conversion operators.  So, if necessary, we
 828              slide some of the vector elements up.  In theory, this
 829              makes this algorithm O(N^2) but we don't expect many
 830              conversion operators.  */
 831           if (template_conv_p)
 832             slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
 833           else
 834             for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; slot < len; ++slot)
 835               {
 836                 tree fn = TREE_VEC_ELT (method_vec, slot);
 837
 838                 if (!fn)
 839                   /* There are no more entries in the vector, so we
 840                      can insert the new conversion operator here.  */
 841                   break;
 842
 843                 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
 844                   /* We can insert the new function right at the
 845                      SLOTth position.  */
 846                   break;
 847               }
 848
 849           if (template_conv_p && have_template_convs_p)
 850             /*OK*/;
 851           else if (!TREE_VEC_ELT (method_vec, slot))
 852             /* There is nothing in the Ith slot, so we can avoid
 853                moving anything.  */
 854                 ;
 855           else
 856             {
 857               /* We know the last slot in the vector is empty
 858                  because we know that at this point there's room
 859                  for a new function.  */
 860               memmove (&TREE_VEC_ELT (method_vec, slot + 1),
 861                        &TREE_VEC_ELT (method_vec, slot),
 862                        (len - slot - 1) * sizeof (tree));
 863               TREE_VEC_ELT (method_vec, slot) = NULL_TREE;
 864             }
 865         }
 866     }
 867
 868   if (processing_template_decl)
 869     /* TYPE is a template class.  Don't issue any errors now; wait
 870        until instantiation time to complain.  */
 871     ;
 872   else
 873     {
 874       tree fns;
 875
 876       /* Check to see if we've already got this method.  */
 877       for (fns = TREE_VEC_ELT (method_vec, slot);
 878            fns;
 879            fns = OVL_NEXT (fns))
 880         {
 881           tree fn = OVL_CURRENT (fns);
 882           tree fn_type;
 883           tree method_type;
 884           tree parms1;
 885           tree parms2;
 886
 887           if (TREE_CODE (fn) != TREE_CODE (method))
 888             continue;
 889
 890           /* [over.load] Member function declarations with the
 891              same name and the same parameter types cannot be
 892              overloaded if any of them is a static member
 893              function declaration.
 894
 895              [namespace.udecl] When a using-declaration brings names
 896              from a base class into a derived class scope, member
 897              functions in the derived class override and/or hide member
 898              functions with the same name and parameter types in a base
 899              class (rather than conflicting).  */
 900           fn_type = TREE_TYPE (fn);
 901           method_type = TREE_TYPE (method);
 902           parms1 = TYPE_ARG_TYPES (fn_type);
 903           parms2 = TYPE_ARG_TYPES (method_type);
 904
 905           /* Compare the quals on the 'this' parm.  Don't compare
 906              the whole types, as used functions are treated as
 907              coming from the using class in overload resolution.  */
 908           if (! DECL_STATIC_FUNCTION_P (fn)
 909               && ! DECL_STATIC_FUNCTION_P (method)
 910               && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1)))
 911                   != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2)))))
 912             continue;
 913
 914           /* For templates, the template parms must be identical.  */
 915           if (TREE_CODE (fn) == TEMPLATE_DECL
 916               && (!same_type_p (TREE_TYPE (fn_type),
 917                                 TREE_TYPE (method_type))
 918                   || !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
 919                                            DECL_TEMPLATE_PARMS (method))))
 920             continue;
 921
 922           if (! DECL_STATIC_FUNCTION_P (fn))
 923             parms1 = TREE_CHAIN (parms1);
 924           if (! DECL_STATIC_FUNCTION_P (method))
 925             parms2 = TREE_CHAIN (parms2);
 926
 927           if (compparms (parms1, parms2)
 928               && (!DECL_CONV_FN_P (fn)
 929                   || same_type_p (TREE_TYPE (fn_type),
 930                                   TREE_TYPE (method_type))))
 931             {
 932               if (using && DECL_CONTEXT (fn) == type)
 933                 /* Defer to the local function.  */
 934                 return;
 935               else
 936                 {
 937                   cp_error_at ("`%#D' and `%#D' cannot be overloaded",
 938                                method, fn);
 939
 940                   /* We don't call duplicate_decls here to merge
 941                      the declarations because that will confuse
 942                      things if the methods have inline
 943                      definitions.  In particular, we will crash
 944                      while processing the definitions.  */
 945                   return;
 946                 }
 947             }
 948         }
 949     }
 950
 951   /* Actually insert the new method.  */
 952   TREE_VEC_ELT (method_vec, slot)
 953     = build_overload (method, TREE_VEC_ELT (method_vec, slot));
 954
 955   /* Add the new binding.  */
 956   if (!DECL_CONSTRUCTOR_P (method)
 957       && !DECL_DESTRUCTOR_P (method))
 958     push_class_level_binding (DECL_NAME (method),
 959                               TREE_VEC_ELT (method_vec, slot));
 960 }
 961
 962 /* Subroutines of finish_struct.  */
 963
 964 /* Change the access of FDECL to ACCESS in T.  Return 1 if change was
 965    legit, otherwise return 0.  */
 966
 967 static int
 968 alter_access (tree t, tree fdecl, tree access)
 969 {
 970   tree elem;
 971
 972   if (!DECL_LANG_SPECIFIC (fdecl))
 973     retrofit_lang_decl (fdecl);
 974
 975   my_friendly_assert (!DECL_DISCRIMINATOR_P (fdecl), 20030624);
 976
 977   elem = purpose_member (t, DECL_ACCESS (fdecl));
 978   if (elem)
 979     {
 980       if (TREE_VALUE (elem) != access)
 981         {
 982           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
 983             cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
 984           else
 985             error ("conflicting access specifications for field `%s', ignored",
 986                    IDENTIFIER_POINTER (DECL_NAME (fdecl)));
 987         }
 988       else
 989         {
 990           /* They're changing the access to the same thing they changed
 991              it to before.  That's OK.  */
 992           ;
 993         }
 994     }
 995   else
 996     {
 997       perform_or_defer_access_check (TYPE_BINFO (t), fdecl);
 998       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
 999       return 1;
1000     }
1001   return 0;
1002 }
1003
1004 /* Process the USING_DECL, which is a member of T.  */
1005
1006 static void
1007 handle_using_decl (tree using_decl, tree t)
1008 {
1009   tree ctype = DECL_INITIAL (using_decl);
1010   tree name = DECL_NAME (using_decl);
1011   tree access
1012     = TREE_PRIVATE (using_decl) ? access_private_node
1013     : TREE_PROTECTED (using_decl) ? access_protected_node
1014     : access_public_node;
1015   tree fdecl, binfo;
1016   tree flist = NULL_TREE;
1017   tree old_value;
1018
1019   if (ctype == error_mark_node)
1020     return;
1021
1022   binfo = lookup_base (t, ctype, ba_any, NULL);
1023   if (! binfo)
1024     {
1025       location_t saved_loc = input_location;
1026
1027       input_location = DECL_SOURCE_LOCATION (using_decl);
1028       error_not_base_type (ctype, t);
1029       input_location = saved_loc;
1030       return;
1031     }
1032
1033   if (constructor_name_p (name, ctype))
1034     {
1035       cp_error_at ("`%D' names constructor", using_decl);
1036       return;
1037     }
1038   if (constructor_name_p (name, t))
1039     {
1040       cp_error_at ("`%D' invalid in `%T'", using_decl, t);
1041       return;
1042     }
1043
1044   fdecl = lookup_member (binfo, name, 0, false);
1045
1046   if (!fdecl)
1047     {
1048       cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype);
1049       return;
1050     }
1051
1052   if (BASELINK_P (fdecl))
1053     /* Ignore base type this came from.  */
1054     fdecl = BASELINK_FUNCTIONS (fdecl);
1055
1056   old_value = IDENTIFIER_CLASS_VALUE (name);
1057   if (old_value)
1058     {
1059       if (is_overloaded_fn (old_value))
1060         old_value = OVL_CURRENT (old_value);
1061
1062       if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1063         /* OK */;
1064       else
1065         old_value = NULL_TREE;
1066     }
1067
1068   if (is_overloaded_fn (fdecl))
1069     flist = fdecl;
1070
1071   if (! old_value)
1072     ;
1073   else if (is_overloaded_fn (old_value))
1074     {
1075       if (flist)
1076         /* It's OK to use functions from a base when there are functions with
1077            the same name already present in the current class.  */;
1078       else
1079         {
1080           cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1081           cp_error_at ("  because of local method `%#D' with same name",
1082                        OVL_CURRENT (old_value));
1083           return;
1084         }
1085     }
1086   else if (!DECL_ARTIFICIAL (old_value))
1087     {
1088       cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1089       cp_error_at ("  because of local member `%#D' with same name", old_value);
1090       return;
1091     }
1092
1093   /* Make type T see field decl FDECL with access ACCESS.  */
1094   if (flist)
1095     for (; flist; flist = OVL_NEXT (flist))
1096       {
1097         add_method (t, OVL_CURRENT (flist), /*error_p=*/0);
1098         alter_access (t, OVL_CURRENT (flist), access);
1099       }
1100   else
1101     alter_access (t, fdecl, access);
1102 }
1103 \f
1104 /* Run through the base clases of T, updating
1105    CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1106    NO_CONST_ASN_REF_P.  Also set flag bits in T based on properties of
1107    the bases.  */
1108
1109 static void
1110 check_bases (tree t,
1111              int* cant_have_default_ctor_p,
1112              int* cant_have_const_ctor_p,
1113              int* no_const_asn_ref_p)
1114 {
1115   int n_baseclasses;
1116   int i;
1117   int seen_non_virtual_nearly_empty_base_p;
1118   tree binfos;
1119
1120   binfos = TYPE_BINFO_BASETYPES (t);
1121   n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1122   seen_non_virtual_nearly_empty_base_p = 0;
1123
1124   /* An aggregate cannot have baseclasses.  */
1125   CLASSTYPE_NON_AGGREGATE (t) |= (n_baseclasses != 0);
1126
1127   for (i = 0; i < n_baseclasses; ++i)
1128     {
1129       tree base_binfo;
1130       tree basetype;
1131
1132       /* Figure out what base we're looking at.  */
1133       base_binfo = TREE_VEC_ELT (binfos, i);
1134       basetype = TREE_TYPE (base_binfo);
1135
1136       /* If the type of basetype is incomplete, then we already
1137          complained about that fact (and we should have fixed it up as
1138          well).  */
1139       if (!COMPLETE_TYPE_P (basetype))
1140         {
1141           int j;
1142           /* The base type is of incomplete type.  It is
1143              probably best to pretend that it does not
1144              exist.  */
1145           if (i == n_baseclasses-1)
1146             TREE_VEC_ELT (binfos, i) = NULL_TREE;
1147           TREE_VEC_LENGTH (binfos) -= 1;
1148           n_baseclasses -= 1;
1149           for (j = i; j+1 < n_baseclasses; j++)
1150             TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1151           continue;
1152         }
1153
1154       /* Effective C++ rule 14.  We only need to check TYPE_POLYMORPHIC_P
1155          here because the case of virtual functions but non-virtual
1156          dtor is handled in finish_struct_1.  */
1157       if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype)
1158           && TYPE_HAS_DESTRUCTOR (basetype))
1159         warning ("base class `%#T' has a non-virtual destructor",
1160                     basetype);
1161
1162       /* If the base class doesn't have copy constructors or
1163          assignment operators that take const references, then the
1164          derived class cannot have such a member automatically
1165          generated.  */
1166       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1167         *cant_have_const_ctor_p = 1;
1168       if (TYPE_HAS_ASSIGN_REF (basetype)
1169           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1170         *no_const_asn_ref_p = 1;
1171       /* Similarly, if the base class doesn't have a default
1172          constructor, then the derived class won't have an
1173          automatically generated default constructor.  */
1174       if (TYPE_HAS_CONSTRUCTOR (basetype)
1175           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1176         {
1177           *cant_have_default_ctor_p = 1;
1178           if (! TYPE_HAS_CONSTRUCTOR (t))
1179             pedwarn ("base `%T' with only non-default constructor in class without a constructor",
1180                         basetype);
1181         }
1182
1183       if (TREE_VIA_VIRTUAL (base_binfo))
1184         /* A virtual base does not effect nearly emptiness.  */
1185         ;
1186       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1187         {
1188           if (seen_non_virtual_nearly_empty_base_p)
1189             /* And if there is more than one nearly empty base, then the
1190                derived class is not nearly empty either.  */
1191             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1192           else
1193             /* Remember we've seen one.  */
1194             seen_non_virtual_nearly_empty_base_p = 1;
1195         }
1196       else if (!is_empty_class (basetype))
1197         /* If the base class is not empty or nearly empty, then this
1198            class cannot be nearly empty.  */
1199         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1200
1201       /* A lot of properties from the bases also apply to the derived
1202          class.  */
1203       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1204       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1205         |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1206       TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1207         |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1208       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1209       TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1210       CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1211         |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1212     }
1213 }
1214
1215 /* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy
1216    dominated by TYPE that are primary bases.  */
1217
1218 static void
1219 mark_primary_bases (tree type)
1220 {
1221   tree binfo;
1222
1223   /* Walk the bases in inheritance graph order.  */
1224   for (binfo = TYPE_BINFO (type); binfo; binfo = TREE_CHAIN (binfo))
1225     {
1226       tree base_binfo = get_primary_binfo (binfo);
1227
1228       if (!base_binfo)
1229         /* Not a dynamic base.  */;
1230       else if (BINFO_PRIMARY_P (base_binfo))
1231         BINFO_LOST_PRIMARY_P (binfo) = 1;
1232       else
1233         {
1234           BINFO_PRIMARY_BASE_OF (base_binfo) = binfo;
1235           /* A virtual binfo might have been copied from within
1236              another hierarchy. As we're about to use it as a primary
1237              base, make sure the offsets match.  */
1238           if (TREE_VIA_VIRTUAL (base_binfo))
1239             {
1240               tree delta = size_diffop (convert (ssizetype,
1241                                                  BINFO_OFFSET (binfo)),
1242                                         convert (ssizetype,
1243                                                  BINFO_OFFSET (base_binfo)));
1244
1245               propagate_binfo_offsets (base_binfo, delta);
1246             }
1247         }
1248     }
1249 }
1250
1251 /* Make the BINFO the primary base of T.  */
1252
1253 static void
1254 set_primary_base (tree t, tree binfo)
1255 {
1256   tree basetype;
1257
1258   CLASSTYPE_PRIMARY_BINFO (t) = binfo;
1259   basetype = BINFO_TYPE (binfo);
1260   TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1261   TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1262   TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1263 }
1264
1265 /* Determine the primary class for T.  */
1266
1267 static void
1268 determine_primary_base (tree t)
1269 {
1270   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1271   tree vbases;
1272   tree type_binfo;
1273
1274   /* If there are no baseclasses, there is certainly no primary base.  */
1275   if (n_baseclasses == 0)
1276     return;
1277
1278   type_binfo = TYPE_BINFO (t);
1279
1280   for (i = 0; i < n_baseclasses; i++)
1281     {
1282       tree base_binfo = BINFO_BASETYPE (type_binfo, i);
1283       tree basetype = BINFO_TYPE (base_binfo);
1284
1285       if (TYPE_CONTAINS_VPTR_P (basetype))
1286         {
1287           /* We prefer a non-virtual base, although a virtual one will
1288              do.  */
1289           if (TREE_VIA_VIRTUAL (base_binfo))
1290             continue;
1291
1292           if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1293             {
1294               set_primary_base (t, base_binfo);
1295               CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype));
1296             }
1297           else
1298             {
1299               tree vfields;
1300
1301               /* Only add unique vfields, and flatten them out as we go.  */
1302               for (vfields = CLASSTYPE_VFIELDS (basetype);
1303                    vfields;
1304                    vfields = TREE_CHAIN (vfields))
1305                 if (VF_BINFO_VALUE (vfields) == NULL_TREE
1306                     || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1307                   CLASSTYPE_VFIELDS (t)
1308                     = tree_cons (base_binfo,
1309                                  VF_BASETYPE_VALUE (vfields),
1310                                  CLASSTYPE_VFIELDS (t));
1311             }
1312         }
1313     }
1314
1315   if (!TYPE_VFIELD (t))
1316     CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
1317
1318   /* Find the indirect primary bases - those virtual bases which are primary
1319      bases of something else in this hierarchy.  */
1320   for (vbases = CLASSTYPE_VBASECLASSES (t);
1321        vbases;
1322        vbases = TREE_CHAIN (vbases))
1323     {
1324       tree vbase_binfo = TREE_VALUE (vbases);
1325
1326       /* See if this virtual base is an indirect primary base.  To be so,
1327          it must be a primary base within the hierarchy of one of our
1328          direct bases.  */
1329       for (i = 0; i < n_baseclasses; ++i)
1330         {
1331           tree basetype = TYPE_BINFO_BASETYPE (t, i);
1332           tree v;
1333
1334           for (v = CLASSTYPE_VBASECLASSES (basetype);
1335                v;
1336                v = TREE_CHAIN (v))
1337             {
1338               tree base_vbase = TREE_VALUE (v);
1339
1340               if (BINFO_PRIMARY_P (base_vbase)
1341                   && same_type_p (BINFO_TYPE (base_vbase),
1342                                   BINFO_TYPE (vbase_binfo)))
1343                 {
1344                   BINFO_INDIRECT_PRIMARY_P (vbase_binfo) = 1;
1345                   break;
1346                 }
1347             }
1348
1349           /* If we've discovered that this virtual base is an indirect
1350              primary base, then we can move on to the next virtual
1351              base.  */
1352           if (BINFO_INDIRECT_PRIMARY_P (vbase_binfo))
1353             break;
1354         }
1355     }
1356
1357   /* A "nearly-empty" virtual base class can be the primary base
1358      class, if no non-virtual polymorphic base can be found.  */
1359   if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1360     {
1361       /* If not NULL, this is the best primary base candidate we have
1362          found so far.  */
1363       tree candidate = NULL_TREE;
1364       tree base_binfo;
1365
1366       /* Loop over the baseclasses.  */
1367       for (base_binfo = TYPE_BINFO (t);
1368            base_binfo;
1369            base_binfo = TREE_CHAIN (base_binfo))
1370         {
1371           tree basetype = BINFO_TYPE (base_binfo);
1372
1373           if (TREE_VIA_VIRTUAL (base_binfo)
1374               && CLASSTYPE_NEARLY_EMPTY_P (basetype))
1375             {
1376               /* If this is not an indirect primary base, then it's
1377                  definitely our primary base.  */
1378               if (!BINFO_INDIRECT_PRIMARY_P (base_binfo))
1379                 {
1380                   candidate = base_binfo;
1381                   break;
1382                 }
1383
1384               /* If this is an indirect primary base, it still could be
1385                  our primary base -- unless we later find there's another
1386                  nearly-empty virtual base that isn't an indirect
1387                  primary base.  */
1388               if (!candidate)
1389                 candidate = base_binfo;
1390             }
1391         }
1392
1393       /* If we've got a primary base, use it.  */
1394       if (candidate)
1395         {
1396           set_primary_base (t, candidate);
1397           CLASSTYPE_VFIELDS (t)
1398             = copy_list (CLASSTYPE_VFIELDS (BINFO_TYPE (candidate)));
1399         }
1400     }
1401
1402   /* Mark the primary base classes at this point.  */
1403   mark_primary_bases (t);
1404 }
1405 \f
1406 /* Set memoizing fields and bits of T (and its variants) for later
1407    use.  */
1408
1409 static void
1410 finish_struct_bits (tree t)
1411 {
1412   int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1413
1414   /* Fix up variants (if any).  */
1415   tree variants = TYPE_NEXT_VARIANT (t);
1416   while (variants)
1417     {
1418       /* These fields are in the _TYPE part of the node, not in
1419          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1420       TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1421       TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1422       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1423       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1424         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1425
1426       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants)
1427         = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t);
1428       TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1429       TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1430       /* Copy whatever these are holding today.  */
1431       TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1432       TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1433       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1434       TYPE_SIZE (variants) = TYPE_SIZE (t);
1435       TYPE_SIZE_UNIT (variants) = TYPE_SIZE_UNIT (t);
1436       variants = TYPE_NEXT_VARIANT (variants);
1437     }
1438
1439   if (n_baseclasses && TYPE_POLYMORPHIC_P (t))
1440     /* For a class w/o baseclasses, `finish_struct' has set
1441        CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
1442        definition). Similarly for a class whose base classes do not
1443        have vtables. When neither of these is true, we might have
1444        removed abstract virtuals (by providing a definition), added
1445        some (by declaring new ones), or redeclared ones from a base
1446        class. We need to recalculate what's really an abstract virtual
1447        at this point (by looking in the vtables).  */
1448       get_pure_virtuals (t);
1449
1450   if (n_baseclasses)
1451     {
1452       /* Notice whether this class has type conversion functions defined.  */
1453       tree binfo = TYPE_BINFO (t);
1454       tree binfos = BINFO_BASETYPES (binfo);
1455       tree basetype;
1456
1457       for (i = n_baseclasses-1; i >= 0; i--)
1458         {
1459           basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1460
1461           TYPE_HAS_CONVERSION (t) |= TYPE_HAS_CONVERSION (basetype);
1462         }
1463     }
1464
1465   /* If this type has a copy constructor or a destructor, force its mode to
1466      be BLKmode, and force its TREE_ADDRESSABLE bit to be nonzero.  This
1467      will cause it to be passed by invisible reference and prevent it from
1468      being returned in a register.  */
1469   if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1470     {
1471       tree variants;
1472       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1473       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1474         {
1475           TYPE_MODE (variants) = BLKmode;
1476           TREE_ADDRESSABLE (variants) = 1;
1477         }
1478     }
1479 }
1480
1481 /* Issue warnings about T having private constructors, but no friends,
1482    and so forth.
1483
1484    HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1485    static members.  HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1486    non-private static member functions.  */
1487
1488 static void
1489 maybe_warn_about_overly_private_class (tree t)
1490 {
1491   int has_member_fn = 0;
1492   int has_nonprivate_method = 0;
1493   tree fn;
1494
1495   if (!warn_ctor_dtor_privacy
1496       /* If the class has friends, those entities might create and
1497          access instances, so we should not warn.  */
1498       || (CLASSTYPE_FRIEND_CLASSES (t)
1499           || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1500       /* We will have warned when the template was declared; there's
1501          no need to warn on every instantiation.  */
1502       || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1503     /* There's no reason to even consider warning about this
1504        class.  */
1505     return;
1506
1507   /* We only issue one warning, if more than one applies, because
1508      otherwise, on code like:
1509
1510      class A {
1511        // Oops - forgot `public:'
1512        A();
1513        A(const A&);
1514        ~A();
1515      };
1516
1517      we warn several times about essentially the same problem.  */
1518
1519   /* Check to see if all (non-constructor, non-destructor) member
1520      functions are private.  (Since there are no friends or
1521      non-private statics, we can't ever call any of the private member
1522      functions.)  */
1523   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1524     /* We're not interested in compiler-generated methods; they don't
1525        provide any way to call private members.  */
1526     if (!DECL_ARTIFICIAL (fn))
1527       {
1528         if (!TREE_PRIVATE (fn))
1529           {
1530             if (DECL_STATIC_FUNCTION_P (fn))
1531               /* A non-private static member function is just like a
1532                  friend; it can create and invoke private member
1533                  functions, and be accessed without a class
1534                  instance.  */
1535               return;
1536
1537             has_nonprivate_method = 1;
1538             /* Keep searching for a static member function.  */
1539           }
1540         else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1541           has_member_fn = 1;
1542       }
1543
1544   if (!has_nonprivate_method && has_member_fn)
1545     {
1546       /* There are no non-private methods, and there's at least one
1547          private member function that isn't a constructor or
1548          destructor.  (If all the private members are
1549          constructors/destructors we want to use the code below that
1550          issues error messages specifically referring to
1551          constructors/destructors.)  */
1552       int i;
1553       tree binfo = TYPE_BINFO (t);
1554
1555       for (i = 0; i < BINFO_N_BASETYPES (binfo); i++)
1556         if (BINFO_BASEACCESS (binfo, i) != access_private_node)
1557           {
1558             has_nonprivate_method = 1;
1559             break;
1560           }
1561       if (!has_nonprivate_method)
1562         {
1563           warning ("all member functions in class `%T' are private", t);
1564           return;
1565         }
1566     }
1567
1568   /* Even if some of the member functions are non-private, the class
1569      won't be useful for much if all the constructors or destructors
1570      are private: such an object can never be created or destroyed.  */
1571   if (TYPE_HAS_DESTRUCTOR (t)
1572       && TREE_PRIVATE (CLASSTYPE_DESTRUCTORS (t)))
1573     {
1574       warning ("`%#T' only defines a private destructor and has no friends",
1575                t);
1576       return;
1577     }
1578
1579   if (TYPE_HAS_CONSTRUCTOR (t))
1580     {
1581       int nonprivate_ctor = 0;
1582
1583       /* If a non-template class does not define a copy
1584          constructor, one is defined for it, enabling it to avoid
1585          this warning.  For a template class, this does not
1586          happen, and so we would normally get a warning on:
1587
1588            template <class T> class C { private: C(); };
1589
1590          To avoid this asymmetry, we check TYPE_HAS_INIT_REF.  All
1591          complete non-template or fully instantiated classes have this
1592          flag set.  */
1593       if (!TYPE_HAS_INIT_REF (t))
1594         nonprivate_ctor = 1;
1595       else
1596         for (fn = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0);
1597              fn;
1598              fn = OVL_NEXT (fn))
1599           {
1600             tree ctor = OVL_CURRENT (fn);
1601             /* Ideally, we wouldn't count copy constructors (or, in
1602                fact, any constructor that takes an argument of the
1603                class type as a parameter) because such things cannot
1604                be used to construct an instance of the class unless
1605                you already have one.  But, for now at least, we're
1606                more generous.  */
1607             if (! TREE_PRIVATE (ctor))
1608               {
1609                 nonprivate_ctor = 1;
1610                 break;
1611               }
1612           }
1613
1614       if (nonprivate_ctor == 0)
1615         {
1616           warning ("`%#T' only defines private constructors and has no friends",
1617                       t);
1618           return;
1619         }
1620     }
1621 }
1622
1623 static struct {
1624   gt_pointer_operator new_value;
1625   void *cookie;
1626 } resort_data;
1627
1628 /* Comparison function to compare two TYPE_METHOD_VEC entries by name.  */
1629
1630 static int
1631 method_name_cmp (const void* m1_p, const void* m2_p)
1632 {
1633   const tree *const m1 = m1_p;
1634   const tree *const m2 = m2_p;
1635
1636   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1637     return 0;
1638   if (*m1 == NULL_TREE)
1639     return -1;
1640   if (*m2 == NULL_TREE)
1641     return 1;
1642   if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1643     return -1;
1644   return 1;
1645 }
1646
1647 /* This routine compares two fields like method_name_cmp but using the
1648    pointer operator in resort_field_decl_data.  */
1649
1650 static int
1651 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1652 {
1653   const tree *const m1 = m1_p;
1654   const tree *const m2 = m2_p;
1655   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1656     return 0;
1657   if (*m1 == NULL_TREE)
1658     return -1;
1659   if (*m2 == NULL_TREE)
1660     return 1;
1661   {
1662     tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1663     tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1664     resort_data.new_value (&d1, resort_data.cookie);
1665     resort_data.new_value (&d2, resort_data.cookie);
1666     if (d1 < d2)
1667       return -1;
1668   }
1669   return 1;
1670 }
1671
1672 /* Resort TYPE_METHOD_VEC because pointers have been reordered.  */
1673
1674 void
1675 resort_type_method_vec (void* obj,
1676                         void* orig_obj ATTRIBUTE_UNUSED ,
1677                         gt_pointer_operator new_value,
1678                         void* cookie)
1679 {
1680   tree method_vec = obj;
1681   int len = TREE_VEC_LENGTH (method_vec);
1682   int slot;
1683
1684   /* The type conversion ops have to live at the front of the vec, so we
1685      can't sort them.  */
1686   for (slot = 2; slot < len; ++slot)
1687     {
1688       tree fn = TREE_VEC_ELT (method_vec, slot);
1689
1690       if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1691         break;
1692     }
1693   if (len - slot > 1)
1694     {
1695       resort_data.new_value = new_value;
1696       resort_data.cookie = cookie;
1697       qsort (&TREE_VEC_ELT (method_vec, slot), len - slot, sizeof (tree),
1698              resort_method_name_cmp);
1699     }
1700 }
1701
1702 /* Warn about duplicate methods in fn_fields.  Also compact method
1703    lists so that lookup can be made faster.
1704
1705    Data Structure: List of method lists.  The outer list is a
1706    TREE_LIST, whose TREE_PURPOSE field is the field name and the
1707    TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs.  TREE_CHAIN
1708    links the entire list of methods for TYPE_METHODS.  Friends are
1709    chained in the same way as member functions (? TREE_CHAIN or
1710    DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1711    list.  That allows them to be quickly deleted, and requires no
1712    extra storage.
1713
1714    Sort methods that are not special (i.e., constructors, destructors,
1715    and type conversion operators) so that we can find them faster in
1716    search.  */
1717
1718 static void
1719 finish_struct_methods (tree t)
1720 {
1721   tree fn_fields;
1722   tree method_vec;
1723   int slot, len;
1724
1725   if (!TYPE_METHODS (t))
1726     {
1727       /* Clear these for safety; perhaps some parsing error could set
1728          these incorrectly.  */
1729       TYPE_HAS_CONSTRUCTOR (t) = 0;
1730       TYPE_HAS_DESTRUCTOR (t) = 0;
1731       CLASSTYPE_METHOD_VEC (t) = NULL_TREE;
1732       return;
1733     }
1734
1735   method_vec = CLASSTYPE_METHOD_VEC (t);
1736   my_friendly_assert (method_vec != NULL_TREE, 19991215);
1737   len = TREE_VEC_LENGTH (method_vec);
1738
1739   /* First fill in entry 0 with the constructors, entry 1 with destructors,
1740      and the next few with type conversion operators (if any).  */
1741   for (fn_fields = TYPE_METHODS (t); fn_fields;
1742        fn_fields = TREE_CHAIN (fn_fields))
1743     /* Clear out this flag.  */
1744     DECL_IN_AGGR_P (fn_fields) = 0;
1745
1746   if (TYPE_HAS_DESTRUCTOR (t) && !CLASSTYPE_DESTRUCTORS (t))
1747     /* We thought there was a destructor, but there wasn't.  Some
1748        parse errors cause this anomalous situation.  */
1749     TYPE_HAS_DESTRUCTOR (t) = 0;
1750
1751   /* Issue warnings about private constructors and such.  If there are
1752      no methods, then some public defaults are generated.  */
1753   maybe_warn_about_overly_private_class (t);
1754
1755   /* Now sort the methods.  */
1756   while (len > 2 && TREE_VEC_ELT (method_vec, len-1) == NULL_TREE)
1757     len--;
1758   TREE_VEC_LENGTH (method_vec) = len;
1759
1760   /* The type conversion ops have to live at the front of the vec, so we
1761      can't sort them.  */
1762   for (slot = 2; slot < len; ++slot)
1763     {
1764       tree fn = TREE_VEC_ELT (method_vec, slot);
1765
1766       if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1767         break;
1768     }
1769   if (len - slot > 1)
1770     qsort (&TREE_VEC_ELT (method_vec, slot), len-slot, sizeof (tree),
1771            method_name_cmp);
1772 }
1773
1774 /* Make BINFO's vtable have N entries, including RTTI entries,
1775    vbase and vcall offsets, etc.  Set its type and call the backend
1776    to lay it out.  */
1777
1778 static void
1779 layout_vtable_decl (tree binfo, int n)
1780 {
1781   tree atype;
1782   tree vtable;
1783
1784   atype = build_cplus_array_type (vtable_entry_type,
1785                                   build_index_type (size_int (n - 1)));
1786   layout_type (atype);
1787
1788   /* We may have to grow the vtable.  */
1789   vtable = get_vtbl_decl_for_binfo (binfo);
1790   if (!same_type_p (TREE_TYPE (vtable), atype))
1791     {
1792       TREE_TYPE (vtable) = atype;
1793       DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1794       layout_decl (vtable, 0);
1795     }
1796 }
1797
1798 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1799    have the same signature.  */
1800
1801 int
1802 same_signature_p (tree fndecl, tree base_fndecl)
1803 {
1804   /* One destructor overrides another if they are the same kind of
1805      destructor.  */
1806   if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1807       && special_function_p (base_fndecl) == special_function_p (fndecl))
1808     return 1;
1809   /* But a non-destructor never overrides a destructor, nor vice
1810      versa, nor do different kinds of destructors override
1811      one-another.  For example, a complete object destructor does not
1812      override a deleting destructor.  */
1813   if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1814     return 0;
1815
1816   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1817       || (DECL_CONV_FN_P (fndecl)
1818           && DECL_CONV_FN_P (base_fndecl)
1819           && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1820                           DECL_CONV_FN_TYPE (base_fndecl))))
1821     {
1822       tree types, base_types;
1823       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1824       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1825       if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
1826            == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
1827           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1828         return 1;
1829     }
1830   return 0;
1831 }
1832
1833 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1834    subobject.  */
1835
1836 static bool
1837 base_derived_from (tree derived, tree base)
1838 {
1839   tree probe;
1840
1841   for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1842     {
1843       if (probe == derived)
1844         return true;
1845       else if (TREE_VIA_VIRTUAL (probe))
1846         /* If we meet a virtual base, we can't follow the inheritance
1847            any more.  See if the complete type of DERIVED contains
1848            such a virtual base.  */
1849         return purpose_member (BINFO_TYPE (probe),
1850                                CLASSTYPE_VBASECLASSES (BINFO_TYPE (derived)))
1851           != NULL_TREE;
1852     }
1853   return false;
1854 }
1855
1856 typedef struct count_depth_data {
1857   /* The depth of the current subobject, with "1" as the depth of the
1858      most derived object in the hierarchy.  */
1859   size_t depth;
1860   /* The maximum depth found so far.  */
1861   size_t max_depth;
1862 } count_depth_data;
1863
1864 /* Called from find_final_overrider via dfs_walk.  */
1865
1866 static tree
1867 dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1868 {
1869   count_depth_data *cd = (count_depth_data *) data;
1870   if (cd->depth > cd->max_depth)
1871     cd->max_depth = cd->depth;
1872   cd->depth--;
1873   return NULL_TREE;
1874 }
1875
1876 /* Called from find_final_overrider via dfs_walk.  */
1877
1878 static tree
1879 dfs_depth_q (tree derived, int i, void *data)
1880 {
1881   count_depth_data *cd = (count_depth_data *) data;
1882   cd->depth++;
1883   return BINFO_BASETYPE (derived, i);
1884 }
1885
1886 typedef struct find_final_overrider_data_s {
1887   /* The function for which we are trying to find a final overrider.  */
1888   tree fn;
1889   /* The base class in which the function was declared.  */
1890   tree declaring_base;
1891   /* The most derived class in the hierarchy.  */
1892   tree most_derived_type;
1893   /* The candidate overriders.  */
1894   tree candidates;
1895   /* Each entry in this array is the next-most-derived class for a
1896      virtual base class along the current path.  */
1897   tree *vpath_list;
1898   /* A pointer one past the top of the VPATH_LIST.  */
1899   tree *vpath;
1900 } find_final_overrider_data;
1901
1902 /* Add the overrider along the current path to FFOD->CANDIDATES.
1903    Returns true if an overrider was found; false otherwise.  */
1904
1905 static bool
1906 dfs_find_final_overrider_1 (tree binfo,
1907                             tree *vpath,
1908                             find_final_overrider_data *ffod)
1909 {
1910   tree method;
1911
1912   /* If BINFO is not the most derived type, try a more derived class.
1913      A definition there will overrider a definition here.  */
1914   if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type))
1915     {
1916       tree derived;
1917
1918       if (TREE_VIA_VIRTUAL (binfo))
1919         derived = *--vpath;
1920       else
1921         derived = BINFO_INHERITANCE_CHAIN (binfo);
1922       if (dfs_find_final_overrider_1 (derived, vpath, ffod))
1923         return true;
1924     }
1925
1926   method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1927   if (method)
1928     {
1929       tree *candidate = &ffod->candidates;
1930
1931       /* Remove any candidates overridden by this new function.  */
1932       while (*candidate)
1933         {
1934           /* If *CANDIDATE overrides METHOD, then METHOD
1935              cannot override anything else on the list.  */
1936           if (base_derived_from (TREE_VALUE (*candidate), binfo))
1937             return true;
1938           /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
1939           if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1940             *candidate = TREE_CHAIN (*candidate);
1941           else
1942             candidate = &TREE_CHAIN (*candidate);
1943         }
1944
1945       /* Add the new function.  */
1946       ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1947       return true;
1948     }
1949
1950   return false;
1951 }
1952
1953 /* Called from find_final_overrider via dfs_walk.  */
1954
1955 static tree
1956 dfs_find_final_overrider (tree binfo, void* data)
1957 {
1958   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1959
1960   if (binfo == ffod->declaring_base)
1961     dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod);
1962
1963   return NULL_TREE;
1964 }
1965
1966 static tree
1967 dfs_find_final_overrider_q (tree derived, int ix, void *data)
1968 {
1969   tree binfo = BINFO_BASETYPE (derived, ix);
1970   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1971
1972   if (TREE_VIA_VIRTUAL (binfo))
1973     *ffod->vpath++ = derived;
1974
1975   return binfo;
1976 }
1977
1978 static tree
1979 dfs_find_final_overrider_post (tree binfo, void *data)
1980 {
1981   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1982
1983   if (TREE_VIA_VIRTUAL (binfo))
1984     ffod->vpath--;
1985
1986   return NULL_TREE;
1987 }
1988
1989 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1990    FN and whose TREE_VALUE is the binfo for the base where the
1991    overriding occurs.  BINFO (in the hierarchy dominated by the binfo
1992    DERIVED) is the base object in which FN is declared.  */
1993
1994 static tree
1995 find_final_overrider (tree derived, tree binfo, tree fn)
1996 {
1997   find_final_overrider_data ffod;
1998   count_depth_data cd;
1999
2000   /* Getting this right is a little tricky.  This is valid:
2001
2002        struct S { virtual void f (); };
2003        struct T { virtual void f (); };
2004        struct U : public S, public T { };
2005
2006      even though calling `f' in `U' is ambiguous.  But,
2007
2008        struct R { virtual void f(); };
2009        struct S : virtual public R { virtual void f (); };
2010        struct T : virtual public R { virtual void f (); };
2011        struct U : public S, public T { };
2012
2013      is not -- there's no way to decide whether to put `S::f' or
2014      `T::f' in the vtable for `R'.
2015
2016      The solution is to look at all paths to BINFO.  If we find
2017      different overriders along any two, then there is a problem.  */
2018   if (DECL_THUNK_P (fn))
2019     fn = THUNK_TARGET (fn);
2020
2021   /* Determine the depth of the hierarchy.  */
2022   cd.depth = 0;
2023   cd.max_depth = 0;
2024   dfs_walk (derived, dfs_depth_post, dfs_depth_q, &cd);
2025
2026   ffod.fn = fn;
2027   ffod.declaring_base = binfo;
2028   ffod.most_derived_type = BINFO_TYPE (derived);
2029   ffod.candidates = NULL_TREE;
2030   ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree));
2031   ffod.vpath = ffod.vpath_list;
2032
2033   dfs_walk_real (derived,
2034                  dfs_find_final_overrider,
2035                  dfs_find_final_overrider_post,
2036                  dfs_find_final_overrider_q,
2037                  &ffod);
2038
2039   free (ffod.vpath_list);
2040
2041   /* If there was no winner, issue an error message.  */
2042   if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2043     return error_mark_node;
2044
2045   return ffod.candidates;
2046 }
2047
2048 /* Return the index of the vcall offset for FN when TYPE is used as a
2049    virtual base.  */
2050
2051 static tree
2052 get_vcall_index (tree fn, tree type)
2053 {
2054   tree v;
2055
2056   for (v = CLASSTYPE_VCALL_INDICES (type); v; v = TREE_CHAIN (v))
2057     if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (TREE_PURPOSE (v)))
2058         || same_signature_p (fn, TREE_PURPOSE (v)))
2059       break;
2060
2061   /* There should always be an appropriate index.  */
2062   my_friendly_assert (v, 20021103);
2063
2064   return TREE_VALUE (v);
2065 }
2066
2067 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2068    dominated by T.  FN has been overridden in BINFO; VIRTUALS points to the
2069    corresponding position in the BINFO_VIRTUALS list.  */
2070
2071 static void
2072 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2073                             unsigned ix)
2074 {
2075   tree b;
2076   tree overrider;
2077   tree delta;
2078   tree virtual_base;
2079   tree first_defn;
2080   tree overrider_fn, overrider_target;
2081   tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2082   tree over_return, base_return;
2083   bool lost = false;
2084
2085   /* Find the nearest primary base (possibly binfo itself) which defines
2086      this function; this is the class the caller will convert to when
2087      calling FN through BINFO.  */
2088   for (b = binfo; ; b = get_primary_binfo (b))
2089     {
2090       my_friendly_assert (b, 20021227);
2091       if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2092         break;
2093
2094       /* The nearest definition is from a lost primary.  */
2095       if (BINFO_LOST_PRIMARY_P (b))
2096         lost = true;
2097     }
2098   first_defn = b;
2099
2100   /* Find the final overrider.  */
2101   overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2102   if (overrider == error_mark_node)
2103     {
2104       error ("no unique final overrider for `%D' in `%T'", target_fn, t);
2105       return;
2106     }
2107   overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2108
2109   /* Check for adjusting covariant return types.  */
2110   over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2111   base_return = TREE_TYPE (TREE_TYPE (target_fn));
2112
2113   if (POINTER_TYPE_P (over_return)
2114       && TREE_CODE (over_return) == TREE_CODE (base_return)
2115       && CLASS_TYPE_P (TREE_TYPE (over_return))
2116       && CLASS_TYPE_P (TREE_TYPE (base_return)))
2117     {
2118       /* If FN is a covariant thunk, we must figure out the adjustment
2119          to the final base FN was converting to. As OVERRIDER_TARGET might
2120          also be converting to the return type of FN, we have to
2121          combine the two conversions here.  */
2122       tree fixed_offset, virtual_offset;
2123
2124       over_return = TREE_TYPE (over_return);
2125       base_return = TREE_TYPE (base_return);
2126
2127       if (DECL_THUNK_P (fn))
2128         {
2129           my_friendly_assert (DECL_RESULT_THUNK_P (fn), 20031211);
2130           fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2131           virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2132         }
2133       else
2134         fixed_offset = virtual_offset = NULL_TREE;
2135
2136       if (virtual_offset)
2137         /* Find the equivalent binfo within the return type of the
2138            overriding function. We will want the vbase offset from
2139            there.  */
2140         virtual_offset =
2141           TREE_VALUE (purpose_member
2142                       (BINFO_TYPE (virtual_offset),
2143                        CLASSTYPE_VBASECLASSES (over_return)));
2144       else if (!same_type_ignoring_top_level_qualifiers_p
2145                (over_return, base_return))
2146         {
2147           /* There was no existing virtual thunk (which takes
2148              precedence).  So find the binfo of the base function's
2149              return type within the overriding function's return type.
2150              We cannot call lookup base here, because we're inside a
2151              dfs_walk, and will therefore clobber the BINFO_MARKED
2152              flags.  Fortunately we know the covariancy is valid (it
2153              has already been checked), so we can just iterate along
2154              the binfos, which have been chained in inheritance graph
2155              order.  Of course it is lame that we have to repeat the
2156              search here anyway -- we should really be caching pieces
2157              of the vtable and avoiding this repeated work.  */
2158           tree thunk_binfo, base_binfo;
2159
2160           /* Find the base binfo within the overriding function's
2161              return type.  We will always find a thunk_binfo, except
2162              when the covariancy is invalid (which we will have
2163              already diagnosed).  */
2164           for (base_binfo = TYPE_BINFO (base_return),
2165                thunk_binfo = TYPE_BINFO (over_return);
2166                thunk_binfo;
2167                thunk_binfo = TREE_CHAIN (thunk_binfo))
2168             if (same_type_p (BINFO_TYPE (thunk_binfo),
2169                              BINFO_TYPE (base_binfo)))
2170               break;
2171
2172           /* See if virtual inheritance is involved.  */
2173           for (virtual_offset = thunk_binfo;
2174                virtual_offset;
2175                virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2176             if (TREE_VIA_VIRTUAL (virtual_offset))
2177               break;
2178
2179           if (virtual_offset
2180               || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2181             {
2182               tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2183
2184               if (virtual_offset)
2185                 {
2186                   /* We convert via virtual base.  Adjust the fixed
2187                      offset to be from there.  */
2188                   offset = size_diffop
2189                     (offset, convert
2190                      (ssizetype, BINFO_OFFSET (virtual_offset)));
2191                 }
2192               if (fixed_offset)
2193                 /* There was an existing fixed offset, this must be
2194                    from the base just converted to, and the base the
2195                    FN was thunking to.  */
2196                 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2197               else
2198                 fixed_offset = offset;
2199             }
2200         }
2201
2202       if (fixed_offset || virtual_offset)
2203         /* Replace the overriding function with a covariant thunk.  We
2204            will emit the overriding function in its own slot as
2205            well.  */
2206         overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2207                                    fixed_offset, virtual_offset);
2208     }
2209   else
2210     my_friendly_assert (!DECL_THUNK_P (fn), 20021231);
2211
2212   /* Assume that we will produce a thunk that convert all the way to
2213      the final overrider, and not to an intermediate virtual base.  */
2214   virtual_base = NULL_TREE;
2215
2216   /* See if we can convert to an intermediate virtual base first, and then
2217      use the vcall offset located there to finish the conversion.  */
2218   for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2219     {
2220       /* If we find the final overrider, then we can stop
2221          walking.  */
2222       if (same_type_p (BINFO_TYPE (b),
2223                        BINFO_TYPE (TREE_VALUE (overrider))))
2224         break;
2225
2226       /* If we find a virtual base, and we haven't yet found the
2227          overrider, then there is a virtual base between the
2228          declaring base (first_defn) and the final overrider.  */
2229       if (TREE_VIA_VIRTUAL (b))
2230         {
2231           virtual_base = b;
2232           break;
2233         }
2234     }
2235
2236   if (overrider_fn != overrider_target && !virtual_base)
2237     {
2238       /* The ABI specifies that a covariant thunk includes a mangling
2239          for a this pointer adjustment.  This-adjusting thunks that
2240          override a function from a virtual base have a vcall
2241          adjustment.  When the virtual base in question is a primary
2242          virtual base, we know the adjustments are zero, (and in the
2243          non-covariant case, we would not use the thunk).
2244          Unfortunately we didn't notice this could happen, when
2245          designing the ABI and so never mandated that such a covariant
2246          thunk should be emitted.  Because we must use the ABI mandated
2247          name, we must continue searching from the binfo where we
2248          found the most recent definition of the function, towards the
2249          primary binfo which first introduced the function into the
2250          vtable.  If that enters a virtual base, we must use a vcall
2251          this-adjusting thunk.  Bleah! */
2252       tree probe = first_defn;
2253
2254       while ((probe = get_primary_binfo (probe))
2255              && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2256         if (TREE_VIA_VIRTUAL (probe))
2257           virtual_base = probe;
2258
2259       if (virtual_base)
2260         /* Even if we find a virtual base, the correct delta is
2261            between the overrider and the binfo we're building a vtable
2262            for.  */
2263         goto virtual_covariant;
2264     }
2265
2266   /* Compute the constant adjustment to the `this' pointer.  The
2267      `this' pointer, when this function is called, will point at BINFO
2268      (or one of its primary bases, which are at the same offset).  */
2269   if (virtual_base)
2270     /* The `this' pointer needs to be adjusted from the declaration to
2271        the nearest virtual base.  */
2272     delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
2273                          convert (ssizetype, BINFO_OFFSET (first_defn)));
2274   else if (lost)
2275     /* If the nearest definition is in a lost primary, we don't need an
2276        entry in our vtable.  Except possibly in a constructor vtable,
2277        if we happen to get our primary back.  In that case, the offset
2278        will be zero, as it will be a primary base.  */
2279     delta = size_zero_node;
2280   else
2281     /* The `this' pointer needs to be adjusted from pointing to
2282        BINFO to pointing at the base where the final overrider
2283        appears.  */
2284     virtual_covariant:
2285     delta = size_diffop (convert (ssizetype,
2286                                   BINFO_OFFSET (TREE_VALUE (overrider))),
2287                          convert (ssizetype, BINFO_OFFSET (binfo)));
2288
2289   modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2290
2291   if (virtual_base)
2292     BV_VCALL_INDEX (*virtuals)
2293       = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2294 }
2295
2296 /* Called from modify_all_vtables via dfs_walk.  */
2297
2298 static tree
2299 dfs_modify_vtables (tree binfo, void* data)
2300 {
2301   if (/* There's no need to modify the vtable for a non-virtual
2302          primary base; we're not going to use that vtable anyhow.
2303          We do still need to do this for virtual primary bases, as they
2304          could become non-primary in a construction vtable.  */
2305       (!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo))
2306       /* Similarly, a base without a vtable needs no modification.  */
2307       && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2308     {
2309       tree t = (tree) data;
2310       tree virtuals;
2311       tree old_virtuals;
2312       unsigned ix;
2313
2314       make_new_vtable (t, binfo);
2315
2316       /* Now, go through each of the virtual functions in the virtual
2317          function table for BINFO.  Find the final overrider, and
2318          update the BINFO_VIRTUALS list appropriately.  */
2319       for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2320              old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2321            virtuals;
2322            ix++, virtuals = TREE_CHAIN (virtuals),
2323              old_virtuals = TREE_CHAIN (old_virtuals))
2324         update_vtable_entry_for_fn (t,
2325                                     binfo,
2326                                     BV_FN (old_virtuals),
2327                                     &virtuals, ix);
2328     }
2329
2330   BINFO_MARKED (binfo) = 1;
2331
2332   return NULL_TREE;
2333 }
2334
2335 /* Update all of the primary and secondary vtables for T.  Create new
2336    vtables as required, and initialize their RTTI information.  Each
2337    of the functions in VIRTUALS is declared in T and may override a
2338    virtual function from a base class; find and modify the appropriate
2339    entries to point to the overriding functions.  Returns a list, in
2340    declaration order, of the virtual functions that are declared in T,
2341    but do not appear in the primary base class vtable, and which
2342    should therefore be appended to the end of the vtable for T.  */
2343
2344 static tree
2345 modify_all_vtables (tree t, tree virtuals)
2346 {
2347   tree binfo = TYPE_BINFO (t);
2348   tree *fnsp;
2349
2350   /* Update all of the vtables.  */
2351   dfs_walk (binfo, dfs_modify_vtables, unmarkedp, t);
2352   dfs_walk (binfo, dfs_unmark, markedp, t);
2353
2354   /* Add virtual functions not already in our primary vtable. These
2355      will be both those introduced by this class, and those overridden
2356      from secondary bases.  It does not include virtuals merely
2357      inherited from secondary bases.  */
2358   for (fnsp = &virtuals; *fnsp; )
2359     {
2360       tree fn = TREE_VALUE (*fnsp);
2361
2362       if (!value_member (fn, BINFO_VIRTUALS (binfo))
2363           || DECL_VINDEX (fn) == error_mark_node)
2364         {
2365           /* We don't need to adjust the `this' pointer when
2366              calling this function.  */
2367           BV_DELTA (*fnsp) = integer_zero_node;
2368           BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2369
2370           /* This is a function not already in our vtable.  Keep it.  */
2371           fnsp = &TREE_CHAIN (*fnsp);
2372         }
2373       else
2374         /* We've already got an entry for this function.  Skip it.  */
2375         *fnsp = TREE_CHAIN (*fnsp);
2376     }
2377
2378   return virtuals;
2379 }
2380
2381 /* Get the base virtual function declarations in T that have the
2382    indicated NAME.  */
2383
2384 static tree
2385 get_basefndecls (tree name, tree t)
2386 {
2387   tree methods;
2388   tree base_fndecls = NULL_TREE;
2389   int n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
2390   int i;
2391
2392   /* Find virtual functions in T with the indicated NAME.  */
2393   i = lookup_fnfields_1 (t, name);
2394   if (i != -1)
2395     for (methods = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), i);
2396          methods;
2397          methods = OVL_NEXT (methods))
2398       {
2399         tree method = OVL_CURRENT (methods);
2400
2401         if (TREE_CODE (method) == FUNCTION_DECL
2402             && DECL_VINDEX (method))
2403           base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2404       }
2405
2406   if (base_fndecls)
2407     return base_fndecls;
2408
2409   for (i = 0; i < n_baseclasses; i++)
2410     {
2411       tree basetype = TYPE_BINFO_BASETYPE (t, i);
2412       base_fndecls = chainon (get_basefndecls (name, basetype),
2413                               base_fndecls);
2414     }
2415
2416   return base_fndecls;
2417 }
2418
2419 /* If this declaration supersedes the declaration of
2420    a method declared virtual in the base class, then
2421    mark this field as being virtual as well.  */
2422
2423 static void
2424 check_for_override (tree decl, tree ctype)
2425 {
2426   if (TREE_CODE (decl) == TEMPLATE_DECL)
2427     /* In [temp.mem] we have:
2428
2429          A specialization of a member function template does not
2430          override a virtual function from a base class.  */
2431     return;
2432   if ((DECL_DESTRUCTOR_P (decl)
2433        || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2434        || DECL_CONV_FN_P (decl))
2435       && look_for_overrides (ctype, decl)
2436       && !DECL_STATIC_FUNCTION_P (decl))
2437     /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2438        the error_mark_node so that we know it is an overriding
2439        function.  */
2440     DECL_VINDEX (decl) = decl;
2441
2442   if (DECL_VIRTUAL_P (decl))
2443     {
2444       if (!DECL_VINDEX (decl))
2445         DECL_VINDEX (decl) = error_mark_node;
2446       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2447     }
2448 }
2449
2450 /* Warn about hidden virtual functions that are not overridden in t.
2451    We know that constructors and destructors don't apply.  */
2452
2453 void
2454 warn_hidden (tree t)
2455 {
2456   tree method_vec = CLASSTYPE_METHOD_VEC (t);
2457   int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
2458   int i;
2459
2460   /* We go through each separately named virtual function.  */
2461   for (i = 2; i < n_methods && TREE_VEC_ELT (method_vec, i); ++i)
2462     {
2463       tree fns;
2464       tree name;
2465       tree fndecl;
2466       tree base_fndecls;
2467       int j;
2468
2469       /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2470          have the same name.  Figure out what name that is.  */
2471       name = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
2472       /* There are no possibly hidden functions yet.  */
2473       base_fndecls = NULL_TREE;
2474       /* Iterate through all of the base classes looking for possibly
2475          hidden functions.  */
2476       for (j = 0; j < CLASSTYPE_N_BASECLASSES (t); j++)
2477         {
2478           tree basetype = TYPE_BINFO_BASETYPE (t, j);
2479           base_fndecls = chainon (get_basefndecls (name, basetype),
2480                                   base_fndecls);
2481         }
2482
2483       /* If there are no functions to hide, continue.  */
2484       if (!base_fndecls)
2485         continue;
2486
2487       /* Remove any overridden functions.  */
2488       for (fns = TREE_VEC_ELT (method_vec, i); fns; fns = OVL_NEXT (fns))
2489         {
2490           fndecl = OVL_CURRENT (fns);
2491           if (DECL_VINDEX (fndecl))
2492             {
2493               tree *prev = &base_fndecls;
2494
2495               while (*prev)
2496                 /* If the method from the base class has the same
2497                    signature as the method from the derived class, it
2498                    has been overridden.  */
2499                 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2500                   *prev = TREE_CHAIN (*prev);
2501                 else
2502                   prev = &TREE_CHAIN (*prev);
2503             }
2504         }
2505
2506       /* Now give a warning for all base functions without overriders,
2507          as they are hidden.  */
2508       while (base_fndecls)
2509         {
2510           /* Here we know it is a hider, and no overrider exists.  */
2511           cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2512           cp_warning_at ("  by `%D'",
2513                          OVL_CURRENT (TREE_VEC_ELT (method_vec, i)));
2514           base_fndecls = TREE_CHAIN (base_fndecls);
2515         }
2516     }
2517 }
2518
2519 /* Check for things that are invalid.  There are probably plenty of other
2520    things we should check for also.  */
2521
2522 static void
2523 finish_struct_anon (tree t)
2524 {
2525   tree field;
2526
2527   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2528     {
2529       if (TREE_STATIC (field))
2530         continue;
2531       if (TREE_CODE (field) != FIELD_DECL)
2532         continue;
2533
2534       if (DECL_NAME (field) == NULL_TREE
2535           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2536         {
2537           tree elt = TYPE_FIELDS (TREE_TYPE (field));
2538           for (; elt; elt = TREE_CHAIN (elt))
2539             {
2540               /* We're generally only interested in entities the user
2541                  declared, but we also find nested classes by noticing
2542                  the TYPE_DECL that we create implicitly.  You're
2543                  allowed to put one anonymous union inside another,
2544                  though, so we explicitly tolerate that.  We use
2545                  TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2546                  we also allow unnamed types used for defining fields.  */
2547               if (DECL_ARTIFICIAL (elt)
2548                   && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2549                       || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2550                 continue;
2551
2552               if (TREE_CODE (elt) != FIELD_DECL)
2553                 {
2554                   cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2555                                  elt);
2556                   continue;
2557                 }
2558
2559               if (TREE_PRIVATE (elt))
2560                 cp_pedwarn_at ("private member `%#D' in anonymous union",
2561                                elt);
2562               else if (TREE_PROTECTED (elt))
2563                 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2564                                elt);
2565
2566               TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2567               TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2568             }
2569         }
2570     }
2571 }
2572
2573 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2574    will be used later during class template instantiation.
2575    When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2576    a non-static member data (FIELD_DECL), a member function
2577    (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2578    a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2579    When FRIEND_P is nonzero, T is either a friend class
2580    (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2581    (FUNCTION_DECL, TEMPLATE_DECL).  */
2582
2583 void
2584 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2585 {
2586   /* Save some memory by not creating TREE_LIST if TYPE is not template.  */
2587   if (CLASSTYPE_TEMPLATE_INFO (type))
2588     CLASSTYPE_DECL_LIST (type)
2589       = tree_cons (friend_p ? NULL_TREE : type,
2590                    t, CLASSTYPE_DECL_LIST (type));
2591 }
2592
2593 /* Create default constructors, assignment operators, and so forth for
2594    the type indicated by T, if they are needed.
2595    CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2596    CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2597    class cannot have a default constructor, copy constructor taking a
2598    const reference argument, or an assignment operator taking a const
2599    reference, respectively.  If a virtual destructor is created, its
2600    DECL is returned; otherwise the return value is NULL_TREE.  */
2601
2602 static void
2603 add_implicitly_declared_members (tree t,
2604                                  int cant_have_default_ctor,
2605                                  int cant_have_const_cctor,
2606                                  int cant_have_const_assignment)
2607 {
2608   tree default_fn;
2609   tree implicit_fns = NULL_TREE;
2610   tree virtual_dtor = NULL_TREE;
2611   tree *f;
2612
2613   ++adding_implicit_members;
2614
2615   /* Destructor.  */
2616   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t))
2617     {
2618       default_fn = implicitly_declare_fn (sfk_destructor, t, /*const_p=*/0);
2619       check_for_override (default_fn, t);
2620
2621       /* If we couldn't make it work, then pretend we didn't need it.  */
2622       if (default_fn == void_type_node)
2623         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 0;
2624       else
2625         {
2626           TREE_CHAIN (default_fn) = implicit_fns;
2627           implicit_fns = default_fn;
2628
2629           if (DECL_VINDEX (default_fn))
2630             virtual_dtor = default_fn;
2631         }
2632     }
2633   else
2634     /* Any non-implicit destructor is non-trivial.  */
2635     TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
2636
2637   /* Default constructor.  */
2638   if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor)
2639     {
2640       default_fn = implicitly_declare_fn (sfk_constructor, t, /*const_p=*/0);
2641       TREE_CHAIN (default_fn) = implicit_fns;
2642       implicit_fns = default_fn;
2643     }
2644
2645   /* Copy constructor.  */
2646   if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2647     {
2648       /* ARM 12.18: You get either X(X&) or X(const X&), but
2649          not both.  --Chip  */
2650       default_fn
2651         = implicitly_declare_fn (sfk_copy_constructor, t,
2652                                  /*const_p=*/!cant_have_const_cctor);
2653       TREE_CHAIN (default_fn) = implicit_fns;
2654       implicit_fns = default_fn;
2655     }
2656
2657   /* Assignment operator.  */
2658   if (! TYPE_HAS_ASSIGN_REF (t) && ! TYPE_FOR_JAVA (t))
2659     {
2660       default_fn
2661         = implicitly_declare_fn (sfk_assignment_operator, t,
2662                                  /*const_p=*/!cant_have_const_assignment);
2663       TREE_CHAIN (default_fn) = implicit_fns;
2664       implicit_fns = default_fn;
2665     }
2666
2667   /* Now, hook all of the new functions on to TYPE_METHODS,
2668      and add them to the CLASSTYPE_METHOD_VEC.  */
2669   for (f = &implicit_fns; *f; f = &TREE_CHAIN (*f))
2670     {
2671       add_method (t, *f, /*error_p=*/0);
2672       maybe_add_class_template_decl_list (current_class_type, *f, /*friend_p=*/0);
2673     }
2674   if (abi_version_at_least (2))
2675     /* G++ 3.2 put the implicit destructor at the *beginning* of the
2676        list, which cause the destructor to be emitted in an incorrect
2677        location in the vtable.  */
2678     TYPE_METHODS (t) = chainon (TYPE_METHODS (t), implicit_fns);
2679   else
2680     {
2681       if (warn_abi && virtual_dtor)
2682         warning ("vtable layout for class `%T' may not be ABI-compliant "
2683                  "and may change in a future version of GCC due to implicit "
2684                  "virtual destructor",
2685                  t);
2686       *f = TYPE_METHODS (t);
2687       TYPE_METHODS (t) = implicit_fns;
2688     }
2689
2690   --adding_implicit_members;
2691 }
2692
2693 /* Subroutine of finish_struct_1.  Recursively count the number of fields
2694    in TYPE, including anonymous union members.  */
2695
2696 static int
2697 count_fields (tree fields)
2698 {
2699   tree x;
2700   int n_fields = 0;
2701   for (x = fields; x; x = TREE_CHAIN (x))
2702     {
2703       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2704         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2705       else
2706         n_fields += 1;
2707     }
2708   return n_fields;
2709 }
2710
2711 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
2712    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
2713
2714 static int
2715 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2716 {
2717   tree x;
2718   for (x = fields; x; x = TREE_CHAIN (x))
2719     {
2720       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2721         idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2722       else
2723         field_vec->elts[idx++] = x;
2724     }
2725   return idx;
2726 }
2727
2728 /* FIELD is a bit-field.  We are finishing the processing for its
2729    enclosing type.  Issue any appropriate messages and set appropriate
2730    flags.  */
2731
2732 static void
2733 check_bitfield_decl (tree field)
2734 {
2735   tree type = TREE_TYPE (field);
2736   tree w = NULL_TREE;
2737
2738   /* Detect invalid bit-field type.  */
2739   if (DECL_INITIAL (field)
2740       && ! INTEGRAL_TYPE_P (TREE_TYPE (field)))
2741     {
2742       cp_error_at ("bit-field `%#D' with non-integral type", field);
2743       w = error_mark_node;
2744     }
2745
2746   /* Detect and ignore out of range field width.  */
2747   if (DECL_INITIAL (field))
2748     {
2749       w = DECL_INITIAL (field);
2750
2751       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
2752       STRIP_NOPS (w);
2753
2754       /* detect invalid field size.  */
2755       if (TREE_CODE (w) == CONST_DECL)
2756         w = DECL_INITIAL (w);
2757       else
2758         w = decl_constant_value (w);
2759
2760       if (TREE_CODE (w) != INTEGER_CST)
2761         {
2762           cp_error_at ("bit-field `%D' width not an integer constant",
2763                        field);
2764           w = error_mark_node;
2765         }
2766       else if (tree_int_cst_sgn (w) < 0)
2767         {
2768           cp_error_at ("negative width in bit-field `%D'", field);
2769           w = error_mark_node;
2770         }
2771       else if (integer_zerop (w) && DECL_NAME (field) != 0)
2772         {
2773           cp_error_at ("zero width for bit-field `%D'", field);
2774           w = error_mark_node;
2775         }
2776       else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2777                && TREE_CODE (type) != ENUMERAL_TYPE
2778                && TREE_CODE (type) != BOOLEAN_TYPE)
2779         cp_warning_at ("width of `%D' exceeds its type", field);
2780       else if (TREE_CODE (type) == ENUMERAL_TYPE
2781                && (0 > compare_tree_int (w,
2782                                          min_precision (TYPE_MIN_VALUE (type),
2783                                                         TREE_UNSIGNED (type)))
2784                    ||  0 > compare_tree_int (w,
2785                                              min_precision
2786                                              (TYPE_MAX_VALUE (type),
2787                                               TREE_UNSIGNED (type)))))
2788         cp_warning_at ("`%D' is too small to hold all values of `%#T'",
2789                        field, type);
2790     }
2791
2792   /* Remove the bit-field width indicator so that the rest of the
2793      compiler does not treat that value as an initializer.  */
2794   DECL_INITIAL (field) = NULL_TREE;
2795
2796   if (w != error_mark_node)
2797     {
2798       DECL_SIZE (field) = convert (bitsizetype, w);
2799       DECL_BIT_FIELD (field) = 1;
2800     }
2801   else
2802     {
2803       /* Non-bit-fields are aligned for their type.  */
2804       DECL_BIT_FIELD (field) = 0;
2805       CLEAR_DECL_C_BIT_FIELD (field);
2806     }
2807 }
2808
2809 /* FIELD is a non bit-field.  We are finishing the processing for its
2810    enclosing type T.  Issue any appropriate messages and set appropriate
2811    flags.  */
2812
2813 static void
2814 check_field_decl (tree field,
2815                   tree t,
2816                   int* cant_have_const_ctor,
2817                   int* cant_have_default_ctor,
2818                   int* no_const_asn_ref,
2819                   int* any_default_members)
2820 {
2821   tree type = strip_array_types (TREE_TYPE (field));
2822
2823   /* An anonymous union cannot contain any fields which would change
2824      the settings of CANT_HAVE_CONST_CTOR and friends.  */
2825   if (ANON_UNION_TYPE_P (type))
2826     ;
2827   /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2828      structs.  So, we recurse through their fields here.  */
2829   else if (ANON_AGGR_TYPE_P (type))
2830     {
2831       tree fields;
2832
2833       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2834         if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2835           check_field_decl (fields, t, cant_have_const_ctor,
2836                             cant_have_default_ctor, no_const_asn_ref,
2837                             any_default_members);
2838     }
2839   /* Check members with class type for constructors, destructors,
2840      etc.  */
2841   else if (CLASS_TYPE_P (type))
2842     {
2843       /* Never let anything with uninheritable virtuals
2844          make it through without complaint.  */
2845       abstract_virtuals_error (field, type);
2846
2847       if (TREE_CODE (t) == UNION_TYPE)
2848         {
2849           if (TYPE_NEEDS_CONSTRUCTING (type))
2850             cp_error_at ("member `%#D' with constructor not allowed in union",
2851                          field);
2852           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2853             cp_error_at ("member `%#D' with destructor not allowed in union",
2854                          field);
2855           if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2856             cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
2857                          field);
2858         }
2859       else
2860         {
2861           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2862           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2863             |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2864           TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2865           TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2866         }
2867
2868       if (!TYPE_HAS_CONST_INIT_REF (type))
2869         *cant_have_const_ctor = 1;
2870
2871       if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2872         *no_const_asn_ref = 1;
2873
2874       if (TYPE_HAS_CONSTRUCTOR (type)
2875           && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2876         *cant_have_default_ctor = 1;
2877     }
2878   if (DECL_INITIAL (field) != NULL_TREE)
2879     {
2880       /* `build_class_init_list' does not recognize
2881          non-FIELD_DECLs.  */
2882       if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2883         error ("multiple fields in union `%T' initialized", t);
2884       *any_default_members = 1;
2885     }
2886 }
2887
2888 /* Check the data members (both static and non-static), class-scoped
2889    typedefs, etc., appearing in the declaration of T.  Issue
2890    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
2891    declaration order) of access declarations; each TREE_VALUE in this
2892    list is a USING_DECL.
2893
2894    In addition, set the following flags:
2895
2896      EMPTY_P
2897        The class is empty, i.e., contains no non-static data members.
2898
2899      CANT_HAVE_DEFAULT_CTOR_P
2900        This class cannot have an implicitly generated default
2901        constructor.
2902
2903      CANT_HAVE_CONST_CTOR_P
2904        This class cannot have an implicitly generated copy constructor
2905        taking a const reference.
2906
2907      CANT_HAVE_CONST_ASN_REF
2908        This class cannot have an implicitly generated assignment
2909        operator taking a const reference.
2910
2911    All of these flags should be initialized before calling this
2912    function.
2913
2914    Returns a pointer to the end of the TYPE_FIELDs chain; additional
2915    fields can be added by adding to this chain.  */
2916
2917 static void
2918 check_field_decls (tree t, tree *access_decls,
2919                    int *cant_have_default_ctor_p,
2920                    int *cant_have_const_ctor_p,
2921                    int *no_const_asn_ref_p)
2922 {
2923   tree *field;
2924   tree *next;
2925   int has_pointers;
2926   int any_default_members;
2927
2928   /* Assume there are no access declarations.  */
2929   *access_decls = NULL_TREE;
2930   /* Assume this class has no pointer members.  */
2931   has_pointers = 0;
2932   /* Assume none of the members of this class have default
2933      initializations.  */
2934   any_default_members = 0;
2935
2936   for (field = &TYPE_FIELDS (t); *field; field = next)
2937     {
2938       tree x = *field;
2939       tree type = TREE_TYPE (x);
2940
2941       next = &TREE_CHAIN (x);
2942
2943       if (TREE_CODE (x) == FIELD_DECL)
2944         {
2945           if (TYPE_PACKED (t))
2946             {
2947               if (!pod_type_p (TREE_TYPE (x)) && !TYPE_PACKED (TREE_TYPE (x)))
2948                 cp_warning_at
2949                   ("ignoring packed attribute on unpacked non-POD field `%#D'",
2950                    x);
2951               else
2952                 DECL_PACKED (x) = 1;
2953             }
2954
2955           if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
2956             /* We don't treat zero-width bitfields as making a class
2957                non-empty.  */
2958             ;
2959           else
2960             {
2961               tree element_type;
2962
2963               /* The class is non-empty.  */
2964               CLASSTYPE_EMPTY_P (t) = 0;
2965               /* The class is not even nearly empty.  */
2966               CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
2967               /* If one of the data members contains an empty class,
2968                  so does T.  */
2969               element_type = strip_array_types (type);
2970               if (CLASS_TYPE_P (element_type)
2971                   && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
2972                 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
2973             }
2974         }
2975
2976       if (TREE_CODE (x) == USING_DECL)
2977         {
2978           /* Prune the access declaration from the list of fields.  */
2979           *field = TREE_CHAIN (x);
2980
2981           /* Save the access declarations for our caller.  */
2982           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2983
2984           /* Since we've reset *FIELD there's no reason to skip to the
2985              next field.  */
2986           next = field;
2987           continue;
2988         }
2989
2990       if (TREE_CODE (x) == TYPE_DECL
2991           || TREE_CODE (x) == TEMPLATE_DECL)
2992         continue;
2993
2994       /* If we've gotten this far, it's a data member, possibly static,
2995          or an enumerator.  */
2996       DECL_CONTEXT (x) = t;
2997
2998       /* When this goes into scope, it will be a non-local reference.  */
2999       DECL_NONLOCAL (x) = 1;
3000
3001       if (TREE_CODE (t) == UNION_TYPE)
3002         {
3003           /* [class.union]
3004
3005              If a union contains a static data member, or a member of
3006              reference type, the program is ill-formed. */
3007           if (TREE_CODE (x) == VAR_DECL)
3008             {
3009               cp_error_at ("`%D' may not be static because it is a member of a union", x);
3010               continue;
3011             }
3012           if (TREE_CODE (type) == REFERENCE_TYPE)
3013             {
3014               cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union",
3015                            x, type);
3016               continue;
3017             }
3018         }
3019
3020       /* ``A local class cannot have static data members.'' ARM 9.4 */
3021       if (current_function_decl && TREE_STATIC (x))
3022         cp_error_at ("field `%D' in local class cannot be static", x);
3023
3024       /* Perform error checking that did not get done in
3025          grokdeclarator.  */
3026       if (TREE_CODE (type) == FUNCTION_TYPE)
3027         {
3028           cp_error_at ("field `%D' invalidly declared function type",
3029                        x);
3030           type = build_pointer_type (type);
3031           TREE_TYPE (x) = type;
3032         }
3033       else if (TREE_CODE (type) == METHOD_TYPE)
3034         {
3035           cp_error_at ("field `%D' invalidly declared method type", x);
3036           type = build_pointer_type (type);
3037           TREE_TYPE (x) = type;
3038         }
3039
3040       if (type == error_mark_node)
3041         continue;
3042
3043       if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3044         continue;
3045
3046       /* Now it can only be a FIELD_DECL.  */
3047
3048       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3049         CLASSTYPE_NON_AGGREGATE (t) = 1;
3050
3051       /* If this is of reference type, check if it needs an init.
3052          Also do a little ANSI jig if necessary.  */
3053       if (TREE_CODE (type) == REFERENCE_TYPE)
3054         {
3055           CLASSTYPE_NON_POD_P (t) = 1;
3056           if (DECL_INITIAL (x) == NULL_TREE)
3057             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3058
3059           /* ARM $12.6.2: [A member initializer list] (or, for an
3060              aggregate, initialization by a brace-enclosed list) is the
3061              only way to initialize nonstatic const and reference
3062              members.  */
3063           *cant_have_default_ctor_p = 1;
3064           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3065
3066           if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3067               && extra_warnings)
3068             cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3069         }
3070
3071       type = strip_array_types (type);
3072
3073       if (TYPE_PTR_P (type))
3074         has_pointers = 1;
3075
3076       if (CLASS_TYPE_P (type))
3077         {
3078           if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3079             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3080           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3081             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3082         }
3083
3084       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3085         CLASSTYPE_HAS_MUTABLE (t) = 1;
3086
3087       if (! pod_type_p (type))
3088         /* DR 148 now allows pointers to members (which are POD themselves),
3089            to be allowed in POD structs.  */
3090         CLASSTYPE_NON_POD_P (t) = 1;
3091
3092       if (! zero_init_p (type))
3093         CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3094
3095       /* If any field is const, the structure type is pseudo-const.  */
3096       if (CP_TYPE_CONST_P (type))
3097         {
3098           C_TYPE_FIELDS_READONLY (t) = 1;
3099           if (DECL_INITIAL (x) == NULL_TREE)
3100             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3101
3102           /* ARM $12.6.2: [A member initializer list] (or, for an
3103              aggregate, initialization by a brace-enclosed list) is the
3104              only way to initialize nonstatic const and reference
3105              members.  */
3106           *cant_have_default_ctor_p = 1;
3107           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3108
3109           if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3110               && extra_warnings)
3111             cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3112         }
3113       /* A field that is pseudo-const makes the structure likewise.  */
3114       else if (CLASS_TYPE_P (type))
3115         {
3116           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3117           SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3118             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3119             | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3120         }
3121
3122       /* Core issue 80: A nonstatic data member is required to have a
3123          different name from the class iff the class has a
3124          user-defined constructor.  */
3125       if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t))
3126         cp_pedwarn_at ("field `%#D' with same name as class", x);
3127
3128       /* We set DECL_C_BIT_FIELD in grokbitfield.
3129          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3130       if (DECL_C_BIT_FIELD (x))
3131         check_bitfield_decl (x);
3132       else
3133         check_field_decl (x, t,
3134                           cant_have_const_ctor_p,
3135                           cant_have_default_ctor_p,
3136                           no_const_asn_ref_p,
3137                           &any_default_members);
3138     }
3139
3140   /* Effective C++ rule 11.  */
3141   if (has_pointers && warn_ecpp && TYPE_HAS_CONSTRUCTOR (t)
3142       && ! (TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3143     {
3144       warning ("`%#T' has pointer data members", t);
3145
3146       if (! TYPE_HAS_INIT_REF (t))
3147         {
3148           warning ("  but does not override `%T(const %T&)'", t, t);
3149           if (! TYPE_HAS_ASSIGN_REF (t))
3150             warning ("  or `operator=(const %T&)'", t);
3151         }
3152       else if (! TYPE_HAS_ASSIGN_REF (t))
3153         warning ("  but does not override `operator=(const %T&)'", t);
3154     }
3155
3156
3157   /* Check anonymous struct/anonymous union fields.  */
3158   finish_struct_anon (t);
3159
3160   /* We've built up the list of access declarations in reverse order.
3161      Fix that now.  */
3162   *access_decls = nreverse (*access_decls);
3163 }
3164
3165 /* If TYPE is an empty class type, records its OFFSET in the table of
3166    OFFSETS.  */
3167
3168 static int
3169 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3170 {
3171   splay_tree_node n;
3172
3173   if (!is_empty_class (type))
3174     return 0;
3175
3176   /* Record the location of this empty object in OFFSETS.  */
3177   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3178   if (!n)
3179     n = splay_tree_insert (offsets,
3180                            (splay_tree_key) offset,
3181                            (splay_tree_value) NULL_TREE);
3182   n->value = ((splay_tree_value)
3183               tree_cons (NULL_TREE,
3184                          type,
3185                          (tree) n->value));
3186
3187   return 0;
3188 }
3189
3190 /* Returns nonzero if TYPE is an empty class type and there is
3191    already an entry in OFFSETS for the same TYPE as the same OFFSET.  */
3192
3193 static int
3194 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3195 {
3196   splay_tree_node n;
3197   tree t;
3198
3199   if (!is_empty_class (type))
3200     return 0;
3201
3202   /* Record the location of this empty object in OFFSETS.  */
3203   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3204   if (!n)
3205     return 0;
3206
3207   for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3208     if (same_type_p (TREE_VALUE (t), type))
3209       return 1;
3210
3211   return 0;
3212 }
3213
3214 /* Walk through all the subobjects of TYPE (located at OFFSET).  Call
3215    F for every subobject, passing it the type, offset, and table of
3216    OFFSETS.  If VBASES_P is one, then virtual non-primary bases should
3217    be traversed.
3218
3219    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3220    than MAX_OFFSET will not be walked.
3221
3222    If F returns a nonzero value, the traversal ceases, and that value
3223    is returned.  Otherwise, returns zero.  */
3224
3225 static int
3226 walk_subobject_offsets (tree type,
3227                         subobject_offset_fn f,
3228                         tree offset,
3229                         splay_tree offsets,
3230                         tree max_offset,
3231                         int vbases_p)
3232 {
3233   int r = 0;
3234   tree type_binfo = NULL_TREE;
3235
3236   /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3237      stop.  */
3238   if (max_offset && INT_CST_LT (max_offset, offset))
3239     return 0;
3240
3241   if (!TYPE_P (type))
3242     {
3243       if (abi_version_at_least (2))
3244         type_binfo = type;
3245       type = BINFO_TYPE (type);
3246     }
3247
3248   if (CLASS_TYPE_P (type))
3249     {
3250       tree field;
3251       tree binfo;
3252       int i;
3253
3254       /* Avoid recursing into objects that are not interesting.  */
3255       if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3256         return 0;
3257
3258       /* Record the location of TYPE.  */
3259       r = (*f) (type, offset, offsets);
3260       if (r)
3261         return r;
3262
3263       /* Iterate through the direct base classes of TYPE.  */
3264       if (!type_binfo)
3265         type_binfo = TYPE_BINFO (type);
3266       for (i = 0; i < BINFO_N_BASETYPES (type_binfo); ++i)
3267         {
3268           tree binfo_offset;
3269
3270           binfo = BINFO_BASETYPE (type_binfo, i);
3271
3272           if (abi_version_at_least (2)
3273               && TREE_VIA_VIRTUAL (binfo))
3274             continue;
3275
3276           if (!vbases_p
3277               && TREE_VIA_VIRTUAL (binfo)
3278               && !BINFO_PRIMARY_P (binfo))
3279             continue;
3280
3281           if (!abi_version_at_least (2))
3282             binfo_offset = size_binop (PLUS_EXPR,
3283                                        offset,
3284                                        BINFO_OFFSET (binfo));
3285           else
3286             {
3287               tree orig_binfo;
3288               /* We cannot rely on BINFO_OFFSET being set for the base
3289                  class yet, but the offsets for direct non-virtual
3290                  bases can be calculated by going back to the TYPE.  */
3291               orig_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
3292               binfo_offset = size_binop (PLUS_EXPR,
3293                                          offset,
3294                                          BINFO_OFFSET (orig_binfo));
3295             }
3296
3297           r = walk_subobject_offsets (binfo,
3298                                       f,
3299                                       binfo_offset,
3300                                       offsets,
3301                                       max_offset,
3302                                       (abi_version_at_least (2)
3303                                        ? /*vbases_p=*/0 : vbases_p));
3304           if (r)
3305             return r;
3306         }
3307
3308       if (abi_version_at_least (2))
3309         {
3310           tree vbase;
3311
3312           /* Iterate through the virtual base classes of TYPE.  In G++
3313              3.2, we included virtual bases in the direct base class
3314              loop above, which results in incorrect results; the
3315              correct offsets for virtual bases are only known when
3316              working with the most derived type.  */
3317           if (vbases_p)
3318             for (vbase = CLASSTYPE_VBASECLASSES (type);
3319                  vbase;
3320                  vbase = TREE_CHAIN (vbase))
3321               {
3322                 binfo = TREE_VALUE (vbase);
3323                 r = walk_subobject_offsets (binfo,
3324                                             f,
3325                                             size_binop (PLUS_EXPR,
3326                                                         offset,
3327                                                         BINFO_OFFSET (binfo)),
3328                                             offsets,
3329                                             max_offset,
3330                                             /*vbases_p=*/0);
3331                 if (r)
3332                   return r;
3333               }
3334           else
3335             {
3336               /* We still have to walk the primary base, if it is
3337                  virtual.  (If it is non-virtual, then it was walked
3338                  above.)  */
3339               vbase = get_primary_binfo (type_binfo);
3340               if (vbase && TREE_VIA_VIRTUAL (vbase)
3341                   && BINFO_PRIMARY_BASE_OF (vbase) == type_binfo)
3342                 {
3343                   r = (walk_subobject_offsets
3344                        (vbase, f, offset,
3345                         offsets, max_offset, /*vbases_p=*/0));
3346                   if (r)
3347                     return r;
3348                 }
3349             }
3350         }
3351
3352       /* Iterate through the fields of TYPE.  */
3353       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3354         if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3355           {
3356             tree field_offset;
3357
3358             if (abi_version_at_least (2))
3359               field_offset = byte_position (field);
3360             else
3361               /* In G++ 3.2, DECL_FIELD_OFFSET was used.  */
3362               field_offset = DECL_FIELD_OFFSET (field);
3363
3364             r = walk_subobject_offsets (TREE_TYPE (field),
3365                                         f,
3366                                         size_binop (PLUS_EXPR,
3367                                                     offset,
3368                                                     field_offset),
3369                                         offsets,
3370                                         max_offset,
3371                                         /*vbases_p=*/1);
3372             if (r)
3373               return r;
3374           }
3375     }
3376   else if (TREE_CODE (type) == ARRAY_TYPE)
3377     {
3378       tree element_type = strip_array_types (type);
3379       tree domain = TYPE_DOMAIN (type);
3380       tree index;
3381
3382       /* Avoid recursing into objects that are not interesting.  */
3383       if (!CLASS_TYPE_P (element_type)
3384           || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3385         return 0;
3386
3387       /* Step through each of the elements in the array.  */
3388       for (index = size_zero_node;
3389            /* G++ 3.2 had an off-by-one error here.  */
3390            (abi_version_at_least (2)
3391             ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3392             : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3393            index = size_binop (PLUS_EXPR, index, size_one_node))
3394         {
3395           r = walk_subobject_offsets (TREE_TYPE (type),
3396                                       f,
3397                                       offset,
3398                                       offsets,
3399                                       max_offset,
3400                                       /*vbases_p=*/1);
3401           if (r)
3402             return r;
3403           offset = size_binop (PLUS_EXPR, offset,
3404                                TYPE_SIZE_UNIT (TREE_TYPE (type)));
3405           /* If this new OFFSET is bigger than the MAX_OFFSET, then
3406              there's no point in iterating through the remaining
3407              elements of the array.  */
3408           if (max_offset && INT_CST_LT (max_offset, offset))
3409             break;
3410         }
3411     }
3412
3413   return 0;
3414 }
3415
3416 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3417    OFFSETS.  If VBASES_P is nonzero, virtual bases of TYPE are
3418    examined.  */
3419
3420 static void
3421 record_subobject_offsets (tree type,
3422                           tree offset,
3423                           splay_tree offsets,
3424                           int vbases_p)
3425 {
3426   walk_subobject_offsets (type, record_subobject_offset, offset,
3427                           offsets, /*max_offset=*/NULL_TREE, vbases_p);
3428 }
3429
3430 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3431    OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
3432    virtual bases of TYPE are examined.  */
3433
3434 static int
3435 layout_conflict_p (tree type,
3436                    tree offset,
3437                    splay_tree offsets,
3438                    int vbases_p)
3439 {
3440   splay_tree_node max_node;
3441
3442   /* Get the node in OFFSETS that indicates the maximum offset where
3443      an empty subobject is located.  */
3444   max_node = splay_tree_max (offsets);
3445   /* If there aren't any empty subobjects, then there's no point in
3446      performing this check.  */
3447   if (!max_node)
3448     return 0;
3449
3450   return walk_subobject_offsets (type, check_subobject_offset, offset,
3451                                  offsets, (tree) (max_node->key),
3452                                  vbases_p);
3453 }
3454
3455 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3456    non-static data member of the type indicated by RLI.  BINFO is the
3457    binfo corresponding to the base subobject, OFFSETS maps offsets to
3458    types already located at those offsets.  This function determines
3459    the position of the DECL.  */
3460
3461 static void
3462 layout_nonempty_base_or_field (record_layout_info rli,
3463                                tree decl,
3464                                tree binfo,
3465                                splay_tree offsets)
3466 {
3467   tree offset = NULL_TREE;
3468   bool field_p;
3469   tree type;
3470
3471   if (binfo)
3472     {
3473       /* For the purposes of determining layout conflicts, we want to
3474          use the class type of BINFO; TREE_TYPE (DECL) will be the
3475          CLASSTYPE_AS_BASE version, which does not contain entries for
3476          zero-sized bases.  */
3477       type = TREE_TYPE (binfo);
3478       field_p = false;
3479     }
3480   else
3481     {
3482       type = TREE_TYPE (decl);
3483       field_p = true;
3484     }
3485
3486   /* Try to place the field.  It may take more than one try if we have
3487      a hard time placing the field without putting two objects of the
3488      same type at the same address.  */
3489   while (1)
3490     {
3491       struct record_layout_info_s old_rli = *rli;
3492
3493       /* Place this field.  */
3494       place_field (rli, decl);
3495       offset = byte_position (decl);
3496
3497       /* We have to check to see whether or not there is already
3498          something of the same type at the offset we're about to use.
3499          For example, consider:
3500
3501            struct S {};
3502            struct T : public S { int i; };
3503            struct U : public S, public T {};
3504
3505          Here, we put S at offset zero in U.  Then, we can't put T at
3506          offset zero -- its S component would be at the same address
3507          as the S we already allocated.  So, we have to skip ahead.
3508          Since all data members, including those whose type is an
3509          empty class, have nonzero size, any overlap can happen only
3510          with a direct or indirect base-class -- it can't happen with
3511          a data member.  */
3512       /* In a union, overlap is permitted; all members are placed at
3513          offset zero.  */
3514       if (TREE_CODE (rli->t) == UNION_TYPE)
3515         break;
3516       /* G++ 3.2 did not check for overlaps when placing a non-empty
3517          virtual base.  */
3518       if (!abi_version_at_least (2) && binfo && TREE_VIA_VIRTUAL (binfo))
3519         break;
3520       if (layout_conflict_p (field_p ? type : binfo, offset,
3521                              offsets, field_p))
3522         {
3523           /* Strip off the size allocated to this field.  That puts us
3524              at the first place we could have put the field with
3525              proper alignment.  */
3526           *rli = old_rli;
3527
3528           /* Bump up by the alignment required for the type.  */
3529           rli->bitpos
3530             = size_binop (PLUS_EXPR, rli->bitpos,
3531                           bitsize_int (binfo
3532                                        ? CLASSTYPE_ALIGN (type)
3533                                        : TYPE_ALIGN (type)));
3534           normalize_rli (rli);
3535         }
3536       else
3537         /* There was no conflict.  We're done laying out this field.  */
3538         break;
3539     }
3540
3541   /* Now that we know where it will be placed, update its
3542      BINFO_OFFSET.  */
3543   if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3544     /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3545        this point because their BINFO_OFFSET is copied from another
3546        hierarchy.  Therefore, we may not need to add the entire
3547        OFFSET.  */
3548     propagate_binfo_offsets (binfo,
3549                              size_diffop (convert (ssizetype, offset),
3550                                           convert (ssizetype,
3551                                                    BINFO_OFFSET (binfo))));
3552 }
3553
3554 /* Returns true if TYPE is empty and OFFSET is nonzero.  */
3555
3556 static int
3557 empty_base_at_nonzero_offset_p (tree type,
3558                                 tree offset,
3559                                 splay_tree offsets ATTRIBUTE_UNUSED)
3560 {
3561   return is_empty_class (type) && !integer_zerop (offset);
3562 }
3563
3564 /* Layout the empty base BINFO.  EOC indicates the byte currently just
3565    past the end of the class, and should be correctly aligned for a
3566    class of the type indicated by BINFO; OFFSETS gives the offsets of
3567    the empty bases allocated so far. T is the most derived
3568    type.  Return nonzero iff we added it at the end.  */
3569
3570 static bool
3571 layout_empty_base (tree binfo, tree eoc, splay_tree offsets)
3572 {
3573   tree alignment;
3574   tree basetype = BINFO_TYPE (binfo);
3575   bool atend = false;
3576
3577   /* This routine should only be used for empty classes.  */
3578   my_friendly_assert (is_empty_class (basetype), 20000321);
3579   alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3580
3581   if (!integer_zerop (BINFO_OFFSET (binfo)))
3582     {
3583       if (abi_version_at_least (2))
3584         propagate_binfo_offsets
3585           (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
3586       else if (warn_abi)
3587         warning ("offset of empty base `%T' may not be ABI-compliant and may"
3588                  "change in a future version of GCC",
3589                  BINFO_TYPE (binfo));
3590     }
3591
3592   /* This is an empty base class.  We first try to put it at offset
3593      zero.  */
3594   if (layout_conflict_p (binfo,
3595                          BINFO_OFFSET (binfo),
3596                          offsets,
3597                          /*vbases_p=*/0))
3598     {
3599       /* That didn't work.  Now, we move forward from the next
3600          available spot in the class.  */
3601       atend = true;
3602       propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3603       while (1)
3604         {
3605           if (!layout_conflict_p (binfo,
3606                                   BINFO_OFFSET (binfo),
3607                                   offsets,
3608                                   /*vbases_p=*/0))
3609             /* We finally found a spot where there's no overlap.  */
3610             break;
3611
3612           /* There's overlap here, too.  Bump along to the next spot.  */
3613           propagate_binfo_offsets (binfo, alignment);
3614         }
3615     }
3616   return atend;
3617 }
3618
3619 /* Layout the the base given by BINFO in the class indicated by RLI.
3620    *BASE_ALIGN is a running maximum of the alignments of
3621    any base class.  OFFSETS gives the location of empty base
3622    subobjects.  T is the most derived type.  Return nonzero if the new
3623    object cannot be nearly-empty.  A new FIELD_DECL is inserted at
3624    *NEXT_FIELD, unless BINFO is for an empty base class.
3625
3626    Returns the location at which the next field should be inserted.  */
3627
3628 static tree *
3629 build_base_field (record_layout_info rli, tree binfo,
3630                   splay_tree offsets, tree *next_field)
3631 {
3632   tree t = rli->t;
3633   tree basetype = BINFO_TYPE (binfo);
3634
3635   if (!COMPLETE_TYPE_P (basetype))
3636     /* This error is now reported in xref_tag, thus giving better
3637        location information.  */
3638     return next_field;
3639
3640   /* Place the base class.  */
3641   if (!is_empty_class (basetype))
3642     {
3643       tree decl;
3644
3645       /* The containing class is non-empty because it has a non-empty
3646          base class.  */
3647       CLASSTYPE_EMPTY_P (t) = 0;
3648
3649       /* Create the FIELD_DECL.  */
3650       decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3651       DECL_ARTIFICIAL (decl) = 1;
3652       DECL_FIELD_CONTEXT (decl) = t;
3653       DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3654       DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3655       DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3656       DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3657       DECL_IGNORED_P (decl) = 1;
3658
3659       /* Try to place the field.  It may take more than one try if we
3660          have a hard time placing the field without putting two
3661          objects of the same type at the same address.  */
3662       layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3663       /* Add the new FIELD_DECL to the list of fields for T.  */
3664       TREE_CHAIN (decl) = *next_field;
3665       *next_field = decl;
3666       next_field = &TREE_CHAIN (decl);
3667     }
3668   else
3669     {
3670       tree eoc;
3671       bool atend;
3672
3673       /* On some platforms (ARM), even empty classes will not be
3674          byte-aligned.  */
3675       eoc = round_up (rli_size_unit_so_far (rli),
3676                       CLASSTYPE_ALIGN_UNIT (basetype));
3677       atend = layout_empty_base (binfo, eoc, offsets);
3678       /* A nearly-empty class "has no proper base class that is empty,
3679          not morally virtual, and at an offset other than zero."  */
3680       if (!TREE_VIA_VIRTUAL (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3681         {
3682           if (atend)
3683             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3684           /* The check above (used in G++ 3.2) is insufficient  because
3685              an empty class placed at offset zero might itself have an
3686              empty base at a nonzero offset.  */
3687           else if (walk_subobject_offsets (basetype,
3688                                            empty_base_at_nonzero_offset_p,
3689                                            size_zero_node,
3690                                            /*offsets=*/NULL,
3691                                            /*max_offset=*/NULL_TREE,
3692                                            /*vbases_p=*/true))
3693             {
3694               if (abi_version_at_least (2))
3695                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3696               else if (warn_abi)
3697                 warning ("class `%T' will be considered nearly empty in a "
3698                          "future version of GCC", t);
3699             }
3700         }
3701
3702       /* We do not create a FIELD_DECL for empty base classes because
3703          it might overlap some other field.  We want to be able to
3704          create CONSTRUCTORs for the class by iterating over the
3705          FIELD_DECLs, and the back end does not handle overlapping
3706          FIELD_DECLs.  */
3707
3708       /* An empty virtual base causes a class to be non-empty
3709          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3710          here because that was already done when the virtual table
3711          pointer was created.  */
3712     }
3713
3714   /* Record the offsets of BINFO and its base subobjects.  */
3715   record_subobject_offsets (binfo,
3716                             BINFO_OFFSET (binfo),
3717                             offsets,
3718                             /*vbases_p=*/0);
3719
3720   return next_field;
3721 }
3722
3723 /* Layout all of the non-virtual base classes.  Record empty
3724    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3725    if the type cannot be nearly empty.  The fields created
3726    corresponding to the base classes will be inserted at
3727    *NEXT_FIELD.  */
3728
3729 static void
3730 build_base_fields (record_layout_info rli,
3731                    splay_tree offsets, tree *next_field)
3732 {
3733   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3734      subobjects.  */
3735   tree t = rli->t;
3736   int n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
3737   int i;
3738
3739   /* The primary base class is always allocated first.  */
3740   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3741     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3742                                    offsets, next_field);
3743
3744   /* Now allocate the rest of the bases.  */
3745   for (i = 0; i < n_baseclasses; ++i)
3746     {
3747       tree base_binfo;
3748
3749       base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
3750
3751       /* The primary base was already allocated above, so we don't
3752          need to allocate it again here.  */
3753       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3754         continue;
3755
3756       /* Virtual bases are added at the end (a primary virtual base
3757          will have already been added).  */
3758       if (TREE_VIA_VIRTUAL (base_binfo))
3759         continue;
3760
3761       next_field = build_base_field (rli, base_binfo,
3762                                      offsets, next_field);
3763     }
3764 }
3765
3766 /* Go through the TYPE_METHODS of T issuing any appropriate
3767    diagnostics, figuring out which methods override which other
3768    methods, and so forth.  */
3769
3770 static void
3771 check_methods (tree t)
3772 {
3773   tree x;
3774
3775   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3776     {
3777       /* If this was an evil function, don't keep it in class.  */
3778       if (DECL_ASSEMBLER_NAME_SET_P (x)
3779           && IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
3780         continue;
3781
3782       check_for_override (x, t);
3783       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3784         cp_error_at ("initializer specified for non-virtual method `%D'", x);
3785
3786       /* The name of the field is the original field name
3787          Save this in auxiliary field for later overloading.  */
3788       if (DECL_VINDEX (x))
3789         {
3790           TYPE_POLYMORPHIC_P (t) = 1;
3791           if (DECL_PURE_VIRTUAL_P (x))
3792             CLASSTYPE_PURE_VIRTUALS (t)
3793               = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t));
3794         }
3795     }
3796 }
3797
3798 /* FN is a constructor or destructor.  Clone the declaration to create
3799    a specialized in-charge or not-in-charge version, as indicated by
3800    NAME.  */
3801
3802 static tree
3803 build_clone (tree fn, tree name)
3804 {
3805   tree parms;
3806   tree clone;
3807
3808   /* Copy the function.  */
3809   clone = copy_decl (fn);
3810   /* Remember where this function came from.  */
3811   DECL_CLONED_FUNCTION (clone) = fn;
3812   DECL_ABSTRACT_ORIGIN (clone) = fn;
3813   /* Reset the function name.  */
3814   DECL_NAME (clone) = name;
3815   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3816   /* There's no pending inline data for this function.  */
3817   DECL_PENDING_INLINE_INFO (clone) = NULL;
3818   DECL_PENDING_INLINE_P (clone) = 0;
3819   /* And it hasn't yet been deferred.  */
3820   DECL_DEFERRED_FN (clone) = 0;
3821
3822   /* The base-class destructor is not virtual.  */
3823   if (name == base_dtor_identifier)
3824     {
3825       DECL_VIRTUAL_P (clone) = 0;
3826       if (TREE_CODE (clone) != TEMPLATE_DECL)
3827         DECL_VINDEX (clone) = NULL_TREE;
3828     }
3829
3830   /* If there was an in-charge parameter, drop it from the function
3831      type.  */
3832   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3833     {
3834       tree basetype;
3835       tree parmtypes;
3836       tree exceptions;
3837
3838       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3839       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3840       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3841       /* Skip the `this' parameter.  */
3842       parmtypes = TREE_CHAIN (parmtypes);
3843       /* Skip the in-charge parameter.  */
3844       parmtypes = TREE_CHAIN (parmtypes);
3845       /* And the VTT parm, in a complete [cd]tor.  */
3846       if (DECL_HAS_VTT_PARM_P (fn)
3847           && ! DECL_NEEDS_VTT_PARM_P (clone))
3848         parmtypes = TREE_CHAIN (parmtypes);
3849        /* If this is subobject constructor or destructor, add the vtt
3850          parameter.  */
3851       TREE_TYPE (clone)
3852         = build_method_type_directly (basetype,
3853                                       TREE_TYPE (TREE_TYPE (clone)),
3854                                       parmtypes);
3855       if (exceptions)
3856         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3857                                                      exceptions);
3858       TREE_TYPE (clone)
3859         = cp_build_type_attribute_variant (TREE_TYPE (clone),
3860                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3861     }
3862
3863   /* Copy the function parameters.  But, DECL_ARGUMENTS on a TEMPLATE_DECL
3864      aren't function parameters; those are the template parameters.  */
3865   if (TREE_CODE (clone) != TEMPLATE_DECL)
3866     {
3867       DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3868       /* Remove the in-charge parameter.  */
3869       if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3870         {
3871           TREE_CHAIN (DECL_ARGUMENTS (clone))
3872             = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3873           DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3874         }
3875       /* And the VTT parm, in a complete [cd]tor.  */
3876       if (DECL_HAS_VTT_PARM_P (fn))
3877         {
3878           if (DECL_NEEDS_VTT_PARM_P (clone))
3879             DECL_HAS_VTT_PARM_P (clone) = 1;
3880           else
3881             {
3882               TREE_CHAIN (DECL_ARGUMENTS (clone))
3883                 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3884               DECL_HAS_VTT_PARM_P (clone) = 0;
3885             }
3886         }
3887
3888       for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3889         {
3890           DECL_CONTEXT (parms) = clone;
3891           cxx_dup_lang_specific_decl (parms);
3892         }
3893     }
3894
3895   /* Create the RTL for this function.  */
3896   SET_DECL_RTL (clone, NULL_RTX);
3897   rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof);
3898
3899   /* Make it easy to find the CLONE given the FN.  */
3900   TREE_CHAIN (clone) = TREE_CHAIN (fn);
3901   TREE_CHAIN (fn) = clone;
3902
3903   /* If this is a template, handle the DECL_TEMPLATE_RESULT as well.  */
3904   if (TREE_CODE (clone) == TEMPLATE_DECL)
3905     {
3906       tree result;
3907
3908       DECL_TEMPLATE_RESULT (clone)
3909         = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3910       result = DECL_TEMPLATE_RESULT (clone);
3911       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3912       DECL_TI_TEMPLATE (result) = clone;
3913     }
3914   else if (DECL_DEFERRED_FN (fn))
3915     defer_fn (clone);
3916
3917   return clone;
3918 }
3919
3920 /* Produce declarations for all appropriate clones of FN.  If
3921    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3922    CLASTYPE_METHOD_VEC as well.  */
3923
3924 void
3925 clone_function_decl (tree fn, int update_method_vec_p)
3926 {
3927   tree clone;
3928
3929   /* Avoid inappropriate cloning.  */
3930   if (TREE_CHAIN (fn)
3931       && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))
3932     return;
3933
3934   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
3935     {
3936       /* For each constructor, we need two variants: an in-charge version
3937          and a not-in-charge version.  */
3938       clone = build_clone (fn, complete_ctor_identifier);
3939       if (update_method_vec_p)
3940         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3941       clone = build_clone (fn, base_ctor_identifier);
3942       if (update_method_vec_p)
3943         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3944     }
3945   else
3946     {
3947       my_friendly_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn), 20000411);
3948
3949       /* For each destructor, we need three variants: an in-charge
3950          version, a not-in-charge version, and an in-charge deleting
3951          version.  We clone the deleting version first because that
3952          means it will go second on the TYPE_METHODS list -- and that
3953          corresponds to the correct layout order in the virtual
3954          function table.
3955
3956          For a non-virtual destructor, we do not build a deleting
3957          destructor.  */
3958       if (DECL_VIRTUAL_P (fn))
3959         {
3960           clone = build_clone (fn, deleting_dtor_identifier);
3961           if (update_method_vec_p)
3962             add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3963         }
3964       clone = build_clone (fn, complete_dtor_identifier);
3965       if (update_method_vec_p)
3966         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3967       clone = build_clone (fn, base_dtor_identifier);
3968       if (update_method_vec_p)
3969         add_method (DECL_CONTEXT (clone), clone, /*error_p=*/0);
3970     }
3971
3972   /* Note that this is an abstract function that is never emitted.  */
3973   DECL_ABSTRACT (fn) = 1;
3974 }
3975
3976 /* DECL is an in charge constructor, which is being defined. This will
3977    have had an in class declaration, from whence clones were
3978    declared. An out-of-class definition can specify additional default
3979    arguments. As it is the clones that are involved in overload
3980    resolution, we must propagate the information from the DECL to its
3981    clones.  */
3982
3983 void
3984 adjust_clone_args (tree decl)
3985 {
3986   tree clone;
3987
3988   for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone);
3989        clone = TREE_CHAIN (clone))
3990     {
3991       tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
3992       tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
3993       tree decl_parms, clone_parms;
3994
3995       clone_parms = orig_clone_parms;
3996
3997       /* Skip the 'this' parameter.  */
3998       orig_clone_parms = TREE_CHAIN (orig_clone_parms);
3999       orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4000
4001       if (DECL_HAS_IN_CHARGE_PARM_P (decl))
4002         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4003       if (DECL_HAS_VTT_PARM_P (decl))
4004         orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4005
4006       clone_parms = orig_clone_parms;
4007       if (DECL_HAS_VTT_PARM_P (clone))
4008         clone_parms = TREE_CHAIN (clone_parms);
4009
4010       for (decl_parms = orig_decl_parms; decl_parms;
4011            decl_parms = TREE_CHAIN (decl_parms),
4012              clone_parms = TREE_CHAIN (clone_parms))
4013         {
4014           my_friendly_assert (same_type_p (TREE_TYPE (decl_parms),
4015                                            TREE_TYPE (clone_parms)), 20010424);
4016
4017           if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4018             {
4019               /* A default parameter has been added. Adjust the
4020                  clone's parameters.  */
4021               tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4022               tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4023               tree type;
4024
4025               clone_parms = orig_decl_parms;
4026
4027               if (DECL_HAS_VTT_PARM_P (clone))
4028                 {
4029                   clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4030                                            TREE_VALUE (orig_clone_parms),
4031                                            clone_parms);
4032                   TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4033                 }
4034               type = build_method_type_directly (basetype,
4035                                                  TREE_TYPE (TREE_TYPE (clone)),
4036                                                  clone_parms);
4037               if (exceptions)
4038                 type = build_exception_variant (type, exceptions);
4039               TREE_TYPE (clone) = type;
4040
4041               clone_parms = NULL_TREE;
4042               break;
4043             }
4044         }
4045       my_friendly_assert (!clone_parms, 20010424);
4046     }
4047 }
4048
4049 /* For each of the constructors and destructors in T, create an
4050    in-charge and not-in-charge variant.  */
4051
4052 static void
4053 clone_constructors_and_destructors (tree t)
4054 {
4055   tree fns;
4056
4057   /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4058      out now.  */
4059   if (!CLASSTYPE_METHOD_VEC (t))
4060     return;
4061
4062   for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4063     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4064   for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4065     clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4066 }
4067
4068 /* Remove all zero-width bit-fields from T.  */
4069
4070 static void
4071 remove_zero_width_bit_fields (tree t)
4072 {
4073   tree *fieldsp;
4074
4075   fieldsp = &TYPE_FIELDS (t);
4076   while (*fieldsp)
4077     {
4078       if (TREE_CODE (*fieldsp) == FIELD_DECL
4079           && DECL_C_BIT_FIELD (*fieldsp)
4080           && DECL_INITIAL (*fieldsp))
4081         *fieldsp = TREE_CHAIN (*fieldsp);
4082       else
4083         fieldsp = &TREE_CHAIN (*fieldsp);
4084     }
4085 }
4086
4087 /* Returns TRUE iff we need a cookie when dynamically allocating an
4088    array whose elements have the indicated class TYPE.  */
4089
4090 static bool
4091 type_requires_array_cookie (tree type)
4092 {
4093   tree fns;
4094   bool has_two_argument_delete_p = false;
4095
4096   my_friendly_assert (CLASS_TYPE_P (type), 20010712);
4097
4098   /* If there's a non-trivial destructor, we need a cookie.  In order
4099      to iterate through the array calling the destructor for each
4100      element, we'll have to know how many elements there are.  */
4101   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4102     return true;
4103
4104   /* If the usual deallocation function is a two-argument whose second
4105      argument is of type `size_t', then we have to pass the size of
4106      the array to the deallocation function, so we will need to store
4107      a cookie.  */
4108   fns = lookup_fnfields (TYPE_BINFO (type),
4109                          ansi_opname (VEC_DELETE_EXPR),
4110                          /*protect=*/0);
4111   /* If there are no `operator []' members, or the lookup is
4112      ambiguous, then we don't need a cookie.  */
4113   if (!fns || fns == error_mark_node)
4114     return false;
4115   /* Loop through all of the functions.  */
4116   for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4117     {
4118       tree fn;
4119       tree second_parm;
4120
4121       /* Select the current function.  */
4122       fn = OVL_CURRENT (fns);
4123       /* See if this function is a one-argument delete function.  If
4124          it is, then it will be the usual deallocation function.  */
4125       second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4126       if (second_parm == void_list_node)
4127         return false;
4128       /* Otherwise, if we have a two-argument function and the second
4129          argument is `size_t', it will be the usual deallocation
4130          function -- unless there is one-argument function, too.  */
4131       if (TREE_CHAIN (second_parm) == void_list_node
4132           && same_type_p (TREE_VALUE (second_parm), sizetype))
4133         has_two_argument_delete_p = true;
4134     }
4135
4136   return has_two_argument_delete_p;
4137 }
4138
4139 /* Check the validity of the bases and members declared in T.  Add any
4140    implicitly-generated functions (like copy-constructors and
4141    assignment operators).  Compute various flag bits (like
4142    CLASSTYPE_NON_POD_T) for T.  This routine works purely at the C++
4143    level: i.e., independently of the ABI in use.  */
4144
4145 static void
4146 check_bases_and_members (tree t)
4147 {
4148   /* Nonzero if we are not allowed to generate a default constructor
4149      for this case.  */
4150   int cant_have_default_ctor;
4151   /* Nonzero if the implicitly generated copy constructor should take
4152      a non-const reference argument.  */
4153   int cant_have_const_ctor;
4154   /* Nonzero if the the implicitly generated assignment operator
4155      should take a non-const reference argument.  */
4156   int no_const_asn_ref;
4157   tree access_decls;
4158
4159   /* By default, we use const reference arguments and generate default
4160      constructors.  */
4161   cant_have_default_ctor = 0;
4162   cant_have_const_ctor = 0;
4163   no_const_asn_ref = 0;
4164
4165   /* Check all the base-classes.  */
4166   check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor,
4167                &no_const_asn_ref);
4168
4169   /* Check all the data member declarations.  */
4170   check_field_decls (t, &access_decls,
4171                      &cant_have_default_ctor,
4172                      &cant_have_const_ctor,
4173                      &no_const_asn_ref);
4174
4175   /* Check all the method declarations.  */
4176   check_methods (t);
4177
4178   /* A nearly-empty class has to be vptr-containing; a nearly empty
4179      class contains just a vptr.  */
4180   if (!TYPE_CONTAINS_VPTR_P (t))
4181     CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4182
4183   /* Do some bookkeeping that will guide the generation of implicitly
4184      declared member functions.  */
4185   TYPE_HAS_COMPLEX_INIT_REF (t)
4186     |= (TYPE_HAS_INIT_REF (t)
4187         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4188         || TYPE_POLYMORPHIC_P (t));
4189   TYPE_NEEDS_CONSTRUCTING (t)
4190     |= (TYPE_HAS_CONSTRUCTOR (t)
4191         || TYPE_USES_VIRTUAL_BASECLASSES (t)
4192         || TYPE_POLYMORPHIC_P (t));
4193   CLASSTYPE_NON_AGGREGATE (t) |= (TYPE_HAS_CONSTRUCTOR (t)
4194                                   || TYPE_POLYMORPHIC_P (t));
4195   CLASSTYPE_NON_POD_P (t)
4196     |= (CLASSTYPE_NON_AGGREGATE (t) || TYPE_HAS_DESTRUCTOR (t)
4197         || TYPE_HAS_ASSIGN_REF (t));
4198   TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
4199   TYPE_HAS_COMPLEX_ASSIGN_REF (t)
4200     |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t);
4201
4202   /* Synthesize any needed methods.  Note that methods will be synthesized
4203      for anonymous unions; grok_x_components undoes that.  */
4204   add_implicitly_declared_members (t, cant_have_default_ctor,
4205                                    cant_have_const_ctor,
4206                                    no_const_asn_ref);
4207
4208   /* Create the in-charge and not-in-charge variants of constructors
4209      and destructors.  */
4210   clone_constructors_and_destructors (t);
4211
4212   /* Process the using-declarations.  */
4213   for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4214     handle_using_decl (TREE_VALUE (access_decls), t);
4215
4216   /* Build and sort the CLASSTYPE_METHOD_VEC.  */
4217   finish_struct_methods (t);
4218
4219   /* Figure out whether or not we will need a cookie when dynamically
4220      allocating an array of this type.  */
4221   TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4222     = type_requires_array_cookie (t);
4223 }
4224
4225 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4226    accordingly.  If a new vfield was created (because T doesn't have a
4227    primary base class), then the newly created field is returned.  It
4228    is not added to the TYPE_FIELDS list; it is the caller's
4229    responsibility to do that.  Accumulate declared virtual functions
4230    on VIRTUALS_P.  */
4231
4232 static tree
4233 create_vtable_ptr (tree t, tree* virtuals_p)
4234 {
4235   tree fn;
4236
4237   /* Collect the virtual functions declared in T.  */
4238   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4239     if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4240         && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4241       {
4242         tree new_virtual = make_node (TREE_LIST);
4243
4244         BV_FN (new_virtual) = fn;
4245         BV_DELTA (new_virtual) = integer_zero_node;
4246
4247         TREE_CHAIN (new_virtual) = *virtuals_p;
4248         *virtuals_p = new_virtual;
4249       }
4250
4251   /* If we couldn't find an appropriate base class, create a new field
4252      here.  Even if there weren't any new virtual functions, we might need a
4253      new virtual function table if we're supposed to include vptrs in
4254      all classes that need them.  */
4255   if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4256     {
4257       /* We build this decl with vtbl_ptr_type_node, which is a
4258          `vtable_entry_type*'.  It might seem more precise to use
4259          `vtable_entry_type (*)[N]' where N is the number of firtual
4260          functions.  However, that would require the vtable pointer in
4261          base classes to have a different type than the vtable pointer
4262          in derived classes.  We could make that happen, but that
4263          still wouldn't solve all the problems.  In particular, the
4264          type-based alias analysis code would decide that assignments
4265          to the base class vtable pointer can't alias assignments to
4266          the derived class vtable pointer, since they have different
4267          types.  Thus, in a derived class destructor, where the base
4268          class constructor was inlined, we could generate bad code for
4269          setting up the vtable pointer.
4270
4271          Therefore, we use one type for all vtable pointers.  We still
4272          use a type-correct type; it's just doesn't indicate the array
4273          bounds.  That's better than using `void*' or some such; it's
4274          cleaner, and it let's the alias analysis code know that these
4275          stores cannot alias stores to void*!  */
4276       tree field;
4277
4278       field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4279       SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE));
4280       DECL_VIRTUAL_P (field) = 1;
4281       DECL_ARTIFICIAL (field) = 1;
4282       DECL_FIELD_CONTEXT (field) = t;
4283       DECL_FCONTEXT (field) = t;
4284
4285       TYPE_VFIELD (t) = field;
4286
4287       /* This class is non-empty.  */
4288       CLASSTYPE_EMPTY_P (t) = 0;
4289
4290       if (CLASSTYPE_N_BASECLASSES (t))
4291         /* If there were any baseclasses, they can't possibly be at
4292            offset zero any more, because that's where the vtable
4293            pointer is.  So, converting to a base class is going to
4294            take work.  */
4295         TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1;
4296
4297       return field;
4298     }
4299
4300   return NULL_TREE;
4301 }
4302
4303 /* Fixup the inline function given by INFO now that the class is
4304    complete.  */
4305
4306 static void
4307 fixup_pending_inline (tree fn)
4308 {
4309   if (DECL_PENDING_INLINE_INFO (fn))
4310     {
4311       tree args = DECL_ARGUMENTS (fn);
4312       while (args)
4313         {
4314           DECL_CONTEXT (args) = fn;
4315           args = TREE_CHAIN (args);
4316         }
4317     }
4318 }
4319
4320 /* Fixup the inline methods and friends in TYPE now that TYPE is
4321    complete.  */
4322
4323 static void
4324 fixup_inline_methods (tree type)
4325 {
4326   tree method = TYPE_METHODS (type);
4327
4328   if (method && TREE_CODE (method) == TREE_VEC)
4329     {
4330       if (TREE_VEC_ELT (method, 1))
4331         method = TREE_VEC_ELT (method, 1);
4332       else if (TREE_VEC_ELT (method, 0))
4333         method = TREE_VEC_ELT (method, 0);
4334       else
4335         method = TREE_VEC_ELT (method, 2);
4336     }
4337
4338   /* Do inline member functions.  */
4339   for (; method; method = TREE_CHAIN (method))
4340     fixup_pending_inline (method);
4341
4342   /* Do friends.  */
4343   for (method = CLASSTYPE_INLINE_FRIENDS (type);
4344        method;
4345        method = TREE_CHAIN (method))
4346     fixup_pending_inline (TREE_VALUE (method));
4347   CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE;
4348 }
4349
4350 /* Add OFFSET to all base types of BINFO which is a base in the
4351    hierarchy dominated by T.
4352
4353    OFFSET, which is a type offset, is number of bytes.  */
4354
4355 static void
4356 propagate_binfo_offsets (tree binfo, tree offset)
4357 {
4358   int i;
4359   tree primary_binfo;
4360
4361   /* Update BINFO's offset.  */
4362   BINFO_OFFSET (binfo)
4363     = convert (sizetype,
4364                size_binop (PLUS_EXPR,
4365                            convert (ssizetype, BINFO_OFFSET (binfo)),
4366                            offset));
4367
4368   /* Find the primary base class.  */
4369   primary_binfo = get_primary_binfo (binfo);
4370
4371   /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4372      downwards.  */
4373   for (i = -1; i < BINFO_N_BASETYPES (binfo); ++i)
4374     {
4375       tree base_binfo;
4376
4377       /* On the first time through the loop, do the primary base.
4378          Because the primary base need not be an immediate base, we
4379          must handle the primary base specially.  */
4380       if (i == -1)
4381         {
4382           if (!primary_binfo)
4383             continue;
4384
4385           base_binfo = primary_binfo;
4386         }
4387       else
4388         {
4389           base_binfo = BINFO_BASETYPE (binfo, i);
4390           /* Don't do the primary base twice.  */
4391           if (base_binfo == primary_binfo)
4392             continue;
4393         }
4394
4395       /* Skip virtual bases that aren't our canonical primary base.  */
4396       if (TREE_VIA_VIRTUAL (base_binfo)
4397           && BINFO_PRIMARY_BASE_OF (base_binfo) != binfo)
4398         continue;
4399
4400       propagate_binfo_offsets (base_binfo, offset);
4401     }
4402 }
4403
4404 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T.  Update
4405    TYPE_ALIGN and TYPE_SIZE for T.  OFFSETS gives the location of
4406    empty subobjects of T.  */
4407
4408 static void
4409 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4410 {
4411   tree vbase;
4412   tree t = rli->t;
4413   bool first_vbase = true;
4414   tree *next_field;
4415
4416   if (CLASSTYPE_N_BASECLASSES (t) == 0)
4417     return;
4418
4419   if (!abi_version_at_least(2))
4420     {
4421       /* In G++ 3.2, we incorrectly rounded the size before laying out
4422          the virtual bases.  */
4423       finish_record_layout (rli, /*free_p=*/false);
4424 #ifdef STRUCTURE_SIZE_BOUNDARY
4425       /* Packed structures don't need to have minimum size.  */
4426       if (! TYPE_PACKED (t))
4427         TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4428 #endif
4429       rli->offset = TYPE_SIZE_UNIT (t);
4430       rli->bitpos = bitsize_zero_node;
4431       rli->record_align = TYPE_ALIGN (t);
4432     }
4433
4434   /* Find the last field.  The artificial fields created for virtual
4435      bases will go after the last extant field to date.  */
4436   next_field = &TYPE_FIELDS (t);
4437   while (*next_field)
4438     next_field = &TREE_CHAIN (*next_field);
4439
4440   /* Go through the virtual bases, allocating space for each virtual
4441      base that is not already a primary base class.  These are
4442      allocated in inheritance graph order.  */
4443   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4444     {
4445       if (!TREE_VIA_VIRTUAL (vbase))
4446         continue;
4447
4448       if (!BINFO_PRIMARY_P (vbase))
4449         {
4450           tree basetype = TREE_TYPE (vbase);
4451
4452           /* This virtual base is not a primary base of any class in the
4453              hierarchy, so we have to add space for it.  */
4454           next_field = build_base_field (rli, vbase,
4455                                          offsets, next_field);
4456
4457           /* If the first virtual base might have been placed at a
4458              lower address, had we started from CLASSTYPE_SIZE, rather
4459              than TYPE_SIZE, issue a warning.  There can be both false
4460              positives and false negatives from this warning in rare
4461              cases; to deal with all the possibilities would probably
4462              require performing both layout algorithms and comparing
4463              the results which is not particularly tractable.  */
4464           if (warn_abi
4465               && first_vbase
4466               && (tree_int_cst_lt
4467                   (size_binop (CEIL_DIV_EXPR,
4468                                round_up (CLASSTYPE_SIZE (t),
4469                                          CLASSTYPE_ALIGN (basetype)),
4470                                bitsize_unit_node),
4471                    BINFO_OFFSET (vbase))))
4472             warning ("offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC",
4473                      basetype);
4474
4475           first_vbase = false;
4476         }
4477     }
4478 }
4479
4480 /* Returns the offset of the byte just past the end of the base class
4481    BINFO.  */
4482
4483 static tree
4484 end_of_base (tree binfo)
4485 {
4486   tree size;
4487
4488   if (is_empty_class (BINFO_TYPE (binfo)))
4489     /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4490        allocate some space for it. It cannot have virtual bases, so
4491        TYPE_SIZE_UNIT is fine.  */
4492     size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4493   else
4494     size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4495
4496   return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4497 }
4498
4499 /* Returns the offset of the byte just past the end of the base class
4500    with the highest offset in T.  If INCLUDE_VIRTUALS_P is zero, then
4501    only non-virtual bases are included.  */
4502
4503 static tree
4504 end_of_class (tree t, int include_virtuals_p)
4505 {
4506   tree result = size_zero_node;
4507   tree binfo;
4508   tree offset;
4509   int i;
4510
4511   for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
4512     {
4513       binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
4514
4515       if (!include_virtuals_p
4516           && TREE_VIA_VIRTUAL (binfo)
4517           && BINFO_PRIMARY_BASE_OF (binfo) != TYPE_BINFO (t))
4518         continue;
4519
4520       offset = end_of_base (binfo);
4521       if (INT_CST_LT_UNSIGNED (result, offset))
4522         result = offset;
4523     }
4524
4525   /* G++ 3.2 did not check indirect virtual bases.  */
4526   if (abi_version_at_least (2) && include_virtuals_p)
4527     for (binfo = CLASSTYPE_VBASECLASSES (t);
4528          binfo;
4529          binfo = TREE_CHAIN (binfo))
4530       {
4531         offset = end_of_base (TREE_VALUE (binfo));
4532         if (INT_CST_LT_UNSIGNED (result, offset))
4533           result = offset;
4534       }
4535
4536   return result;
4537 }
4538
4539 /* Warn about bases of T that are inaccessible because they are
4540    ambiguous.  For example:
4541
4542      struct S {};
4543      struct T : public S {};
4544      struct U : public S, public T {};
4545
4546    Here, `(S*) new U' is not allowed because there are two `S'
4547    subobjects of U.  */
4548
4549 static void
4550 warn_about_ambiguous_bases (tree t)
4551 {
4552   int i;
4553   tree vbases;
4554   tree basetype;
4555
4556   /* Check direct bases.  */
4557   for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
4558     {
4559       basetype = TYPE_BINFO_BASETYPE (t, i);
4560
4561       if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4562         warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
4563                  basetype, t);
4564     }
4565
4566   /* Check for ambiguous virtual bases.  */
4567   if (extra_warnings)
4568     for (vbases = CLASSTYPE_VBASECLASSES (t);
4569          vbases;
4570          vbases = TREE_CHAIN (vbases))
4571       {
4572         basetype = BINFO_TYPE (TREE_VALUE (vbases));
4573
4574         if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4575           warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
4576                    basetype, t);
4577       }
4578 }
4579
4580 /* Compare two INTEGER_CSTs K1 and K2.  */
4581
4582 static int
4583 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4584 {
4585   return tree_int_cst_compare ((tree) k1, (tree) k2);
4586 }
4587
4588 /* Increase the size indicated in RLI to account for empty classes
4589    that are "off the end" of the class.  */
4590
4591 static void
4592 include_empty_classes (record_layout_info rli)
4593 {
4594   tree eoc;
4595   tree rli_size;
4596
4597   /* It might be the case that we grew the class to allocate a
4598      zero-sized base class.  That won't be reflected in RLI, yet,
4599      because we are willing to overlay multiple bases at the same
4600      offset.  However, now we need to make sure that RLI is big enough
4601      to reflect the entire class.  */
4602   eoc = end_of_class (rli->t,
4603                       CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4604   rli_size = rli_size_unit_so_far (rli);
4605   if (TREE_CODE (rli_size) == INTEGER_CST
4606       && INT_CST_LT_UNSIGNED (rli_size, eoc))
4607     {
4608       if (!abi_version_at_least (2))
4609         /* In version 1 of the ABI, the size of a class that ends with
4610            a bitfield was not rounded up to a whole multiple of a
4611            byte.  Because rli_size_unit_so_far returns only the number
4612            of fully allocated bytes, any extra bits were not included
4613            in the size.  */
4614         rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4615       else
4616         /* The size should have been rounded to a whole byte.  */
4617         my_friendly_assert (tree_int_cst_equal (rli->bitpos,
4618                                                 round_down (rli->bitpos,
4619                                                             BITS_PER_UNIT)),
4620                             20030903);
4621       rli->bitpos
4622         = size_binop (PLUS_EXPR,
4623                       rli->bitpos,
4624                       size_binop (MULT_EXPR,
4625                                   convert (bitsizetype,
4626                                            size_binop (MINUS_EXPR,
4627                                                        eoc, rli_size)),
4628                                   bitsize_int (BITS_PER_UNIT)));
4629       normalize_rli (rli);
4630     }
4631 }
4632
4633 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T.  Calculate
4634    BINFO_OFFSETs for all of the base-classes.  Position the vtable
4635    pointer.  Accumulate declared virtual functions on VIRTUALS_P.  */
4636
4637 static void
4638 layout_class_type (tree t, tree *virtuals_p)
4639 {
4640   tree non_static_data_members;
4641   tree field;
4642   tree vptr;
4643   record_layout_info rli;
4644   /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4645      types that appear at that offset.  */
4646   splay_tree empty_base_offsets;
4647   /* True if the last field layed out was a bit-field.  */
4648   bool last_field_was_bitfield = false;
4649   /* The location at which the next field should be inserted.  */
4650   tree *next_field;
4651   /* T, as a base class.  */
4652   tree base_t;
4653
4654   /* Keep track of the first non-static data member.  */
4655   non_static_data_members = TYPE_FIELDS (t);
4656
4657   /* Start laying out the record.  */
4658   rli = start_record_layout (t);
4659
4660   /* If possible, we reuse the virtual function table pointer from one
4661      of our base classes.  */
4662   determine_primary_base (t);
4663
4664   /* Create a pointer to our virtual function table.  */
4665   vptr = create_vtable_ptr (t, virtuals_p);
4666
4667   /* The vptr is always the first thing in the class.  */
4668   if (vptr)
4669     {
4670       TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4671       TYPE_FIELDS (t) = vptr;
4672       next_field = &TREE_CHAIN (vptr);
4673       place_field (rli, vptr);
4674     }
4675   else
4676     next_field = &TYPE_FIELDS (t);
4677
4678   /* Build FIELD_DECLs for all of the non-virtual base-types.  */
4679   empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4680                                        NULL, NULL);
4681   build_base_fields (rli, empty_base_offsets, next_field);
4682
4683   /* Layout the non-static data members.  */
4684   for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4685     {
4686       tree type;
4687       tree padding;
4688
4689       /* We still pass things that aren't non-static data members to
4690          the back-end, in case it wants to do something with them.  */
4691       if (TREE_CODE (field) != FIELD_DECL)
4692         {
4693           place_field (rli, field);
4694           /* If the static data member has incomplete type, keep track
4695              of it so that it can be completed later.  (The handling
4696              of pending statics in finish_record_layout is
4697              insufficient; consider:
4698
4699                struct S1;
4700                struct S2 { static S1 s1; };
4701
4702              At this point, finish_record_layout will be called, but
4703              S1 is still incomplete.)  */
4704           if (TREE_CODE (field) == VAR_DECL)
4705             maybe_register_incomplete_var (field);
4706           continue;
4707         }
4708
4709       type = TREE_TYPE (field);
4710
4711       padding = NULL_TREE;
4712
4713       /* If this field is a bit-field whose width is greater than its
4714          type, then there are some special rules for allocating
4715          it.  */
4716       if (DECL_C_BIT_FIELD (field)
4717           && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4718         {
4719           integer_type_kind itk;
4720           tree integer_type;
4721           bool was_unnamed_p = false;
4722           /* We must allocate the bits as if suitably aligned for the
4723              longest integer type that fits in this many bits.  type
4724              of the field.  Then, we are supposed to use the left over
4725              bits as additional padding.  */
4726           for (itk = itk_char; itk != itk_none; ++itk)
4727             if (INT_CST_LT (DECL_SIZE (field),
4728                             TYPE_SIZE (integer_types[itk])))
4729               break;
4730
4731           /* ITK now indicates a type that is too large for the
4732              field.  We have to back up by one to find the largest
4733              type that fits.  */
4734           integer_type = integer_types[itk - 1];
4735
4736           /* Figure out how much additional padding is required.  GCC
4737              3.2 always created a padding field, even if it had zero
4738              width.  */
4739           if (!abi_version_at_least (2)
4740               || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4741             {
4742               if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4743                 /* In a union, the padding field must have the full width
4744                    of the bit-field; all fields start at offset zero.  */
4745                 padding = DECL_SIZE (field);
4746               else
4747                 {
4748                   if (warn_abi && TREE_CODE (t) == UNION_TYPE)
4749                     warning ("size assigned to `%T' may not be "
4750                              "ABI-compliant and may change in a future "
4751                              "version of GCC",
4752                              t);
4753                   padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4754                                         TYPE_SIZE (integer_type));
4755                 }
4756             }
4757 #ifdef PCC_BITFIELD_TYPE_MATTERS
4758           /* An unnamed bitfield does not normally affect the
4759              alignment of the containing class on a target where
4760              PCC_BITFIELD_TYPE_MATTERS.  But, the C++ ABI does not
4761              make any exceptions for unnamed bitfields when the
4762              bitfields are longer than their types.  Therefore, we
4763              temporarily give the field a name.  */
4764           if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4765             {
4766               was_unnamed_p = true;
4767               DECL_NAME (field) = make_anon_name ();
4768             }
4769 #endif
4770           DECL_SIZE (field) = TYPE_SIZE (integer_type);
4771           DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4772           DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4773           layout_nonempty_base_or_field (rli, field, NULL_TREE,
4774                                          empty_base_offsets);
4775           if (was_unnamed_p)
4776             DECL_NAME (field) = NULL_TREE;
4777           /* Now that layout has been performed, set the size of the
4778              field to the size of its declared type; the rest of the
4779              field is effectively invisible.  */
4780           DECL_SIZE (field) = TYPE_SIZE (type);
4781           /* We must also reset the DECL_MODE of the field.  */
4782           if (abi_version_at_least (2))
4783             DECL_MODE (field) = TYPE_MODE (type);
4784           else if (warn_abi
4785                    && DECL_MODE (field) != TYPE_MODE (type))
4786             /* Versions of G++ before G++ 3.4 did not reset the
4787                DECL_MODE.  */
4788             warning ("the offset of `%D' may not be ABI-compliant and may "
4789                      "change in a future version of GCC", field);
4790         }
4791       else
4792         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4793                                        empty_base_offsets);
4794
4795       /* Remember the location of any empty classes in FIELD.  */
4796       if (abi_version_at_least (2))
4797         record_subobject_offsets (TREE_TYPE (field),
4798                                   byte_position(field),
4799                                   empty_base_offsets,
4800                                   /*vbases_p=*/1);
4801
4802       /* If a bit-field does not immediately follow another bit-field,
4803          and yet it starts in the middle of a byte, we have failed to
4804          comply with the ABI.  */
4805       if (warn_abi
4806           && DECL_C_BIT_FIELD (field)
4807           && !last_field_was_bitfield
4808           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4809                                          DECL_FIELD_BIT_OFFSET (field),
4810                                          bitsize_unit_node)))
4811         cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC",
4812                        field);
4813
4814       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4815          offset of the field.  */
4816       if (warn_abi
4817           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4818                                   byte_position (field))
4819           && contains_empty_class_p (TREE_TYPE (field)))
4820         cp_warning_at ("`%D' contains empty classes which may cause base "
4821                        "classes to be placed at different locations in a "
4822                        "future version of GCC",
4823                        field);
4824
4825       /* If we needed additional padding after this field, add it
4826          now.  */
4827       if (padding)
4828         {
4829           tree padding_field;
4830
4831           padding_field = build_decl (FIELD_DECL,
4832                                       NULL_TREE,
4833                                       char_type_node);
4834           DECL_BIT_FIELD (padding_field) = 1;
4835           DECL_SIZE (padding_field) = padding;
4836           DECL_CONTEXT (padding_field) = t;
4837           DECL_ARTIFICIAL (padding_field) = 1;
4838           layout_nonempty_base_or_field (rli, padding_field,
4839                                          NULL_TREE,
4840                                          empty_base_offsets);
4841         }
4842
4843       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4844     }
4845
4846   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4847     {
4848       /* Make sure that we are on a byte boundary so that the size of
4849          the class without virtual bases will always be a round number
4850          of bytes.  */
4851       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4852       normalize_rli (rli);
4853     }
4854
4855   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4856      padding.  */
4857   if (!abi_version_at_least (2))
4858     include_empty_classes(rli);
4859
4860   /* Delete all zero-width bit-fields from the list of fields.  Now
4861      that the type is laid out they are no longer important.  */
4862   remove_zero_width_bit_fields (t);
4863
4864   /* Create the version of T used for virtual bases.  We do not use
4865      make_aggr_type for this version; this is an artificial type.  For
4866      a POD type, we just reuse T.  */
4867   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4868     {
4869       base_t = make_node (TREE_CODE (t));
4870
4871       /* Set the size and alignment for the new type.  In G++ 3.2, all
4872          empty classes were considered to have size zero when used as
4873          base classes.  */
4874       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4875         {
4876           TYPE_SIZE (base_t) = bitsize_zero_node;
4877           TYPE_SIZE_UNIT (base_t) = size_zero_node;
4878           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4879             warning ("layout of classes derived from empty class `%T' "
4880                      "may change in a future version of GCC",
4881                      t);
4882         }
4883       else
4884         {
4885           tree eoc;
4886
4887           /* If the ABI version is not at least two, and the last
4888              field was a bit-field, RLI may not be on a byte
4889              boundary.  In particular, rli_size_unit_so_far might
4890              indicate the last complete byte, while rli_size_so_far
4891              indicates the total number of bits used.  Therefore,
4892              rli_size_so_far, rather than rli_size_unit_so_far, is
4893              used to compute TYPE_SIZE_UNIT.  */
4894           eoc = end_of_class (t, /*include_virtuals_p=*/0);
4895           TYPE_SIZE_UNIT (base_t)
4896             = size_binop (MAX_EXPR,
4897                           convert (sizetype,
4898                                    size_binop (CEIL_DIV_EXPR,
4899                                                rli_size_so_far (rli),
4900                                                bitsize_int (BITS_PER_UNIT))),
4901                           eoc);
4902           TYPE_SIZE (base_t)
4903             = size_binop (MAX_EXPR,
4904                           rli_size_so_far (rli),
4905                           size_binop (MULT_EXPR,
4906                                       convert (bitsizetype, eoc),
4907                                       bitsize_int (BITS_PER_UNIT)));
4908         }
4909       TYPE_ALIGN (base_t) = rli->record_align;
4910       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4911
4912       /* Copy the fields from T.  */
4913       next_field = &TYPE_FIELDS (base_t);
4914       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4915         if (TREE_CODE (field) == FIELD_DECL)
4916           {
4917             *next_field = build_decl (FIELD_DECL,
4918                                       DECL_NAME (field),
4919                                       TREE_TYPE (field));
4920             DECL_CONTEXT (*next_field) = base_t;
4921             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4922             DECL_FIELD_BIT_OFFSET (*next_field)
4923               = DECL_FIELD_BIT_OFFSET (field);
4924             DECL_SIZE (*next_field) = DECL_SIZE (field);
4925             DECL_MODE (*next_field) = DECL_MODE (field);
4926             next_field = &TREE_CHAIN (*next_field);
4927           }
4928
4929       /* Record the base version of the type.  */
4930       CLASSTYPE_AS_BASE (t) = base_t;
4931       TYPE_CONTEXT (base_t) = t;
4932     }
4933   else
4934     CLASSTYPE_AS_BASE (t) = t;
4935
4936   /* Every empty class contains an empty class.  */
4937   if (CLASSTYPE_EMPTY_P (t))
4938     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
4939
4940   /* Set the TYPE_DECL for this type to contain the right
4941      value for DECL_OFFSET, so that we can use it as part
4942      of a COMPONENT_REF for multiple inheritance.  */
4943   layout_decl (TYPE_MAIN_DECL (t), 0);
4944
4945   /* Now fix up any virtual base class types that we left lying
4946      around.  We must get these done before we try to lay out the
4947      virtual function table.  As a side-effect, this will remove the
4948      base subobject fields.  */
4949   layout_virtual_bases (rli, empty_base_offsets);
4950
4951   /* Make sure that empty classes are reflected in RLI at this
4952      point.  */
4953   include_empty_classes(rli);
4954
4955   /* Make sure not to create any structures with zero size.  */
4956   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
4957     place_field (rli,
4958                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
4959
4960   /* Let the back-end lay out the type.  */
4961   finish_record_layout (rli, /*free_p=*/true);
4962
4963   /* Warn about bases that can't be talked about due to ambiguity.  */
4964   warn_about_ambiguous_bases (t);
4965
4966   /* Clean up.  */
4967   splay_tree_delete (empty_base_offsets);
4968 }
4969
4970 /* Returns the virtual function with which the vtable for TYPE is
4971    emitted, or NULL_TREE if that heuristic is not applicable to TYPE.  */
4972
4973 static tree
4974 key_method (tree type)
4975 {
4976   tree method;
4977
4978   if (TYPE_FOR_JAVA (type)
4979       || processing_template_decl
4980       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4981       || CLASSTYPE_INTERFACE_KNOWN (type))
4982     return NULL_TREE;
4983
4984   for (method = TYPE_METHODS (type); method != NULL_TREE;
4985        method = TREE_CHAIN (method))
4986     if (DECL_VINDEX (method) != NULL_TREE
4987         && ! DECL_DECLARED_INLINE_P (method)
4988         && ! DECL_PURE_VIRTUAL_P (method))
4989       return method;
4990
4991   return NULL_TREE;
4992 }
4993
4994 /* Perform processing required when the definition of T (a class type)
4995    is complete.  */
4996
4997 void
4998 finish_struct_1 (tree t)
4999 {
5000   tree x;
5001   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
5002   tree virtuals = NULL_TREE;
5003   int n_fields = 0;
5004   tree vfield;
5005
5006   if (COMPLETE_TYPE_P (t))
5007     {
5008       if (IS_AGGR_TYPE (t))
5009         error ("redefinition of `%#T'", t);
5010       else
5011         abort ();
5012       popclass ();
5013       return;
5014     }
5015
5016   /* If this type was previously laid out as a forward reference,
5017      make sure we lay it out again.  */
5018   TYPE_SIZE (t) = NULL_TREE;
5019   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5020
5021   fixup_inline_methods (t);
5022
5023   /* Make assumptions about the class; we'll reset the flags if
5024      necessary.  */
5025   CLASSTYPE_EMPTY_P (t) = 1;
5026   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5027   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5028
5029   /* Do end-of-class semantic processing: checking the validity of the
5030      bases and members and add implicitly generated methods.  */
5031   check_bases_and_members (t);
5032
5033   /* Find the key method.  */
5034   if (TYPE_CONTAINS_VPTR_P (t))
5035     {
5036       CLASSTYPE_KEY_METHOD (t) = key_method (t);
5037
5038       /* If a polymorphic class has no key method, we may emit the vtable
5039          in every translation unit where the class definition appears.  */
5040       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5041         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5042     }
5043
5044   /* Layout the class itself.  */
5045   layout_class_type (t, &virtuals);
5046   if (CLASSTYPE_AS_BASE (t) != t)
5047     /* We use the base type for trivial assignments, and hence it
5048        needs a mode.  */
5049     compute_record_mode (CLASSTYPE_AS_BASE (t));
5050
5051   /* Make sure that we get our own copy of the vfield FIELD_DECL.  */
5052   vfield = TYPE_VFIELD (t);
5053   if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5054     {
5055       tree primary = CLASSTYPE_PRIMARY_BINFO (t);
5056
5057       my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
5058                                        BINFO_TYPE (primary)),
5059                           20010726);
5060       /* The vtable better be at the start.  */
5061       my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)),
5062                           20010726);
5063       my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)),
5064                           20010726);
5065
5066       vfield = copy_decl (vfield);
5067       DECL_FIELD_CONTEXT (vfield) = t;
5068       TYPE_VFIELD (t) = vfield;
5069     }
5070   else
5071     my_friendly_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t, 20010726);
5072
5073   virtuals = modify_all_vtables (t, nreverse (virtuals));
5074
5075   /* If we created a new vtbl pointer for this class, add it to the
5076      list.  */
5077   if (TYPE_VFIELD (t) && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5078     CLASSTYPE_VFIELDS (t)
5079       = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t));
5080
5081   /* If necessary, create the primary vtable for this class.  */
5082   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5083     {
5084       /* We must enter these virtuals into the table.  */
5085       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5086         build_primary_vtable (NULL_TREE, t);
5087       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5088         /* Here we know enough to change the type of our virtual
5089            function table, but we will wait until later this function.  */
5090         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5091     }
5092
5093   if (TYPE_CONTAINS_VPTR_P (t))
5094     {
5095       int vindex;
5096       tree fn;
5097
5098       if (TYPE_BINFO_VTABLE (t))
5099         my_friendly_assert (DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)),
5100                             20000116);
5101       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5102         my_friendly_assert (TYPE_BINFO_VIRTUALS (t) == NULL_TREE,
5103                             20000116);
5104
5105       /* Add entries for virtual functions introduced by this class.  */
5106       TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t), virtuals);
5107
5108       /* Set DECL_VINDEX for all functions declared in this class.  */
5109       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5110            fn;
5111            fn = TREE_CHAIN (fn),
5112              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5113                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5114         {
5115           tree fndecl = BV_FN (fn);
5116
5117           if (DECL_THUNK_P (fndecl))
5118             /* A thunk. We should never be calling this entry directly
5119                from this vtable -- we'd use the entry for the non
5120                thunk base function.  */
5121             DECL_VINDEX (fndecl) = NULL_TREE;
5122           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5123             DECL_VINDEX (fndecl) = build_shared_int_cst (vindex);
5124         }
5125     }
5126
5127   finish_struct_bits (t);
5128
5129   /* Complete the rtl for any static member objects of the type we're
5130      working on.  */
5131   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5132     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5133         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5134       DECL_MODE (x) = TYPE_MODE (t);
5135
5136   /* Done with FIELDS...now decide whether to sort these for
5137      faster lookups later.
5138
5139      We use a small number because most searches fail (succeeding
5140      ultimately as the search bores through the inheritance
5141      hierarchy), and we want this failure to occur quickly.  */
5142
5143   n_fields = count_fields (TYPE_FIELDS (t));
5144   if (n_fields > 7)
5145     {
5146       struct sorted_fields_type *field_vec = ggc_alloc (sizeof (struct sorted_fields_type)
5147         + n_fields * sizeof (tree));
5148       field_vec->len = n_fields;
5149       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5150       qsort (field_vec->elts, n_fields, sizeof (tree),
5151              field_decl_cmp);
5152       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5153         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5154       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5155     }
5156
5157   if (TYPE_HAS_CONSTRUCTOR (t))
5158     {
5159       tree vfields = CLASSTYPE_VFIELDS (t);
5160
5161       for (vfields = CLASSTYPE_VFIELDS (t);
5162            vfields; vfields = TREE_CHAIN (vfields))
5163         /* Mark the fact that constructor for T could affect anybody
5164            inheriting from T who wants to initialize vtables for
5165            VFIELDS's type.  */
5166         if (VF_BINFO_VALUE (vfields))
5167           TREE_ADDRESSABLE (vfields) = 1;
5168     }
5169
5170   /* Make the rtl for any new vtables we have created, and unmark
5171      the base types we marked.  */
5172   finish_vtbls (t);
5173
5174   /* Build the VTT for T.  */
5175   build_vtt (t);
5176
5177   if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
5178       && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE)
5179     warning ("`%#T' has virtual functions but non-virtual destructor", t);
5180
5181   complete_vars (t);
5182
5183   if (warn_overloaded_virtual)
5184     warn_hidden (t);
5185
5186   maybe_suppress_debug_info (t);
5187
5188   dump_class_hierarchy (t);
5189
5190   /* Finish debugging output for this type.  */
5191   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5192 }
5193
5194 /* When T was built up, the member declarations were added in reverse
5195    order.  Rearrange them to declaration order.  */
5196
5197 void
5198 unreverse_member_declarations (tree t)
5199 {
5200   tree next;
5201   tree prev;
5202   tree x;
5203
5204   /* The following lists are all in reverse order.  Put them in
5205      declaration order now.  */
5206   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5207   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5208
5209   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5210      reverse order, so we can't just use nreverse.  */
5211   prev = NULL_TREE;
5212   for (x = TYPE_FIELDS (t);
5213        x && TREE_CODE (x) != TYPE_DECL;
5214        x = next)
5215     {
5216       next = TREE_CHAIN (x);
5217       TREE_CHAIN (x) = prev;
5218       prev = x;
5219     }
5220   if (prev)
5221     {
5222       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5223       if (prev)
5224         TYPE_FIELDS (t) = prev;
5225     }
5226 }
5227
5228 tree
5229 finish_struct (tree t, tree attributes)
5230 {
5231   location_t saved_loc = input_location;
5232
5233   /* Now that we've got all the field declarations, reverse everything
5234      as necessary.  */
5235   unreverse_member_declarations (t);
5236
5237   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5238
5239   /* Nadger the current location so that diagnostics point to the start of
5240      the struct, not the end.  */
5241   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5242
5243   if (processing_template_decl)
5244     {
5245       finish_struct_methods (t);
5246       TYPE_SIZE (t) = bitsize_zero_node;
5247       TYPE_SIZE_UNIT (t) = size_zero_node;
5248     }
5249   else
5250     finish_struct_1 (t);
5251
5252   input_location = saved_loc;
5253
5254   TYPE_BEING_DEFINED (t) = 0;
5255
5256   if (current_class_type)
5257     popclass ();
5258   else
5259     error ("trying to finish struct, but kicked out due to previous parse errors");
5260
5261   if (processing_template_decl && at_function_scope_p ())
5262     add_stmt (build_min (TAG_DEFN, t));
5263
5264   return t;
5265 }
5266 \f
5267 /* Return the dynamic type of INSTANCE, if known.
5268    Used to determine whether the virtual function table is needed
5269    or not.
5270
5271    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5272    of our knowledge of its type.  *NONNULL should be initialized
5273    before this function is called.  */
5274
5275 static tree
5276 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5277 {
5278   switch (TREE_CODE (instance))
5279     {
5280     case INDIRECT_REF:
5281       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5282         return NULL_TREE;
5283       else
5284         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5285                                    nonnull, cdtorp);
5286
5287     case CALL_EXPR:
5288       /* This is a call to a constructor, hence it's never zero.  */
5289       if (TREE_HAS_CONSTRUCTOR (instance))
5290         {
5291           if (nonnull)
5292             *nonnull = 1;
5293           return TREE_TYPE (instance);
5294         }
5295       return NULL_TREE;
5296
5297     case SAVE_EXPR:
5298       /* This is a call to a constructor, hence it's never zero.  */
5299       if (TREE_HAS_CONSTRUCTOR (instance))
5300         {
5301           if (nonnull)
5302             *nonnull = 1;
5303           return TREE_TYPE (instance);
5304         }
5305       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5306
5307     case RTL_EXPR:
5308       return NULL_TREE;
5309
5310     case PLUS_EXPR:
5311     case MINUS_EXPR:
5312       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5313         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5314       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5315         /* Propagate nonnull.  */
5316         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5317       return NULL_TREE;
5318
5319     case NOP_EXPR:
5320     case CONVERT_EXPR:
5321       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5322
5323     case ADDR_EXPR:
5324       if (nonnull)
5325         *nonnull = 1;
5326       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5327
5328     case COMPONENT_REF:
5329       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5330
5331     case VAR_DECL:
5332     case FIELD_DECL:
5333       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5334           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5335         {
5336           if (nonnull)
5337             *nonnull = 1;
5338           return TREE_TYPE (TREE_TYPE (instance));
5339         }
5340       /* fall through...  */
5341     case TARGET_EXPR:
5342     case PARM_DECL:
5343     case RESULT_DECL:
5344       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5345         {
5346           if (nonnull)
5347             *nonnull = 1;
5348           return TREE_TYPE (instance);
5349         }
5350       else if (instance == current_class_ptr)
5351         {
5352           if (nonnull)
5353             *nonnull = 1;
5354
5355           /* if we're in a ctor or dtor, we know our type.  */
5356           if (DECL_LANG_SPECIFIC (current_function_decl)
5357               && (DECL_CONSTRUCTOR_P (current_function_decl)
5358                   || DECL_DESTRUCTOR_P (current_function_decl)))
5359             {
5360               if (cdtorp)
5361                 *cdtorp = 1;
5362               return TREE_TYPE (TREE_TYPE (instance));
5363             }
5364         }
5365       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5366         {
5367           /* Reference variables should be references to objects.  */
5368           if (nonnull)
5369             *nonnull = 1;
5370
5371           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5372              variable's initializer may refer to the variable
5373              itself.  */
5374           if (TREE_CODE (instance) == VAR_DECL
5375               && DECL_INITIAL (instance)
5376               && !DECL_VAR_MARKED_P (instance))
5377             {
5378               tree type;
5379               DECL_VAR_MARKED_P (instance) = 1;
5380               type = fixed_type_or_null (DECL_INITIAL (instance),
5381                                          nonnull, cdtorp);
5382               DECL_VAR_MARKED_P (instance) = 0;
5383               return type;
5384             }
5385         }
5386       return NULL_TREE;
5387
5388     default:
5389       return NULL_TREE;
5390     }
5391 }
5392
5393 /* Return nonzero if the dynamic type of INSTANCE is known, and
5394    equivalent to the static type.  We also handle the case where
5395    INSTANCE is really a pointer. Return negative if this is a
5396    ctor/dtor. There the dynamic type is known, but this might not be
5397    the most derived base of the original object, and hence virtual
5398    bases may not be layed out according to this type.
5399
5400    Used to determine whether the virtual function table is needed
5401    or not.
5402
5403    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5404    of our knowledge of its type.  *NONNULL should be initialized
5405    before this function is called.  */
5406
5407 int
5408 resolves_to_fixed_type_p (tree instance, int* nonnull)
5409 {
5410   tree t = TREE_TYPE (instance);
5411   int cdtorp = 0;
5412
5413   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5414   if (fixed == NULL_TREE)
5415     return 0;
5416   if (POINTER_TYPE_P (t))
5417     t = TREE_TYPE (t);
5418   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5419     return 0;
5420   return cdtorp ? -1 : 1;
5421 }
5422
5423 \f
5424 void
5425 init_class_processing (void)
5426 {
5427   current_class_depth = 0;
5428   current_class_stack_size = 10;
5429   current_class_stack
5430     = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5431   VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5432
5433   ridpointers[(int) RID_PUBLIC] = access_public_node;
5434   ridpointers[(int) RID_PRIVATE] = access_private_node;
5435   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5436 }
5437
5438 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5439    appropriate for TYPE.
5440
5441    So that we may avoid calls to lookup_name, we cache the _TYPE
5442    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5443
5444    For multiple inheritance, we perform a two-pass depth-first search
5445    of the type lattice.  The first pass performs a pre-order search,
5446    marking types after the type has had its fields installed in
5447    the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
5448    unmarks the marked types.  If a field or member function name
5449    appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5450    that name becomes `error_mark_node'.  */
5451
5452 void
5453 pushclass (tree type)
5454 {
5455   type = TYPE_MAIN_VARIANT (type);
5456
5457   /* Make sure there is enough room for the new entry on the stack.  */
5458   if (current_class_depth + 1 >= current_class_stack_size)
5459     {
5460       current_class_stack_size *= 2;
5461       current_class_stack
5462         = xrealloc (current_class_stack,
5463                     current_class_stack_size
5464                     * sizeof (struct class_stack_node));
5465     }
5466
5467   /* Insert a new entry on the class stack.  */
5468   current_class_stack[current_class_depth].name = current_class_name;
5469   current_class_stack[current_class_depth].type = current_class_type;
5470   current_class_stack[current_class_depth].access = current_access_specifier;
5471   current_class_stack[current_class_depth].names_used = 0;
5472   current_class_depth++;
5473
5474   /* Now set up the new type.  */
5475   current_class_name = TYPE_NAME (type);
5476   if (TREE_CODE (current_class_name) == TYPE_DECL)
5477     current_class_name = DECL_NAME (current_class_name);
5478   current_class_type = type;
5479
5480   /* By default, things in classes are private, while things in
5481      structures or unions are public.  */
5482   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5483                               ? access_private_node
5484                               : access_public_node);
5485
5486   if (previous_class_type != NULL_TREE
5487       && (type != previous_class_type
5488           || !COMPLETE_TYPE_P (previous_class_type))
5489       && current_class_depth == 1)
5490     {
5491       /* Forcibly remove any old class remnants.  */
5492       invalidate_class_lookup_cache ();
5493     }
5494
5495   /* If we're about to enter a nested class, clear
5496      IDENTIFIER_CLASS_VALUE for the enclosing classes.  */
5497   if (current_class_depth > 1)
5498     clear_identifier_class_values ();
5499
5500   pushlevel_class ();
5501
5502   if (type != previous_class_type || current_class_depth > 1)
5503     {
5504       push_class_decls (type);
5505       if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type))
5506         {
5507           /* If we are entering the scope of a template declaration (not a
5508              specialization), we need to push all the using decls with
5509              dependent scope too.  */
5510           tree fields;
5511
5512           for (fields = TYPE_FIELDS (type);
5513                fields; fields = TREE_CHAIN (fields))
5514             if (TREE_CODE (fields) == USING_DECL && !TREE_TYPE (fields))
5515               pushdecl_class_level (fields);
5516         }
5517     }
5518   else
5519     {
5520       tree item;
5521
5522       /* We are re-entering the same class we just left, so we don't
5523          have to search the whole inheritance matrix to find all the
5524          decls to bind again.  Instead, we install the cached
5525          class_shadowed list, and walk through it binding names and
5526          setting up IDENTIFIER_TYPE_VALUEs.  */
5527       set_class_shadows (previous_class_values);
5528       for (item = previous_class_values; item; item = TREE_CHAIN (item))
5529         {
5530           tree id = TREE_PURPOSE (item);
5531           tree decl = TREE_TYPE (item);
5532
5533           push_class_binding (id, decl);
5534           if (TREE_CODE (decl) == TYPE_DECL)
5535             set_identifier_type_value (id, decl);
5536         }
5537       unuse_fields (type);
5538     }
5539
5540   cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type));
5541 }
5542
5543 /* When we exit a toplevel class scope, we save the
5544    IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5545    reenter the class.  Here, we've entered some other class, so we
5546    must invalidate our cache.  */
5547
5548 void
5549 invalidate_class_lookup_cache (void)
5550 {
5551   tree t;
5552
5553   /* The IDENTIFIER_CLASS_VALUEs are no longer valid.  */
5554   for (t = previous_class_values; t; t = TREE_CHAIN (t))
5555     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
5556
5557   previous_class_values = NULL_TREE;
5558   previous_class_type = NULL_TREE;
5559 }
5560
5561 /* Get out of the current class scope. If we were in a class scope
5562    previously, that is the one popped to.  */
5563
5564 void
5565 popclass (void)
5566 {
5567   poplevel_class ();
5568   pop_class_decls ();
5569
5570   current_class_depth--;
5571   current_class_name = current_class_stack[current_class_depth].name;
5572   current_class_type = current_class_stack[current_class_depth].type;
5573   current_access_specifier = current_class_stack[current_class_depth].access;
5574   if (current_class_stack[current_class_depth].names_used)
5575     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5576 }
5577
5578 /* Returns 1 if current_class_type is either T or a nested type of T.
5579    We start looking from 1 because entry 0 is from global scope, and has
5580    no type.  */
5581
5582 int
5583 currently_open_class (tree t)
5584 {
5585   int i;
5586   if (current_class_type && same_type_p (t, current_class_type))
5587     return 1;
5588   for (i = 1; i < current_class_depth; ++i)
5589     if (current_class_stack[i].type
5590         && same_type_p (current_class_stack [i].type, t))
5591       return 1;
5592   return 0;
5593 }
5594
5595 /* If either current_class_type or one of its enclosing classes are derived
5596    from T, return the appropriate type.  Used to determine how we found
5597    something via unqualified lookup.  */
5598
5599 tree
5600 currently_open_derived_class (tree t)
5601 {
5602   int i;
5603
5604   /* The bases of a dependent type are unknown.  */
5605   if (dependent_type_p (t))
5606     return NULL_TREE;
5607
5608   if (!current_class_type)
5609     return NULL_TREE;
5610
5611   if (DERIVED_FROM_P (t, current_class_type))
5612     return current_class_type;
5613
5614   for (i = current_class_depth - 1; i > 0; --i)
5615     if (DERIVED_FROM_P (t, current_class_stack[i].type))
5616       return current_class_stack[i].type;
5617
5618   return NULL_TREE;
5619 }
5620
5621 /* When entering a class scope, all enclosing class scopes' names with
5622    static meaning (static variables, static functions, types and
5623    enumerators) have to be visible.  This recursive function calls
5624    pushclass for all enclosing class contexts until global or a local
5625    scope is reached.  TYPE is the enclosed class.  */
5626
5627 void
5628 push_nested_class (tree type)
5629 {
5630   tree context;
5631
5632   /* A namespace might be passed in error cases, like A::B:C.  */
5633   if (type == NULL_TREE
5634       || type == error_mark_node
5635       || TREE_CODE (type) == NAMESPACE_DECL
5636       || ! IS_AGGR_TYPE (type)
5637       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5638       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5639     return;
5640
5641   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5642
5643   if (context && CLASS_TYPE_P (context))
5644     push_nested_class (context);
5645   pushclass (type);
5646 }
5647
5648 /* Undoes a push_nested_class call.  */
5649
5650 void
5651 pop_nested_class (void)
5652 {
5653   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5654
5655   popclass ();
5656   if (context && CLASS_TYPE_P (context))
5657     pop_nested_class ();
5658 }
5659
5660 /* Returns the number of extern "LANG" blocks we are nested within.  */
5661
5662 int
5663 current_lang_depth (void)
5664 {
5665   return VARRAY_ACTIVE_SIZE (current_lang_base);
5666 }
5667
5668 /* Set global variables CURRENT_LANG_NAME to appropriate value
5669    so that behavior of name-mangling machinery is correct.  */
5670
5671 void
5672 push_lang_context (tree name)
5673 {
5674   VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5675
5676   if (name == lang_name_cplusplus)
5677     {
5678       current_lang_name = name;
5679     }
5680   else if (name == lang_name_java)
5681     {
5682       current_lang_name = name;
5683       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5684          (See record_builtin_java_type in decl.c.)  However, that causes
5685          incorrect debug entries if these types are actually used.
5686          So we re-enable debug output after extern "Java".  */
5687       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5688       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5689       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5690       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5691       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5692       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5693       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5694       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5695     }
5696   else if (name == lang_name_c)
5697     {
5698       current_lang_name = name;
5699     }
5700   else
5701     error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
5702 }
5703
5704 /* Get out of the current language scope.  */
5705
5706 void
5707 pop_lang_context (void)
5708 {
5709   current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5710   VARRAY_POP (current_lang_base);
5711 }
5712 \f
5713 /* Type instantiation routines.  */
5714
5715 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5716    matches the TARGET_TYPE.  If there is no satisfactory match, return
5717    error_mark_node, and issue a error & warning messages under control
5718    of FLAGS.  Permit pointers to member function if FLAGS permits.  If
5719    TEMPLATE_ONLY, the name of the overloaded function was a
5720    template-id, and EXPLICIT_TARGS are the explicitly provided
5721    template arguments.  */
5722
5723 static tree
5724 resolve_address_of_overloaded_function (tree target_type,
5725                                         tree overload,
5726                                         tsubst_flags_t flags,
5727                                         bool template_only,
5728                                         tree explicit_targs)
5729 {
5730   /* Here's what the standard says:
5731
5732        [over.over]
5733
5734        If the name is a function template, template argument deduction
5735        is done, and if the argument deduction succeeds, the deduced
5736        arguments are used to generate a single template function, which
5737        is added to the set of overloaded functions considered.
5738
5739        Non-member functions and static member functions match targets of
5740        type "pointer-to-function" or "reference-to-function."  Nonstatic
5741        member functions match targets of type "pointer-to-member
5742        function;" the function type of the pointer to member is used to
5743        select the member function from the set of overloaded member
5744        functions.  If a nonstatic member function is selected, the
5745        reference to the overloaded function name is required to have the
5746        form of a pointer to member as described in 5.3.1.
5747
5748        If more than one function is selected, any template functions in
5749        the set are eliminated if the set also contains a non-template
5750        function, and any given template function is eliminated if the
5751        set contains a second template function that is more specialized
5752        than the first according to the partial ordering rules 14.5.5.2.
5753        After such eliminations, if any, there shall remain exactly one
5754        selected function.  */
5755
5756   int is_ptrmem = 0;
5757   int is_reference = 0;
5758   /* We store the matches in a TREE_LIST rooted here.  The functions
5759      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5760      interoperability with most_specialized_instantiation.  */
5761   tree matches = NULL_TREE;
5762   tree fn;
5763
5764   /* By the time we get here, we should be seeing only real
5765      pointer-to-member types, not the internal POINTER_TYPE to
5766      METHOD_TYPE representation.  */
5767   my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE
5768                         && (TREE_CODE (TREE_TYPE (target_type))
5769                             == METHOD_TYPE)), 0);
5770
5771   my_friendly_assert (is_overloaded_fn (overload), 20030910);
5772
5773   /* Check that the TARGET_TYPE is reasonable.  */
5774   if (TYPE_PTRFN_P (target_type))
5775     /* This is OK.  */;
5776   else if (TYPE_PTRMEMFUNC_P (target_type))
5777     /* This is OK, too.  */
5778     is_ptrmem = 1;
5779   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5780     {
5781       /* This is OK, too.  This comes from a conversion to reference
5782          type.  */
5783       target_type = build_reference_type (target_type);
5784       is_reference = 1;
5785     }
5786   else
5787     {
5788       if (flags & tf_error)
5789         error ("\
5790 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5791                   DECL_NAME (OVL_FUNCTION (overload)), target_type);
5792       return error_mark_node;
5793     }
5794
5795   /* If we can find a non-template function that matches, we can just
5796      use it.  There's no point in generating template instantiations
5797      if we're just going to throw them out anyhow.  But, of course, we
5798      can only do this when we don't *need* a template function.  */
5799   if (!template_only)
5800     {
5801       tree fns;
5802
5803       for (fns = overload; fns; fns = OVL_NEXT (fns))
5804         {
5805           tree fn = OVL_CURRENT (fns);
5806           tree fntype;
5807
5808           if (TREE_CODE (fn) == TEMPLATE_DECL)
5809             /* We're not looking for templates just yet.  */
5810             continue;
5811
5812           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5813               != is_ptrmem)
5814             /* We're looking for a non-static member, and this isn't
5815                one, or vice versa.  */
5816             continue;
5817
5818           /* Ignore anticipated decls of undeclared builtins.  */
5819           if (DECL_ANTICIPATED (fn))
5820             continue;
5821
5822           /* See if there's a match.  */
5823           fntype = TREE_TYPE (fn);
5824           if (is_ptrmem)
5825             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5826           else if (!is_reference)
5827             fntype = build_pointer_type (fntype);
5828
5829           if (can_convert_arg (target_type, fntype, fn))
5830             matches = tree_cons (fn, NULL_TREE, matches);
5831         }
5832     }
5833
5834   /* Now, if we've already got a match (or matches), there's no need
5835      to proceed to the template functions.  But, if we don't have a
5836      match we need to look at them, too.  */
5837   if (!matches)
5838     {
5839       tree target_fn_type;
5840       tree target_arg_types;
5841       tree target_ret_type;
5842       tree fns;
5843
5844       if (is_ptrmem)
5845         target_fn_type
5846           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5847       else
5848         target_fn_type = TREE_TYPE (target_type);
5849       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5850       target_ret_type = TREE_TYPE (target_fn_type);
5851
5852       /* Never do unification on the 'this' parameter.  */
5853       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5854         target_arg_types = TREE_CHAIN (target_arg_types);
5855
5856       for (fns = overload; fns; fns = OVL_NEXT (fns))
5857         {
5858           tree fn = OVL_CURRENT (fns);
5859           tree instantiation;
5860           tree instantiation_type;
5861           tree targs;
5862
5863           if (TREE_CODE (fn) != TEMPLATE_DECL)
5864             /* We're only looking for templates.  */
5865             continue;
5866
5867           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5868               != is_ptrmem)
5869             /* We're not looking for a non-static member, and this is
5870                one, or vice versa.  */
5871             continue;
5872
5873           /* Try to do argument deduction.  */
5874           targs = make_tree_vec (DECL_NTPARMS (fn));
5875           if (fn_type_unification (fn, explicit_targs, targs,
5876                                    target_arg_types, target_ret_type,
5877                                    DEDUCE_EXACT, -1) != 0)
5878             /* Argument deduction failed.  */
5879             continue;
5880
5881           /* Instantiate the template.  */
5882           instantiation = instantiate_template (fn, targs, flags);
5883           if (instantiation == error_mark_node)
5884             /* Instantiation failed.  */
5885             continue;
5886
5887           /* See if there's a match.  */
5888           instantiation_type = TREE_TYPE (instantiation);
5889           if (is_ptrmem)
5890             instantiation_type =
5891               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5892           else if (!is_reference)
5893             instantiation_type = build_pointer_type (instantiation_type);
5894           if (can_convert_arg (target_type, instantiation_type, instantiation))
5895             matches = tree_cons (instantiation, fn, matches);
5896         }
5897
5898       /* Now, remove all but the most specialized of the matches.  */
5899       if (matches)
5900         {
5901           tree match = most_specialized_instantiation (matches);
5902
5903           if (match != error_mark_node)
5904             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5905         }
5906     }
5907
5908   /* Now we should have exactly one function in MATCHES.  */
5909   if (matches == NULL_TREE)
5910     {
5911       /* There were *no* matches.  */
5912       if (flags & tf_error)
5913         {
5914           error ("no matches converting function `%D' to type `%#T'",
5915                     DECL_NAME (OVL_FUNCTION (overload)),
5916                     target_type);
5917
5918           /* print_candidates expects a chain with the functions in
5919              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5920              so why be clever?).  */
5921           for (; overload; overload = OVL_NEXT (overload))
5922             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5923                                  matches);
5924
5925           print_candidates (matches);
5926         }
5927       return error_mark_node;
5928     }
5929   else if (TREE_CHAIN (matches))
5930     {
5931       /* There were too many matches.  */
5932
5933       if (flags & tf_error)
5934         {
5935           tree match;
5936
5937           error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5938                     DECL_NAME (OVL_FUNCTION (overload)),
5939                     target_type);
5940
5941           /* Since print_candidates expects the functions in the
5942              TREE_VALUE slot, we flip them here.  */
5943           for (match = matches; match; match = TREE_CHAIN (match))
5944             TREE_VALUE (match) = TREE_PURPOSE (match);
5945
5946           print_candidates (matches);
5947         }
5948
5949       return error_mark_node;
5950     }
5951
5952   /* Good, exactly one match.  Now, convert it to the correct type.  */
5953   fn = TREE_PURPOSE (matches);
5954
5955   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5956       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5957     {
5958       static int explained;
5959
5960       if (!(flags & tf_error))
5961         return error_mark_node;
5962
5963       pedwarn ("assuming pointer to member `%D'", fn);
5964       if (!explained)
5965         {
5966           pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
5967           explained = 1;
5968         }
5969     }
5970
5971   /* If we're doing overload resolution purely for the purpose of
5972      determining conversion sequences, we should not consider the
5973      function used.  If this conversion sequence is selected, the
5974      function will be marked as used at this point.  */
5975   if (!(flags & tf_conv))
5976     mark_used (fn);
5977
5978   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5979     return build_unary_op (ADDR_EXPR, fn, 0);
5980   else
5981     {
5982       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5983          will mark the function as addressed, but here we must do it
5984          explicitly.  */
5985       cxx_mark_addressable (fn);
5986
5987       return fn;
5988     }
5989 }
5990
5991 /* This function will instantiate the type of the expression given in
5992    RHS to match the type of LHSTYPE.  If errors exist, then return
5993    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5994    we complain on errors.  If we are not complaining, never modify rhs,
5995    as overload resolution wants to try many possible instantiations, in
5996    the hope that at least one will work.
5997
5998    For non-recursive calls, LHSTYPE should be a function, pointer to
5999    function, or a pointer to member function.  */
6000
6001 tree
6002 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6003 {
6004   tsubst_flags_t flags_in = flags;
6005
6006   flags &= ~tf_ptrmem_ok;
6007
6008   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6009     {
6010       if (flags & tf_error)
6011         error ("not enough type information");
6012       return error_mark_node;
6013     }
6014
6015   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6016     {
6017       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6018         return rhs;
6019       if (flag_ms_extensions
6020           && TYPE_PTRMEMFUNC_P (lhstype)
6021           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6022         /* Microsoft allows `A::f' to be resolved to a
6023            pointer-to-member.  */
6024         ;
6025       else
6026         {
6027           if (flags & tf_error)
6028             error ("argument of type `%T' does not match `%T'",
6029                    TREE_TYPE (rhs), lhstype);
6030           return error_mark_node;
6031         }
6032     }
6033
6034   if (TREE_CODE (rhs) == BASELINK)
6035     rhs = BASELINK_FUNCTIONS (rhs);
6036
6037   /* We don't overwrite rhs if it is an overloaded function.
6038      Copying it would destroy the tree link.  */
6039   if (TREE_CODE (rhs) != OVERLOAD)
6040     rhs = copy_node (rhs);
6041
6042   /* This should really only be used when attempting to distinguish
6043      what sort of a pointer to function we have.  For now, any
6044      arithmetic operation which is not supported on pointers
6045      is rejected as an error.  */
6046
6047   switch (TREE_CODE (rhs))
6048     {
6049     case TYPE_EXPR:
6050     case CONVERT_EXPR:
6051     case SAVE_EXPR:
6052     case CONSTRUCTOR:
6053     case BUFFER_REF:
6054       abort ();
6055       return error_mark_node;
6056
6057     case INDIRECT_REF:
6058     case ARRAY_REF:
6059       {
6060         tree new_rhs;
6061
6062         new_rhs = instantiate_type (build_pointer_type (lhstype),
6063                                     TREE_OPERAND (rhs, 0), flags);
6064         if (new_rhs == error_mark_node)
6065           return error_mark_node;
6066
6067         TREE_TYPE (rhs) = lhstype;
6068         TREE_OPERAND (rhs, 0) = new_rhs;
6069         return rhs;
6070       }
6071
6072     case NOP_EXPR:
6073       rhs = copy_node (TREE_OPERAND (rhs, 0));
6074       TREE_TYPE (rhs) = unknown_type_node;
6075       return instantiate_type (lhstype, rhs, flags);
6076
6077     case COMPONENT_REF:
6078       {
6079         tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6080
6081         if (addr != error_mark_node
6082             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6083           /* Do not lose object's side effects.  */
6084           addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
6085                         TREE_OPERAND (rhs, 0), addr);
6086         return addr;
6087       }
6088
6089     case OFFSET_REF:
6090       rhs = TREE_OPERAND (rhs, 1);
6091       if (BASELINK_P (rhs))
6092         return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
6093
6094       /* This can happen if we are forming a pointer-to-member for a
6095          member template.  */
6096       my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
6097
6098       /* Fall through.  */
6099
6100     case TEMPLATE_ID_EXPR:
6101       {
6102         tree fns = TREE_OPERAND (rhs, 0);
6103         tree args = TREE_OPERAND (rhs, 1);
6104
6105         return
6106           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6107                                                   /*template_only=*/true,
6108                                                   args);
6109       }
6110
6111     case OVERLOAD:
6112     case FUNCTION_DECL:
6113       return
6114         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6115                                                 /*template_only=*/false,
6116                                                 /*explicit_targs=*/NULL_TREE);
6117
6118     case TREE_LIST:
6119       /* Now we should have a baselink.  */
6120       my_friendly_assert (BASELINK_P (rhs), 990412);
6121
6122       return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
6123
6124     case CALL_EXPR:
6125       /* This is too hard for now.  */
6126       abort ();
6127       return error_mark_node;
6128
6129     case PLUS_EXPR:
6130     case MINUS_EXPR:
6131     case COMPOUND_EXPR:
6132       TREE_OPERAND (rhs, 0)
6133         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6134       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6135         return error_mark_node;
6136       TREE_OPERAND (rhs, 1)
6137         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6138       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6139         return error_mark_node;
6140
6141       TREE_TYPE (rhs) = lhstype;
6142       return rhs;
6143
6144     case MULT_EXPR:
6145     case TRUNC_DIV_EXPR:
6146     case FLOOR_DIV_EXPR:
6147     case CEIL_DIV_EXPR:
6148     case ROUND_DIV_EXPR:
6149     case RDIV_EXPR:
6150     case TRUNC_MOD_EXPR:
6151     case FLOOR_MOD_EXPR:
6152     case CEIL_MOD_EXPR:
6153     case ROUND_MOD_EXPR:
6154     case FIX_ROUND_EXPR:
6155     case FIX_FLOOR_EXPR:
6156     case FIX_CEIL_EXPR:
6157     case FIX_TRUNC_EXPR:
6158     case FLOAT_EXPR:
6159     case NEGATE_EXPR:
6160     case ABS_EXPR:
6161     case MAX_EXPR:
6162     case MIN_EXPR:
6163
6164     case BIT_AND_EXPR:
6165     case BIT_IOR_EXPR:
6166     case BIT_XOR_EXPR:
6167     case LSHIFT_EXPR:
6168     case RSHIFT_EXPR:
6169     case LROTATE_EXPR:
6170     case RROTATE_EXPR:
6171
6172     case PREINCREMENT_EXPR:
6173     case PREDECREMENT_EXPR:
6174     case POSTINCREMENT_EXPR:
6175     case POSTDECREMENT_EXPR:
6176       if (flags & tf_error)
6177         error ("invalid operation on uninstantiated type");
6178       return error_mark_node;
6179
6180     case TRUTH_AND_EXPR:
6181     case TRUTH_OR_EXPR:
6182     case TRUTH_XOR_EXPR:
6183     case LT_EXPR:
6184     case LE_EXPR:
6185     case GT_EXPR:
6186     case GE_EXPR:
6187     case EQ_EXPR:
6188     case NE_EXPR:
6189     case TRUTH_ANDIF_EXPR:
6190     case TRUTH_ORIF_EXPR:
6191     case TRUTH_NOT_EXPR:
6192       if (flags & tf_error)
6193         error ("not enough type information");
6194       return error_mark_node;
6195
6196     case COND_EXPR:
6197       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6198         {
6199           if (flags & tf_error)
6200             error ("not enough type information");
6201           return error_mark_node;
6202         }
6203       TREE_OPERAND (rhs, 1)
6204         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6205       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6206         return error_mark_node;
6207       TREE_OPERAND (rhs, 2)
6208         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6209       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6210         return error_mark_node;
6211
6212       TREE_TYPE (rhs) = lhstype;
6213       return rhs;
6214
6215     case MODIFY_EXPR:
6216       TREE_OPERAND (rhs, 1)
6217         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6218       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6219         return error_mark_node;
6220
6221       TREE_TYPE (rhs) = lhstype;
6222       return rhs;
6223
6224     case ADDR_EXPR:
6225     {
6226       if (PTRMEM_OK_P (rhs))
6227         flags |= tf_ptrmem_ok;
6228
6229       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6230     }
6231     case ENTRY_VALUE_EXPR:
6232       abort ();
6233       return error_mark_node;
6234
6235     case ERROR_MARK:
6236       return error_mark_node;
6237
6238     default:
6239       abort ();
6240       return error_mark_node;
6241     }
6242 }
6243 \f
6244 /* Return the name of the virtual function pointer field
6245    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6246    this may have to look back through base types to find the
6247    ultimate field name.  (For single inheritance, these could
6248    all be the same name.  Who knows for multiple inheritance).  */
6249
6250 static tree
6251 get_vfield_name (tree type)
6252 {
6253   tree binfo = TYPE_BINFO (type);
6254   char *buf;
6255
6256   while (BINFO_BASETYPES (binfo)
6257          && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
6258          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
6259     binfo = BINFO_BASETYPE (binfo, 0);
6260
6261   type = BINFO_TYPE (binfo);
6262   buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6263   sprintf (buf, VFIELD_NAME_FORMAT,
6264            IDENTIFIER_POINTER (constructor_name (type)));
6265   return get_identifier (buf);
6266 }
6267
6268 void
6269 print_class_statistics (void)
6270 {
6271 #ifdef GATHER_STATISTICS
6272   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6273   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6274   if (n_vtables)
6275     {
6276       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6277                n_vtables, n_vtable_searches);
6278       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6279                n_vtable_entries, n_vtable_elems);
6280     }
6281 #endif
6282 }
6283
6284 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6285    according to [class]:
6286                                           The class-name is also inserted
6287    into  the scope of the class itself.  For purposes of access checking,
6288    the inserted class name is treated as if it were a public member name.  */
6289
6290 void
6291 build_self_reference (void)
6292 {
6293   tree name = constructor_name (current_class_type);
6294   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6295   tree saved_cas;
6296
6297   DECL_NONLOCAL (value) = 1;
6298   DECL_CONTEXT (value) = current_class_type;
6299   DECL_ARTIFICIAL (value) = 1;
6300   SET_DECL_SELF_REFERENCE_P (value);
6301
6302   if (processing_template_decl)
6303     value = push_template_decl (value);
6304
6305   saved_cas = current_access_specifier;
6306   current_access_specifier = access_public_node;
6307   finish_member_declaration (value);
6308   current_access_specifier = saved_cas;
6309 }
6310
6311 /* Returns 1 if TYPE contains only padding bytes.  */
6312
6313 int
6314 is_empty_class (tree type)
6315 {
6316   if (type == error_mark_node)
6317     return 0;
6318
6319   if (! IS_AGGR_TYPE (type))
6320     return 0;
6321
6322   /* In G++ 3.2, whether or not a class was empty was determined by
6323      looking at its size.  */
6324   if (abi_version_at_least (2))
6325     return CLASSTYPE_EMPTY_P (type);
6326   else
6327     return integer_zerop (CLASSTYPE_SIZE (type));
6328 }
6329
6330 /* Returns true if TYPE contains an empty class.  */
6331
6332 static bool
6333 contains_empty_class_p (tree type)
6334 {
6335   if (is_empty_class (type))
6336     return true;
6337   if (CLASS_TYPE_P (type))
6338     {
6339       tree field;
6340       int i;
6341
6342       for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
6343         if (contains_empty_class_p (TYPE_BINFO_BASETYPE (type, i)))
6344           return true;
6345       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6346         if (TREE_CODE (field) == FIELD_DECL
6347             && !DECL_ARTIFICIAL (field)
6348             && is_empty_class (TREE_TYPE (field)))
6349           return true;
6350     }
6351   else if (TREE_CODE (type) == ARRAY_TYPE)
6352     return contains_empty_class_p (TREE_TYPE (type));
6353   return false;
6354 }
6355
6356 /* Find the enclosing class of the given NODE.  NODE can be a *_DECL or
6357    a *_TYPE node.  NODE can also be a local class.  */
6358
6359 tree
6360 get_enclosing_class (tree type)
6361 {
6362   tree node = type;
6363
6364   while (node && TREE_CODE (node) != NAMESPACE_DECL)
6365     {
6366       switch (TREE_CODE_CLASS (TREE_CODE (node)))
6367         {
6368         case 'd':
6369           node = DECL_CONTEXT (node);
6370           break;
6371
6372         case 't':
6373           if (node != type)
6374             return node;
6375           node = TYPE_CONTEXT (node);
6376           break;
6377
6378         default:
6379           abort ();
6380         }
6381     }
6382   return NULL_TREE;
6383 }
6384
6385 /* Note that NAME was looked up while the current class was being
6386    defined and that the result of that lookup was DECL.  */
6387
6388 void
6389 maybe_note_name_used_in_class (tree name, tree decl)
6390 {
6391   splay_tree names_used;
6392
6393   /* If we're not defining a class, there's nothing to do.  */
6394   if (innermost_scope_kind() != sk_class)
6395     return;
6396
6397   /* If there's already a binding for this NAME, then we don't have
6398      anything to worry about.  */
6399   if (IDENTIFIER_CLASS_VALUE (name))
6400     return;
6401
6402   if (!current_class_stack[current_class_depth - 1].names_used)
6403     current_class_stack[current_class_depth - 1].names_used
6404       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6405   names_used = current_class_stack[current_class_depth - 1].names_used;
6406
6407   splay_tree_insert (names_used,
6408                      (splay_tree_key) name,
6409                      (splay_tree_value) decl);
6410 }
6411
6412 /* Note that NAME was declared (as DECL) in the current class.  Check
6413    to see that the declaration is valid.  */
6414
6415 void
6416 note_name_declared_in_class (tree name, tree decl)
6417 {
6418   splay_tree names_used;
6419   splay_tree_node n;
6420
6421   /* Look to see if we ever used this name.  */
6422   names_used
6423     = current_class_stack[current_class_depth - 1].names_used;
6424   if (!names_used)
6425     return;
6426
6427   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6428   if (n)
6429     {
6430       /* [basic.scope.class]
6431
6432          A name N used in a class S shall refer to the same declaration
6433          in its context and when re-evaluated in the completed scope of
6434          S.  */
6435       error ("declaration of `%#D'", decl);
6436       cp_error_at ("changes meaning of `%D' from `%+#D'",
6437                    DECL_NAME (OVL_CURRENT (decl)),
6438                    (tree) n->value);
6439     }
6440 }
6441
6442 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6443    Secondary vtables are merged with primary vtables; this function
6444    will return the VAR_DECL for the primary vtable.  */
6445
6446 tree
6447 get_vtbl_decl_for_binfo (tree binfo)
6448 {
6449   tree decl;
6450
6451   decl = BINFO_VTABLE (binfo);
6452   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6453     {
6454       my_friendly_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR,
6455                           2000403);
6456       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6457     }
6458   if (decl)
6459     my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20000403);
6460   return decl;
6461 }
6462
6463
6464 /* Returns the binfo for the primary base of BINFO.  If the resulting
6465    BINFO is a virtual base, and it is inherited elsewhere in the
6466    hierarchy, then the returned binfo might not be the primary base of
6467    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6468    BINFO_LOST_PRIMARY_P to be sure.  */
6469
6470 tree
6471 get_primary_binfo (tree binfo)
6472 {
6473   tree primary_base;
6474   tree result;
6475
6476   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6477   if (!primary_base)
6478     return NULL_TREE;
6479
6480   result = copied_binfo (primary_base, binfo);
6481   return result;
6482 }
6483
6484 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6485
6486 static int
6487 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6488 {
6489   if (!indented_p)
6490     fprintf (stream, "%*s", indent, "");
6491   return 1;
6492 }
6493
6494 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6495    INDENT should be zero when called from the top level; it is
6496    incremented recursively.  IGO indicates the next expected BINFO in
6497    inheritance graph ordering.  */
6498
6499 static tree
6500 dump_class_hierarchy_r (FILE *stream,
6501                         int flags,
6502                         tree binfo,
6503                         tree igo,
6504                         int indent)
6505 {
6506   int indented = 0;
6507   tree base_binfos;
6508
6509   indented = maybe_indent_hierarchy (stream, indent, 0);
6510   fprintf (stream, "%s (0x%lx) ",
6511            type_as_string (binfo, TFF_PLAIN_IDENTIFIER),
6512            (unsigned long) binfo);
6513   if (binfo != igo)
6514     {
6515       fprintf (stream, "alternative-path\n");
6516       return igo;
6517     }
6518   igo = TREE_CHAIN (binfo);
6519
6520   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6521            tree_low_cst (BINFO_OFFSET (binfo), 0));
6522   if (is_empty_class (BINFO_TYPE (binfo)))
6523     fprintf (stream, " empty");
6524   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6525     fprintf (stream, " nearly-empty");
6526   if (TREE_VIA_VIRTUAL (binfo))
6527     fprintf (stream, " virtual");
6528   fprintf (stream, "\n");
6529
6530   indented = 0;
6531   if (BINFO_PRIMARY_BASE_OF (binfo))
6532     {
6533       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6534       fprintf (stream, " primary-for %s (0x%lx)",
6535                type_as_string (BINFO_PRIMARY_BASE_OF (binfo),
6536                                TFF_PLAIN_IDENTIFIER),
6537                (unsigned long)BINFO_PRIMARY_BASE_OF (binfo));
6538     }
6539   if (BINFO_LOST_PRIMARY_P (binfo))
6540     {
6541       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6542       fprintf (stream, " lost-primary");
6543     }
6544   if (indented)
6545     fprintf (stream, "\n");
6546
6547   if (!(flags & TDF_SLIM))
6548     {
6549       int indented = 0;
6550
6551       if (BINFO_SUBVTT_INDEX (binfo))
6552         {
6553           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6554           fprintf (stream, " subvttidx=%s",
6555                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6556                                    TFF_PLAIN_IDENTIFIER));
6557         }
6558       if (BINFO_VPTR_INDEX (binfo))
6559         {
6560           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6561           fprintf (stream, " vptridx=%s",
6562                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6563                                    TFF_PLAIN_IDENTIFIER));
6564         }
6565       if (BINFO_VPTR_FIELD (binfo))
6566         {
6567           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6568           fprintf (stream, " vbaseoffset=%s",
6569                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6570                                    TFF_PLAIN_IDENTIFIER));
6571         }
6572       if (BINFO_VTABLE (binfo))
6573         {
6574           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6575           fprintf (stream, " vptr=%s",
6576                    expr_as_string (BINFO_VTABLE (binfo),
6577                                    TFF_PLAIN_IDENTIFIER));
6578         }
6579
6580       if (indented)
6581         fprintf (stream, "\n");
6582     }
6583
6584   base_binfos = BINFO_BASETYPES (binfo);
6585   if (base_binfos)
6586     {
6587       int ix, n;
6588
6589       n = TREE_VEC_LENGTH (base_binfos);
6590       for (ix = 0; ix != n; ix++)
6591         {
6592           tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
6593
6594           igo = dump_class_hierarchy_r (stream, flags, base_binfo,
6595                                         igo, indent + 2);
6596         }
6597     }
6598
6599   return igo;
6600 }
6601
6602 /* Dump the BINFO hierarchy for T.  */
6603
6604 static void
6605 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6606 {
6607   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6608   fprintf (stream, "   size=%lu align=%lu\n",
6609            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6610            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6611   fprintf (stream, "   base size=%lu base align=%lu\n",
6612            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6613                            / BITS_PER_UNIT),
6614            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6615                            / BITS_PER_UNIT));
6616   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6617   fprintf (stream, "\n");
6618 }
6619
6620 /* Debug interface to hierarchy dumping.  */
6621
6622 extern void
6623 debug_class (tree t)
6624 {
6625   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6626 }
6627
6628 static void
6629 dump_class_hierarchy (tree t)
6630 {
6631   int flags;
6632   FILE *stream = dump_begin (TDI_class, &flags);
6633
6634   if (stream)
6635     {
6636       dump_class_hierarchy_1 (stream, flags, t);
6637       dump_end (TDI_class, stream);
6638     }
6639 }
6640
6641 static void
6642 dump_array (FILE * stream, tree decl)
6643 {
6644   tree inits;
6645   int ix;
6646   HOST_WIDE_INT elt;
6647   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6648
6649   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6650          / BITS_PER_UNIT);
6651   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6652   fprintf (stream, " %s entries",
6653            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6654                            TFF_PLAIN_IDENTIFIER));
6655   fprintf (stream, "\n");
6656
6657   for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6658        inits; ix++, inits = TREE_CHAIN (inits))
6659     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6660              expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6661 }
6662
6663 static void
6664 dump_vtable (tree t, tree binfo, tree vtable)
6665 {
6666   int flags;
6667   FILE *stream = dump_begin (TDI_class, &flags);
6668
6669   if (!stream)
6670     return;
6671
6672   if (!(flags & TDF_SLIM))
6673     {
6674       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6675
6676       fprintf (stream, "%s for %s",
6677                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6678                type_as_string (binfo, TFF_PLAIN_IDENTIFIER));
6679       if (ctor_vtbl_p)
6680         {
6681           if (!TREE_VIA_VIRTUAL (binfo))
6682             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6683           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6684         }
6685       fprintf (stream, "\n");
6686       dump_array (stream, vtable);
6687       fprintf (stream, "\n");
6688     }
6689
6690   dump_end (TDI_class, stream);
6691 }
6692
6693 static void
6694 dump_vtt (tree t, tree vtt)
6695 {
6696   int flags;
6697   FILE *stream = dump_begin (TDI_class, &flags);
6698
6699   if (!stream)
6700     return;
6701
6702   if (!(flags & TDF_SLIM))
6703     {
6704       fprintf (stream, "VTT for %s\n",
6705                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6706       dump_array (stream, vtt);
6707       fprintf (stream, "\n");
6708     }
6709
6710   dump_end (TDI_class, stream);
6711 }
6712
6713 /* Dump a function or thunk and its thunkees.  */
6714
6715 static void
6716 dump_thunk (FILE *stream, int indent, tree thunk)
6717 {
6718   static const char spaces[] = "        ";
6719   tree name = DECL_NAME (thunk);
6720   tree thunks;
6721
6722   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6723            (void *)thunk,
6724            !DECL_THUNK_P (thunk) ? "function"
6725            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6726            name ? IDENTIFIER_POINTER (name) : "<unset>");
6727   if (DECL_THUNK_P (thunk))
6728     {
6729       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6730       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6731
6732       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6733       if (!virtual_adjust)
6734         /*NOP*/;
6735       else if (DECL_THIS_THUNK_P (thunk))
6736         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6737                  tree_low_cst (virtual_adjust, 0));
6738       else
6739         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6740                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6741                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6742       if (THUNK_ALIAS (thunk))
6743         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6744     }
6745   fprintf (stream, "\n");
6746   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6747     dump_thunk (stream, indent + 2, thunks);
6748 }
6749
6750 /* Dump the thunks for FN.  */
6751
6752 extern void
6753 debug_thunks (tree fn)
6754 {
6755   dump_thunk (stderr, 0, fn);
6756 }
6757
6758 /* Virtual function table initialization.  */
6759
6760 /* Create all the necessary vtables for T and its base classes.  */
6761
6762 static void
6763 finish_vtbls (tree t)
6764 {
6765   tree list;
6766   tree vbase;
6767
6768   /* We lay out the primary and secondary vtables in one contiguous
6769      vtable.  The primary vtable is first, followed by the non-virtual
6770      secondary vtables in inheritance graph order.  */
6771   list = build_tree_list (TYPE_BINFO_VTABLE (t), NULL_TREE);
6772   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6773                          TYPE_BINFO (t), t, list);
6774
6775   /* Then come the virtual bases, also in inheritance graph order.  */
6776   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6777     {
6778       if (!TREE_VIA_VIRTUAL (vbase))
6779         continue;
6780       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6781     }
6782
6783   if (TYPE_BINFO_VTABLE (t))
6784     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6785 }
6786
6787 /* Initialize the vtable for BINFO with the INITS.  */
6788
6789 static void
6790 initialize_vtable (tree binfo, tree inits)
6791 {
6792   tree decl;
6793
6794   layout_vtable_decl (binfo, list_length (inits));
6795   decl = get_vtbl_decl_for_binfo (binfo);
6796   initialize_array (decl, inits);
6797   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6798 }
6799
6800 /* Initialize DECL (a declaration for a namespace-scope array) with
6801    the INITS.  */
6802
6803 static void
6804 initialize_array (tree decl, tree inits)
6805 {
6806   tree context;
6807
6808   context = DECL_CONTEXT (decl);
6809   DECL_CONTEXT (decl) = NULL_TREE;
6810   DECL_INITIAL (decl) = build_constructor (NULL_TREE, inits);
6811   TREE_HAS_CONSTRUCTOR (DECL_INITIAL (decl)) = 1;
6812   cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
6813   DECL_CONTEXT (decl) = context;
6814 }
6815
6816 /* Build the VTT (virtual table table) for T.
6817    A class requires a VTT if it has virtual bases.
6818
6819    This holds
6820    1 - primary virtual pointer for complete object T
6821    2 - secondary VTTs for each direct non-virtual base of T which requires a
6822        VTT
6823    3 - secondary virtual pointers for each direct or indirect base of T which
6824        has virtual bases or is reachable via a virtual path from T.
6825    4 - secondary VTTs for each direct or indirect virtual base of T.
6826
6827    Secondary VTTs look like complete object VTTs without part 4.  */
6828
6829 static void
6830 build_vtt (tree t)
6831 {
6832   tree inits;
6833   tree type;
6834   tree vtt;
6835   tree index;
6836
6837   /* Build up the initializers for the VTT.  */
6838   inits = NULL_TREE;
6839   index = size_zero_node;
6840   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6841
6842   /* If we didn't need a VTT, we're done.  */
6843   if (!inits)
6844     return;
6845
6846   /* Figure out the type of the VTT.  */
6847   type = build_index_type (size_int (list_length (inits) - 1));
6848   type = build_cplus_array_type (const_ptr_type_node, type);
6849
6850   /* Now, build the VTT object itself.  */
6851   vtt = build_vtable (t, get_vtt_name (t), type);
6852   initialize_array (vtt, inits);
6853   /* Add the VTT to the vtables list.  */
6854   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6855   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6856
6857   dump_vtt (t, vtt);
6858 }
6859
6860 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6861    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6862    and CHAIN the vtable pointer for this binfo after construction is
6863    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6864
6865 static tree
6866 binfo_ctor_vtable (tree binfo)
6867 {
6868   tree vt;
6869
6870   while (1)
6871     {
6872       vt = BINFO_VTABLE (binfo);
6873       if (TREE_CODE (vt) == TREE_LIST)
6874         vt = TREE_VALUE (vt);
6875       if (TREE_CODE (vt) == TREE_VEC)
6876         binfo = vt;
6877       else
6878         break;
6879     }
6880
6881   return vt;
6882 }
6883
6884 /* Recursively build the VTT-initializer for BINFO (which is in the
6885    hierarchy dominated by T).  INITS points to the end of the initializer
6886    list to date.  INDEX is the VTT index where the next element will be
6887    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6888    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6889    for virtual bases of T. When it is not so, we build the constructor
6890    vtables for the BINFO-in-T variant.  */
6891
6892 static tree *
6893 build_vtt_inits (tree binfo, tree t, tree* inits, tree* index)
6894 {
6895   int i;
6896   tree b;
6897   tree init;
6898   tree secondary_vptrs;
6899   int top_level_p = same_type_p (TREE_TYPE (binfo), t);
6900
6901   /* We only need VTTs for subobjects with virtual bases.  */
6902   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
6903     return inits;
6904
6905   /* We need to use a construction vtable if this is not the primary
6906      VTT.  */
6907   if (!top_level_p)
6908     {
6909       build_ctor_vtbl_group (binfo, t);
6910
6911       /* Record the offset in the VTT where this sub-VTT can be found.  */
6912       BINFO_SUBVTT_INDEX (binfo) = *index;
6913     }
6914
6915   /* Add the address of the primary vtable for the complete object.  */
6916   init = binfo_ctor_vtable (binfo);
6917   *inits = build_tree_list (NULL_TREE, init);
6918   inits = &TREE_CHAIN (*inits);
6919   if (top_level_p)
6920     {
6921       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
6922       BINFO_VPTR_INDEX (binfo) = *index;
6923     }
6924   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6925
6926   /* Recursively add the secondary VTTs for non-virtual bases.  */
6927   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
6928     {
6929       b = BINFO_BASETYPE (binfo, i);
6930       if (!TREE_VIA_VIRTUAL (b))
6931         inits = build_vtt_inits (BINFO_BASETYPE (binfo, i), t,
6932                                  inits, index);
6933     }
6934
6935   /* Add secondary virtual pointers for all subobjects of BINFO with
6936      either virtual bases or reachable along a virtual path, except
6937      subobjects that are non-virtual primary bases.  */
6938   secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo));
6939   TREE_TYPE (secondary_vptrs) = *index;
6940   VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p;
6941   VTT_MARKED_BINFO_P (secondary_vptrs) = 0;
6942
6943   dfs_walk_real (binfo,
6944                  dfs_build_secondary_vptr_vtt_inits,
6945                  NULL,
6946                  dfs_ctor_vtable_bases_queue_p,
6947                  secondary_vptrs);
6948   VTT_MARKED_BINFO_P (secondary_vptrs) = 1;
6949   dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p,
6950             secondary_vptrs);
6951
6952   *index = TREE_TYPE (secondary_vptrs);
6953
6954   /* The secondary vptrs come back in reverse order.  After we reverse
6955      them, and add the INITS, the last init will be the first element
6956      of the chain.  */
6957   secondary_vptrs = TREE_VALUE (secondary_vptrs);
6958   if (secondary_vptrs)
6959     {
6960       *inits = nreverse (secondary_vptrs);
6961       inits = &TREE_CHAIN (secondary_vptrs);
6962       my_friendly_assert (*inits == NULL_TREE, 20000517);
6963     }
6964
6965   /* Add the secondary VTTs for virtual bases.  */
6966   if (top_level_p)
6967     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6968       {
6969         if (!TREE_VIA_VIRTUAL (b))
6970           continue;
6971
6972         inits = build_vtt_inits (b, t, inits, index);
6973       }
6974
6975   if (!top_level_p)
6976     {
6977       tree data = tree_cons (t, binfo, NULL_TREE);
6978       VTT_TOP_LEVEL_P (data) = 0;
6979       VTT_MARKED_BINFO_P (data) = 0;
6980
6981       dfs_walk (binfo, dfs_fixup_binfo_vtbls,
6982                 dfs_ctor_vtable_bases_queue_p,
6983                 data);
6984     }
6985
6986   return inits;
6987 }
6988
6989 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo
6990    for the base in most derived. DATA is a TREE_LIST who's
6991    TREE_CHAIN is the type of the base being
6992    constructed whilst this secondary vptr is live.  The TREE_UNSIGNED
6993    flag of DATA indicates that this is a constructor vtable.  The
6994    TREE_TOP_LEVEL flag indicates that this is the primary VTT.  */
6995
6996 static tree
6997 dfs_build_secondary_vptr_vtt_inits (tree binfo, void* data)
6998 {
6999   tree l;
7000   tree t;
7001   tree init;
7002   tree index;
7003   int top_level_p;
7004
7005   l = (tree) data;
7006   t = TREE_CHAIN (l);
7007   top_level_p = VTT_TOP_LEVEL_P (l);
7008
7009   BINFO_MARKED (binfo) = 1;
7010
7011   /* We don't care about bases that don't have vtables.  */
7012   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7013     return NULL_TREE;
7014
7015   /* We're only interested in proper subobjects of T.  */
7016   if (same_type_p (BINFO_TYPE (binfo), t))
7017     return NULL_TREE;
7018
7019   /* We're not interested in non-virtual primary bases.  */
7020   if (!TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_P (binfo))
7021     return NULL_TREE;
7022
7023   /* If BINFO has virtual bases or is reachable via a virtual path
7024      from T, it'll have a secondary vptr.  */
7025   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7026       && !binfo_via_virtual (binfo, t))
7027     return NULL_TREE;
7028
7029   /* Record the index where this secondary vptr can be found.  */
7030   index = TREE_TYPE (l);
7031   if (top_level_p)
7032     {
7033       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
7034       BINFO_VPTR_INDEX (binfo) = index;
7035     }
7036   TREE_TYPE (l) = size_binop (PLUS_EXPR, index,
7037                               TYPE_SIZE_UNIT (ptr_type_node));
7038
7039   /* Add the initializer for the secondary vptr itself.  */
7040   if (top_level_p && TREE_VIA_VIRTUAL (binfo))
7041     {
7042       /* It's a primary virtual base, and this is not the construction
7043          vtable. Find the base this is primary of in the inheritance graph,
7044          and use that base's vtable now.  */
7045       while (BINFO_PRIMARY_BASE_OF (binfo))
7046         binfo = BINFO_PRIMARY_BASE_OF (binfo);
7047     }
7048   init = binfo_ctor_vtable (binfo);
7049   TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l));
7050
7051   return NULL_TREE;
7052 }
7053
7054 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
7055    VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
7056    should be walked.  TREE_PURPOSE is the TREE_TYPE that dominates the
7057    hierarchy.  */
7058
7059 static tree
7060 dfs_ctor_vtable_bases_queue_p (tree derived, int ix,
7061                                void* data)
7062 {
7063   tree binfo = BINFO_BASETYPE (derived, ix);
7064
7065   if (!BINFO_MARKED (binfo) == VTT_MARKED_BINFO_P ((tree) data))
7066     return NULL_TREE;
7067   return binfo;
7068 }
7069
7070 /* Called from build_vtt_inits via dfs_walk. After building constructor
7071    vtables and generating the sub-vtt from them, we need to restore the
7072    BINFO_VTABLES that were scribbled on.  DATA is a TREE_LIST whose
7073    TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated.  */
7074
7075 static tree
7076 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7077 {
7078   BINFO_MARKED (binfo) = 0;
7079
7080   /* We don't care about bases that don't have vtables.  */
7081   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7082     return NULL_TREE;
7083
7084   /* If we scribbled the construction vtable vptr into BINFO, clear it
7085      out now.  */
7086   if (BINFO_VTABLE (binfo)
7087       && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST
7088       && (TREE_PURPOSE (BINFO_VTABLE (binfo))
7089           == TREE_VALUE ((tree) data)))
7090     BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo));
7091
7092   return NULL_TREE;
7093 }
7094
7095 /* Build the construction vtable group for BINFO which is in the
7096    hierarchy dominated by T.  */
7097
7098 static void
7099 build_ctor_vtbl_group (tree binfo, tree t)
7100 {
7101   tree list;
7102   tree type;
7103   tree vtbl;
7104   tree inits;
7105   tree id;
7106   tree vbase;
7107
7108   /* See if we've already created this construction vtable group.  */
7109   id = mangle_ctor_vtbl_for_type (t, binfo);
7110   if (IDENTIFIER_GLOBAL_VALUE (id))
7111     return;
7112
7113   my_friendly_assert (!same_type_p (BINFO_TYPE (binfo), t), 20010124);
7114   /* Build a version of VTBL (with the wrong type) for use in
7115      constructing the addresses of secondary vtables in the
7116      construction vtable group.  */
7117   vtbl = build_vtable (t, id, ptr_type_node);
7118   list = build_tree_list (vtbl, NULL_TREE);
7119   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7120                          binfo, t, list);
7121
7122   /* Add the vtables for each of our virtual bases using the vbase in T
7123      binfo.  */
7124   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7125        vbase;
7126        vbase = TREE_CHAIN (vbase))
7127     {
7128       tree b;
7129
7130       if (!TREE_VIA_VIRTUAL (vbase))
7131         continue;
7132       b = copied_binfo (vbase, binfo);
7133
7134       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7135     }
7136   inits = TREE_VALUE (list);
7137
7138   /* Figure out the type of the construction vtable.  */
7139   type = build_index_type (size_int (list_length (inits) - 1));
7140   type = build_cplus_array_type (vtable_entry_type, type);
7141   TREE_TYPE (vtbl) = type;
7142
7143   /* Initialize the construction vtable.  */
7144   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7145   initialize_array (vtbl, inits);
7146   dump_vtable (t, binfo, vtbl);
7147 }
7148
7149 /* Add the vtbl initializers for BINFO (and its bases other than
7150    non-virtual primaries) to the list of INITS.  BINFO is in the
7151    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7152    the constructor the vtbl inits should be accumulated for. (If this
7153    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7154    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7155    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7156    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7157    but are not necessarily the same in terms of layout.  */
7158
7159 static void
7160 accumulate_vtbl_inits (tree binfo,
7161                        tree orig_binfo,
7162                        tree rtti_binfo,
7163                        tree t,
7164                        tree inits)
7165 {
7166   int i;
7167   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7168
7169   my_friendly_assert (same_type_p (BINFO_TYPE (binfo),
7170                                    BINFO_TYPE (orig_binfo)),
7171                       20000517);
7172
7173   /* If it doesn't have a vptr, we don't do anything.  */
7174   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7175     return;
7176
7177   /* If we're building a construction vtable, we're not interested in
7178      subobjects that don't require construction vtables.  */
7179   if (ctor_vtbl_p
7180       && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7181       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7182     return;
7183
7184   /* Build the initializers for the BINFO-in-T vtable.  */
7185   TREE_VALUE (inits)
7186     = chainon (TREE_VALUE (inits),
7187                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7188                                           rtti_binfo, t, inits));
7189
7190   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7191      initialize each vtable we can figure out at what offset the
7192      secondary vtable lies from the primary vtable.  We can't use
7193      dfs_walk here because we need to iterate through bases of BINFO
7194      and RTTI_BINFO simultaneously.  */
7195   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7196     {
7197       tree base_binfo = BINFO_BASETYPE (binfo, i);
7198
7199       /* Skip virtual bases.  */
7200       if (TREE_VIA_VIRTUAL (base_binfo))
7201         continue;
7202       accumulate_vtbl_inits (base_binfo,
7203                              BINFO_BASETYPE (orig_binfo, i),
7204                              rtti_binfo, t,
7205                              inits);
7206     }
7207 }
7208
7209 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7210    the BINFO vtable.  */
7211
7212 static tree
7213 dfs_accumulate_vtbl_inits (tree binfo,
7214                            tree orig_binfo,
7215                            tree rtti_binfo,
7216                            tree t,
7217                            tree l)
7218 {
7219   tree inits = NULL_TREE;
7220   tree vtbl = NULL_TREE;
7221   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7222
7223   if (ctor_vtbl_p
7224       && TREE_VIA_VIRTUAL (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7225     {
7226       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7227          primary virtual base.  If it is not the same primary in
7228          the hierarchy of T, we'll need to generate a ctor vtable
7229          for it, to place at its location in T.  If it is the same
7230          primary, we still need a VTT entry for the vtable, but it
7231          should point to the ctor vtable for the base it is a
7232          primary for within the sub-hierarchy of RTTI_BINFO.
7233
7234          There are three possible cases:
7235
7236          1) We are in the same place.
7237          2) We are a primary base within a lost primary virtual base of
7238          RTTI_BINFO.
7239          3) We are primary to something not a base of RTTI_BINFO.  */
7240
7241       tree b = BINFO_PRIMARY_BASE_OF (binfo);
7242       tree last = NULL_TREE;
7243
7244       /* First, look through the bases we are primary to for RTTI_BINFO
7245          or a virtual base.  */
7246       for (; b; b = BINFO_PRIMARY_BASE_OF (b))
7247         {
7248           last = b;
7249           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7250             break;
7251         }
7252       /* If we run out of primary links, keep looking down our
7253          inheritance chain; we might be an indirect primary.  */
7254       if (b == NULL_TREE)
7255         for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7256           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7257             break;
7258
7259       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7260          base B and it is a base of RTTI_BINFO, this is case 2.  In
7261          either case, we share our vtable with LAST, i.e. the
7262          derived-most base within B of which we are a primary.  */
7263       if (b == rtti_binfo
7264           || (b && purpose_member (BINFO_TYPE (b),
7265                                    CLASSTYPE_VBASECLASSES (BINFO_TYPE (rtti_binfo)))))
7266         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7267            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7268            binfo_ctor_vtable after everything's been set up.  */
7269         vtbl = last;
7270
7271       /* Otherwise, this is case 3 and we get our own.  */
7272     }
7273   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7274     return inits;
7275
7276   if (!vtbl)
7277     {
7278       tree index;
7279       int non_fn_entries;
7280
7281       /* Compute the initializer for this vtable.  */
7282       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7283                                       &non_fn_entries);
7284
7285       /* Figure out the position to which the VPTR should point.  */
7286       vtbl = TREE_PURPOSE (l);
7287       vtbl = build1 (ADDR_EXPR,
7288                      vtbl_ptr_type_node,
7289                      vtbl);
7290       TREE_CONSTANT (vtbl) = 1;
7291       index = size_binop (PLUS_EXPR,
7292                           size_int (non_fn_entries),
7293                           size_int (list_length (TREE_VALUE (l))));
7294       index = size_binop (MULT_EXPR,
7295                           TYPE_SIZE_UNIT (vtable_entry_type),
7296                           index);
7297       vtbl = build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7298       TREE_CONSTANT (vtbl) = 1;
7299     }
7300
7301   if (ctor_vtbl_p)
7302     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7303        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7304        straighten this out.  */
7305     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7306   else if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo))
7307     inits = NULL_TREE;
7308   else
7309      /* For an ordinary vtable, set BINFO_VTABLE.  */
7310     BINFO_VTABLE (binfo) = vtbl;
7311
7312   return inits;
7313 }
7314
7315 /* Construct the initializer for BINFO's virtual function table.  BINFO
7316    is part of the hierarchy dominated by T.  If we're building a
7317    construction vtable, the ORIG_BINFO is the binfo we should use to
7318    find the actual function pointers to put in the vtable - but they
7319    can be overridden on the path to most-derived in the graph that
7320    ORIG_BINFO belongs.  Otherwise,
7321    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7322    BINFO that should be indicated by the RTTI information in the
7323    vtable; it will be a base class of T, rather than T itself, if we
7324    are building a construction vtable.
7325
7326    The value returned is a TREE_LIST suitable for wrapping in a
7327    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7328    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7329    number of non-function entries in the vtable.
7330
7331    It might seem that this function should never be called with a
7332    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7333    base is always subsumed by a derived class vtable.  However, when
7334    we are building construction vtables, we do build vtables for
7335    primary bases; we need these while the primary base is being
7336    constructed.  */
7337
7338 static tree
7339 build_vtbl_initializer (tree binfo,
7340                         tree orig_binfo,
7341                         tree t,
7342                         tree rtti_binfo,
7343                         int* non_fn_entries_p)
7344 {
7345   tree v, b;
7346   tree vfun_inits;
7347   tree vbase;
7348   vtbl_init_data vid;
7349
7350   /* Initialize VID.  */
7351   memset (&vid, 0, sizeof (vid));
7352   vid.binfo = binfo;
7353   vid.derived = t;
7354   vid.rtti_binfo = rtti_binfo;
7355   vid.last_init = &vid.inits;
7356   vid.primary_vtbl_p = (binfo == TYPE_BINFO (t));
7357   vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7358   vid.generate_vcall_entries = true;
7359   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7360   vid.index = ssize_int (-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7361
7362   /* Add entries to the vtable for RTTI.  */
7363   build_rtti_vtbl_entries (binfo, &vid);
7364
7365   /* Create an array for keeping track of the functions we've
7366      processed.  When we see multiple functions with the same
7367      signature, we share the vcall offsets.  */
7368   VARRAY_TREE_INIT (vid.fns, 32, "fns");
7369   /* Add the vcall and vbase offset entries.  */
7370   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7371   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7372      build_vbase_offset_vtbl_entries.  */
7373   for (vbase = CLASSTYPE_VBASECLASSES (t);
7374        vbase;
7375        vbase = TREE_CHAIN (vbase))
7376     BINFO_VTABLE_PATH_MARKED (TREE_VALUE (vbase)) = 0;
7377
7378   /* If the target requires padding between data entries, add that now.  */
7379   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7380     {
7381       tree cur, *prev;
7382
7383       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7384         {
7385           tree add = cur;
7386           int i;
7387
7388           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7389             add = tree_cons (NULL_TREE,
7390                              build1 (NOP_EXPR, vtable_entry_type,
7391                                      null_pointer_node),
7392                              add);
7393           *prev = add;
7394         }
7395     }
7396
7397   if (non_fn_entries_p)
7398     *non_fn_entries_p = list_length (vid.inits);
7399
7400   /* Go through all the ordinary virtual functions, building up
7401      initializers.  */
7402   vfun_inits = NULL_TREE;
7403   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7404     {
7405       tree delta;
7406       tree vcall_index;
7407       tree fn, fn_original;
7408       tree init = NULL_TREE;
7409
7410       fn = BV_FN (v);
7411       fn_original = fn;
7412       if (DECL_THUNK_P (fn))
7413         {
7414           if (!DECL_NAME (fn))
7415             finish_thunk (fn);
7416           if (THUNK_ALIAS (fn))
7417             {
7418               fn = THUNK_ALIAS (fn);
7419               BV_FN (v) = fn;
7420             }
7421           fn_original = THUNK_TARGET (fn);
7422         }
7423
7424       /* If the only definition of this function signature along our
7425          primary base chain is from a lost primary, this vtable slot will
7426          never be used, so just zero it out.  This is important to avoid
7427          requiring extra thunks which cannot be generated with the function.
7428
7429          We first check this in update_vtable_entry_for_fn, so we handle
7430          restored primary bases properly; we also need to do it here so we
7431          zero out unused slots in ctor vtables, rather than filling themff
7432          with erroneous values (though harmless, apart from relocation
7433          costs).  */
7434       for (b = binfo; ; b = get_primary_binfo (b))
7435         {
7436           /* We found a defn before a lost primary; go ahead as normal.  */
7437           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7438             break;
7439
7440           /* The nearest definition is from a lost primary; clear the
7441              slot.  */
7442           if (BINFO_LOST_PRIMARY_P (b))
7443             {
7444               init = size_zero_node;
7445               break;
7446             }
7447         }
7448
7449       if (! init)
7450         {
7451           /* Pull the offset for `this', and the function to call, out of
7452              the list.  */
7453           delta = BV_DELTA (v);
7454           vcall_index = BV_VCALL_INDEX (v);
7455
7456           my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727);
7457           my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727);
7458
7459           /* You can't call an abstract virtual function; it's abstract.
7460              So, we replace these functions with __pure_virtual.  */
7461           if (DECL_PURE_VIRTUAL_P (fn_original))
7462             fn = abort_fndecl;
7463           else if (!integer_zerop (delta) || vcall_index)
7464             {
7465               fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7466               if (!DECL_NAME (fn))
7467                 finish_thunk (fn);
7468             }
7469           /* Take the address of the function, considering it to be of an
7470              appropriate generic type.  */
7471           init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7472           /* The address of a function can't change.  */
7473           TREE_CONSTANT (init) = 1;
7474         }
7475
7476       /* And add it to the chain of initializers.  */
7477       if (TARGET_VTABLE_USES_DESCRIPTORS)
7478         {
7479           int i;
7480           if (init == size_zero_node)
7481             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7482               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7483           else
7484             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7485               {
7486                 tree fdesc = build (FDESC_EXPR, vfunc_ptr_type_node,
7487                                     TREE_OPERAND (init, 0),
7488                                     build_int_2 (i, 0));
7489                 TREE_CONSTANT (fdesc) = 1;
7490
7491                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7492               }
7493         }
7494       else
7495         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7496     }
7497
7498   /* The initializers for virtual functions were built up in reverse
7499      order; straighten them out now.  */
7500   vfun_inits = nreverse (vfun_inits);
7501
7502   /* The negative offset initializers are also in reverse order.  */
7503   vid.inits = nreverse (vid.inits);
7504
7505   /* Chain the two together.  */
7506   return chainon (vid.inits, vfun_inits);
7507 }
7508
7509 /* Adds to vid->inits the initializers for the vbase and vcall
7510    offsets in BINFO, which is in the hierarchy dominated by T.  */
7511
7512 static void
7513 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7514 {
7515   tree b;
7516
7517   /* If this is a derived class, we must first create entries
7518      corresponding to the primary base class.  */
7519   b = get_primary_binfo (binfo);
7520   if (b)
7521     build_vcall_and_vbase_vtbl_entries (b, vid);
7522
7523   /* Add the vbase entries for this base.  */
7524   build_vbase_offset_vtbl_entries (binfo, vid);
7525   /* Add the vcall entries for this base.  */
7526   build_vcall_offset_vtbl_entries (binfo, vid);
7527 }
7528
7529 /* Returns the initializers for the vbase offset entries in the vtable
7530    for BINFO (which is part of the class hierarchy dominated by T), in
7531    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7532    where the next vbase offset will go.  */
7533
7534 static void
7535 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7536 {
7537   tree vbase;
7538   tree t;
7539   tree non_primary_binfo;
7540
7541   /* If there are no virtual baseclasses, then there is nothing to
7542      do.  */
7543   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
7544     return;
7545
7546   t = vid->derived;
7547
7548   /* We might be a primary base class.  Go up the inheritance hierarchy
7549      until we find the most derived class of which we are a primary base:
7550      it is the offset of that which we need to use.  */
7551   non_primary_binfo = binfo;
7552   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7553     {
7554       tree b;
7555
7556       /* If we have reached a virtual base, then it must be a primary
7557          base (possibly multi-level) of vid->binfo, or we wouldn't
7558          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7559          might be a lost primary, so just skip down to vid->binfo.  */
7560       if (TREE_VIA_VIRTUAL (non_primary_binfo))
7561         {
7562           non_primary_binfo = vid->binfo;
7563           break;
7564         }
7565
7566       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7567       if (get_primary_binfo (b) != non_primary_binfo)
7568         break;
7569       non_primary_binfo = b;
7570     }
7571
7572   /* Go through the virtual bases, adding the offsets.  */
7573   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7574        vbase;
7575        vbase = TREE_CHAIN (vbase))
7576     {
7577       tree b;
7578       tree delta;
7579
7580       if (!TREE_VIA_VIRTUAL (vbase))
7581         continue;
7582
7583       /* Find the instance of this virtual base in the complete
7584          object.  */
7585       b = copied_binfo (vbase, binfo);
7586
7587       /* If we've already got an offset for this virtual base, we
7588          don't need another one.  */
7589       if (BINFO_VTABLE_PATH_MARKED (b))
7590         continue;
7591       BINFO_VTABLE_PATH_MARKED (b) = 1;
7592
7593       /* Figure out where we can find this vbase offset.  */
7594       delta = size_binop (MULT_EXPR,
7595                           vid->index,
7596                           convert (ssizetype,
7597                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7598       if (vid->primary_vtbl_p)
7599         BINFO_VPTR_FIELD (b) = delta;
7600
7601       if (binfo != TYPE_BINFO (t))
7602         {
7603           /* The vbase offset had better be the same.  */
7604           my_friendly_assert (tree_int_cst_equal (delta,
7605                                                   BINFO_VPTR_FIELD (vbase)),
7606                               20030202);
7607         }
7608
7609       /* The next vbase will come at a more negative offset.  */
7610       vid->index = size_binop (MINUS_EXPR, vid->index,
7611                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7612
7613       /* The initializer is the delta from BINFO to this virtual base.
7614          The vbase offsets go in reverse inheritance-graph order, and
7615          we are walking in inheritance graph order so these end up in
7616          the right order.  */
7617       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7618
7619       *vid->last_init
7620         = build_tree_list (NULL_TREE,
7621                            fold (build1 (NOP_EXPR,
7622                                          vtable_entry_type,
7623                                          delta)));
7624       vid->last_init = &TREE_CHAIN (*vid->last_init);
7625     }
7626 }
7627
7628 /* Adds the initializers for the vcall offset entries in the vtable
7629    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7630    to VID->INITS.  */
7631
7632 static void
7633 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7634 {
7635   /* We only need these entries if this base is a virtual base.  We
7636      compute the indices -- but do not add to the vtable -- when
7637      building the main vtable for a class.  */
7638   if (TREE_VIA_VIRTUAL (binfo) || binfo == TYPE_BINFO (vid->derived))
7639     {
7640       /* We need a vcall offset for each of the virtual functions in this
7641          vtable.  For example:
7642
7643            class A { virtual void f (); };
7644            class B1 : virtual public A { virtual void f (); };
7645            class B2 : virtual public A { virtual void f (); };
7646            class C: public B1, public B2 { virtual void f (); };
7647
7648          A C object has a primary base of B1, which has a primary base of A.  A
7649          C also has a secondary base of B2, which no longer has a primary base
7650          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7651          A, which will adjust the A* to a B2* to call f.  We have no way of
7652          knowing what (or even whether) this offset will be when we define B2,
7653          so we store this "vcall offset" in the A sub-vtable and look it up in
7654          a "virtual thunk" for B2::f.
7655
7656          We need entries for all the functions in our primary vtable and
7657          in our non-virtual bases' secondary vtables.  */
7658       vid->vbase = binfo;
7659       /* If we are just computing the vcall indices -- but do not need
7660          the actual entries -- not that.  */
7661       if (!TREE_VIA_VIRTUAL (binfo))
7662         vid->generate_vcall_entries = false;
7663       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7664       add_vcall_offset_vtbl_entries_r (binfo, vid);
7665     }
7666 }
7667
7668 /* Build vcall offsets, starting with those for BINFO.  */
7669
7670 static void
7671 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7672 {
7673   int i;
7674   tree primary_binfo;
7675
7676   /* Don't walk into virtual bases -- except, of course, for the
7677      virtual base for which we are building vcall offsets.  Any
7678      primary virtual base will have already had its offsets generated
7679      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7680   if (TREE_VIA_VIRTUAL (binfo) && vid->vbase != binfo)
7681     return;
7682
7683   /* If BINFO has a primary base, process it first.  */
7684   primary_binfo = get_primary_binfo (binfo);
7685   if (primary_binfo)
7686     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7687
7688   /* Add BINFO itself to the list.  */
7689   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7690
7691   /* Scan the non-primary bases of BINFO.  */
7692   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7693     {
7694       tree base_binfo;
7695
7696       base_binfo = BINFO_BASETYPE (binfo, i);
7697       if (base_binfo != primary_binfo)
7698         add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7699     }
7700 }
7701
7702 /* Called from build_vcall_offset_vtbl_entries_r.  */
7703
7704 static void
7705 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7706 {
7707   /* Make entries for the rest of the virtuals.  */
7708   if (abi_version_at_least (2))
7709     {
7710       tree orig_fn;
7711
7712       /* The ABI requires that the methods be processed in declaration
7713          order.  G++ 3.2 used the order in the vtable.  */
7714       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7715            orig_fn;
7716            orig_fn = TREE_CHAIN (orig_fn))
7717         if (DECL_VINDEX (orig_fn))
7718           add_vcall_offset (orig_fn, binfo, vid);
7719     }
7720   else
7721     {
7722       tree derived_virtuals;
7723       tree base_virtuals;
7724       tree orig_virtuals;
7725       /* If BINFO is a primary base, the most derived class which has
7726          BINFO as a primary base; otherwise, just BINFO.  */
7727       tree non_primary_binfo;
7728
7729       /* We might be a primary base class.  Go up the inheritance hierarchy
7730          until we find the most derived class of which we are a primary base:
7731          it is the BINFO_VIRTUALS there that we need to consider.  */
7732       non_primary_binfo = binfo;
7733       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7734         {
7735           tree b;
7736
7737           /* If we have reached a virtual base, then it must be vid->vbase,
7738              because we ignore other virtual bases in
7739              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7740              base (possibly multi-level) of vid->binfo, or we wouldn't
7741              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7742              might be a lost primary, so just skip down to vid->binfo.  */
7743           if (TREE_VIA_VIRTUAL (non_primary_binfo))
7744             {
7745               if (non_primary_binfo != vid->vbase)
7746                 abort ();
7747               non_primary_binfo = vid->binfo;
7748               break;
7749             }
7750
7751           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7752           if (get_primary_binfo (b) != non_primary_binfo)
7753             break;
7754           non_primary_binfo = b;
7755         }
7756
7757       if (vid->ctor_vtbl_p)
7758         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7759            where rtti_binfo is the most derived type.  */
7760         non_primary_binfo
7761           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7762
7763       for (base_virtuals = BINFO_VIRTUALS (binfo),
7764              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7765              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7766            base_virtuals;
7767            base_virtuals = TREE_CHAIN (base_virtuals),
7768              derived_virtuals = TREE_CHAIN (derived_virtuals),
7769              orig_virtuals = TREE_CHAIN (orig_virtuals))
7770         {
7771           tree orig_fn;
7772
7773           /* Find the declaration that originally caused this function to
7774              be present in BINFO_TYPE (binfo).  */
7775           orig_fn = BV_FN (orig_virtuals);
7776
7777           /* When processing BINFO, we only want to generate vcall slots for
7778              function slots introduced in BINFO.  So don't try to generate
7779              one if the function isn't even defined in BINFO.  */
7780           if (!same_type_p (DECL_CONTEXT (orig_fn), BINFO_TYPE (binfo)))
7781             continue;
7782
7783           add_vcall_offset (orig_fn, binfo, vid);
7784         }
7785     }
7786 }
7787
7788 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7789
7790 static void
7791 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7792 {
7793   size_t i;
7794   tree vcall_offset;
7795
7796   /* If there is already an entry for a function with the same
7797      signature as FN, then we do not need a second vcall offset.
7798      Check the list of functions already present in the derived
7799      class vtable.  */
7800   for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7801     {
7802       tree derived_entry;
7803
7804       derived_entry = VARRAY_TREE (vid->fns, i);
7805       if (same_signature_p (derived_entry, orig_fn)
7806           /* We only use one vcall offset for virtual destructors,
7807              even though there are two virtual table entries.  */
7808           || (DECL_DESTRUCTOR_P (derived_entry)
7809               && DECL_DESTRUCTOR_P (orig_fn)))
7810         return;
7811     }
7812
7813   /* If we are building these vcall offsets as part of building
7814      the vtable for the most derived class, remember the vcall
7815      offset.  */
7816   if (vid->binfo == TYPE_BINFO (vid->derived))
7817     CLASSTYPE_VCALL_INDICES (vid->derived)
7818       = tree_cons (orig_fn, vid->index,
7819                    CLASSTYPE_VCALL_INDICES (vid->derived));
7820
7821   /* The next vcall offset will be found at a more negative
7822      offset.  */
7823   vid->index = size_binop (MINUS_EXPR, vid->index,
7824                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7825
7826   /* Keep track of this function.  */
7827   VARRAY_PUSH_TREE (vid->fns, orig_fn);
7828
7829   if (vid->generate_vcall_entries)
7830     {
7831       tree base;
7832       tree fn;
7833
7834       /* Find the overriding function.  */
7835       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7836       if (fn == error_mark_node)
7837         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7838                                integer_zero_node);
7839       else
7840         {
7841           base = TREE_VALUE (fn);
7842
7843           /* The vbase we're working on is a primary base of
7844              vid->binfo.  But it might be a lost primary, so its
7845              BINFO_OFFSET might be wrong, so we just use the
7846              BINFO_OFFSET from vid->binfo.  */
7847           vcall_offset = size_diffop (BINFO_OFFSET (base),
7848                                       BINFO_OFFSET (vid->binfo));
7849           vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7850                                        vcall_offset));
7851         }
7852       /* Add the initializer to the vtable.  */
7853       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7854       vid->last_init = &TREE_CHAIN (*vid->last_init);
7855     }
7856 }
7857
7858 /* Return vtbl initializers for the RTTI entries corresponding to the
7859    BINFO's vtable.  The RTTI entries should indicate the object given
7860    by VID->rtti_binfo.  */
7861
7862 static void
7863 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7864 {
7865   tree b;
7866   tree t;
7867   tree basetype;
7868   tree offset;
7869   tree decl;
7870   tree init;
7871
7872   basetype = BINFO_TYPE (binfo);
7873   t = BINFO_TYPE (vid->rtti_binfo);
7874
7875   /* To find the complete object, we will first convert to our most
7876      primary base, and then add the offset in the vtbl to that value.  */
7877   b = binfo;
7878   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7879          && !BINFO_LOST_PRIMARY_P (b))
7880     {
7881       tree primary_base;
7882
7883       primary_base = get_primary_binfo (b);
7884       my_friendly_assert (BINFO_PRIMARY_BASE_OF (primary_base) == b, 20010127);
7885       b = primary_base;
7886     }
7887   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7888
7889   /* The second entry is the address of the typeinfo object.  */
7890   if (flag_rtti)
7891     decl = build_address (get_tinfo_decl (t));
7892   else
7893     decl = integer_zero_node;
7894
7895   /* Convert the declaration to a type that can be stored in the
7896      vtable.  */
7897   init = build_nop (vfunc_ptr_type_node, decl);
7898   *vid->last_init = build_tree_list (NULL_TREE, init);
7899   vid->last_init = &TREE_CHAIN (*vid->last_init);
7900
7901   /* Add the offset-to-top entry.  It comes earlier in the vtable that
7902      the the typeinfo entry.  Convert the offset to look like a
7903      function pointer, so that we can put it in the vtable.  */
7904   init = build_nop (vfunc_ptr_type_node, offset);
7905   *vid->last_init = build_tree_list (NULL_TREE, init);
7906   vid->last_init = &TREE_CHAIN (*vid->last_init);
7907 }