gcc/cp/class.c

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