OSDN Git Service

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