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