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