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