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