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