OSDN Git Service

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