OSDN Git Service

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