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