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