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         }
4763       else
4764         layout_nonempty_base_or_field (rli, field, NULL_TREE,
4765                                        empty_base_offsets);
4766
4767       /* Remember the location of any empty classes in FIELD.  */
4768       if (abi_version_at_least (2))
4769         record_subobject_offsets (TREE_TYPE (field),
4770                                   byte_position(field),
4771                                   empty_base_offsets,
4772                                   /*vbases_p=*/1);
4773
4774       /* If a bit-field does not immediately follow another bit-field,
4775          and yet it starts in the middle of a byte, we have failed to
4776          comply with the ABI.  */
4777       if (warn_abi
4778           && DECL_C_BIT_FIELD (field)
4779           && !last_field_was_bitfield
4780           && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4781                                          DECL_FIELD_BIT_OFFSET (field),
4782                                          bitsize_unit_node)))
4783         cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC",
4784                        field);
4785
4786       /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4787          offset of the field.  */
4788       if (warn_abi
4789           && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4790                                   byte_position (field))
4791           && contains_empty_class_p (TREE_TYPE (field)))
4792         cp_warning_at ("`%D' contains empty classes which may cause base "
4793                        "classes to be placed at different locations in a "
4794                        "future version of GCC",
4795                        field);
4796
4797       /* If we needed additional padding after this field, add it
4798          now.  */
4799       if (padding)
4800         {
4801           tree padding_field;
4802
4803           padding_field = build_decl (FIELD_DECL,
4804                                       NULL_TREE,
4805                                       char_type_node);
4806           DECL_BIT_FIELD (padding_field) = 1;
4807           DECL_SIZE (padding_field) = padding;
4808           DECL_CONTEXT (padding_field) = t;
4809           layout_nonempty_base_or_field (rli, padding_field,
4810                                          NULL_TREE,
4811                                          empty_base_offsets);
4812         }
4813
4814       last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4815     }
4816
4817   if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4818     {
4819       /* Make sure that we are on a byte boundary so that the size of
4820          the class without virtual bases will always be a round number
4821          of bytes.  */
4822       rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4823       normalize_rli (rli);
4824     }
4825
4826   /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4827      padding.  */
4828   if (!abi_version_at_least (2))
4829     include_empty_classes(rli);
4830
4831   /* Delete all zero-width bit-fields from the list of fields.  Now
4832      that the type is laid out they are no longer important.  */
4833   remove_zero_width_bit_fields (t);
4834
4835   /* Create the version of T used for virtual bases.  We do not use
4836      make_aggr_type for this version; this is an artificial type.  For
4837      a POD type, we just reuse T.  */
4838   if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4839     {
4840       base_t = make_node (TREE_CODE (t));
4841
4842       /* Set the size and alignment for the new type.  In G++ 3.2, all
4843          empty classes were considered to have size zero when used as
4844          base classes.  */
4845       if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4846         {
4847           TYPE_SIZE (base_t) = bitsize_zero_node;
4848           TYPE_SIZE_UNIT (base_t) = size_zero_node;
4849           if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4850             warning ("layout of classes derived from empty class `%T' "
4851                      "may change in a future version of GCC",
4852                      t);
4853         }
4854       else
4855         {
4856           tree eoc;
4857
4858           /* If the ABI version is not at least two, and the last
4859              field was a bit-field, RLI may not be on a byte
4860              boundary.  In particular, rli_size_unit_so_far might
4861              indicate the last complete byte, while rli_size_so_far
4862              indicates the total number of bits used.  Therefore,
4863              rli_size_so_far, rather than rli_size_unit_so_far, is
4864              used to compute TYPE_SIZE_UNIT.  */
4865           eoc = end_of_class (t, /*include_virtuals_p=*/0);
4866           TYPE_SIZE_UNIT (base_t)
4867             = size_binop (MAX_EXPR,
4868                           convert (sizetype,
4869                                    size_binop (CEIL_DIV_EXPR,
4870                                                rli_size_so_far (rli),
4871                                                bitsize_int (BITS_PER_UNIT))),
4872                           eoc);
4873           TYPE_SIZE (base_t)
4874             = size_binop (MAX_EXPR,
4875                           rli_size_so_far (rli),
4876                           size_binop (MULT_EXPR,
4877                                       convert (bitsizetype, eoc),
4878                                       bitsize_int (BITS_PER_UNIT)));
4879         }
4880       TYPE_ALIGN (base_t) = rli->record_align;
4881       TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4882
4883       /* Copy the fields from T.  */
4884       next_field = &TYPE_FIELDS (base_t);
4885       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4886         if (TREE_CODE (field) == FIELD_DECL)
4887           {
4888             *next_field = build_decl (FIELD_DECL,
4889                                       DECL_NAME (field),
4890                                       TREE_TYPE (field));
4891             DECL_CONTEXT (*next_field) = base_t;
4892             DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4893             DECL_FIELD_BIT_OFFSET (*next_field)
4894               = DECL_FIELD_BIT_OFFSET (field);
4895             next_field = &TREE_CHAIN (*next_field);
4896           }
4897
4898       /* Record the base version of the type.  */
4899       CLASSTYPE_AS_BASE (t) = base_t;
4900       TYPE_CONTEXT (base_t) = t;
4901     }
4902   else
4903     CLASSTYPE_AS_BASE (t) = t;
4904
4905   /* Every empty class contains an empty class.  */
4906   if (CLASSTYPE_EMPTY_P (t))
4907     CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
4908
4909   /* Set the TYPE_DECL for this type to contain the right
4910      value for DECL_OFFSET, so that we can use it as part
4911      of a COMPONENT_REF for multiple inheritance.  */
4912   layout_decl (TYPE_MAIN_DECL (t), 0);
4913
4914   /* Now fix up any virtual base class types that we left lying
4915      around.  We must get these done before we try to lay out the
4916      virtual function table.  As a side-effect, this will remove the
4917      base subobject fields.  */
4918   layout_virtual_bases (rli, empty_base_offsets);
4919
4920   /* Make sure that empty classes are reflected in RLI at this
4921      point.  */
4922   include_empty_classes(rli);
4923
4924   /* Make sure not to create any structures with zero size.  */
4925   if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
4926     place_field (rli,
4927                  build_decl (FIELD_DECL, NULL_TREE, char_type_node));
4928
4929   /* Let the back-end lay out the type.  */
4930   finish_record_layout (rli, /*free_p=*/true);
4931
4932   /* Warn about bases that can't be talked about due to ambiguity.  */
4933   warn_about_ambiguous_bases (t);
4934
4935   /* Clean up.  */
4936   splay_tree_delete (empty_base_offsets);
4937 }
4938
4939 /* Returns the virtual function with which the vtable for TYPE is
4940    emitted, or NULL_TREE if that heuristic is not applicable to TYPE.  */
4941
4942 static tree
4943 key_method (tree type)
4944 {
4945   tree method;
4946
4947   if (TYPE_FOR_JAVA (type)
4948       || processing_template_decl
4949       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4950       || CLASSTYPE_INTERFACE_KNOWN (type))
4951     return NULL_TREE;
4952
4953   for (method = TYPE_METHODS (type); method != NULL_TREE;
4954        method = TREE_CHAIN (method))
4955     if (DECL_VINDEX (method) != NULL_TREE
4956         && ! DECL_DECLARED_INLINE_P (method)
4957         && ! DECL_PURE_VIRTUAL_P (method))
4958       return method;
4959
4960   return NULL_TREE;
4961 }
4962
4963 /* Perform processing required when the definition of T (a class type)
4964    is complete.  */
4965
4966 void
4967 finish_struct_1 (tree t)
4968 {
4969   tree x;
4970   /* A TREE_LIST.  The TREE_VALUE of each node is a FUNCTION_DECL.  */
4971   tree virtuals = NULL_TREE;
4972   int n_fields = 0;
4973   tree vfield;
4974
4975   if (COMPLETE_TYPE_P (t))
4976     {
4977       if (IS_AGGR_TYPE (t))
4978         error ("redefinition of `%#T'", t);
4979       else
4980         abort ();
4981       popclass ();
4982       return;
4983     }
4984
4985   /* If this type was previously laid out as a forward reference,
4986      make sure we lay it out again.  */
4987   TYPE_SIZE (t) = NULL_TREE;
4988   CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
4989
4990   fixup_inline_methods (t);
4991
4992   /* Make assumptions about the class; we'll reset the flags if
4993      necessary.  */
4994   CLASSTYPE_EMPTY_P (t) = 1;
4995   CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
4996   CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
4997
4998   /* Do end-of-class semantic processing: checking the validity of the
4999      bases and members and add implicitly generated methods.  */
5000   check_bases_and_members (t);
5001
5002   /* Find the key method */
5003   if (TYPE_CONTAINS_VPTR_P (t))
5004     {
5005       CLASSTYPE_KEY_METHOD (t) = key_method (t);
5006
5007       /* If a polymorphic class has no key method, we may emit the vtable
5008          in every translation unit where the class definition appears.  */
5009       if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5010         keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5011     }
5012
5013   /* Layout the class itself.  */
5014   layout_class_type (t, &virtuals);
5015
5016   /* Make sure that we get our own copy of the vfield FIELD_DECL.  */
5017   vfield = TYPE_VFIELD (t);
5018   if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5019     {
5020       tree primary = CLASSTYPE_PRIMARY_BINFO (t);
5021
5022       my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
5023                                        BINFO_TYPE (primary)),
5024                           20010726);
5025       /* The vtable better be at the start.  */
5026       my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)),
5027                           20010726);
5028       my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)),
5029                           20010726);
5030
5031       vfield = copy_decl (vfield);
5032       DECL_FIELD_CONTEXT (vfield) = t;
5033       TYPE_VFIELD (t) = vfield;
5034     }
5035   else
5036     my_friendly_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t, 20010726);
5037
5038   virtuals = modify_all_vtables (t, nreverse (virtuals));
5039
5040   /* If we created a new vtbl pointer for this class, add it to the
5041      list.  */
5042   if (TYPE_VFIELD (t) && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5043     CLASSTYPE_VFIELDS (t)
5044       = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t));
5045
5046   /* If necessary, create the primary vtable for this class.  */
5047   if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5048     {
5049       /* We must enter these virtuals into the table.  */
5050       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5051         build_primary_vtable (NULL_TREE, t);
5052       else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5053         /* Here we know enough to change the type of our virtual
5054            function table, but we will wait until later this function.  */
5055         build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5056     }
5057
5058   if (TYPE_CONTAINS_VPTR_P (t))
5059     {
5060       int vindex;
5061       tree fn;
5062
5063       if (TYPE_BINFO_VTABLE (t))
5064         my_friendly_assert (DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)),
5065                             20000116);
5066       if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5067         my_friendly_assert (TYPE_BINFO_VIRTUALS (t) == NULL_TREE,
5068                             20000116);
5069
5070       /* Add entries for virtual functions introduced by this class.  */
5071       TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t), virtuals);
5072
5073       /* Set DECL_VINDEX for all functions declared in this class.  */
5074       for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5075            fn;
5076            fn = TREE_CHAIN (fn),
5077              vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5078                         ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5079         {
5080           tree fndecl = BV_FN (fn);
5081
5082           if (DECL_THUNK_P (fndecl))
5083             /* A thunk. We should never be calling this entry directly
5084                from this vtable -- we'd use the entry for the non
5085                thunk base function.  */
5086             DECL_VINDEX (fndecl) = NULL_TREE;
5087           else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5088             DECL_VINDEX (fndecl) = build_shared_int_cst (vindex);
5089         }
5090     }
5091
5092   finish_struct_bits (t);
5093
5094   /* Complete the rtl for any static member objects of the type we're
5095      working on.  */
5096   for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5097     if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5098         && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5099       DECL_MODE (x) = TYPE_MODE (t);
5100
5101   /* Done with FIELDS...now decide whether to sort these for
5102      faster lookups later.
5103
5104      We use a small number because most searches fail (succeeding
5105      ultimately as the search bores through the inheritance
5106      hierarchy), and we want this failure to occur quickly.  */
5107
5108   n_fields = count_fields (TYPE_FIELDS (t));
5109   if (n_fields > 7)
5110     {
5111       struct sorted_fields_type *field_vec = ggc_alloc (sizeof (struct sorted_fields_type)
5112         + n_fields * sizeof (tree));
5113       field_vec->len = n_fields;
5114       add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5115       qsort (field_vec->elts, n_fields, sizeof (tree),
5116              field_decl_cmp);
5117       if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5118         retrofit_lang_decl (TYPE_MAIN_DECL (t));
5119       DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5120     }
5121
5122   if (TYPE_HAS_CONSTRUCTOR (t))
5123     {
5124       tree vfields = CLASSTYPE_VFIELDS (t);
5125
5126       for (vfields = CLASSTYPE_VFIELDS (t);
5127            vfields; vfields = TREE_CHAIN (vfields))
5128         /* Mark the fact that constructor for T could affect anybody
5129            inheriting from T who wants to initialize vtables for
5130            VFIELDS's type.  */
5131         if (VF_BINFO_VALUE (vfields))
5132           TREE_ADDRESSABLE (vfields) = 1;
5133     }
5134
5135   /* Make the rtl for any new vtables we have created, and unmark
5136      the base types we marked.  */
5137   finish_vtbls (t);
5138
5139   /* Build the VTT for T.  */
5140   build_vtt (t);
5141
5142   if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
5143       && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 1)) == NULL_TREE)
5144     warning ("`%#T' has virtual functions but non-virtual destructor", t);
5145
5146   complete_vars (t);
5147
5148   if (warn_overloaded_virtual)
5149     warn_hidden (t);
5150
5151   maybe_suppress_debug_info (t);
5152
5153   dump_class_hierarchy (t);
5154
5155   /* Finish debugging output for this type.  */
5156   rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5157 }
5158
5159 /* When T was built up, the member declarations were added in reverse
5160    order.  Rearrange them to declaration order.  */
5161
5162 void
5163 unreverse_member_declarations (tree t)
5164 {
5165   tree next;
5166   tree prev;
5167   tree x;
5168
5169   /* The following lists are all in reverse order.  Put them in
5170      declaration order now.  */
5171   TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5172   CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5173
5174   /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5175      reverse order, so we can't just use nreverse.  */
5176   prev = NULL_TREE;
5177   for (x = TYPE_FIELDS (t);
5178        x && TREE_CODE (x) != TYPE_DECL;
5179        x = next)
5180     {
5181       next = TREE_CHAIN (x);
5182       TREE_CHAIN (x) = prev;
5183       prev = x;
5184     }
5185   if (prev)
5186     {
5187       TREE_CHAIN (TYPE_FIELDS (t)) = x;
5188       if (prev)
5189         TYPE_FIELDS (t) = prev;
5190     }
5191 }
5192
5193 tree
5194 finish_struct (tree t, tree attributes)
5195 {
5196   location_t saved_loc = input_location;
5197
5198   /* Now that we've got all the field declarations, reverse everything
5199      as necessary.  */
5200   unreverse_member_declarations (t);
5201
5202   cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5203
5204   /* Nadger the current location so that diagnostics point to the start of
5205      the struct, not the end.  */
5206   input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5207
5208   if (processing_template_decl)
5209     {
5210       finish_struct_methods (t);
5211       TYPE_SIZE (t) = bitsize_zero_node;
5212     }
5213   else
5214     finish_struct_1 (t);
5215
5216   input_location = saved_loc;
5217
5218   TYPE_BEING_DEFINED (t) = 0;
5219
5220   if (current_class_type)
5221     popclass ();
5222   else
5223     error ("trying to finish struct, but kicked out due to previous parse errors");
5224
5225   if (processing_template_decl && at_function_scope_p ())
5226     add_stmt (build_min (TAG_DEFN, t));
5227
5228   return t;
5229 }
5230 \f
5231 /* Return the dynamic type of INSTANCE, if known.
5232    Used to determine whether the virtual function table is needed
5233    or not.
5234
5235    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5236    of our knowledge of its type.  *NONNULL should be initialized
5237    before this function is called.  */
5238
5239 static tree
5240 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5241 {
5242   switch (TREE_CODE (instance))
5243     {
5244     case INDIRECT_REF:
5245       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5246         return NULL_TREE;
5247       else
5248         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5249                                    nonnull, cdtorp);
5250
5251     case CALL_EXPR:
5252       /* This is a call to a constructor, hence it's never zero.  */
5253       if (TREE_HAS_CONSTRUCTOR (instance))
5254         {
5255           if (nonnull)
5256             *nonnull = 1;
5257           return TREE_TYPE (instance);
5258         }
5259       return NULL_TREE;
5260
5261     case SAVE_EXPR:
5262       /* This is a call to a constructor, hence it's never zero.  */
5263       if (TREE_HAS_CONSTRUCTOR (instance))
5264         {
5265           if (nonnull)
5266             *nonnull = 1;
5267           return TREE_TYPE (instance);
5268         }
5269       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5270
5271     case RTL_EXPR:
5272       return NULL_TREE;
5273
5274     case PLUS_EXPR:
5275     case MINUS_EXPR:
5276       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5277         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5278       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5279         /* Propagate nonnull.  */
5280         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5281       return NULL_TREE;
5282
5283     case NOP_EXPR:
5284     case CONVERT_EXPR:
5285       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5286
5287     case ADDR_EXPR:
5288       if (nonnull)
5289         *nonnull = 1;
5290       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5291
5292     case COMPONENT_REF:
5293       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5294
5295     case VAR_DECL:
5296     case FIELD_DECL:
5297       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5298           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5299         {
5300           if (nonnull)
5301             *nonnull = 1;
5302           return TREE_TYPE (TREE_TYPE (instance));
5303         }
5304       /* fall through...  */
5305     case TARGET_EXPR:
5306     case PARM_DECL:
5307     case RESULT_DECL:
5308       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5309         {
5310           if (nonnull)
5311             *nonnull = 1;
5312           return TREE_TYPE (instance);
5313         }
5314       else if (instance == current_class_ptr)
5315         {
5316           if (nonnull)
5317             *nonnull = 1;
5318
5319           /* if we're in a ctor or dtor, we know our type.  */
5320           if (DECL_LANG_SPECIFIC (current_function_decl)
5321               && (DECL_CONSTRUCTOR_P (current_function_decl)
5322                   || DECL_DESTRUCTOR_P (current_function_decl)))
5323             {
5324               if (cdtorp)
5325                 *cdtorp = 1;
5326               return TREE_TYPE (TREE_TYPE (instance));
5327             }
5328         }
5329       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5330         {
5331           /* Reference variables should be references to objects.  */
5332           if (nonnull)
5333             *nonnull = 1;
5334
5335           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5336              variable's initializer may refer to the variable
5337              itself.  */
5338           if (TREE_CODE (instance) == VAR_DECL
5339               && DECL_INITIAL (instance)
5340               && !DECL_VAR_MARKED_P (instance))
5341             {
5342               tree type;
5343               DECL_VAR_MARKED_P (instance) = 1;
5344               type = fixed_type_or_null (DECL_INITIAL (instance),
5345                                          nonnull, cdtorp);
5346               DECL_VAR_MARKED_P (instance) = 0;
5347               return type;
5348             }
5349         }
5350       return NULL_TREE;
5351
5352     default:
5353       return NULL_TREE;
5354     }
5355 }
5356
5357 /* Return nonzero if the dynamic type of INSTANCE is known, and
5358    equivalent to the static type.  We also handle the case where
5359    INSTANCE is really a pointer. Return negative if this is a
5360    ctor/dtor. There the dynamic type is known, but this might not be
5361    the most derived base of the original object, and hence virtual
5362    bases may not be layed out according to this type.
5363
5364    Used to determine whether the virtual function table is needed
5365    or not.
5366
5367    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5368    of our knowledge of its type.  *NONNULL should be initialized
5369    before this function is called.  */
5370
5371 int
5372 resolves_to_fixed_type_p (tree instance, int* nonnull)
5373 {
5374   tree t = TREE_TYPE (instance);
5375   int cdtorp = 0;
5376
5377   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5378   if (fixed == NULL_TREE)
5379     return 0;
5380   if (POINTER_TYPE_P (t))
5381     t = TREE_TYPE (t);
5382   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5383     return 0;
5384   return cdtorp ? -1 : 1;
5385 }
5386
5387 \f
5388 void
5389 init_class_processing (void)
5390 {
5391   current_class_depth = 0;
5392   current_class_stack_size = 10;
5393   current_class_stack
5394     = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5395   VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5396
5397   ridpointers[(int) RID_PUBLIC] = access_public_node;
5398   ridpointers[(int) RID_PRIVATE] = access_private_node;
5399   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5400 }
5401
5402 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5403    appropriate for TYPE.
5404
5405    So that we may avoid calls to lookup_name, we cache the _TYPE
5406    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5407
5408    For multiple inheritance, we perform a two-pass depth-first search
5409    of the type lattice.  The first pass performs a pre-order search,
5410    marking types after the type has had its fields installed in
5411    the appropriate IDENTIFIER_CLASS_VALUE slot.  The second pass merely
5412    unmarks the marked types.  If a field or member function name
5413    appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5414    that name becomes `error_mark_node'.  */
5415
5416 void
5417 pushclass (tree type)
5418 {
5419   type = TYPE_MAIN_VARIANT (type);
5420
5421   /* Make sure there is enough room for the new entry on the stack.  */
5422   if (current_class_depth + 1 >= current_class_stack_size)
5423     {
5424       current_class_stack_size *= 2;
5425       current_class_stack
5426         = xrealloc (current_class_stack,
5427                     current_class_stack_size
5428                     * sizeof (struct class_stack_node));
5429     }
5430
5431   /* Insert a new entry on the class stack.  */
5432   current_class_stack[current_class_depth].name = current_class_name;
5433   current_class_stack[current_class_depth].type = current_class_type;
5434   current_class_stack[current_class_depth].access = current_access_specifier;
5435   current_class_stack[current_class_depth].names_used = 0;
5436   current_class_depth++;
5437
5438   /* Now set up the new type.  */
5439   current_class_name = TYPE_NAME (type);
5440   if (TREE_CODE (current_class_name) == TYPE_DECL)
5441     current_class_name = DECL_NAME (current_class_name);
5442   current_class_type = type;
5443
5444   /* By default, things in classes are private, while things in
5445      structures or unions are public.  */
5446   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5447                               ? access_private_node
5448                               : access_public_node);
5449
5450   if (previous_class_type != NULL_TREE
5451       && (type != previous_class_type
5452           || !COMPLETE_TYPE_P (previous_class_type))
5453       && current_class_depth == 1)
5454     {
5455       /* Forcibly remove any old class remnants.  */
5456       invalidate_class_lookup_cache ();
5457     }
5458
5459   /* If we're about to enter a nested class, clear
5460      IDENTIFIER_CLASS_VALUE for the enclosing classes.  */
5461   if (current_class_depth > 1)
5462     clear_identifier_class_values ();
5463
5464   pushlevel_class ();
5465
5466   if (type != previous_class_type || current_class_depth > 1)
5467     {
5468       push_class_decls (type);
5469       if (CLASSTYPE_TEMPLATE_INFO (type) && !CLASSTYPE_USE_TEMPLATE (type))
5470         {
5471           /* If we are entering the scope of a template declaration (not a
5472              specialization), we need to push all the using decls with
5473              dependent scope too.  */
5474           tree fields;
5475
5476           for (fields = TYPE_FIELDS (type);
5477                fields; fields = TREE_CHAIN (fields))
5478             if (TREE_CODE (fields) == USING_DECL && !TREE_TYPE (fields))
5479               pushdecl_class_level (fields);
5480         }
5481     }
5482   else
5483     {
5484       tree item;
5485
5486       /* We are re-entering the same class we just left, so we don't
5487          have to search the whole inheritance matrix to find all the
5488          decls to bind again.  Instead, we install the cached
5489          class_shadowed list, and walk through it binding names and
5490          setting up IDENTIFIER_TYPE_VALUEs.  */
5491       set_class_shadows (previous_class_values);
5492       for (item = previous_class_values; item; item = TREE_CHAIN (item))
5493         {
5494           tree id = TREE_PURPOSE (item);
5495           tree decl = TREE_TYPE (item);
5496
5497           push_class_binding (id, decl);
5498           if (TREE_CODE (decl) == TYPE_DECL)
5499             set_identifier_type_value (id, decl);
5500         }
5501       unuse_fields (type);
5502     }
5503
5504   cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type));
5505 }
5506
5507 /* When we exit a toplevel class scope, we save the
5508    IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5509    reenter the class.  Here, we've entered some other class, so we
5510    must invalidate our cache.  */
5511
5512 void
5513 invalidate_class_lookup_cache (void)
5514 {
5515   tree t;
5516
5517   /* The IDENTIFIER_CLASS_VALUEs are no longer valid.  */
5518   for (t = previous_class_values; t; t = TREE_CHAIN (t))
5519     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
5520
5521   previous_class_values = NULL_TREE;
5522   previous_class_type = NULL_TREE;
5523 }
5524
5525 /* Get out of the current class scope. If we were in a class scope
5526    previously, that is the one popped to.  */
5527
5528 void
5529 popclass (void)
5530 {
5531   poplevel_class ();
5532   pop_class_decls ();
5533
5534   current_class_depth--;
5535   current_class_name = current_class_stack[current_class_depth].name;
5536   current_class_type = current_class_stack[current_class_depth].type;
5537   current_access_specifier = current_class_stack[current_class_depth].access;
5538   if (current_class_stack[current_class_depth].names_used)
5539     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5540 }
5541
5542 /* Returns 1 if current_class_type is either T or a nested type of T.
5543    We start looking from 1 because entry 0 is from global scope, and has
5544    no type.  */
5545
5546 int
5547 currently_open_class (tree t)
5548 {
5549   int i;
5550   if (current_class_type && same_type_p (t, current_class_type))
5551     return 1;
5552   for (i = 1; i < current_class_depth; ++i)
5553     if (current_class_stack[i].type
5554         && same_type_p (current_class_stack [i].type, t))
5555       return 1;
5556   return 0;
5557 }
5558
5559 /* If either current_class_type or one of its enclosing classes are derived
5560    from T, return the appropriate type.  Used to determine how we found
5561    something via unqualified lookup.  */
5562
5563 tree
5564 currently_open_derived_class (tree t)
5565 {
5566   int i;
5567
5568   /* The bases of a dependent type are unknown.  */
5569   if (dependent_type_p (t))
5570     return NULL_TREE;
5571
5572   if (DERIVED_FROM_P (t, current_class_type))
5573     return current_class_type;
5574
5575   for (i = current_class_depth - 1; i > 0; --i)
5576     if (DERIVED_FROM_P (t, current_class_stack[i].type))
5577       return current_class_stack[i].type;
5578
5579   return NULL_TREE;
5580 }
5581
5582 /* When entering a class scope, all enclosing class scopes' names with
5583    static meaning (static variables, static functions, types and
5584    enumerators) have to be visible.  This recursive function calls
5585    pushclass for all enclosing class contexts until global or a local
5586    scope is reached.  TYPE is the enclosed class.  */
5587
5588 void
5589 push_nested_class (tree type)
5590 {
5591   tree context;
5592
5593   /* A namespace might be passed in error cases, like A::B:C.  */
5594   if (type == NULL_TREE
5595       || type == error_mark_node
5596       || TREE_CODE (type) == NAMESPACE_DECL
5597       || ! IS_AGGR_TYPE (type)
5598       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5599       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5600     return;
5601
5602   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5603
5604   if (context && CLASS_TYPE_P (context))
5605     push_nested_class (context);
5606   pushclass (type);
5607 }
5608
5609 /* Undoes a push_nested_class call.  */
5610
5611 void
5612 pop_nested_class (void)
5613 {
5614   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5615
5616   popclass ();
5617   if (context && CLASS_TYPE_P (context))
5618     pop_nested_class ();
5619 }
5620
5621 /* Returns the number of extern "LANG" blocks we are nested within.  */
5622
5623 int
5624 current_lang_depth (void)
5625 {
5626   return VARRAY_ACTIVE_SIZE (current_lang_base);
5627 }
5628
5629 /* Set global variables CURRENT_LANG_NAME to appropriate value
5630    so that behavior of name-mangling machinery is correct.  */
5631
5632 void
5633 push_lang_context (tree name)
5634 {
5635   VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5636
5637   if (name == lang_name_cplusplus)
5638     {
5639       current_lang_name = name;
5640     }
5641   else if (name == lang_name_java)
5642     {
5643       current_lang_name = name;
5644       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5645          (See record_builtin_java_type in decl.c.)  However, that causes
5646          incorrect debug entries if these types are actually used.
5647          So we re-enable debug output after extern "Java".  */
5648       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5649       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5650       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5651       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5652       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5653       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5654       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5655       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5656     }
5657   else if (name == lang_name_c)
5658     {
5659       current_lang_name = name;
5660     }
5661   else
5662     error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
5663 }
5664
5665 /* Get out of the current language scope.  */
5666
5667 void
5668 pop_lang_context (void)
5669 {
5670   current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5671   VARRAY_POP (current_lang_base);
5672 }
5673 \f
5674 /* Type instantiation routines.  */
5675
5676 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5677    matches the TARGET_TYPE.  If there is no satisfactory match, return
5678    error_mark_node, and issue a error & warning messages under control
5679    of FLAGS.  Permit pointers to member function if FLAGS permits.  If
5680    TEMPLATE_ONLY, the name of the overloaded function was a
5681    template-id, and EXPLICIT_TARGS are the explicitly provided
5682    template arguments.  */
5683
5684 static tree
5685 resolve_address_of_overloaded_function (tree target_type,
5686                                         tree overload,
5687                                         tsubst_flags_t flags,
5688                                         bool template_only,
5689                                         tree explicit_targs)
5690 {
5691   /* Here's what the standard says:
5692
5693        [over.over]
5694
5695        If the name is a function template, template argument deduction
5696        is done, and if the argument deduction succeeds, the deduced
5697        arguments are used to generate a single template function, which
5698        is added to the set of overloaded functions considered.
5699
5700        Non-member functions and static member functions match targets of
5701        type "pointer-to-function" or "reference-to-function."  Nonstatic
5702        member functions match targets of type "pointer-to-member
5703        function;" the function type of the pointer to member is used to
5704        select the member function from the set of overloaded member
5705        functions.  If a nonstatic member function is selected, the
5706        reference to the overloaded function name is required to have the
5707        form of a pointer to member as described in 5.3.1.
5708
5709        If more than one function is selected, any template functions in
5710        the set are eliminated if the set also contains a non-template
5711        function, and any given template function is eliminated if the
5712        set contains a second template function that is more specialized
5713        than the first according to the partial ordering rules 14.5.5.2.
5714        After such eliminations, if any, there shall remain exactly one
5715        selected function.  */
5716
5717   int is_ptrmem = 0;
5718   int is_reference = 0;
5719   /* We store the matches in a TREE_LIST rooted here.  The functions
5720      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5721      interoperability with most_specialized_instantiation.  */
5722   tree matches = NULL_TREE;
5723   tree fn;
5724
5725   /* By the time we get here, we should be seeing only real
5726      pointer-to-member types, not the internal POINTER_TYPE to
5727      METHOD_TYPE representation.  */
5728   my_friendly_assert (!(TREE_CODE (target_type) == POINTER_TYPE
5729                         && (TREE_CODE (TREE_TYPE (target_type))
5730                             == METHOD_TYPE)), 0);
5731
5732   my_friendly_assert (is_overloaded_fn (overload), 20030910);
5733
5734   /* Check that the TARGET_TYPE is reasonable.  */
5735   if (TYPE_PTRFN_P (target_type))
5736     /* This is OK.  */;
5737   else if (TYPE_PTRMEMFUNC_P (target_type))
5738     /* This is OK, too.  */
5739     is_ptrmem = 1;
5740   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5741     {
5742       /* This is OK, too.  This comes from a conversion to reference
5743          type.  */
5744       target_type = build_reference_type (target_type);
5745       is_reference = 1;
5746     }
5747   else
5748     {
5749       if (flags & tf_error)
5750         error ("\
5751 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5752                   DECL_NAME (OVL_FUNCTION (overload)), target_type);
5753       return error_mark_node;
5754     }
5755
5756   /* If we can find a non-template function that matches, we can just
5757      use it.  There's no point in generating template instantiations
5758      if we're just going to throw them out anyhow.  But, of course, we
5759      can only do this when we don't *need* a template function.  */
5760   if (!template_only)
5761     {
5762       tree fns;
5763
5764       for (fns = overload; fns; fns = OVL_NEXT (fns))
5765         {
5766           tree fn = OVL_CURRENT (fns);
5767           tree fntype;
5768
5769           if (TREE_CODE (fn) == TEMPLATE_DECL)
5770             /* We're not looking for templates just yet.  */
5771             continue;
5772
5773           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5774               != is_ptrmem)
5775             /* We're looking for a non-static member, and this isn't
5776                one, or vice versa.  */
5777             continue;
5778
5779           /* Ignore anticipated decls of undeclared builtins.  */
5780           if (DECL_ANTICIPATED (fn))
5781             continue;
5782
5783           /* See if there's a match.  */
5784           fntype = TREE_TYPE (fn);
5785           if (is_ptrmem)
5786             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5787           else if (!is_reference)
5788             fntype = build_pointer_type (fntype);
5789
5790           if (can_convert_arg (target_type, fntype, fn))
5791             matches = tree_cons (fn, NULL_TREE, matches);
5792         }
5793     }
5794
5795   /* Now, if we've already got a match (or matches), there's no need
5796      to proceed to the template functions.  But, if we don't have a
5797      match we need to look at them, too.  */
5798   if (!matches)
5799     {
5800       tree target_fn_type;
5801       tree target_arg_types;
5802       tree target_ret_type;
5803       tree fns;
5804
5805       if (is_ptrmem)
5806         target_fn_type
5807           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5808       else
5809         target_fn_type = TREE_TYPE (target_type);
5810       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5811       target_ret_type = TREE_TYPE (target_fn_type);
5812
5813       /* Never do unification on the 'this' parameter.  */
5814       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5815         target_arg_types = TREE_CHAIN (target_arg_types);
5816
5817       for (fns = overload; fns; fns = OVL_NEXT (fns))
5818         {
5819           tree fn = OVL_CURRENT (fns);
5820           tree instantiation;
5821           tree instantiation_type;
5822           tree targs;
5823
5824           if (TREE_CODE (fn) != TEMPLATE_DECL)
5825             /* We're only looking for templates.  */
5826             continue;
5827
5828           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5829               != is_ptrmem)
5830             /* We're not looking for a non-static member, and this is
5831                one, or vice versa.  */
5832             continue;
5833
5834           /* Try to do argument deduction.  */
5835           targs = make_tree_vec (DECL_NTPARMS (fn));
5836           if (fn_type_unification (fn, explicit_targs, targs,
5837                                    target_arg_types, target_ret_type,
5838                                    DEDUCE_EXACT, -1) != 0)
5839             /* Argument deduction failed.  */
5840             continue;
5841
5842           /* Instantiate the template.  */
5843           instantiation = instantiate_template (fn, targs, flags);
5844           if (instantiation == error_mark_node)
5845             /* Instantiation failed.  */
5846             continue;
5847
5848           /* See if there's a match.  */
5849           instantiation_type = TREE_TYPE (instantiation);
5850           if (is_ptrmem)
5851             instantiation_type =
5852               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5853           else if (!is_reference)
5854             instantiation_type = build_pointer_type (instantiation_type);
5855           if (can_convert_arg (target_type, instantiation_type, instantiation))
5856             matches = tree_cons (instantiation, fn, matches);
5857         }
5858
5859       /* Now, remove all but the most specialized of the matches.  */
5860       if (matches)
5861         {
5862           tree match = most_specialized_instantiation (matches);
5863
5864           if (match != error_mark_node)
5865             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5866         }
5867     }
5868
5869   /* Now we should have exactly one function in MATCHES.  */
5870   if (matches == NULL_TREE)
5871     {
5872       /* There were *no* matches.  */
5873       if (flags & tf_error)
5874         {
5875           error ("no matches converting function `%D' to type `%#T'",
5876                     DECL_NAME (OVL_FUNCTION (overload)),
5877                     target_type);
5878
5879           /* print_candidates expects a chain with the functions in
5880              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5881              so why be clever?).  */
5882           for (; overload; overload = OVL_NEXT (overload))
5883             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5884                                  matches);
5885
5886           print_candidates (matches);
5887         }
5888       return error_mark_node;
5889     }
5890   else if (TREE_CHAIN (matches))
5891     {
5892       /* There were too many matches.  */
5893
5894       if (flags & tf_error)
5895         {
5896           tree match;
5897
5898           error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5899                     DECL_NAME (OVL_FUNCTION (overload)),
5900                     target_type);
5901
5902           /* Since print_candidates expects the functions in the
5903              TREE_VALUE slot, we flip them here.  */
5904           for (match = matches; match; match = TREE_CHAIN (match))
5905             TREE_VALUE (match) = TREE_PURPOSE (match);
5906
5907           print_candidates (matches);
5908         }
5909
5910       return error_mark_node;
5911     }
5912
5913   /* Good, exactly one match.  Now, convert it to the correct type.  */
5914   fn = TREE_PURPOSE (matches);
5915
5916   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5917       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5918     {
5919       static int explained;
5920
5921       if (!(flags & tf_error))
5922         return error_mark_node;
5923
5924       pedwarn ("assuming pointer to member `%D'", fn);
5925       if (!explained)
5926         {
5927           pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
5928           explained = 1;
5929         }
5930     }
5931   mark_used (fn);
5932
5933   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5934     return build_unary_op (ADDR_EXPR, fn, 0);
5935   else
5936     {
5937       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5938          will mark the function as addressed, but here we must do it
5939          explicitly.  */
5940       cxx_mark_addressable (fn);
5941
5942       return fn;
5943     }
5944 }
5945
5946 /* This function will instantiate the type of the expression given in
5947    RHS to match the type of LHSTYPE.  If errors exist, then return
5948    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5949    we complain on errors.  If we are not complaining, never modify rhs,
5950    as overload resolution wants to try many possible instantiations, in
5951    the hope that at least one will work.
5952
5953    For non-recursive calls, LHSTYPE should be a function, pointer to
5954    function, or a pointer to member function.  */
5955
5956 tree
5957 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
5958 {
5959   tsubst_flags_t flags_in = flags;
5960
5961   flags &= ~tf_ptrmem_ok;
5962
5963   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
5964     {
5965       if (flags & tf_error)
5966         error ("not enough type information");
5967       return error_mark_node;
5968     }
5969
5970   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
5971     {
5972       if (same_type_p (lhstype, TREE_TYPE (rhs)))
5973         return rhs;
5974       if (flag_ms_extensions
5975           && TYPE_PTRMEMFUNC_P (lhstype)
5976           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
5977         /* Microsoft allows `A::f' to be resolved to a
5978            pointer-to-member.  */
5979         ;
5980       else
5981         {
5982           if (flags & tf_error)
5983             error ("argument of type `%T' does not match `%T'",
5984                    TREE_TYPE (rhs), lhstype);
5985           return error_mark_node;
5986         }
5987     }
5988
5989   if (TREE_CODE (rhs) == BASELINK)
5990     rhs = BASELINK_FUNCTIONS (rhs);
5991
5992   /* We don't overwrite rhs if it is an overloaded function.
5993      Copying it would destroy the tree link.  */
5994   if (TREE_CODE (rhs) != OVERLOAD)
5995     rhs = copy_node (rhs);
5996
5997   /* This should really only be used when attempting to distinguish
5998      what sort of a pointer to function we have.  For now, any
5999      arithmetic operation which is not supported on pointers
6000      is rejected as an error.  */
6001
6002   switch (TREE_CODE (rhs))
6003     {
6004     case TYPE_EXPR:
6005     case CONVERT_EXPR:
6006     case SAVE_EXPR:
6007     case CONSTRUCTOR:
6008     case BUFFER_REF:
6009       abort ();
6010       return error_mark_node;
6011
6012     case INDIRECT_REF:
6013     case ARRAY_REF:
6014       {
6015         tree new_rhs;
6016
6017         new_rhs = instantiate_type (build_pointer_type (lhstype),
6018                                     TREE_OPERAND (rhs, 0), flags);
6019         if (new_rhs == error_mark_node)
6020           return error_mark_node;
6021
6022         TREE_TYPE (rhs) = lhstype;
6023         TREE_OPERAND (rhs, 0) = new_rhs;
6024         return rhs;
6025       }
6026
6027     case NOP_EXPR:
6028       rhs = copy_node (TREE_OPERAND (rhs, 0));
6029       TREE_TYPE (rhs) = unknown_type_node;
6030       return instantiate_type (lhstype, rhs, flags);
6031
6032     case COMPONENT_REF:
6033       {
6034         tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6035
6036         if (addr != error_mark_node
6037             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6038           /* Do not lose object's side effects. */
6039           addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
6040                         TREE_OPERAND (rhs, 0), addr);
6041         return addr;
6042       }
6043
6044     case OFFSET_REF:
6045       rhs = TREE_OPERAND (rhs, 1);
6046       if (BASELINK_P (rhs))
6047         return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
6048
6049       /* This can happen if we are forming a pointer-to-member for a
6050          member template.  */
6051       my_friendly_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR, 0);
6052
6053       /* Fall through.  */
6054
6055     case TEMPLATE_ID_EXPR:
6056       {
6057         tree fns = TREE_OPERAND (rhs, 0);
6058         tree args = TREE_OPERAND (rhs, 1);
6059
6060         return
6061           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6062                                                   /*template_only=*/true,
6063                                                   args);
6064       }
6065
6066     case OVERLOAD:
6067     case FUNCTION_DECL:
6068       return
6069         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6070                                                 /*template_only=*/false,
6071                                                 /*explicit_targs=*/NULL_TREE);
6072
6073     case TREE_LIST:
6074       /* Now we should have a baselink.  */
6075       my_friendly_assert (BASELINK_P (rhs), 990412);
6076
6077       return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
6078
6079     case CALL_EXPR:
6080       /* This is too hard for now.  */
6081       abort ();
6082       return error_mark_node;
6083
6084     case PLUS_EXPR:
6085     case MINUS_EXPR:
6086     case COMPOUND_EXPR:
6087       TREE_OPERAND (rhs, 0)
6088         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6089       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6090         return error_mark_node;
6091       TREE_OPERAND (rhs, 1)
6092         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6093       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6094         return error_mark_node;
6095
6096       TREE_TYPE (rhs) = lhstype;
6097       return rhs;
6098
6099     case MULT_EXPR:
6100     case TRUNC_DIV_EXPR:
6101     case FLOOR_DIV_EXPR:
6102     case CEIL_DIV_EXPR:
6103     case ROUND_DIV_EXPR:
6104     case RDIV_EXPR:
6105     case TRUNC_MOD_EXPR:
6106     case FLOOR_MOD_EXPR:
6107     case CEIL_MOD_EXPR:
6108     case ROUND_MOD_EXPR:
6109     case FIX_ROUND_EXPR:
6110     case FIX_FLOOR_EXPR:
6111     case FIX_CEIL_EXPR:
6112     case FIX_TRUNC_EXPR:
6113     case FLOAT_EXPR:
6114     case NEGATE_EXPR:
6115     case ABS_EXPR:
6116     case MAX_EXPR:
6117     case MIN_EXPR:
6118     case FFS_EXPR:
6119
6120     case BIT_AND_EXPR:
6121     case BIT_IOR_EXPR:
6122     case BIT_XOR_EXPR:
6123     case LSHIFT_EXPR:
6124     case RSHIFT_EXPR:
6125     case LROTATE_EXPR:
6126     case RROTATE_EXPR:
6127
6128     case PREINCREMENT_EXPR:
6129     case PREDECREMENT_EXPR:
6130     case POSTINCREMENT_EXPR:
6131     case POSTDECREMENT_EXPR:
6132       if (flags & tf_error)
6133         error ("invalid operation on uninstantiated type");
6134       return error_mark_node;
6135
6136     case TRUTH_AND_EXPR:
6137     case TRUTH_OR_EXPR:
6138     case TRUTH_XOR_EXPR:
6139     case LT_EXPR:
6140     case LE_EXPR:
6141     case GT_EXPR:
6142     case GE_EXPR:
6143     case EQ_EXPR:
6144     case NE_EXPR:
6145     case TRUTH_ANDIF_EXPR:
6146     case TRUTH_ORIF_EXPR:
6147     case TRUTH_NOT_EXPR:
6148       if (flags & tf_error)
6149         error ("not enough type information");
6150       return error_mark_node;
6151
6152     case COND_EXPR:
6153       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6154         {
6155           if (flags & tf_error)
6156             error ("not enough type information");
6157           return error_mark_node;
6158         }
6159       TREE_OPERAND (rhs, 1)
6160         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6161       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6162         return error_mark_node;
6163       TREE_OPERAND (rhs, 2)
6164         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6165       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6166         return error_mark_node;
6167
6168       TREE_TYPE (rhs) = lhstype;
6169       return rhs;
6170
6171     case MODIFY_EXPR:
6172       TREE_OPERAND (rhs, 1)
6173         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6174       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6175         return error_mark_node;
6176
6177       TREE_TYPE (rhs) = lhstype;
6178       return rhs;
6179
6180     case ADDR_EXPR:
6181     {
6182       if (PTRMEM_OK_P (rhs))
6183         flags |= tf_ptrmem_ok;
6184
6185       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6186     }
6187     case ENTRY_VALUE_EXPR:
6188       abort ();
6189       return error_mark_node;
6190
6191     case ERROR_MARK:
6192       return error_mark_node;
6193
6194     default:
6195       abort ();
6196       return error_mark_node;
6197     }
6198 }
6199 \f
6200 /* Return the name of the virtual function pointer field
6201    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6202    this may have to look back through base types to find the
6203    ultimate field name.  (For single inheritance, these could
6204    all be the same name.  Who knows for multiple inheritance).  */
6205
6206 static tree
6207 get_vfield_name (tree type)
6208 {
6209   tree binfo = TYPE_BINFO (type);
6210   char *buf;
6211
6212   while (BINFO_BASETYPES (binfo)
6213          && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
6214          && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
6215     binfo = BINFO_BASETYPE (binfo, 0);
6216
6217   type = BINFO_TYPE (binfo);
6218   buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6219   sprintf (buf, VFIELD_NAME_FORMAT,
6220            IDENTIFIER_POINTER (constructor_name (type)));
6221   return get_identifier (buf);
6222 }
6223
6224 void
6225 print_class_statistics (void)
6226 {
6227 #ifdef GATHER_STATISTICS
6228   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6229   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6230   fprintf (stderr, "build_method_call = %d (inner = %d)\n",
6231            n_build_method_call, n_inner_fields_searched);
6232   if (n_vtables)
6233     {
6234       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6235                n_vtables, n_vtable_searches);
6236       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6237                n_vtable_entries, n_vtable_elems);
6238     }
6239 #endif
6240 }
6241
6242 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6243    according to [class]:
6244                                           The class-name is also inserted
6245    into  the scope of the class itself.  For purposes of access checking,
6246    the inserted class name is treated as if it were a public member name.  */
6247
6248 void
6249 build_self_reference (void)
6250 {
6251   tree name = constructor_name (current_class_type);
6252   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6253   tree saved_cas;
6254
6255   DECL_NONLOCAL (value) = 1;
6256   DECL_CONTEXT (value) = current_class_type;
6257   DECL_ARTIFICIAL (value) = 1;
6258   SET_DECL_SELF_REFERENCE_P (value);
6259
6260   if (processing_template_decl)
6261     value = push_template_decl (value);
6262
6263   saved_cas = current_access_specifier;
6264   current_access_specifier = access_public_node;
6265   finish_member_declaration (value);
6266   current_access_specifier = saved_cas;
6267 }
6268
6269 /* Returns 1 if TYPE contains only padding bytes.  */
6270
6271 int
6272 is_empty_class (tree type)
6273 {
6274   if (type == error_mark_node)
6275     return 0;
6276
6277   if (! IS_AGGR_TYPE (type))
6278     return 0;
6279
6280   /* In G++ 3.2, whether or not a class was empty was determined by
6281      looking at its size.  */
6282   if (abi_version_at_least (2))
6283     return CLASSTYPE_EMPTY_P (type);
6284   else
6285     return integer_zerop (CLASSTYPE_SIZE (type));
6286 }
6287
6288 /* Returns true if TYPE contains an empty class.  */
6289
6290 static bool
6291 contains_empty_class_p (tree type)
6292 {
6293   if (is_empty_class (type))
6294     return true;
6295   if (CLASS_TYPE_P (type))
6296     {
6297       tree field;
6298       int i;
6299
6300       for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); ++i)
6301         if (contains_empty_class_p (TYPE_BINFO_BASETYPE (type, i)))
6302           return true;
6303       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6304         if (TREE_CODE (field) == FIELD_DECL
6305             && !DECL_ARTIFICIAL (field)
6306             && is_empty_class (TREE_TYPE (field)))
6307           return true;
6308     }
6309   else if (TREE_CODE (type) == ARRAY_TYPE)
6310     return contains_empty_class_p (TREE_TYPE (type));
6311   return false;
6312 }
6313
6314 /* Find the enclosing class of the given NODE.  NODE can be a *_DECL or
6315    a *_TYPE node.  NODE can also be a local class.  */
6316
6317 tree
6318 get_enclosing_class (tree type)
6319 {
6320   tree node = type;
6321
6322   while (node && TREE_CODE (node) != NAMESPACE_DECL)
6323     {
6324       switch (TREE_CODE_CLASS (TREE_CODE (node)))
6325         {
6326         case 'd':
6327           node = DECL_CONTEXT (node);
6328           break;
6329
6330         case 't':
6331           if (node != type)
6332             return node;
6333           node = TYPE_CONTEXT (node);
6334           break;
6335
6336         default:
6337           abort ();
6338         }
6339     }
6340   return NULL_TREE;
6341 }
6342
6343 /* Note that NAME was looked up while the current class was being
6344    defined and that the result of that lookup was DECL.  */
6345
6346 void
6347 maybe_note_name_used_in_class (tree name, tree decl)
6348 {
6349   splay_tree names_used;
6350
6351   /* If we're not defining a class, there's nothing to do.  */
6352   if (!current_class_type || !TYPE_BEING_DEFINED (current_class_type))
6353     return;
6354
6355   /* If there's already a binding for this NAME, then we don't have
6356      anything to worry about.  */
6357   if (IDENTIFIER_CLASS_VALUE (name))
6358     return;
6359
6360   if (!current_class_stack[current_class_depth - 1].names_used)
6361     current_class_stack[current_class_depth - 1].names_used
6362       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6363   names_used = current_class_stack[current_class_depth - 1].names_used;
6364
6365   splay_tree_insert (names_used,
6366                      (splay_tree_key) name,
6367                      (splay_tree_value) decl);
6368 }
6369
6370 /* Note that NAME was declared (as DECL) in the current class.  Check
6371    to see that the declaration is valid.  */
6372
6373 void
6374 note_name_declared_in_class (tree name, tree decl)
6375 {
6376   splay_tree names_used;
6377   splay_tree_node n;
6378
6379   /* Look to see if we ever used this name.  */
6380   names_used
6381     = current_class_stack[current_class_depth - 1].names_used;
6382   if (!names_used)
6383     return;
6384
6385   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6386   if (n)
6387     {
6388       /* [basic.scope.class]
6389
6390          A name N used in a class S shall refer to the same declaration
6391          in its context and when re-evaluated in the completed scope of
6392          S.  */
6393       error ("declaration of `%#D'", decl);
6394       cp_error_at ("changes meaning of `%D' from `%+#D'",
6395                    DECL_NAME (OVL_CURRENT (decl)),
6396                    (tree) n->value);
6397     }
6398 }
6399
6400 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6401    Secondary vtables are merged with primary vtables; this function
6402    will return the VAR_DECL for the primary vtable.  */
6403
6404 tree
6405 get_vtbl_decl_for_binfo (tree binfo)
6406 {
6407   tree decl;
6408
6409   decl = BINFO_VTABLE (binfo);
6410   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6411     {
6412       my_friendly_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR,
6413                           2000403);
6414       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6415     }
6416   if (decl)
6417     my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20000403);
6418   return decl;
6419 }
6420
6421
6422 /* Returns the binfo for the primary base of BINFO.  If the resulting
6423    BINFO is a virtual base, and it is inherited elsewhere in the
6424    hierarchy, then the returned binfo might not be the primary base of
6425    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6426    BINFO_LOST_PRIMARY_P to be sure.  */
6427
6428 tree
6429 get_primary_binfo (tree binfo)
6430 {
6431   tree primary_base;
6432   tree result;
6433
6434   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6435   if (!primary_base)
6436     return NULL_TREE;
6437
6438   result = copied_binfo (primary_base, binfo);
6439   return result;
6440 }
6441
6442 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6443
6444 static int
6445 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6446 {
6447   if (!indented_p)
6448     fprintf (stream, "%*s", indent, "");
6449   return 1;
6450 }
6451
6452 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6453    INDENT should be zero when called from the top level; it is
6454    incremented recursively.  IGO indicates the next expected BINFO in
6455    inheritance graph ordering.  */
6456
6457 static tree
6458 dump_class_hierarchy_r (FILE *stream,
6459                         int flags,
6460                         tree binfo,
6461                         tree igo,
6462                         int indent)
6463 {
6464   int indented = 0;
6465   tree base_binfos;
6466
6467   indented = maybe_indent_hierarchy (stream, indent, 0);
6468   fprintf (stream, "%s (0x%lx) ",
6469            type_as_string (binfo, TFF_PLAIN_IDENTIFIER),
6470            (unsigned long) binfo);
6471   if (binfo != igo)
6472     {
6473       fprintf (stream, "alternative-path\n");
6474       return igo;
6475     }
6476   igo = TREE_CHAIN (binfo);
6477
6478   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6479            tree_low_cst (BINFO_OFFSET (binfo), 0));
6480   if (is_empty_class (BINFO_TYPE (binfo)))
6481     fprintf (stream, " empty");
6482   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6483     fprintf (stream, " nearly-empty");
6484   if (TREE_VIA_VIRTUAL (binfo))
6485     fprintf (stream, " virtual");
6486   fprintf (stream, "\n");
6487
6488   indented = 0;
6489   if (BINFO_PRIMARY_BASE_OF (binfo))
6490     {
6491       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6492       fprintf (stream, " primary-for %s (0x%lx)",
6493                type_as_string (BINFO_PRIMARY_BASE_OF (binfo),
6494                                TFF_PLAIN_IDENTIFIER),
6495                (unsigned long)BINFO_PRIMARY_BASE_OF (binfo));
6496     }
6497   if (BINFO_LOST_PRIMARY_P (binfo))
6498     {
6499       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6500       fprintf (stream, " lost-primary");
6501     }
6502   if (indented)
6503     fprintf (stream, "\n");
6504
6505   if (!(flags & TDF_SLIM))
6506     {
6507       int indented = 0;
6508
6509       if (BINFO_SUBVTT_INDEX (binfo))
6510         {
6511           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6512           fprintf (stream, " subvttidx=%s",
6513                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6514                                    TFF_PLAIN_IDENTIFIER));
6515         }
6516       if (BINFO_VPTR_INDEX (binfo))
6517         {
6518           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6519           fprintf (stream, " vptridx=%s",
6520                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6521                                    TFF_PLAIN_IDENTIFIER));
6522         }
6523       if (BINFO_VPTR_FIELD (binfo))
6524         {
6525           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6526           fprintf (stream, " vbaseoffset=%s",
6527                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6528                                    TFF_PLAIN_IDENTIFIER));
6529         }
6530       if (BINFO_VTABLE (binfo))
6531         {
6532           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6533           fprintf (stream, " vptr=%s",
6534                    expr_as_string (BINFO_VTABLE (binfo),
6535                                    TFF_PLAIN_IDENTIFIER));
6536         }
6537
6538       if (indented)
6539         fprintf (stream, "\n");
6540     }
6541
6542   base_binfos = BINFO_BASETYPES (binfo);
6543   if (base_binfos)
6544     {
6545       int ix, n;
6546
6547       n = TREE_VEC_LENGTH (base_binfos);
6548       for (ix = 0; ix != n; ix++)
6549         {
6550           tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
6551
6552           igo = dump_class_hierarchy_r (stream, flags, base_binfo,
6553                                         igo, indent + 2);
6554         }
6555     }
6556
6557   return igo;
6558 }
6559
6560 /* Dump the BINFO hierarchy for T.  */
6561
6562 static void
6563 dump_class_hierarchy (tree t)
6564 {
6565   int flags;
6566   FILE *stream = dump_begin (TDI_class, &flags);
6567
6568   if (!stream)
6569     return;
6570
6571   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6572   fprintf (stream, "   size=%lu align=%lu\n",
6573            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6574            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6575   fprintf (stream, "   base size=%lu base align=%lu\n",
6576            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6577                            / BITS_PER_UNIT),
6578            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6579                            / BITS_PER_UNIT));
6580   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6581   fprintf (stream, "\n");
6582   dump_end (TDI_class, stream);
6583 }
6584
6585 static void
6586 dump_array (FILE * stream, tree decl)
6587 {
6588   tree inits;
6589   int ix;
6590   HOST_WIDE_INT elt;
6591   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6592
6593   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6594          / BITS_PER_UNIT);
6595   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6596   fprintf (stream, " %s entries",
6597            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6598                            TFF_PLAIN_IDENTIFIER));
6599   fprintf (stream, "\n");
6600
6601   for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6602        inits; ix++, inits = TREE_CHAIN (inits))
6603     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6604              expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6605 }
6606
6607 static void
6608 dump_vtable (tree t, tree binfo, tree vtable)
6609 {
6610   int flags;
6611   FILE *stream = dump_begin (TDI_class, &flags);
6612
6613   if (!stream)
6614     return;
6615
6616   if (!(flags & TDF_SLIM))
6617     {
6618       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6619
6620       fprintf (stream, "%s for %s",
6621                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6622                type_as_string (binfo, TFF_PLAIN_IDENTIFIER));
6623       if (ctor_vtbl_p)
6624         {
6625           if (!TREE_VIA_VIRTUAL (binfo))
6626             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6627           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6628         }
6629       fprintf (stream, "\n");
6630       dump_array (stream, vtable);
6631       fprintf (stream, "\n");
6632     }
6633
6634   dump_end (TDI_class, stream);
6635 }
6636
6637 static void
6638 dump_vtt (tree t, tree vtt)
6639 {
6640   int flags;
6641   FILE *stream = dump_begin (TDI_class, &flags);
6642
6643   if (!stream)
6644     return;
6645
6646   if (!(flags & TDF_SLIM))
6647     {
6648       fprintf (stream, "VTT for %s\n",
6649                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6650       dump_array (stream, vtt);
6651       fprintf (stream, "\n");
6652     }
6653
6654   dump_end (TDI_class, stream);
6655 }
6656
6657 /* Virtual function table initialization.  */
6658
6659 /* Create all the necessary vtables for T and its base classes.  */
6660
6661 static void
6662 finish_vtbls (tree t)
6663 {
6664   tree list;
6665   tree vbase;
6666
6667   /* We lay out the primary and secondary vtables in one contiguous
6668      vtable.  The primary vtable is first, followed by the non-virtual
6669      secondary vtables in inheritance graph order.  */
6670   list = build_tree_list (TYPE_BINFO_VTABLE (t), NULL_TREE);
6671   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6672                          TYPE_BINFO (t), t, list);
6673
6674   /* Then come the virtual bases, also in inheritance graph order.  */
6675   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6676     {
6677       if (!TREE_VIA_VIRTUAL (vbase))
6678         continue;
6679       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6680     }
6681
6682   if (TYPE_BINFO_VTABLE (t))
6683     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6684 }
6685
6686 /* Initialize the vtable for BINFO with the INITS.  */
6687
6688 static void
6689 initialize_vtable (tree binfo, tree inits)
6690 {
6691   tree decl;
6692
6693   layout_vtable_decl (binfo, list_length (inits));
6694   decl = get_vtbl_decl_for_binfo (binfo);
6695   initialize_array (decl, inits);
6696   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6697 }
6698
6699 /* Initialize DECL (a declaration for a namespace-scope array) with
6700    the INITS.  */
6701
6702 static void
6703 initialize_array (tree decl, tree inits)
6704 {
6705   tree context;
6706
6707   context = DECL_CONTEXT (decl);
6708   DECL_CONTEXT (decl) = NULL_TREE;
6709   DECL_INITIAL (decl) = build_constructor (NULL_TREE, inits);
6710   TREE_HAS_CONSTRUCTOR (DECL_INITIAL (decl)) = 1;
6711   cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
6712   DECL_CONTEXT (decl) = context;
6713 }
6714
6715 /* Build the VTT (virtual table table) for T.
6716    A class requires a VTT if it has virtual bases.
6717
6718    This holds
6719    1 - primary virtual pointer for complete object T
6720    2 - secondary VTTs for each direct non-virtual base of T which requires a
6721        VTT
6722    3 - secondary virtual pointers for each direct or indirect base of T which
6723        has virtual bases or is reachable via a virtual path from T.
6724    4 - secondary VTTs for each direct or indirect virtual base of T.
6725
6726    Secondary VTTs look like complete object VTTs without part 4.  */
6727
6728 static void
6729 build_vtt (tree t)
6730 {
6731   tree inits;
6732   tree type;
6733   tree vtt;
6734   tree index;
6735
6736   /* Build up the initializers for the VTT.  */
6737   inits = NULL_TREE;
6738   index = size_zero_node;
6739   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6740
6741   /* If we didn't need a VTT, we're done.  */
6742   if (!inits)
6743     return;
6744
6745   /* Figure out the type of the VTT.  */
6746   type = build_index_type (size_int (list_length (inits) - 1));
6747   type = build_cplus_array_type (const_ptr_type_node, type);
6748
6749   /* Now, build the VTT object itself.  */
6750   vtt = build_vtable (t, get_vtt_name (t), type);
6751   initialize_array (vtt, inits);
6752   /* Add the VTT to the vtables list.  */
6753   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6754   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6755
6756   dump_vtt (t, vtt);
6757 }
6758
6759 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6760    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6761    and CHAIN the vtable pointer for this binfo after construction is
6762    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6763
6764 static tree
6765 binfo_ctor_vtable (tree binfo)
6766 {
6767   tree vt;
6768
6769   while (1)
6770     {
6771       vt = BINFO_VTABLE (binfo);
6772       if (TREE_CODE (vt) == TREE_LIST)
6773         vt = TREE_VALUE (vt);
6774       if (TREE_CODE (vt) == TREE_VEC)
6775         binfo = vt;
6776       else
6777         break;
6778     }
6779
6780   return vt;
6781 }
6782
6783 /* Recursively build the VTT-initializer for BINFO (which is in the
6784    hierarchy dominated by T).  INITS points to the end of the initializer
6785    list to date.  INDEX is the VTT index where the next element will be
6786    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6787    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6788    for virtual bases of T. When it is not so, we build the constructor
6789    vtables for the BINFO-in-T variant.  */
6790
6791 static tree *
6792 build_vtt_inits (tree binfo, tree t, tree* inits, tree* index)
6793 {
6794   int i;
6795   tree b;
6796   tree init;
6797   tree secondary_vptrs;
6798   int top_level_p = same_type_p (TREE_TYPE (binfo), t);
6799
6800   /* We only need VTTs for subobjects with virtual bases.  */
6801   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
6802     return inits;
6803
6804   /* We need to use a construction vtable if this is not the primary
6805      VTT.  */
6806   if (!top_level_p)
6807     {
6808       build_ctor_vtbl_group (binfo, t);
6809
6810       /* Record the offset in the VTT where this sub-VTT can be found.  */
6811       BINFO_SUBVTT_INDEX (binfo) = *index;
6812     }
6813
6814   /* Add the address of the primary vtable for the complete object.  */
6815   init = binfo_ctor_vtable (binfo);
6816   *inits = build_tree_list (NULL_TREE, init);
6817   inits = &TREE_CHAIN (*inits);
6818   if (top_level_p)
6819     {
6820       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
6821       BINFO_VPTR_INDEX (binfo) = *index;
6822     }
6823   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6824
6825   /* Recursively add the secondary VTTs for non-virtual bases.  */
6826   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
6827     {
6828       b = BINFO_BASETYPE (binfo, i);
6829       if (!TREE_VIA_VIRTUAL (b))
6830         inits = build_vtt_inits (BINFO_BASETYPE (binfo, i), t,
6831                                  inits, index);
6832     }
6833
6834   /* Add secondary virtual pointers for all subobjects of BINFO with
6835      either virtual bases or reachable along a virtual path, except
6836      subobjects that are non-virtual primary bases.  */
6837   secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo));
6838   TREE_TYPE (secondary_vptrs) = *index;
6839   VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p;
6840   VTT_MARKED_BINFO_P (secondary_vptrs) = 0;
6841
6842   dfs_walk_real (binfo,
6843                  dfs_build_secondary_vptr_vtt_inits,
6844                  NULL,
6845                  dfs_ctor_vtable_bases_queue_p,
6846                  secondary_vptrs);
6847   VTT_MARKED_BINFO_P (secondary_vptrs) = 1;
6848   dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p,
6849             secondary_vptrs);
6850
6851   *index = TREE_TYPE (secondary_vptrs);
6852
6853   /* The secondary vptrs come back in reverse order.  After we reverse
6854      them, and add the INITS, the last init will be the first element
6855      of the chain.  */
6856   secondary_vptrs = TREE_VALUE (secondary_vptrs);
6857   if (secondary_vptrs)
6858     {
6859       *inits = nreverse (secondary_vptrs);
6860       inits = &TREE_CHAIN (secondary_vptrs);
6861       my_friendly_assert (*inits == NULL_TREE, 20000517);
6862     }
6863
6864   /* Add the secondary VTTs for virtual bases.  */
6865   if (top_level_p)
6866     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6867       {
6868         if (!TREE_VIA_VIRTUAL (b))
6869           continue;
6870
6871         inits = build_vtt_inits (b, t, inits, index);
6872       }
6873
6874   if (!top_level_p)
6875     {
6876       tree data = tree_cons (t, binfo, NULL_TREE);
6877       VTT_TOP_LEVEL_P (data) = 0;
6878       VTT_MARKED_BINFO_P (data) = 0;
6879
6880       dfs_walk (binfo, dfs_fixup_binfo_vtbls,
6881                 dfs_ctor_vtable_bases_queue_p,
6882                 data);
6883     }
6884
6885   return inits;
6886 }
6887
6888 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo
6889    for the base in most derived. DATA is a TREE_LIST who's
6890    TREE_CHAIN is the type of the base being
6891    constructed whilst this secondary vptr is live.  The TREE_UNSIGNED
6892    flag of DATA indicates that this is a constructor vtable.  The
6893    TREE_TOP_LEVEL flag indicates that this is the primary VTT.  */
6894
6895 static tree
6896 dfs_build_secondary_vptr_vtt_inits (tree binfo, void* data)
6897 {
6898   tree l;
6899   tree t;
6900   tree init;
6901   tree index;
6902   int top_level_p;
6903
6904   l = (tree) data;
6905   t = TREE_CHAIN (l);
6906   top_level_p = VTT_TOP_LEVEL_P (l);
6907
6908   BINFO_MARKED (binfo) = 1;
6909
6910   /* We don't care about bases that don't have vtables.  */
6911   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6912     return NULL_TREE;
6913
6914   /* We're only interested in proper subobjects of T.  */
6915   if (same_type_p (BINFO_TYPE (binfo), t))
6916     return NULL_TREE;
6917
6918   /* We're not interested in non-virtual primary bases.  */
6919   if (!TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_P (binfo))
6920     return NULL_TREE;
6921
6922   /* If BINFO has virtual bases or is reachable via a virtual path
6923      from T, it'll have a secondary vptr.  */
6924   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
6925       && !binfo_via_virtual (binfo, t))
6926     return NULL_TREE;
6927
6928   /* Record the index where this secondary vptr can be found.  */
6929   index = TREE_TYPE (l);
6930   if (top_level_p)
6931     {
6932       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);
6933       BINFO_VPTR_INDEX (binfo) = index;
6934     }
6935   TREE_TYPE (l) = size_binop (PLUS_EXPR, index,
6936                               TYPE_SIZE_UNIT (ptr_type_node));
6937
6938   /* Add the initializer for the secondary vptr itself.  */
6939   if (top_level_p && TREE_VIA_VIRTUAL (binfo))
6940     {
6941       /* It's a primary virtual base, and this is not the construction
6942          vtable. Find the base this is primary of in the inheritance graph,
6943          and use that base's vtable now.  */
6944       while (BINFO_PRIMARY_BASE_OF (binfo))
6945         binfo = BINFO_PRIMARY_BASE_OF (binfo);
6946     }
6947   init = binfo_ctor_vtable (binfo);
6948   TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l));
6949
6950   return NULL_TREE;
6951 }
6952
6953 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
6954    VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
6955    should be walked.  TREE_PURPOSE is the TREE_TYPE that dominates the
6956    hierarchy.  */
6957
6958 static tree
6959 dfs_ctor_vtable_bases_queue_p (tree derived, int ix,
6960                                void* data)
6961 {
6962   tree binfo = BINFO_BASETYPE (derived, ix);
6963
6964   if (!BINFO_MARKED (binfo) == VTT_MARKED_BINFO_P ((tree) data))
6965     return NULL_TREE;
6966   return binfo;
6967 }
6968
6969 /* Called from build_vtt_inits via dfs_walk. After building constructor
6970    vtables and generating the sub-vtt from them, we need to restore the
6971    BINFO_VTABLES that were scribbled on.  DATA is a TREE_LIST whose
6972    TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated.  */
6973
6974 static tree
6975 dfs_fixup_binfo_vtbls (tree binfo, void* data)
6976 {
6977   BINFO_MARKED (binfo) = 0;
6978
6979   /* We don't care about bases that don't have vtables.  */
6980   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6981     return NULL_TREE;
6982
6983   /* If we scribbled the construction vtable vptr into BINFO, clear it
6984      out now.  */
6985   if (BINFO_VTABLE (binfo)
6986       && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST
6987       && (TREE_PURPOSE (BINFO_VTABLE (binfo))
6988           == TREE_VALUE ((tree) data)))
6989     BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo));
6990
6991   return NULL_TREE;
6992 }
6993
6994 /* Build the construction vtable group for BINFO which is in the
6995    hierarchy dominated by T.  */
6996
6997 static void
6998 build_ctor_vtbl_group (tree binfo, tree t)
6999 {
7000   tree list;
7001   tree type;
7002   tree vtbl;
7003   tree inits;
7004   tree id;
7005   tree vbase;
7006
7007   /* See if we've already created this construction vtable group.  */
7008   id = mangle_ctor_vtbl_for_type (t, binfo);
7009   if (IDENTIFIER_GLOBAL_VALUE (id))
7010     return;
7011
7012   my_friendly_assert (!same_type_p (BINFO_TYPE (binfo), t), 20010124);
7013   /* Build a version of VTBL (with the wrong type) for use in
7014      constructing the addresses of secondary vtables in the
7015      construction vtable group.  */
7016   vtbl = build_vtable (t, id, ptr_type_node);
7017   list = build_tree_list (vtbl, NULL_TREE);
7018   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7019                          binfo, t, list);
7020
7021   /* Add the vtables for each of our virtual bases using the vbase in T
7022      binfo.  */
7023   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7024        vbase;
7025        vbase = TREE_CHAIN (vbase))
7026     {
7027       tree b;
7028
7029       if (!TREE_VIA_VIRTUAL (vbase))
7030         continue;
7031       b = copied_binfo (vbase, binfo);
7032
7033       accumulate_vtbl_inits (b, vbase, binfo, t, list);
7034     }
7035   inits = TREE_VALUE (list);
7036
7037   /* Figure out the type of the construction vtable.  */
7038   type = build_index_type (size_int (list_length (inits) - 1));
7039   type = build_cplus_array_type (vtable_entry_type, type);
7040   TREE_TYPE (vtbl) = type;
7041
7042   /* Initialize the construction vtable.  */
7043   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7044   initialize_array (vtbl, inits);
7045   dump_vtable (t, binfo, vtbl);
7046 }
7047
7048 /* Add the vtbl initializers for BINFO (and its bases other than
7049    non-virtual primaries) to the list of INITS.  BINFO is in the
7050    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
7051    the constructor the vtbl inits should be accumulated for. (If this
7052    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7053    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7054    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7055    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7056    but are not necessarily the same in terms of layout.  */
7057
7058 static void
7059 accumulate_vtbl_inits (tree binfo,
7060                        tree orig_binfo,
7061                        tree rtti_binfo,
7062                        tree t,
7063                        tree inits)
7064 {
7065   int i;
7066   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7067
7068   my_friendly_assert (same_type_p (BINFO_TYPE (binfo),
7069                                    BINFO_TYPE (orig_binfo)),
7070                       20000517);
7071
7072   /* If it doesn't have a vptr, we don't do anything.  */
7073   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7074     return;
7075
7076   /* If we're building a construction vtable, we're not interested in
7077      subobjects that don't require construction vtables.  */
7078   if (ctor_vtbl_p
7079       && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7080       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7081     return;
7082
7083   /* Build the initializers for the BINFO-in-T vtable.  */
7084   TREE_VALUE (inits)
7085     = chainon (TREE_VALUE (inits),
7086                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7087                                           rtti_binfo, t, inits));
7088
7089   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7090      initialize each vtable we can figure out at what offset the
7091      secondary vtable lies from the primary vtable.  We can't use
7092      dfs_walk here because we need to iterate through bases of BINFO
7093      and RTTI_BINFO simultaneously.  */
7094   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7095     {
7096       tree base_binfo = BINFO_BASETYPE (binfo, i);
7097
7098       /* Skip virtual bases.  */
7099       if (TREE_VIA_VIRTUAL (base_binfo))
7100         continue;
7101       accumulate_vtbl_inits (base_binfo,
7102                              BINFO_BASETYPE (orig_binfo, i),
7103                              rtti_binfo, t,
7104                              inits);
7105     }
7106 }
7107
7108 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7109    the BINFO vtable.  */
7110
7111 static tree
7112 dfs_accumulate_vtbl_inits (tree binfo,
7113                            tree orig_binfo,
7114                            tree rtti_binfo,
7115                            tree t,
7116                            tree l)
7117 {
7118   tree inits = NULL_TREE;
7119   tree vtbl = NULL_TREE;
7120   int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7121
7122   if (ctor_vtbl_p
7123       && TREE_VIA_VIRTUAL (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7124     {
7125       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7126          primary virtual base.  If it is not the same primary in
7127          the hierarchy of T, we'll need to generate a ctor vtable
7128          for it, to place at its location in T.  If it is the same
7129          primary, we still need a VTT entry for the vtable, but it
7130          should point to the ctor vtable for the base it is a
7131          primary for within the sub-hierarchy of RTTI_BINFO.
7132
7133          There are three possible cases:
7134
7135          1) We are in the same place.
7136          2) We are a primary base within a lost primary virtual base of
7137          RTTI_BINFO.
7138          3) We are primary to something not a base of RTTI_BINFO.  */
7139
7140       tree b = BINFO_PRIMARY_BASE_OF (binfo);
7141       tree last = NULL_TREE;
7142
7143       /* First, look through the bases we are primary to for RTTI_BINFO
7144          or a virtual base.  */
7145       for (; b; b = BINFO_PRIMARY_BASE_OF (b))
7146         {
7147           last = b;
7148           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7149             break;
7150         }
7151       /* If we run out of primary links, keep looking down our
7152          inheritance chain; we might be an indirect primary.  */
7153       if (b == NULL_TREE)
7154         for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7155           if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)
7156             break;
7157
7158       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7159          base B and it is a base of RTTI_BINFO, this is case 2.  In
7160          either case, we share our vtable with LAST, i.e. the
7161          derived-most base within B of which we are a primary.  */
7162       if (b == rtti_binfo
7163           || (b && purpose_member (BINFO_TYPE (b),
7164                                    CLASSTYPE_VBASECLASSES (BINFO_TYPE (rtti_binfo)))))
7165         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7166            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7167            binfo_ctor_vtable after everything's been set up.  */
7168         vtbl = last;
7169
7170       /* Otherwise, this is case 3 and we get our own.  */
7171     }
7172   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7173     return inits;
7174
7175   if (!vtbl)
7176     {
7177       tree index;
7178       int non_fn_entries;
7179
7180       /* Compute the initializer for this vtable.  */
7181       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7182                                       &non_fn_entries);
7183
7184       /* Figure out the position to which the VPTR should point.  */
7185       vtbl = TREE_PURPOSE (l);
7186       vtbl = build1 (ADDR_EXPR,
7187                      vtbl_ptr_type_node,
7188                      vtbl);
7189       TREE_CONSTANT (vtbl) = 1;
7190       index = size_binop (PLUS_EXPR,
7191                           size_int (non_fn_entries),
7192                           size_int (list_length (TREE_VALUE (l))));
7193       index = size_binop (MULT_EXPR,
7194                           TYPE_SIZE_UNIT (vtable_entry_type),
7195                           index);
7196       vtbl = build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7197       TREE_CONSTANT (vtbl) = 1;
7198     }
7199
7200   if (ctor_vtbl_p)
7201     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7202        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7203        straighten this out.  */
7204     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7205   else if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo))
7206     inits = NULL_TREE;
7207   else
7208      /* For an ordinary vtable, set BINFO_VTABLE.  */
7209     BINFO_VTABLE (binfo) = vtbl;
7210
7211   return inits;
7212 }
7213
7214 /* Construct the initializer for BINFO's virtual function table.  BINFO
7215    is part of the hierarchy dominated by T.  If we're building a
7216    construction vtable, the ORIG_BINFO is the binfo we should use to
7217    find the actual function pointers to put in the vtable - but they
7218    can be overridden on the path to most-derived in the graph that
7219    ORIG_BINFO belongs.  Otherwise,
7220    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7221    BINFO that should be indicated by the RTTI information in the
7222    vtable; it will be a base class of T, rather than T itself, if we
7223    are building a construction vtable.
7224
7225    The value returned is a TREE_LIST suitable for wrapping in a
7226    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7227    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7228    number of non-function entries in the vtable.
7229
7230    It might seem that this function should never be called with a
7231    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7232    base is always subsumed by a derived class vtable.  However, when
7233    we are building construction vtables, we do build vtables for
7234    primary bases; we need these while the primary base is being
7235    constructed.  */
7236
7237 static tree
7238 build_vtbl_initializer (tree binfo,
7239                         tree orig_binfo,
7240                         tree t,
7241                         tree rtti_binfo,
7242                         int* non_fn_entries_p)
7243 {
7244   tree v, b;
7245   tree vfun_inits;
7246   tree vbase;
7247   vtbl_init_data vid;
7248
7249   /* Initialize VID.  */
7250   memset (&vid, 0, sizeof (vid));
7251   vid.binfo = binfo;
7252   vid.derived = t;
7253   vid.rtti_binfo = rtti_binfo;
7254   vid.last_init = &vid.inits;
7255   vid.primary_vtbl_p = (binfo == TYPE_BINFO (t));
7256   vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7257   vid.generate_vcall_entries = true;
7258   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7259   vid.index = ssize_int (-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7260
7261   /* Add entries to the vtable for RTTI.  */
7262   build_rtti_vtbl_entries (binfo, &vid);
7263
7264   /* Create an array for keeping track of the functions we've
7265      processed.  When we see multiple functions with the same
7266      signature, we share the vcall offsets.  */
7267   VARRAY_TREE_INIT (vid.fns, 32, "fns");
7268   /* Add the vcall and vbase offset entries.  */
7269   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7270   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7271      build_vbase_offset_vtbl_entries.  */
7272   for (vbase = CLASSTYPE_VBASECLASSES (t);
7273        vbase;
7274        vbase = TREE_CHAIN (vbase))
7275     BINFO_VTABLE_PATH_MARKED (TREE_VALUE (vbase)) = 0;
7276
7277   /* If the target requires padding between data entries, add that now.  */
7278   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7279     {
7280       tree cur, *prev;
7281
7282       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7283         {
7284           tree add = cur;
7285           int i;
7286
7287           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7288             add = tree_cons (NULL_TREE,
7289                              build1 (NOP_EXPR, vtable_entry_type,
7290                                      null_pointer_node),
7291                              add);
7292           *prev = add;
7293         }
7294     }
7295
7296   if (non_fn_entries_p)
7297     *non_fn_entries_p = list_length (vid.inits);
7298
7299   /* Go through all the ordinary virtual functions, building up
7300      initializers.  */
7301   vfun_inits = NULL_TREE;
7302   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7303     {
7304       tree delta;
7305       tree vcall_index;
7306       tree fn, fn_original;
7307       tree init = NULL_TREE;
7308
7309       fn = BV_FN (v);
7310       fn_original = fn;
7311       if (DECL_THUNK_P (fn))
7312         {
7313           if (!DECL_NAME (fn))
7314             finish_thunk (fn);
7315           fn_original = THUNK_TARGET (fn);
7316         }
7317
7318       /* If the only definition of this function signature along our
7319          primary base chain is from a lost primary, this vtable slot will
7320          never be used, so just zero it out.  This is important to avoid
7321          requiring extra thunks which cannot be generated with the function.
7322
7323          We first check this in update_vtable_entry_for_fn, so we handle
7324          restored primary bases properly; we also need to do it here so we
7325          zero out unused slots in ctor vtables, rather than filling themff
7326          with erroneous values (though harmless, apart from relocation
7327          costs).  */
7328       for (b = binfo; ; b = get_primary_binfo (b))
7329         {
7330           /* We found a defn before a lost primary; go ahead as normal.  */
7331           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7332             break;
7333
7334           /* The nearest definition is from a lost primary; clear the
7335              slot.  */
7336           if (BINFO_LOST_PRIMARY_P (b))
7337             {
7338               init = size_zero_node;
7339               break;
7340             }
7341         }
7342
7343       if (! init)
7344         {
7345           /* Pull the offset for `this', and the function to call, out of
7346              the list.  */
7347           delta = BV_DELTA (v);
7348           vcall_index = BV_VCALL_INDEX (v);
7349
7350           my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727);
7351           my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727);
7352
7353           /* You can't call an abstract virtual function; it's abstract.
7354              So, we replace these functions with __pure_virtual.  */
7355           if (DECL_PURE_VIRTUAL_P (fn_original))
7356             fn = abort_fndecl;
7357           else if (!integer_zerop (delta) || vcall_index)
7358             {
7359               fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7360               if (!DECL_NAME (fn))
7361                 finish_thunk (fn);
7362             }
7363           /* Take the address of the function, considering it to be of an
7364              appropriate generic type.  */
7365           init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7366           /* The address of a function can't change.  */
7367           TREE_CONSTANT (init) = 1;
7368         }
7369
7370       /* And add it to the chain of initializers.  */
7371       if (TARGET_VTABLE_USES_DESCRIPTORS)
7372         {
7373           int i;
7374           if (init == size_zero_node)
7375             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7376               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7377           else
7378             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7379               {
7380                 tree fdesc = build (FDESC_EXPR, vfunc_ptr_type_node,
7381                                     TREE_OPERAND (init, 0),
7382                                     build_int_2 (i, 0));
7383                 TREE_CONSTANT (fdesc) = 1;
7384
7385                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7386               }
7387         }
7388       else
7389         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7390     }
7391
7392   /* The initializers for virtual functions were built up in reverse
7393      order; straighten them out now.  */
7394   vfun_inits = nreverse (vfun_inits);
7395
7396   /* The negative offset initializers are also in reverse order.  */
7397   vid.inits = nreverse (vid.inits);
7398
7399   /* Chain the two together.  */
7400   return chainon (vid.inits, vfun_inits);
7401 }
7402
7403 /* Adds to vid->inits the initializers for the vbase and vcall
7404    offsets in BINFO, which is in the hierarchy dominated by T.  */
7405
7406 static void
7407 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7408 {
7409   tree b;
7410
7411   /* If this is a derived class, we must first create entries
7412      corresponding to the primary base class.  */
7413   b = get_primary_binfo (binfo);
7414   if (b)
7415     build_vcall_and_vbase_vtbl_entries (b, vid);
7416
7417   /* Add the vbase entries for this base.  */
7418   build_vbase_offset_vtbl_entries (binfo, vid);
7419   /* Add the vcall entries for this base.  */
7420   build_vcall_offset_vtbl_entries (binfo, vid);
7421 }
7422
7423 /* Returns the initializers for the vbase offset entries in the vtable
7424    for BINFO (which is part of the class hierarchy dominated by T), in
7425    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7426    where the next vbase offset will go.  */
7427
7428 static void
7429 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7430 {
7431   tree vbase;
7432   tree t;
7433   tree non_primary_binfo;
7434
7435   /* If there are no virtual baseclasses, then there is nothing to
7436      do.  */
7437   if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
7438     return;
7439
7440   t = vid->derived;
7441
7442   /* We might be a primary base class.  Go up the inheritance hierarchy
7443      until we find the most derived class of which we are a primary base:
7444      it is the offset of that which we need to use.  */
7445   non_primary_binfo = binfo;
7446   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7447     {
7448       tree b;
7449
7450       /* If we have reached a virtual base, then it must be a primary
7451          base (possibly multi-level) of vid->binfo, or we wouldn't
7452          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7453          might be a lost primary, so just skip down to vid->binfo.  */
7454       if (TREE_VIA_VIRTUAL (non_primary_binfo))
7455         {
7456           non_primary_binfo = vid->binfo;
7457           break;
7458         }
7459
7460       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7461       if (get_primary_binfo (b) != non_primary_binfo)
7462         break;
7463       non_primary_binfo = b;
7464     }
7465
7466   /* Go through the virtual bases, adding the offsets.  */
7467   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7468        vbase;
7469        vbase = TREE_CHAIN (vbase))
7470     {
7471       tree b;
7472       tree delta;
7473
7474       if (!TREE_VIA_VIRTUAL (vbase))
7475         continue;
7476
7477       /* Find the instance of this virtual base in the complete
7478          object.  */
7479       b = copied_binfo (vbase, binfo);
7480
7481       /* If we've already got an offset for this virtual base, we
7482          don't need another one.  */
7483       if (BINFO_VTABLE_PATH_MARKED (b))
7484         continue;
7485       BINFO_VTABLE_PATH_MARKED (b) = 1;
7486
7487       /* Figure out where we can find this vbase offset.  */
7488       delta = size_binop (MULT_EXPR,
7489                           vid->index,
7490                           convert (ssizetype,
7491                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7492       if (vid->primary_vtbl_p)
7493         BINFO_VPTR_FIELD (b) = delta;
7494
7495       if (binfo != TYPE_BINFO (t))
7496         {
7497           /* The vbase offset had better be the same.  */
7498           my_friendly_assert (tree_int_cst_equal (delta,
7499                                                   BINFO_VPTR_FIELD (vbase)),
7500                               20030202);
7501         }
7502
7503       /* The next vbase will come at a more negative offset.  */
7504       vid->index = size_binop (MINUS_EXPR, vid->index,
7505                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7506
7507       /* The initializer is the delta from BINFO to this virtual base.
7508          The vbase offsets go in reverse inheritance-graph order, and
7509          we are walking in inheritance graph order so these end up in
7510          the right order.  */
7511       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7512
7513       *vid->last_init
7514         = build_tree_list (NULL_TREE,
7515                            fold (build1 (NOP_EXPR,
7516                                          vtable_entry_type,
7517                                          delta)));
7518       vid->last_init = &TREE_CHAIN (*vid->last_init);
7519     }
7520 }
7521
7522 /* Adds the initializers for the vcall offset entries in the vtable
7523    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7524    to VID->INITS.  */
7525
7526 static void
7527 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7528 {
7529   /* We only need these entries if this base is a virtual base.  We
7530      compute the indices -- but do not add to the vtable -- when
7531      building the main vtable for a class.  */
7532   if (TREE_VIA_VIRTUAL (binfo) || binfo == TYPE_BINFO (vid->derived))
7533     {
7534       /* We need a vcall offset for each of the virtual functions in this
7535          vtable.  For example:
7536
7537            class A { virtual void f (); };
7538            class B1 : virtual public A { virtual void f (); };
7539            class B2 : virtual public A { virtual void f (); };
7540            class C: public B1, public B2 { virtual void f (); };
7541
7542          A C object has a primary base of B1, which has a primary base of A.  A
7543          C also has a secondary base of B2, which no longer has a primary base
7544          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7545          A, which will adjust the A* to a B2* to call f.  We have no way of
7546          knowing what (or even whether) this offset will be when we define B2,
7547          so we store this "vcall offset" in the A sub-vtable and look it up in
7548          a "virtual thunk" for B2::f.
7549
7550          We need entries for all the functions in our primary vtable and
7551          in our non-virtual bases' secondary vtables.  */
7552       vid->vbase = binfo;
7553       /* If we are just computing the vcall indices -- but do not need
7554          the actual entries -- not that.  */
7555       if (!TREE_VIA_VIRTUAL (binfo))
7556         vid->generate_vcall_entries = false;
7557       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7558       add_vcall_offset_vtbl_entries_r (binfo, vid);
7559     }
7560 }
7561
7562 /* Build vcall offsets, starting with those for BINFO.  */
7563
7564 static void
7565 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7566 {
7567   int i;
7568   tree primary_binfo;
7569
7570   /* Don't walk into virtual bases -- except, of course, for the
7571      virtual base for which we are building vcall offsets.  Any
7572      primary virtual base will have already had its offsets generated
7573      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7574   if (TREE_VIA_VIRTUAL (binfo) && vid->vbase != binfo)
7575     return;
7576
7577   /* If BINFO has a primary base, process it first.  */
7578   primary_binfo = get_primary_binfo (binfo);
7579   if (primary_binfo)
7580     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7581
7582   /* Add BINFO itself to the list.  */
7583   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7584
7585   /* Scan the non-primary bases of BINFO.  */
7586   for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7587     {
7588       tree base_binfo;
7589
7590       base_binfo = BINFO_BASETYPE (binfo, i);
7591       if (base_binfo != primary_binfo)
7592         add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7593     }
7594 }
7595
7596 /* Called from build_vcall_offset_vtbl_entries_r.  */
7597
7598 static void
7599 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7600 {
7601   /* Make entries for the rest of the virtuals.  */
7602   if (abi_version_at_least (2))
7603     {
7604       tree orig_fn;
7605
7606       /* The ABI requires that the methods be processed in declaration
7607          order.  G++ 3.2 used the order in the vtable.  */
7608       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7609            orig_fn;
7610            orig_fn = TREE_CHAIN (orig_fn))
7611         if (DECL_VINDEX (orig_fn))
7612           add_vcall_offset (orig_fn, binfo, vid);
7613     }
7614   else
7615     {
7616       tree derived_virtuals;
7617       tree base_virtuals;
7618       tree orig_virtuals;
7619       /* If BINFO is a primary base, the most derived class which has
7620          BINFO as a primary base; otherwise, just BINFO.  */
7621       tree non_primary_binfo;
7622
7623       /* We might be a primary base class.  Go up the inheritance hierarchy
7624          until we find the most derived class of which we are a primary base:
7625          it is the BINFO_VIRTUALS there that we need to consider.  */
7626       non_primary_binfo = binfo;
7627       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7628         {
7629           tree b;
7630
7631           /* If we have reached a virtual base, then it must be vid->vbase,
7632              because we ignore other virtual bases in
7633              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7634              base (possibly multi-level) of vid->binfo, or we wouldn't
7635              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7636              might be a lost primary, so just skip down to vid->binfo.  */
7637           if (TREE_VIA_VIRTUAL (non_primary_binfo))
7638             {
7639               if (non_primary_binfo != vid->vbase)
7640                 abort ();
7641               non_primary_binfo = vid->binfo;
7642               break;
7643             }
7644
7645           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7646           if (get_primary_binfo (b) != non_primary_binfo)
7647             break;
7648           non_primary_binfo = b;
7649         }
7650
7651       if (vid->ctor_vtbl_p)
7652         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7653            where rtti_binfo is the most derived type.  */
7654         non_primary_binfo
7655           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7656
7657       for (base_virtuals = BINFO_VIRTUALS (binfo),
7658              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7659              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7660            base_virtuals;
7661            base_virtuals = TREE_CHAIN (base_virtuals),
7662              derived_virtuals = TREE_CHAIN (derived_virtuals),
7663              orig_virtuals = TREE_CHAIN (orig_virtuals))
7664         {
7665           tree orig_fn;
7666
7667           /* Find the declaration that originally caused this function to
7668              be present in BINFO_TYPE (binfo).  */
7669           orig_fn = BV_FN (orig_virtuals);
7670
7671           /* When processing BINFO, we only want to generate vcall slots for
7672              function slots introduced in BINFO.  So don't try to generate
7673              one if the function isn't even defined in BINFO.  */
7674           if (!same_type_p (DECL_CONTEXT (orig_fn), BINFO_TYPE (binfo)))
7675             continue;
7676
7677           add_vcall_offset (orig_fn, binfo, vid);
7678         }
7679     }
7680 }
7681
7682 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7683
7684 static void
7685 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7686 {
7687   size_t i;
7688   tree vcall_offset;
7689
7690   /* If there is already an entry for a function with the same
7691      signature as FN, then we do not need a second vcall offset.
7692      Check the list of functions already present in the derived
7693      class vtable.  */
7694   for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7695     {
7696       tree derived_entry;
7697
7698       derived_entry = VARRAY_TREE (vid->fns, i);
7699       if (same_signature_p (derived_entry, orig_fn)
7700           /* We only use one vcall offset for virtual destructors,
7701              even though there are two virtual table entries.  */
7702           || (DECL_DESTRUCTOR_P (derived_entry)
7703               && DECL_DESTRUCTOR_P (orig_fn)))
7704         return;
7705     }
7706
7707   /* If we are building these vcall offsets as part of building
7708      the vtable for the most derived class, remember the vcall
7709      offset.  */
7710   if (vid->binfo == TYPE_BINFO (vid->derived))
7711     CLASSTYPE_VCALL_INDICES (vid->derived)
7712       = tree_cons (orig_fn, vid->index,
7713                    CLASSTYPE_VCALL_INDICES (vid->derived));
7714
7715   /* The next vcall offset will be found at a more negative
7716      offset.  */
7717   vid->index = size_binop (MINUS_EXPR, vid->index,
7718                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7719
7720   /* Keep track of this function.  */
7721   VARRAY_PUSH_TREE (vid->fns, orig_fn);
7722
7723   if (vid->generate_vcall_entries)
7724     {
7725       tree base;
7726       tree fn;
7727
7728       /* Find the overriding function.  */
7729       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7730       if (fn == error_mark_node)
7731         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7732                                integer_zero_node);
7733       else
7734         {
7735           base = TREE_VALUE (fn);
7736
7737           /* The vbase we're working on is a primary base of
7738              vid->binfo.  But it might be a lost primary, so its
7739              BINFO_OFFSET might be wrong, so we just use the
7740              BINFO_OFFSET from vid->binfo.  */
7741           vcall_offset = size_diffop (BINFO_OFFSET (base),
7742                                       BINFO_OFFSET (vid->binfo));
7743           vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7744                                        vcall_offset));
7745         }
7746       /* Add the initializer to the vtable.  */
7747       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7748       vid->last_init = &TREE_CHAIN (*vid->last_init);
7749     }
7750 }
7751
7752 /* Return vtbl initializers for the RTTI entries corresponding to the
7753    BINFO's vtable.  The RTTI entries should indicate the object given
7754    by VID->rtti_binfo.  */
7755
7756 static void
7757 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7758 {
7759   tree b;
7760   tree t;
7761   tree basetype;
7762   tree offset;
7763   tree decl;
7764   tree init;
7765
7766   basetype = BINFO_TYPE (binfo);
7767   t = BINFO_TYPE (vid->rtti_binfo);
7768
7769   /* To find the complete object, we will first convert to our most
7770      primary base, and then add the offset in the vtbl to that value.  */
7771   b = binfo;
7772   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7773          && !BINFO_LOST_PRIMARY_P (b))
7774     {
7775       tree primary_base;
7776
7777       primary_base = get_primary_binfo (b);
7778       my_friendly_assert (BINFO_PRIMARY_BASE_OF (primary_base) == b, 20010127);
7779       b = primary_base;
7780     }
7781   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7782
7783   /* The second entry is the address of the typeinfo object.  */
7784   if (flag_rtti)
7785     decl = build_address (get_tinfo_decl (t));
7786   else
7787     decl = integer_zero_node;
7788
7789   /* Convert the declaration to a type that can be stored in the
7790      vtable.  */
7791   init = build_nop (vfunc_ptr_type_node, decl);
7792   *vid->last_init = build_tree_list (NULL_TREE, init);
7793   vid->last_init = &TREE_CHAIN (*vid->last_init);
7794
7795   /* Add the offset-to-top entry.  It comes earlier in the vtable that
7796      the the typeinfo entry.  Convert the offset to look like a
7797      function pointer, so that we can put it in the vtable.  */
7798   init = build_nop (vfunc_ptr_type_node, offset);
7799   *vid->last_init = build_tree_list (NULL_TREE, init);
7800   vid->last_init = &TREE_CHAIN (*vid->last_init);
7801 }