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