OSDN Git Service

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