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