contrib/gcc-3.4/gcc/cp/class.c

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