gcc/cp/class.c

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