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