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   switch (TREE_CODE (instance))
5250     {
5251     case INDIRECT_REF:
5252       if (POINTER_TYPE_P (TREE_TYPE (instance)))
5253         return NULL_TREE;
5254       else
5255         return fixed_type_or_null (TREE_OPERAND (instance, 0),
5256                                    nonnull, cdtorp);
5257
5258     case CALL_EXPR:
5259       /* This is a call to a constructor, hence it's never zero.  */
5260       if (TREE_HAS_CONSTRUCTOR (instance))
5261         {
5262           if (nonnull)
5263             *nonnull = 1;
5264           return TREE_TYPE (instance);
5265         }
5266       return NULL_TREE;
5267
5268     case SAVE_EXPR:
5269       /* This is a call to a constructor, hence it's never zero.  */
5270       if (TREE_HAS_CONSTRUCTOR (instance))
5271         {
5272           if (nonnull)
5273             *nonnull = 1;
5274           return TREE_TYPE (instance);
5275         }
5276       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5277
5278     case PLUS_EXPR:
5279     case MINUS_EXPR:
5280       if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5281         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5282       if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5283         /* Propagate nonnull.  */
5284         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5285       return NULL_TREE;
5286
5287     case NOP_EXPR:
5288     case CONVERT_EXPR:
5289       return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5290
5291     case ADDR_EXPR:
5292       instance = TREE_OPERAND (instance, 0);
5293       if (nonnull)
5294         {
5295           /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5296              with a real object -- given &p->f, p can still be null.  */
5297           tree t = get_base_address (instance);
5298           /* ??? Probably should check DECL_WEAK here.  */
5299           if (t && DECL_P (t))
5300             *nonnull = 1;
5301         }
5302       return fixed_type_or_null (instance, nonnull, cdtorp);
5303
5304     case COMPONENT_REF:
5305       /* If this component is really a base class reference, then the field
5306          itself isn't definitive.  */
5307       if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5308         return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5309       return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5310
5311     case VAR_DECL:
5312     case FIELD_DECL:
5313       if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5314           && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5315         {
5316           if (nonnull)
5317             *nonnull = 1;
5318           return TREE_TYPE (TREE_TYPE (instance));
5319         }
5320       /* fall through...  */
5321     case TARGET_EXPR:
5322     case PARM_DECL:
5323     case RESULT_DECL:
5324       if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5325         {
5326           if (nonnull)
5327             *nonnull = 1;
5328           return TREE_TYPE (instance);
5329         }
5330       else if (instance == current_class_ptr)
5331         {
5332           if (nonnull)
5333             *nonnull = 1;
5334
5335           /* if we're in a ctor or dtor, we know our type.  */
5336           if (DECL_LANG_SPECIFIC (current_function_decl)
5337               && (DECL_CONSTRUCTOR_P (current_function_decl)
5338                   || DECL_DESTRUCTOR_P (current_function_decl)))
5339             {
5340               if (cdtorp)
5341                 *cdtorp = 1;
5342               return TREE_TYPE (TREE_TYPE (instance));
5343             }
5344         }
5345       else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5346         {
5347           /* Reference variables should be references to objects.  */
5348           if (nonnull)
5349             *nonnull = 1;
5350
5351           /* DECL_VAR_MARKED_P is used to prevent recursion; a
5352              variable's initializer may refer to the variable
5353              itself.  */
5354           if (TREE_CODE (instance) == VAR_DECL
5355               && DECL_INITIAL (instance)
5356               && !DECL_VAR_MARKED_P (instance))
5357             {
5358               tree type;
5359               DECL_VAR_MARKED_P (instance) = 1;
5360               type = fixed_type_or_null (DECL_INITIAL (instance),
5361                                          nonnull, cdtorp);
5362               DECL_VAR_MARKED_P (instance) = 0;
5363               return type;
5364             }
5365         }
5366       return NULL_TREE;
5367
5368     default:
5369       return NULL_TREE;
5370     }
5371 }
5372
5373 /* Return nonzero if the dynamic type of INSTANCE is known, and
5374    equivalent to the static type.  We also handle the case where
5375    INSTANCE is really a pointer. Return negative if this is a
5376    ctor/dtor. There the dynamic type is known, but this might not be
5377    the most derived base of the original object, and hence virtual
5378    bases may not be layed out according to this type.
5379
5380    Used to determine whether the virtual function table is needed
5381    or not.
5382
5383    *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5384    of our knowledge of its type.  *NONNULL should be initialized
5385    before this function is called.  */
5386
5387 int
5388 resolves_to_fixed_type_p (tree instance, int* nonnull)
5389 {
5390   tree t = TREE_TYPE (instance);
5391   int cdtorp = 0;
5392
5393   tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5394   if (fixed == NULL_TREE)
5395     return 0;
5396   if (POINTER_TYPE_P (t))
5397     t = TREE_TYPE (t);
5398   if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5399     return 0;
5400   return cdtorp ? -1 : 1;
5401 }
5402
5403 \f
5404 void
5405 init_class_processing (void)
5406 {
5407   current_class_depth = 0;
5408   current_class_stack_size = 10;
5409   current_class_stack
5410     = XNEWVEC (struct class_stack_node, current_class_stack_size);
5411   local_classes = VEC_alloc (tree, gc, 8);
5412   sizeof_biggest_empty_class = size_zero_node;
5413
5414   ridpointers[(int) RID_PUBLIC] = access_public_node;
5415   ridpointers[(int) RID_PRIVATE] = access_private_node;
5416   ridpointers[(int) RID_PROTECTED] = access_protected_node;
5417 }
5418
5419 /* Restore the cached PREVIOUS_CLASS_LEVEL.  */
5420
5421 static void
5422 restore_class_cache (void)
5423 {
5424   tree type;
5425
5426   /* We are re-entering the same class we just left, so we don't
5427      have to search the whole inheritance matrix to find all the
5428      decls to bind again.  Instead, we install the cached
5429      class_shadowed list and walk through it binding names.  */
5430   push_binding_level (previous_class_level);
5431   class_binding_level = previous_class_level;
5432   /* Restore IDENTIFIER_TYPE_VALUE.  */
5433   for (type = class_binding_level->type_shadowed;
5434        type;
5435        type = TREE_CHAIN (type))
5436     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5437 }
5438
5439 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5440    appropriate for TYPE.
5441
5442    So that we may avoid calls to lookup_name, we cache the _TYPE
5443    nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5444
5445    For multiple inheritance, we perform a two-pass depth-first search
5446    of the type lattice.  */
5447
5448 void
5449 pushclass (tree type)
5450 {
5451   class_stack_node_t csn;
5452
5453   type = TYPE_MAIN_VARIANT (type);
5454
5455   /* Make sure there is enough room for the new entry on the stack.  */
5456   if (current_class_depth + 1 >= current_class_stack_size)
5457     {
5458       current_class_stack_size *= 2;
5459       current_class_stack
5460         = XRESIZEVEC (struct class_stack_node, current_class_stack,
5461                       current_class_stack_size);
5462     }
5463
5464   /* Insert a new entry on the class stack.  */
5465   csn = current_class_stack + current_class_depth;
5466   csn->name = current_class_name;
5467   csn->type = current_class_type;
5468   csn->access = current_access_specifier;
5469   csn->names_used = 0;
5470   csn->hidden = 0;
5471   current_class_depth++;
5472
5473   /* Now set up the new type.  */
5474   current_class_name = TYPE_NAME (type);
5475   if (TREE_CODE (current_class_name) == TYPE_DECL)
5476     current_class_name = DECL_NAME (current_class_name);
5477   current_class_type = type;
5478
5479   /* By default, things in classes are private, while things in
5480      structures or unions are public.  */
5481   current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5482                               ? access_private_node
5483                               : access_public_node);
5484
5485   if (previous_class_level
5486       && type != previous_class_level->this_entity
5487       && current_class_depth == 1)
5488     {
5489       /* Forcibly remove any old class remnants.  */
5490       invalidate_class_lookup_cache ();
5491     }
5492
5493   if (!previous_class_level
5494       || type != previous_class_level->this_entity
5495       || current_class_depth > 1)
5496     pushlevel_class ();
5497   else
5498     restore_class_cache ();
5499 }
5500
5501 /* When we exit a toplevel class scope, we save its binding level so
5502    that we can restore it quickly.  Here, we've entered some other
5503    class, so we must invalidate our cache.  */
5504
5505 void
5506 invalidate_class_lookup_cache (void)
5507 {
5508   previous_class_level = NULL;
5509 }
5510
5511 /* Get out of the current class scope. If we were in a class scope
5512    previously, that is the one popped to.  */
5513
5514 void
5515 popclass (void)
5516 {
5517   poplevel_class ();
5518
5519   current_class_depth--;
5520   current_class_name = current_class_stack[current_class_depth].name;
5521   current_class_type = current_class_stack[current_class_depth].type;
5522   current_access_specifier = current_class_stack[current_class_depth].access;
5523   if (current_class_stack[current_class_depth].names_used)
5524     splay_tree_delete (current_class_stack[current_class_depth].names_used);
5525 }
5526
5527 /* Mark the top of the class stack as hidden.  */
5528
5529 void
5530 push_class_stack (void)
5531 {
5532   if (current_class_depth)
5533     ++current_class_stack[current_class_depth - 1].hidden;
5534 }
5535
5536 /* Mark the top of the class stack as un-hidden.  */
5537
5538 void
5539 pop_class_stack (void)
5540 {
5541   if (current_class_depth)
5542     --current_class_stack[current_class_depth - 1].hidden;
5543 }
5544
5545 /* Returns 1 if the class type currently being defined is either T or
5546    a nested type of T.  */
5547
5548 bool
5549 currently_open_class (tree t)
5550 {
5551   int i;
5552
5553   /* We start looking from 1 because entry 0 is from global scope,
5554      and has no type.  */
5555   for (i = current_class_depth; i > 0; --i)
5556     {
5557       tree c;
5558       if (i == current_class_depth)
5559         c = current_class_type;
5560       else
5561         {
5562           if (current_class_stack[i].hidden)
5563             break;
5564           c = current_class_stack[i].type;
5565         }
5566       if (!c)
5567         continue;
5568       if (same_type_p (c, t))
5569         return true;
5570     }
5571   return false;
5572 }
5573
5574 /* If either current_class_type or one of its enclosing classes are derived
5575    from T, return the appropriate type.  Used to determine how we found
5576    something via unqualified lookup.  */
5577
5578 tree
5579 currently_open_derived_class (tree t)
5580 {
5581   int i;
5582
5583   /* The bases of a dependent type are unknown.  */
5584   if (dependent_type_p (t))
5585     return NULL_TREE;
5586
5587   if (!current_class_type)
5588     return NULL_TREE;
5589
5590   if (DERIVED_FROM_P (t, current_class_type))
5591     return current_class_type;
5592
5593   for (i = current_class_depth - 1; i > 0; --i)
5594     {
5595       if (current_class_stack[i].hidden)
5596         break;
5597       if (DERIVED_FROM_P (t, current_class_stack[i].type))
5598         return current_class_stack[i].type;
5599     }
5600
5601   return NULL_TREE;
5602 }
5603
5604 /* When entering a class scope, all enclosing class scopes' names with
5605    static meaning (static variables, static functions, types and
5606    enumerators) have to be visible.  This recursive function calls
5607    pushclass for all enclosing class contexts until global or a local
5608    scope is reached.  TYPE is the enclosed class.  */
5609
5610 void
5611 push_nested_class (tree type)
5612 {
5613   tree context;
5614
5615   /* A namespace might be passed in error cases, like A::B:C.  */
5616   if (type == NULL_TREE
5617       || type == error_mark_node
5618       || TREE_CODE (type) == NAMESPACE_DECL
5619       || ! IS_AGGR_TYPE (type)
5620       || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5621       || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5622     return;
5623
5624   context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5625
5626   if (context && CLASS_TYPE_P (context))
5627     push_nested_class (context);
5628   pushclass (type);
5629 }
5630
5631 /* Undoes a push_nested_class call.  */
5632
5633 void
5634 pop_nested_class (void)
5635 {
5636   tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5637
5638   popclass ();
5639   if (context && CLASS_TYPE_P (context))
5640     pop_nested_class ();
5641 }
5642
5643 /* Returns the number of extern "LANG" blocks we are nested within.  */
5644
5645 int
5646 current_lang_depth (void)
5647 {
5648   return VEC_length (tree, current_lang_base);
5649 }
5650
5651 /* Set global variables CURRENT_LANG_NAME to appropriate value
5652    so that behavior of name-mangling machinery is correct.  */
5653
5654 void
5655 push_lang_context (tree name)
5656 {
5657   VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
5658
5659   if (name == lang_name_cplusplus)
5660     {
5661       current_lang_name = name;
5662     }
5663   else if (name == lang_name_java)
5664     {
5665       current_lang_name = name;
5666       /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5667          (See record_builtin_java_type in decl.c.)  However, that causes
5668          incorrect debug entries if these types are actually used.
5669          So we re-enable debug output after extern "Java".  */
5670       DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5671       DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5672       DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5673       DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5674       DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5675       DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5676       DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5677       DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5678     }
5679   else if (name == lang_name_c)
5680     {
5681       current_lang_name = name;
5682     }
5683   else
5684     error ("language string %<\"%E\"%> not recognized", name);
5685 }
5686
5687 /* Get out of the current language scope.  */
5688
5689 void
5690 pop_lang_context (void)
5691 {
5692   current_lang_name = VEC_pop (tree, current_lang_base);
5693 }
5694 \f
5695 /* Type instantiation routines.  */
5696
5697 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5698    matches the TARGET_TYPE.  If there is no satisfactory match, return
5699    error_mark_node, and issue an error & warning messages under
5700    control of FLAGS.  Permit pointers to member function if FLAGS
5701    permits.  If TEMPLATE_ONLY, the name of the overloaded function was
5702    a template-id, and EXPLICIT_TARGS are the explicitly provided
5703    template arguments.  If OVERLOAD is for one or more member
5704    functions, then ACCESS_PATH is the base path used to reference
5705    those member functions.  */
5706
5707 static tree
5708 resolve_address_of_overloaded_function (tree target_type,
5709                                         tree overload,
5710                                         tsubst_flags_t flags,
5711                                         bool template_only,
5712                                         tree explicit_targs,
5713                                         tree access_path)
5714 {
5715   /* Here's what the standard says:
5716
5717        [over.over]
5718
5719        If the name is a function template, template argument deduction
5720        is done, and if the argument deduction succeeds, the deduced
5721        arguments are used to generate a single template function, which
5722        is added to the set of overloaded functions considered.
5723
5724        Non-member functions and static member functions match targets of
5725        type "pointer-to-function" or "reference-to-function."  Nonstatic
5726        member functions match targets of type "pointer-to-member
5727        function;" the function type of the pointer to member is used to
5728        select the member function from the set of overloaded member
5729        functions.  If a nonstatic member function is selected, the
5730        reference to the overloaded function name is required to have the
5731        form of a pointer to member as described in 5.3.1.
5732
5733        If more than one function is selected, any template functions in
5734        the set are eliminated if the set also contains a non-template
5735        function, and any given template function is eliminated if the
5736        set contains a second template function that is more specialized
5737        than the first according to the partial ordering rules 14.5.5.2.
5738        After such eliminations, if any, there shall remain exactly one
5739        selected function.  */
5740
5741   int is_ptrmem = 0;
5742   int is_reference = 0;
5743   /* We store the matches in a TREE_LIST rooted here.  The functions
5744      are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5745      interoperability with most_specialized_instantiation.  */
5746   tree matches = NULL_TREE;
5747   tree fn;
5748
5749   /* By the time we get here, we should be seeing only real
5750      pointer-to-member types, not the internal POINTER_TYPE to
5751      METHOD_TYPE representation.  */
5752   gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
5753               || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
5754
5755   gcc_assert (is_overloaded_fn (overload));
5756
5757   /* Check that the TARGET_TYPE is reasonable.  */
5758   if (TYPE_PTRFN_P (target_type))
5759     /* This is OK.  */;
5760   else if (TYPE_PTRMEMFUNC_P (target_type))
5761     /* This is OK, too.  */
5762     is_ptrmem = 1;
5763   else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5764     {
5765       /* This is OK, too.  This comes from a conversion to reference
5766          type.  */
5767       target_type = build_reference_type (target_type);
5768       is_reference = 1;
5769     }
5770   else
5771     {
5772       if (flags & tf_error)
5773         error ("cannot resolve overloaded function %qD based on"
5774                " conversion to type %qT",
5775                DECL_NAME (OVL_FUNCTION (overload)), target_type);
5776       return error_mark_node;
5777     }
5778
5779   /* If we can find a non-template function that matches, we can just
5780      use it.  There's no point in generating template instantiations
5781      if we're just going to throw them out anyhow.  But, of course, we
5782      can only do this when we don't *need* a template function.  */
5783   if (!template_only)
5784     {
5785       tree fns;
5786
5787       for (fns = overload; fns; fns = OVL_NEXT (fns))
5788         {
5789           tree fn = OVL_CURRENT (fns);
5790           tree fntype;
5791
5792           if (TREE_CODE (fn) == TEMPLATE_DECL)
5793             /* We're not looking for templates just yet.  */
5794             continue;
5795
5796           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5797               != is_ptrmem)
5798             /* We're looking for a non-static member, and this isn't
5799                one, or vice versa.  */
5800             continue;
5801
5802           /* Ignore functions which haven't been explicitly
5803              declared.  */
5804           if (DECL_ANTICIPATED (fn))
5805             continue;
5806
5807           /* See if there's a match.  */
5808           fntype = TREE_TYPE (fn);
5809           if (is_ptrmem)
5810             fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5811           else if (!is_reference)
5812             fntype = build_pointer_type (fntype);
5813
5814           if (can_convert_arg (target_type, fntype, fn, LOOKUP_NORMAL))
5815             matches = tree_cons (fn, NULL_TREE, matches);
5816         }
5817     }
5818
5819   /* Now, if we've already got a match (or matches), there's no need
5820      to proceed to the template functions.  But, if we don't have a
5821      match we need to look at them, too.  */
5822   if (!matches)
5823     {
5824       tree target_fn_type;
5825       tree target_arg_types;
5826       tree target_ret_type;
5827       tree fns;
5828
5829       if (is_ptrmem)
5830         target_fn_type
5831           = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5832       else
5833         target_fn_type = TREE_TYPE (target_type);
5834       target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5835       target_ret_type = TREE_TYPE (target_fn_type);
5836
5837       /* Never do unification on the 'this' parameter.  */
5838       if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5839         target_arg_types = TREE_CHAIN (target_arg_types);
5840
5841       for (fns = overload; fns; fns = OVL_NEXT (fns))
5842         {
5843           tree fn = OVL_CURRENT (fns);
5844           tree instantiation;
5845           tree instantiation_type;
5846           tree targs;
5847
5848           if (TREE_CODE (fn) != TEMPLATE_DECL)
5849             /* We're only looking for templates.  */
5850             continue;
5851
5852           if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5853               != is_ptrmem)
5854             /* We're not looking for a non-static member, and this is
5855                one, or vice versa.  */
5856             continue;
5857
5858           /* Try to do argument deduction.  */
5859           targs = make_tree_vec (DECL_NTPARMS (fn));
5860           if (fn_type_unification (fn, explicit_targs, targs,
5861                                    target_arg_types, target_ret_type,
5862                                    DEDUCE_EXACT, LOOKUP_NORMAL))
5863             /* Argument deduction failed.  */
5864             continue;
5865
5866           /* Instantiate the template.  */
5867           instantiation = instantiate_template (fn, targs, flags);
5868           if (instantiation == error_mark_node)
5869             /* Instantiation failed.  */
5870             continue;
5871
5872           /* See if there's a match.  */
5873           instantiation_type = TREE_TYPE (instantiation);
5874           if (is_ptrmem)
5875             instantiation_type =
5876               build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5877           else if (!is_reference)
5878             instantiation_type = build_pointer_type (instantiation_type);
5879           if (can_convert_arg (target_type, instantiation_type, instantiation,
5880                                LOOKUP_NORMAL))
5881             matches = tree_cons (instantiation, fn, matches);
5882         }
5883
5884       /* Now, remove all but the most specialized of the matches.  */
5885       if (matches)
5886         {
5887           tree match = most_specialized_instantiation (matches);
5888
5889           if (match != error_mark_node)
5890             matches = tree_cons (TREE_PURPOSE (match),
5891                                  NULL_TREE,
5892                                  NULL_TREE);
5893         }
5894     }
5895
5896   /* Now we should have exactly one function in MATCHES.  */
5897   if (matches == NULL_TREE)
5898     {
5899       /* There were *no* matches.  */
5900       if (flags & tf_error)
5901         {
5902           error ("no matches converting function %qD to type %q#T",
5903                  DECL_NAME (OVL_FUNCTION (overload)),
5904                  target_type);
5905
5906           /* print_candidates expects a chain with the functions in
5907              TREE_VALUE slots, so we cons one up here (we're losing anyway,
5908              so why be clever?).  */
5909           for (; overload; overload = OVL_NEXT (overload))
5910             matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5911                                  matches);
5912
5913           print_candidates (matches);
5914         }
5915       return error_mark_node;
5916     }
5917   else if (TREE_CHAIN (matches))
5918     {
5919       /* There were too many matches.  */
5920
5921       if (flags & tf_error)
5922         {
5923           tree match;
5924
5925           error ("converting overloaded function %qD to type %q#T is ambiguous",
5926                     DECL_NAME (OVL_FUNCTION (overload)),
5927                     target_type);
5928
5929           /* Since print_candidates expects the functions in the
5930              TREE_VALUE slot, we flip them here.  */
5931           for (match = matches; match; match = TREE_CHAIN (match))
5932             TREE_VALUE (match) = TREE_PURPOSE (match);
5933
5934           print_candidates (matches);
5935         }
5936
5937       return error_mark_node;
5938     }
5939
5940   /* Good, exactly one match.  Now, convert it to the correct type.  */
5941   fn = TREE_PURPOSE (matches);
5942
5943   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5944       && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5945     {
5946       static int explained;
5947
5948       if (!(flags & tf_error))
5949         return error_mark_node;
5950
5951       pedwarn ("assuming pointer to member %qD", fn);
5952       if (!explained)
5953         {
5954           pedwarn ("(a pointer to member can only be formed with %<&%E%>)", fn);
5955           explained = 1;
5956         }
5957     }
5958
5959   /* If we're doing overload resolution purely for the purpose of
5960      determining conversion sequences, we should not consider the
5961      function used.  If this conversion sequence is selected, the
5962      function will be marked as used at this point.  */
5963   if (!(flags & tf_conv))
5964     {
5965       mark_used (fn);
5966       /* We could not check access when this expression was originally
5967          created since we did not know at that time to which function
5968          the expression referred.  */
5969       if (DECL_FUNCTION_MEMBER_P (fn))
5970         {
5971           gcc_assert (access_path);
5972           perform_or_defer_access_check (access_path, fn, fn);
5973         }
5974     }
5975
5976   if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5977     return build_unary_op (ADDR_EXPR, fn, 0);
5978   else
5979     {
5980       /* The target must be a REFERENCE_TYPE.  Above, build_unary_op
5981          will mark the function as addressed, but here we must do it
5982          explicitly.  */
5983       cxx_mark_addressable (fn);
5984
5985       return fn;
5986     }
5987 }
5988
5989 /* This function will instantiate the type of the expression given in
5990    RHS to match the type of LHSTYPE.  If errors exist, then return
5991    error_mark_node. FLAGS is a bit mask.  If TF_ERROR is set, then
5992    we complain on errors.  If we are not complaining, never modify rhs,
5993    as overload resolution wants to try many possible instantiations, in
5994    the hope that at least one will work.
5995
5996    For non-recursive calls, LHSTYPE should be a function, pointer to
5997    function, or a pointer to member function.  */
5998
5999 tree
6000 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6001 {
6002   tsubst_flags_t flags_in = flags;
6003   tree access_path = NULL_TREE;
6004
6005   flags &= ~tf_ptrmem_ok;
6006
6007   if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
6008     {
6009       if (flags & tf_error)
6010         error ("not enough type information");
6011       return error_mark_node;
6012     }
6013
6014   if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6015     {
6016       if (same_type_p (lhstype, TREE_TYPE (rhs)))
6017         return rhs;
6018       if (flag_ms_extensions
6019           && TYPE_PTRMEMFUNC_P (lhstype)
6020           && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6021         /* Microsoft allows `A::f' to be resolved to a
6022            pointer-to-member.  */
6023         ;
6024       else
6025         {
6026           if (flags & tf_error)
6027             error ("argument of type %qT does not match %qT",
6028                    TREE_TYPE (rhs), lhstype);
6029           return error_mark_node;
6030         }
6031     }
6032
6033   if (TREE_CODE (rhs) == BASELINK)
6034     {
6035       access_path = BASELINK_ACCESS_BINFO (rhs);
6036       rhs = BASELINK_FUNCTIONS (rhs);
6037     }
6038
6039   /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6040      deduce any type information.  */
6041   if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6042     {
6043       if (flags & tf_error)
6044         error ("not enough type information");
6045       return error_mark_node;
6046     }
6047
6048   /* There only a few kinds of expressions that may have a type
6049      dependent on overload resolution.  */
6050   gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6051               || TREE_CODE (rhs) == COMPONENT_REF
6052               || TREE_CODE (rhs) == COMPOUND_EXPR
6053               || really_overloaded_fn (rhs));
6054
6055   /* We don't overwrite rhs if it is an overloaded function.
6056      Copying it would destroy the tree link.  */
6057   if (TREE_CODE (rhs) != OVERLOAD)
6058     rhs = copy_node (rhs);
6059
6060   /* This should really only be used when attempting to distinguish
6061      what sort of a pointer to function we have.  For now, any
6062      arithmetic operation which is not supported on pointers
6063      is rejected as an error.  */
6064
6065   switch (TREE_CODE (rhs))
6066     {
6067     case COMPONENT_REF:
6068       {
6069         tree member = TREE_OPERAND (rhs, 1);
6070
6071         member = instantiate_type (lhstype, member, flags);
6072         if (member != error_mark_node
6073             && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6074           /* Do not lose object's side effects.  */
6075           return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6076                          TREE_OPERAND (rhs, 0), member);
6077         return member;
6078       }
6079
6080     case OFFSET_REF:
6081       rhs = TREE_OPERAND (rhs, 1);
6082       if (BASELINK_P (rhs))
6083         return instantiate_type (lhstype, rhs, flags_in);
6084
6085       /* This can happen if we are forming a pointer-to-member for a
6086          member template.  */
6087       gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6088
6089       /* Fall through.  */
6090
6091     case TEMPLATE_ID_EXPR:
6092       {
6093         tree fns = TREE_OPERAND (rhs, 0);
6094         tree args = TREE_OPERAND (rhs, 1);
6095
6096         return
6097           resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6098                                                   /*template_only=*/true,
6099                                                   args, access_path);
6100       }
6101
6102     case OVERLOAD:
6103     case FUNCTION_DECL:
6104       return
6105         resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6106                                                 /*template_only=*/false,
6107                                                 /*explicit_targs=*/NULL_TREE,
6108                                                 access_path);
6109
6110     case COMPOUND_EXPR:
6111       TREE_OPERAND (rhs, 0)
6112         = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6113       if (TREE_OPERAND (rhs, 0) == error_mark_node)
6114         return error_mark_node;
6115       TREE_OPERAND (rhs, 1)
6116         = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6117       if (TREE_OPERAND (rhs, 1) == error_mark_node)
6118         return error_mark_node;
6119
6120       TREE_TYPE (rhs) = lhstype;
6121       return rhs;
6122
6123     case ADDR_EXPR:
6124     {
6125       if (PTRMEM_OK_P (rhs))
6126         flags |= tf_ptrmem_ok;
6127
6128       return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6129     }
6130
6131     case ERROR_MARK:
6132       return error_mark_node;
6133
6134     default:
6135       gcc_unreachable ();
6136     }
6137   return error_mark_node;
6138 }
6139 \f
6140 /* Return the name of the virtual function pointer field
6141    (as an IDENTIFIER_NODE) for the given TYPE.  Note that
6142    this may have to look back through base types to find the
6143    ultimate field name.  (For single inheritance, these could
6144    all be the same name.  Who knows for multiple inheritance).  */
6145
6146 static tree
6147 get_vfield_name (tree type)
6148 {
6149   tree binfo, base_binfo;
6150   char *buf;
6151
6152   for (binfo = TYPE_BINFO (type);
6153        BINFO_N_BASE_BINFOS (binfo);
6154        binfo = base_binfo)
6155     {
6156       base_binfo = BINFO_BASE_BINFO (binfo, 0);
6157
6158       if (BINFO_VIRTUAL_P (base_binfo)
6159           || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6160         break;
6161     }
6162
6163   type = BINFO_TYPE (binfo);
6164   buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6165                          + TYPE_NAME_LENGTH (type) + 2);
6166   sprintf (buf, VFIELD_NAME_FORMAT,
6167            IDENTIFIER_POINTER (constructor_name (type)));
6168   return get_identifier (buf);
6169 }
6170
6171 void
6172 print_class_statistics (void)
6173 {
6174 #ifdef GATHER_STATISTICS
6175   fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6176   fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6177   if (n_vtables)
6178     {
6179       fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6180                n_vtables, n_vtable_searches);
6181       fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6182                n_vtable_entries, n_vtable_elems);
6183     }
6184 #endif
6185 }
6186
6187 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6188    according to [class]:
6189                                           The class-name is also inserted
6190    into  the scope of the class itself.  For purposes of access checking,
6191    the inserted class name is treated as if it were a public member name.  */
6192
6193 void
6194 build_self_reference (void)
6195 {
6196   tree name = constructor_name (current_class_type);
6197   tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6198   tree saved_cas;
6199
6200   DECL_NONLOCAL (value) = 1;
6201   DECL_CONTEXT (value) = current_class_type;
6202   DECL_ARTIFICIAL (value) = 1;
6203   SET_DECL_SELF_REFERENCE_P (value);
6204
6205   if (processing_template_decl)
6206     value = push_template_decl (value);
6207
6208   saved_cas = current_access_specifier;
6209   current_access_specifier = access_public_node;
6210   finish_member_declaration (value);
6211   current_access_specifier = saved_cas;
6212 }
6213
6214 /* Returns 1 if TYPE contains only padding bytes.  */
6215
6216 int
6217 is_empty_class (tree type)
6218 {
6219   if (type == error_mark_node)
6220     return 0;
6221
6222   if (! IS_AGGR_TYPE (type))
6223     return 0;
6224
6225   /* In G++ 3.2, whether or not a class was empty was determined by
6226      looking at its size.  */
6227   if (abi_version_at_least (2))
6228     return CLASSTYPE_EMPTY_P (type);
6229   else
6230     return integer_zerop (CLASSTYPE_SIZE (type));
6231 }
6232
6233 /* Returns true if TYPE contains an empty class.  */
6234
6235 static bool
6236 contains_empty_class_p (tree type)
6237 {
6238   if (is_empty_class (type))
6239     return true;
6240   if (CLASS_TYPE_P (type))
6241     {
6242       tree field;
6243       tree binfo;
6244       tree base_binfo;
6245       int i;
6246
6247       for (binfo = TYPE_BINFO (type), i = 0;
6248            BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6249         if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6250           return true;
6251       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6252         if (TREE_CODE (field) == FIELD_DECL
6253             && !DECL_ARTIFICIAL (field)
6254             && is_empty_class (TREE_TYPE (field)))
6255           return true;
6256     }
6257   else if (TREE_CODE (type) == ARRAY_TYPE)
6258     return contains_empty_class_p (TREE_TYPE (type));
6259   return false;
6260 }
6261
6262 /* Note that NAME was looked up while the current class was being
6263    defined and that the result of that lookup was DECL.  */
6264
6265 void
6266 maybe_note_name_used_in_class (tree name, tree decl)
6267 {
6268   splay_tree names_used;
6269
6270   /* If we're not defining a class, there's nothing to do.  */
6271   if (!(innermost_scope_kind() == sk_class
6272         && TYPE_BEING_DEFINED (current_class_type)))
6273     return;
6274
6275   /* If there's already a binding for this NAME, then we don't have
6276      anything to worry about.  */
6277   if (lookup_member (current_class_type, name,
6278                      /*protect=*/0, /*want_type=*/false))
6279     return;
6280
6281   if (!current_class_stack[current_class_depth - 1].names_used)
6282     current_class_stack[current_class_depth - 1].names_used
6283       = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6284   names_used = current_class_stack[current_class_depth - 1].names_used;
6285
6286   splay_tree_insert (names_used,
6287                      (splay_tree_key) name,
6288                      (splay_tree_value) decl);
6289 }
6290
6291 /* Note that NAME was declared (as DECL) in the current class.  Check
6292    to see that the declaration is valid.  */
6293
6294 void
6295 note_name_declared_in_class (tree name, tree decl)
6296 {
6297   splay_tree names_used;
6298   splay_tree_node n;
6299
6300   /* Look to see if we ever used this name.  */
6301   names_used
6302     = current_class_stack[current_class_depth - 1].names_used;
6303   if (!names_used)
6304     return;
6305
6306   n = splay_tree_lookup (names_used, (splay_tree_key) name);
6307   if (n)
6308     {
6309       /* [basic.scope.class]
6310
6311          A name N used in a class S shall refer to the same declaration
6312          in its context and when re-evaluated in the completed scope of
6313          S.  */
6314       pedwarn ("declaration of %q#D", decl);
6315       pedwarn ("changes meaning of %qD from %q+#D",
6316                DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6317     }
6318 }
6319
6320 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6321    Secondary vtables are merged with primary vtables; this function
6322    will return the VAR_DECL for the primary vtable.  */
6323
6324 tree
6325 get_vtbl_decl_for_binfo (tree binfo)
6326 {
6327   tree decl;
6328
6329   decl = BINFO_VTABLE (binfo);
6330   if (decl && TREE_CODE (decl) == PLUS_EXPR)
6331     {
6332       gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6333       decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6334     }
6335   if (decl)
6336     gcc_assert (TREE_CODE (decl) == VAR_DECL);
6337   return decl;
6338 }
6339
6340
6341 /* Returns the binfo for the primary base of BINFO.  If the resulting
6342    BINFO is a virtual base, and it is inherited elsewhere in the
6343    hierarchy, then the returned binfo might not be the primary base of
6344    BINFO in the complete object.  Check BINFO_PRIMARY_P or
6345    BINFO_LOST_PRIMARY_P to be sure.  */
6346
6347 static tree
6348 get_primary_binfo (tree binfo)
6349 {
6350   tree primary_base;
6351
6352   primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6353   if (!primary_base)
6354     return NULL_TREE;
6355
6356   return copied_binfo (primary_base, binfo);
6357 }
6358
6359 /* If INDENTED_P is zero, indent to INDENT. Return nonzero.  */
6360
6361 static int
6362 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6363 {
6364   if (!indented_p)
6365     fprintf (stream, "%*s", indent, "");
6366   return 1;
6367 }
6368
6369 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6370    INDENT should be zero when called from the top level; it is
6371    incremented recursively.  IGO indicates the next expected BINFO in
6372    inheritance graph ordering.  */
6373
6374 static tree
6375 dump_class_hierarchy_r (FILE *stream,
6376                         int flags,
6377                         tree binfo,
6378                         tree igo,
6379                         int indent)
6380 {
6381   int indented = 0;
6382   tree base_binfo;
6383   int i;
6384
6385   indented = maybe_indent_hierarchy (stream, indent, 0);
6386   fprintf (stream, "%s (0x%lx) ",
6387            type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6388            (unsigned long) binfo);
6389   if (binfo != igo)
6390     {
6391       fprintf (stream, "alternative-path\n");
6392       return igo;
6393     }
6394   igo = TREE_CHAIN (binfo);
6395
6396   fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6397            tree_low_cst (BINFO_OFFSET (binfo), 0));
6398   if (is_empty_class (BINFO_TYPE (binfo)))
6399     fprintf (stream, " empty");
6400   else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6401     fprintf (stream, " nearly-empty");
6402   if (BINFO_VIRTUAL_P (binfo))
6403     fprintf (stream, " virtual");
6404   fprintf (stream, "\n");
6405
6406   indented = 0;
6407   if (BINFO_PRIMARY_P (binfo))
6408     {
6409       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6410       fprintf (stream, " primary-for %s (0x%lx)",
6411                type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6412                                TFF_PLAIN_IDENTIFIER),
6413                (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6414     }
6415   if (BINFO_LOST_PRIMARY_P (binfo))
6416     {
6417       indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6418       fprintf (stream, " lost-primary");
6419     }
6420   if (indented)
6421     fprintf (stream, "\n");
6422
6423   if (!(flags & TDF_SLIM))
6424     {
6425       int indented = 0;
6426
6427       if (BINFO_SUBVTT_INDEX (binfo))
6428         {
6429           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6430           fprintf (stream, " subvttidx=%s",
6431                    expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6432                                    TFF_PLAIN_IDENTIFIER));
6433         }
6434       if (BINFO_VPTR_INDEX (binfo))
6435         {
6436           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6437           fprintf (stream, " vptridx=%s",
6438                    expr_as_string (BINFO_VPTR_INDEX (binfo),
6439                                    TFF_PLAIN_IDENTIFIER));
6440         }
6441       if (BINFO_VPTR_FIELD (binfo))
6442         {
6443           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6444           fprintf (stream, " vbaseoffset=%s",
6445                    expr_as_string (BINFO_VPTR_FIELD (binfo),
6446                                    TFF_PLAIN_IDENTIFIER));
6447         }
6448       if (BINFO_VTABLE (binfo))
6449         {
6450           indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6451           fprintf (stream, " vptr=%s",
6452                    expr_as_string (BINFO_VTABLE (binfo),
6453                                    TFF_PLAIN_IDENTIFIER));
6454         }
6455
6456       if (indented)
6457         fprintf (stream, "\n");
6458     }
6459
6460   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6461     igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6462
6463   return igo;
6464 }
6465
6466 /* Dump the BINFO hierarchy for T.  */
6467
6468 static void
6469 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6470 {
6471   fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6472   fprintf (stream, "   size=%lu align=%lu\n",
6473            (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6474            (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6475   fprintf (stream, "   base size=%lu base align=%lu\n",
6476            (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6477                            / BITS_PER_UNIT),
6478            (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6479                            / BITS_PER_UNIT));
6480   dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6481   fprintf (stream, "\n");
6482 }
6483
6484 /* Debug interface to hierarchy dumping.  */
6485
6486 void
6487 debug_class (tree t)
6488 {
6489   dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6490 }
6491
6492 static void
6493 dump_class_hierarchy (tree t)
6494 {
6495   int flags;
6496   FILE *stream = dump_begin (TDI_class, &flags);
6497
6498   if (stream)
6499     {
6500       dump_class_hierarchy_1 (stream, flags, t);
6501       dump_end (TDI_class, stream);
6502     }
6503 }
6504
6505 static void
6506 dump_array (FILE * stream, tree decl)
6507 {
6508   tree value;
6509   unsigned HOST_WIDE_INT ix;
6510   HOST_WIDE_INT elt;
6511   tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6512
6513   elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6514          / BITS_PER_UNIT);
6515   fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6516   fprintf (stream, " %s entries",
6517            expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6518                            TFF_PLAIN_IDENTIFIER));
6519   fprintf (stream, "\n");
6520
6521   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6522                               ix, value)
6523     fprintf (stream, "%-4ld  %s\n", (long)(ix * elt),
6524              expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6525 }
6526
6527 static void
6528 dump_vtable (tree t, tree binfo, tree vtable)
6529 {
6530   int flags;
6531   FILE *stream = dump_begin (TDI_class, &flags);
6532
6533   if (!stream)
6534     return;
6535
6536   if (!(flags & TDF_SLIM))
6537     {
6538       int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6539
6540       fprintf (stream, "%s for %s",
6541                ctor_vtbl_p ? "Construction vtable" : "Vtable",
6542                type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6543       if (ctor_vtbl_p)
6544         {
6545           if (!BINFO_VIRTUAL_P (binfo))
6546             fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6547           fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6548         }
6549       fprintf (stream, "\n");
6550       dump_array (stream, vtable);
6551       fprintf (stream, "\n");
6552     }
6553
6554   dump_end (TDI_class, stream);
6555 }
6556
6557 static void
6558 dump_vtt (tree t, tree vtt)
6559 {
6560   int flags;
6561   FILE *stream = dump_begin (TDI_class, &flags);
6562
6563   if (!stream)
6564     return;
6565
6566   if (!(flags & TDF_SLIM))
6567     {
6568       fprintf (stream, "VTT for %s\n",
6569                type_as_string (t, TFF_PLAIN_IDENTIFIER));
6570       dump_array (stream, vtt);
6571       fprintf (stream, "\n");
6572     }
6573
6574   dump_end (TDI_class, stream);
6575 }
6576
6577 /* Dump a function or thunk and its thunkees.  */
6578
6579 static void
6580 dump_thunk (FILE *stream, int indent, tree thunk)
6581 {
6582   static const char spaces[] = "        ";
6583   tree name = DECL_NAME (thunk);
6584   tree thunks;
6585
6586   fprintf (stream, "%.*s%p %s %s", indent, spaces,
6587            (void *)thunk,
6588            !DECL_THUNK_P (thunk) ? "function"
6589            : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6590            name ? IDENTIFIER_POINTER (name) : "<unset>");
6591   if (DECL_THUNK_P (thunk))
6592     {
6593       HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6594       tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6595
6596       fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6597       if (!virtual_adjust)
6598         /*NOP*/;
6599       else if (DECL_THIS_THUNK_P (thunk))
6600         fprintf (stream, " vcall="  HOST_WIDE_INT_PRINT_DEC,
6601                  tree_low_cst (virtual_adjust, 0));
6602       else
6603         fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6604                  tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6605                  type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6606       if (THUNK_ALIAS (thunk))
6607         fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6608     }
6609   fprintf (stream, "\n");
6610   for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6611     dump_thunk (stream, indent + 2, thunks);
6612 }
6613
6614 /* Dump the thunks for FN.  */
6615
6616 void
6617 debug_thunks (tree fn)
6618 {
6619   dump_thunk (stderr, 0, fn);
6620 }
6621
6622 /* Virtual function table initialization.  */
6623
6624 /* Create all the necessary vtables for T and its base classes.  */
6625
6626 static void
6627 finish_vtbls (tree t)
6628 {
6629   tree list;
6630   tree vbase;
6631
6632   /* We lay out the primary and secondary vtables in one contiguous
6633      vtable.  The primary vtable is first, followed by the non-virtual
6634      secondary vtables in inheritance graph order.  */
6635   list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6636   accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6637                          TYPE_BINFO (t), t, list);
6638
6639   /* Then come the virtual bases, also in inheritance graph order.  */
6640   for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6641     {
6642       if (!BINFO_VIRTUAL_P (vbase))
6643         continue;
6644       accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6645     }
6646
6647   if (BINFO_VTABLE (TYPE_BINFO (t)))
6648     initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6649 }
6650
6651 /* Initialize the vtable for BINFO with the INITS.  */
6652
6653 static void
6654 initialize_vtable (tree binfo, tree inits)
6655 {
6656   tree decl;
6657
6658   layout_vtable_decl (binfo, list_length (inits));
6659   decl = get_vtbl_decl_for_binfo (binfo);
6660   initialize_artificial_var (decl, inits);
6661   dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6662 }
6663
6664 /* Build the VTT (virtual table table) for T.
6665    A class requires a VTT if it has virtual bases.
6666
6667    This holds
6668    1 - primary virtual pointer for complete object T
6669    2 - secondary VTTs for each direct non-virtual base of T which requires a
6670        VTT
6671    3 - secondary virtual pointers for each direct or indirect base of T which
6672        has virtual bases or is reachable via a virtual path from T.
6673    4 - secondary VTTs for each direct or indirect virtual base of T.
6674
6675    Secondary VTTs look like complete object VTTs without part 4.  */
6676
6677 static void
6678 build_vtt (tree t)
6679 {
6680   tree inits;
6681   tree type;
6682   tree vtt;
6683   tree index;
6684
6685   /* Build up the initializers for the VTT.  */
6686   inits = NULL_TREE;
6687   index = size_zero_node;
6688   build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6689
6690   /* If we didn't need a VTT, we're done.  */
6691   if (!inits)
6692     return;
6693
6694   /* Figure out the type of the VTT.  */
6695   type = build_index_type (size_int (list_length (inits) - 1));
6696   type = build_cplus_array_type (const_ptr_type_node, type);
6697
6698   /* Now, build the VTT object itself.  */
6699   vtt = build_vtable (t, mangle_vtt_for_type (t), type);
6700   initialize_artificial_var (vtt, inits);
6701   /* Add the VTT to the vtables list.  */
6702   TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6703   TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6704
6705   dump_vtt (t, vtt);
6706 }
6707
6708 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6709    PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6710    and CHAIN the vtable pointer for this binfo after construction is
6711    complete.  VALUE can also be another BINFO, in which case we recurse.  */
6712
6713 static tree
6714 binfo_ctor_vtable (tree binfo)
6715 {
6716   tree vt;
6717
6718   while (1)
6719     {
6720       vt = BINFO_VTABLE (binfo);
6721       if (TREE_CODE (vt) == TREE_LIST)
6722         vt = TREE_VALUE (vt);
6723       if (TREE_CODE (vt) == TREE_BINFO)
6724         binfo = vt;
6725       else
6726         break;
6727     }
6728
6729   return vt;
6730 }
6731
6732 /* Data for secondary VTT initialization.  */
6733 typedef struct secondary_vptr_vtt_init_data_s
6734 {
6735   /* Is this the primary VTT? */
6736   bool top_level_p;
6737
6738   /* Current index into the VTT.  */
6739   tree index;
6740
6741   /* TREE_LIST of initializers built up.  */
6742   tree inits;
6743
6744   /* The type being constructed by this secondary VTT.  */
6745   tree type_being_constructed;
6746 } secondary_vptr_vtt_init_data;
6747
6748 /* Recursively build the VTT-initializer for BINFO (which is in the
6749    hierarchy dominated by T).  INITS points to the end of the initializer
6750    list to date.  INDEX is the VTT index where the next element will be
6751    replaced.  Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6752    not a subvtt for some base of T).  When that is so, we emit the sub-VTTs
6753    for virtual bases of T. When it is not so, we build the constructor
6754    vtables for the BINFO-in-T variant.  */
6755
6756 static tree *
6757 build_vtt_inits (tree binfo, tree t, tree *inits, tree *index)
6758 {
6759   int i;
6760   tree b;
6761   tree init;
6762   tree secondary_vptrs;
6763   secondary_vptr_vtt_init_data data;
6764   int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
6765
6766   /* We only need VTTs for subobjects with virtual bases.  */
6767   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
6768     return inits;
6769
6770   /* We need to use a construction vtable if this is not the primary
6771      VTT.  */
6772   if (!top_level_p)
6773     {
6774       build_ctor_vtbl_group (binfo, t);
6775
6776       /* Record the offset in the VTT where this sub-VTT can be found.  */
6777       BINFO_SUBVTT_INDEX (binfo) = *index;
6778     }
6779
6780   /* Add the address of the primary vtable for the complete object.  */
6781   init = binfo_ctor_vtable (binfo);
6782   *inits = build_tree_list (NULL_TREE, init);
6783   inits = &TREE_CHAIN (*inits);
6784   if (top_level_p)
6785     {
6786       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6787       BINFO_VPTR_INDEX (binfo) = *index;
6788     }
6789   *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6790
6791   /* Recursively add the secondary VTTs for non-virtual bases.  */
6792   for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
6793     if (!BINFO_VIRTUAL_P (b))
6794       inits = build_vtt_inits (b, t, inits, index);
6795
6796   /* Add secondary virtual pointers for all subobjects of BINFO with
6797      either virtual bases or reachable along a virtual path, except
6798      subobjects that are non-virtual primary bases.  */
6799   data.top_level_p = top_level_p;
6800   data.index = *index;
6801   data.inits = NULL;
6802   data.type_being_constructed = BINFO_TYPE (binfo);
6803
6804   dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
6805
6806   *index = data.index;
6807
6808   /* The secondary vptrs come back in reverse order.  After we reverse
6809      them, and add the INITS, the last init will be the first element
6810      of the chain.  */
6811   secondary_vptrs = data.inits;
6812   if (secondary_vptrs)
6813     {
6814       *inits = nreverse (secondary_vptrs);
6815       inits = &TREE_CHAIN (secondary_vptrs);
6816       gcc_assert (*inits == NULL_TREE);
6817     }
6818
6819   if (top_level_p)
6820     /* Add the secondary VTTs for virtual bases in inheritance graph
6821        order.  */
6822     for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6823       {
6824         if (!BINFO_VIRTUAL_P (b))
6825           continue;
6826
6827         inits = build_vtt_inits (b, t, inits, index);
6828       }
6829   else
6830     /* Remove the ctor vtables we created.  */
6831     dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
6832
6833   return inits;
6834 }
6835
6836 /* Called from build_vtt_inits via dfs_walk.  BINFO is the binfo for the base
6837    in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure.  */
6838
6839 static tree
6840 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
6841 {
6842   secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
6843
6844   /* We don't care about bases that don't have vtables.  */
6845   if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6846     return dfs_skip_bases;
6847
6848   /* We're only interested in proper subobjects of the type being
6849      constructed.  */
6850   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
6851     return NULL_TREE;
6852
6853   /* We're only interested in bases with virtual bases or reachable
6854      via a virtual path from the type being constructed.  */
6855   if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
6856         || binfo_via_virtual (binfo, data->type_being_constructed)))
6857     return dfs_skip_bases;
6858
6859   /* We're not interested in non-virtual primary bases.  */
6860   if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
6861     return NULL_TREE;
6862
6863   /* Record the index where this secondary vptr can be found.  */
6864   if (data->top_level_p)
6865     {
6866       gcc_assert (!BINFO_VPTR_INDEX (binfo));
6867       BINFO_VPTR_INDEX (binfo) = data->index;
6868
6869       if (BINFO_VIRTUAL_P (binfo))
6870         {
6871           /* It's a primary virtual base, and this is not a
6872              construction vtable.  Find the base this is primary of in
6873              the inheritance graph, and use that base's vtable
6874              now.  */
6875           while (BINFO_PRIMARY_P (binfo))
6876             binfo = BINFO_INHERITANCE_CHAIN (binfo);
6877         }
6878     }
6879
6880   /* Add the initializer for the secondary vptr itself.  */
6881   data->inits = tree_cons (NULL_TREE, binfo_ctor_vtable (binfo), data->inits);
6882
6883   /* Advance the vtt index.  */
6884   data->index = size_binop (PLUS_EXPR, data->index,
6885                             TYPE_SIZE_UNIT (ptr_type_node));
6886
6887   return NULL_TREE;
6888 }
6889
6890 /* Called from build_vtt_inits via dfs_walk. After building
6891    constructor vtables and generating the sub-vtt from them, we need
6892    to restore the BINFO_VTABLES that were scribbled on.  DATA is the
6893    binfo of the base whose sub vtt was generated.  */
6894
6895 static tree
6896 dfs_fixup_binfo_vtbls (tree binfo, void* data)
6897 {
6898   tree vtable = BINFO_VTABLE (binfo);
6899
6900   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6901     /* If this class has no vtable, none of its bases do.  */
6902     return dfs_skip_bases;
6903
6904   if (!vtable)
6905     /* This might be a primary base, so have no vtable in this
6906        hierarchy.  */
6907     return NULL_TREE;
6908
6909   /* If we scribbled the construction vtable vptr into BINFO, clear it
6910      out now.  */
6911   if (TREE_CODE (vtable) == TREE_LIST
6912       && (TREE_PURPOSE (vtable) == (tree) data))
6913     BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
6914
6915   return NULL_TREE;
6916 }
6917
6918 /* Build the construction vtable group for BINFO which is in the
6919    hierarchy dominated by T.  */
6920
6921 static void
6922 build_ctor_vtbl_group (tree binfo, tree t)
6923 {
6924   tree list;
6925   tree type;
6926   tree vtbl;
6927   tree inits;
6928   tree id;
6929   tree vbase;
6930
6931   /* See if we've already created this construction vtable group.  */
6932   id = mangle_ctor_vtbl_for_type (t, binfo);
6933   if (IDENTIFIER_GLOBAL_VALUE (id))
6934     return;
6935
6936   gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
6937   /* Build a version of VTBL (with the wrong type) for use in
6938      constructing the addresses of secondary vtables in the
6939      construction vtable group.  */
6940   vtbl = build_vtable (t, id, ptr_type_node);
6941   DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
6942   list = build_tree_list (vtbl, NULL_TREE);
6943   accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
6944                          binfo, t, list);
6945
6946   /* Add the vtables for each of our virtual bases using the vbase in T
6947      binfo.  */
6948   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
6949        vbase;
6950        vbase = TREE_CHAIN (vbase))
6951     {
6952       tree b;
6953
6954       if (!BINFO_VIRTUAL_P (vbase))
6955         continue;
6956       b = copied_binfo (vbase, binfo);
6957
6958       accumulate_vtbl_inits (b, vbase, binfo, t, list);
6959     }
6960   inits = TREE_VALUE (list);
6961
6962   /* Figure out the type of the construction vtable.  */
6963   type = build_index_type (size_int (list_length (inits) - 1));
6964   type = build_cplus_array_type (vtable_entry_type, type);
6965   TREE_TYPE (vtbl) = type;
6966
6967   /* Initialize the construction vtable.  */
6968   CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
6969   initialize_artificial_var (vtbl, inits);
6970   dump_vtable (t, binfo, vtbl);
6971 }
6972
6973 /* Add the vtbl initializers for BINFO (and its bases other than
6974    non-virtual primaries) to the list of INITS.  BINFO is in the
6975    hierarchy dominated by T.  RTTI_BINFO is the binfo within T of
6976    the constructor the vtbl inits should be accumulated for. (If this
6977    is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
6978    ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
6979    BINFO is the active base equivalent of ORIG_BINFO in the inheritance
6980    graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
6981    but are not necessarily the same in terms of layout.  */
6982
6983 static void
6984 accumulate_vtbl_inits (tree binfo,
6985                        tree orig_binfo,
6986                        tree rtti_binfo,
6987                        tree t,
6988                        tree inits)
6989 {
6990   int i;
6991   tree base_binfo;
6992   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
6993
6994   gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
6995
6996   /* If it doesn't have a vptr, we don't do anything.  */
6997   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
6998     return;
6999
7000   /* If we're building a construction vtable, we're not interested in
7001      subobjects that don't require construction vtables.  */
7002   if (ctor_vtbl_p
7003       && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7004       && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7005     return;
7006
7007   /* Build the initializers for the BINFO-in-T vtable.  */
7008   TREE_VALUE (inits)
7009     = chainon (TREE_VALUE (inits),
7010                dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7011                                           rtti_binfo, t, inits));
7012
7013   /* Walk the BINFO and its bases.  We walk in preorder so that as we
7014      initialize each vtable we can figure out at what offset the
7015      secondary vtable lies from the primary vtable.  We can't use
7016      dfs_walk here because we need to iterate through bases of BINFO
7017      and RTTI_BINFO simultaneously.  */
7018   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7019     {
7020       /* Skip virtual bases.  */
7021       if (BINFO_VIRTUAL_P (base_binfo))
7022         continue;
7023       accumulate_vtbl_inits (base_binfo,
7024                              BINFO_BASE_BINFO (orig_binfo, i),
7025                              rtti_binfo, t,
7026                              inits);
7027     }
7028 }
7029
7030 /* Called from accumulate_vtbl_inits.  Returns the initializers for
7031    the BINFO vtable.  */
7032
7033 static tree
7034 dfs_accumulate_vtbl_inits (tree binfo,
7035                            tree orig_binfo,
7036                            tree rtti_binfo,
7037                            tree t,
7038                            tree l)
7039 {
7040   tree inits = NULL_TREE;
7041   tree vtbl = NULL_TREE;
7042   int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7043
7044   if (ctor_vtbl_p
7045       && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7046     {
7047       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7048          primary virtual base.  If it is not the same primary in
7049          the hierarchy of T, we'll need to generate a ctor vtable
7050          for it, to place at its location in T.  If it is the same
7051          primary, we still need a VTT entry for the vtable, but it
7052          should point to the ctor vtable for the base it is a
7053          primary for within the sub-hierarchy of RTTI_BINFO.
7054
7055          There are three possible cases:
7056
7057          1) We are in the same place.
7058          2) We are a primary base within a lost primary virtual base of
7059          RTTI_BINFO.
7060          3) We are primary to something not a base of RTTI_BINFO.  */
7061
7062       tree b;
7063       tree last = NULL_TREE;
7064
7065       /* First, look through the bases we are primary to for RTTI_BINFO
7066          or a virtual base.  */
7067       b = binfo;
7068       while (BINFO_PRIMARY_P (b))
7069         {
7070           b = BINFO_INHERITANCE_CHAIN (b);
7071           last = b;
7072           if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7073             goto found;
7074         }
7075       /* If we run out of primary links, keep looking down our
7076          inheritance chain; we might be an indirect primary.  */
7077       for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7078         if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7079           break;
7080     found:
7081
7082       /* If we found RTTI_BINFO, this is case 1.  If we found a virtual
7083          base B and it is a base of RTTI_BINFO, this is case 2.  In
7084          either case, we share our vtable with LAST, i.e. the
7085          derived-most base within B of which we are a primary.  */
7086       if (b == rtti_binfo
7087           || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7088         /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7089            set LAST's BINFO_VTABLE yet.  We'll extract the actual vptr in
7090            binfo_ctor_vtable after everything's been set up.  */
7091         vtbl = last;
7092
7093       /* Otherwise, this is case 3 and we get our own.  */
7094     }
7095   else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7096     return inits;
7097
7098   if (!vtbl)
7099     {
7100       tree index;
7101       int non_fn_entries;
7102
7103       /* Compute the initializer for this vtable.  */
7104       inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7105                                       &non_fn_entries);
7106
7107       /* Figure out the position to which the VPTR should point.  */
7108       vtbl = TREE_PURPOSE (l);
7109       vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7110       index = size_binop (PLUS_EXPR,
7111                           size_int (non_fn_entries),
7112                           size_int (list_length (TREE_VALUE (l))));
7113       index = size_binop (MULT_EXPR,
7114                           TYPE_SIZE_UNIT (vtable_entry_type),
7115                           index);
7116       vtbl = build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7117     }
7118
7119   if (ctor_vtbl_p)
7120     /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7121        So, we make a TREE_LIST.  Later, dfs_fixup_binfo_vtbls will
7122        straighten this out.  */
7123     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7124   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7125     inits = NULL_TREE;
7126   else
7127      /* For an ordinary vtable, set BINFO_VTABLE.  */
7128     BINFO_VTABLE (binfo) = vtbl;
7129
7130   return inits;
7131 }
7132
7133 static GTY(()) tree abort_fndecl_addr;
7134
7135 /* Construct the initializer for BINFO's virtual function table.  BINFO
7136    is part of the hierarchy dominated by T.  If we're building a
7137    construction vtable, the ORIG_BINFO is the binfo we should use to
7138    find the actual function pointers to put in the vtable - but they
7139    can be overridden on the path to most-derived in the graph that
7140    ORIG_BINFO belongs.  Otherwise,
7141    ORIG_BINFO should be the same as BINFO.  The RTTI_BINFO is the
7142    BINFO that should be indicated by the RTTI information in the
7143    vtable; it will be a base class of T, rather than T itself, if we
7144    are building a construction vtable.
7145
7146    The value returned is a TREE_LIST suitable for wrapping in a
7147    CONSTRUCTOR to use as the DECL_INITIAL for a vtable.  If
7148    NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7149    number of non-function entries in the vtable.
7150
7151    It might seem that this function should never be called with a
7152    BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7153    base is always subsumed by a derived class vtable.  However, when
7154    we are building construction vtables, we do build vtables for
7155    primary bases; we need these while the primary base is being
7156    constructed.  */
7157
7158 static tree
7159 build_vtbl_initializer (tree binfo,
7160                         tree orig_binfo,
7161                         tree t,
7162                         tree rtti_binfo,
7163                         int* non_fn_entries_p)
7164 {
7165   tree v, b;
7166   tree vfun_inits;
7167   vtbl_init_data vid;
7168   unsigned ix;
7169   tree vbinfo;
7170   VEC(tree,gc) *vbases;
7171
7172   /* Initialize VID.  */
7173   memset (&vid, 0, sizeof (vid));
7174   vid.binfo = binfo;
7175   vid.derived = t;
7176   vid.rtti_binfo = rtti_binfo;
7177   vid.last_init = &vid.inits;
7178   vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7179   vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7180   vid.generate_vcall_entries = true;
7181   /* The first vbase or vcall offset is at index -3 in the vtable.  */
7182   vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7183
7184   /* Add entries to the vtable for RTTI.  */
7185   build_rtti_vtbl_entries (binfo, &vid);
7186
7187   /* Create an array for keeping track of the functions we've
7188      processed.  When we see multiple functions with the same
7189      signature, we share the vcall offsets.  */
7190   vid.fns = VEC_alloc (tree, gc, 32);
7191   /* Add the vcall and vbase offset entries.  */
7192   build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7193
7194   /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7195      build_vbase_offset_vtbl_entries.  */
7196   for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7197        VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7198     BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7199
7200   /* If the target requires padding between data entries, add that now.  */
7201   if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7202     {
7203       tree cur, *prev;
7204
7205       for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7206         {
7207           tree add = cur;
7208           int i;
7209
7210           for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7211             add = tree_cons (NULL_TREE,
7212                              build1 (NOP_EXPR, vtable_entry_type,
7213                                      null_pointer_node),
7214                              add);
7215           *prev = add;
7216         }
7217     }
7218
7219   if (non_fn_entries_p)
7220     *non_fn_entries_p = list_length (vid.inits);
7221
7222   /* Go through all the ordinary virtual functions, building up
7223      initializers.  */
7224   vfun_inits = NULL_TREE;
7225   for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7226     {
7227       tree delta;
7228       tree vcall_index;
7229       tree fn, fn_original;
7230       tree init = NULL_TREE;
7231
7232       fn = BV_FN (v);
7233       fn_original = fn;
7234       if (DECL_THUNK_P (fn))
7235         {
7236           if (!DECL_NAME (fn))
7237             finish_thunk (fn);
7238           if (THUNK_ALIAS (fn))
7239             {
7240               fn = THUNK_ALIAS (fn);
7241               BV_FN (v) = fn;
7242             }
7243           fn_original = THUNK_TARGET (fn);
7244         }
7245
7246       /* If the only definition of this function signature along our
7247          primary base chain is from a lost primary, this vtable slot will
7248          never be used, so just zero it out.  This is important to avoid
7249          requiring extra thunks which cannot be generated with the function.
7250
7251          We first check this in update_vtable_entry_for_fn, so we handle
7252          restored primary bases properly; we also need to do it here so we
7253          zero out unused slots in ctor vtables, rather than filling themff
7254          with erroneous values (though harmless, apart from relocation
7255          costs).  */
7256       for (b = binfo; ; b = get_primary_binfo (b))
7257         {
7258           /* We found a defn before a lost primary; go ahead as normal.  */
7259           if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7260             break;
7261
7262           /* The nearest definition is from a lost primary; clear the
7263              slot.  */
7264           if (BINFO_LOST_PRIMARY_P (b))
7265             {
7266               init = size_zero_node;
7267               break;
7268             }
7269         }
7270
7271       if (! init)
7272         {
7273           /* Pull the offset for `this', and the function to call, out of
7274              the list.  */
7275           delta = BV_DELTA (v);
7276           vcall_index = BV_VCALL_INDEX (v);
7277
7278           gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7279           gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7280
7281           /* You can't call an abstract virtual function; it's abstract.
7282              So, we replace these functions with __pure_virtual.  */
7283           if (DECL_PURE_VIRTUAL_P (fn_original))
7284             {
7285               fn = abort_fndecl;
7286               if (abort_fndecl_addr == NULL)
7287                 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7288               init = abort_fndecl_addr;
7289             }
7290           else
7291             {
7292               if (!integer_zerop (delta) || vcall_index)
7293                 {
7294                   fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7295                   if (!DECL_NAME (fn))
7296                     finish_thunk (fn);
7297                 }
7298               /* Take the address of the function, considering it to be of an
7299                  appropriate generic type.  */
7300               init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7301             }
7302         }
7303
7304       /* And add it to the chain of initializers.  */
7305       if (TARGET_VTABLE_USES_DESCRIPTORS)
7306         {
7307           int i;
7308           if (init == size_zero_node)
7309             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7310               vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7311           else
7312             for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7313               {
7314                 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7315                                      TREE_OPERAND (init, 0),
7316                                      build_int_cst (NULL_TREE, i));
7317                 TREE_CONSTANT (fdesc) = 1;
7318                 TREE_INVARIANT (fdesc) = 1;
7319
7320                 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7321               }
7322         }
7323       else
7324         vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7325     }
7326
7327   /* The initializers for virtual functions were built up in reverse
7328      order; straighten them out now.  */
7329   vfun_inits = nreverse (vfun_inits);
7330
7331   /* The negative offset initializers are also in reverse order.  */
7332   vid.inits = nreverse (vid.inits);
7333
7334   /* Chain the two together.  */
7335   return chainon (vid.inits, vfun_inits);
7336 }
7337
7338 /* Adds to vid->inits the initializers for the vbase and vcall
7339    offsets in BINFO, which is in the hierarchy dominated by T.  */
7340
7341 static void
7342 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7343 {
7344   tree b;
7345
7346   /* If this is a derived class, we must first create entries
7347      corresponding to the primary base class.  */
7348   b = get_primary_binfo (binfo);
7349   if (b)
7350     build_vcall_and_vbase_vtbl_entries (b, vid);
7351
7352   /* Add the vbase entries for this base.  */
7353   build_vbase_offset_vtbl_entries (binfo, vid);
7354   /* Add the vcall entries for this base.  */
7355   build_vcall_offset_vtbl_entries (binfo, vid);
7356 }
7357
7358 /* Returns the initializers for the vbase offset entries in the vtable
7359    for BINFO (which is part of the class hierarchy dominated by T), in
7360    reverse order.  VBASE_OFFSET_INDEX gives the vtable index
7361    where the next vbase offset will go.  */
7362
7363 static void
7364 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7365 {
7366   tree vbase;
7367   tree t;
7368   tree non_primary_binfo;
7369
7370   /* If there are no virtual baseclasses, then there is nothing to
7371      do.  */
7372   if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7373     return;
7374
7375   t = vid->derived;
7376
7377   /* We might be a primary base class.  Go up the inheritance hierarchy
7378      until we find the most derived class of which we are a primary base:
7379      it is the offset of that which we need to use.  */
7380   non_primary_binfo = binfo;
7381   while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7382     {
7383       tree b;
7384
7385       /* If we have reached a virtual base, then it must be a primary
7386          base (possibly multi-level) of vid->binfo, or we wouldn't
7387          have called build_vcall_and_vbase_vtbl_entries for it.  But it
7388          might be a lost primary, so just skip down to vid->binfo.  */
7389       if (BINFO_VIRTUAL_P (non_primary_binfo))
7390         {
7391           non_primary_binfo = vid->binfo;
7392           break;
7393         }
7394
7395       b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7396       if (get_primary_binfo (b) != non_primary_binfo)
7397         break;
7398       non_primary_binfo = b;
7399     }
7400
7401   /* Go through the virtual bases, adding the offsets.  */
7402   for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7403        vbase;
7404        vbase = TREE_CHAIN (vbase))
7405     {
7406       tree b;
7407       tree delta;
7408
7409       if (!BINFO_VIRTUAL_P (vbase))
7410         continue;
7411
7412       /* Find the instance of this virtual base in the complete
7413          object.  */
7414       b = copied_binfo (vbase, binfo);
7415
7416       /* If we've already got an offset for this virtual base, we
7417          don't need another one.  */
7418       if (BINFO_VTABLE_PATH_MARKED (b))
7419         continue;
7420       BINFO_VTABLE_PATH_MARKED (b) = 1;
7421
7422       /* Figure out where we can find this vbase offset.  */
7423       delta = size_binop (MULT_EXPR,
7424                           vid->index,
7425                           convert (ssizetype,
7426                                    TYPE_SIZE_UNIT (vtable_entry_type)));
7427       if (vid->primary_vtbl_p)
7428         BINFO_VPTR_FIELD (b) = delta;
7429
7430       if (binfo != TYPE_BINFO (t))
7431         /* The vbase offset had better be the same.  */
7432         gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7433
7434       /* The next vbase will come at a more negative offset.  */
7435       vid->index = size_binop (MINUS_EXPR, vid->index,
7436                                ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7437
7438       /* The initializer is the delta from BINFO to this virtual base.
7439          The vbase offsets go in reverse inheritance-graph order, and
7440          we are walking in inheritance graph order so these end up in
7441          the right order.  */
7442       delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7443
7444       *vid->last_init
7445         = build_tree_list (NULL_TREE,
7446                            fold_build1 (NOP_EXPR,
7447                                         vtable_entry_type,
7448                                         delta));
7449       vid->last_init = &TREE_CHAIN (*vid->last_init);
7450     }
7451 }
7452
7453 /* Adds the initializers for the vcall offset entries in the vtable
7454    for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7455    to VID->INITS.  */
7456
7457 static void
7458 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7459 {
7460   /* We only need these entries if this base is a virtual base.  We
7461      compute the indices -- but do not add to the vtable -- when
7462      building the main vtable for a class.  */
7463   if (binfo == TYPE_BINFO (vid->derived)
7464       || (BINFO_VIRTUAL_P (binfo)
7465           /* If BINFO is RTTI_BINFO, then (since BINFO does not
7466              correspond to VID->DERIVED), we are building a primary
7467              construction virtual table.  Since this is a primary
7468              virtual table, we do not need the vcall offsets for
7469              BINFO.  */
7470           && binfo != vid->rtti_binfo))
7471     {
7472       /* We need a vcall offset for each of the virtual functions in this
7473          vtable.  For example:
7474
7475            class A { virtual void f (); };
7476            class B1 : virtual public A { virtual void f (); };
7477            class B2 : virtual public A { virtual void f (); };
7478            class C: public B1, public B2 { virtual void f (); };
7479
7480          A C object has a primary base of B1, which has a primary base of A.  A
7481          C also has a secondary base of B2, which no longer has a primary base
7482          of A.  So the B2-in-C construction vtable needs a secondary vtable for
7483          A, which will adjust the A* to a B2* to call f.  We have no way of
7484          knowing what (or even whether) this offset will be when we define B2,
7485          so we store this "vcall offset" in the A sub-vtable and look it up in
7486          a "virtual thunk" for B2::f.
7487
7488          We need entries for all the functions in our primary vtable and
7489          in our non-virtual bases' secondary vtables.  */
7490       vid->vbase = binfo;
7491       /* If we are just computing the vcall indices -- but do not need
7492          the actual entries -- not that.  */
7493       if (!BINFO_VIRTUAL_P (binfo))
7494         vid->generate_vcall_entries = false;
7495       /* Now, walk through the non-virtual bases, adding vcall offsets.  */
7496       add_vcall_offset_vtbl_entries_r (binfo, vid);
7497     }
7498 }
7499
7500 /* Build vcall offsets, starting with those for BINFO.  */
7501
7502 static void
7503 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7504 {
7505   int i;
7506   tree primary_binfo;
7507   tree base_binfo;
7508
7509   /* Don't walk into virtual bases -- except, of course, for the
7510      virtual base for which we are building vcall offsets.  Any
7511      primary virtual base will have already had its offsets generated
7512      through the recursion in build_vcall_and_vbase_vtbl_entries.  */
7513   if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7514     return;
7515
7516   /* If BINFO has a primary base, process it first.  */
7517   primary_binfo = get_primary_binfo (binfo);
7518   if (primary_binfo)
7519     add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7520
7521   /* Add BINFO itself to the list.  */
7522   add_vcall_offset_vtbl_entries_1 (binfo, vid);
7523
7524   /* Scan the non-primary bases of BINFO.  */
7525   for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7526     if (base_binfo != primary_binfo)
7527       add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7528 }
7529
7530 /* Called from build_vcall_offset_vtbl_entries_r.  */
7531
7532 static void
7533 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7534 {
7535   /* Make entries for the rest of the virtuals.  */
7536   if (abi_version_at_least (2))
7537     {
7538       tree orig_fn;
7539
7540       /* The ABI requires that the methods be processed in declaration
7541          order.  G++ 3.2 used the order in the vtable.  */
7542       for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7543            orig_fn;
7544            orig_fn = TREE_CHAIN (orig_fn))
7545         if (DECL_VINDEX (orig_fn))
7546           add_vcall_offset (orig_fn, binfo, vid);
7547     }
7548   else
7549     {
7550       tree derived_virtuals;
7551       tree base_virtuals;
7552       tree orig_virtuals;
7553       /* If BINFO is a primary base, the most derived class which has
7554          BINFO as a primary base; otherwise, just BINFO.  */
7555       tree non_primary_binfo;
7556
7557       /* We might be a primary base class.  Go up the inheritance hierarchy
7558          until we find the most derived class of which we are a primary base:
7559          it is the BINFO_VIRTUALS there that we need to consider.  */
7560       non_primary_binfo = binfo;
7561       while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7562         {
7563           tree b;
7564
7565           /* If we have reached a virtual base, then it must be vid->vbase,
7566              because we ignore other virtual bases in
7567              add_vcall_offset_vtbl_entries_r.  In turn, it must be a primary
7568              base (possibly multi-level) of vid->binfo, or we wouldn't
7569              have called build_vcall_and_vbase_vtbl_entries for it.  But it
7570              might be a lost primary, so just skip down to vid->binfo.  */
7571           if (BINFO_VIRTUAL_P (non_primary_binfo))
7572             {
7573               gcc_assert (non_primary_binfo == vid->vbase);
7574               non_primary_binfo = vid->binfo;
7575               break;
7576             }
7577
7578           b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7579           if (get_primary_binfo (b) != non_primary_binfo)
7580             break;
7581           non_primary_binfo = b;
7582         }
7583
7584       if (vid->ctor_vtbl_p)
7585         /* For a ctor vtable we need the equivalent binfo within the hierarchy
7586            where rtti_binfo is the most derived type.  */
7587         non_primary_binfo
7588           = original_binfo (non_primary_binfo, vid->rtti_binfo);
7589
7590       for (base_virtuals = BINFO_VIRTUALS (binfo),
7591              derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7592              orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7593            base_virtuals;
7594            base_virtuals = TREE_CHAIN (base_virtuals),
7595              derived_virtuals = TREE_CHAIN (derived_virtuals),
7596              orig_virtuals = TREE_CHAIN (orig_virtuals))
7597         {
7598           tree orig_fn;
7599
7600           /* Find the declaration that originally caused this function to
7601              be present in BINFO_TYPE (binfo).  */
7602           orig_fn = BV_FN (orig_virtuals);
7603
7604           /* When processing BINFO, we only want to generate vcall slots for
7605              function slots introduced in BINFO.  So don't try to generate
7606              one if the function isn't even defined in BINFO.  */
7607           if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
7608             continue;
7609
7610           add_vcall_offset (orig_fn, binfo, vid);
7611         }
7612     }
7613 }
7614
7615 /* Add a vcall offset entry for ORIG_FN to the vtable.  */
7616
7617 static void
7618 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7619 {
7620   size_t i;
7621   tree vcall_offset;
7622   tree derived_entry;
7623
7624   /* If there is already an entry for a function with the same
7625      signature as FN, then we do not need a second vcall offset.
7626      Check the list of functions already present in the derived
7627      class vtable.  */
7628   for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
7629     {
7630       if (same_signature_p (derived_entry, orig_fn)
7631           /* We only use one vcall offset for virtual destructors,
7632              even though there are two virtual table entries.  */
7633           || (DECL_DESTRUCTOR_P (derived_entry)
7634               && DECL_DESTRUCTOR_P (orig_fn)))
7635         return;
7636     }
7637
7638   /* If we are building these vcall offsets as part of building
7639      the vtable for the most derived class, remember the vcall
7640      offset.  */
7641   if (vid->binfo == TYPE_BINFO (vid->derived))
7642     {
7643       tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
7644                                        CLASSTYPE_VCALL_INDICES (vid->derived),
7645                                        NULL);
7646       elt->purpose = orig_fn;
7647       elt->value = vid->index;
7648     }
7649
7650   /* The next vcall offset will be found at a more negative
7651      offset.  */
7652   vid->index = size_binop (MINUS_EXPR, vid->index,
7653                            ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7654
7655   /* Keep track of this function.  */
7656   VEC_safe_push (tree, gc, vid->fns, orig_fn);
7657
7658   if (vid->generate_vcall_entries)
7659     {
7660       tree base;
7661       tree fn;
7662
7663       /* Find the overriding function.  */
7664       fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7665       if (fn == error_mark_node)
7666         vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7667                                integer_zero_node);
7668       else
7669         {
7670           base = TREE_VALUE (fn);
7671
7672           /* The vbase we're working on is a primary base of
7673              vid->binfo.  But it might be a lost primary, so its
7674              BINFO_OFFSET might be wrong, so we just use the
7675              BINFO_OFFSET from vid->binfo.  */
7676           vcall_offset = size_diffop (BINFO_OFFSET (base),
7677                                       BINFO_OFFSET (vid->binfo));
7678           vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type,
7679                                       vcall_offset);
7680         }
7681       /* Add the initializer to the vtable.  */
7682       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7683       vid->last_init = &TREE_CHAIN (*vid->last_init);
7684     }
7685 }
7686
7687 /* Return vtbl initializers for the RTTI entries corresponding to the
7688    BINFO's vtable.  The RTTI entries should indicate the object given
7689    by VID->rtti_binfo.  */
7690
7691 static void
7692 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7693 {
7694   tree b;
7695   tree t;
7696   tree basetype;
7697   tree offset;
7698   tree decl;
7699   tree init;
7700
7701   basetype = BINFO_TYPE (binfo);
7702   t = BINFO_TYPE (vid->rtti_binfo);
7703
7704   /* To find the complete object, we will first convert to our most
7705      primary base, and then add the offset in the vtbl to that value.  */
7706   b = binfo;
7707   while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7708          && !BINFO_LOST_PRIMARY_P (b))
7709     {
7710       tree primary_base;
7711
7712       primary_base = get_primary_binfo (b);
7713       gcc_assert (BINFO_PRIMARY_P (primary_base)
7714                   && BINFO_INHERITANCE_CHAIN (primary_base) == b);
7715       b = primary_base;
7716     }
7717   offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7718
7719   /* The second entry is the address of the typeinfo object.  */
7720   if (flag_rtti)
7721     decl = build_address (get_tinfo_decl (t));
7722   else
7723     decl = integer_zero_node;
7724
7725   /* Convert the declaration to a type that can be stored in the
7726      vtable.  */
7727   init = build_nop (vfunc_ptr_type_node, decl);
7728   *vid->last_init = build_tree_list (NULL_TREE, init);
7729   vid->last_init = &TREE_CHAIN (*vid->last_init);
7730
7731   /* Add the offset-to-top entry.  It comes earlier in the vtable than
7732      the typeinfo entry.  Convert the offset to look like a
7733      function pointer, so that we can put it in the vtable.  */
7734   init = build_nop (vfunc_ptr_type_node, offset);
7735   *vid->last_init = build_tree_list (NULL_TREE, init);
7736   vid->last_init = &TREE_CHAIN (*vid->last_init);
7737 }
7738
7739 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7740    KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF).  */
7741
7742 tree
7743 cp_fold_obj_type_ref (tree ref, tree known_type)
7744 {
7745   HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
7746   HOST_WIDE_INT i = 0;
7747   tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
7748   tree fndecl;
7749
7750   while (i != index)
7751     {
7752       i += (TARGET_VTABLE_USES_DESCRIPTORS
7753             ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
7754       v = TREE_CHAIN (v);
7755     }
7756
7757   fndecl = BV_FN (v);
7758
7759 #ifdef ENABLE_CHECKING
7760   gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
7761                                   DECL_VINDEX (fndecl)));
7762 #endif
7763
7764   cgraph_node (fndecl)->local.vtable_method = true;
7765
7766   return build_address (fndecl);
7767 }
7768
7769 #include "gt-cp-class.h"