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