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 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 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
5115       /* We need to emit an error message if this type was used as a parameter
5116          and it is an abstract type, even if it is a template. We construct
5117          a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5118          account and we call complete_vars with this type, which will check
5119          the PARM_DECLS. Note that while the type is being defined,
5120          CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5121          (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it.  */
5122       CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5123       for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5124         if (DECL_PURE_VIRTUAL_P (x))
5125           VEC_safe_push (tree, CLASSTYPE_PURE_VIRTUALS (t), x);
5126       complete_vars (t);
5127     }
5128   else
5129     finish_struct_1 (t);
5130
5131   input_location = saved_loc;
5132
5133   TYPE_BEING_DEFINED (t) = 0;
5134
5135   if (current_class_type)
5136     popclass ();
5137   else
5138     error ("trying to finish struct, but kicked out due to previous parse errors");
5139
5140   if (processing_template_decl && at_function_scope_p ())
5141     add_stmt (build_min (TAG_DEFN, t));
5142
5143   return t;
5144 }
5145 \f
5146 /* Return the dynamic type of INSTANCE, if known.
5147    Used to determine whether the virtual function table is needed
5148    or not.
5149
5150    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5151    of our knowledge of its type.  *NONNULL should be initialized
5152    before this function is called.  */
5153
5154 static tree
5155 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5156 {
5157   switch (TREE_CODE (instance))
5158     {
5159     case INDIRECT_REF:
5160       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5161         return NULL_TREE;
5162       else
5163         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5164                                    nonnull, cdtorp);
5165
5166     case CALL_EXPR:
5167       /* This is a call to a constructor, hence it's never zero.  */
5168       if (TREE_HAS_CONSTRUCTOR (instance))
5169         {
5170           if (nonnull)
5171             *nonnull = 1;
5172           return TREE_TYPE (instance);
5173         }
5174       return NULL_TREE;
5175
5176     case SAVE_EXPR:
5177       /* This is a call to a constructor, hence it's never zero.  */
5178       if (TREE_HAS_CONSTRUCTOR (instance))
5179         {
5180           if (nonnull)
5181             *nonnull = 1;
5182           return TREE_TYPE (instance);
5183         }
5184       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5185
5186     case PLUS_EXPR:
5187     case MINUS_EXPR:
5188       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5189         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5190       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5191         /* Propagate nonnull.  */
5192         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5193       return NULL_TREE;
5194
5195     case NOP_EXPR:
5196     case CONVERT_EXPR:
5197       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5198
5199     case ADDR_EXPR:
5200       instance = TREE_OPERAND (instance, 0);
5201       if (nonnull)
5202         {
5203           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5204              with a real object -- given &p->f, p can still be null.  */
5205           tree t = get_base_address (instance);
5206           /* ??? Probably should check DECL_WEAK here.  */
5207           if (t && DECL_P (t))
5208             *nonnull = 1;
5209         }
5210       return fixed_type_or_null (instance, nonnull, cdtorp);
5211
5212     case COMPONENT_REF:
5213       /* If this component is really a base class reference, then the field
5214          itself isn't definitive.  */
5215       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5216         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5217       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5218
5219     case VAR_DECL:
5220     case FIELD_DECL:
5221       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5222           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5223         {
5224           if (nonnull)
5225             *nonnull = 1;
5226           return TREE_TYPE (TREE_TYPE (instance));
5227         }
5228       /* fall through...  */
5229     case TARGET_EXPR:
5230     case PARM_DECL:
5231     case RESULT_DECL:
5232       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5233         {
5234           if (nonnull)
5235             *nonnull = 1;
5236           return TREE_TYPE (instance);
5237         }
5238       else if (instance == current_class_ptr)
5239         {
5240           if (nonnull)
5241             *nonnull = 1;
5242
5243           /* if we're in a ctor or dtor, we know our type.  */
5244           if (DECL_LANG_SPECIFIC (current_function_decl)
5245               && (DECL_CONSTRUCTOR_P (current_function_decl)
5246                   || DECL_DESTRUCTOR_P (current_function_decl)))
5247             {
5248               if (cdtorp)
5249                 *cdtorp = 1;
5250               return TREE_TYPE (TREE_TYPE (instance));
5251             }
5252         }
5253       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5254         {
5255           /* Reference variables should be references to objects.  */
5256           if (nonnull)
5257             *nonnull = 1;
5258
5259           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5260              variable's initializer may refer to the variable
5261              itself.  */
5262           if (TREE_CODE (instance) == VAR_DECL
5263               && DECL_INITIAL (instance)
5264               && !DECL_VAR_MARKED_P (instance))
5265             {
5266               tree type;
5267               DECL_VAR_MARKED_P (instance) = 1;
5268               type = fixed_type_or_null (DECL_INITIAL (instance),
5269                                          nonnull, cdtorp);
5270               DECL_VAR_MARKED_P (instance) = 0;
5271               return type;
5272             }
5273         }
5274       return NULL_TREE;
5275
5276     default:
5277       return NULL_TREE;
5278     }
5279 }
5280
5281 /* Return nonzero if the dynamic type of INSTANCE is known, and
5282    equivalent to the static type.  We also handle the case where
5283    INSTANCE is really a pointer. Return negative if this is a
5284    ctor/dtor. There the dynamic type is known, but this might not be
5285    the most derived base of the original object, and hence virtual
5286    bases may not be layed out according to this type.
5287
5288    Used to determine whether the virtual function table is needed
5289    or not.
5290
5291    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5292    of our knowledge of its type.  *NONNULL should be initialized
5293    before this function is called.  */
5294
5295 int
5296 resolves_to_fixed_type_p (tree instance, int* nonnull)
5297 {
5298   tree t = TREE_TYPE (instance);
5299   int cdtorp = 0;
5300
5301   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5302   if (fixed == NULL_TREE)
5303     return 0;
5304   if (POINTER_TYPE_P (t))
5305     t = TREE_TYPE (t);
5306   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5307     return 0;
5308   return cdtorp ? -1 : 1;
5309 }
5310
5311 \f
5312 void
5313 init_class_processing (void)
5314 {
5315   current_class_depth = 0;
5316   current_class_stack_size = 10;
5317   current_class_stack
5318     = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5319   VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5320
5321   ridpointers[(int) RID_PUBLIC] = access_public_node;
5322   ridpointers[(int) RID_PRIVATE] = access_private_node;
5323   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5324 }
5325
5326 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5327
5328 static void
5329 restore_class_cache (void)
5330 {
5331   tree type;
5332
5333   /* We are re-entering the same class we just left, so we don't
5334      have to search the whole inheritance matrix to find all the
5335      decls to bind again.  Instead, we install the cached
5336      class_shadowed list and walk through it binding names.  */
5337   push_binding_level (previous_class_level);
5338   class_binding_level = previous_class_level;
5339   /* Restore IDENTIFIER_TYPE_VALUE.  */
5340   for (type = class_binding_level->type_shadowed;
5341        type;
5342        type = TREE_CHAIN (type))
5343     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5344 }
5345
5346 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5347    appropriate for TYPE.
5348
5349    So that we may avoid calls to lookup_name, we cache the _TYPE
5350    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5351
5352    For multiple inheritance, we perform a two-pass depth-first search
5353    of the type lattice.  */
5354
5355 void
5356 pushclass (tree type)
5357 {
5358   type = TYPE_MAIN_VARIANT (type);
5359
5360   /* Make sure there is enough room for the new entry on the stack.  */
5361   if (current_class_depth + 1 >= current_class_stack_size)
5362     {
5363       current_class_stack_size *= 2;
5364       current_class_stack
5365         = xrealloc (current_class_stack,
5366                     current_class_stack_size
5367                     * sizeof (struct class_stack_node));
5368     }
5369
5370   /* Insert a new entry on the class stack.  */
5371   current_class_stack[current_class_depth].name = current_class_name;
5372   current_class_stack[current_class_depth].type = current_class_type;
5373   current_class_stack[current_class_depth].access = current_access_specifier;
5374   current_class_stack[current_class_depth].names_used = 0;
5375   current_class_depth++;
5376
5377   /* Now set up the new type.  */
5378   current_class_name = TYPE_NAME (type);
5379   if (TREE_CODE (current_class_name) == TYPE_DECL)
5380     current_class_name = DECL_NAME (current_class_name);
5381   current_class_type = type;
5382
5383   /* By default, things in classes are private, while things in
5384      structures or unions are public.  */
5385   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5386                               ? access_private_node
5387                               : access_public_node);
5388
5389   if (previous_class_level
5390       && type != previous_class_level->this_entity
5391       && current_class_depth == 1)
5392     {
5393       /* Forcibly remove any old class remnants.  */
5394       invalidate_class_lookup_cache ();
5395     }
5396
5397   if (!previous_class_level
5398       || type != previous_class_level->this_entity
5399       || current_class_depth > 1)
5400     pushlevel_class ();
5401   else
5402     restore_class_cache ();
5403 }
5404
5405 /* When we exit a toplevel class scope, we save its binding level so
5406    that we can restore it quickly.  Here, we've entered some other
5407    class, so we must invalidate our cache.  */
5408
5409 void
5410 invalidate_class_lookup_cache (void)
5411 {
5412   previous_class_level = NULL;
5413 }
5414
5415 /* Get out of the current class scope. If we were in a class scope
5416    previously, that is the one popped to.  */
5417
5418 void
5419 popclass (void)
5420 {
5421   poplevel_class ();
5422
5423   current_class_depth--;
5424   current_class_name = current_class_stack[current_class_depth].name;
5425   current_class_type = current_class_stack[current_class_depth].type;
5426   current_access_specifier = current_class_stack[current_class_depth].access;
5427   if (current_class_stack[current_class_depth].names_used)
5428     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5429 }
5430
5431 /* Returns 1 if current_class_type is either T or a nested type of T.
5432    We start looking from 1 because entry 0 is from global scope, and has
5433    no type.  */
5434
5435 int
5436 currently_open_class (tree t)
5437 {
5438   int i;
5439   if (current_class_type && same_type_p (t, current_class_type))
5440     return 1;
5441   for (i = 1; i < current_class_depth; ++i)
5442     if (current_class_stack[i].type
5443         && same_type_p (current_class_stack [i].type, t))
5444       return 1;
5445   return 0;
5446 }
5447
5448 /* If either current_class_type or one of its enclosing classes are derived
5449    from T, return the appropriate type.  Used to determine how we found
5450    something via unqualified lookup.  */
5451
5452 tree
5453 currently_open_derived_class (tree t)
5454 {
5455   int i;
5456
5457   /* The bases of a dependent type are unknown.  */
5458   if (dependent_type_p (t))
5459     return NULL_TREE;
5460
5461   if (!current_class_type)
5462     return NULL_TREE;
5463
5464   if (DERIVED_FROM_P (t, current_class_type))
5465     return current_class_type;
5466
5467   for (i = current_class_depth - 1; i > 0; --i)
5468     if (DERIVED_FROM_P (t, current_class_stack[i].type))
5469       return current_class_stack[i].type;
5470
5471   return NULL_TREE;
5472 }
5473
5474 /* When entering a class scope, all enclosing class scopes' names with
5475    static meaning (static variables, static functions, types and
5476    enumerators) have to be visible.  This recursive function calls
5477    pushclass for all enclosing class contexts until global or a local
5478    scope is reached.  TYPE is the enclosed class.  */
5479
5480 void
5481 push_nested_class (tree type)
5482 {
5483   tree context;
5484
5485   /* A namespace might be passed in error cases, like A::B:C.  */
5486   if (type == NULL_TREE
5487       || type == error_mark_node
5488       || TREE_CODE (type) == NAMESPACE_DECL
5489       || ! IS_AGGR_TYPE (type)
5490       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5491       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5492     return;
5493
5494   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5495
5496   if (context && CLASS_TYPE_P (context))
5497     push_nested_class (context);
5498   pushclass (type);
5499 }
5500
5501 /* Undoes a push_nested_class call.  */
5502
5503 void
5504 pop_nested_class (void)
5505 {
5506   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5507
5508   popclass ();
5509   if (context && CLASS_TYPE_P (context))
5510     pop_nested_class ();
5511 }
5512
5513 /* Returns the number of extern "LANG" blocks we are nested within.  */
5514
5515 int
5516 current_lang_depth (void)
5517 {
5518   return VARRAY_ACTIVE_SIZE (current_lang_base);
5519 }
5520
5521 /* Set global variables CURRENT_LANG_NAME to appropriate value
5522    so that behavior of name-mangling machinery is correct.  */
5523
5524 void
5525 push_lang_context (tree name)
5526 {
5527   VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5528
5529   if (name == lang_name_cplusplus)
5530     {
5531       current_lang_name = name;
5532     }
5533   else if (name == lang_name_java)
5534     {
5535       current_lang_name = name;
5536       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5537          (See record_builtin_java_type in decl.c.)  However, that causes
5538          incorrect debug entries if these types are actually used.
5539          So we re-enable debug output after extern "Java".  */
5540       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5541       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5542       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5543       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5544       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5545       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5546       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5547       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5548     }
5549   else if (name == lang_name_c)
5550     {
5551       current_lang_name = name;
5552     }
5553   else
5554     error ("language string %<\"%E\"%> not recognized", name);
5555 }
5556
5557 /* Get out of the current language scope.  */
5558
5559 void
5560 pop_lang_context (void)
5561 {
5562   current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5563   VARRAY_POP (current_lang_base);
5564 }
5565 \f
5566 /* Type instantiation routines.  */
5567
5568 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5569    matches the TARGET_TYPE.  If there is no satisfactory match, return
5570    error_mark_node, and issue a error & warning messages under control
5571    of FLAGS.  Permit pointers to member function if FLAGS permits.  If
5572    TEMPLATE_ONLY, the name of the overloaded function was a
5573    template-id, and EXPLICIT_TARGS are the explicitly provided
5574    template arguments.  */
5575
5576 static tree
5577 resolve_address_of_overloaded_function (tree target_type,
5578                                         tree overload,
5579                                         tsubst_flags_t flags,
5580                                         bool template_only,
5581                                         tree explicit_targs)
5582 {
5583   /* Here's what the standard says:
5584
5585        [over.over]
5586
5587        If the name is a function template, template argument deduction
5588        is done, and if the argument deduction succeeds, the deduced
5589        arguments are used to generate a single template function, which
5590        is added to the set of overloaded functions considered.
5591
5592        Non-member functions and static member functions match targets of
5593        type "pointer-to-function" or "reference-to-function."  Nonstatic
5594        member functions match targets of type "pointer-to-member
5595        function;" the function type of the pointer to member is used to
5596        select the member function from the set of overloaded member
5597        functions.  If a nonstatic member function is selected, the
5598        reference to the overloaded function name is required to have the
5599        form of a pointer to member as described in 5.3.1.
5600
5601        If more than one function is selected, any template functions in
5602        the set are eliminated if the set also contains a non-template
5603        function, and any given template function is eliminated if the
5604        set contains a second template function that is more specialized
5605        than the first according to the partial ordering rules 14.5.5.2.
5606        After such eliminations, if any, there shall remain exactly one
5607        selected function.  */
5608
5609   int is_ptrmem = 0;
5610   int is_reference = 0;
5611   /* We store the matches in a TREE_LIST rooted here.  The functions
5612      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5613      interoperability with most_specialized_instantiation.  */
5614   tree matches = NULL_TREE;
5615   tree fn;
5616
5617   /* By the time we get here, we should be seeing only real
5618      pointer-to-member types, not the internal POINTER_TYPE to
5619      METHOD_TYPE representation.  */
5620   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
5621               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
5622
5623   gcc_assert (is_overloaded_fn (overload));
5624
5625   /* Check that the TARGET_TYPE is reasonable.  */
5626   if (TYPE_PTRFN_P (target_type))
5627     /* This is OK.  */;
5628   else if (TYPE_PTRMEMFUNC_P (target_type))
5629     /* This is OK, too.  */
5630     is_ptrmem = 1;
5631   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5632     {
5633       /* This is OK, too.  This comes from a conversion to reference
5634          type.  */
5635       target_type = build_reference_type (target_type);
5636       is_reference = 1;
5637     }
5638   else
5639     {
5640       if (flags & tf_error)
5641         error ("cannot resolve overloaded function %qD based on"
5642                " conversion to type %qT",
5643                DECL_NAME (OVL_FUNCTION (overload)), target_type);
5644       return error_mark_node;
5645     }
5646
5647   /* If we can find a non-template function that matches, we can just
5648      use it.  There's no point in generating template instantiations
5649      if we're just going to throw them out anyhow.  But, of course, we
5650      can only do this when we don't *need* a template function.  */
5651   if (!template_only)
5652     {
5653       tree fns;
5654
5655       for (fns = overload; fns; fns = OVL_NEXT (fns))
5656         {
5657           tree fn = OVL_CURRENT (fns);
5658           tree fntype;
5659
5660           if (TREE_CODE (fn) == TEMPLATE_DECL)
5661             /* We're not looking for templates just yet.  */
5662             continue;
5663
5664           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5665               != is_ptrmem)
5666             /* We're looking for a non-static member, and this isn't
5667                one, or vice versa.  */
5668             continue;
5669
5670           /* Ignore anticipated decls of undeclared builtins.  */
5671           if (DECL_ANTICIPATED (fn))
5672             continue;
5673
5674           /* See if there's a match.  */
5675           fntype = TREE_TYPE (fn);
5676           if (is_ptrmem)
5677             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5678           else if (!is_reference)
5679             fntype = build_pointer_type (fntype);
5680
5681           if (can_convert_arg (target_type, fntype, fn))
5682             matches = tree_cons (fn, NULL_TREE, matches);
5683         }
5684     }
5685
5686   /* Now, if we've already got a match (or matches), there's no need
5687      to proceed to the template functions.  But, if we don't have a
5688      match we need to look at them, too.  */
5689   if (!matches)
5690     {
5691       tree target_fn_type;
5692       tree target_arg_types;
5693       tree target_ret_type;
5694       tree fns;
5695
5696       if (is_ptrmem)
5697         target_fn_type
5698           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5699       else
5700         target_fn_type = TREE_TYPE (target_type);
5701       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5702       target_ret_type = TREE_TYPE (target_fn_type);
5703
5704       /* Never do unification on the 'this' parameter.  */
5705       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5706         target_arg_types = TREE_CHAIN (target_arg_types);
5707
5708       for (fns = overload; fns; fns = OVL_NEXT (fns))
5709         {
5710           tree fn = OVL_CURRENT (fns);
5711           tree instantiation;
5712           tree instantiation_type;
5713           tree targs;
5714
5715           if (TREE_CODE (fn) != TEMPLATE_DECL)
5716             /* We're only looking for templates.  */
5717             continue;
5718
5719           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5720               != is_ptrmem)
5721             /* We're not looking for a non-static member, and this is
5722                one, or vice versa.  */
5723             continue;
5724
5725           /* Try to do argument deduction.  */
5726           targs = make_tree_vec (DECL_NTPARMS (fn));
5727           if (fn_type_unification (fn, explicit_targs, targs,
5728                                    target_arg_types, target_ret_type,
5729                                    DEDUCE_EXACT, -1) != 0)
5730             /* Argument deduction failed.  */
5731             continue;
5732
5733           /* Instantiate the template.  */
5734           instantiation = instantiate_template (fn, targs, flags);
5735           if (instantiation == error_mark_node)
5736             /* Instantiation failed.  */
5737             continue;
5738
5739           /* See if there's a match.  */
5740           instantiation_type = TREE_TYPE (instantiation);
5741           if (is_ptrmem)
5742             instantiation_type =
5743               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5744           else if (!is_reference)
5745             instantiation_type = build_pointer_type (instantiation_type);
5746           if (can_convert_arg (target_type, instantiation_type, instantiation))
5747             matches = tree_cons (instantiation, fn, matches);
5748         }
5749
5750       /* Now, remove all but the most specialized of the matches.  */
5751       if (matches)
5752         {
5753           tree match = most_specialized_instantiation (matches);
5754
5755           if (match != error_mark_node)
5756             matches = tree_cons (match, NULL_TREE, NULL_TREE);
5757         }
5758     }
5759
5760   /* Now we should have exactly one function in MATCHES.  */
5761   if (matches == NULL_TREE)
5762     {
5763       /* There were *no* matches.  */
5764       if (flags & tf_error)
5765         {
5766           error ("no matches converting function %qD to type %q#T",
5767                  DECL_NAME (OVL_FUNCTION (overload)),
5768                  target_type);
5769
5770           /* print_candidates expects a chain with the functions in
5771              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5772              so why be clever?).  */
5773           for (; overload; overload = OVL_NEXT (overload))
5774             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5775                                  matches);
5776
5777           print_candidates (matches);
5778         }
5779       return error_mark_node;
5780     }
5781   else if (TREE_CHAIN (matches))
5782     {
5783       /* There were too many matches.  */
5784
5785       if (flags & tf_error)
5786         {
5787           tree match;
5788
5789           error ("converting overloaded function %qD to type %q#T is ambiguous",
5790                     DECL_NAME (OVL_FUNCTION (overload)),
5791                     target_type);
5792
5793           /* Since print_candidates expects the functions in the
5794              TREE_VALUE slot, we flip them here.  */
5795           for (match = matches; match; match = TREE_CHAIN (match))
5796             TREE_VALUE (match) = TREE_PURPOSE (match);
5797
5798           print_candidates (matches);
5799         }
5800
5801       return error_mark_node;
5802     }
5803
5804   /* Good, exactly one match.  Now, convert it to the correct type.  */
5805   fn = TREE_PURPOSE (matches);
5806
5807   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5808       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5809     {
5810       static int explained;
5811
5812       if (!(flags & tf_error))
5813         return error_mark_node;
5814
5815       pedwarn ("assuming pointer to member %qD", fn);
5816       if (!explained)
5817         {
5818           pedwarn ("(a pointer to member can only be formed with %<&%E%>)", fn);
5819           explained = 1;
5820         }
5821     }
5822
5823   /* If we're doing overload resolution purely for the purpose of
5824      determining conversion sequences, we should not consider the
5825      function used.  If this conversion sequence is selected, the
5826      function will be marked as used at this point.  */
5827   if (!(flags & tf_conv))
5828     mark_used (fn);
5829
5830   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5831     return build_unary_op (ADDR_EXPR, fn, 0);
5832   else
5833     {
5834       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5835          will mark the function as addressed, but here we must do it
5836          explicitly.  */
5837       cxx_mark_addressable (fn);
5838
5839       return fn;
5840     }
5841 }
5842
5843 /* This function will instantiate the type of the expression given in
5844    RHS to match the type of LHSTYPE.  If errors exist, then return
5845    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5846    we complain on errors.  If we are not complaining, never modify rhs,
5847    as overload resolution wants to try many possible instantiations, in
5848    the hope that at least one will work.
5849
5850    For non-recursive calls, LHSTYPE should be a function, pointer to
5851    function, or a pointer to member function.  */
5852
5853 tree
5854 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
5855 {
5856   tsubst_flags_t flags_in = flags;
5857
5858   flags &= ~tf_ptrmem_ok;
5859
5860   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
5861     {
5862       if (flags & tf_error)
5863         error ("not enough type information");
5864       return error_mark_node;
5865     }
5866
5867   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
5868     {
5869       if (same_type_p (lhstype, TREE_TYPE (rhs)))
5870         return rhs;
5871       if (flag_ms_extensions
5872           && TYPE_PTRMEMFUNC_P (lhstype)
5873           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
5874         /* Microsoft allows `A::f' to be resolved to a
5875            pointer-to-member.  */
5876         ;
5877       else
5878         {
5879           if (flags & tf_error)
5880             error ("argument of type %qT does not match %qT",
5881                    TREE_TYPE (rhs), lhstype);
5882           return error_mark_node;
5883         }
5884     }
5885
5886   if (TREE_CODE (rhs) == BASELINK)
5887     rhs = BASELINK_FUNCTIONS (rhs);
5888
5889   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
5890      deduce any type information.  */
5891   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
5892     {
5893       if (flags & tf_error)
5894         error ("not enough type information");
5895       return error_mark_node;
5896     }
5897
5898   /* We don't overwrite rhs if it is an overloaded function.
5899      Copying it would destroy the tree link.  */
5900   if (TREE_CODE (rhs) != OVERLOAD)
5901     rhs = copy_node (rhs);
5902
5903   /* This should really only be used when attempting to distinguish
5904      what sort of a pointer to function we have.  For now, any
5905      arithmetic operation which is not supported on pointers
5906      is rejected as an error.  */
5907
5908   switch (TREE_CODE (rhs))
5909     {
5910     case TYPE_EXPR:
5911     case CONVERT_EXPR:
5912     case SAVE_EXPR:
5913     case CONSTRUCTOR:
5914       gcc_unreachable ();
5915
5916     case INDIRECT_REF:
5917     case ARRAY_REF:
5918       {
5919         tree new_rhs;
5920
5921         new_rhs = instantiate_type (build_pointer_type (lhstype),
5922                                     TREE_OPERAND (rhs, 0), flags);
5923         if (new_rhs == error_mark_node)
5924           return error_mark_node;
5925
5926         TREE_TYPE (rhs) = lhstype;
5927         TREE_OPERAND (rhs, 0) = new_rhs;
5928         return rhs;
5929       }
5930
5931     case NOP_EXPR:
5932       rhs = copy_node (TREE_OPERAND (rhs, 0));
5933       TREE_TYPE (rhs) = unknown_type_node;
5934       return instantiate_type (lhstype, rhs, flags);
5935
5936     case COMPONENT_REF:
5937       {
5938         tree member = TREE_OPERAND (rhs, 1);
5939
5940         member = instantiate_type (lhstype, member, flags);
5941         if (member != error_mark_node
5942             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
5943           /* Do not lose object's side effects.  */
5944           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
5945                          TREE_OPERAND (rhs, 0), member);
5946         return member;
5947       }
5948
5949     case OFFSET_REF:
5950       rhs = TREE_OPERAND (rhs, 1);
5951       if (BASELINK_P (rhs))
5952         return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
5953
5954       /* This can happen if we are forming a pointer-to-member for a
5955          member template.  */
5956       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
5957
5958       /* Fall through.  */
5959
5960     case TEMPLATE_ID_EXPR:
5961       {
5962         tree fns = TREE_OPERAND (rhs, 0);
5963         tree args = TREE_OPERAND (rhs, 1);
5964
5965         return
5966           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
5967                                                   /*template_only=*/true,
5968                                                   args);
5969       }
5970
5971     case OVERLOAD:
5972     case FUNCTION_DECL:
5973       return
5974         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
5975                                                 /*template_only=*/false,
5976                                                 /*explicit_targs=*/NULL_TREE);
5977
5978     case CALL_EXPR:
5979       /* This is too hard for now.  */
5980       gcc_unreachable ();
5981
5982     case PLUS_EXPR:
5983     case MINUS_EXPR:
5984     case COMPOUND_EXPR:
5985       TREE_OPERAND (rhs, 0)
5986         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
5987       if (TREE_OPERAND (rhs, 0) == error_mark_node)
5988         return error_mark_node;
5989       TREE_OPERAND (rhs, 1)
5990         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
5991       if (TREE_OPERAND (rhs, 1) == error_mark_node)
5992         return error_mark_node;
5993
5994       TREE_TYPE (rhs) = lhstype;
5995       return rhs;
5996
5997     case MULT_EXPR:
5998     case TRUNC_DIV_EXPR:
5999     case FLOOR_DIV_EXPR:
6000     case CEIL_DIV_EXPR:
6001     case ROUND_DIV_EXPR:
6002     case RDIV_EXPR:
6003     case TRUNC_MOD_EXPR:
6004     case FLOOR_MOD_EXPR:
6005     case CEIL_MOD_EXPR:
6006     case ROUND_MOD_EXPR:
6007     case FIX_ROUND_EXPR:
6008     case FIX_FLOOR_EXPR:
6009     case FIX_CEIL_EXPR:
6010     case FIX_TRUNC_EXPR:
6011     case FLOAT_EXPR:
6012     case NEGATE_EXPR:
6013     case ABS_EXPR:
6014     case MAX_EXPR:
6015     case MIN_EXPR:
6016
6017     case BIT_AND_EXPR:
6018     case BIT_IOR_EXPR:
6019     case BIT_XOR_EXPR:
6020     case LSHIFT_EXPR:
6021     case RSHIFT_EXPR:
6022     case LROTATE_EXPR:
6023     case RROTATE_EXPR:
6024
6025     case PREINCREMENT_EXPR:
6026     case PREDECREMENT_EXPR:
6027     case POSTINCREMENT_EXPR:
6028     case POSTDECREMENT_EXPR:
6029       if (flags & tf_error)
6030         error ("invalid operation on uninstantiated type");
6031       return error_mark_node;
6032
6033     case TRUTH_AND_EXPR:
6034     case TRUTH_OR_EXPR:
6035     case TRUTH_XOR_EXPR:
6036     case LT_EXPR:
6037     case LE_EXPR:
6038     case GT_EXPR:
6039     case GE_EXPR:
6040     case EQ_EXPR:
6041     case NE_EXPR:
6042     case TRUTH_ANDIF_EXPR:
6043     case TRUTH_ORIF_EXPR:
6044     case TRUTH_NOT_EXPR:
6045       if (flags & tf_error)
6046         error ("not enough type information");
6047       return error_mark_node;
6048
6049     case COND_EXPR:
6050       if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6051         {
6052           if (flags & tf_error)
6053             error ("not enough type information");
6054           return error_mark_node;
6055         }
6056       TREE_OPERAND (rhs, 1)
6057         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6058       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6059         return error_mark_node;
6060       TREE_OPERAND (rhs, 2)
6061         = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6062       if (TREE_OPERAND (rhs, 2) == error_mark_node)
6063         return error_mark_node;
6064
6065       TREE_TYPE (rhs) = lhstype;
6066       return rhs;
6067
6068     case MODIFY_EXPR:
6069       TREE_OPERAND (rhs, 1)
6070         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6071       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6072         return error_mark_node;
6073
6074       TREE_TYPE (rhs) = lhstype;
6075       return rhs;
6076
6077     case ADDR_EXPR:
6078     {
6079       if (PTRMEM_OK_P (rhs))
6080         flags |= tf_ptrmem_ok;
6081
6082       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6083     }
6084
6085     case ERROR_MARK:
6086       return error_mark_node;
6087
6088     default:
6089       gcc_unreachable ();
6090     }
6091   return error_mark_node;
6092 }
6093 \f
6094 /* Return the name of the virtual function pointer field
6095    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6096    this may have to look back through base types to find the
6097    ultimate field name.  (For single inheritance, these could
6098    all be the same name.  Who knows for multiple inheritance).  */
6099
6100 static tree
6101 get_vfield_name (tree type)
6102 {
6103   tree binfo, base_binfo;
6104   char *buf;
6105
6106   for (binfo = TYPE_BINFO (type);
6107        BINFO_N_BASE_BINFOS (binfo);
6108        binfo = base_binfo)
6109     {
6110       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6111
6112       if (BINFO_VIRTUAL_P (base_binfo)
6113           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6114         break;
6115     }
6116
6117   type = BINFO_TYPE (binfo);
6118   buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6119   sprintf (buf, VFIELD_NAME_FORMAT,
6120            IDENTIFIER_POINTER (constructor_name (type)));
6121   return get_identifier (buf);
6122 }
6123
6124 void
6125 print_class_statistics (void)
6126 {
6127 #ifdef GATHER_STATISTICS
6128   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6129   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6130   if (n_vtables)
6131     {
6132       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6133                n_vtables, n_vtable_searches);
6134       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6135                n_vtable_entries, n_vtable_elems);
6136     }
6137 #endif
6138 }
6139
6140 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6141    according to [class]:
6142                                           The class-name is also inserted
6143    into  the scope of the class itself.  For purposes of access checking,
6144    the inserted class name is treated as if it were a public member name.  */
6145
6146 void
6147 build_self_reference (void)
6148 {
6149   tree name = constructor_name (current_class_type);
6150   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6151   tree saved_cas;
6152
6153   DECL_NONLOCAL (value) = 1;
6154   DECL_CONTEXT (value) = current_class_type;
6155   DECL_ARTIFICIAL (value) = 1;
6156   SET_DECL_SELF_REFERENCE_P (value);
6157
6158   if (processing_template_decl)
6159     value = push_template_decl (value);
6160
6161   saved_cas = current_access_specifier;
6162   current_access_specifier = access_public_node;
6163   finish_member_declaration (value);
6164   current_access_specifier = saved_cas;
6165 }
6166
6167 /* Returns 1 if TYPE contains only padding bytes.  */
6168
6169 int
6170 is_empty_class (tree type)
6171 {
6172   if (type == error_mark_node)
6173     return 0;
6174
6175   if (! IS_AGGR_TYPE (type))
6176     return 0;
6177
6178   /* In G++ 3.2, whether or not a class was empty was determined by
6179      looking at its size.  */
6180   if (abi_version_at_least (2))
6181     return CLASSTYPE_EMPTY_P (type);
6182   else
6183     return integer_zerop (CLASSTYPE_SIZE (type));
6184 }
6185
6186 /* Returns true if TYPE contains an empty class.  */
6187
6188 static bool
6189 contains_empty_class_p (tree type)
6190 {
6191   if (is_empty_class (type))
6192     return true;
6193   if (CLASS_TYPE_P (type))
6194     {
6195       tree field;
6196       tree binfo;
6197       tree base_binfo;
6198       int i;
6199
6200       for (binfo = TYPE_BINFO (type), i = 0;
6201            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6202         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6203           return true;
6204       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6205         if (TREE_CODE (field) == FIELD_DECL
6206             && !DECL_ARTIFICIAL (field)
6207             && is_empty_class (TREE_TYPE (field)))
6208           return true;
6209     }
6210   else if (TREE_CODE (type) == ARRAY_TYPE)
6211     return contains_empty_class_p (TREE_TYPE (type));
6212   return false;
6213 }
6214
6215 /* Note that NAME was looked up while the current class was being
6216    defined and that the result of that lookup was DECL.  */
6217
6218 void
6219 maybe_note_name_used_in_class (tree name, tree decl)
6220 {
6221   splay_tree names_used;
6222
6223   /* If we're not defining a class, there's nothing to do.  */
6224   if (!(innermost_scope_kind() == sk_class
6225         && TYPE_BEING_DEFINED (current_class_type)))
6226     return;
6227
6228   /* If there's already a binding for this NAME, then we don't have
6229      anything to worry about.  */
6230   if (lookup_member (current_class_type, name,
6231                      /*protect=*/0, /*want_type=*/false))
6232     return;
6233
6234   if (!current_class_stack[current_class_depth - 1].names_used)
6235     current_class_stack[current_class_depth - 1].names_used
6236       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6237   names_used = current_class_stack[current_class_depth - 1].names_used;
6238
6239   splay_tree_insert (names_used,
6240                      (splay_tree_key) name,
6241                      (splay_tree_value) decl);
6242 }
6243
6244 /* Note that NAME was declared (as DECL) in the current class.  Check
6245    to see that the declaration is valid.  */
6246
6247 void
6248 note_name_declared_in_class (tree name, tree decl)
6249 {
6250   splay_tree names_used;
6251   splay_tree_node n;
6252
6253   /* Look to see if we ever used this name.  */
6254   names_used
6255     = current_class_stack[current_class_depth - 1].names_used;
6256   if (!names_used)
6257     return;
6258
6259   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6260   if (n)
6261     {
6262       /* [basic.scope.class]
6263
6264          A name N used in a class S shall refer to the same declaration
6265          in its context and when re-evaluated in the completed scope of
6266          S.  */
6267       error ("declaration of %q#D", decl);
6268       cp_error_at ("changes meaning of %qD from %q+#D",
6269                    DECL_NAME (OVL_CURRENT (decl)),
6270                    (tree) n->value);
6271     }
6272 }
6273
6274 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6275    Secondary vtables are merged with primary vtables; this function
6276    will return the VAR_DECL for the primary vtable.  */
6277
6278 tree
6279 get_vtbl_decl_for_binfo (tree binfo)
6280 {
6281   tree decl;
6282
6283   decl = BINFO_VTABLE (binfo);
6284   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6285     {
6286       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6287       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6288     }
6289   if (decl)
6290     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6291   return decl;
6292 }
6293
6294
6295 /* Returns the binfo for the primary base of BINFO.  If the resulting
6296    BINFO is a virtual base, and it is inherited elsewhere in the
6297    hierarchy, then the returned binfo might not be the primary base of
6298    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6299    BINFO_LOST_PRIMARY_P to be sure.  */
6300
6301 tree
6302 get_primary_binfo (tree binfo)
6303 {
6304   tree primary_base;
6305   tree result;
6306
6307   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6308   if (!primary_base)
6309     return NULL_TREE;
6310
6311   result = copied_binfo (primary_base, binfo);
6312   return result;
6313 }
6314
6315 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6316
6317 static int
6318 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6319 {
6320   if (!indented_p)
6321     fprintf (stream, "%*s", indent, "");
6322   return 1;
6323 }
6324
6325 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6326    INDENT should be zero when called from the top level; it is
6327    incremented recursively.  IGO indicates the next expected BINFO in
6328    inheritance graph ordering.  */
6329
6330 static tree
6331 dump_class_hierarchy_r (FILE *stream,
6332                         int flags,
6333                         tree binfo,
6334                         tree igo,
6335                         int indent)
6336 {
6337   int indented = 0;
6338   tree base_binfo;
6339   int i;
6340
6341   indented = maybe_indent_hierarchy (stream, indent, 0);
6342   fprintf (stream, "%s (0x%lx) ",
6343            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6344            (unsigned long) binfo);
6345   if (binfo != igo)
6346     {
6347       fprintf (stream, "alternative-path\n");
6348       return igo;
6349     }
6350   igo = TREE_CHAIN (binfo);
6351
6352   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6353            tree_low_cst (BINFO_OFFSET (binfo), 0));
6354   if (is_empty_class (BINFO_TYPE (binfo)))
6355     fprintf (stream, " empty");
6356   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6357     fprintf (stream, " nearly-empty");
6358   if (BINFO_VIRTUAL_P (binfo))
6359     fprintf (stream, " virtual");
6360   fprintf (stream, "\n");
6361
6362   indented = 0;
6363   if (BINFO_PRIMARY_P (binfo))
6364     {
6365       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6366       fprintf (stream, " primary-for %s (0x%lx)",
6367                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6368                                TFF_PLAIN_IDENTIFIER),
6369                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6370     }
6371   if (BINFO_LOST_PRIMARY_P (binfo))
6372     {
6373       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6374       fprintf (stream, " lost-primary");
6375     }
6376   if (indented)
6377     fprintf (stream, "\n");
6378
6379   if (!(flags & TDF_SLIM))
6380     {
6381       int indented = 0;
6382
6383       if (BINFO_SUBVTT_INDEX (binfo))
6384         {
6385           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6386           fprintf (stream, " subvttidx=%s",
6387                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6388                                    TFF_PLAIN_IDENTIFIER));
6389         }
6390       if (BINFO_VPTR_INDEX (binfo))
6391         {
6392           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6393           fprintf (stream, " vptridx=%s",
6394                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6395                                    TFF_PLAIN_IDENTIFIER));
6396         }
6397       if (BINFO_VPTR_FIELD (binfo))
6398         {
6399           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6400           fprintf (stream, " vbaseoffset=%s",
6401                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6402                                    TFF_PLAIN_IDENTIFIER));
6403         }
6404       if (BINFO_VTABLE (binfo))
6405         {
6406           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6407           fprintf (stream, " vptr=%s",
6408                    expr_as_string (BINFO_VTABLE (binfo),
6409                                    TFF_PLAIN_IDENTIFIER));
6410         }
6411
6412       if (indented)
6413         fprintf (stream, "\n");
6414     }
6415
6416   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6417     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6418
6419   return igo;
6420 }
6421
6422 /* Dump the BINFO hierarchy for T.  */
6423
6424 static void
6425 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6426 {
6427   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6428   fprintf (stream, "   size=%lu align=%lu\n",
6429            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6430            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6431   fprintf (stream, "   base size=%lu base align=%lu\n",
6432            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6433                            / BITS_PER_UNIT),
6434            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6435                            / BITS_PER_UNIT));
6436   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6437   fprintf (stream, "\n");
6438 }
6439
6440 /* Debug interface to hierarchy dumping.  */
6441
6442 extern void
6443 debug_class (tree t)
6444 {
6445   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6446 }
6447
6448 static void
6449 dump_class_hierarchy (tree t)
6450 {
6451   int flags;
6452   FILE *stream = dump_begin (TDI_class, &flags);
6453
6454   if (stream)
6455     {
6456       dump_class_hierarchy_1 (stream, flags, t);
6457       dump_end (TDI_class, stream);
6458     }
6459 }
6460
6461 static void
6462 dump_array (FILE * stream, tree decl)
6463 {
6464   tree inits;
6465   int ix;
6466   HOST_WIDE_INT elt;
6467   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6468
6469   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6470          / BITS_PER_UNIT);
6471   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6472   fprintf (stream, " %s entries",
6473            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6474                            TFF_PLAIN_IDENTIFIER));
6475   fprintf (stream, "\n");
6476
6477   for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6478        inits; ix++, inits = TREE_CHAIN (inits))
6479     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6480              expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6481 }
6482
6483 static void
6484 dump_vtable (tree t, tree binfo, tree vtable)
6485 {
6486   int flags;
6487   FILE *stream = dump_begin (TDI_class, &flags);
6488
6489   if (!stream)
6490     return;
6491
6492   if (!(flags & TDF_SLIM))
6493     {
6494       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6495
6496       fprintf (stream, "%s for %s",
6497                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6498                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6499       if (ctor_vtbl_p)
6500         {
6501           if (!BINFO_VIRTUAL_P (binfo))
6502             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6503           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6504         }
6505       fprintf (stream, "\n");
6506       dump_array (stream, vtable);
6507       fprintf (stream, "\n");
6508     }
6509
6510   dump_end (TDI_class, stream);
6511 }
6512
6513 static void
6514 dump_vtt (tree t, tree vtt)
6515 {
6516   int flags;
6517   FILE *stream = dump_begin (TDI_class, &flags);
6518
6519   if (!stream)
6520     return;
6521
6522   if (!(flags & TDF_SLIM))
6523     {
6524       fprintf (stream, "VTT for %s\n",
6525                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6526       dump_array (stream, vtt);
6527       fprintf (stream, "\n");
6528     }
6529
6530   dump_end (TDI_class, stream);
6531 }
6532
6533 /* Dump a function or thunk and its thunkees.  */
6534
6535 static void
6536 dump_thunk (FILE *stream, int indent, tree thunk)
6537 {
6538   static const char spaces[] = "        ";
6539   tree name = DECL_NAME (thunk);
6540   tree thunks;
6541
6542   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6543            (void *)thunk,
6544            !DECL_THUNK_P (thunk) ? "function"
6545            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6546            name ? IDENTIFIER_POINTER (name) : "<unset>");
6547   if (DECL_THUNK_P (thunk))
6548     {
6549       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6550       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6551
6552       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6553       if (!virtual_adjust)
6554         /*NOP*/;
6555       else if (DECL_THIS_THUNK_P (thunk))
6556         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6557                  tree_low_cst (virtual_adjust, 0));
6558       else
6559         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6560                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6561                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6562       if (THUNK_ALIAS (thunk))
6563         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6564     }
6565   fprintf (stream, "\n");
6566   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6567     dump_thunk (stream, indent + 2, thunks);
6568 }
6569
6570 /* Dump the thunks for FN.  */
6571
6572 extern void
6573 debug_thunks (tree fn)
6574 {
6575   dump_thunk (stderr, 0, fn);
6576 }
6577
6578 /* Virtual function table initialization.  */
6579
6580 /* Create all the necessary vtables for T and its base classes.  */
6581
6582 static void
6583 finish_vtbls (tree t)
6584 {
6585   tree list;
6586   tree vbase;
6587
6588   /* We lay out the primary and secondary vtables in one contiguous
6589      vtable.  The primary vtable is first, followed by the non-virtual
6590      secondary vtables in inheritance graph order.  */
6591   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6592   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6593                          TYPE_BINFO (t), t, list);
6594
6595   /* Then come the virtual bases, also in inheritance graph order.  */
6596   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6597     {
6598       if (!BINFO_VIRTUAL_P (vbase))
6599         continue;
6600       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6601     }
6602
6603   if (BINFO_VTABLE (TYPE_BINFO (t)))
6604     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6605 }
6606
6607 /* Initialize the vtable for BINFO with the INITS.  */
6608
6609 static void
6610 initialize_vtable (tree binfo, tree inits)
6611 {
6612   tree decl;
6613
6614   layout_vtable_decl (binfo, list_length (inits));
6615   decl = get_vtbl_decl_for_binfo (binfo);
6616   initialize_artificial_var (decl, inits);
6617   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6618 }
6619
6620 /* Build the VTT (virtual table table) for T.
6621    A class requires a VTT if it has virtual bases.
6622
6623    This holds
6624    1 - primary virtual pointer for complete object T
6625    2 - secondary VTTs for each direct non-virtual base of T which requires a
6626        VTT
6627    3 - secondary virtual pointers for each direct or indirect base of T which
6628        has virtual bases or is reachable via a virtual path from T.
6629    4 - secondary VTTs for each direct or indirect virtual base of T.
6630
6631    Secondary VTTs look like complete object VTTs without part 4.  */
6632
6633 static void
6634 build_vtt (tree t)
6635 {
6636   tree inits;
6637   tree type;
6638   tree vtt;
6639   tree index;
6640
6641   /* Build up the initializers for the VTT.  */
6642   inits = NULL_TREE;
6643   index = size_zero_node;
6644   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6645
6646   /* If we didn't need a VTT, we're done.  */
6647   if (!inits)
6648     return;
6649
6650   /* Figure out the type of the VTT.  */
6651   type = build_index_type (size_int (list_length (inits) - 1));
6652   type = build_cplus_array_type (const_ptr_type_node, type);
6653
6654   /* Now, build the VTT object itself.  */
6655   vtt = build_vtable (t, get_vtt_name (t), type);
6656   initialize_artificial_var (vtt, inits);
6657   /* Add the VTT to the vtables list.  */
6658   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6659   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6660
6661   dump_vtt (t, vtt);
6662 }
6663
6664 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6665    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6666    and CHAIN the vtable pointer for this binfo after construction is
6667    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6668
6669 static tree
6670 binfo_ctor_vtable (tree binfo)
6671 {
6672   tree vt;
6673
6674   while (1)
6675     {
6676       vt = BINFO_VTABLE (binfo);
6677       if (TREE_CODE (vt) == TREE_LIST)
6678         vt = TREE_VALUE (vt);
6679       if (TREE_CODE (vt) == TREE_BINFO)
6680         binfo = vt;
6681       else
6682         break;
6683     }
6684
6685   return vt;
6686 }
6687
6688 /* Data for secondary VTT initialization.  */
6689 typedef struct secondary_vptr_vtt_init_data_s
6690 {
6691   /* Is this the primary VTT? */
6692   bool top_level_p;
6693
6694   /* Current index into the VTT.  */
6695   tree index;
6696
6697   /* TREE_LIST of initializers built up.  */
6698   tree inits;
6699
6700   /* The type being constructed by this secondary VTT.  */
6701   tree type_being_constructed;
6702 } secondary_vptr_vtt_init_data;
6703
6704 /* Recursively build the VTT-initializer for BINFO (which is in the
6705    hierarchy dominated by T).  INITS points to the end of the initializer
6706    list to date.  INDEX is the VTT index where the next element will be
6707    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6708    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6709    for virtual bases of T. When it is not so, we build the constructor
6710    vtables for the BINFO-in-T variant.  */
6711
6712 static tree *
6713 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
6714 {
6715   int i;
6716   tree b;
6717   tree init;
6718   tree secondary_vptrs;
6719   secondary_vptr_vtt_init_data data;
6720   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
6721
6722   /* We only need VTTs for subobjects with virtual bases.  */
6723   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
6724     return inits;
6725
6726   /* We need to use a construction vtable if this is not the primary
6727      VTT.  */
6728   if (!top_level_p)
6729     {
6730       build_ctor_vtbl_group (binfo, t);
6731
6732       /* Record the offset in the VTT where this sub-VTT can be found.  */
6733       BINFO_SUBVTT_INDEX (binfo) = *index;
6734     }
6735
6736   /* Add the address of the primary vtable for the complete object.  */
6737   init = binfo_ctor_vtable (binfo);
6738   *inits = build_tree_list (NULL_TREE, init);
6739   inits = &TREE_CHAIN (*inits);
6740   if (top_level_p)
6741     {
6742       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6743       BINFO_VPTR_INDEX (binfo) = *index;
6744     }
6745   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6746
6747   /* Recursively add the secondary VTTs for non-virtual bases.  */
6748   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
6749     if (!BINFO_VIRTUAL_P (b))
6750       inits = build_vtt_inits (b, t, inits, index);
6751
6752   /* Add secondary virtual pointers for all subobjects of BINFO with
6753      either virtual bases or reachable along a virtual path, except
6754      subobjects that are non-virtual primary bases.  */
6755   data.top_level_p = top_level_p;
6756   data.index = *index;
6757   data.inits = NULL;
6758   data.type_being_constructed = BINFO_TYPE (binfo);
6759
6760   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
6761
6762   *index = data.index;
6763
6764   /* The secondary vptrs come back in reverse order.  After we reverse
6765      them, and add the INITS, the last init will be the first element
6766      of the chain.  */
6767   secondary_vptrs = data.inits;
6768   if (secondary_vptrs)
6769     {
6770       *inits = nreverse (secondary_vptrs);
6771       inits = &TREE_CHAIN (secondary_vptrs);
6772       gcc_assert (*inits == NULL_TREE);
6773     }
6774
6775   if (top_level_p)
6776     /* Add the secondary VTTs for virtual bases in inheritance graph
6777        order.  */
6778     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6779       {
6780         if (!BINFO_VIRTUAL_P (b))
6781           continue;
6782
6783         inits = build_vtt_inits (b, t, inits, index);
6784       }
6785   else
6786     /* Remove the ctor vtables we created.  */
6787     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
6788
6789   return inits;
6790 }
6791
6792 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
6793    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
6794
6795 static tree
6796 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
6797 {
6798   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
6799
6800   /* We don't care about bases that don't have vtables.  */
6801   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6802     return dfs_skip_bases;
6803
6804   /* We're only interested in proper subobjects of the type being
6805      constructed.  */
6806   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
6807     return NULL_TREE;
6808
6809   /* We're only interested in bases with virtual bases or reachable
6810      via a virtual path from the type being constructed.  */
6811   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6812         || binfo_via_virtual (binfo, data->type_being_constructed)))
6813     return dfs_skip_bases;
6814
6815   /* We're not interested in non-virtual primary bases.  */
6816   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
6817     return NULL_TREE;
6818
6819   /* Record the index where this secondary vptr can be found.  */
6820   if (data->top_level_p)
6821     {
6822       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6823       BINFO_VPTR_INDEX (binfo) = data->index;
6824
6825       if (BINFO_VIRTUAL_P (binfo))
6826         {
6827           /* It's a primary virtual base, and this is not a
6828              construction vtable.  Find the base this is primary of in
6829              the inheritance graph, and use that base's vtable
6830              now.  */
6831           while (BINFO_PRIMARY_P (binfo))
6832             binfo = BINFO_INHERITANCE_CHAIN (binfo);
6833         }
6834     }
6835
6836   /* Add the initializer for the secondary vptr itself.  */
6837   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
6838
6839   /* Advance the vtt index.  */
6840   data->index = size_binop (PLUS_EXPR, data->index,
6841                             TYPE_SIZE_UNIT (ptr_type_node));
6842
6843   return NULL_TREE;
6844 }
6845
6846 /* Called from build_vtt_inits via dfs_walk. After building
6847    constructor vtables and generating the sub-vtt from them, we need
6848    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
6849    binfo of the base whose sub vtt was generated.  */
6850
6851 static tree
6852 dfs_fixup_binfo_vtbls (tree binfo, void* data)
6853 {
6854   tree vtable = BINFO_VTABLE (binfo);
6855
6856   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6857     /* If this class has no vtable, none of its bases do.  */
6858     return dfs_skip_bases;
6859
6860   if (!vtable)
6861     /* This might be a primary base, so have no vtable in this
6862        hierarchy.  */
6863     return NULL_TREE;
6864
6865   /* If we scribbled the construction vtable vptr into BINFO, clear it
6866      out now.  */
6867   if (TREE_CODE (vtable) == TREE_LIST
6868       && (TREE_PURPOSE (vtable) == (tree) data))
6869     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
6870
6871   return NULL_TREE;
6872 }
6873
6874 /* Build the construction vtable group for BINFO which is in the
6875    hierarchy dominated by T.  */
6876
6877 static void
6878 build_ctor_vtbl_group (tree binfo, tree t)
6879 {
6880   tree list;
6881   tree type;
6882   tree vtbl;
6883   tree inits;
6884   tree id;
6885   tree vbase;
6886
6887   /* See if we've already created this construction vtable group.  */
6888   id = mangle_ctor_vtbl_for_type (t, binfo);
6889   if (IDENTIFIER_GLOBAL_VALUE (id))
6890     return;
6891
6892   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
6893   /* Build a version of VTBL (with the wrong type) for use in
6894      constructing the addresses of secondary vtables in the
6895      construction vtable group.  */
6896   vtbl = build_vtable (t, id, ptr_type_node);
6897   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
6898   list = build_tree_list (vtbl, NULL_TREE);
6899   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
6900                          binfo, t, list);
6901
6902   /* Add the vtables for each of our virtual bases using the vbase in T
6903      binfo.  */
6904   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
6905        vbase;
6906        vbase = TREE_CHAIN (vbase))
6907     {
6908       tree b;
6909
6910       if (!BINFO_VIRTUAL_P (vbase))
6911         continue;
6912       b = copied_binfo (vbase, binfo);
6913
6914       accumulate_vtbl_inits (b, vbase, binfo, t, list);
6915     }
6916   inits = TREE_VALUE (list);
6917
6918   /* Figure out the type of the construction vtable.  */
6919   type = build_index_type (size_int (list_length (inits) - 1));
6920   type = build_cplus_array_type (vtable_entry_type, type);
6921   TREE_TYPE (vtbl) = type;
6922
6923   /* Initialize the construction vtable.  */
6924   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
6925   initialize_artificial_var (vtbl, inits);
6926   dump_vtable (t, binfo, vtbl);
6927 }
6928
6929 /* Add the vtbl initializers for BINFO (and its bases other than
6930    non-virtual primaries) to the list of INITS.  BINFO is in the
6931    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
6932    the constructor the vtbl inits should be accumulated for. (If this
6933    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
6934    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
6935    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
6936    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
6937    but are not necessarily the same in terms of layout.  */
6938
6939 static void
6940 accumulate_vtbl_inits (tree binfo,
6941                        tree orig_binfo,
6942                        tree rtti_binfo,
6943                        tree t,
6944                        tree inits)
6945 {
6946   int i;
6947   tree base_binfo;
6948   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
6949
6950   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
6951
6952   /* If it doesn't have a vptr, we don't do anything.  */
6953   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6954     return;
6955
6956   /* If we're building a construction vtable, we're not interested in
6957      subobjects that don't require construction vtables.  */
6958   if (ctor_vtbl_p
6959       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6960       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
6961     return;
6962
6963   /* Build the initializers for the BINFO-in-T vtable.  */
6964   TREE_VALUE (inits)
6965     = chainon (TREE_VALUE (inits),
6966                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
6967                                           rtti_binfo, t, inits));
6968
6969   /* Walk the BINFO and its bases.  We walk in preorder so that as we
6970      initialize each vtable we can figure out at what offset the
6971      secondary vtable lies from the primary vtable.  We can't use
6972      dfs_walk here because we need to iterate through bases of BINFO
6973      and RTTI_BINFO simultaneously.  */
6974   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6975     {
6976       /* Skip virtual bases.  */
6977       if (BINFO_VIRTUAL_P (base_binfo))
6978         continue;
6979       accumulate_vtbl_inits (base_binfo,
6980                              BINFO_BASE_BINFO (orig_binfo, i),
6981                              rtti_binfo, t,
6982                              inits);
6983     }
6984 }
6985
6986 /* Called from accumulate_vtbl_inits.  Returns the initializers for
6987    the BINFO vtable.  */
6988
6989 static tree
6990 dfs_accumulate_vtbl_inits (tree binfo,
6991                            tree orig_binfo,
6992                            tree rtti_binfo,
6993                            tree t,
6994                            tree l)
6995 {
6996   tree inits = NULL_TREE;
6997   tree vtbl = NULL_TREE;
6998   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
6999
7000   if (ctor_vtbl_p
7001       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7002     {
7003       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7004          primary virtual base.  If it is not the same primary in
7005          the hierarchy of T, we'll need to generate a ctor vtable
7006          for it, to place at its location in T.  If it is the same
7007          primary, we still need a VTT entry for the vtable, but it
7008          should point to the ctor vtable for the base it is a
7009          primary for within the sub-hierarchy of RTTI_BINFO.
7010
7011          There are three possible cases:
7012
7013          1) We are in the same place.
7014          2) We are a primary base within a lost primary virtual base of
7015          RTTI_BINFO.
7016          3) We are primary to something not a base of RTTI_BINFO.  */
7017
7018       tree b;
7019       tree last = NULL_TREE;
7020
7021       /* First, look through the bases we are primary to for RTTI_BINFO
7022          or a virtual base.  */
7023       b = binfo;
7024       while (BINFO_PRIMARY_P (b))
7025         {
7026           b = BINFO_INHERITANCE_CHAIN (b);
7027           last = b;
7028           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7029             goto found;
7030         }
7031       /* If we run out of primary links, keep looking down our
7032          inheritance chain; we might be an indirect primary.  */
7033       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7034         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7035           break;
7036     found:
7037
7038       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7039          base B and it is a base of RTTI_BINFO, this is case 2.  In
7040          either case, we share our vtable with LAST, i.e. the
7041          derived-most base within B of which we are a primary.  */
7042       if (b == rtti_binfo
7043           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7044         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7045            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7046            binfo_ctor_vtable after everything's been set up.  */
7047         vtbl = last;
7048
7049       /* Otherwise, this is case 3 and we get our own.  */
7050     }
7051   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7052     return inits;
7053
7054   if (!vtbl)
7055     {
7056       tree index;
7057       int non_fn_entries;
7058
7059       /* Compute the initializer for this vtable.  */
7060       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7061                                       &non_fn_entries);
7062
7063       /* Figure out the position to which the VPTR should point.  */
7064       vtbl = TREE_PURPOSE (l);
7065       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7066       index = size_binop (PLUS_EXPR,
7067                           size_int (non_fn_entries),
7068                           size_int (list_length (TREE_VALUE (l))));
7069       index = size_binop (MULT_EXPR,
7070                           TYPE_SIZE_UNIT (vtable_entry_type),
7071                           index);
7072       vtbl = build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7073     }
7074
7075   if (ctor_vtbl_p)
7076     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7077        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7078        straighten this out.  */
7079     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7080   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7081     inits = NULL_TREE;
7082   else
7083      /* For an ordinary vtable, set BINFO_VTABLE.  */
7084     BINFO_VTABLE (binfo) = vtbl;
7085
7086   return inits;
7087 }
7088
7089 static GTY(()) tree abort_fndecl_addr;
7090
7091 /* Construct the initializer for BINFO's virtual function table.  BINFO
7092    is part of the hierarchy dominated by T.  If we're building a
7093    construction vtable, the ORIG_BINFO is the binfo we should use to
7094    find the actual function pointers to put in the vtable - but they
7095    can be overridden on the path to most-derived in the graph that
7096    ORIG_BINFO belongs.  Otherwise,
7097    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7098    BINFO that should be indicated by the RTTI information in the
7099    vtable; it will be a base class of T, rather than T itself, if we
7100    are building a construction vtable.
7101
7102    The value returned is a TREE_LIST suitable for wrapping in a
7103    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7104    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7105    number of non-function entries in the vtable.
7106
7107    It might seem that this function should never be called with a
7108    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7109    base is always subsumed by a derived class vtable.  However, when
7110    we are building construction vtables, we do build vtables for
7111    primary bases; we need these while the primary base is being
7112    constructed.  */
7113
7114 static tree
7115 build_vtbl_initializer (tree binfo,
7116                         tree orig_binfo,
7117                         tree t,
7118                         tree rtti_binfo,
7119                         int* non_fn_entries_p)
7120 {
7121   tree v, b;
7122   tree vfun_inits;
7123   vtbl_init_data vid;
7124   unsigned ix;
7125   tree vbinfo;
7126   VEC (tree) *vbases;
7127
7128   /* Initialize VID.  */
7129   memset (&vid, 0, sizeof (vid));
7130   vid.binfo = binfo;
7131   vid.derived = t;
7132   vid.rtti_binfo = rtti_binfo;
7133   vid.last_init = &vid.inits;
7134   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7135   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7136   vid.generate_vcall_entries = true;
7137   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7138   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7139
7140   /* Add entries to the vtable for RTTI.  */
7141   build_rtti_vtbl_entries (binfo, &vid);
7142
7143   /* Create an array for keeping track of the functions we've
7144      processed.  When we see multiple functions with the same
7145      signature, we share the vcall offsets.  */
7146   VARRAY_TREE_INIT (vid.fns, 32, "fns");
7147   /* Add the vcall and vbase offset entries.  */
7148   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7149
7150   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7151      build_vbase_offset_vtbl_entries.  */
7152   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7153        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7154     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7155
7156   /* If the target requires padding between data entries, add that now.  */
7157   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7158     {
7159       tree cur, *prev;
7160
7161       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7162         {
7163           tree add = cur;
7164           int i;
7165
7166           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7167             add = tree_cons (NULL_TREE,
7168                              build1 (NOP_EXPR, vtable_entry_type,
7169                                      null_pointer_node),
7170                              add);
7171           *prev = add;
7172         }
7173     }
7174
7175   if (non_fn_entries_p)
7176     *non_fn_entries_p = list_length (vid.inits);
7177
7178   /* Go through all the ordinary virtual functions, building up
7179      initializers.  */
7180   vfun_inits = NULL_TREE;
7181   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7182     {
7183       tree delta;
7184       tree vcall_index;
7185       tree fn, fn_original;
7186       tree init = NULL_TREE;
7187
7188       fn = BV_FN (v);
7189       fn_original = fn;
7190       if (DECL_THUNK_P (fn))
7191         {
7192           if (!DECL_NAME (fn))
7193             finish_thunk (fn);
7194           if (THUNK_ALIAS (fn))
7195             {
7196               fn = THUNK_ALIAS (fn);
7197               BV_FN (v) = fn;
7198             }
7199           fn_original = THUNK_TARGET (fn);
7200         }
7201
7202       /* If the only definition of this function signature along our
7203          primary base chain is from a lost primary, this vtable slot will
7204          never be used, so just zero it out.  This is important to avoid
7205          requiring extra thunks which cannot be generated with the function.
7206
7207          We first check this in update_vtable_entry_for_fn, so we handle
7208          restored primary bases properly; we also need to do it here so we
7209          zero out unused slots in ctor vtables, rather than filling themff
7210          with erroneous values (though harmless, apart from relocation
7211          costs).  */
7212       for (b = binfo; ; b = get_primary_binfo (b))
7213         {
7214           /* We found a defn before a lost primary; go ahead as normal.  */
7215           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7216             break;
7217
7218           /* The nearest definition is from a lost primary; clear the
7219              slot.  */
7220           if (BINFO_LOST_PRIMARY_P (b))
7221             {
7222               init = size_zero_node;
7223               break;
7224             }
7225         }
7226
7227       if (! init)
7228         {
7229           /* Pull the offset for `this', and the function to call, out of
7230              the list.  */
7231           delta = BV_DELTA (v);
7232           vcall_index = BV_VCALL_INDEX (v);
7233
7234           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7235           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7236
7237           /* You can't call an abstract virtual function; it's abstract.
7238              So, we replace these functions with __pure_virtual.  */
7239           if (DECL_PURE_VIRTUAL_P (fn_original))
7240             {
7241               fn = abort_fndecl;
7242               if (abort_fndecl_addr == NULL)
7243                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7244               init = abort_fndecl_addr;
7245             }
7246           else
7247             {
7248               if (!integer_zerop (delta) || vcall_index)
7249                 {
7250                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7251                   if (!DECL_NAME (fn))
7252                     finish_thunk (fn);
7253                 }
7254               /* Take the address of the function, considering it to be of an
7255                  appropriate generic type.  */
7256               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7257             }
7258         }
7259
7260       /* And add it to the chain of initializers.  */
7261       if (TARGET_VTABLE_USES_DESCRIPTORS)
7262         {
7263           int i;
7264           if (init == size_zero_node)
7265             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7266               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7267           else
7268             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7269               {
7270                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7271                                      TREE_OPERAND (init, 0),
7272                                      build_int_cst (NULL_TREE, i));
7273                 TREE_CONSTANT (fdesc) = 1;
7274                 TREE_INVARIANT (fdesc) = 1;
7275
7276                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7277               }
7278         }
7279       else
7280         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7281     }
7282
7283   /* The initializers for virtual functions were built up in reverse
7284      order; straighten them out now.  */
7285   vfun_inits = nreverse (vfun_inits);
7286
7287   /* The negative offset initializers are also in reverse order.  */
7288   vid.inits = nreverse (vid.inits);
7289
7290   /* Chain the two together.  */
7291   return chainon (vid.inits, vfun_inits);
7292 }
7293
7294 /* Adds to vid->inits the initializers for the vbase and vcall
7295    offsets in BINFO, which is in the hierarchy dominated by T.  */
7296
7297 static void
7298 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7299 {
7300   tree b;
7301
7302   /* If this is a derived class, we must first create entries
7303      corresponding to the primary base class.  */
7304   b = get_primary_binfo (binfo);
7305   if (b)
7306     build_vcall_and_vbase_vtbl_entries (b, vid);
7307
7308   /* Add the vbase entries for this base.  */
7309   build_vbase_offset_vtbl_entries (binfo, vid);
7310   /* Add the vcall entries for this base.  */
7311   build_vcall_offset_vtbl_entries (binfo, vid);
7312 }
7313
7314 /* Returns the initializers for the vbase offset entries in the vtable
7315    for BINFO (which is part of the class hierarchy dominated by T), in
7316    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7317    where the next vbase offset will go.  */
7318
7319 static void
7320 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7321 {
7322   tree vbase;
7323   tree t;
7324   tree non_primary_binfo;
7325
7326   /* If there are no virtual baseclasses, then there is nothing to
7327      do.  */
7328   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7329     return;
7330
7331   t = vid->derived;
7332
7333   /* We might be a primary base class.  Go up the inheritance hierarchy
7334      until we find the most derived class of which we are a primary base:
7335      it is the offset of that which we need to use.  */
7336   non_primary_binfo = binfo;
7337   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7338     {
7339       tree b;
7340
7341       /* If we have reached a virtual base, then it must be a primary
7342          base (possibly multi-level) of vid->binfo, or we wouldn't
7343          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7344          might be a lost primary, so just skip down to vid->binfo.  */
7345       if (BINFO_VIRTUAL_P (non_primary_binfo))
7346         {
7347           non_primary_binfo = vid->binfo;
7348           break;
7349         }
7350
7351       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7352       if (get_primary_binfo (b) != non_primary_binfo)
7353         break;
7354       non_primary_binfo = b;
7355     }
7356
7357   /* Go through the virtual bases, adding the offsets.  */
7358   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7359        vbase;
7360        vbase = TREE_CHAIN (vbase))
7361     {
7362       tree b;
7363       tree delta;
7364
7365       if (!BINFO_VIRTUAL_P (vbase))
7366         continue;
7367
7368       /* Find the instance of this virtual base in the complete
7369          object.  */
7370       b = copied_binfo (vbase, binfo);
7371
7372       /* If we've already got an offset for this virtual base, we
7373          don't need another one.  */
7374       if (BINFO_VTABLE_PATH_MARKED (b))
7375         continue;
7376       BINFO_VTABLE_PATH_MARKED (b) = 1;
7377
7378       /* Figure out where we can find this vbase offset.  */
7379       delta = size_binop (MULT_EXPR,
7380                           vid->index,
7381                           convert (ssizetype,
7382                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7383       if (vid->primary_vtbl_p)
7384         BINFO_VPTR_FIELD (b) = delta;
7385
7386       if (binfo != TYPE_BINFO (t))
7387         /* The vbase offset had better be the same.  */
7388         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7389
7390       /* The next vbase will come at a more negative offset.  */
7391       vid->index = size_binop (MINUS_EXPR, vid->index,
7392                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7393
7394       /* The initializer is the delta from BINFO to this virtual base.
7395          The vbase offsets go in reverse inheritance-graph order, and
7396          we are walking in inheritance graph order so these end up in
7397          the right order.  */
7398       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7399
7400       *vid->last_init
7401         = build_tree_list (NULL_TREE,
7402                            fold (build1 (NOP_EXPR,
7403                                          vtable_entry_type,
7404                                          delta)));
7405       vid->last_init = &TREE_CHAIN (*vid->last_init);
7406     }
7407 }
7408
7409 /* Adds the initializers for the vcall offset entries in the vtable
7410    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7411    to VID->INITS.  */
7412
7413 static void
7414 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7415 {
7416   /* We only need these entries if this base is a virtual base.  We
7417      compute the indices -- but do not add to the vtable -- when
7418      building the main vtable for a class.  */
7419   if (BINFO_VIRTUAL_P (binfo) || binfo == TYPE_BINFO (vid->derived))
7420     {
7421       /* We need a vcall offset for each of the virtual functions in this
7422          vtable.  For example:
7423
7424            class A { virtual void f (); };
7425            class B1 : virtual public A { virtual void f (); };
7426            class B2 : virtual public A { virtual void f (); };
7427            class C: public B1, public B2 { virtual void f (); };
7428
7429          A C object has a primary base of B1, which has a primary base of A.  A
7430          C also has a secondary base of B2, which no longer has a primary base
7431          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7432          A, which will adjust the A* to a B2* to call f.  We have no way of
7433          knowing what (or even whether) this offset will be when we define B2,
7434          so we store this "vcall offset" in the A sub-vtable and look it up in
7435          a "virtual thunk" for B2::f.
7436
7437          We need entries for all the functions in our primary vtable and
7438          in our non-virtual bases' secondary vtables.  */
7439       vid->vbase = binfo;
7440       /* If we are just computing the vcall indices -- but do not need
7441          the actual entries -- not that.  */
7442       if (!BINFO_VIRTUAL_P (binfo))
7443         vid->generate_vcall_entries = false;
7444       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7445       add_vcall_offset_vtbl_entries_r (binfo, vid);
7446     }
7447 }
7448
7449 /* Build vcall offsets, starting with those for BINFO.  */
7450
7451 static void
7452 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7453 {
7454   int i;
7455   tree primary_binfo;
7456   tree base_binfo;
7457
7458   /* Don't walk into virtual bases -- except, of course, for the
7459      virtual base for which we are building vcall offsets.  Any
7460      primary virtual base will have already had its offsets generated
7461      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7462   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7463     return;
7464
7465   /* If BINFO has a primary base, process it first.  */
7466   primary_binfo = get_primary_binfo (binfo);
7467   if (primary_binfo)
7468     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7469
7470   /* Add BINFO itself to the list.  */
7471   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7472
7473   /* Scan the non-primary bases of BINFO.  */
7474   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7475     if (base_binfo != primary_binfo)
7476       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7477 }
7478
7479 /* Called from build_vcall_offset_vtbl_entries_r.  */
7480
7481 static void
7482 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7483 {
7484   /* Make entries for the rest of the virtuals.  */
7485   if (abi_version_at_least (2))
7486     {
7487       tree orig_fn;
7488
7489       /* The ABI requires that the methods be processed in declaration
7490          order.  G++ 3.2 used the order in the vtable.  */
7491       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7492            orig_fn;
7493            orig_fn = TREE_CHAIN (orig_fn))
7494         if (DECL_VINDEX (orig_fn))
7495           add_vcall_offset (orig_fn, binfo, vid);
7496     }
7497   else
7498     {
7499       tree derived_virtuals;
7500       tree base_virtuals;
7501       tree orig_virtuals;
7502       /* If BINFO is a primary base, the most derived class which has
7503          BINFO as a primary base; otherwise, just BINFO.  */
7504       tree non_primary_binfo;
7505
7506       /* We might be a primary base class.  Go up the inheritance hierarchy
7507          until we find the most derived class of which we are a primary base:
7508          it is the BINFO_VIRTUALS there that we need to consider.  */
7509       non_primary_binfo = binfo;
7510       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7511         {
7512           tree b;
7513
7514           /* If we have reached a virtual base, then it must be vid->vbase,
7515              because we ignore other virtual bases in
7516              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7517              base (possibly multi-level) of vid->binfo, or we wouldn't
7518              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7519              might be a lost primary, so just skip down to vid->binfo.  */
7520           if (BINFO_VIRTUAL_P (non_primary_binfo))
7521             {
7522               gcc_assert (non_primary_binfo == vid->vbase);
7523               non_primary_binfo = vid->binfo;
7524               break;
7525             }
7526
7527           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7528           if (get_primary_binfo (b) != non_primary_binfo)
7529             break;
7530           non_primary_binfo = b;
7531         }
7532
7533       if (vid->ctor_vtbl_p)
7534         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7535            where rtti_binfo is the most derived type.  */
7536         non_primary_binfo
7537           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7538
7539       for (base_virtuals = BINFO_VIRTUALS (binfo),
7540              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7541              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7542            base_virtuals;
7543            base_virtuals = TREE_CHAIN (base_virtuals),
7544              derived_virtuals = TREE_CHAIN (derived_virtuals),
7545              orig_virtuals = TREE_CHAIN (orig_virtuals))
7546         {
7547           tree orig_fn;
7548
7549           /* Find the declaration that originally caused this function to
7550              be present in BINFO_TYPE (binfo).  */
7551           orig_fn = BV_FN (orig_virtuals);
7552
7553           /* When processing BINFO, we only want to generate vcall slots for
7554              function slots introduced in BINFO.  So don't try to generate
7555              one if the function isn't even defined in BINFO.  */
7556           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7557             continue;
7558
7559           add_vcall_offset (orig_fn, binfo, vid);
7560         }
7561     }
7562 }
7563
7564 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7565
7566 static void
7567 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7568 {
7569   size_t i;
7570   tree vcall_offset;
7571
7572   /* If there is already an entry for a function with the same
7573      signature as FN, then we do not need a second vcall offset.
7574      Check the list of functions already present in the derived
7575      class vtable.  */
7576   for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7577     {
7578       tree derived_entry;
7579
7580       derived_entry = VARRAY_TREE (vid->fns, i);
7581       if (same_signature_p (derived_entry, orig_fn)
7582           /* We only use one vcall offset for virtual destructors,
7583              even though there are two virtual table entries.  */
7584           || (DECL_DESTRUCTOR_P (derived_entry)
7585               && DECL_DESTRUCTOR_P (orig_fn)))
7586         return;
7587     }
7588
7589   /* If we are building these vcall offsets as part of building
7590      the vtable for the most derived class, remember the vcall
7591      offset.  */
7592   if (vid->binfo == TYPE_BINFO (vid->derived))
7593     {
7594       tree_pair_p elt = VEC_safe_push (tree_pair_s,
7595                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7596                                        NULL);
7597       elt->purpose = orig_fn;
7598       elt->value = vid->index;
7599     }
7600
7601   /* The next vcall offset will be found at a more negative
7602      offset.  */
7603   vid->index = size_binop (MINUS_EXPR, vid->index,
7604                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7605
7606   /* Keep track of this function.  */
7607   VARRAY_PUSH_TREE (vid->fns, orig_fn);
7608
7609   if (vid->generate_vcall_entries)
7610     {
7611       tree base;
7612       tree fn;
7613
7614       /* Find the overriding function.  */
7615       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7616       if (fn == error_mark_node)
7617         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7618                                integer_zero_node);
7619       else
7620         {
7621           base = TREE_VALUE (fn);
7622
7623           /* The vbase we're working on is a primary base of
7624              vid->binfo.  But it might be a lost primary, so its
7625              BINFO_OFFSET might be wrong, so we just use the
7626              BINFO_OFFSET from vid->binfo.  */
7627           vcall_offset = size_diffop (BINFO_OFFSET (base),
7628                                       BINFO_OFFSET (vid->binfo));
7629           vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7630                                        vcall_offset));
7631         }
7632       /* Add the initializer to the vtable.  */
7633       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7634       vid->last_init = &TREE_CHAIN (*vid->last_init);
7635     }
7636 }
7637
7638 /* Return vtbl initializers for the RTTI entries corresponding to the
7639    BINFO's vtable.  The RTTI entries should indicate the object given
7640    by VID->rtti_binfo.  */
7641
7642 static void
7643 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7644 {
7645   tree b;
7646   tree t;
7647   tree basetype;
7648   tree offset;
7649   tree decl;
7650   tree init;
7651
7652   basetype = BINFO_TYPE (binfo);
7653   t = BINFO_TYPE (vid->rtti_binfo);
7654
7655   /* To find the complete object, we will first convert to our most
7656      primary base, and then add the offset in the vtbl to that value.  */
7657   b = binfo;
7658   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7659          && !BINFO_LOST_PRIMARY_P (b))
7660     {
7661       tree primary_base;
7662
7663       primary_base = get_primary_binfo (b);
7664       gcc_assert (BINFO_PRIMARY_P (primary_base)
7665                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
7666       b = primary_base;
7667     }
7668   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7669
7670   /* The second entry is the address of the typeinfo object.  */
7671   if (flag_rtti)
7672     decl = build_address (get_tinfo_decl (t));
7673   else
7674     decl = integer_zero_node;
7675
7676   /* Convert the declaration to a type that can be stored in the
7677      vtable.  */
7678   init = build_nop (vfunc_ptr_type_node, decl);
7679   *vid->last_init = build_tree_list (NULL_TREE, init);
7680   vid->last_init = &TREE_CHAIN (*vid->last_init);
7681
7682   /* Add the offset-to-top entry.  It comes earlier in the vtable that
7683      the the typeinfo entry.  Convert the offset to look like a
7684      function pointer, so that we can put it in the vtable.  */
7685   init = build_nop (vfunc_ptr_type_node, offset);
7686   *vid->last_init = build_tree_list (NULL_TREE, init);
7687   vid->last_init = &TREE_CHAIN (*vid->last_init);
7688 }
7689
7690 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7691    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
7692
7693 tree
7694 cp_fold_obj_type_ref (tree ref, tree known_type)
7695 {
7696   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
7697   HOST_WIDE_INT i = 0;
7698   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
7699   tree fndecl;
7700
7701   while (i != index)
7702     {
7703       i += (TARGET_VTABLE_USES_DESCRIPTORS
7704             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
7705       v = TREE_CHAIN (v);
7706     }
7707
7708   fndecl = BV_FN (v);
7709
7710 #ifdef ENABLE_CHECKING
7711   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
7712                                   DECL_VINDEX (fndecl)));
7713 #endif
7714
7715   return build_address (fndecl);
7716 }
7717
7718 #include "gt-cp-class.h"