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