gcc/cp/class.c

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