OSDN Git Service

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