contrib/gcc-4.1/gcc/cp/class.c

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