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