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