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