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