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