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