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