OSDN Git Service

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