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