OSDN Git Service

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