OSDN Git Service

e22ef079440299249d111c6ae458824dd4092e1d
[pf3gnuchains/gcc-fork.git] / gcc / cp / class.c
1 /* Functions related to building classes and their related objects.
2    Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5    Contributed by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
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 bool 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 propagate_binfo_offsets (tree, tree);
155 static void layout_virtual_bases (record_layout_info, splay_tree);
156 static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *);
157 static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *);
158 static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *);
159 static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *);
160 static void add_vcall_offset (tree, tree, vtbl_init_data *);
161 static void layout_vtable_decl (tree, int);
162 static tree dfs_find_final_overrider_pre (tree, void *);
163 static tree dfs_find_final_overrider_post (tree, void *);
164 static tree find_final_overrider (tree, tree, tree);
165 static int make_new_vtable (tree, tree);
166 static tree get_primary_binfo (tree);
167 static int maybe_indent_hierarchy (FILE *, int, int);
168 static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int);
169 static void dump_class_hierarchy (tree);
170 static void dump_class_hierarchy_1 (FILE *, int, tree);
171 static void dump_array (FILE *, tree);
172 static void dump_vtable (tree, tree, tree);
173 static void dump_vtt (tree, tree);
174 static void dump_thunk (FILE *, int, tree);
175 static tree build_vtable (tree, tree, tree);
176 static void initialize_vtable (tree, tree);
177 static void layout_nonempty_base_or_field (record_layout_info,
178                                            tree, tree, splay_tree);
179 static tree end_of_class (tree, int);
180 static bool layout_empty_base (record_layout_info, tree, tree, splay_tree);
181 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree);
182 static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree,
183                                                tree);
184 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
185 static void build_vcall_and_vbase_vtbl_entries (tree, vtbl_init_data *);
186 static void clone_constructors_and_destructors (tree);
187 static tree build_clone (tree, tree);
188 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
189 static void build_ctor_vtbl_group (tree, tree);
190 static void build_vtt (tree);
191 static tree binfo_ctor_vtable (tree);
192 static tree *build_vtt_inits (tree, tree, tree *, tree *);
193 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
194 static tree dfs_fixup_binfo_vtbls (tree, void *);
195 static int record_subobject_offset (tree, tree, splay_tree);
196 static int check_subobject_offset (tree, tree, splay_tree);
197 static int walk_subobject_offsets (tree, subobject_offset_fn,
198                                    tree, splay_tree, tree, int);
199 static void record_subobject_offsets (tree, tree, splay_tree, bool);
200 static int layout_conflict_p (tree, tree, splay_tree, int);
201 static int splay_tree_compare_integer_csts (splay_tree_key k1,
202                                             splay_tree_key k2);
203 static void warn_about_ambiguous_bases (tree);
204 static bool type_requires_array_cookie (tree);
205 static bool contains_empty_class_p (tree);
206 static bool base_derived_from (tree, tree);
207 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
208 static tree end_of_base (tree);
209 static tree get_vcall_index (tree, tree);
210
211 /* Variables shared between class.c and call.c.  */
212
213 #ifdef GATHER_STATISTICS
214 int n_vtables = 0;
215 int n_vtable_entries = 0;
216 int n_vtable_searches = 0;
217 int n_vtable_elems = 0;
218 int n_convert_harshness = 0;
219 int n_compute_conversion_costs = 0;
220 int n_inner_fields_searched = 0;
221 #endif
222
223 /* Convert to or from a base subobject.  EXPR is an expression of type
224    `A' or `A*', an expression of type `B' or `B*' is returned.  To
225    convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
226    the B base instance within A.  To convert base A to derived B, CODE
227    is MINUS_EXPR and BINFO is the binfo for the A instance within B.
228    In this latter case, A must not be a morally virtual base of B.
229    NONNULL is true if EXPR is known to be non-NULL (this is only
230    needed when EXPR is of pointer type).  CV qualifiers are preserved
231    from EXPR.  */
232
233 tree
234 build_base_path (enum tree_code code,
235                  tree expr,
236                  tree binfo,
237                  int nonnull)
238 {
239   tree v_binfo = NULL_TREE;
240   tree d_binfo = NULL_TREE;
241   tree probe;
242   tree offset;
243   tree target_type;
244   tree null_test = NULL;
245   tree ptr_target_type;
246   int fixed_type_p;
247   int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
248   bool has_empty = false;
249   bool virtual_access;
250
251   if (expr == error_mark_node || binfo == error_mark_node || !binfo)
252     return error_mark_node;
253
254   for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
255     {
256       d_binfo = probe;
257       if (is_empty_class (BINFO_TYPE (probe)))
258         has_empty = true;
259       if (!v_binfo && BINFO_VIRTUAL_P (probe))
260         v_binfo = probe;
261     }
262
263   probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
264   if (want_pointer)
265     probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
266
267   gcc_assert ((code == MINUS_EXPR
268                && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), probe))
269               || (code == PLUS_EXPR
270                   && SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe)));
271
272   if (binfo == d_binfo)
273     /* Nothing to do.  */
274     return expr;
275
276   if (code == MINUS_EXPR && v_binfo)
277     {
278       error ("cannot convert from base %qT to derived type %qT via virtual base %qT",
279              BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
280       return error_mark_node;
281     }
282
283   if (!want_pointer)
284     /* This must happen before the call to save_expr.  */
285     expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
286
287   offset = BINFO_OFFSET (binfo);
288   fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
289   target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
290
291   /* Do we need to look in the vtable for the real offset?  */
292   virtual_access = (v_binfo && fixed_type_p <= 0);
293
294   /* Don't bother with the calculations inside sizeof; they'll ICE if the
295      source type is incomplete and the pointer value doesn't matter.  */
296   if (cp_unevaluated_operand != 0)
297     {
298       expr = build_nop (build_pointer_type (target_type), expr);
299       if (!want_pointer)
300         expr = build_indirect_ref (EXPR_LOCATION (expr), expr, RO_NULL);
301       return expr;
302     }
303
304   /* Do we need to check for a null pointer?  */
305   if (want_pointer && !nonnull)
306     {
307       /* If we know the conversion will not actually change the value
308          of EXPR, then we can avoid testing the expression for NULL.
309          We have to avoid generating a COMPONENT_REF for a base class
310          field, because other parts of the compiler know that such
311          expressions are always non-NULL.  */
312       if (!virtual_access && integer_zerop (offset))
313         {
314           tree class_type;
315           /* TARGET_TYPE has been extracted from BINFO, and, is
316              therefore always cv-unqualified.  Extract the
317              cv-qualifiers from EXPR so that the expression returned
318              matches the input.  */
319           class_type = TREE_TYPE (TREE_TYPE (expr));
320           target_type
321             = cp_build_qualified_type (target_type,
322                                        cp_type_quals (class_type));
323           return build_nop (build_pointer_type (target_type), expr);
324         }
325       null_test = error_mark_node;
326     }
327
328   /* Protect against multiple evaluation if necessary.  */
329   if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access))
330     expr = save_expr (expr);
331
332   /* Now that we've saved expr, build the real null test.  */
333   if (null_test)
334     {
335       tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
336       null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
337                                expr, zero);
338     }
339
340   /* If this is a simple base reference, express it as a COMPONENT_REF.  */
341   if (code == PLUS_EXPR && !virtual_access
342       /* We don't build base fields for empty bases, and they aren't very
343          interesting to the optimizers anyway.  */
344       && !has_empty)
345     {
346       expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
347       expr = build_simple_base_path (expr, binfo);
348       if (want_pointer)
349         expr = build_address (expr);
350       target_type = TREE_TYPE (expr);
351       goto out;
352     }
353
354   if (virtual_access)
355     {
356       /* Going via virtual base V_BINFO.  We need the static offset
357          from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
358          V_BINFO.  That offset is an entry in D_BINFO's vtable.  */
359       tree v_offset;
360
361       if (fixed_type_p < 0 && in_base_initializer)
362         {
363           /* In a base member initializer, we cannot rely on the
364              vtable being set up.  We have to indirect via the
365              vtt_parm.  */
366           tree t;
367
368           t = TREE_TYPE (TYPE_VFIELD (current_class_type));
369           t = build_pointer_type (t);
370           v_offset = convert (t, current_vtt_parm);
371           v_offset = cp_build_indirect_ref (v_offset, RO_NULL, 
372                                             tf_warning_or_error);
373         }
374       else
375         v_offset = build_vfield_ref (cp_build_indirect_ref (expr, RO_NULL,
376                                                             tf_warning_or_error),
377                                      TREE_TYPE (TREE_TYPE (expr)));
378
379       v_offset = build2 (POINTER_PLUS_EXPR, TREE_TYPE (v_offset),
380                          v_offset, fold_convert (sizetype, BINFO_VPTR_FIELD (v_binfo)));
381       v_offset = build1 (NOP_EXPR,
382                          build_pointer_type (ptrdiff_type_node),
383                          v_offset);
384       v_offset = cp_build_indirect_ref (v_offset, RO_NULL, tf_warning_or_error);
385       TREE_CONSTANT (v_offset) = 1;
386
387       offset = convert_to_integer (ptrdiff_type_node,
388                                    size_diffop_loc (input_location, offset,
389                                                 BINFO_OFFSET (v_binfo)));
390
391       if (!integer_zerop (offset))
392         v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
393
394       if (fixed_type_p < 0)
395         /* Negative fixed_type_p means this is a constructor or destructor;
396            virtual base layout is fixed in in-charge [cd]tors, but not in
397            base [cd]tors.  */
398         offset = build3 (COND_EXPR, ptrdiff_type_node,
399                          build2 (EQ_EXPR, boolean_type_node,
400                                  current_in_charge_parm, integer_zero_node),
401                          v_offset,
402                          convert_to_integer (ptrdiff_type_node,
403                                              BINFO_OFFSET (binfo)));
404       else
405         offset = v_offset;
406     }
407
408   target_type = cp_build_qualified_type
409     (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
410   ptr_target_type = build_pointer_type (target_type);
411   if (want_pointer)
412     target_type = ptr_target_type;
413
414   expr = build1 (NOP_EXPR, ptr_target_type, expr);
415
416   if (!integer_zerop (offset))
417     {
418       offset = fold_convert (sizetype, offset);
419       if (code == MINUS_EXPR)
420         offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset);
421       expr = build2 (POINTER_PLUS_EXPR, ptr_target_type, expr, offset);
422     }
423   else
424     null_test = NULL;
425
426   if (!want_pointer)
427     expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
428
429  out:
430   if (null_test)
431     expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr,
432                         fold_build1_loc (input_location, NOP_EXPR, target_type,
433                                      integer_zero_node));
434
435   return expr;
436 }
437
438 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
439    Perform a derived-to-base conversion by recursively building up a
440    sequence of COMPONENT_REFs to the appropriate base fields.  */
441
442 static tree
443 build_simple_base_path (tree expr, tree binfo)
444 {
445   tree type = BINFO_TYPE (binfo);
446   tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
447   tree field;
448
449   if (d_binfo == NULL_TREE)
450     {
451       tree temp;
452
453       gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
454
455       /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
456          into `(*(a ?  &b : &c)).x', and so on.  A COND_EXPR is only
457          an lvalue in the front end; only _DECLs and _REFs are lvalues
458          in the back end.  */
459       temp = unary_complex_lvalue (ADDR_EXPR, expr);
460       if (temp)
461         expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error);
462
463       return expr;
464     }
465
466   /* Recurse.  */
467   expr = build_simple_base_path (expr, d_binfo);
468
469   for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
470        field; field = TREE_CHAIN (field))
471     /* Is this the base field created by build_base_field?  */
472     if (TREE_CODE (field) == FIELD_DECL
473         && DECL_FIELD_IS_BASE (field)
474         && TREE_TYPE (field) == type)
475       {
476         /* We don't use build_class_member_access_expr here, as that
477            has unnecessary checks, and more importantly results in
478            recursive calls to dfs_walk_once.  */
479         int type_quals = cp_type_quals (TREE_TYPE (expr));
480
481         expr = build3 (COMPONENT_REF,
482                        cp_build_qualified_type (type, type_quals),
483                        expr, field, NULL_TREE);
484         expr = fold_if_not_in_template (expr);
485
486         /* Mark the expression const or volatile, as appropriate.
487            Even though we've dealt with the type above, we still have
488            to mark the expression itself.  */
489         if (type_quals & TYPE_QUAL_CONST)
490           TREE_READONLY (expr) = 1;
491         if (type_quals & TYPE_QUAL_VOLATILE)
492           TREE_THIS_VOLATILE (expr) = 1;
493
494         return expr;
495       }
496
497   /* Didn't find the base field?!?  */
498   gcc_unreachable ();
499 }
500
501 /* Convert OBJECT to the base TYPE.  OBJECT is an expression whose
502    type is a class type or a pointer to a class type.  In the former
503    case, TYPE is also a class type; in the latter it is another
504    pointer type.  If CHECK_ACCESS is true, an error message is emitted
505    if TYPE is inaccessible.  If OBJECT has pointer type, the value is
506    assumed to be non-NULL.  */
507
508 tree
509 convert_to_base (tree object, tree type, bool check_access, bool nonnull,
510                  tsubst_flags_t complain)
511 {
512   tree binfo;
513   tree object_type;
514   base_access access;
515
516   if (TYPE_PTR_P (TREE_TYPE (object)))
517     {
518       object_type = TREE_TYPE (TREE_TYPE (object));
519       type = TREE_TYPE (type);
520     }
521   else
522     object_type = TREE_TYPE (object);
523
524   access = check_access ? ba_check : ba_unique;
525   if (!(complain & tf_error))
526     access |= ba_quiet;
527   binfo = lookup_base (object_type, type,
528                        access,
529                        NULL);
530   if (!binfo || binfo == error_mark_node)
531     return error_mark_node;
532
533   return build_base_path (PLUS_EXPR, object, binfo, nonnull);
534 }
535
536 /* EXPR is an expression with unqualified class type.  BASE is a base
537    binfo of that class type.  Returns EXPR, converted to the BASE
538    type.  This function assumes that EXPR is the most derived class;
539    therefore virtual bases can be found at their static offsets.  */
540
541 tree
542 convert_to_base_statically (tree expr, tree base)
543 {
544   tree expr_type;
545
546   expr_type = TREE_TYPE (expr);
547   if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type))
548     {
549       tree pointer_type;
550
551       pointer_type = build_pointer_type (expr_type);
552
553       /* We use fold_build2 and fold_convert below to simplify the trees
554          provided to the optimizers.  It is not safe to call these functions
555          when processing a template because they do not handle C++-specific
556          trees.  */
557       gcc_assert (!processing_template_decl);
558       expr = cp_build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1, 
559                              tf_warning_or_error);
560       if (!integer_zerop (BINFO_OFFSET (base)))
561         expr = fold_build2_loc (input_location,
562                             POINTER_PLUS_EXPR, pointer_type, expr,
563                             fold_convert (sizetype, BINFO_OFFSET (base)));
564       expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr);
565       expr = build_fold_indirect_ref_loc (input_location, expr);
566     }
567
568   return expr;
569 }
570
571 \f
572 tree
573 build_vfield_ref (tree datum, tree type)
574 {
575   tree vfield, vcontext;
576
577   if (datum == error_mark_node)
578     return error_mark_node;
579
580   /* First, convert to the requested type.  */
581   if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
582     datum = convert_to_base (datum, type, /*check_access=*/false,
583                              /*nonnull=*/true, tf_warning_or_error);
584
585   /* Second, the requested type may not be the owner of its own vptr.
586      If not, convert to the base class that owns it.  We cannot use
587      convert_to_base here, because VCONTEXT may appear more than once
588      in the inheritance hierarchy of TYPE, and thus direct conversion
589      between the types may be ambiguous.  Following the path back up
590      one step at a time via primary bases avoids the problem.  */
591   vfield = TYPE_VFIELD (type);
592   vcontext = DECL_CONTEXT (vfield);
593   while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type))
594     {
595       datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type));
596       type = TREE_TYPE (datum);
597     }
598
599   return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE);
600 }
601
602 /* Given an object INSTANCE, return an expression which yields the
603    vtable element corresponding to INDEX.  There are many special
604    cases for INSTANCE which we take care of here, mainly to avoid
605    creating extra tree nodes when we don't have to.  */
606
607 static tree
608 build_vtbl_ref_1 (tree instance, tree idx)
609 {
610   tree aref;
611   tree vtbl = NULL_TREE;
612
613   /* Try to figure out what a reference refers to, and
614      access its virtual function table directly.  */
615
616   int cdtorp = 0;
617   tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
618
619   tree basetype = non_reference (TREE_TYPE (instance));
620
621   if (fixed_type && !cdtorp)
622     {
623       tree binfo = lookup_base (fixed_type, basetype,
624                                 ba_unique | ba_quiet, NULL);
625       if (binfo)
626         vtbl = unshare_expr (BINFO_VTABLE (binfo));
627     }
628
629   if (!vtbl)
630     vtbl = build_vfield_ref (instance, basetype);
631
632   aref = build_array_ref (input_location, vtbl, idx, tf_warning_or_error);
633   TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
634
635   return aref;
636 }
637
638 tree
639 build_vtbl_ref (tree instance, tree idx)
640 {
641   tree aref = build_vtbl_ref_1 (instance, idx);
642
643   return aref;
644 }
645
646 /* Given a stable object pointer INSTANCE_PTR, return an expression which
647    yields a function pointer corresponding to vtable element INDEX.  */
648
649 tree
650 build_vfn_ref (tree instance_ptr, tree idx)
651 {
652   tree aref;
653
654   aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL,
655                                                   tf_warning_or_error), 
656                            idx);
657
658   /* When using function descriptors, the address of the
659      vtable entry is treated as a function pointer.  */
660   if (TARGET_VTABLE_USES_DESCRIPTORS)
661     aref = build1 (NOP_EXPR, TREE_TYPE (aref),
662                    cp_build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1,
663                                    tf_warning_or_error));
664
665   /* Remember this as a method reference, for later devirtualization.  */
666   aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx);
667
668   return aref;
669 }
670
671 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
672    for the given TYPE.  */
673
674 static tree
675 get_vtable_name (tree type)
676 {
677   return mangle_vtbl_for_type (type);
678 }
679
680 /* DECL is an entity associated with TYPE, like a virtual table or an
681    implicitly generated constructor.  Determine whether or not DECL
682    should have external or internal linkage at the object file
683    level.  This routine does not deal with COMDAT linkage and other
684    similar complexities; it simply sets TREE_PUBLIC if it possible for
685    entities in other translation units to contain copies of DECL, in
686    the abstract.  */
687
688 void
689 set_linkage_according_to_type (tree type, tree decl)
690 {
691   /* If TYPE involves a local class in a function with internal
692      linkage, then DECL should have internal linkage too.  Other local
693      classes have no linkage -- but if their containing functions
694      have external linkage, it makes sense for DECL to have external
695      linkage too.  That will allow template definitions to be merged,
696      for example.  */
697   if (no_linkage_check (type, /*relaxed_p=*/true))
698     {
699       TREE_PUBLIC (decl) = 0;
700       DECL_INTERFACE_KNOWN (decl) = 1;
701     }
702   else
703     TREE_PUBLIC (decl) = 1;
704 }
705
706 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
707    (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
708    Use NAME for the name of the vtable, and VTABLE_TYPE for its type.  */
709
710 static tree
711 build_vtable (tree class_type, tree name, tree vtable_type)
712 {
713   tree decl;
714
715   decl = build_lang_decl (VAR_DECL, name, vtable_type);
716   /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
717      now to avoid confusion in mangle_decl.  */
718   SET_DECL_ASSEMBLER_NAME (decl, name);
719   DECL_CONTEXT (decl) = class_type;
720   DECL_ARTIFICIAL (decl) = 1;
721   TREE_STATIC (decl) = 1;
722   TREE_READONLY (decl) = 1;
723   DECL_VIRTUAL_P (decl) = 1;
724   DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
725   DECL_VTABLE_OR_VTT_P (decl) = 1;
726   /* At one time the vtable info was grabbed 2 words at a time.  This
727      fails on sparc unless you have 8-byte alignment.  (tiemann) */
728   DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
729                            DECL_ALIGN (decl));
730   set_linkage_according_to_type (class_type, decl);
731   /* The vtable has not been defined -- yet.  */
732   DECL_EXTERNAL (decl) = 1;
733   DECL_NOT_REALLY_EXTERN (decl) = 1;
734
735   /* Mark the VAR_DECL node representing the vtable itself as a
736      "gratuitous" one, thereby forcing dwarfout.c to ignore it.  It
737      is rather important that such things be ignored because any
738      effort to actually generate DWARF for them will run into
739      trouble when/if we encounter code like:
740
741      #pragma interface
742      struct S { virtual void member (); };
743
744      because the artificial declaration of the vtable itself (as
745      manufactured by the g++ front end) will say that the vtable is
746      a static member of `S' but only *after* the debug output for
747      the definition of `S' has already been output.  This causes
748      grief because the DWARF entry for the definition of the vtable
749      will try to refer back to an earlier *declaration* of the
750      vtable as a static member of `S' and there won't be one.  We
751      might be able to arrange to have the "vtable static member"
752      attached to the member list for `S' before the debug info for
753      `S' get written (which would solve the problem) but that would
754      require more intrusive changes to the g++ front end.  */
755   DECL_IGNORED_P (decl) = 1;
756
757   return decl;
758 }
759
760 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
761    or even complete.  If this does not exist, create it.  If COMPLETE is
762    nonzero, then complete the definition of it -- that will render it
763    impossible to actually build the vtable, but is useful to get at those
764    which are known to exist in the runtime.  */
765
766 tree
767 get_vtable_decl (tree type, int complete)
768 {
769   tree decl;
770
771   if (CLASSTYPE_VTABLES (type))
772     return CLASSTYPE_VTABLES (type);
773
774   decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
775   CLASSTYPE_VTABLES (type) = decl;
776
777   if (complete)
778     {
779       DECL_EXTERNAL (decl) = 1;
780       cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
781     }
782
783   return decl;
784 }
785
786 /* Build the primary virtual function table for TYPE.  If BINFO is
787    non-NULL, build the vtable starting with the initial approximation
788    that it is the same as the one which is the head of the association
789    list.  Returns a nonzero value if a new vtable is actually
790    created.  */
791
792 static int
793 build_primary_vtable (tree binfo, tree type)
794 {
795   tree decl;
796   tree virtuals;
797
798   decl = get_vtable_decl (type, /*complete=*/0);
799
800   if (binfo)
801     {
802       if (BINFO_NEW_VTABLE_MARKED (binfo))
803         /* We have already created a vtable for this base, so there's
804            no need to do it again.  */
805         return 0;
806
807       virtuals = copy_list (BINFO_VIRTUALS (binfo));
808       TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
809       DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
810       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
811     }
812   else
813     {
814       gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
815       virtuals = NULL_TREE;
816     }
817
818 #ifdef GATHER_STATISTICS
819   n_vtables += 1;
820   n_vtable_elems += list_length (virtuals);
821 #endif
822
823   /* Initialize the association list for this type, based
824      on our first approximation.  */
825   BINFO_VTABLE (TYPE_BINFO (type)) = decl;
826   BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
827   SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
828   return 1;
829 }
830
831 /* Give BINFO a new virtual function table which is initialized
832    with a skeleton-copy of its original initialization.  The only
833    entry that changes is the `delta' entry, so we can really
834    share a lot of structure.
835
836    FOR_TYPE is the most derived type which caused this table to
837    be needed.
838
839    Returns nonzero if we haven't met BINFO before.
840
841    The order in which vtables are built (by calling this function) for
842    an object must remain the same, otherwise a binary incompatibility
843    can result.  */
844
845 static int
846 build_secondary_vtable (tree binfo)
847 {
848   if (BINFO_NEW_VTABLE_MARKED (binfo))
849     /* We already created a vtable for this base.  There's no need to
850        do it again.  */
851     return 0;
852
853   /* Remember that we've created a vtable for this BINFO, so that we
854      don't try to do so again.  */
855   SET_BINFO_NEW_VTABLE_MARKED (binfo);
856
857   /* Make fresh virtual list, so we can smash it later.  */
858   BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
859
860   /* Secondary vtables are laid out as part of the same structure as
861      the primary vtable.  */
862   BINFO_VTABLE (binfo) = NULL_TREE;
863   return 1;
864 }
865
866 /* Create a new vtable for BINFO which is the hierarchy dominated by
867    T. Return nonzero if we actually created a new vtable.  */
868
869 static int
870 make_new_vtable (tree t, tree binfo)
871 {
872   if (binfo == TYPE_BINFO (t))
873     /* In this case, it is *type*'s vtable we are modifying.  We start
874        with the approximation that its vtable is that of the
875        immediate base class.  */
876     return build_primary_vtable (binfo, t);
877   else
878     /* This is our very own copy of `basetype' to play with.  Later,
879        we will fill in all the virtual functions that override the
880        virtual functions in these base classes which are not defined
881        by the current type.  */
882     return build_secondary_vtable (binfo);
883 }
884
885 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
886    (which is in the hierarchy dominated by T) list FNDECL as its
887    BV_FN.  DELTA is the required constant adjustment from the `this'
888    pointer where the vtable entry appears to the `this' required when
889    the function is actually called.  */
890
891 static void
892 modify_vtable_entry (tree t,
893                      tree binfo,
894                      tree fndecl,
895                      tree delta,
896                      tree *virtuals)
897 {
898   tree v;
899
900   v = *virtuals;
901
902   if (fndecl != BV_FN (v)
903       || !tree_int_cst_equal (delta, BV_DELTA (v)))
904     {
905       /* We need a new vtable for BINFO.  */
906       if (make_new_vtable (t, binfo))
907         {
908           /* If we really did make a new vtable, we also made a copy
909              of the BINFO_VIRTUALS list.  Now, we have to find the
910              corresponding entry in that list.  */
911           *virtuals = BINFO_VIRTUALS (binfo);
912           while (BV_FN (*virtuals) != BV_FN (v))
913             *virtuals = TREE_CHAIN (*virtuals);
914           v = *virtuals;
915         }
916
917       BV_DELTA (v) = delta;
918       BV_VCALL_INDEX (v) = NULL_TREE;
919       BV_FN (v) = fndecl;
920     }
921 }
922
923 \f
924 /* Add method METHOD to class TYPE.  If USING_DECL is non-null, it is
925    the USING_DECL naming METHOD.  Returns true if the method could be
926    added to the method vec.  */
927
928 bool
929 add_method (tree type, tree method, tree using_decl)
930 {
931   unsigned slot;
932   tree overload;
933   bool template_conv_p = false;
934   bool conv_p;
935   VEC(tree,gc) *method_vec;
936   bool complete_p;
937   bool insert_p = false;
938   tree current_fns;
939   tree fns;
940
941   if (method == error_mark_node)
942     return false;
943
944   complete_p = COMPLETE_TYPE_P (type);
945   conv_p = DECL_CONV_FN_P (method);
946   if (conv_p)
947     template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
948                        && DECL_TEMPLATE_CONV_FN_P (method));
949
950   method_vec = CLASSTYPE_METHOD_VEC (type);
951   if (!method_vec)
952     {
953       /* Make a new method vector.  We start with 8 entries.  We must
954          allocate at least two (for constructors and destructors), and
955          we're going to end up with an assignment operator at some
956          point as well.  */
957       method_vec = VEC_alloc (tree, gc, 8);
958       /* Create slots for constructors and destructors.  */
959       VEC_quick_push (tree, method_vec, NULL_TREE);
960       VEC_quick_push (tree, method_vec, NULL_TREE);
961       CLASSTYPE_METHOD_VEC (type) = method_vec;
962     }
963
964   /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc.  */
965   grok_special_member_properties (method);
966
967   /* Constructors and destructors go in special slots.  */
968   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
969     slot = CLASSTYPE_CONSTRUCTOR_SLOT;
970   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
971     {
972       slot = CLASSTYPE_DESTRUCTOR_SLOT;
973
974       if (TYPE_FOR_JAVA (type))
975         {
976           if (!DECL_ARTIFICIAL (method))
977             error ("Java class %qT cannot have a destructor", type);
978           else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
979             error ("Java class %qT cannot have an implicit non-trivial "
980                    "destructor",
981                    type);
982         }
983     }
984   else
985     {
986       tree m;
987
988       insert_p = true;
989       /* See if we already have an entry with this name.  */
990       for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
991            VEC_iterate (tree, method_vec, slot, m);
992            ++slot)
993         {
994           m = OVL_CURRENT (m);
995           if (template_conv_p)
996             {
997               if (TREE_CODE (m) == TEMPLATE_DECL
998                   && DECL_TEMPLATE_CONV_FN_P (m))
999                 insert_p = false;
1000               break;
1001             }
1002           if (conv_p && !DECL_CONV_FN_P (m))
1003             break;
1004           if (DECL_NAME (m) == DECL_NAME (method))
1005             {
1006               insert_p = false;
1007               break;
1008             }
1009           if (complete_p
1010               && !DECL_CONV_FN_P (m)
1011               && DECL_NAME (m) > DECL_NAME (method))
1012             break;
1013         }
1014     }
1015   current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot);
1016
1017   /* Check to see if we've already got this method.  */
1018   for (fns = current_fns; fns; fns = OVL_NEXT (fns))
1019     {
1020       tree fn = OVL_CURRENT (fns);
1021       tree fn_type;
1022       tree method_type;
1023       tree parms1;
1024       tree parms2;
1025
1026       if (TREE_CODE (fn) != TREE_CODE (method))
1027         continue;
1028
1029       /* [over.load] Member function declarations with the
1030          same name and the same parameter types cannot be
1031          overloaded if any of them is a static member
1032          function declaration.
1033
1034          [namespace.udecl] When a using-declaration brings names
1035          from a base class into a derived class scope, member
1036          functions in the derived class override and/or hide member
1037          functions with the same name and parameter types in a base
1038          class (rather than conflicting).  */
1039       fn_type = TREE_TYPE (fn);
1040       method_type = TREE_TYPE (method);
1041       parms1 = TYPE_ARG_TYPES (fn_type);
1042       parms2 = TYPE_ARG_TYPES (method_type);
1043
1044       /* Compare the quals on the 'this' parm.  Don't compare
1045          the whole types, as used functions are treated as
1046          coming from the using class in overload resolution.  */
1047       if (! DECL_STATIC_FUNCTION_P (fn)
1048           && ! DECL_STATIC_FUNCTION_P (method)
1049           && TREE_TYPE (TREE_VALUE (parms1)) != error_mark_node
1050           && TREE_TYPE (TREE_VALUE (parms2)) != error_mark_node
1051           && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1)))
1052               != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2)))))
1053         continue;
1054
1055       /* For templates, the return type and template parameters
1056          must be identical.  */
1057       if (TREE_CODE (fn) == TEMPLATE_DECL
1058           && (!same_type_p (TREE_TYPE (fn_type),
1059                             TREE_TYPE (method_type))
1060               || !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
1061                                        DECL_TEMPLATE_PARMS (method))))
1062         continue;
1063
1064       if (! DECL_STATIC_FUNCTION_P (fn))
1065         parms1 = TREE_CHAIN (parms1);
1066       if (! DECL_STATIC_FUNCTION_P (method))
1067         parms2 = TREE_CHAIN (parms2);
1068
1069       if (compparms (parms1, parms2)
1070           && (!DECL_CONV_FN_P (fn)
1071               || same_type_p (TREE_TYPE (fn_type),
1072                               TREE_TYPE (method_type))))
1073         {
1074           if (using_decl)
1075             {
1076               if (DECL_CONTEXT (fn) == type)
1077                 /* Defer to the local function.  */
1078                 return false;
1079               if (DECL_CONTEXT (fn) == DECL_CONTEXT (method))
1080                 error ("repeated using declaration %q+D", using_decl);
1081               else
1082                 error ("using declaration %q+D conflicts with a previous using declaration",
1083                        using_decl);
1084             }
1085           else
1086             {
1087               error ("%q+#D cannot be overloaded", method);
1088               error ("with %q+#D", fn);
1089             }
1090
1091           /* We don't call duplicate_decls here to merge the
1092              declarations because that will confuse things if the
1093              methods have inline definitions.  In particular, we
1094              will crash while processing the definitions.  */
1095           return false;
1096         }
1097     }
1098
1099   /* A class should never have more than one destructor.  */
1100   if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
1101     return false;
1102
1103   /* Add the new binding.  */
1104   overload = build_overload (method, current_fns);
1105
1106   if (conv_p)
1107     TYPE_HAS_CONVERSION (type) = 1;
1108   else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p)
1109     push_class_level_binding (DECL_NAME (method), overload);
1110
1111   if (insert_p)
1112     {
1113       bool reallocated;
1114
1115       /* We only expect to add few methods in the COMPLETE_P case, so
1116          just make room for one more method in that case.  */
1117       if (complete_p)
1118         reallocated = VEC_reserve_exact (tree, gc, method_vec, 1);
1119       else
1120         reallocated = VEC_reserve (tree, gc, method_vec, 1);
1121       if (reallocated)
1122         CLASSTYPE_METHOD_VEC (type) = method_vec;
1123       if (slot == VEC_length (tree, method_vec))
1124         VEC_quick_push (tree, method_vec, overload);
1125       else
1126         VEC_quick_insert (tree, method_vec, slot, overload);
1127     }
1128   else
1129     /* Replace the current slot.  */
1130     VEC_replace (tree, method_vec, slot, overload);
1131   return true;
1132 }
1133
1134 /* Subroutines of finish_struct.  */
1135
1136 /* Change the access of FDECL to ACCESS in T.  Return 1 if change was
1137    legit, otherwise return 0.  */
1138
1139 static int
1140 alter_access (tree t, tree fdecl, tree access)
1141 {
1142   tree elem;
1143
1144   if (!DECL_LANG_SPECIFIC (fdecl))
1145     retrofit_lang_decl (fdecl);
1146
1147   gcc_assert (!DECL_DISCRIMINATOR_P (fdecl));
1148
1149   elem = purpose_member (t, DECL_ACCESS (fdecl));
1150   if (elem)
1151     {
1152       if (TREE_VALUE (elem) != access)
1153         {
1154           if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1155             error ("conflicting access specifications for method"
1156                    " %q+D, ignored", TREE_TYPE (fdecl));
1157           else
1158             error ("conflicting access specifications for field %qE, ignored",
1159                    DECL_NAME (fdecl));
1160         }
1161       else
1162         {
1163           /* They're changing the access to the same thing they changed
1164              it to before.  That's OK.  */
1165           ;
1166         }
1167     }
1168   else
1169     {
1170       perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl);
1171       DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1172       return 1;
1173     }
1174   return 0;
1175 }
1176
1177 /* Process the USING_DECL, which is a member of T.  */
1178
1179 static void
1180 handle_using_decl (tree using_decl, tree t)
1181 {
1182   tree decl = USING_DECL_DECLS (using_decl);
1183   tree name = DECL_NAME (using_decl);
1184   tree access
1185     = TREE_PRIVATE (using_decl) ? access_private_node
1186     : TREE_PROTECTED (using_decl) ? access_protected_node
1187     : access_public_node;
1188   tree flist = NULL_TREE;
1189   tree old_value;
1190
1191   gcc_assert (!processing_template_decl && decl);
1192
1193   old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false);
1194   if (old_value)
1195     {
1196       if (is_overloaded_fn (old_value))
1197         old_value = OVL_CURRENT (old_value);
1198
1199       if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1200         /* OK */;
1201       else
1202         old_value = NULL_TREE;
1203     }
1204
1205   cp_emit_debug_info_for_using (decl, USING_DECL_SCOPE (using_decl));
1206
1207   if (is_overloaded_fn (decl))
1208     flist = decl;
1209
1210   if (! old_value)
1211     ;
1212   else if (is_overloaded_fn (old_value))
1213     {
1214       if (flist)
1215         /* It's OK to use functions from a base when there are functions with
1216            the same name already present in the current class.  */;
1217       else
1218         {
1219           error ("%q+D invalid in %q#T", using_decl, t);
1220           error ("  because of local method %q+#D with same name",
1221                  OVL_CURRENT (old_value));
1222           return;
1223         }
1224     }
1225   else if (!DECL_ARTIFICIAL (old_value))
1226     {
1227       error ("%q+D invalid in %q#T", using_decl, t);
1228       error ("  because of local member %q+#D with same name", old_value);
1229       return;
1230     }
1231
1232   /* Make type T see field decl FDECL with access ACCESS.  */
1233   if (flist)
1234     for (; flist; flist = OVL_NEXT (flist))
1235       {
1236         add_method (t, OVL_CURRENT (flist), using_decl);
1237         alter_access (t, OVL_CURRENT (flist), access);
1238       }
1239   else
1240     alter_access (t, decl, access);
1241 }
1242 \f
1243 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1244    and NO_CONST_ASN_REF_P.  Also set flag bits in T based on
1245    properties of the bases.  */
1246
1247 static void
1248 check_bases (tree t,
1249              int* cant_have_const_ctor_p,
1250              int* no_const_asn_ref_p)
1251 {
1252   int i;
1253   int seen_non_virtual_nearly_empty_base_p;
1254   tree base_binfo;
1255   tree binfo;
1256   tree field = NULL_TREE;
1257
1258   seen_non_virtual_nearly_empty_base_p = 0;
1259
1260   if (!CLASSTYPE_NON_STD_LAYOUT (t))
1261     for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1262       if (TREE_CODE (field) == FIELD_DECL)
1263         break;
1264
1265   for (binfo = TYPE_BINFO (t), i = 0;
1266        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1267     {
1268       tree basetype = TREE_TYPE (base_binfo);
1269
1270       gcc_assert (COMPLETE_TYPE_P (basetype));
1271
1272       /* Effective C++ rule 14.  We only need to check TYPE_POLYMORPHIC_P
1273          here because the case of virtual functions but non-virtual
1274          dtor is handled in finish_struct_1.  */
1275       if (!TYPE_POLYMORPHIC_P (basetype))
1276         warning (OPT_Weffc__,
1277                  "base class %q#T has a non-virtual destructor", basetype);
1278
1279       /* If the base class doesn't have copy constructors or
1280          assignment operators that take const references, then the
1281          derived class cannot have such a member automatically
1282          generated.  */
1283       if (! TYPE_HAS_CONST_INIT_REF (basetype))
1284         *cant_have_const_ctor_p = 1;
1285       if (TYPE_HAS_ASSIGN_REF (basetype)
1286           && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1287         *no_const_asn_ref_p = 1;
1288
1289       if (BINFO_VIRTUAL_P (base_binfo))
1290         /* A virtual base does not effect nearly emptiness.  */
1291         ;
1292       else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1293         {
1294           if (seen_non_virtual_nearly_empty_base_p)
1295             /* And if there is more than one nearly empty base, then the
1296                derived class is not nearly empty either.  */
1297             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1298           else
1299             /* Remember we've seen one.  */
1300             seen_non_virtual_nearly_empty_base_p = 1;
1301         }
1302       else if (!is_empty_class (basetype))
1303         /* If the base class is not empty or nearly empty, then this
1304            class cannot be nearly empty.  */
1305         CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1306
1307       /* A lot of properties from the bases also apply to the derived
1308          class.  */
1309       TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1310       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1311         |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1312       TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1313         |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1314       TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1315       TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1316       CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1317         |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1318       TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (basetype);      
1319
1320       /*  A standard-layout class is a class that:
1321           ...
1322           * has no non-standard-layout base classes,  */
1323       CLASSTYPE_NON_STD_LAYOUT (t) |= CLASSTYPE_NON_STD_LAYOUT (basetype);
1324       if (!CLASSTYPE_NON_STD_LAYOUT (t))
1325         {
1326           tree basefield;
1327           /* ...has no base classes of the same type as the first non-static
1328              data member...  */
1329           if (field && DECL_CONTEXT (field) == t
1330               && (same_type_ignoring_top_level_qualifiers_p
1331                   (TREE_TYPE (field), basetype)))
1332             CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1333           else
1334             /* ...either has no non-static data members in the most-derived
1335                class and at most one base class with non-static data
1336                members, or has no base classes with non-static data
1337                members */
1338             for (basefield = TYPE_FIELDS (basetype); basefield;
1339                  basefield = TREE_CHAIN (basefield))
1340               if (TREE_CODE (basefield) == FIELD_DECL)
1341                 {
1342                   if (field)
1343                     CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1344                   else
1345                     field = basefield;
1346                   break;
1347                 }
1348         }
1349     }
1350 }
1351
1352 /* Determine all the primary bases within T.  Sets BINFO_PRIMARY_BASE_P for
1353    those that are primaries.  Sets BINFO_LOST_PRIMARY_P for those
1354    that have had a nearly-empty virtual primary base stolen by some
1355    other base in the hierarchy.  Determines CLASSTYPE_PRIMARY_BASE for
1356    T.  */
1357
1358 static void
1359 determine_primary_bases (tree t)
1360 {
1361   unsigned i;
1362   tree primary = NULL_TREE;
1363   tree type_binfo = TYPE_BINFO (t);
1364   tree base_binfo;
1365
1366   /* Determine the primary bases of our bases.  */
1367   for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1368        base_binfo = TREE_CHAIN (base_binfo))
1369     {
1370       tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1371
1372       /* See if we're the non-virtual primary of our inheritance
1373          chain.  */
1374       if (!BINFO_VIRTUAL_P (base_binfo))
1375         {
1376           tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1377           tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1378
1379           if (parent_primary
1380               && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
1381                                     BINFO_TYPE (parent_primary)))
1382             /* We are the primary binfo.  */
1383             BINFO_PRIMARY_P (base_binfo) = 1;
1384         }
1385       /* Determine if we have a virtual primary base, and mark it so.
1386        */
1387       if (primary && BINFO_VIRTUAL_P (primary))
1388         {
1389           tree this_primary = copied_binfo (primary, base_binfo);
1390
1391           if (BINFO_PRIMARY_P (this_primary))
1392             /* Someone already claimed this base.  */
1393             BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1394           else
1395             {
1396               tree delta;
1397
1398               BINFO_PRIMARY_P (this_primary) = 1;
1399               BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1400
1401               /* A virtual binfo might have been copied from within
1402                  another hierarchy. As we're about to use it as a
1403                  primary base, make sure the offsets match.  */
1404               delta = size_diffop_loc (input_location,
1405                                    convert (ssizetype,
1406                                             BINFO_OFFSET (base_binfo)),
1407                                    convert (ssizetype,
1408                                             BINFO_OFFSET (this_primary)));
1409
1410               propagate_binfo_offsets (this_primary, delta);
1411             }
1412         }
1413     }
1414
1415   /* First look for a dynamic direct non-virtual base.  */
1416   for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1417     {
1418       tree basetype = BINFO_TYPE (base_binfo);
1419
1420       if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1421         {
1422           primary = base_binfo;
1423           goto found;
1424         }
1425     }
1426
1427   /* A "nearly-empty" virtual base class can be the primary base
1428      class, if no non-virtual polymorphic base can be found.  Look for
1429      a nearly-empty virtual dynamic base that is not already a primary
1430      base of something in the hierarchy.  If there is no such base,
1431      just pick the first nearly-empty virtual base.  */
1432
1433   for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1434        base_binfo = TREE_CHAIN (base_binfo))
1435     if (BINFO_VIRTUAL_P (base_binfo)
1436         && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1437       {
1438         if (!BINFO_PRIMARY_P (base_binfo))
1439           {
1440             /* Found one that is not primary.  */
1441             primary = base_binfo;
1442             goto found;
1443           }
1444         else if (!primary)
1445           /* Remember the first candidate.  */
1446           primary = base_binfo;
1447       }
1448
1449  found:
1450   /* If we've got a primary base, use it.  */
1451   if (primary)
1452     {
1453       tree basetype = BINFO_TYPE (primary);
1454
1455       CLASSTYPE_PRIMARY_BINFO (t) = primary;
1456       if (BINFO_PRIMARY_P (primary))
1457         /* We are stealing a primary base.  */
1458         BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1459       BINFO_PRIMARY_P (primary) = 1;
1460       if (BINFO_VIRTUAL_P (primary))
1461         {
1462           tree delta;
1463
1464           BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1465           /* A virtual binfo might have been copied from within
1466              another hierarchy. As we're about to use it as a primary
1467              base, make sure the offsets match.  */
1468           delta = size_diffop_loc (input_location, ssize_int (0),
1469                                convert (ssizetype, BINFO_OFFSET (primary)));
1470
1471           propagate_binfo_offsets (primary, delta);
1472         }
1473
1474       primary = TYPE_BINFO (basetype);
1475
1476       TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1477       BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1478       BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1479     }
1480 }
1481
1482 /* Update the variant types of T.  */
1483
1484 void
1485 fixup_type_variants (tree t)
1486 {
1487   tree variants;
1488
1489   if (!t)
1490     return;
1491
1492   for (variants = TYPE_NEXT_VARIANT (t);
1493        variants;
1494        variants = TYPE_NEXT_VARIANT (variants))
1495     {
1496       /* These fields are in the _TYPE part of the node, not in
1497          the TYPE_LANG_SPECIFIC component, so they are not shared.  */
1498       TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t);
1499       TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1500       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1501         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1502
1503       TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1504
1505       TYPE_BINFO (variants) = TYPE_BINFO (t);
1506
1507       /* Copy whatever these are holding today.  */
1508       TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1509       TYPE_METHODS (variants) = TYPE_METHODS (t);
1510       TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1511
1512       /* All variants of a class have the same attributes.  */
1513       TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
1514     }
1515 }
1516
1517 \f
1518 /* Set memoizing fields and bits of T (and its variants) for later
1519    use.  */
1520
1521 static void
1522 finish_struct_bits (tree t)
1523 {
1524   /* Fix up variants (if any).  */
1525   fixup_type_variants (t);
1526
1527   if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1528     /* For a class w/o baseclasses, 'finish_struct' has set
1529        CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1530        Similarly for a class whose base classes do not have vtables.
1531        When neither of these is true, we might have removed abstract
1532        virtuals (by providing a definition), added some (by declaring
1533        new ones), or redeclared ones from a base class.  We need to
1534        recalculate what's really an abstract virtual at this point (by
1535        looking in the vtables).  */
1536     get_pure_virtuals (t);
1537
1538   /* If this type has a copy constructor or a destructor, force its
1539      mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1540      nonzero.  This will cause it to be passed by invisible reference
1541      and prevent it from being returned in a register.  */
1542   if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1543     {
1544       tree variants;
1545       DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1546       for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1547         {
1548           SET_TYPE_MODE (variants, BLKmode);
1549           TREE_ADDRESSABLE (variants) = 1;
1550         }
1551     }
1552 }
1553
1554 /* Issue warnings about T having private constructors, but no friends,
1555    and so forth.
1556
1557    HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1558    static members.  HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1559    non-private static member functions.  */
1560
1561 static void
1562 maybe_warn_about_overly_private_class (tree t)
1563 {
1564   int has_member_fn = 0;
1565   int has_nonprivate_method = 0;
1566   tree fn;
1567
1568   if (!warn_ctor_dtor_privacy
1569       /* If the class has friends, those entities might create and
1570          access instances, so we should not warn.  */
1571       || (CLASSTYPE_FRIEND_CLASSES (t)
1572           || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1573       /* We will have warned when the template was declared; there's
1574          no need to warn on every instantiation.  */
1575       || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1576     /* There's no reason to even consider warning about this
1577        class.  */
1578     return;
1579
1580   /* We only issue one warning, if more than one applies, because
1581      otherwise, on code like:
1582
1583      class A {
1584        // Oops - forgot `public:'
1585        A();
1586        A(const A&);
1587        ~A();
1588      };
1589
1590      we warn several times about essentially the same problem.  */
1591
1592   /* Check to see if all (non-constructor, non-destructor) member
1593      functions are private.  (Since there are no friends or
1594      non-private statics, we can't ever call any of the private member
1595      functions.)  */
1596   for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1597     /* We're not interested in compiler-generated methods; they don't
1598        provide any way to call private members.  */
1599     if (!DECL_ARTIFICIAL (fn))
1600       {
1601         if (!TREE_PRIVATE (fn))
1602           {
1603             if (DECL_STATIC_FUNCTION_P (fn))
1604               /* A non-private static member function is just like a
1605                  friend; it can create and invoke private member
1606                  functions, and be accessed without a class
1607                  instance.  */
1608               return;
1609
1610             has_nonprivate_method = 1;
1611             /* Keep searching for a static member function.  */
1612           }
1613         else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1614           has_member_fn = 1;
1615       }
1616
1617   if (!has_nonprivate_method && has_member_fn)
1618     {
1619       /* There are no non-private methods, and there's at least one
1620          private member function that isn't a constructor or
1621          destructor.  (If all the private members are
1622          constructors/destructors we want to use the code below that
1623          issues error messages specifically referring to
1624          constructors/destructors.)  */
1625       unsigned i;
1626       tree binfo = TYPE_BINFO (t);
1627
1628       for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1629         if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1630           {
1631             has_nonprivate_method = 1;
1632             break;
1633           }
1634       if (!has_nonprivate_method)
1635         {
1636           warning (OPT_Wctor_dtor_privacy,
1637                    "all member functions in class %qT are private", t);
1638           return;
1639         }
1640     }
1641
1642   /* Even if some of the member functions are non-private, the class
1643      won't be useful for much if all the constructors or destructors
1644      are private: such an object can never be created or destroyed.  */
1645   fn = CLASSTYPE_DESTRUCTORS (t);
1646   if (fn && TREE_PRIVATE (fn))
1647     {
1648       warning (OPT_Wctor_dtor_privacy,
1649                "%q#T only defines a private destructor and has no friends",
1650                t);
1651       return;
1652     }
1653
1654   /* Warn about classes that have private constructors and no friends.  */
1655   if (TYPE_HAS_USER_CONSTRUCTOR (t)
1656       /* Implicitly generated constructors are always public.  */
1657       && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t)
1658           || !CLASSTYPE_LAZY_COPY_CTOR (t)))
1659     {
1660       int nonprivate_ctor = 0;
1661
1662       /* If a non-template class does not define a copy
1663          constructor, one is defined for it, enabling it to avoid
1664          this warning.  For a template class, this does not
1665          happen, and so we would normally get a warning on:
1666
1667            template <class T> class C { private: C(); };
1668
1669          To avoid this asymmetry, we check TYPE_HAS_INIT_REF.  All
1670          complete non-template or fully instantiated classes have this
1671          flag set.  */
1672       if (!TYPE_HAS_INIT_REF (t))
1673         nonprivate_ctor = 1;
1674       else
1675         for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1676           {
1677             tree ctor = OVL_CURRENT (fn);
1678             /* Ideally, we wouldn't count copy constructors (or, in
1679                fact, any constructor that takes an argument of the
1680                class type as a parameter) because such things cannot
1681                be used to construct an instance of the class unless
1682                you already have one.  But, for now at least, we're
1683                more generous.  */
1684             if (! TREE_PRIVATE (ctor))
1685               {
1686                 nonprivate_ctor = 1;
1687                 break;
1688               }
1689           }
1690
1691       if (nonprivate_ctor == 0)
1692         {
1693           warning (OPT_Wctor_dtor_privacy,
1694                    "%q#T only defines private constructors and has no friends",
1695                    t);
1696           return;
1697         }
1698     }
1699 }
1700
1701 static struct {
1702   gt_pointer_operator new_value;
1703   void *cookie;
1704 } resort_data;
1705
1706 /* Comparison function to compare two TYPE_METHOD_VEC entries by name.  */
1707
1708 static int
1709 method_name_cmp (const void* m1_p, const void* m2_p)
1710 {
1711   const tree *const m1 = (const tree *) m1_p;
1712   const tree *const m2 = (const tree *) m2_p;
1713
1714   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1715     return 0;
1716   if (*m1 == NULL_TREE)
1717     return -1;
1718   if (*m2 == NULL_TREE)
1719     return 1;
1720   if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1721     return -1;
1722   return 1;
1723 }
1724
1725 /* This routine compares two fields like method_name_cmp but using the
1726    pointer operator in resort_field_decl_data.  */
1727
1728 static int
1729 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1730 {
1731   const tree *const m1 = (const tree *) m1_p;
1732   const tree *const m2 = (const tree *) m2_p;
1733   if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1734     return 0;
1735   if (*m1 == NULL_TREE)
1736     return -1;
1737   if (*m2 == NULL_TREE)
1738     return 1;
1739   {
1740     tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1741     tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1742     resort_data.new_value (&d1, resort_data.cookie);
1743     resort_data.new_value (&d2, resort_data.cookie);
1744     if (d1 < d2)
1745       return -1;
1746   }
1747   return 1;
1748 }
1749
1750 /* Resort TYPE_METHOD_VEC because pointers have been reordered.  */
1751
1752 void
1753 resort_type_method_vec (void* obj,
1754                         void* orig_obj ATTRIBUTE_UNUSED ,
1755                         gt_pointer_operator new_value,
1756                         void* cookie)
1757 {
1758   VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj;
1759   int len = VEC_length (tree, method_vec);
1760   size_t slot;
1761   tree fn;
1762
1763   /* The type conversion ops have to live at the front of the vec, so we
1764      can't sort them.  */
1765   for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1766        VEC_iterate (tree, method_vec, slot, fn);
1767        ++slot)
1768     if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1769       break;
1770
1771   if (len - slot > 1)
1772     {
1773       resort_data.new_value = new_value;
1774       resort_data.cookie = cookie;
1775       qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1776              resort_method_name_cmp);
1777     }
1778 }
1779
1780 /* Warn about duplicate methods in fn_fields.
1781
1782    Sort methods that are not special (i.e., constructors, destructors,
1783    and type conversion operators) so that we can find them faster in
1784    search.  */
1785
1786 static void
1787 finish_struct_methods (tree t)
1788 {
1789   tree fn_fields;
1790   VEC(tree,gc) *method_vec;
1791   int slot, len;
1792
1793   method_vec = CLASSTYPE_METHOD_VEC (t);
1794   if (!method_vec)
1795     return;
1796
1797   len = VEC_length (tree, method_vec);
1798
1799   /* Clear DECL_IN_AGGR_P for all functions.  */
1800   for (fn_fields = TYPE_METHODS (t); fn_fields;
1801        fn_fields = TREE_CHAIN (fn_fields))
1802     DECL_IN_AGGR_P (fn_fields) = 0;
1803
1804   /* Issue warnings about private constructors and such.  If there are
1805      no methods, then some public defaults are generated.  */
1806   maybe_warn_about_overly_private_class (t);
1807
1808   /* The type conversion ops have to live at the front of the vec, so we
1809      can't sort them.  */
1810   for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1811        VEC_iterate (tree, method_vec, slot, fn_fields);
1812        ++slot)
1813     if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1814       break;
1815   if (len - slot > 1)
1816     qsort (VEC_address (tree, method_vec) + slot,
1817            len-slot, sizeof (tree), method_name_cmp);
1818 }
1819
1820 /* Make BINFO's vtable have N entries, including RTTI entries,
1821    vbase and vcall offsets, etc.  Set its type and call the back end
1822    to lay it out.  */
1823
1824 static void
1825 layout_vtable_decl (tree binfo, int n)
1826 {
1827   tree atype;
1828   tree vtable;
1829
1830   atype = build_cplus_array_type (vtable_entry_type,
1831                                   build_index_type (size_int (n - 1)));
1832   layout_type (atype);
1833
1834   /* We may have to grow the vtable.  */
1835   vtable = get_vtbl_decl_for_binfo (binfo);
1836   if (!same_type_p (TREE_TYPE (vtable), atype))
1837     {
1838       TREE_TYPE (vtable) = atype;
1839       DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1840       layout_decl (vtable, 0);
1841     }
1842 }
1843
1844 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1845    have the same signature.  */
1846
1847 int
1848 same_signature_p (const_tree fndecl, const_tree base_fndecl)
1849 {
1850   /* One destructor overrides another if they are the same kind of
1851      destructor.  */
1852   if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1853       && special_function_p (base_fndecl) == special_function_p (fndecl))
1854     return 1;
1855   /* But a non-destructor never overrides a destructor, nor vice
1856      versa, nor do different kinds of destructors override
1857      one-another.  For example, a complete object destructor does not
1858      override a deleting destructor.  */
1859   if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1860     return 0;
1861
1862   if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1863       || (DECL_CONV_FN_P (fndecl)
1864           && DECL_CONV_FN_P (base_fndecl)
1865           && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1866                           DECL_CONV_FN_TYPE (base_fndecl))))
1867     {
1868       tree types, base_types;
1869       types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1870       base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1871       if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
1872            == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
1873           && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1874         return 1;
1875     }
1876   return 0;
1877 }
1878
1879 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1880    subobject.  */
1881
1882 static bool
1883 base_derived_from (tree derived, tree base)
1884 {
1885   tree probe;
1886
1887   for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1888     {
1889       if (probe == derived)
1890         return true;
1891       else if (BINFO_VIRTUAL_P (probe))
1892         /* If we meet a virtual base, we can't follow the inheritance
1893            any more.  See if the complete type of DERIVED contains
1894            such a virtual base.  */
1895         return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1896                 != NULL_TREE);
1897     }
1898   return false;
1899 }
1900
1901 typedef struct find_final_overrider_data_s {
1902   /* The function for which we are trying to find a final overrider.  */
1903   tree fn;
1904   /* The base class in which the function was declared.  */
1905   tree declaring_base;
1906   /* The candidate overriders.  */
1907   tree candidates;
1908   /* Path to most derived.  */
1909   VEC(tree,heap) *path;
1910 } find_final_overrider_data;
1911
1912 /* Add the overrider along the current path to FFOD->CANDIDATES.
1913    Returns true if an overrider was found; false otherwise.  */
1914
1915 static bool
1916 dfs_find_final_overrider_1 (tree binfo,
1917                             find_final_overrider_data *ffod,
1918                             unsigned depth)
1919 {
1920   tree method;
1921
1922   /* If BINFO is not the most derived type, try a more derived class.
1923      A definition there will overrider a definition here.  */
1924   if (depth)
1925     {
1926       depth--;
1927       if (dfs_find_final_overrider_1
1928           (VEC_index (tree, ffod->path, depth), ffod, depth))
1929         return true;
1930     }
1931
1932   method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1933   if (method)
1934     {
1935       tree *candidate = &ffod->candidates;
1936
1937       /* Remove any candidates overridden by this new function.  */
1938       while (*candidate)
1939         {
1940           /* If *CANDIDATE overrides METHOD, then METHOD
1941              cannot override anything else on the list.  */
1942           if (base_derived_from (TREE_VALUE (*candidate), binfo))
1943             return true;
1944           /* If METHOD overrides *CANDIDATE, remove *CANDIDATE.  */
1945           if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1946             *candidate = TREE_CHAIN (*candidate);
1947           else
1948             candidate = &TREE_CHAIN (*candidate);
1949         }
1950
1951       /* Add the new function.  */
1952       ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1953       return true;
1954     }
1955
1956   return false;
1957 }
1958
1959 /* Called from find_final_overrider via dfs_walk.  */
1960
1961 static tree
1962 dfs_find_final_overrider_pre (tree binfo, void *data)
1963 {
1964   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1965
1966   if (binfo == ffod->declaring_base)
1967     dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path));
1968   VEC_safe_push (tree, heap, ffod->path, binfo);
1969
1970   return NULL_TREE;
1971 }
1972
1973 static tree
1974 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1975 {
1976   find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1977   VEC_pop (tree, ffod->path);
1978
1979   return NULL_TREE;
1980 }
1981
1982 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1983    FN and whose TREE_VALUE is the binfo for the base where the
1984    overriding occurs.  BINFO (in the hierarchy dominated by the binfo
1985    DERIVED) is the base object in which FN is declared.  */
1986
1987 static tree
1988 find_final_overrider (tree derived, tree binfo, tree fn)
1989 {
1990   find_final_overrider_data ffod;
1991
1992   /* Getting this right is a little tricky.  This is valid:
1993
1994        struct S { virtual void f (); };
1995        struct T { virtual void f (); };
1996        struct U : public S, public T { };
1997
1998      even though calling `f' in `U' is ambiguous.  But,
1999
2000        struct R { virtual void f(); };
2001        struct S : virtual public R { virtual void f (); };
2002        struct T : virtual public R { virtual void f (); };
2003        struct U : public S, public T { };
2004
2005      is not -- there's no way to decide whether to put `S::f' or
2006      `T::f' in the vtable for `R'.
2007
2008      The solution is to look at all paths to BINFO.  If we find
2009      different overriders along any two, then there is a problem.  */
2010   if (DECL_THUNK_P (fn))
2011     fn = THUNK_TARGET (fn);
2012
2013   /* Determine the depth of the hierarchy.  */
2014   ffod.fn = fn;
2015   ffod.declaring_base = binfo;
2016   ffod.candidates = NULL_TREE;
2017   ffod.path = VEC_alloc (tree, heap, 30);
2018
2019   dfs_walk_all (derived, dfs_find_final_overrider_pre,
2020                 dfs_find_final_overrider_post, &ffod);
2021
2022   VEC_free (tree, heap, ffod.path);
2023
2024   /* If there was no winner, issue an error message.  */
2025   if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2026     return error_mark_node;
2027
2028   return ffod.candidates;
2029 }
2030
2031 /* Return the index of the vcall offset for FN when TYPE is used as a
2032    virtual base.  */
2033
2034 static tree
2035 get_vcall_index (tree fn, tree type)
2036 {
2037   VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type);
2038   tree_pair_p p;
2039   unsigned ix;
2040
2041   for (ix = 0; VEC_iterate (tree_pair_s, indices, ix, p); ix++)
2042     if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2043         || same_signature_p (fn, p->purpose))
2044       return p->value;
2045
2046   /* There should always be an appropriate index.  */
2047   gcc_unreachable ();
2048 }
2049
2050 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2051    dominated by T.  FN has been overridden in BINFO; VIRTUALS points to the
2052    corresponding position in the BINFO_VIRTUALS list.  */
2053
2054 static void
2055 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2056                             unsigned ix)
2057 {
2058   tree b;
2059   tree overrider;
2060   tree delta;
2061   tree virtual_base;
2062   tree first_defn;
2063   tree overrider_fn, overrider_target;
2064   tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2065   tree over_return, base_return;
2066   bool lost = false;
2067
2068   /* Find the nearest primary base (possibly binfo itself) which defines
2069      this function; this is the class the caller will convert to when
2070      calling FN through BINFO.  */
2071   for (b = binfo; ; b = get_primary_binfo (b))
2072     {
2073       gcc_assert (b);
2074       if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2075         break;
2076
2077       /* The nearest definition is from a lost primary.  */
2078       if (BINFO_LOST_PRIMARY_P (b))
2079         lost = true;
2080     }
2081   first_defn = b;
2082
2083   /* Find the final overrider.  */
2084   overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2085   if (overrider == error_mark_node)
2086     {
2087       error ("no unique final overrider for %qD in %qT", target_fn, t);
2088       return;
2089     }
2090   overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2091
2092   /* Check for adjusting covariant return types.  */
2093   over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2094   base_return = TREE_TYPE (TREE_TYPE (target_fn));
2095
2096   if (POINTER_TYPE_P (over_return)
2097       && TREE_CODE (over_return) == TREE_CODE (base_return)
2098       && CLASS_TYPE_P (TREE_TYPE (over_return))
2099       && CLASS_TYPE_P (TREE_TYPE (base_return))
2100       /* If the overrider is invalid, don't even try.  */
2101       && !DECL_INVALID_OVERRIDER_P (overrider_target))
2102     {
2103       /* If FN is a covariant thunk, we must figure out the adjustment
2104          to the final base FN was converting to. As OVERRIDER_TARGET might
2105          also be converting to the return type of FN, we have to
2106          combine the two conversions here.  */
2107       tree fixed_offset, virtual_offset;
2108
2109       over_return = TREE_TYPE (over_return);
2110       base_return = TREE_TYPE (base_return);
2111
2112       if (DECL_THUNK_P (fn))
2113         {
2114           gcc_assert (DECL_RESULT_THUNK_P (fn));
2115           fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2116           virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2117         }
2118       else
2119         fixed_offset = virtual_offset = NULL_TREE;
2120
2121       if (virtual_offset)
2122         /* Find the equivalent binfo within the return type of the
2123            overriding function. We will want the vbase offset from
2124            there.  */
2125         virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2126                                           over_return);
2127       else if (!same_type_ignoring_top_level_qualifiers_p
2128                (over_return, base_return))
2129         {
2130           /* There was no existing virtual thunk (which takes
2131              precedence).  So find the binfo of the base function's
2132              return type within the overriding function's return type.
2133              We cannot call lookup base here, because we're inside a
2134              dfs_walk, and will therefore clobber the BINFO_MARKED
2135              flags.  Fortunately we know the covariancy is valid (it
2136              has already been checked), so we can just iterate along
2137              the binfos, which have been chained in inheritance graph
2138              order.  Of course it is lame that we have to repeat the
2139              search here anyway -- we should really be caching pieces
2140              of the vtable and avoiding this repeated work.  */
2141           tree thunk_binfo, base_binfo;
2142
2143           /* Find the base binfo within the overriding function's
2144              return type.  We will always find a thunk_binfo, except
2145              when the covariancy is invalid (which we will have
2146              already diagnosed).  */
2147           for (base_binfo = TYPE_BINFO (base_return),
2148                thunk_binfo = TYPE_BINFO (over_return);
2149                thunk_binfo;
2150                thunk_binfo = TREE_CHAIN (thunk_binfo))
2151             if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
2152                                    BINFO_TYPE (base_binfo)))
2153               break;
2154
2155           /* See if virtual inheritance is involved.  */
2156           for (virtual_offset = thunk_binfo;
2157                virtual_offset;
2158                virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2159             if (BINFO_VIRTUAL_P (virtual_offset))
2160               break;
2161
2162           if (virtual_offset
2163               || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2164             {
2165               tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2166
2167               if (virtual_offset)
2168                 {
2169                   /* We convert via virtual base.  Adjust the fixed
2170                      offset to be from there.  */
2171                   offset = 
2172                     size_diffop (offset,
2173                                  convert (ssizetype,
2174                                           BINFO_OFFSET (virtual_offset)));
2175                 }
2176               if (fixed_offset)
2177                 /* There was an existing fixed offset, this must be
2178                    from the base just converted to, and the base the
2179                    FN was thunking to.  */
2180                 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2181               else
2182                 fixed_offset = offset;
2183             }
2184         }
2185
2186       if (fixed_offset || virtual_offset)
2187         /* Replace the overriding function with a covariant thunk.  We
2188            will emit the overriding function in its own slot as
2189            well.  */
2190         overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2191                                    fixed_offset, virtual_offset);
2192     }
2193   else
2194     gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) ||
2195                 !DECL_THUNK_P (fn));
2196
2197   /* Assume that we will produce a thunk that convert all the way to
2198      the final overrider, and not to an intermediate virtual base.  */
2199   virtual_base = NULL_TREE;
2200
2201   /* See if we can convert to an intermediate virtual base first, and then
2202      use the vcall offset located there to finish the conversion.  */
2203   for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2204     {
2205       /* If we find the final overrider, then we can stop
2206          walking.  */
2207       if (SAME_BINFO_TYPE_P (BINFO_TYPE (b),
2208                              BINFO_TYPE (TREE_VALUE (overrider))))
2209         break;
2210
2211       /* If we find a virtual base, and we haven't yet found the
2212          overrider, then there is a virtual base between the
2213          declaring base (first_defn) and the final overrider.  */
2214       if (BINFO_VIRTUAL_P (b))
2215         {
2216           virtual_base = b;
2217           break;
2218         }
2219     }
2220
2221   if (overrider_fn != overrider_target && !virtual_base)
2222     {
2223       /* The ABI specifies that a covariant thunk includes a mangling
2224          for a this pointer adjustment.  This-adjusting thunks that
2225          override a function from a virtual base have a vcall
2226          adjustment.  When the virtual base in question is a primary
2227          virtual base, we know the adjustments are zero, (and in the
2228          non-covariant case, we would not use the thunk).
2229          Unfortunately we didn't notice this could happen, when
2230          designing the ABI and so never mandated that such a covariant
2231          thunk should be emitted.  Because we must use the ABI mandated
2232          name, we must continue searching from the binfo where we
2233          found the most recent definition of the function, towards the
2234          primary binfo which first introduced the function into the
2235          vtable.  If that enters a virtual base, we must use a vcall
2236          this-adjusting thunk.  Bleah! */
2237       tree probe = first_defn;
2238
2239       while ((probe = get_primary_binfo (probe))
2240              && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2241         if (BINFO_VIRTUAL_P (probe))
2242           virtual_base = probe;
2243
2244       if (virtual_base)
2245         /* Even if we find a virtual base, the correct delta is
2246            between the overrider and the binfo we're building a vtable
2247            for.  */
2248         goto virtual_covariant;
2249     }
2250
2251   /* Compute the constant adjustment to the `this' pointer.  The
2252      `this' pointer, when this function is called, will point at BINFO
2253      (or one of its primary bases, which are at the same offset).  */
2254   if (virtual_base)
2255     /* The `this' pointer needs to be adjusted from the declaration to
2256        the nearest virtual base.  */
2257     delta = size_diffop_loc (input_location,
2258                          convert (ssizetype, BINFO_OFFSET (virtual_base)),
2259                          convert (ssizetype, BINFO_OFFSET (first_defn)));
2260   else if (lost)
2261     /* If the nearest definition is in a lost primary, we don't need an
2262        entry in our vtable.  Except possibly in a constructor vtable,
2263        if we happen to get our primary back.  In that case, the offset
2264        will be zero, as it will be a primary base.  */
2265     delta = size_zero_node;
2266   else
2267     /* The `this' pointer needs to be adjusted from pointing to
2268        BINFO to pointing at the base where the final overrider
2269        appears.  */
2270     virtual_covariant:
2271     delta = size_diffop_loc (input_location,
2272                          convert (ssizetype,
2273                                   BINFO_OFFSET (TREE_VALUE (overrider))),
2274                          convert (ssizetype, BINFO_OFFSET (binfo)));
2275
2276   modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2277
2278   if (virtual_base)
2279     BV_VCALL_INDEX (*virtuals)
2280       = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2281   else
2282     BV_VCALL_INDEX (*virtuals) = NULL_TREE;
2283 }
2284
2285 /* Called from modify_all_vtables via dfs_walk.  */
2286
2287 static tree
2288 dfs_modify_vtables (tree binfo, void* data)
2289 {
2290   tree t = (tree) data;
2291   tree virtuals;
2292   tree old_virtuals;
2293   unsigned ix;
2294
2295   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2296     /* A base without a vtable needs no modification, and its bases
2297        are uninteresting.  */
2298     return dfs_skip_bases;
2299
2300   if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)
2301       && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2302     /* Don't do the primary vtable, if it's new.  */
2303     return NULL_TREE;
2304
2305   if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo))
2306     /* There's no need to modify the vtable for a non-virtual primary
2307        base; we're not going to use that vtable anyhow.  We do still
2308        need to do this for virtual primary bases, as they could become
2309        non-primary in a construction vtable.  */
2310     return NULL_TREE;
2311
2312   make_new_vtable (t, binfo);
2313
2314   /* Now, go through each of the virtual functions in the virtual
2315      function table for BINFO.  Find the final overrider, and update
2316      the BINFO_VIRTUALS list appropriately.  */
2317   for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2318          old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2319        virtuals;
2320        ix++, virtuals = TREE_CHAIN (virtuals),
2321          old_virtuals = TREE_CHAIN (old_virtuals))
2322     update_vtable_entry_for_fn (t,
2323                                 binfo,
2324                                 BV_FN (old_virtuals),
2325                                 &virtuals, ix);
2326
2327   return NULL_TREE;
2328 }
2329
2330 /* Update all of the primary and secondary vtables for T.  Create new
2331    vtables as required, and initialize their RTTI information.  Each
2332    of the functions in VIRTUALS is declared in T and may override a
2333    virtual function from a base class; find and modify the appropriate
2334    entries to point to the overriding functions.  Returns a list, in
2335    declaration order, of the virtual functions that are declared in T,
2336    but do not appear in the primary base class vtable, and which
2337    should therefore be appended to the end of the vtable for T.  */
2338
2339 static tree
2340 modify_all_vtables (tree t, tree virtuals)
2341 {
2342   tree binfo = TYPE_BINFO (t);
2343   tree *fnsp;
2344
2345   /* Update all of the vtables.  */
2346   dfs_walk_once (binfo, dfs_modify_vtables, NULL, t);
2347
2348   /* Add virtual functions not already in our primary vtable. These
2349      will be both those introduced by this class, and those overridden
2350      from secondary bases.  It does not include virtuals merely
2351      inherited from secondary bases.  */
2352   for (fnsp = &virtuals; *fnsp; )
2353     {
2354       tree fn = TREE_VALUE (*fnsp);
2355
2356       if (!value_member (fn, BINFO_VIRTUALS (binfo))
2357           || DECL_VINDEX (fn) == error_mark_node)
2358         {
2359           /* We don't need to adjust the `this' pointer when
2360              calling this function.  */
2361           BV_DELTA (*fnsp) = integer_zero_node;
2362           BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2363
2364           /* This is a function not already in our vtable.  Keep it.  */
2365           fnsp = &TREE_CHAIN (*fnsp);
2366         }
2367       else
2368         /* We've already got an entry for this function.  Skip it.  */
2369         *fnsp = TREE_CHAIN (*fnsp);
2370     }
2371
2372   return virtuals;
2373 }
2374
2375 /* Get the base virtual function declarations in T that have the
2376    indicated NAME.  */
2377
2378 static tree
2379 get_basefndecls (tree name, tree t)
2380 {
2381   tree methods;
2382   tree base_fndecls = NULL_TREE;
2383   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2384   int i;
2385
2386   /* Find virtual functions in T with the indicated NAME.  */
2387   i = lookup_fnfields_1 (t, name);
2388   if (i != -1)
2389     for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2390          methods;
2391          methods = OVL_NEXT (methods))
2392       {
2393         tree method = OVL_CURRENT (methods);
2394
2395         if (TREE_CODE (method) == FUNCTION_DECL
2396             && DECL_VINDEX (method))
2397           base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2398       }
2399
2400   if (base_fndecls)
2401     return base_fndecls;
2402
2403   for (i = 0; i < n_baseclasses; i++)
2404     {
2405       tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2406       base_fndecls = chainon (get_basefndecls (name, basetype),
2407                               base_fndecls);
2408     }
2409
2410   return base_fndecls;
2411 }
2412
2413 /* If this declaration supersedes the declaration of
2414    a method declared virtual in the base class, then
2415    mark this field as being virtual as well.  */
2416
2417 void
2418 check_for_override (tree decl, tree ctype)
2419 {
2420   if (TREE_CODE (decl) == TEMPLATE_DECL)
2421     /* In [temp.mem] we have:
2422
2423          A specialization of a member function template does not
2424          override a virtual function from a base class.  */
2425     return;
2426   if ((DECL_DESTRUCTOR_P (decl)
2427        || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2428        || DECL_CONV_FN_P (decl))
2429       && look_for_overrides (ctype, decl)
2430       && !DECL_STATIC_FUNCTION_P (decl))
2431     /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2432        the error_mark_node so that we know it is an overriding
2433        function.  */
2434     DECL_VINDEX (decl) = decl;
2435
2436   if (DECL_VIRTUAL_P (decl))
2437     {
2438       if (!DECL_VINDEX (decl))
2439         DECL_VINDEX (decl) = error_mark_node;
2440       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2441     }
2442 }
2443
2444 /* Warn about hidden virtual functions that are not overridden in t.
2445    We know that constructors and destructors don't apply.  */
2446
2447 static void
2448 warn_hidden (tree t)
2449 {
2450   VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t);
2451   tree fns;
2452   size_t i;
2453
2454   /* We go through each separately named virtual function.  */
2455   for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2456        VEC_iterate (tree, method_vec, i, fns);
2457        ++i)
2458     {
2459       tree fn;
2460       tree name;
2461       tree fndecl;
2462       tree base_fndecls;
2463       tree base_binfo;
2464       tree binfo;
2465       int j;
2466
2467       /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2468          have the same name.  Figure out what name that is.  */
2469       name = DECL_NAME (OVL_CURRENT (fns));
2470       /* There are no possibly hidden functions yet.  */
2471       base_fndecls = NULL_TREE;
2472       /* Iterate through all of the base classes looking for possibly
2473          hidden functions.  */
2474       for (binfo = TYPE_BINFO (t), j = 0;
2475            BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2476         {
2477           tree basetype = BINFO_TYPE (base_binfo);
2478           base_fndecls = chainon (get_basefndecls (name, basetype),
2479                                   base_fndecls);
2480         }
2481
2482       /* If there are no functions to hide, continue.  */
2483       if (!base_fndecls)
2484         continue;
2485
2486       /* Remove any overridden functions.  */
2487       for (fn = fns; fn; fn = OVL_NEXT (fn))
2488         {
2489           fndecl = OVL_CURRENT (fn);
2490           if (DECL_VINDEX (fndecl))
2491             {
2492               tree *prev = &base_fndecls;
2493
2494               while (*prev)
2495                 /* If the method from the base class has the same
2496                    signature as the method from the derived class, it
2497                    has been overridden.  */
2498                 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2499                   *prev = TREE_CHAIN (*prev);
2500                 else
2501                   prev = &TREE_CHAIN (*prev);
2502             }
2503         }
2504
2505       /* Now give a warning for all base functions without overriders,
2506          as they are hidden.  */
2507       while (base_fndecls)
2508         {
2509           /* Here we know it is a hider, and no overrider exists.  */
2510           warning (OPT_Woverloaded_virtual, "%q+D was hidden", TREE_VALUE (base_fndecls));
2511           warning (OPT_Woverloaded_virtual, "  by %q+D", fns);
2512           base_fndecls = TREE_CHAIN (base_fndecls);
2513         }
2514     }
2515 }
2516
2517 /* Check for things that are invalid.  There are probably plenty of other
2518    things we should check for also.  */
2519
2520 static void
2521 finish_struct_anon (tree t)
2522 {
2523   tree field;
2524
2525   for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2526     {
2527       if (TREE_STATIC (field))
2528         continue;
2529       if (TREE_CODE (field) != FIELD_DECL)
2530         continue;
2531
2532       if (DECL_NAME (field) == NULL_TREE
2533           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2534         {
2535           bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
2536           tree elt = TYPE_FIELDS (TREE_TYPE (field));
2537           for (; elt; elt = TREE_CHAIN (elt))
2538             {
2539               /* We're generally only interested in entities the user
2540                  declared, but we also find nested classes by noticing
2541                  the TYPE_DECL that we create implicitly.  You're
2542                  allowed to put one anonymous union inside another,
2543                  though, so we explicitly tolerate that.  We use
2544                  TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2545                  we also allow unnamed types used for defining fields.  */
2546               if (DECL_ARTIFICIAL (elt)
2547                   && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2548                       || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2549                 continue;
2550
2551               if (TREE_CODE (elt) != FIELD_DECL)
2552                 {
2553                   if (is_union)
2554                     permerror (input_location, "%q+#D invalid; an anonymous union can "
2555                                "only have non-static data members", elt);
2556                   else
2557                     permerror (input_location, "%q+#D invalid; an anonymous struct can "
2558                                "only have non-static data members", elt);
2559                   continue;
2560                 }
2561
2562               if (TREE_PRIVATE (elt))
2563                 {
2564                   if (is_union)
2565                     permerror (input_location, "private member %q+#D in anonymous union", elt);
2566                   else
2567                     permerror (input_location, "private member %q+#D in anonymous struct", elt);
2568                 }
2569               else if (TREE_PROTECTED (elt))
2570                 {
2571                   if (is_union)
2572                     permerror (input_location, "protected member %q+#D in anonymous union", elt);
2573                   else
2574                     permerror (input_location, "protected member %q+#D in anonymous struct", elt);
2575                 }
2576
2577               TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2578               TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2579             }
2580         }
2581     }
2582 }
2583
2584 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2585    will be used later during class template instantiation.
2586    When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2587    a non-static member data (FIELD_DECL), a member function
2588    (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2589    a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2590    When FRIEND_P is nonzero, T is either a friend class
2591    (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2592    (FUNCTION_DECL, TEMPLATE_DECL).  */
2593
2594 void
2595 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2596 {
2597   /* Save some memory by not creating TREE_LIST if TYPE is not template.  */
2598   if (CLASSTYPE_TEMPLATE_INFO (type))
2599     CLASSTYPE_DECL_LIST (type)
2600       = tree_cons (friend_p ? NULL_TREE : type,
2601                    t, CLASSTYPE_DECL_LIST (type));
2602 }
2603
2604 /* Create default constructors, assignment operators, and so forth for
2605    the type indicated by T, if they are needed.  CANT_HAVE_CONST_CTOR,
2606    and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2607    the class cannot have a default constructor, copy constructor
2608    taking a const reference argument, or an assignment operator taking
2609    a const reference, respectively.  */
2610
2611 static void
2612 add_implicitly_declared_members (tree t,
2613                                  int cant_have_const_cctor,
2614                                  int cant_have_const_assignment)
2615 {
2616   /* Destructor.  */
2617   if (!CLASSTYPE_DESTRUCTORS (t))
2618     {
2619       /* In general, we create destructors lazily.  */
2620       CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
2621       /* However, if the implicit destructor is non-trivial
2622          destructor, we sometimes have to create it at this point.  */
2623       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
2624         {
2625           bool lazy_p = true;
2626
2627           if (TYPE_FOR_JAVA (t))
2628             /* If this a Java class, any non-trivial destructor is
2629                invalid, even if compiler-generated.  Therefore, if the
2630                destructor is non-trivial we create it now.  */
2631             lazy_p = false;
2632           else
2633             {
2634               tree binfo;
2635               tree base_binfo;
2636               int ix;
2637
2638               /* If the implicit destructor will be virtual, then we must
2639                  generate it now because (unfortunately) we do not
2640                  generate virtual tables lazily.  */
2641               binfo = TYPE_BINFO (t);
2642               for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2643                 {
2644                   tree base_type;
2645                   tree dtor;
2646
2647                   base_type = BINFO_TYPE (base_binfo);
2648                   dtor = CLASSTYPE_DESTRUCTORS (base_type);
2649                   if (dtor && DECL_VIRTUAL_P (dtor))
2650                     {
2651                       lazy_p = false;
2652                       break;
2653                     }
2654                 }
2655             }
2656
2657           /* If we can't get away with being lazy, generate the destructor
2658              now.  */
2659           if (!lazy_p)
2660             lazily_declare_fn (sfk_destructor, t);
2661         }
2662     }
2663
2664   /* [class.ctor]
2665
2666      If there is no user-declared constructor for a class, a default
2667      constructor is implicitly declared.  */
2668   if (! TYPE_HAS_USER_CONSTRUCTOR (t))
2669     {
2670       TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2671       CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2672     }
2673
2674   /* [class.ctor]
2675
2676      If a class definition does not explicitly declare a copy
2677      constructor, one is declared implicitly.  */
2678   if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2679     {
2680       TYPE_HAS_INIT_REF (t) = 1;
2681       TYPE_HAS_CONST_INIT_REF (t) = !cant_have_const_cctor;
2682       CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2683     }
2684
2685   /* Currently only lambdas get a lazy move ctor, but N2987 adds them for
2686      other classes.  */
2687   if (LAMBDA_TYPE_P (t))
2688     CLASSTYPE_LAZY_MOVE_CTOR (t) = 1;
2689
2690   /* If there is no assignment operator, one will be created if and
2691      when it is needed.  For now, just record whether or not the type
2692      of the parameter to the assignment operator will be a const or
2693      non-const reference.  */
2694   if (!TYPE_HAS_ASSIGN_REF (t) && !TYPE_FOR_JAVA (t))
2695     {
2696       TYPE_HAS_ASSIGN_REF (t) = 1;
2697       TYPE_HAS_CONST_ASSIGN_REF (t) = !cant_have_const_assignment;
2698       CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 1;
2699     }
2700 }
2701
2702 /* Subroutine of finish_struct_1.  Recursively count the number of fields
2703    in TYPE, including anonymous union members.  */
2704
2705 static int
2706 count_fields (tree fields)
2707 {
2708   tree x;
2709   int n_fields = 0;
2710   for (x = fields; x; x = TREE_CHAIN (x))
2711     {
2712       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2713         n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2714       else
2715         n_fields += 1;
2716     }
2717   return n_fields;
2718 }
2719
2720 /* Subroutine of finish_struct_1.  Recursively add all the fields in the
2721    TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX.  */
2722
2723 static int
2724 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2725 {
2726   tree x;
2727   for (x = fields; x; x = TREE_CHAIN (x))
2728     {
2729       if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2730         idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2731       else
2732         field_vec->elts[idx++] = x;
2733     }
2734   return idx;
2735 }
2736
2737 /* FIELD is a bit-field.  We are finishing the processing for its
2738    enclosing type.  Issue any appropriate messages and set appropriate
2739    flags.  Returns false if an error has been diagnosed.  */
2740
2741 static bool
2742 check_bitfield_decl (tree field)
2743 {
2744   tree type = TREE_TYPE (field);
2745   tree w;
2746
2747   /* Extract the declared width of the bitfield, which has been
2748      temporarily stashed in DECL_INITIAL.  */
2749   w = DECL_INITIAL (field);
2750   gcc_assert (w != NULL_TREE);
2751   /* Remove the bit-field width indicator so that the rest of the
2752      compiler does not treat that value as an initializer.  */
2753   DECL_INITIAL (field) = NULL_TREE;
2754
2755   /* Detect invalid bit-field type.  */
2756   if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2757     {
2758       error ("bit-field %q+#D with non-integral type", field);
2759       w = error_mark_node;
2760     }
2761   else
2762     {
2763       /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs.  */
2764       STRIP_NOPS (w);
2765
2766       /* detect invalid field size.  */
2767       w = integral_constant_value (w);
2768
2769       if (TREE_CODE (w) != INTEGER_CST)
2770         {
2771           error ("bit-field %q+D width not an integer constant", field);
2772           w = error_mark_node;
2773         }
2774       else if (tree_int_cst_sgn (w) < 0)
2775         {
2776           error ("negative width in bit-field %q+D", field);
2777           w = error_mark_node;
2778         }
2779       else if (integer_zerop (w) && DECL_NAME (field) != 0)
2780         {
2781           error ("zero width for bit-field %q+D", field);
2782           w = error_mark_node;
2783         }
2784       else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2785                && TREE_CODE (type) != ENUMERAL_TYPE
2786                && TREE_CODE (type) != BOOLEAN_TYPE)
2787         warning (0, "width of %q+D exceeds its type", field);
2788       else if (TREE_CODE (type) == ENUMERAL_TYPE
2789                && (0 > (compare_tree_int
2790                         (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
2791         warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2792     }
2793
2794   if (w != error_mark_node)
2795     {
2796       DECL_SIZE (field) = convert (bitsizetype, w);
2797       DECL_BIT_FIELD (field) = 1;
2798       return true;
2799     }
2800   else
2801     {
2802       /* Non-bit-fields are aligned for their type.  */
2803       DECL_BIT_FIELD (field) = 0;
2804       CLEAR_DECL_C_BIT_FIELD (field);
2805       return false;
2806     }
2807 }
2808
2809 /* FIELD is a non bit-field.  We are finishing the processing for its
2810    enclosing type T.  Issue any appropriate messages and set appropriate
2811    flags.  */
2812
2813 static void
2814 check_field_decl (tree field,
2815                   tree t,
2816                   int* cant_have_const_ctor,
2817                   int* no_const_asn_ref,
2818                   int* any_default_members)
2819 {
2820   tree type = strip_array_types (TREE_TYPE (field));
2821
2822   /* An anonymous union cannot contain any fields which would change
2823      the settings of CANT_HAVE_CONST_CTOR and friends.  */
2824   if (ANON_UNION_TYPE_P (type))
2825     ;
2826   /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2827      structs.  So, we recurse through their fields here.  */
2828   else if (ANON_AGGR_TYPE_P (type))
2829     {
2830       tree fields;
2831
2832       for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2833         if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2834           check_field_decl (fields, t, cant_have_const_ctor,
2835                             no_const_asn_ref, any_default_members);
2836     }
2837   /* Check members with class type for constructors, destructors,
2838      etc.  */
2839   else if (CLASS_TYPE_P (type))
2840     {
2841       /* Never let anything with uninheritable virtuals
2842          make it through without complaint.  */
2843       abstract_virtuals_error (field, type);
2844
2845       if (TREE_CODE (t) == UNION_TYPE)
2846         {
2847           if (TYPE_NEEDS_CONSTRUCTING (type))
2848             error ("member %q+#D with constructor not allowed in union",
2849                    field);
2850           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2851             error ("member %q+#D with destructor not allowed in union", field);
2852           if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2853             error ("member %q+#D with copy assignment operator not allowed in union",
2854                    field);
2855         }
2856       else
2857         {
2858           TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2859           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2860             |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2861           TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2862           TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2863           TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (type);
2864         }
2865
2866       if (!TYPE_HAS_CONST_INIT_REF (type))
2867         *cant_have_const_ctor = 1;
2868
2869       if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2870         *no_const_asn_ref = 1;
2871     }
2872   if (DECL_INITIAL (field) != NULL_TREE)
2873     {
2874       /* `build_class_init_list' does not recognize
2875          non-FIELD_DECLs.  */
2876       if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2877         error ("multiple fields in union %qT initialized", t);
2878       *any_default_members = 1;
2879     }
2880 }
2881
2882 /* Check the data members (both static and non-static), class-scoped
2883    typedefs, etc., appearing in the declaration of T.  Issue
2884    appropriate diagnostics.  Sets ACCESS_DECLS to a list (in
2885    declaration order) of access declarations; each TREE_VALUE in this
2886    list is a USING_DECL.
2887
2888    In addition, set the following flags:
2889
2890      EMPTY_P
2891        The class is empty, i.e., contains no non-static data members.
2892
2893      CANT_HAVE_CONST_CTOR_P
2894        This class cannot have an implicitly generated copy constructor
2895        taking a const reference.
2896
2897      CANT_HAVE_CONST_ASN_REF
2898        This class cannot have an implicitly generated assignment
2899        operator taking a const reference.
2900
2901    All of these flags should be initialized before calling this
2902    function.
2903
2904    Returns a pointer to the end of the TYPE_FIELDs chain; additional
2905    fields can be added by adding to this chain.  */
2906
2907 static void
2908 check_field_decls (tree t, tree *access_decls,
2909                    int *cant_have_const_ctor_p,
2910                    int *no_const_asn_ref_p)
2911 {
2912   tree *field;
2913   tree *next;
2914   bool has_pointers;
2915   int any_default_members;
2916   int cant_pack = 0;
2917   int field_access = -1;
2918
2919   /* Assume there are no access declarations.  */
2920   *access_decls = NULL_TREE;
2921   /* Assume this class has no pointer members.  */
2922   has_pointers = false;
2923   /* Assume none of the members of this class have default
2924      initializations.  */
2925   any_default_members = 0;
2926
2927   for (field = &TYPE_FIELDS (t); *field; field = next)
2928     {
2929       tree x = *field;
2930       tree type = TREE_TYPE (x);
2931       int this_field_access;
2932
2933       next = &TREE_CHAIN (x);
2934
2935       if (TREE_CODE (x) == USING_DECL)
2936         {
2937           /* Prune the access declaration from the list of fields.  */
2938           *field = TREE_CHAIN (x);
2939
2940           /* Save the access declarations for our caller.  */
2941           *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2942
2943           /* Since we've reset *FIELD there's no reason to skip to the
2944              next field.  */
2945           next = field;
2946           continue;
2947         }
2948
2949       if (TREE_CODE (x) == TYPE_DECL
2950           || TREE_CODE (x) == TEMPLATE_DECL)
2951         continue;
2952
2953       /* If we've gotten this far, it's a data member, possibly static,
2954          or an enumerator.  */
2955       DECL_CONTEXT (x) = t;
2956
2957       /* When this goes into scope, it will be a non-local reference.  */
2958       DECL_NONLOCAL (x) = 1;
2959
2960       if (TREE_CODE (t) == UNION_TYPE)
2961         {
2962           /* [class.union]
2963
2964              If a union contains a static data member, or a member of
2965              reference type, the program is ill-formed.  */
2966           if (TREE_CODE (x) == VAR_DECL)
2967             {
2968               error ("%q+D may not be static because it is a member of a union", x);
2969               continue;
2970             }
2971           if (TREE_CODE (type) == REFERENCE_TYPE)
2972             {
2973               error ("%q+D may not have reference type %qT because"
2974                      " it is a member of a union",
2975                      x, type);
2976               continue;
2977             }
2978         }
2979
2980       /* Perform error checking that did not get done in
2981          grokdeclarator.  */
2982       if (TREE_CODE (type) == FUNCTION_TYPE)
2983         {
2984           error ("field %q+D invalidly declared function type", x);
2985           type = build_pointer_type (type);
2986           TREE_TYPE (x) = type;
2987         }
2988       else if (TREE_CODE (type) == METHOD_TYPE)
2989         {
2990           error ("field %q+D invalidly declared method type", x);
2991           type = build_pointer_type (type);
2992           TREE_TYPE (x) = type;
2993         }
2994
2995       if (type == error_mark_node)
2996         continue;
2997
2998       if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
2999         continue;
3000
3001       /* Now it can only be a FIELD_DECL.  */
3002
3003       if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3004         CLASSTYPE_NON_AGGREGATE (t) = 1;
3005
3006       /* A standard-layout class is a class that:
3007          ...
3008          has the same access control (Clause 11) for all non-static data members,
3009          ...  */
3010       this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0;
3011       if (field_access == -1)
3012         field_access = this_field_access;
3013       else if (this_field_access != field_access)
3014         CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3015
3016       /* If this is of reference type, check if it needs an init.  */
3017       if (TREE_CODE (type) == REFERENCE_TYPE)
3018         {
3019           CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3020           CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3021           if (DECL_INITIAL (x) == NULL_TREE)
3022             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3023
3024           /* ARM $12.6.2: [A member initializer list] (or, for an
3025              aggregate, initialization by a brace-enclosed list) is the
3026              only way to initialize nonstatic const and reference
3027              members.  */
3028           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3029         }
3030
3031       type = strip_array_types (type);
3032
3033       if (TYPE_PACKED (t))
3034         {
3035           if (!layout_pod_type_p (type) && !TYPE_PACKED (type))
3036             {
3037               warning
3038                 (0,
3039                  "ignoring packed attribute because of unpacked non-POD field %q+#D",
3040                  x);
3041               cant_pack = 1;
3042             }
3043           else if (DECL_C_BIT_FIELD (x)
3044                    || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
3045             DECL_PACKED (x) = 1;
3046         }
3047
3048       if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3049         /* We don't treat zero-width bitfields as making a class
3050            non-empty.  */
3051         ;
3052       else
3053         {
3054           /* The class is non-empty.  */
3055           CLASSTYPE_EMPTY_P (t) = 0;
3056           /* The class is not even nearly empty.  */
3057           CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3058           /* If one of the data members contains an empty class,
3059              so does T.  */
3060           if (CLASS_TYPE_P (type)
3061               && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3062             CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3063         }
3064
3065       /* This is used by -Weffc++ (see below). Warn only for pointers
3066          to members which might hold dynamic memory. So do not warn
3067          for pointers to functions or pointers to members.  */
3068       if (TYPE_PTR_P (type)
3069           && !TYPE_PTRFN_P (type)
3070           && !TYPE_PTR_TO_MEMBER_P (type))
3071         has_pointers = true;
3072
3073       if (CLASS_TYPE_P (type))
3074         {
3075           if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3076             SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3077           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3078             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3079         }
3080
3081       if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3082         CLASSTYPE_HAS_MUTABLE (t) = 1;
3083
3084       if (! layout_pod_type_p (type))
3085         /* DR 148 now allows pointers to members (which are POD themselves),
3086            to be allowed in POD structs.  */
3087         CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3088
3089       if (!std_layout_type_p (type))
3090         CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3091
3092       if (! zero_init_p (type))
3093         CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3094
3095       /* If any field is const, the structure type is pseudo-const.  */
3096       if (CP_TYPE_CONST_P (type))
3097         {
3098           C_TYPE_FIELDS_READONLY (t) = 1;
3099           if (DECL_INITIAL (x) == NULL_TREE)
3100             SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3101
3102           /* ARM $12.6.2: [A member initializer list] (or, for an
3103              aggregate, initialization by a brace-enclosed list) is the
3104              only way to initialize nonstatic const and reference
3105              members.  */
3106           TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3107         }
3108       /* A field that is pseudo-const makes the structure likewise.  */
3109       else if (CLASS_TYPE_P (type))
3110         {
3111           C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3112           SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3113             CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3114             | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3115         }
3116
3117       /* Core issue 80: A nonstatic data member is required to have a
3118          different name from the class iff the class has a
3119          user-declared constructor.  */
3120       if (constructor_name_p (DECL_NAME (x), t)
3121           && TYPE_HAS_USER_CONSTRUCTOR (t))
3122         permerror (input_location, "field %q+#D with same name as class", x);
3123
3124       /* We set DECL_C_BIT_FIELD in grokbitfield.
3125          If the type and width are valid, we'll also set DECL_BIT_FIELD.  */
3126       if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3127         check_field_decl (x, t,
3128                           cant_have_const_ctor_p,
3129                           no_const_asn_ref_p,
3130                           &any_default_members);
3131     }
3132
3133   /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3134      it should also define a copy constructor and an assignment operator to
3135      implement the correct copy semantic (deep vs shallow, etc.). As it is
3136      not feasible to check whether the constructors do allocate dynamic memory
3137      and store it within members, we approximate the warning like this:
3138
3139      -- Warn only if there are members which are pointers
3140      -- Warn only if there is a non-trivial constructor (otherwise,
3141         there cannot be memory allocated).
3142      -- Warn only if there is a non-trivial destructor. We assume that the
3143         user at least implemented the cleanup correctly, and a destructor
3144         is needed to free dynamic memory.
3145
3146      This seems enough for practical purposes.  */
3147   if (warn_ecpp
3148       && has_pointers
3149       && TYPE_HAS_USER_CONSTRUCTOR (t)
3150       && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3151       && !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3152     {
3153       warning (OPT_Weffc__, "%q#T has pointer data members", t);
3154
3155       if (! TYPE_HAS_INIT_REF (t))
3156         {
3157           warning (OPT_Weffc__,
3158                    "  but does not override %<%T(const %T&)%>", t, t);
3159           if (!TYPE_HAS_ASSIGN_REF (t))
3160             warning (OPT_Weffc__, "  or %<operator=(const %T&)%>", t);
3161         }
3162       else if (! TYPE_HAS_ASSIGN_REF (t))
3163         warning (OPT_Weffc__,
3164                  "  but does not override %<operator=(const %T&)%>", t);
3165     }
3166
3167   /* If any of the fields couldn't be packed, unset TYPE_PACKED.  */
3168   if (cant_pack)
3169     TYPE_PACKED (t) = 0;
3170
3171   /* Check anonymous struct/anonymous union fields.  */
3172   finish_struct_anon (t);
3173
3174   /* We've built up the list of access declarations in reverse order.
3175      Fix that now.  */
3176   *access_decls = nreverse (*access_decls);
3177 }
3178
3179 /* If TYPE is an empty class type, records its OFFSET in the table of
3180    OFFSETS.  */
3181
3182 static int
3183 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3184 {
3185   splay_tree_node n;
3186
3187   if (!is_empty_class (type))
3188     return 0;
3189
3190   /* Record the location of this empty object in OFFSETS.  */
3191   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3192   if (!n)
3193     n = splay_tree_insert (offsets,
3194                            (splay_tree_key) offset,
3195                            (splay_tree_value) NULL_TREE);
3196   n->value = ((splay_tree_value)
3197               tree_cons (NULL_TREE,
3198                          type,
3199                          (tree) n->value));
3200
3201   return 0;
3202 }
3203
3204 /* Returns nonzero if TYPE is an empty class type and there is
3205    already an entry in OFFSETS for the same TYPE as the same OFFSET.  */
3206
3207 static int
3208 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3209 {
3210   splay_tree_node n;
3211   tree t;
3212
3213   if (!is_empty_class (type))
3214     return 0;
3215
3216   /* Record the location of this empty object in OFFSETS.  */
3217   n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3218   if (!n)
3219     return 0;
3220
3221   for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3222     if (same_type_p (TREE_VALUE (t), type))
3223       return 1;
3224
3225   return 0;
3226 }
3227
3228 /* Walk through all the subobjects of TYPE (located at OFFSET).  Call
3229    F for every subobject, passing it the type, offset, and table of
3230    OFFSETS.  If VBASES_P is one, then virtual non-primary bases should
3231    be traversed.
3232
3233    If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3234    than MAX_OFFSET will not be walked.
3235
3236    If F returns a nonzero value, the traversal ceases, and that value
3237    is returned.  Otherwise, returns zero.  */
3238
3239 static int
3240 walk_subobject_offsets (tree type,
3241                         subobject_offset_fn f,
3242                         tree offset,
3243                         splay_tree offsets,
3244                         tree max_offset,
3245                         int vbases_p)
3246 {
3247   int r = 0;
3248   tree type_binfo = NULL_TREE;
3249
3250   /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3251      stop.  */
3252   if (max_offset && INT_CST_LT (max_offset, offset))
3253     return 0;
3254
3255   if (type == error_mark_node)
3256     return 0;
3257
3258   if (!TYPE_P (type))
3259     {
3260       if (abi_version_at_least (2))
3261         type_binfo = type;
3262       type = BINFO_TYPE (type);
3263     }
3264
3265   if (CLASS_TYPE_P (type))
3266     {
3267       tree field;
3268       tree binfo;
3269       int i;
3270
3271       /* Avoid recursing into objects that are not interesting.  */
3272       if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3273         return 0;
3274
3275       /* Record the location of TYPE.  */
3276       r = (*f) (type, offset, offsets);
3277       if (r)
3278         return r;
3279
3280       /* Iterate through the direct base classes of TYPE.  */
3281       if (!type_binfo)
3282         type_binfo = TYPE_BINFO (type);
3283       for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3284         {
3285           tree binfo_offset;
3286
3287           if (abi_version_at_least (2)
3288               && BINFO_VIRTUAL_P (binfo))
3289             continue;
3290
3291           if (!vbases_p
3292               && BINFO_VIRTUAL_P (binfo)
3293               && !BINFO_PRIMARY_P (binfo))
3294             continue;
3295
3296           if (!abi_version_at_least (2))
3297             binfo_offset = size_binop (PLUS_EXPR,
3298                                        offset,
3299                                        BINFO_OFFSET (binfo));
3300           else
3301             {
3302               tree orig_binfo;
3303               /* We cannot rely on BINFO_OFFSET being set for the base
3304                  class yet, but the offsets for direct non-virtual
3305                  bases can be calculated by going back to the TYPE.  */
3306               orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3307               binfo_offset = size_binop (PLUS_EXPR,
3308                                          offset,
3309                                          BINFO_OFFSET (orig_binfo));
3310             }
3311
3312           r = walk_subobject_offsets (binfo,
3313                                       f,
3314                                       binfo_offset,
3315                                       offsets,
3316                                       max_offset,
3317                                       (abi_version_at_least (2)
3318                                        ? /*vbases_p=*/0 : vbases_p));
3319           if (r)
3320             return r;
3321         }
3322
3323       if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3324         {
3325           unsigned ix;
3326           VEC(tree,gc) *vbases;
3327
3328           /* Iterate through the virtual base classes of TYPE.  In G++
3329              3.2, we included virtual bases in the direct base class
3330              loop above, which results in incorrect results; the
3331              correct offsets for virtual bases are only known when
3332              working with the most derived type.  */
3333           if (vbases_p)
3334             for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3335                  VEC_iterate (tree, vbases, ix, binfo); ix++)
3336               {
3337                 r = walk_subobject_offsets (binfo,
3338                                             f,
3339                                             size_binop (PLUS_EXPR,
3340                                                         offset,
3341                                                         BINFO_OFFSET (binfo)),
3342                                             offsets,
3343                                             max_offset,
3344                                             /*vbases_p=*/0);
3345                 if (r)
3346                   return r;
3347               }
3348           else
3349             {
3350               /* We still have to walk the primary base, if it is
3351                  virtual.  (If it is non-virtual, then it was walked
3352                  above.)  */
3353               tree vbase = get_primary_binfo (type_binfo);
3354
3355               if (vbase && BINFO_VIRTUAL_P (vbase)
3356                   && BINFO_PRIMARY_P (vbase)
3357                   && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3358                 {
3359                   r = (walk_subobject_offsets
3360                        (vbase, f, offset,
3361                         offsets, max_offset, /*vbases_p=*/0));
3362                   if (r)
3363                     return r;
3364                 }
3365             }
3366         }
3367
3368       /* Iterate through the fields of TYPE.  */
3369       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3370         if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3371           {
3372             tree field_offset;
3373
3374             if (abi_version_at_least (2))
3375               field_offset = byte_position (field);
3376             else
3377               /* In G++ 3.2, DECL_FIELD_OFFSET was used.  */
3378               field_offset = DECL_FIELD_OFFSET (field);
3379
3380             r = walk_subobject_offsets (TREE_TYPE (field),
3381                                         f,
3382                                         size_binop (PLUS_EXPR,
3383                                                     offset,
3384                                                     field_offset),
3385                                         offsets,
3386                                         max_offset,
3387                                         /*vbases_p=*/1);
3388             if (r)
3389               return r;
3390           }
3391     }
3392   else if (TREE_CODE (type) == ARRAY_TYPE)
3393     {
3394       tree element_type = strip_array_types (type);
3395       tree domain = TYPE_DOMAIN (type);
3396       tree index;
3397
3398       /* Avoid recursing into objects that are not interesting.  */
3399       if (!CLASS_TYPE_P (element_type)
3400           || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3401         return 0;
3402
3403       /* Step through each of the elements in the array.  */
3404       for (index = size_zero_node;
3405            /* G++ 3.2 had an off-by-one error here.  */
3406            (abi_version_at_least (2)
3407             ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3408             : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3409            index = size_binop (PLUS_EXPR, index, size_one_node))
3410         {
3411           r = walk_subobject_offsets (TREE_TYPE (type),
3412                                       f,
3413                                       offset,
3414                                       offsets,
3415                                       max_offset,
3416                                       /*vbases_p=*/1);
3417           if (r)
3418             return r;
3419           offset = size_binop (PLUS_EXPR, offset,
3420                                TYPE_SIZE_UNIT (TREE_TYPE (type)));
3421           /* If this new OFFSET is bigger than the MAX_OFFSET, then
3422              there's no point in iterating through the remaining
3423              elements of the array.  */
3424           if (max_offset && INT_CST_LT (max_offset, offset))
3425             break;
3426         }
3427     }
3428
3429   return 0;
3430 }
3431
3432 /* Record all of the empty subobjects of TYPE (either a type or a
3433    binfo).  If IS_DATA_MEMBER is true, then a non-static data member
3434    is being placed at OFFSET; otherwise, it is a base class that is
3435    being placed at OFFSET.  */
3436
3437 static void
3438 record_subobject_offsets (tree type,
3439                           tree offset,
3440                           splay_tree offsets,
3441                           bool is_data_member)
3442 {
3443   tree max_offset;
3444   /* If recording subobjects for a non-static data member or a
3445      non-empty base class , we do not need to record offsets beyond
3446      the size of the biggest empty class.  Additional data members
3447      will go at the end of the class.  Additional base classes will go
3448      either at offset zero (if empty, in which case they cannot
3449      overlap with offsets past the size of the biggest empty class) or
3450      at the end of the class.
3451
3452      However, if we are placing an empty base class, then we must record
3453      all offsets, as either the empty class is at offset zero (where
3454      other empty classes might later be placed) or at the end of the
3455      class (where other objects might then be placed, so other empty
3456      subobjects might later overlap).  */
3457   if (is_data_member
3458       || !is_empty_class (BINFO_TYPE (type)))
3459     max_offset = sizeof_biggest_empty_class;
3460   else
3461     max_offset = NULL_TREE;
3462   walk_subobject_offsets (type, record_subobject_offset, offset,
3463                           offsets, max_offset, is_data_member);
3464 }
3465
3466 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3467    OFFSET) conflict with entries in OFFSETS.  If VBASES_P is nonzero,
3468    virtual bases of TYPE are examined.  */
3469
3470 static int
3471 layout_conflict_p (tree type,
3472                    tree offset,
3473                    splay_tree offsets,
3474                    int vbases_p)
3475 {
3476   splay_tree_node max_node;
3477
3478   /* Get the node in OFFSETS that indicates the maximum offset where
3479      an empty subobject is located.  */
3480   max_node = splay_tree_max (offsets);
3481   /* If there aren't any empty subobjects, then there's no point in
3482      performing this check.  */
3483   if (!max_node)
3484     return 0;
3485
3486   return walk_subobject_offsets (type, check_subobject_offset, offset,
3487                                  offsets, (tree) (max_node->key),
3488                                  vbases_p);
3489 }
3490
3491 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3492    non-static data member of the type indicated by RLI.  BINFO is the
3493    binfo corresponding to the base subobject, OFFSETS maps offsets to
3494    types already located at those offsets.  This function determines
3495    the position of the DECL.  */
3496
3497 static void
3498 layout_nonempty_base_or_field (record_layout_info rli,
3499                                tree decl,
3500                                tree binfo,
3501                                splay_tree offsets)
3502 {
3503   tree offset = NULL_TREE;
3504   bool field_p;
3505   tree type;
3506
3507   if (binfo)
3508     {
3509       /* For the purposes of determining layout conflicts, we want to
3510          use the class type of BINFO; TREE_TYPE (DECL) will be the
3511          CLASSTYPE_AS_BASE version, which does not contain entries for
3512          zero-sized bases.  */
3513       type = TREE_TYPE (binfo);
3514       field_p = false;
3515     }
3516   else
3517     {
3518       type = TREE_TYPE (decl);
3519       field_p = true;
3520     }
3521
3522   /* Try to place the field.  It may take more than one try if we have
3523      a hard time placing the field without putting two objects of the
3524      same type at the same address.  */
3525   while (1)
3526     {
3527       struct record_layout_info_s old_rli = *rli;
3528
3529       /* Place this field.  */
3530       place_field (rli, decl);
3531       offset = byte_position (decl);
3532
3533       /* We have to check to see whether or not there is already
3534          something of the same type at the offset we're about to use.
3535          For example, consider:
3536
3537            struct S {};
3538            struct T : public S { int i; };
3539            struct U : public S, public T {};
3540
3541          Here, we put S at offset zero in U.  Then, we can't put T at
3542          offset zero -- its S component would be at the same address
3543          as the S we already allocated.  So, we have to skip ahead.
3544          Since all data members, including those whose type is an
3545          empty class, have nonzero size, any overlap can happen only
3546          with a direct or indirect base-class -- it can't happen with
3547          a data member.  */
3548       /* In a union, overlap is permitted; all members are placed at
3549          offset zero.  */
3550       if (TREE_CODE (rli->t) == UNION_TYPE)
3551         break;
3552       /* G++ 3.2 did not check for overlaps when placing a non-empty
3553          virtual base.  */
3554       if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3555         break;
3556       if (layout_conflict_p (field_p ? type : binfo, offset,
3557                              offsets, field_p))
3558         {
3559           /* Strip off the size allocated to this field.  That puts us
3560              at the first place we could have put the field with
3561              proper alignment.  */
3562           *rli = old_rli;
3563
3564           /* Bump up by the alignment required for the type.  */
3565           rli->bitpos
3566             = size_binop (PLUS_EXPR, rli->bitpos,
3567                           bitsize_int (binfo
3568                                        ? CLASSTYPE_ALIGN (type)
3569                                        : TYPE_ALIGN (type)));
3570           normalize_rli (rli);
3571         }
3572       else
3573         /* There was no conflict.  We're done laying out this field.  */
3574         break;
3575     }
3576
3577   /* Now that we know where it will be placed, update its
3578      BINFO_OFFSET.  */
3579   if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3580     /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3581        this point because their BINFO_OFFSET is copied from another
3582        hierarchy.  Therefore, we may not need to add the entire
3583        OFFSET.  */
3584     propagate_binfo_offsets (binfo,
3585                              size_diffop_loc (input_location,
3586                                           convert (ssizetype, offset),
3587                                           convert (ssizetype,
3588                                                    BINFO_OFFSET (binfo))));
3589 }
3590
3591 /* Returns true if TYPE is empty and OFFSET is nonzero.  */
3592
3593 static int
3594 empty_base_at_nonzero_offset_p (tree type,
3595                                 tree offset,
3596                                 splay_tree offsets ATTRIBUTE_UNUSED)
3597 {
3598   return is_empty_class (type) && !integer_zerop (offset);
3599 }
3600
3601 /* Layout the empty base BINFO.  EOC indicates the byte currently just
3602    past the end of the class, and should be correctly aligned for a
3603    class of the type indicated by BINFO; OFFSETS gives the offsets of
3604    the empty bases allocated so far. T is the most derived
3605    type.  Return nonzero iff we added it at the end.  */
3606
3607 static bool
3608 layout_empty_base (record_layout_info rli, tree binfo,
3609                    tree eoc, splay_tree offsets)
3610 {
3611   tree alignment;
3612   tree basetype = BINFO_TYPE (binfo);
3613   bool atend = false;
3614
3615   /* This routine should only be used for empty classes.  */
3616   gcc_assert (is_empty_class (basetype));
3617   alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3618
3619   if (!integer_zerop (BINFO_OFFSET (binfo)))
3620     {
3621       if (abi_version_at_least (2))
3622         propagate_binfo_offsets
3623           (binfo, size_diffop_loc (input_location,
3624                                size_zero_node, BINFO_OFFSET (binfo)));
3625       else
3626         warning (OPT_Wabi,
3627                  "offset of empty base %qT may not be ABI-compliant and may"
3628                  "change in a future version of GCC",
3629                  BINFO_TYPE (binfo));
3630     }
3631
3632   /* This is an empty base class.  We first try to put it at offset
3633      zero.  */
3634   if (layout_conflict_p (binfo,
3635                          BINFO_OFFSET (binfo),
3636                          offsets,
3637                          /*vbases_p=*/0))
3638     {
3639       /* That didn't work.  Now, we move forward from the next
3640          available spot in the class.  */
3641       atend = true;
3642       propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3643       while (1)
3644         {
3645           if (!layout_conflict_p (binfo,
3646                                   BINFO_OFFSET (binfo),
3647                                   offsets,
3648                                   /*vbases_p=*/0))
3649             /* We finally found a spot where there's no overlap.  */
3650             break;
3651
3652           /* There's overlap here, too.  Bump along to the next spot.  */
3653           propagate_binfo_offsets (binfo, alignment);
3654         }
3655     }
3656
3657   if (CLASSTYPE_USER_ALIGN (basetype))
3658     {
3659       rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3660       if (warn_packed)
3661         rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3662       TYPE_USER_ALIGN (rli->t) = 1;
3663     }
3664
3665   return atend;
3666 }
3667
3668 /* Layout the base given by BINFO in the class indicated by RLI.
3669    *BASE_ALIGN is a running maximum of the alignments of
3670    any base class.  OFFSETS gives the location of empty base
3671    subobjects.  T is the most derived type.  Return nonzero if the new
3672    object cannot be nearly-empty.  A new FIELD_DECL is inserted at
3673    *NEXT_FIELD, unless BINFO is for an empty base class.
3674
3675    Returns the location at which the next field should be inserted.  */
3676
3677 static tree *
3678 build_base_field (record_layout_info rli, tree binfo,
3679                   splay_tree offsets, tree *next_field)
3680 {
3681   tree t = rli->t;
3682   tree basetype = BINFO_TYPE (binfo);
3683
3684   if (!COMPLETE_TYPE_P (basetype))
3685     /* This error is now reported in xref_tag, thus giving better
3686        location information.  */
3687     return next_field;
3688
3689   /* Place the base class.  */
3690   if (!is_empty_class (basetype))
3691     {
3692       tree decl;
3693
3694       /* The containing class is non-empty because it has a non-empty
3695          base class.  */
3696       CLASSTYPE_EMPTY_P (t) = 0;
3697
3698       /* Create the FIELD_DECL.  */
3699       decl = build_decl (input_location,
3700                          FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3701       DECL_ARTIFICIAL (decl) = 1;
3702       DECL_IGNORED_P (decl) = 1;
3703       DECL_FIELD_CONTEXT (decl) = t;
3704       if (CLASSTYPE_AS_BASE (basetype))
3705         {
3706           DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3707           DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3708           DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3709           DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3710           DECL_MODE (decl) = TYPE_MODE (basetype);
3711           DECL_FIELD_IS_BASE (decl) = 1;
3712
3713           /* Try to place the field.  It may take more than one try if we
3714              have a hard time placing the field without putting two
3715              objects of the same type at the same address.  */
3716           layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3717           /* Add the new FIELD_DECL to the list of fields for T.  */
3718           TREE_CHAIN (decl) = *next_field;
3719           *next_field = decl;
3720           next_field = &TREE_CHAIN (decl);
3721         }
3722     }
3723   else
3724     {
3725       tree eoc;
3726       bool atend;
3727
3728       /* On some platforms (ARM), even empty classes will not be
3729          byte-aligned.  */
3730       eoc = round_up_loc (input_location,
3731                       rli_size_unit_so_far (rli),
3732                       CLASSTYPE_ALIGN_UNIT (basetype));
3733       atend = layout_empty_base (rli, binfo, eoc, offsets);
3734       /* A nearly-empty class "has no proper base class that is empty,
3735          not morally virtual, and at an offset other than zero."  */
3736       if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3737         {
3738           if (atend)
3739             CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3740           /* The check above (used in G++ 3.2) is insufficient because
3741              an empty class placed at offset zero might itself have an
3742              empty base at a nonzero offset.  */
3743           else if (walk_subobject_offsets (basetype,
3744                                            empty_base_at_nonzero_offset_p,
3745                                            size_zero_node,
3746                                            /*offsets=*/NULL,
3747                                            /*max_offset=*/NULL_TREE,
3748                                            /*vbases_p=*/true))
3749             {
3750               if (abi_version_at_least (2))
3751                 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3752               else
3753                 warning (OPT_Wabi,
3754                          "class %qT will be considered nearly empty in a "
3755                          "future version of GCC", t);
3756             }
3757         }
3758
3759       /* We do not create a FIELD_DECL for empty base classes because
3760          it might overlap some other field.  We want to be able to
3761          create CONSTRUCTORs for the class by iterating over the
3762          FIELD_DECLs, and the back end does not handle overlapping
3763          FIELD_DECLs.  */
3764
3765       /* An empty virtual base causes a class to be non-empty
3766          -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3767          here because that was already done when the virtual table
3768          pointer was created.  */
3769     }
3770
3771   /* Record the offsets of BINFO and its base subobjects.  */
3772   record_subobject_offsets (binfo,
3773                             BINFO_OFFSET (binfo),
3774                             offsets,
3775                             /*is_data_member=*/false);
3776
3777   return next_field;
3778 }
3779
3780 /* Layout all of the non-virtual base classes.  Record empty
3781    subobjects in OFFSETS.  T is the most derived type.  Return nonzero
3782    if the type cannot be nearly empty.  The fields created
3783    corresponding to the base classes will be inserted at
3784    *NEXT_FIELD.  */
3785
3786 static void
3787 build_base_fields (record_layout_info rli,
3788                    splay_tree offsets, tree *next_field)
3789 {
3790   /* Chain to hold all the new FIELD_DECLs which stand in for base class
3791      subobjects.  */
3792   tree t = rli->t;
3793   int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3794   int i;
3795
3796   /* The primary base class is always allocated first.  */
3797   if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3798     next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3799                                    offsets, next_field);
3800
3801   /* Now allocate the rest of the bases.  */
3802   for (i = 0; i < n_baseclasses; ++i)
3803     {
3804       tree base_binfo;
3805
3806       base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3807
3808       /* The primary base was already allocated above, so we don't
3809          need to allocate it again here.  */
3810       if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3811         continue;
3812
3813       /* Virtual bases are added at the end (a primary virtual base
3814          will have already been added).  */
3815       if (BINFO_VIRTUAL_P (base_binfo))
3816         continue;
3817
3818       next_field = build_base_field (rli, base_binfo,
3819                                      offsets, next_field);
3820     }
3821 }
3822
3823 /* Go through the TYPE_METHODS of T issuing any appropriate
3824    diagnostics, figuring out which methods override which other
3825    methods, and so forth.  */
3826
3827 static void
3828 check_methods (tree t)
3829 {
3830   tree x;
3831
3832   for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3833     {
3834       check_for_override (x, t);
3835       if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3836         error ("initializer specified for non-virtual method %q+D", x);
3837       /* The name of the field is the original field name
3838          Save this in auxiliary field for later overloading.  */
3839       if (DECL_VINDEX (x))
3840         {
3841           TYPE_POLYMORPHIC_P (t) = 1;
3842           if (DECL_PURE_VIRTUAL_P (x))
3843             VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3844         }
3845       /* All user-provided destructors are non-trivial.  */
3846       if (DECL_DESTRUCTOR_P (x) && user_provided_p (x))
3847         TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3848     }
3849 }
3850
3851 /* FN is a constructor or destructor.  Clone the declaration to create
3852    a specialized in-charge or not-in-charge version, as indicated by
3853    NAME.  */
3854
3855 static tree
3856 build_clone (tree fn, tree name)
3857 {
3858   tree parms;
3859   tree clone;
3860
3861   /* Copy the function.  */
3862   clone = copy_decl (fn);
3863   /* Reset the function name.  */
3864   DECL_NAME (clone) = name;
3865   SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3866   /* Remember where this function came from.  */
3867   DECL_ABSTRACT_ORIGIN (clone) = fn;
3868   /* Make it easy to find the CLONE given the FN.  */
3869   TREE_CHAIN (clone) = TREE_CHAIN (fn);
3870   TREE_CHAIN (fn) = clone;
3871
3872   /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT.  */
3873   if (TREE_CODE (clone) == TEMPLATE_DECL)
3874     {
3875       tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3876       DECL_TEMPLATE_RESULT (clone) = result;
3877       DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3878       DECL_TI_TEMPLATE (result) = clone;
3879       TREE_TYPE (clone) = TREE_TYPE (result);
3880       return clone;
3881     }
3882
3883   DECL_CLONED_FUNCTION (clone) = fn;
3884   /* There's no pending inline data for this function.  */
3885   DECL_PENDING_INLINE_INFO (clone) = NULL;
3886   DECL_PENDING_INLINE_P (clone) = 0;
3887
3888   /* The base-class destructor is not virtual.  */
3889   if (name == base_dtor_identifier)
3890     {
3891       DECL_VIRTUAL_P (clone) = 0;
3892       if (TREE_CODE (clone) != TEMPLATE_DECL)
3893         DECL_VINDEX (clone) = NULL_TREE;
3894     }
3895
3896   /* If there was an in-charge parameter, drop it from the function
3897      type.  */
3898   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3899     {
3900       tree basetype;
3901       tree parmtypes;
3902       tree exceptions;
3903
3904       exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3905       basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3906       parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3907       /* Skip the `this' parameter.  */
3908       parmtypes = TREE_CHAIN (parmtypes);
3909       /* Skip the in-charge parameter.  */
3910       parmtypes = TREE_CHAIN (parmtypes);
3911       /* And the VTT parm, in a complete [cd]tor.  */
3912       if (DECL_HAS_VTT_PARM_P (fn)
3913           && ! DECL_NEEDS_VTT_PARM_P (clone))
3914         parmtypes = TREE_CHAIN (parmtypes);
3915        /* If this is subobject constructor or destructor, add the vtt
3916          parameter.  */
3917       TREE_TYPE (clone)
3918         = build_method_type_directly (basetype,
3919                                       TREE_TYPE (TREE_TYPE (clone)),
3920                                       parmtypes);
3921       if (exceptions)
3922         TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3923                                                      exceptions);
3924       TREE_TYPE (clone)
3925         = cp_build_type_attribute_variant (TREE_TYPE (clone),
3926                                            TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3927     }
3928
3929   /* Copy the function parameters.  */
3930   DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3931   /* Remove the in-charge parameter.  */
3932   if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3933     {
3934       TREE_CHAIN (DECL_ARGUMENTS (clone))
3935         = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3936       DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3937     }
3938   /* And the VTT parm, in a complete [cd]tor.  */
3939   if (DECL_HAS_VTT_PARM_P (fn))
3940     {
3941       if (DECL_NEEDS_VTT_PARM_P (clone))
3942         DECL_HAS_VTT_PARM_P (clone) = 1;
3943       else
3944         {
3945           TREE_CHAIN (DECL_ARGUMENTS (clone))
3946             = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3947           DECL_HAS_VTT_PARM_P (clone) = 0;
3948         }
3949     }
3950
3951   for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3952     {
3953       DECL_CONTEXT (parms) = clone;
3954       cxx_dup_lang_specific_decl (parms);
3955     }
3956
3957   /* Create the RTL for this function.  */
3958   SET_DECL_RTL (clone, NULL_RTX);
3959   rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
3960
3961   if (pch_file)
3962     note_decl_for_pch (clone);
3963
3964   return clone;
3965 }
3966
3967 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
3968    not invoke this function directly.
3969
3970    For a non-thunk function, returns the address of the slot for storing
3971    the function it is a clone of.  Otherwise returns NULL_TREE.
3972
3973    If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
3974    cloned_function is unset.  This is to support the separate
3975    DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
3976    on a template makes sense, but not the former.  */
3977
3978 tree *
3979 decl_cloned_function_p (const_tree decl, bool just_testing)
3980 {
3981   tree *ptr;
3982   if (just_testing)
3983     decl = STRIP_TEMPLATE (decl);
3984
3985   if (TREE_CODE (decl) != FUNCTION_DECL
3986       || !DECL_LANG_SPECIFIC (decl)
3987       || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p)
3988     {
3989 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3990       if (!just_testing)
3991         lang_check_failed (__FILE__, __LINE__, __FUNCTION__);
3992       else
3993 #endif
3994         return NULL;
3995     }
3996
3997   ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function;
3998   if (just_testing && *ptr == NULL_TREE)
3999     return NULL;
4000   else
4001     return ptr;
4002 }
4003
4004 /* Produce declarations for all appropriate clones of FN.  If
4005    UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4006    CLASTYPE_METHOD_VEC as well.  */
4007
4008 void
4009 clone_function_decl (tree fn, int update_method_vec_p)
4010 {
4011   tree clone;
4012
4013   /* Avoid inappropriate cloning.  */
4014   if (TREE_CHAIN (fn)
4015       && DECL_CLONED_FUNCTION_P (TREE_CHAIN (fn)))
4016     return;
4017
4018   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
4019     {
4020       /* For each constructor, we need two variants: an in-charge version
4021          and a not-in-charge version.  */
4022       clone = build_clone (fn, complete_ctor_identifier);
4023       if (update_method_vec_p)
4024         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4025       clone = build_clone (fn, base_ctor_identifier);
4026       if (update_method_vec_p)
4027         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4028     }
4029   else
4030     {
4031       gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
4032
4033       /* For each destructor, we need three variants: an in-charge
4034          version, a not-in-charge version, and an in-charge deleting
4035          version.  We clone the deleting version first because that
4036          means it will go second on the TYPE_METHODS list -- and that
4037          corresponds to the correct layout order in the virtual
4038          function table.
4039
4040          For a non-virtual destructor, we do not build a deleting
4041          destructor.  */
4042       if (DECL_VIRTUAL_P (fn))
4043         {
4044           clone = build_clone (fn, deleting_dtor_identifier);
4045           if (update_method_vec_p)
4046             add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4047         }
4048       clone = build_clone (fn, complete_dtor_identifier);
4049       if (update_method_vec_p)
4050         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4051       clone = build_clone (fn, base_dtor_identifier);
4052       if (update_method_vec_p)
4053         add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4054     }
4055
4056   /* Note that this is an abstract function that is never emitted.  */
4057   DECL_ABSTRACT (fn) = 1;
4058 }
4059
4060 /* DECL is an in charge constructor, which is being defined. This will
4061    have had an in class&nbs