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