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