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