gcc/cp/class.c

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