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