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