]> gcc.gnu.org Git - gcc.git/blob - gcc/cp/class.c
git://gcc.gnu.org / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
hooks.c (hook_bool_void_true): New function.
[gcc.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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23
24 /* High-level class interface. */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31 #include "cp-tree.h"
32 #include "flags.h"
33 #include "rtl.h"
34 #include "output.h"
35 #include "toplev.h"
36 #include "target.h"
37 #include "convert.h"
38
39 /* The number of nested classes being processed. If we are not in the
40 scope of any class, this is zero. */
41
42 int current_class_depth;
43
44 /* In order to deal with nested classes, we keep a stack of classes.
45 The topmost entry is the innermost class, and is the entry at index
46 CURRENT_CLASS_DEPTH */
47
48 typedef struct class_stack_node {
49 /* The name of the class. */
50 tree name;
51
52 /* The _TYPE node for the class. */
53 tree type;
54
55 /* The access specifier pending for new declarations in the scope of
56 this class. */
57 tree access;
58
59 /* If were defining TYPE, the names used in this class. */
60 splay_tree names_used;
61 }* class_stack_node_t;
62
63 typedef struct vtbl_init_data_s
64 {
65 /* The base for which we're building initializers. */
66 tree binfo;
67 /* The type of the most-derived type. */
68 tree derived;
69 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
70 unless ctor_vtbl_p is true. */
71 tree rtti_binfo;
72 /* The negative-index vtable initializers built up so far. These
73 are in order from least negative index to most negative index. */
74 tree inits;
75 /* The last (i.e., most negative) entry in INITS. */
76 tree* last_init;
77 /* The binfo for the virtual base for which we're building
78 vcall offset initializers. */
79 tree vbase;
80 /* The functions in vbase for which we have already provided vcall
81 offsets. */
82 varray_type fns;
83 /* The vtable index of the next vcall or vbase offset. */
84 tree index;
85 /* Nonzero if we are building the initializer for the primary
86 vtable. */
87 int primary_vtbl_p;
88 /* Nonzero if we are building the initializer for a construction
89 vtable. */
90 int ctor_vtbl_p;
91 /* True when adding vcall offset entries to the vtable. False when
92 merely computing the indices. */
93 bool generate_vcall_entries;
94 } vtbl_init_data;
95
96 /* The type of a function passed to walk_subobject_offsets. */
97 typedef int (*subobject_offset_fn) (tree, tree, splay_tree);
98
99 /* The stack itself. This is a dynamically resized array. The
100 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
101 static int current_class_stack_size;
102 static class_stack_node_t current_class_stack;
103
104 /* An array of all local classes present in this translation unit, in
105 declaration order. */
106 varray_type local_classes;
107
108 static tree get_vfield_name (tree);
109 static void finish_struct_anon (tree);
110 static tree get_vtable_name (tree);
111 static tree get_basefndecls (tree, tree);
112 static int build_primary_vtable (tree, tree);
113 static int build_secondary_vtable (tree);
114 static void finish_vtbls (tree);
115 static void modify_vtable_entry (tree, tree, tree, tree, tree *);
116 static void finish_struct_bits (tree);
117 static int alter_access (tree, tree, tree);
118 static void handle_using_decl (tree, tree);
119 static void check_for_override (tree, tree);
120 static tree dfs_modify_vtables (tree, void *);
121 static tree modify_all_vtables (tree, tree);
122 static void determine_primary_bases (tree);
123 static void finish_struct_methods (tree);
124 static void maybe_warn_about_overly_private_class (tree);
125 static int method_name_cmp (const void *, const void *);
126 static int resort_method_name_cmp (const void *, const void *);
127 static void add_implicitly_declared_members (tree, int, int, int);
128 static tree fixed_type_or_null (tree, int *, int *);
129 static tree resolve_address_of_overloaded_function (tree, tree, tsubst_flags_t,
130 bool, tree);
131 static tree build_simple_base_path (tree expr, tree binfo);
132 static tree build_vtbl_ref_1 (tree, tree);
133 static tree build_vtbl_initializer (tree, tree, tree, tree, int *);
134 static int count_fields (tree);
135 static int add_fields_to_record_type (tree, struct sorted_fields_type*, int);
136 static void check_bitfield_decl (tree);
137 static void check_field_decl (tree, tree, int *, int *, int *, int *);
138 static void check_field_decls (tree, tree *, int *, int *, int *);
139 static tree *build_base_field (record_layout_info, tree, splay_tree, tree *);
140 static void build_base_fields (record_layout_info, splay_tree, tree *);
141 static void check_methods (tree);
142 static void remove_zero_width_bit_fields (tree);
143 static void check_bases (tree, int *, int *, int *);
144 static void check_bases_and_members (tree);
145 static tree create_vtable_ptr (tree, tree *);
146 static void include_empty_classes (record_layout_info);
147 static void layout_class_type (tree, tree *);
148 static void fixup_pending_inline (tree);
149 static void fixup_inline_methods (tree);
150 static void propagate_binfo_offsets (tree, tree);
151 static void layout_virtual_bases (record_layout_info, splay_tree);
152 static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *);
153 static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *);
154 static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *);
155 static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *);
156 static void add_vcall_offset (tree, tree, vtbl_init_data *);
157 static void layout_vtable_decl (tree, int);
158 static tree dfs_find_final_overrider (tree, void *);
159 static tree dfs_find_final_overrider_post (tree, void *);
160 static tree dfs_find_final_overrider_q (tree, int, void *);
161 static tree find_final_overrider (tree, tree, tree);
162 static int make_new_vtable (tree, tree);
163 static int maybe_indent_hierarchy (FILE *, int, int);
164 static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int);
165 static void dump_class_hierarchy (tree);
166 static void dump_class_hierarchy_1 (FILE *, int, tree);
167 static void dump_array (FILE *, tree);
168 static void dump_vtable (tree, tree, tree);
169 static void dump_vtt (tree, tree);
170 static void dump_thunk (FILE *, int, tree);
171 static tree build_vtable (tree, tree, tree);
172 static void initialize_vtable (tree, tree);
173 static void layout_nonempty_base_or_field (record_layout_info,
174 tree, tree, splay_tree);
175 static tree end_of_class (tree, int);
176 static bool layout_empty_base (tree, tree, splay_tree);
177 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree);
178 static tree dfs_accumulate_vtbl_inits (tree, tree, tree, tree,
179 tree);
180 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
181 static void build_vcall_and_vbase_vtbl_entries (tree,
182 vtbl_init_data *);
183 static void clone_constructors_and_destructors (tree);
184 static tree build_clone (tree, tree);
185 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
186 static tree copy_virtuals (tree);
187 static void build_ctor_vtbl_group (tree, tree);
188 static void build_vtt (tree);
189 static tree binfo_ctor_vtable (tree);
190 static tree *build_vtt_inits (tree, tree, tree *, tree *);
191 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
192 static tree dfs_ctor_vtable_bases_queue_p (tree, int, void *data);
193 static tree dfs_fixup_binfo_vtbls (tree, void *);
194 static int record_subobject_offset (tree, tree, splay_tree);
195 static int check_subobject_offset (tree, tree, splay_tree);
196 static int walk_subobject_offsets (tree, subobject_offset_fn,
197 tree, splay_tree, tree, int);
198 static void record_subobject_offsets (tree, tree, splay_tree, int);
199 static int layout_conflict_p (tree, tree, splay_tree, int);
200 static int splay_tree_compare_integer_csts (splay_tree_key k1,
201 splay_tree_key k2);
202 static void warn_about_ambiguous_bases (tree);
203 static bool type_requires_array_cookie (tree);
204 static bool contains_empty_class_p (tree);
205 static bool base_derived_from (tree, tree);
206 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
207 static tree end_of_base (tree);
208 static tree get_vcall_index (tree, tree);
209
210 /* Macros for dfs walking during vtt construction. See
211 dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
212 and dfs_fixup_binfo_vtbls. */
213 #define VTT_TOP_LEVEL_P(NODE) (TREE_LIST_CHECK (NODE)->common.unsigned_flag)
214 #define VTT_MARKED_BINFO_P(NODE) TREE_USED (NODE)
215
216 /* Variables shared between class.c and call.c. */
217
218 #ifdef GATHER_STATISTICS
219 int n_vtables = 0;
220 int n_vtable_entries = 0;
221 int n_vtable_searches = 0;
222 int n_vtable_elems = 0;
223 int n_convert_harshness = 0;
224 int n_compute_conversion_costs = 0;
225 int n_inner_fields_searched = 0;
226 #endif
227
228 /* Convert to or from a base subobject. EXPR is an expression of type
229 `A' or `A*', an expression of type `B' or `B*' is returned. To
230 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
231 the B base instance within A. To convert base A to derived B, CODE
232 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
233 In this latter case, A must not be a morally virtual base of B.
234 NONNULL is true if EXPR is known to be non-NULL (this is only
235 needed when EXPR is of pointer type). CV qualifiers are preserved
236 from EXPR. */
237
238 tree
239 build_base_path (enum tree_code code,
240 tree expr,
241 tree binfo,
242 int nonnull)
243 {
244 tree v_binfo = NULL_TREE;
245 tree d_binfo = NULL_TREE;
246 tree probe;
247 tree offset;
248 tree target_type;
249 tree null_test = NULL;
250 tree ptr_target_type;
251 int fixed_type_p;
252 int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
253 bool has_empty = false;
254 bool virtual_access;
255
256 if (expr == error_mark_node || binfo == error_mark_node || !binfo)
257 return error_mark_node;
258
259 for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
260 {
261 d_binfo = probe;
262 if (is_empty_class (BINFO_TYPE (probe)))
263 has_empty = true;
264 if (!v_binfo && BINFO_VIRTUAL_P (probe))
265 v_binfo = probe;
266 }
267
268 probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
269 if (want_pointer)
270 probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
271
272 gcc_assert (code == MINUS_EXPR
273 ? same_type_p (BINFO_TYPE (binfo), probe)
274 : code == PLUS_EXPR
275 ? same_type_p (BINFO_TYPE (d_binfo), probe)
276 : false);
277
278 if (binfo == d_binfo)
279 /* Nothing to do. */
280 return expr;
281
282 if (code == MINUS_EXPR && v_binfo)
283 {
284 error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
285 BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
286 return error_mark_node;
287 }
288
289 if (!want_pointer)
290 /* This must happen before the call to save_expr. */
291 expr = build_unary_op (ADDR_EXPR, expr, 0);
292
293 offset = BINFO_OFFSET (binfo);
294 fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
295
296 /* Do we need to look in the vtable for the real offset? */
297 virtual_access = (v_binfo && fixed_type_p <= 0);
298
299 /* Do we need to check for a null pointer? */
300 if (want_pointer && !nonnull && (virtual_access || !integer_zerop (offset)))
301 null_test = error_mark_node;
302
303 /* Protect against multiple evaluation if necessary. */
304 if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access))
305 expr = save_expr (expr);
306
307 /* Now that we've saved expr, build the real null test. */
308 if (null_test)
309 null_test = fold (build2 (NE_EXPR, boolean_type_node,
310 expr, integer_zero_node));
311
312 /* If this is a simple base reference, express it as a COMPONENT_REF. */
313 if (code == PLUS_EXPR && !virtual_access
314 /* We don't build base fields for empty bases, and they aren't very
315 interesting to the optimizers anyway. */
316 && !has_empty)
317 {
318 expr = build_indirect_ref (expr, NULL);
319 expr = build_simple_base_path (expr, binfo);
320 if (want_pointer)
321 expr = build_address (expr);
322 target_type = TREE_TYPE (expr);
323 goto out;
324 }
325
326 if (virtual_access)
327 {
328 /* Going via virtual base V_BINFO. We need the static offset
329 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
330 V_BINFO. That offset is an entry in D_BINFO's vtable. */
331 tree v_offset;
332
333 if (fixed_type_p < 0 && in_base_initializer)
334 {
335 /* In a base member initializer, we cannot rely on
336 the vtable being set up. We have to use the vtt_parm. */
337 tree derived = BINFO_INHERITANCE_CHAIN (v_binfo);
338 tree t;
339
340 t = TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived)));
341 t = build_pointer_type (t);
342 v_offset = convert (t, current_vtt_parm);
343 v_offset = build2 (PLUS_EXPR, t, v_offset,
344 BINFO_VPTR_INDEX (derived));
345 v_offset = build_indirect_ref (v_offset, NULL);
346 }
347 else
348 v_offset = build_vfield_ref (build_indirect_ref (expr, NULL),
349 TREE_TYPE (TREE_TYPE (expr)));
350
351 v_offset = build2 (PLUS_EXPR, TREE_TYPE (v_offset),
352 v_offset, BINFO_VPTR_FIELD (v_binfo));
353 v_offset = build1 (NOP_EXPR,
354 build_pointer_type (ptrdiff_type_node),
355 v_offset);
356 v_offset = build_indirect_ref (v_offset, NULL);
357 TREE_CONSTANT (v_offset) = 1;
358 TREE_INVARIANT (v_offset) = 1;
359
360 offset = convert_to_integer (ptrdiff_type_node,
361 size_diffop (offset,
362 BINFO_OFFSET (v_binfo)));
363
364 if (!integer_zerop (offset))
365 v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
366
367 if (fixed_type_p < 0)
368 /* Negative fixed_type_p means this is a constructor or destructor;
369 virtual base layout is fixed in in-charge [cd]tors, but not in
370 base [cd]tors. */
371 offset = build3 (COND_EXPR, ptrdiff_type_node,
372 build2 (EQ_EXPR, boolean_type_node,
373 current_in_charge_parm, integer_zero_node),
374 v_offset,
375 BINFO_OFFSET (binfo));
376 else
377 offset = v_offset;
378 }
379
380 target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
381
382 target_type = cp_build_qualified_type
383 (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
384 ptr_target_type = build_pointer_type (target_type);
385 if (want_pointer)
386 target_type = ptr_target_type;
387
388 expr = build1 (NOP_EXPR, ptr_target_type, expr);
389
390 if (!integer_zerop (offset))
391 expr = build2 (code, ptr_target_type, expr, offset);
392 else
393 null_test = NULL;
394
395 if (!want_pointer)
396 expr = build_indirect_ref (expr, NULL);
397
398 out:
399 if (null_test)
400 expr = fold (build3 (COND_EXPR, target_type, null_test, expr,
401 fold (build1 (NOP_EXPR, target_type,
402 integer_zero_node))));
403
404 return expr;
405 }
406
407 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
408 Perform a derived-to-base conversion by recursively building up a
409 sequence of COMPONENT_REFs to the appropriate base fields. */
410
411 static tree
412 build_simple_base_path (tree expr, tree binfo)
413 {
414 tree type = BINFO_TYPE (binfo);
415 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
416 tree field;
417
418 if (d_binfo == NULL_TREE)
419 {
420 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
421 return expr;
422 }
423
424 /* Recurse. */
425 expr = build_simple_base_path (expr, d_binfo);
426
427 for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
428 field; field = TREE_CHAIN (field))
429 /* Is this the base field created by build_base_field? */
430 if (TREE_CODE (field) == FIELD_DECL
431 && DECL_FIELD_IS_BASE (field)
432 && TREE_TYPE (field) == type)
433 return build_class_member_access_expr (expr, field,
434 NULL_TREE, false);
435
436 /* Didn't find the base field?!? */
437 gcc_unreachable ();
438 }
439
440 /* Convert OBJECT to the base TYPE. If CHECK_ACCESS is true, an error
441 message is emitted if TYPE is inaccessible. OBJECT is assumed to
442 be non-NULL. */
443
444 tree
445 convert_to_base (tree object, tree type, bool check_access)
446 {
447 tree binfo;
448
449 binfo = lookup_base (TREE_TYPE (object), type,
450 check_access ? ba_check : ba_ignore,
451 NULL);
452 if (!binfo || binfo == error_mark_node)
453 return error_mark_node;
454
455 return build_base_path (PLUS_EXPR, object, binfo, /*nonnull=*/1);
456 }
457
458 /* EXPR is an expression with class type. BASE is a base class (a
459 BINFO) of that class type. Returns EXPR, converted to the BASE
460 type. This function assumes that EXPR is the most derived class;
461 therefore virtual bases can be found at their static offsets. */
462
463 tree
464 convert_to_base_statically (tree expr, tree base)
465 {
466 tree expr_type;
467
468 expr_type = TREE_TYPE (expr);
469 if (!same_type_p (expr_type, BINFO_TYPE (base)))
470 {
471 tree pointer_type;
472
473 pointer_type = build_pointer_type (expr_type);
474 expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1);
475 if (!integer_zerop (BINFO_OFFSET (base)))
476 expr = build2 (PLUS_EXPR, pointer_type, expr,
477 build_nop (pointer_type, BINFO_OFFSET (base)));
478 expr = build_nop (build_pointer_type (BINFO_TYPE (base)), expr);
479 expr = build1 (INDIRECT_REF, BINFO_TYPE (base), expr);
480 }
481
482 return expr;
483 }
484
485 \f
486 /* Given an object INSTANCE, return an expression which yields the
487 vtable element corresponding to INDEX. There are many special
488 cases for INSTANCE which we take care of here, mainly to avoid
489 creating extra tree nodes when we don't have to. */
490
491 static tree
492 build_vtbl_ref_1 (tree instance, tree idx)
493 {
494 tree aref;
495 tree vtbl = NULL_TREE;
496
497 /* Try to figure out what a reference refers to, and
498 access its virtual function table directly. */
499
500 int cdtorp = 0;
501 tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
502
503 tree basetype = non_reference (TREE_TYPE (instance));
504
505 if (fixed_type && !cdtorp)
506 {
507 tree binfo = lookup_base (fixed_type, basetype,
508 ba_ignore|ba_quiet, NULL);
509 if (binfo)
510 vtbl = unshare_expr (BINFO_VTABLE (binfo));
511 }
512
513 if (!vtbl)
514 vtbl = build_vfield_ref (instance, basetype);
515
516 assemble_external (vtbl);
517
518 aref = build_array_ref (vtbl, idx);
519 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
520 TREE_INVARIANT (aref) = TREE_CONSTANT (aref);
521
522 return aref;
523 }
524
525 tree
526 build_vtbl_ref (tree instance, tree idx)
527 {
528 tree aref = build_vtbl_ref_1 (instance, idx);
529
530 return aref;
531 }
532
533 /* Given a stable object pointer INSTANCE_PTR, return an expression which
534 yields a function pointer corresponding to vtable element INDEX. */
535
536 tree
537 build_vfn_ref (tree instance_ptr, tree idx)
538 {
539 tree aref;
540
541 aref = build_vtbl_ref_1 (build_indirect_ref (instance_ptr, 0), idx);
542
543 /* When using function descriptors, the address of the
544 vtable entry is treated as a function pointer. */
545 if (TARGET_VTABLE_USES_DESCRIPTORS)
546 aref = build1 (NOP_EXPR, TREE_TYPE (aref),
547 build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1));
548
549 /* Remember this as a method reference, for later devirtualization. */
550 aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx);
551
552 return aref;
553 }
554
555 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
556 for the given TYPE. */
557
558 static tree
559 get_vtable_name (tree type)
560 {
561 return mangle_vtbl_for_type (type);
562 }
563
564 /* Return an IDENTIFIER_NODE for the name of the virtual table table
565 for TYPE. */
566
567 tree
568 get_vtt_name (tree type)
569 {
570 return mangle_vtt_for_type (type);
571 }
572
573 /* DECL is an entity associated with TYPE, like a virtual table or an
574 implicitly generated constructor. Determine whether or not DECL
575 should have external or internal linkage at the object file
576 level. This routine does not deal with COMDAT linkage and other
577 similar complexities; it simply sets TREE_PUBLIC if it possible for
578 entities in other translation units to contain copies of DECL, in
579 the abstract. */
580
581 void
582 set_linkage_according_to_type (tree type, tree decl)
583 {
584 /* If TYPE involves a local class in a function with internal
585 linkage, then DECL should have internal linkage too. Other local
586 classes have no linkage -- but if their containing functions
587 have external linkage, it makes sense for DECL to have external
588 linkage too. That will allow template definitions to be merged,
589 for example. */
590 if (no_linkage_check (type, /*relaxed_p=*/true))
591 {
592 TREE_PUBLIC (decl) = 0;
593 DECL_INTERFACE_KNOWN (decl) = 1;
594 }
595 else
596 TREE_PUBLIC (decl) = 1;
597 }
598
599 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
600 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
601 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
602
603 static tree
604 build_vtable (tree class_type, tree name, tree vtable_type)
605 {
606 tree decl;
607
608 decl = build_lang_decl (VAR_DECL, name, vtable_type);
609 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
610 now to avoid confusion in mangle_decl. */
611 SET_DECL_ASSEMBLER_NAME (decl, name);
612 DECL_CONTEXT (decl) = class_type;
613 DECL_ARTIFICIAL (decl) = 1;
614 TREE_STATIC (decl) = 1;
615 TREE_READONLY (decl) = 1;
616 DECL_VIRTUAL_P (decl) = 1;
617 DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
618 DECL_VTABLE_OR_VTT_P (decl) = 1;
619 /* At one time the vtable info was grabbed 2 words at a time. This
620 fails on sparc unless you have 8-byte alignment. (tiemann) */
621 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
622 DECL_ALIGN (decl));
623 set_linkage_according_to_type (class_type, decl);
624 /* The vtable has not been defined -- yet. */
625 DECL_EXTERNAL (decl) = 1;
626 DECL_NOT_REALLY_EXTERN (decl) = 1;
627
628 if (write_symbols == DWARF2_DEBUG)
629 /* Mark the VAR_DECL node representing the vtable itself as a
630 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
631 is rather important that such things be ignored because any
632 effort to actually generate DWARF for them will run into
633 trouble when/if we encounter code like:
634
635 #pragma interface
636 struct S { virtual void member (); };
637
638 because the artificial declaration of the vtable itself (as
639 manufactured by the g++ front end) will say that the vtable is
640 a static member of `S' but only *after* the debug output for
641 the definition of `S' has already been output. This causes
642 grief because the DWARF entry for the definition of the vtable
643 will try to refer back to an earlier *declaration* of the
644 vtable as a static member of `S' and there won't be one. We
645 might be able to arrange to have the "vtable static member"
646 attached to the member list for `S' before the debug info for
647 `S' get written (which would solve the problem) but that would
648 require more intrusive changes to the g++ front end. */
649 DECL_IGNORED_P (decl) = 1;
650
651 return decl;
652 }
653
654 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
655 or even complete. If this does not exist, create it. If COMPLETE is
656 nonzero, then complete the definition of it -- that will render it
657 impossible to actually build the vtable, but is useful to get at those
658 which are known to exist in the runtime. */
659
660 tree
661 get_vtable_decl (tree type, int complete)
662 {
663 tree decl;
664
665 if (CLASSTYPE_VTABLES (type))
666 return CLASSTYPE_VTABLES (type);
667
668 decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
669 CLASSTYPE_VTABLES (type) = decl;
670
671 if (complete)
672 {
673 DECL_EXTERNAL (decl) = 1;
674 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
675 }
676
677 return decl;
678 }
679
680 /* Returns a copy of the BINFO_VIRTUALS list in BINFO. The
681 BV_VCALL_INDEX for each entry is cleared. */
682
683 static tree
684 copy_virtuals (tree binfo)
685 {
686 tree copies;
687 tree t;
688
689 copies = copy_list (BINFO_VIRTUALS (binfo));
690 for (t = copies; t; t = TREE_CHAIN (t))
691 BV_VCALL_INDEX (t) = NULL_TREE;
692
693 return copies;
694 }
695
696 /* Build the primary virtual function table for TYPE. If BINFO is
697 non-NULL, build the vtable starting with the initial approximation
698 that it is the same as the one which is the head of the association
699 list. Returns a nonzero value if a new vtable is actually
700 created. */
701
702 static int
703 build_primary_vtable (tree binfo, tree type)
704 {
705 tree decl;
706 tree virtuals;
707
708 decl = get_vtable_decl (type, /*complete=*/0);
709
710 if (binfo)
711 {
712 if (BINFO_NEW_VTABLE_MARKED (binfo))
713 /* We have already created a vtable for this base, so there's
714 no need to do it again. */
715 return 0;
716
717 virtuals = copy_virtuals (binfo);
718 TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
719 DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
720 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
721 }
722 else
723 {
724 gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
725 virtuals = NULL_TREE;
726 }
727
728 #ifdef GATHER_STATISTICS
729 n_vtables += 1;
730 n_vtable_elems += list_length (virtuals);
731 #endif
732
733 /* Initialize the association list for this type, based
734 on our first approximation. */
735 BINFO_VTABLE (TYPE_BINFO (type)) = decl;
736 BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
737 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
738 return 1;
739 }
740
741 /* Give BINFO a new virtual function table which is initialized
742 with a skeleton-copy of its original initialization. The only
743 entry that changes is the `delta' entry, so we can really
744 share a lot of structure.
745
746 FOR_TYPE is the most derived type which caused this table to
747 be needed.
748
749 Returns nonzero if we haven't met BINFO before.
750
751 The order in which vtables are built (by calling this function) for
752 an object must remain the same, otherwise a binary incompatibility
753 can result. */
754
755 static int
756 build_secondary_vtable (tree binfo)
757 {
758 if (BINFO_NEW_VTABLE_MARKED (binfo))
759 /* We already created a vtable for this base. There's no need to
760 do it again. */
761 return 0;
762
763 /* Remember that we've created a vtable for this BINFO, so that we
764 don't try to do so again. */
765 SET_BINFO_NEW_VTABLE_MARKED (binfo);
766
767 /* Make fresh virtual list, so we can smash it later. */
768 BINFO_VIRTUALS (binfo) = copy_virtuals (binfo);
769
770 /* Secondary vtables are laid out as part of the same structure as
771 the primary vtable. */
772 BINFO_VTABLE (binfo) = NULL_TREE;
773 return 1;
774 }
775
776 /* Create a new vtable for BINFO which is the hierarchy dominated by
777 T. Return nonzero if we actually created a new vtable. */
778
779 static int
780 make_new_vtable (tree t, tree binfo)
781 {
782 if (binfo == TYPE_BINFO (t))
783 /* In this case, it is *type*'s vtable we are modifying. We start
784 with the approximation that its vtable is that of the
785 immediate base class. */
786 /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
787 since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */
788 return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))),
789 t);
790 else
791 /* This is our very own copy of `basetype' to play with. Later,
792 we will fill in all the virtual functions that override the
793 virtual functions in these base classes which are not defined
794 by the current type. */
795 return build_secondary_vtable (binfo);
796 }
797
798 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
799 (which is in the hierarchy dominated by T) list FNDECL as its
800 BV_FN. DELTA is the required constant adjustment from the `this'
801 pointer where the vtable entry appears to the `this' required when
802 the function is actually called. */
803
804 static void
805 modify_vtable_entry (tree t,
806 tree binfo,
807 tree fndecl,
808 tree delta,
809 tree *virtuals)
810 {
811 tree v;
812
813 v = *virtuals;
814
815 if (fndecl != BV_FN (v)
816 || !tree_int_cst_equal (delta, BV_DELTA (v)))
817 {
818 /* We need a new vtable for BINFO. */
819 if (make_new_vtable (t, binfo))
820 {
821 /* If we really did make a new vtable, we also made a copy
822 of the BINFO_VIRTUALS list. Now, we have to find the
823 corresponding entry in that list. */
824 *virtuals = BINFO_VIRTUALS (binfo);
825 while (BV_FN (*virtuals) != BV_FN (v))
826 *virtuals = TREE_CHAIN (*virtuals);
827 v = *virtuals;
828 }
829
830 BV_DELTA (v) = delta;
831 BV_VCALL_INDEX (v) = NULL_TREE;
832 BV_FN (v) = fndecl;
833 }
834 }
835
836 \f
837 /* Add method METHOD to class TYPE. */
838
839 void
840 add_method (tree type, tree method)
841 {
842 int using;
843 unsigned slot;
844 tree overload;
845 int template_conv_p;
846 VEC(tree) *method_vec;
847 bool complete_p;
848 bool insert_p = false;
849 tree current_fns;
850
851 if (method == error_mark_node)
852 return;
853
854 complete_p = COMPLETE_TYPE_P (type);
855 using = (DECL_CONTEXT (method) != type);
856 template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
857 && DECL_TEMPLATE_CONV_FN_P (method));
858
859 method_vec = CLASSTYPE_METHOD_VEC (type);
860 if (!method_vec)
861 {
862 /* Make a new method vector. We start with 8 entries. We must
863 allocate at least two (for constructors and destructors), and
864 we're going to end up with an assignment operator at some
865 point as well. */
866 method_vec = VEC_alloc (tree, 8);
867 /* Create slots for constructors and destructors. */
868 VEC_quick_push (tree, method_vec, NULL_TREE);
869 VEC_quick_push (tree, method_vec, NULL_TREE);
870 CLASSTYPE_METHOD_VEC (type) = method_vec;
871 }
872
873 /* Constructors and destructors go in special slots. */
874 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
875 slot = CLASSTYPE_CONSTRUCTOR_SLOT;
876 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
877 {
878 slot = CLASSTYPE_DESTRUCTOR_SLOT;
879 TYPE_HAS_DESTRUCTOR (type) = 1;
880
881 if (TYPE_FOR_JAVA (type))
882 error (DECL_ARTIFICIAL (method)
883 ? "Java class '%T' cannot have an implicit non-trivial destructor"
884 : "Java class '%T' cannot have a destructor",
885 DECL_CONTEXT (method));
886 }
887 else
888 {
889 bool conv_p = DECL_CONV_FN_P (method);
890 tree m;
891
892 insert_p = true;
893 /* See if we already have an entry with this name. */
894 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
895 VEC_iterate (tree, method_vec, slot, m);
896 ++slot)
897 {
898 m = OVL_CURRENT (m);
899 if (template_conv_p)
900 {
901 if (TREE_CODE (m) == TEMPLATE_DECL
902 && DECL_TEMPLATE_CONV_FN_P (m))
903 insert_p = false;
904 break;
905 }
906 if (conv_p && !DECL_CONV_FN_P (m))
907 break;
908 if (DECL_NAME (m) == DECL_NAME (method))
909 {
910 insert_p = false;
911 break;
912 }
913 if (complete_p
914 && !DECL_CONV_FN_P (m)
915 && DECL_NAME (m) > DECL_NAME (method))
916 break;
917 }
918 }
919 current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot);
920
921 if (processing_template_decl)
922 /* TYPE is a template class. Don't issue any errors now; wait
923 until instantiation time to complain. */
924 ;
925 else
926 {
927 tree fns;
928
929 /* Check to see if we've already got this method. */
930 for (fns = current_fns; fns; fns = OVL_NEXT (fns))
931 {
932 tree fn = OVL_CURRENT (fns);
933 tree parms1;
934 tree parms2;
935 bool same = 1;
936
937 if (TREE_CODE (fn) != TREE_CODE (method))
938 continue;
939
940 /* [over.load] Member function declarations with the
941 same name and the same parameter types cannot be
942 overloaded if any of them is a static member
943 function declaration.
944
945 [namespace.udecl] When a using-declaration brings names
946 from a base class into a derived class scope, member
947 functions in the derived class override and/or hide member
948 functions with the same name and parameter types in a base
949 class (rather than conflicting). */
950 parms1 = TYPE_ARG_TYPES (TREE_TYPE (fn));
951 parms2 = TYPE_ARG_TYPES (TREE_TYPE (method));
952
953 /* Compare the quals on the 'this' parm. Don't compare
954 the whole types, as used functions are treated as
955 coming from the using class in overload resolution. */
956 if (! DECL_STATIC_FUNCTION_P (fn)
957 && ! DECL_STATIC_FUNCTION_P (method)
958 && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1)))
959 != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2)))))
960 same = 0;
961
962 /* For templates, the template parms must be identical. */
963 if (TREE_CODE (fn) == TEMPLATE_DECL
964 && !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
965 DECL_TEMPLATE_PARMS (method)))
966 same = 0;
967
968 if (! DECL_STATIC_FUNCTION_P (fn))
969 parms1 = TREE_CHAIN (parms1);
970 if (! DECL_STATIC_FUNCTION_P (method))
971 parms2 = TREE_CHAIN (parms2);
972
973 if (same && compparms (parms1, parms2)
974 && (!DECL_CONV_FN_P (fn)
975 || same_type_p (TREE_TYPE (TREE_TYPE (fn)),
976 TREE_TYPE (TREE_TYPE (method)))))
977 {
978 if (using && DECL_CONTEXT (fn) == type)
979 /* Defer to the local function. */
980 return;
981 else
982 {
983 cp_error_at ("`%#D' and `%#D' cannot be overloaded",
984 method, fn);
985
986 /* We don't call duplicate_decls here to merge
987 the declarations because that will confuse
988 things if the methods have inline
989 definitions. In particular, we will crash
990 while processing the definitions. */
991 return;
992 }
993 }
994 }
995 }
996
997 /* Add the new binding. */
998 overload = build_overload (method, current_fns);
999
1000 if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p)
1001 push_class_level_binding (DECL_NAME (method), overload);
1002
1003 if (insert_p)
1004 {
1005 /* We only expect to add few methods in the COMPLETE_P case, so
1006 just make room for one more method in that case. */
1007 if (VEC_reserve (tree, method_vec, complete_p ? 1 : -1))
1008 CLASSTYPE_METHOD_VEC (type) = method_vec;
1009 if (slot == VEC_length (tree, method_vec))
1010 VEC_quick_push (tree, method_vec, overload);
1011 else
1012 VEC_quick_insert (tree, method_vec, slot, overload);
1013 }
1014 else
1015 /* Replace the current slot. */
1016 VEC_replace (tree, method_vec, slot, overload);
1017 }
1018
1019 /* Subroutines of finish_struct. */
1020
1021 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1022 legit, otherwise return 0. */
1023
1024 static int
1025 alter_access (tree t, tree fdecl, tree access)
1026 {
1027 tree elem;
1028
1029 if (!DECL_LANG_SPECIFIC (fdecl))
1030 retrofit_lang_decl (fdecl);
1031
1032 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl));
1033
1034 elem = purpose_member (t, DECL_ACCESS (fdecl));
1035 if (elem)
1036 {
1037 if (TREE_VALUE (elem) != access)
1038 {
1039 if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1040 cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
1041 else
1042 error ("conflicting access specifications for field `%E', ignored",
1043 DECL_NAME (fdecl));
1044 }
1045 else
1046 {
1047 /* They're changing the access to the same thing they changed
1048 it to before. That's OK. */
1049 ;
1050 }
1051 }
1052 else
1053 {
1054 perform_or_defer_access_check (TYPE_BINFO (t), fdecl);
1055 DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1056 return 1;
1057 }
1058 return 0;
1059 }
1060
1061 /* Process the USING_DECL, which is a member of T. */
1062
1063 static void
1064 handle_using_decl (tree using_decl, tree t)
1065 {
1066 tree ctype = DECL_INITIAL (using_decl);
1067 tree name = DECL_NAME (using_decl);
1068 tree access
1069 = TREE_PRIVATE (using_decl) ? access_private_node
1070 : TREE_PROTECTED (using_decl) ? access_protected_node
1071 : access_public_node;
1072 tree fdecl, binfo;
1073 tree flist = NULL_TREE;
1074 tree old_value;
1075
1076 if (ctype == error_mark_node)
1077 return;
1078
1079 binfo = lookup_base (t, ctype, ba_any, NULL);
1080 if (! binfo)
1081 {
1082 location_t saved_loc = input_location;
1083
1084 input_location = DECL_SOURCE_LOCATION (using_decl);
1085 error_not_base_type (ctype, t);
1086 input_location = saved_loc;
1087 return;
1088 }
1089
1090 if (constructor_name_p (name, ctype))
1091 {
1092 cp_error_at ("`%D' names constructor", using_decl);
1093 return;
1094 }
1095 if (constructor_name_p (name, t))
1096 {
1097 cp_error_at ("`%D' invalid in `%T'", using_decl, t);
1098 return;
1099 }
1100
1101 fdecl = lookup_member (binfo, name, 0, false);
1102
1103 if (!fdecl)
1104 {
1105 cp_error_at ("no members matching `%D' in `%#T'", using_decl, ctype);
1106 return;
1107 }
1108
1109 if (BASELINK_P (fdecl))
1110 /* Ignore base type this came from. */
1111 fdecl = BASELINK_FUNCTIONS (fdecl);
1112
1113 old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false);
1114 if (old_value)
1115 {
1116 if (is_overloaded_fn (old_value))
1117 old_value = OVL_CURRENT (old_value);
1118
1119 if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1120 /* OK */;
1121 else
1122 old_value = NULL_TREE;
1123 }
1124
1125 if (is_overloaded_fn (fdecl))
1126 flist = fdecl;
1127
1128 if (! old_value)
1129 ;
1130 else if (is_overloaded_fn (old_value))
1131 {
1132 if (flist)
1133 /* It's OK to use functions from a base when there are functions with
1134 the same name already present in the current class. */;
1135 else
1136 {
1137 cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1138 cp_error_at (" because of local method `%#D' with same name",
1139 OVL_CURRENT (old_value));
1140 return;
1141 }
1142 }
1143 else if (!DECL_ARTIFICIAL (old_value))
1144 {
1145 cp_error_at ("`%D' invalid in `%#T'", using_decl, t);
1146 cp_error_at (" because of local member `%#D' with same name", old_value);
1147 return;
1148 }
1149
1150 /* Make type T see field decl FDECL with access ACCESS. */
1151 if (flist)
1152 for (; flist; flist = OVL_NEXT (flist))
1153 {
1154 add_method (t, OVL_CURRENT (flist));
1155 alter_access (t, OVL_CURRENT (flist), access);
1156 }
1157 else
1158 alter_access (t, fdecl, access);
1159 }
1160 \f
1161 /* Run through the base classes of T, updating
1162 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1163 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1164 the bases. */
1165
1166 static void
1167 check_bases (tree t,
1168 int* cant_have_default_ctor_p,
1169 int* cant_have_const_ctor_p,
1170 int* no_const_asn_ref_p)
1171 {
1172 int i;
1173 int seen_non_virtual_nearly_empty_base_p;
1174 tree base_binfo;
1175 tree binfo;
1176
1177 seen_non_virtual_nearly_empty_base_p = 0;
1178
1179 for (binfo = TYPE_BINFO (t), i = 0;
1180 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1181 {
1182 tree basetype = TREE_TYPE (base_binfo);
1183
1184 gcc_assert (COMPLETE_TYPE_P (basetype));
1185
1186 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1187 here because the case of virtual functions but non-virtual
1188 dtor is handled in finish_struct_1. */
1189 if (warn_ecpp && ! TYPE_POLYMORPHIC_P (basetype)
1190 && TYPE_HAS_DESTRUCTOR (basetype))
1191 warning ("base class `%#T' has a non-virtual destructor",
1192 basetype);
1193
1194 /* If the base class doesn't have copy constructors or
1195 assignment operators that take const references, then the
1196 derived class cannot have such a member automatically
1197 generated. */
1198 if (! TYPE_HAS_CONST_INIT_REF (basetype))
1199 *cant_have_const_ctor_p = 1;
1200 if (TYPE_HAS_ASSIGN_REF (basetype)
1201 && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1202 *no_const_asn_ref_p = 1;
1203 /* Similarly, if the base class doesn't have a default
1204 constructor, then the derived class won't have an
1205 automatically generated default constructor. */
1206 if (TYPE_HAS_CONSTRUCTOR (basetype)
1207 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1208 {
1209 *cant_have_default_ctor_p = 1;
1210 if (! TYPE_HAS_CONSTRUCTOR (t))
1211 pedwarn ("base `%T' with only non-default constructor in class without a constructor",
1212 basetype);
1213 }
1214
1215 if (BINFO_VIRTUAL_P (base_binfo))
1216 /* A virtual base does not effect nearly emptiness. */
1217 ;
1218 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1219 {
1220 if (seen_non_virtual_nearly_empty_base_p)
1221 /* And if there is more than one nearly empty base, then the
1222 derived class is not nearly empty either. */
1223 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1224 else
1225 /* Remember we've seen one. */
1226 seen_non_virtual_nearly_empty_base_p = 1;
1227 }
1228 else if (!is_empty_class (basetype))
1229 /* If the base class is not empty or nearly empty, then this
1230 class cannot be nearly empty. */
1231 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1232
1233 /* A lot of properties from the bases also apply to the derived
1234 class. */
1235 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1236 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1237 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1238 TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1239 |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1240 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1241 TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1242 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1243 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1244 }
1245 }
1246
1247 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1248 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1249 that have had a nearly-empty virtual primary base stolen by some
1250 other base in the heirarchy. Determines CLASSTYPE_PRIMARY_BASE for
1251 T. */
1252
1253 static void
1254 determine_primary_bases (tree t)
1255 {
1256 unsigned i;
1257 tree primary = NULL_TREE;
1258 tree type_binfo = TYPE_BINFO (t);
1259 tree base_binfo;
1260
1261 /* Determine the primary bases of our bases. */
1262 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1263 base_binfo = TREE_CHAIN (base_binfo))
1264 {
1265 tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1266
1267 /* See if we're the non-virtual primary of our inheritance
1268 chain. */
1269 if (!BINFO_VIRTUAL_P (base_binfo))
1270 {
1271 tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1272 tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1273
1274 if (parent_primary
1275 && BINFO_TYPE (base_binfo) == BINFO_TYPE (parent_primary))
1276 /* We are the primary binfo. */
1277 BINFO_PRIMARY_P (base_binfo) = 1;
1278 }
1279 /* Determine if we have a virtual primary base, and mark it so.
1280 */
1281 if (primary && BINFO_VIRTUAL_P (primary))
1282 {
1283 tree this_primary = copied_binfo (primary, base_binfo);
1284
1285 if (BINFO_PRIMARY_P (this_primary))
1286 /* Someone already claimed this base. */
1287 BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1288 else
1289 {
1290 tree delta;
1291
1292 BINFO_PRIMARY_P (this_primary) = 1;
1293 BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1294
1295 /* A virtual binfo might have been copied from within
1296 another hierarchy. As we're about to use it as a
1297 primary base, make sure the offsets match. */
1298 delta = size_diffop (convert (ssizetype,
1299 BINFO_OFFSET (base_binfo)),
1300 convert (ssizetype,
1301 BINFO_OFFSET (this_primary)));
1302
1303 propagate_binfo_offsets (this_primary, delta);
1304 }
1305 }
1306 }
1307
1308 /* First look for a dynamic direct non-virtual base. */
1309 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1310 {
1311 tree basetype = BINFO_TYPE (base_binfo);
1312
1313 if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1314 {
1315 primary = base_binfo;
1316 goto found;
1317 }
1318 }
1319
1320 /* A "nearly-empty" virtual base class can be the primary base
1321 class, if no non-virtual polymorphic base can be found. Look for
1322 a nearly-empty virtual dynamic base that is not already a primary
1323 base of something in the heirarchy. If there is no such base,
1324 just pick the first nearly-empty virtual base. */
1325
1326 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1327 base_binfo = TREE_CHAIN (base_binfo))
1328 if (BINFO_VIRTUAL_P (base_binfo)
1329 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1330 {
1331 if (!BINFO_PRIMARY_P (base_binfo))
1332 {
1333 /* Found one that is not primary. */
1334 primary = base_binfo;
1335 goto found;
1336 }
1337 else if (!primary)
1338 /* Remember the first candidate. */
1339 primary = base_binfo;
1340 }
1341
1342 found:
1343 /* If we've got a primary base, use it. */
1344 if (primary)
1345 {
1346 tree basetype = BINFO_TYPE (primary);
1347
1348 CLASSTYPE_PRIMARY_BINFO (t) = primary;
1349 if (BINFO_PRIMARY_P (primary))
1350 /* We are stealing a primary base. */
1351 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1352 BINFO_PRIMARY_P (primary) = 1;
1353 if (BINFO_VIRTUAL_P (primary))
1354 {
1355 tree delta;
1356
1357 BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1358 /* A virtual binfo might have been copied from within
1359 another hierarchy. As we're about to use it as a primary
1360 base, make sure the offsets match. */
1361 delta = size_diffop (ssize_int (0),
1362 convert (ssizetype, BINFO_OFFSET (primary)));
1363
1364 propagate_binfo_offsets (primary, delta);
1365 }
1366
1367 primary = TYPE_BINFO (basetype);
1368
1369 TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1370 BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1371 BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1372 }
1373 }
1374 \f
1375 /* Set memoizing fields and bits of T (and its variants) for later
1376 use. */
1377
1378 static void
1379 finish_struct_bits (tree t)
1380 {
1381 tree variants;
1382
1383 /* Fix up variants (if any). */
1384 for (variants = TYPE_NEXT_VARIANT (t);
1385 variants;
1386 variants = TYPE_NEXT_VARIANT (variants))
1387 {
1388 /* These fields are in the _TYPE part of the node, not in
1389 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1390 TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1391 TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1392 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1393 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1394 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1395
1396 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants)
1397 = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t);
1398 TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1399 TYPE_USES_VIRTUAL_BASECLASSES (variants)
1400 = TYPE_USES_VIRTUAL_BASECLASSES (t);
1401
1402 TYPE_BINFO (variants) = TYPE_BINFO (t);
1403
1404 /* Copy whatever these are holding today. */
1405 TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1406 TYPE_METHODS (variants) = TYPE_METHODS (t);
1407 TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1408 TYPE_SIZE (variants) = TYPE_SIZE (t);
1409 TYPE_SIZE_UNIT (variants) = TYPE_SIZE_UNIT (t);
1410 }
1411
1412 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1413 /* For a class w/o baseclasses, `finish_struct' has set
1414 CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by definition).
1415 Similarly for a class whose base classes do not have vtables.
1416 When neither of these is true, we might have removed abstract
1417 virtuals (by providing a definition), added some (by declaring
1418 new ones), or redeclared ones from a base class. We need to
1419 recalculate what's really an abstract virtual at this point (by
1420 looking in the vtables). */
1421 get_pure_virtuals (t);
1422
1423 /* If this type has a copy constructor or a destructor, force its
1424 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1425 nonzero. This will cause it to be passed by invisible reference
1426 and prevent it from being returned in a register. */
1427 if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1428 {
1429 tree variants;
1430 DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1431 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1432 {
1433 TYPE_MODE (variants) = BLKmode;
1434 TREE_ADDRESSABLE (variants) = 1;
1435 }
1436 }
1437 }
1438
1439 /* Issue warnings about T having private constructors, but no friends,
1440 and so forth.
1441
1442 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1443 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1444 non-private static member functions. */
1445
1446 static void
1447 maybe_warn_about_overly_private_class (tree t)
1448 {
1449 int has_member_fn = 0;
1450 int has_nonprivate_method = 0;
1451 tree fn;
1452
1453 if (!warn_ctor_dtor_privacy
1454 /* If the class has friends, those entities might create and
1455 access instances, so we should not warn. */
1456 || (CLASSTYPE_FRIEND_CLASSES (t)
1457 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1458 /* We will have warned when the template was declared; there's
1459 no need to warn on every instantiation. */
1460 || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1461 /* There's no reason to even consider warning about this
1462 class. */
1463 return;
1464
1465 /* We only issue one warning, if more than one applies, because
1466 otherwise, on code like:
1467
1468 class A {
1469 // Oops - forgot `public:'
1470 A();
1471 A(const A&);
1472 ~A();
1473 };
1474
1475 we warn several times about essentially the same problem. */
1476
1477 /* Check to see if all (non-constructor, non-destructor) member
1478 functions are private. (Since there are no friends or
1479 non-private statics, we can't ever call any of the private member
1480 functions.) */
1481 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1482 /* We're not interested in compiler-generated methods; they don't
1483 provide any way to call private members. */
1484 if (!DECL_ARTIFICIAL (fn))
1485 {
1486 if (!TREE_PRIVATE (fn))
1487 {
1488 if (DECL_STATIC_FUNCTION_P (fn))
1489 /* A non-private static member function is just like a
1490 friend; it can create and invoke private member
1491 functions, and be accessed without a class
1492 instance. */
1493 return;
1494
1495 has_nonprivate_method = 1;
1496 /* Keep searching for a static member function. */
1497 }
1498 else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1499 has_member_fn = 1;
1500 }
1501
1502 if (!has_nonprivate_method && has_member_fn)
1503 {
1504 /* There are no non-private methods, and there's at least one
1505 private member function that isn't a constructor or
1506 destructor. (If all the private members are
1507 constructors/destructors we want to use the code below that
1508 issues error messages specifically referring to
1509 constructors/destructors.) */
1510 unsigned i;
1511 tree binfo = TYPE_BINFO (t);
1512
1513 for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1514 if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1515 {
1516 has_nonprivate_method = 1;
1517 break;
1518 }
1519 if (!has_nonprivate_method)
1520 {
1521 warning ("all member functions in class `%T' are private", t);
1522 return;
1523 }
1524 }
1525
1526 /* Even if some of the member functions are non-private, the class
1527 won't be useful for much if all the constructors or destructors
1528 are private: such an object can never be created or destroyed. */
1529 if (TYPE_HAS_DESTRUCTOR (t)
1530 && TREE_PRIVATE (CLASSTYPE_DESTRUCTORS (t)))
1531 {
1532 warning ("`%#T' only defines a private destructor and has no friends",
1533 t);
1534 return;
1535 }
1536
1537 if (TYPE_HAS_CONSTRUCTOR (t))
1538 {
1539 int nonprivate_ctor = 0;
1540
1541 /* If a non-template class does not define a copy
1542 constructor, one is defined for it, enabling it to avoid
1543 this warning. For a template class, this does not
1544 happen, and so we would normally get a warning on:
1545
1546 template <class T> class C { private: C(); };
1547
1548 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1549 complete non-template or fully instantiated classes have this
1550 flag set. */
1551 if (!TYPE_HAS_INIT_REF (t))
1552 nonprivate_ctor = 1;
1553 else
1554 for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1555 {
1556 tree ctor = OVL_CURRENT (fn);
1557 /* Ideally, we wouldn't count copy constructors (or, in
1558 fact, any constructor that takes an argument of the
1559 class type as a parameter) because such things cannot
1560 be used to construct an instance of the class unless
1561 you already have one. But, for now at least, we're
1562 more generous. */
1563 if (! TREE_PRIVATE (ctor))
1564 {
1565 nonprivate_ctor = 1;
1566 break;
1567 }
1568 }
1569
1570 if (nonprivate_ctor == 0)
1571 {
1572 warning ("`%#T' only defines private constructors and has no friends",
1573 t);
1574 return;
1575 }
1576 }
1577 }
1578
1579 static struct {
1580 gt_pointer_operator new_value;
1581 void *cookie;
1582 } resort_data;
1583
1584 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1585
1586 static int
1587 method_name_cmp (const void* m1_p, const void* m2_p)
1588 {
1589 const tree *const m1 = m1_p;
1590 const tree *const m2 = m2_p;
1591
1592 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1593 return 0;
1594 if (*m1 == NULL_TREE)
1595 return -1;
1596 if (*m2 == NULL_TREE)
1597 return 1;
1598 if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1599 return -1;
1600 return 1;
1601 }
1602
1603 /* This routine compares two fields like method_name_cmp but using the
1604 pointer operator in resort_field_decl_data. */
1605
1606 static int
1607 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1608 {
1609 const tree *const m1 = m1_p;
1610 const tree *const m2 = m2_p;
1611 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1612 return 0;
1613 if (*m1 == NULL_TREE)
1614 return -1;
1615 if (*m2 == NULL_TREE)
1616 return 1;
1617 {
1618 tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1619 tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1620 resort_data.new_value (&d1, resort_data.cookie);
1621 resort_data.new_value (&d2, resort_data.cookie);
1622 if (d1 < d2)
1623 return -1;
1624 }
1625 return 1;
1626 }
1627
1628 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1629
1630 void
1631 resort_type_method_vec (void* obj,
1632 void* orig_obj ATTRIBUTE_UNUSED ,
1633 gt_pointer_operator new_value,
1634 void* cookie)
1635 {
1636 VEC(tree) *method_vec = (VEC(tree) *) obj;
1637 int len = VEC_length (tree, method_vec);
1638 size_t slot;
1639 tree fn;
1640
1641 /* The type conversion ops have to live at the front of the vec, so we
1642 can't sort them. */
1643 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1644 VEC_iterate (tree, method_vec, slot, fn);
1645 ++slot)
1646 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1647 break;
1648
1649 if (len - slot > 1)
1650 {
1651 resort_data.new_value = new_value;
1652 resort_data.cookie = cookie;
1653 qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1654 resort_method_name_cmp);
1655 }
1656 }
1657
1658 /* Warn about duplicate methods in fn_fields. Also compact method
1659 lists so that lookup can be made faster.
1660
1661 Data Structure: List of method lists. The outer list is a
1662 TREE_LIST, whose TREE_PURPOSE field is the field name and the
1663 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
1664 links the entire list of methods for TYPE_METHODS. Friends are
1665 chained in the same way as member functions (? TREE_CHAIN or
1666 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1667 list. That allows them to be quickly deleted, and requires no
1668 extra storage.
1669
1670 Sort methods that are not special (i.e., constructors, destructors,
1671 and type conversion operators) so that we can find them faster in
1672 search. */
1673
1674 static void
1675 finish_struct_methods (tree t)
1676 {
1677 tree fn_fields;
1678 VEC(tree) *method_vec;
1679 int slot, len;
1680
1681 method_vec = CLASSTYPE_METHOD_VEC (t);
1682 if (!method_vec)
1683 return;
1684
1685 len = VEC_length (tree, method_vec);
1686
1687 /* First fill in entry 0 with the constructors, entry 1 with destructors,
1688 and the next few with type conversion operators (if any). */
1689 for (fn_fields = TYPE_METHODS (t); fn_fields;
1690 fn_fields = TREE_CHAIN (fn_fields))
1691 /* Clear out this flag. */
1692 DECL_IN_AGGR_P (fn_fields) = 0;
1693
1694 if (TYPE_HAS_DESTRUCTOR (t) && !CLASSTYPE_DESTRUCTORS (t))
1695 /* We thought there was a destructor, but there wasn't. Some
1696 parse errors cause this anomalous situation. */
1697 TYPE_HAS_DESTRUCTOR (t) = 0;
1698
1699 /* Issue warnings about private constructors and such. If there are
1700 no methods, then some public defaults are generated. */
1701 maybe_warn_about_overly_private_class (t);
1702
1703 /* The type conversion ops have to live at the front of the vec, so we
1704 can't sort them. */
1705 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1706 VEC_iterate (tree, method_vec, slot, fn_fields);
1707 ++slot)
1708 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1709 break;
1710 if (len - slot > 1)
1711 qsort (VEC_address (tree, method_vec) + slot,
1712 len-slot, sizeof (tree), method_name_cmp);
1713 }
1714
1715 /* Make BINFO's vtable have N entries, including RTTI entries,
1716 vbase and vcall offsets, etc. Set its type and call the backend
1717 to lay it out. */
1718
1719 static void
1720 layout_vtable_decl (tree binfo, int n)
1721 {
1722 tree atype;
1723 tree vtable;
1724
1725 atype = build_cplus_array_type (vtable_entry_type,
1726 build_index_type (size_int (n - 1)));
1727 layout_type (atype);
1728
1729 /* We may have to grow the vtable. */
1730 vtable = get_vtbl_decl_for_binfo (binfo);
1731 if (!same_type_p (TREE_TYPE (vtable), atype))
1732 {
1733 TREE_TYPE (vtable) = atype;
1734 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1735 layout_decl (vtable, 0);
1736 }
1737 }
1738
1739 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1740 have the same signature. */
1741
1742 int
1743 same_signature_p (tree fndecl, tree base_fndecl)
1744 {
1745 /* One destructor overrides another if they are the same kind of
1746 destructor. */
1747 if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1748 && special_function_p (base_fndecl) == special_function_p (fndecl))
1749 return 1;
1750 /* But a non-destructor never overrides a destructor, nor vice
1751 versa, nor do different kinds of destructors override
1752 one-another. For example, a complete object destructor does not
1753 override a deleting destructor. */
1754 if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1755 return 0;
1756
1757 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1758 || (DECL_CONV_FN_P (fndecl)
1759 && DECL_CONV_FN_P (base_fndecl)
1760 && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1761 DECL_CONV_FN_TYPE (base_fndecl))))
1762 {
1763 tree types, base_types;
1764 types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1765 base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1766 if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types)))
1767 == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types))))
1768 && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1769 return 1;
1770 }
1771 return 0;
1772 }
1773
1774 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1775 subobject. */
1776
1777 static bool
1778 base_derived_from (tree derived, tree base)
1779 {
1780 tree probe;
1781
1782 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1783 {
1784 if (probe == derived)
1785 return true;
1786 else if (BINFO_VIRTUAL_P (probe))
1787 /* If we meet a virtual base, we can't follow the inheritance
1788 any more. See if the complete type of DERIVED contains
1789 such a virtual base. */
1790 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1791 != NULL_TREE);
1792 }
1793 return false;
1794 }
1795
1796 typedef struct count_depth_data {
1797 /* The depth of the current subobject, with "1" as the depth of the
1798 most derived object in the hierarchy. */
1799 size_t depth;
1800 /* The maximum depth found so far. */
1801 size_t max_depth;
1802 } count_depth_data;
1803
1804 /* Called from find_final_overrider via dfs_walk. */
1805
1806 static tree
1807 dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1808 {
1809 count_depth_data *cd = (count_depth_data *) data;
1810 if (cd->depth > cd->max_depth)
1811 cd->max_depth = cd->depth;
1812 cd->depth--;
1813 return NULL_TREE;
1814 }
1815
1816 /* Called from find_final_overrider via dfs_walk. */
1817
1818 static tree
1819 dfs_depth_q (tree derived, int i, void *data)
1820 {
1821 count_depth_data *cd = (count_depth_data *) data;
1822 cd->depth++;
1823 return BINFO_BASE_BINFO (derived, i);
1824 }
1825
1826 typedef struct find_final_overrider_data_s {
1827 /* The function for which we are trying to find a final overrider. */
1828 tree fn;
1829 /* The base class in which the function was declared. */
1830 tree declaring_base;
1831 /* The most derived class in the hierarchy. */
1832 tree most_derived_type;
1833 /* The candidate overriders. */
1834 tree candidates;
1835 /* Each entry in this array is the next-most-derived class for a
1836 virtual base class along the current path. */
1837 tree *vpath_list;
1838 /* A pointer one past the top of the VPATH_LIST. */
1839 tree *vpath;
1840 } find_final_overrider_data;
1841
1842 /* Add the overrider along the current path to FFOD->CANDIDATES.
1843 Returns true if an overrider was found; false otherwise. */
1844
1845 static bool
1846 dfs_find_final_overrider_1 (tree binfo,
1847 tree *vpath,
1848 find_final_overrider_data *ffod)
1849 {
1850 tree method;
1851
1852 /* If BINFO is not the most derived type, try a more derived class.
1853 A definition there will overrider a definition here. */
1854 if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type))
1855 {
1856 tree derived;
1857
1858 if (BINFO_VIRTUAL_P (binfo))
1859 derived = *--vpath;
1860 else
1861 derived = BINFO_INHERITANCE_CHAIN (binfo);
1862 if (dfs_find_final_overrider_1 (derived, vpath, ffod))
1863 return true;
1864 }
1865
1866 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1867 if (method)
1868 {
1869 tree *candidate = &ffod->candidates;
1870
1871 /* Remove any candidates overridden by this new function. */
1872 while (*candidate)
1873 {
1874 /* If *CANDIDATE overrides METHOD, then METHOD
1875 cannot override anything else on the list. */
1876 if (base_derived_from (TREE_VALUE (*candidate), binfo))
1877 return true;
1878 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1879 if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1880 *candidate = TREE_CHAIN (*candidate);
1881 else
1882 candidate = &TREE_CHAIN (*candidate);
1883 }
1884
1885 /* Add the new function. */
1886 ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1887 return true;
1888 }
1889
1890 return false;
1891 }
1892
1893 /* Called from find_final_overrider via dfs_walk. */
1894
1895 static tree
1896 dfs_find_final_overrider (tree binfo, void* data)
1897 {
1898 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1899
1900 if (binfo == ffod->declaring_base)
1901 dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod);
1902
1903 return NULL_TREE;
1904 }
1905
1906 static tree
1907 dfs_find_final_overrider_q (tree derived, int ix, void *data)
1908 {
1909 tree binfo = BINFO_BASE_BINFO (derived, ix);
1910 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1911
1912 if (BINFO_VIRTUAL_P (binfo))
1913 *ffod->vpath++ = derived;
1914
1915 return binfo;
1916 }
1917
1918 static tree
1919 dfs_find_final_overrider_post (tree binfo, void *data)
1920 {
1921 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1922
1923 if (BINFO_VIRTUAL_P (binfo))
1924 ffod->vpath--;
1925
1926 return NULL_TREE;
1927 }
1928
1929 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1930 FN and whose TREE_VALUE is the binfo for the base where the
1931 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1932 DERIVED) is the base object in which FN is declared. */
1933
1934 static tree
1935 find_final_overrider (tree derived, tree binfo, tree fn)
1936 {
1937 find_final_overrider_data ffod;
1938 count_depth_data cd;
1939
1940 /* Getting this right is a little tricky. This is valid:
1941
1942 struct S { virtual void f (); };
1943 struct T { virtual void f (); };
1944 struct U : public S, public T { };
1945
1946 even though calling `f' in `U' is ambiguous. But,
1947
1948 struct R { virtual void f(); };
1949 struct S : virtual public R { virtual void f (); };
1950 struct T : virtual public R { virtual void f (); };
1951 struct U : public S, public T { };
1952
1953 is not -- there's no way to decide whether to put `S::f' or
1954 `T::f' in the vtable for `R'.
1955
1956 The solution is to look at all paths to BINFO. If we find
1957 different overriders along any two, then there is a problem. */
1958 if (DECL_THUNK_P (fn))
1959 fn = THUNK_TARGET (fn);
1960
1961 /* Determine the depth of the hierarchy. */
1962 cd.depth = 0;
1963 cd.max_depth = 0;
1964 dfs_walk (derived, dfs_depth_post, dfs_depth_q, &cd);
1965
1966 ffod.fn = fn;
1967 ffod.declaring_base = binfo;
1968 ffod.most_derived_type = BINFO_TYPE (derived);
1969 ffod.candidates = NULL_TREE;
1970 ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree));
1971 ffod.vpath = ffod.vpath_list;
1972
1973 dfs_walk_real (derived,
1974 dfs_find_final_overrider,
1975 dfs_find_final_overrider_post,
1976 dfs_find_final_overrider_q,
1977 &ffod);
1978
1979 free (ffod.vpath_list);
1980
1981 /* If there was no winner, issue an error message. */
1982 if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
1983 {
1984 error ("no unique final overrider for `%D' in `%T'", fn,
1985 BINFO_TYPE (derived));
1986 return error_mark_node;
1987 }
1988
1989 return ffod.candidates;
1990 }
1991
1992 /* Return the index of the vcall offset for FN when TYPE is used as a
1993 virtual base. */
1994
1995 static tree
1996 get_vcall_index (tree fn, tree type)
1997 {
1998 VEC (tree_pair_s) *indices = CLASSTYPE_VCALL_INDICES (type);
1999 tree_pair_p p;
2000 unsigned ix;
2001
2002 for (ix = 0; VEC_iterate (tree_pair_s, indices, ix, p); ix++)
2003 if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2004 || same_signature_p (fn, p->purpose))
2005 return p->value;
2006
2007 /* There should always be an appropriate index. */
2008 gcc_unreachable ();
2009 }
2010
2011 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2012 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
2013 corresponding position in the BINFO_VIRTUALS list. */
2014
2015 static void
2016 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2017 unsigned ix)
2018 {
2019 tree b;
2020 tree overrider;
2021 tree delta;
2022 tree virtual_base;
2023 tree first_defn;
2024 tree overrider_fn, overrider_target;
2025 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2026 tree over_return, base_return;
2027 bool lost = false;
2028
2029 /* Find the nearest primary base (possibly binfo itself) which defines
2030 this function; this is the class the caller will convert to when
2031 calling FN through BINFO. */
2032 for (b = binfo; ; b = get_primary_binfo (b))
2033 {
2034 gcc_assert (b);
2035 if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2036 break;
2037
2038 /* The nearest definition is from a lost primary. */
2039 if (BINFO_LOST_PRIMARY_P (b))
2040 lost = true;
2041 }
2042 first_defn = b;
2043
2044 /* Find the final overrider. */
2045 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2046 if (overrider == error_mark_node)
2047 return;
2048 overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2049
2050 /* Check for adjusting covariant return types. */
2051 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2052 base_return = TREE_TYPE (TREE_TYPE (target_fn));
2053
2054 if (POINTER_TYPE_P (over_return)
2055 && TREE_CODE (over_return) == TREE_CODE (base_return)
2056 && CLASS_TYPE_P (TREE_TYPE (over_return))
2057 && CLASS_TYPE_P (TREE_TYPE (base_return)))
2058 {
2059 /* If FN is a covariant thunk, we must figure out the adjustment
2060 to the final base FN was converting to. As OVERRIDER_TARGET might
2061 also be converting to the return type of FN, we have to
2062 combine the two conversions here. */
2063 tree fixed_offset, virtual_offset;
2064
2065 if (DECL_THUNK_P (fn))
2066 {
2067 gcc_assert (DECL_RESULT_THUNK_P (fn));
2068 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2069 virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2070 }
2071 else
2072 fixed_offset = virtual_offset = NULL_TREE;
2073
2074 if (virtual_offset)
2075 /* Find the equivalent binfo within the return type of the
2076 overriding function. We will want the vbase offset from
2077 there. */
2078 virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2079 TREE_TYPE (over_return));
2080 else if (!same_type_p (TREE_TYPE (over_return),
2081 TREE_TYPE (base_return)))
2082 {
2083 /* There was no existing virtual thunk (which takes
2084 precedence). */
2085 tree thunk_binfo;
2086 base_kind kind;
2087
2088 thunk_binfo = lookup_base (TREE_TYPE (over_return),
2089 TREE_TYPE (base_return),
2090 ba_check | ba_quiet, &kind);
2091
2092 if (thunk_binfo && (kind == bk_via_virtual
2093 || !BINFO_OFFSET_ZEROP (thunk_binfo)))
2094 {
2095 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2096
2097 if (kind == bk_via_virtual)
2098 {
2099 /* We convert via virtual base. Find the virtual
2100 base and adjust the fixed offset to be from there. */
2101 while (!BINFO_VIRTUAL_P (thunk_binfo))
2102 thunk_binfo = BINFO_INHERITANCE_CHAIN (thunk_binfo);
2103
2104 virtual_offset = thunk_binfo;
2105 offset = size_diffop
2106 (offset, convert
2107 (ssizetype, BINFO_OFFSET (virtual_offset)));
2108 }
2109 if (fixed_offset)
2110 /* There was an existing fixed offset, this must be
2111 from the base just converted to, and the base the
2112 FN was thunking to. */
2113 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2114 else
2115 fixed_offset = offset;
2116 }
2117 }
2118
2119 if (fixed_offset || virtual_offset)
2120 /* Replace the overriding function with a covariant thunk. We
2121 will emit the overriding function in its own slot as
2122 well. */
2123 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2124 fixed_offset, virtual_offset);
2125 }
2126 else
2127 gcc_assert (!DECL_THUNK_P (fn));
2128
2129 /* Assume that we will produce a thunk that convert all the way to
2130 the final overrider, and not to an intermediate virtual base. */
2131 virtual_base = NULL_TREE;
2132
2133 /* See if we can convert to an intermediate virtual base first, and then
2134 use the vcall offset located there to finish the conversion. */
2135 for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2136 {
2137 /* If we find the final overrider, then we can stop
2138 walking. */
2139 if (same_type_p (BINFO_TYPE (b),
2140 BINFO_TYPE (TREE_VALUE (overrider))))
2141 break;
2142
2143 /* If we find a virtual base, and we haven't yet found the
2144 overrider, then there is a virtual base between the
2145 declaring base (first_defn) and the final overrider. */
2146 if (BINFO_VIRTUAL_P (b))
2147 {
2148 virtual_base = b;
2149 break;
2150 }
2151 }
2152
2153 if (overrider_fn != overrider_target && !virtual_base)
2154 {
2155 /* The ABI specifies that a covariant thunk includes a mangling
2156 for a this pointer adjustment. This-adjusting thunks that
2157 override a function from a virtual base have a vcall
2158 adjustment. When the virtual base in question is a primary
2159 virtual base, we know the adjustments are zero, (and in the
2160 non-covariant case, we would not use the thunk).
2161 Unfortunately we didn't notice this could happen, when
2162 designing the ABI and so never mandated that such a covariant
2163 thunk should be emitted. Because we must use the ABI mandated
2164 name, we must continue searching from the binfo where we
2165 found the most recent definition of the function, towards the
2166 primary binfo which first introduced the function into the
2167 vtable. If that enters a virtual base, we must use a vcall
2168 this-adjusting thunk. Bleah! */
2169 tree probe = first_defn;
2170
2171 while ((probe = get_primary_binfo (probe))
2172 && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2173 if (BINFO_VIRTUAL_P (probe))
2174 virtual_base = probe;
2175
2176 if (virtual_base)
2177 /* Even if we find a virtual base, the correct delta is
2178 between the overrider and the binfo we're building a vtable
2179 for. */
2180 goto virtual_covariant;
2181 }
2182
2183 /* Compute the constant adjustment to the `this' pointer. The
2184 `this' pointer, when this function is called, will point at BINFO
2185 (or one of its primary bases, which are at the same offset). */
2186 if (virtual_base)
2187 /* The `this' pointer needs to be adjusted from the declaration to
2188 the nearest virtual base. */
2189 delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
2190 convert (ssizetype, BINFO_OFFSET (first_defn)));
2191 else if (lost)
2192 /* If the nearest definition is in a lost primary, we don't need an
2193 entry in our vtable. Except possibly in a constructor vtable,
2194 if we happen to get our primary back. In that case, the offset
2195 will be zero, as it will be a primary base. */
2196 delta = size_zero_node;
2197 else
2198 /* The `this' pointer needs to be adjusted from pointing to
2199 BINFO to pointing at the base where the final overrider
2200 appears. */
2201 virtual_covariant:
2202 delta = size_diffop (convert (ssizetype,
2203 BINFO_OFFSET (TREE_VALUE (overrider))),
2204 convert (ssizetype, BINFO_OFFSET (binfo)));
2205
2206 modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2207
2208 if (virtual_base)
2209 BV_VCALL_INDEX (*virtuals)
2210 = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2211 }
2212
2213 /* Called from modify_all_vtables via dfs_walk. */
2214
2215 static tree
2216 dfs_modify_vtables (tree binfo, void* data)
2217 {
2218 tree t = (tree) data;
2219
2220 if (/* There's no need to modify the vtable for a non-virtual
2221 primary base; we're not going to use that vtable anyhow.
2222 We do still need to do this for virtual primary bases, as they
2223 could become non-primary in a construction vtable. */
2224 (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
2225 /* Similarly, a base without a vtable needs no modification. */
2226 && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))
2227 /* Don't do the primary vtable, if it's new. */
2228 && (BINFO_TYPE (binfo) != t || CLASSTYPE_HAS_PRIMARY_BASE_P (t)))
2229 {
2230 tree virtuals;
2231 tree old_virtuals;
2232 unsigned ix;
2233
2234 make_new_vtable (t, binfo);
2235
2236 /* Now, go through each of the virtual functions in the virtual
2237 function table for BINFO. Find the final overrider, and
2238 update the BINFO_VIRTUALS list appropriately. */
2239 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2240 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2241 virtuals;
2242 ix++, virtuals = TREE_CHAIN (virtuals),
2243 old_virtuals = TREE_CHAIN (old_virtuals))
2244 update_vtable_entry_for_fn (t,
2245 binfo,
2246 BV_FN (old_virtuals),
2247 &virtuals, ix);
2248 }
2249
2250 BINFO_MARKED (binfo) = 1;
2251
2252 return NULL_TREE;
2253 }
2254
2255 /* Update all of the primary and secondary vtables for T. Create new
2256 vtables as required, and initialize their RTTI information. Each
2257 of the functions in VIRTUALS is declared in T and may override a
2258 virtual function from a base class; find and modify the appropriate
2259 entries to point to the overriding functions. Returns a list, in
2260 declaration order, of the virtual functions that are declared in T,
2261 but do not appear in the primary base class vtable, and which
2262 should therefore be appended to the end of the vtable for T. */
2263
2264 static tree
2265 modify_all_vtables (tree t, tree virtuals)
2266 {
2267 tree binfo = TYPE_BINFO (t);
2268 tree *fnsp;
2269
2270 /* Update all of the vtables. */
2271 dfs_walk (binfo, dfs_modify_vtables, unmarkedp, t);
2272 dfs_walk (binfo, dfs_unmark, markedp, t);
2273
2274 /* Add virtual functions not already in our primary vtable. These
2275 will be both those introduced by this class, and those overridden
2276 from secondary bases. It does not include virtuals merely
2277 inherited from secondary bases. */
2278 for (fnsp = &virtuals; *fnsp; )
2279 {
2280 tree fn = TREE_VALUE (*fnsp);
2281
2282 if (!value_member (fn, BINFO_VIRTUALS (binfo))
2283 || DECL_VINDEX (fn) == error_mark_node)
2284 {
2285 /* We don't need to adjust the `this' pointer when
2286 calling this function. */
2287 BV_DELTA (*fnsp) = integer_zero_node;
2288 BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2289
2290 /* This is a function not already in our vtable. Keep it. */
2291 fnsp = &TREE_CHAIN (*fnsp);
2292 }
2293 else
2294 /* We've already got an entry for this function. Skip it. */
2295 *fnsp = TREE_CHAIN (*fnsp);
2296 }
2297
2298 return virtuals;
2299 }
2300
2301 /* Get the base virtual function declarations in T that have the
2302 indicated NAME. */
2303
2304 static tree
2305 get_basefndecls (tree name, tree t)
2306 {
2307 tree methods;
2308 tree base_fndecls = NULL_TREE;
2309 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2310 int i;
2311
2312 /* Find virtual functions in T with the indicated NAME. */
2313 i = lookup_fnfields_1 (t, name);
2314 if (i != -1)
2315 for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2316 methods;
2317 methods = OVL_NEXT (methods))
2318 {
2319 tree method = OVL_CURRENT (methods);
2320
2321 if (TREE_CODE (method) == FUNCTION_DECL
2322 && DECL_VINDEX (method))
2323 base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2324 }
2325
2326 if (base_fndecls)
2327 return base_fndecls;
2328
2329 for (i = 0; i < n_baseclasses; i++)
2330 {
2331 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2332 base_fndecls = chainon (get_basefndecls (name, basetype),
2333 base_fndecls);
2334 }
2335
2336 return base_fndecls;
2337 }
2338
2339 /* If this declaration supersedes the declaration of
2340 a method declared virtual in the base class, then
2341 mark this field as being virtual as well. */
2342
2343 static void
2344 check_for_override (tree decl, tree ctype)
2345 {
2346 if (TREE_CODE (decl) == TEMPLATE_DECL)
2347 /* In [temp.mem] we have:
2348
2349 A specialization of a member function template does not
2350 override a virtual function from a base class. */
2351 return;
2352 if ((DECL_DESTRUCTOR_P (decl)
2353 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2354 || DECL_CONV_FN_P (decl))
2355 && look_for_overrides (ctype, decl)
2356 && !DECL_STATIC_FUNCTION_P (decl))
2357 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2358 the error_mark_node so that we know it is an overriding
2359 function. */
2360 DECL_VINDEX (decl) = decl;
2361
2362 if (DECL_VIRTUAL_P (decl))
2363 {
2364 if (!DECL_VINDEX (decl))
2365 DECL_VINDEX (decl) = error_mark_node;
2366 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2367 }
2368 }
2369
2370 /* Warn about hidden virtual functions that are not overridden in t.
2371 We know that constructors and destructors don't apply. */
2372
2373 void
2374 warn_hidden (tree t)
2375 {
2376 VEC(tree) *method_vec = CLASSTYPE_METHOD_VEC (t);
2377 tree fns;
2378 size_t i;
2379
2380 /* We go through each separately named virtual function. */
2381 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2382 VEC_iterate (tree, method_vec, i, fns);
2383 ++i)
2384 {
2385 tree fn;
2386 tree name;
2387 tree fndecl;
2388 tree base_fndecls;
2389 tree base_binfo;
2390 tree binfo;
2391 int j;
2392
2393 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2394 have the same name. Figure out what name that is. */
2395 name = DECL_NAME (OVL_CURRENT (fns));
2396 /* There are no possibly hidden functions yet. */
2397 base_fndecls = NULL_TREE;
2398 /* Iterate through all of the base classes looking for possibly
2399 hidden functions. */
2400 for (binfo = TYPE_BINFO (t), j = 0;
2401 BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2402 {
2403 tree basetype = BINFO_TYPE (base_binfo);
2404 base_fndecls = chainon (get_basefndecls (name, basetype),
2405 base_fndecls);
2406 }
2407
2408 /* If there are no functions to hide, continue. */
2409 if (!base_fndecls)
2410 continue;
2411
2412 /* Remove any overridden functions. */
2413 for (fn = fns; fn; fn = OVL_NEXT (fn))
2414 {
2415 fndecl = OVL_CURRENT (fn);
2416 if (DECL_VINDEX (fndecl))
2417 {
2418 tree *prev = &base_fndecls;
2419
2420 while (*prev)
2421 /* If the method from the base class has the same
2422 signature as the method from the derived class, it
2423 has been overridden. */
2424 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2425 *prev = TREE_CHAIN (*prev);
2426 else
2427 prev = &TREE_CHAIN (*prev);
2428 }
2429 }
2430
2431 /* Now give a warning for all base functions without overriders,
2432 as they are hidden. */
2433 while (base_fndecls)
2434 {
2435 /* Here we know it is a hider, and no overrider exists. */
2436 cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2437 cp_warning_at (" by `%D'", fns);
2438 base_fndecls = TREE_CHAIN (base_fndecls);
2439 }
2440 }
2441 }
2442
2443 /* Check for things that are invalid. There are probably plenty of other
2444 things we should check for also. */
2445
2446 static void
2447 finish_struct_anon (tree t)
2448 {
2449 tree field;
2450
2451 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2452 {
2453 if (TREE_STATIC (field))
2454 continue;
2455 if (TREE_CODE (field) != FIELD_DECL)
2456 continue;
2457
2458 if (DECL_NAME (field) == NULL_TREE
2459 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2460 {
2461 tree elt = TYPE_FIELDS (TREE_TYPE (field));
2462 for (; elt; elt = TREE_CHAIN (elt))
2463 {
2464 /* We're generally only interested in entities the user
2465 declared, but we also find nested classes by noticing
2466 the TYPE_DECL that we create implicitly. You're
2467 allowed to put one anonymous union inside another,
2468 though, so we explicitly tolerate that. We use
2469 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2470 we also allow unnamed types used for defining fields. */
2471 if (DECL_ARTIFICIAL (elt)
2472 && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2473 || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2474 continue;
2475
2476 if (TREE_CODE (elt) != FIELD_DECL)
2477 {
2478 cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2479 elt);
2480 continue;
2481 }
2482
2483 if (TREE_PRIVATE (elt))
2484 cp_pedwarn_at ("private member `%#D' in anonymous union",
2485 elt);
2486 else if (TREE_PROTECTED (elt))
2487 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2488 elt);
2489
2490 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2491 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2492 }
2493 }
2494 }
2495 }
2496
2497 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2498 will be used later during class template instantiation.
2499 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2500 a non-static member data (FIELD_DECL), a member function
2501 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2502 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2503 When FRIEND_P is nonzero, T is either a friend class
2504 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2505 (FUNCTION_DECL, TEMPLATE_DECL). */
2506
2507 void
2508 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2509 {
2510 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2511 if (CLASSTYPE_TEMPLATE_INFO (type))
2512 CLASSTYPE_DECL_LIST (type)
2513 = tree_cons (friend_p ? NULL_TREE : type,
2514 t, CLASSTYPE_DECL_LIST (type));
2515 }
2516
2517 /* Create default constructors, assignment operators, and so forth for
2518 the type indicated by T, if they are needed.
2519 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2520 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2521 class cannot have a default constructor, copy constructor taking a
2522 const reference argument, or an assignment operator taking a const
2523 reference, respectively. If a virtual destructor is created, its
2524 DECL is returned; otherwise the return value is NULL_TREE. */
2525
2526 static void
2527 add_implicitly_declared_members (tree t,
2528 int cant_have_default_ctor,
2529 int cant_have_const_cctor,
2530 int cant_have_const_assignment)
2531 {
2532 tree default_fn;
2533 tree implicit_fns = NULL_TREE;
2534 tree virtual_dtor = NULL_TREE;
2535 tree *f;
2536
2537 /* Destructor. */
2538 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t))
2539 {
2540 default_fn = implicitly_declare_fn (sfk_destructor, t, /*const_p=*/0);
2541 check_for_override (default_fn, t);
2542
2543 /* If we couldn't make it work, then pretend we didn't need it. */
2544 if (default_fn == void_type_node)
2545 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 0;
2546 else
2547 {
2548 TREE_CHAIN (default_fn) = implicit_fns;
2549 implicit_fns = default_fn;
2550
2551 if (DECL_VINDEX (default_fn))
2552 virtual_dtor = default_fn;
2553 }
2554 }
2555 else
2556 /* Any non-implicit destructor is non-trivial. */
2557 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
2558
2559 /* Default constructor. */
2560 if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor)
2561 {
2562 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2563 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2564 }
2565
2566 /* Copy constructor. */
2567 if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2568 {
2569 TYPE_HAS_INIT_REF (t) = 1;
2570 TYPE_HAS_CONST_INIT_REF (t) = !cant_have_const_cctor;
2571 CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2572 TYPE_HAS_CONSTRUCTOR (t) = 1;
2573 }
2574
2575 /* If there is no assignment operator, one will be created if and
2576 when it is needed. For now, just record whether or not the type
2577 of the parameter to the assignment operator will be a const or
2578 non-const reference. */
2579 if (!TYPE_HAS_ASSIGN_REF (t) && !TYPE_FOR_JAVA (t))
2580 {
2581 TYPE_HAS_ASSIGN_REF (t) = 1;
2582 TYPE_HAS_CONST_ASSIGN_REF (t) = !cant_have_const_assignment;
2583 CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 1;
2584 }
2585
2586 /* Now, hook all of the new functions on to TYPE_METHODS,
2587 and add them to the CLASSTYPE_METHOD_VEC. */
2588 for (f = &implicit_fns; *f; f = &TREE_CHAIN (*f))
2589 {
2590 add_method (t, *f);
2591 maybe_add_class_template_decl_list (current_class_type, *f, /*friend_p=*/0);
2592 }
2593 if (abi_version_at_least (2))
2594 /* G++ 3.2 put the implicit destructor at the *beginning* of the
2595 list, which cause the destructor to be emitted in an incorrect
2596 location in the vtable. */
2597 TYPE_METHODS (t) = chainon (TYPE_METHODS (t), implicit_fns);
2598 else
2599 {
2600 if (warn_abi && virtual_dtor)
2601 warning ("vtable layout for class `%T' may not be ABI-compliant "
2602 "and may change in a future version of GCC due to implicit "
2603 "virtual destructor",
2604 t);
2605 *f = TYPE_METHODS (t);
2606 TYPE_METHODS (t) = implicit_fns;
2607 }
2608 }
2609
2610 /* Subroutine of finish_struct_1. Recursively count the number of fields
2611 in TYPE, including anonymous union members. */
2612
2613 static int
2614 count_fields (tree fields)
2615 {
2616 tree x;
2617 int n_fields = 0;
2618 for (x = fields; x; x = TREE_CHAIN (x))
2619 {
2620 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2621 n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2622 else
2623 n_fields += 1;
2624 }
2625 return n_fields;
2626 }
2627
2628 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2629 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2630
2631 static int
2632 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2633 {
2634 tree x;
2635 for (x = fields; x; x = TREE_CHAIN (x))
2636 {
2637 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2638 idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2639 else
2640 field_vec->elts[idx++] = x;
2641 }
2642 return idx;
2643 }
2644
2645 /* FIELD is a bit-field. We are finishing the processing for its
2646 enclosing type. Issue any appropriate messages and set appropriate
2647 flags. */
2648
2649 static void
2650 check_bitfield_decl (tree field)
2651 {
2652 tree type = TREE_TYPE (field);
2653 tree w = NULL_TREE;
2654
2655 /* Detect invalid bit-field type. */
2656 if (DECL_INITIAL (field)
2657 && ! INTEGRAL_TYPE_P (TREE_TYPE (field)))
2658 {
2659 cp_error_at ("bit-field `%#D' with non-integral type", field);
2660 w = error_mark_node;
2661 }
2662
2663 /* Detect and ignore out of range field width. */
2664 if (DECL_INITIAL (field))
2665 {
2666 w = DECL_INITIAL (field);
2667
2668 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2669 STRIP_NOPS (w);
2670
2671 /* detect invalid field size. */
2672 if (TREE_CODE (w) == CONST_DECL)
2673 w = DECL_INITIAL (w);
2674 else
2675 w = decl_constant_value (w);
2676
2677 if (TREE_CODE (w) != INTEGER_CST)
2678 {
2679 cp_error_at ("bit-field `%D' width not an integer constant",
2680 field);
2681 w = error_mark_node;
2682 }
2683 else if (tree_int_cst_sgn (w) < 0)
2684 {
2685 cp_error_at ("negative width in bit-field `%D'", field);
2686 w = error_mark_node;
2687 }
2688 else if (integer_zerop (w) && DECL_NAME (field) != 0)
2689 {
2690 cp_error_at ("zero width for bit-field `%D'", field);
2691 w = error_mark_node;
2692 }
2693 else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2694 && TREE_CODE (type) != ENUMERAL_TYPE
2695 && TREE_CODE (type) != BOOLEAN_TYPE)
2696 cp_warning_at ("width of `%D' exceeds its type", field);
2697 else if (TREE_CODE (type) == ENUMERAL_TYPE
2698 && (0 > compare_tree_int (w,
2699 min_precision (TYPE_MIN_VALUE (type),
2700 TYPE_UNSIGNED (type)))
2701 || 0 > compare_tree_int (w,
2702 min_precision
2703 (TYPE_MAX_VALUE (type),
2704 TYPE_UNSIGNED (type)))))
2705 cp_warning_at ("`%D' is too small to hold all values of `%#T'",
2706 field, type);
2707 }
2708
2709 /* Remove the bit-field width indicator so that the rest of the
2710 compiler does not treat that value as an initializer. */
2711 DECL_INITIAL (field) = NULL_TREE;
2712
2713 if (w != error_mark_node)
2714 {
2715 DECL_SIZE (field) = convert (bitsizetype, w);
2716 DECL_BIT_FIELD (field) = 1;
2717 }
2718 else
2719 {
2720 /* Non-bit-fields are aligned for their type. */
2721 DECL_BIT_FIELD (field) = 0;
2722 CLEAR_DECL_C_BIT_FIELD (field);
2723 }
2724 }
2725
2726 /* FIELD is a non bit-field. We are finishing the processing for its
2727 enclosing type T. Issue any appropriate messages and set appropriate
2728 flags. */
2729
2730 static void
2731 check_field_decl (tree field,
2732 tree t,
2733 int* cant_have_const_ctor,
2734 int* cant_have_default_ctor,
2735 int* no_const_asn_ref,
2736 int* any_default_members)
2737 {
2738 tree type = strip_array_types (TREE_TYPE (field));
2739
2740 /* An anonymous union cannot contain any fields which would change
2741 the settings of CANT_HAVE_CONST_CTOR and friends. */
2742 if (ANON_UNION_TYPE_P (type))
2743 ;
2744 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2745 structs. So, we recurse through their fields here. */
2746 else if (ANON_AGGR_TYPE_P (type))
2747 {
2748 tree fields;
2749
2750 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2751 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2752 check_field_decl (fields, t, cant_have_const_ctor,
2753 cant_have_default_ctor, no_const_asn_ref,
2754 any_default_members);
2755 }
2756 /* Check members with class type for constructors, destructors,
2757 etc. */
2758 else if (CLASS_TYPE_P (type))
2759 {
2760 /* Never let anything with uninheritable virtuals
2761 make it through without complaint. */
2762 abstract_virtuals_error (field, type);
2763
2764 if (TREE_CODE (t) == UNION_TYPE)
2765 {
2766 if (TYPE_NEEDS_CONSTRUCTING (type))
2767 cp_error_at ("member `%#D' with constructor not allowed in union",
2768 field);
2769 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2770 cp_error_at ("member `%#D' with destructor not allowed in union",
2771 field);
2772 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2773 cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
2774 field);
2775 }
2776 else
2777 {
2778 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2779 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2780 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2781 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2782 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2783 }
2784
2785 if (!TYPE_HAS_CONST_INIT_REF (type))
2786 *cant_have_const_ctor = 1;
2787
2788 if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2789 *no_const_asn_ref = 1;
2790
2791 if (TYPE_HAS_CONSTRUCTOR (type)
2792 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2793 *cant_have_default_ctor = 1;
2794 }
2795 if (DECL_INITIAL (field) != NULL_TREE)
2796 {
2797 /* `build_class_init_list' does not recognize
2798 non-FIELD_DECLs. */
2799 if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2800 error ("multiple fields in union `%T' initialized", t);
2801 *any_default_members = 1;
2802 }
2803 }
2804
2805 /* Check the data members (both static and non-static), class-scoped
2806 typedefs, etc., appearing in the declaration of T. Issue
2807 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2808 declaration order) of access declarations; each TREE_VALUE in this
2809 list is a USING_DECL.
2810
2811 In addition, set the following flags:
2812
2813 EMPTY_P
2814 The class is empty, i.e., contains no non-static data members.
2815
2816 CANT_HAVE_DEFAULT_CTOR_P
2817 This class cannot have an implicitly generated default
2818 constructor.
2819
2820 CANT_HAVE_CONST_CTOR_P
2821 This class cannot have an implicitly generated copy constructor
2822 taking a const reference.
2823
2824 CANT_HAVE_CONST_ASN_REF
2825 This class cannot have an implicitly generated assignment
2826 operator taking a const reference.
2827
2828 All of these flags should be initialized before calling this
2829 function.
2830
2831 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2832 fields can be added by adding to this chain. */
2833
2834 static void
2835 check_field_decls (tree t, tree *access_decls,
2836 int *cant_have_default_ctor_p,
2837 int *cant_have_const_ctor_p,
2838 int *no_const_asn_ref_p)
2839 {
2840 tree *field;
2841 tree *next;
2842 bool has_pointers;
2843 int any_default_members;
2844
2845 /* Assume there are no access declarations. */
2846 *access_decls = NULL_TREE;
2847 /* Assume this class has no pointer members. */
2848 has_pointers = false;
2849 /* Assume none of the members of this class have default
2850 initializations. */
2851 any_default_members = 0;
2852
2853 for (field = &TYPE_FIELDS (t); *field; field = next)
2854 {
2855 tree x = *field;
2856 tree type = TREE_TYPE (x);
2857
2858 next = &TREE_CHAIN (x);
2859
2860 if (TREE_CODE (x) == FIELD_DECL)
2861 {
2862 if (TYPE_PACKED (t))
2863 {
2864 if (!pod_type_p (TREE_TYPE (x)) && !TYPE_PACKED (TREE_TYPE (x)))
2865 cp_warning_at
2866 ("ignoring packed attribute on unpacked non-POD field `%#D'",
2867 x);
2868 else
2869 DECL_PACKED (x) = 1;
2870 }
2871
2872 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
2873 /* We don't treat zero-width bitfields as making a class
2874 non-empty. */
2875 ;
2876 else
2877 {
2878 tree element_type;
2879
2880 /* The class is non-empty. */
2881 CLASSTYPE_EMPTY_P (t) = 0;
2882 /* The class is not even nearly empty. */
2883 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
2884 /* If one of the data members contains an empty class,
2885 so does T. */
2886 element_type = strip_array_types (type);
2887 if (CLASS_TYPE_P (element_type)
2888 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
2889 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
2890 }
2891 }
2892
2893 if (TREE_CODE (x) == USING_DECL)
2894 {
2895 /* Prune the access declaration from the list of fields. */
2896 *field = TREE_CHAIN (x);
2897
2898 /* Save the access declarations for our caller. */
2899 *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2900
2901 /* Since we've reset *FIELD there's no reason to skip to the
2902 next field. */
2903 next = field;
2904 continue;
2905 }
2906
2907 if (TREE_CODE (x) == TYPE_DECL
2908 || TREE_CODE (x) == TEMPLATE_DECL)
2909 continue;
2910
2911 /* If we've gotten this far, it's a data member, possibly static,
2912 or an enumerator. */
2913 DECL_CONTEXT (x) = t;
2914
2915 /* When this goes into scope, it will be a non-local reference. */
2916 DECL_NONLOCAL (x) = 1;
2917
2918 if (TREE_CODE (t) == UNION_TYPE)
2919 {
2920 /* [class.union]
2921
2922 If a union contains a static data member, or a member of
2923 reference type, the program is ill-formed. */
2924 if (TREE_CODE (x) == VAR_DECL)
2925 {
2926 cp_error_at ("`%D' may not be static because it is a member of a union", x);
2927 continue;
2928 }
2929 if (TREE_CODE (type) == REFERENCE_TYPE)
2930 {
2931 cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union",
2932 x, type);
2933 continue;
2934 }
2935 }
2936
2937 /* ``A local class cannot have static data members.'' ARM 9.4 */
2938 if (current_function_decl && TREE_STATIC (x))
2939 cp_error_at ("field `%D' in local class cannot be static", x);
2940
2941 /* Perform error checking that did not get done in
2942 grokdeclarator. */
2943 if (TREE_CODE (type) == FUNCTION_TYPE)
2944 {
2945 cp_error_at ("field `%D' invalidly declared function type",
2946 x);
2947 type = build_pointer_type (type);
2948 TREE_TYPE (x) = type;
2949 }
2950 else if (TREE_CODE (type) == METHOD_TYPE)
2951 {
2952 cp_error_at ("field `%D' invalidly declared method type", x);
2953 type = build_pointer_type (type);
2954 TREE_TYPE (x) = type;
2955 }
2956
2957 if (type == error_mark_node)
2958 continue;
2959
2960 if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
2961 continue;
2962
2963 /* Now it can only be a FIELD_DECL. */
2964
2965 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
2966 CLASSTYPE_NON_AGGREGATE (t) = 1;
2967
2968 /* If this is of reference type, check if it needs an init.
2969 Also do a little ANSI jig if necessary. */
2970 if (TREE_CODE (type) == REFERENCE_TYPE)
2971 {
2972 CLASSTYPE_NON_POD_P (t) = 1;
2973 if (DECL_INITIAL (x) == NULL_TREE)
2974 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
2975
2976 /* ARM $12.6.2: [A member initializer list] (or, for an
2977 aggregate, initialization by a brace-enclosed list) is the
2978 only way to initialize nonstatic const and reference
2979 members. */
2980 *cant_have_default_ctor_p = 1;
2981 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
2982
2983 if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
2984 && extra_warnings)
2985 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
2986 }
2987
2988 type = strip_array_types (type);
2989
2990 /* This is used by -Weffc++ (see below). Warn only for pointers
2991 to members which might hold dynamic memory. So do not warn
2992 for pointers to functions or pointers to members. */
2993 if (TYPE_PTR_P (type)
2994 && !TYPE_PTRFN_P (type)
2995 && !TYPE_PTR_TO_MEMBER_P (type))
2996 has_pointers = true;
2997
2998 if (CLASS_TYPE_P (type))
2999 {
3000 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3001 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3002 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3003 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3004 }
3005
3006 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3007 CLASSTYPE_HAS_MUTABLE (t) = 1;
3008
3009 if (! pod_type_p (type))
3010 /* DR 148 now allows pointers to members (which are POD themselves),
3011 to be allowed in POD structs. */
3012 CLASSTYPE_NON_POD_P (t) = 1;
3013
3014 if (! zero_init_p (type))
3015 CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3016
3017 /* If any field is const, the structure type is pseudo-const. */
3018 if (CP_TYPE_CONST_P (type))
3019 {
3020 C_TYPE_FIELDS_READONLY (t) = 1;
3021 if (DECL_INITIAL (x) == NULL_TREE)
3022 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3023
3024 /* ARM $12.6.2: [A member initializer list] (or, for an
3025 aggregate, initialization by a brace-enclosed list) is the
3026 only way to initialize nonstatic const and reference
3027 members. */
3028 *cant_have_default_ctor_p = 1;
3029 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3030
3031 if (! TYPE_HAS_CONSTRUCTOR (t) && CLASSTYPE_NON_AGGREGATE (t)
3032 && extra_warnings)
3033 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3034 }
3035 /* A field that is pseudo-const makes the structure likewise. */
3036 else if (CLASS_TYPE_P (type))
3037 {
3038 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3039 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3040 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3041 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3042 }
3043
3044 /* Core issue 80: A nonstatic data member is required to have a
3045 different name from the class iff the class has a
3046 user-defined constructor. */
3047 if (constructor_name_p (DECL_NAME (x), t) && TYPE_HAS_CONSTRUCTOR (t))
3048 cp_pedwarn_at ("field `%#D' with same name as class", x);
3049
3050 /* We set DECL_C_BIT_FIELD in grokbitfield.
3051 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3052 if (DECL_C_BIT_FIELD (x))
3053 check_bitfield_decl (x);
3054 else
3055 check_field_decl (x, t,
3056 cant_have_const_ctor_p,
3057 cant_have_default_ctor_p,
3058 no_const_asn_ref_p,
3059 &any_default_members);
3060 }
3061
3062 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3063 it should also define a copy constructor and an assignment operator to
3064 implement the correct copy semantic (deep vs shallow, etc.). As it is
3065 not feasible to check whether the constructors do allocate dynamic memory
3066 and store it within members, we approximate the warning like this:
3067
3068 -- Warn only if there are members which are pointers
3069 -- Warn only if there is a non-trivial constructor (otherwise,
3070 there cannot be memory allocated).
3071 -- Warn only if there is a non-trivial destructor. We assume that the
3072 user at least implemented the cleanup correctly, and a destructor
3073 is needed to free dynamic memory.
3074
3075 This seems enough for pratical purposes. */
3076 if (warn_ecpp
3077 && has_pointers
3078 && TYPE_HAS_CONSTRUCTOR (t)
3079 && TYPE_HAS_DESTRUCTOR (t)
3080 && !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3081 {
3082 warning ("`%#T' has pointer data members", t);
3083
3084 if (! TYPE_HAS_INIT_REF (t))
3085 {
3086 warning (" but does not override `%T(const %T&)'", t, t);
3087 if (! TYPE_HAS_ASSIGN_REF (t))
3088 warning (" or `operator=(const %T&)'", t);
3089 }
3090 else if (! TYPE_HAS_ASSIGN_REF (t))
3091 warning (" but does not override `operator=(const %T&)'", t);
3092 }
3093
3094
3095 /* Check anonymous struct/anonymous union fields. */
3096 finish_struct_anon (t);
3097
3098 /* We've built up the list of access declarations in reverse order.
3099 Fix that now. */
3100 *access_decls = nreverse (*access_decls);
3101 }
3102
3103 /* If TYPE is an empty class type, records its OFFSET in the table of
3104 OFFSETS. */
3105
3106 static int
3107 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3108 {
3109 splay_tree_node n;
3110
3111 if (!is_empty_class (type))
3112 return 0;
3113
3114 /* Record the location of this empty object in OFFSETS. */
3115 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3116 if (!n)
3117 n = splay_tree_insert (offsets,
3118 (splay_tree_key) offset,
3119 (splay_tree_value) NULL_TREE);
3120 n->value = ((splay_tree_value)
3121 tree_cons (NULL_TREE,
3122 type,
3123 (tree) n->value));
3124
3125 return 0;
3126 }
3127
3128 /* Returns nonzero if TYPE is an empty class type and there is
3129 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3130
3131 static int
3132 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3133 {
3134 splay_tree_node n;
3135 tree t;
3136
3137 if (!is_empty_class (type))
3138 return 0;
3139
3140 /* Record the location of this empty object in OFFSETS. */
3141 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3142 if (!n)
3143 return 0;
3144
3145 for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3146 if (same_type_p (TREE_VALUE (t), type))
3147 return 1;
3148
3149 return 0;
3150 }
3151
3152 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3153 F for every subobject, passing it the type, offset, and table of
3154 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3155 be traversed.
3156
3157 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3158 than MAX_OFFSET will not be walked.
3159
3160 If F returns a nonzero value, the traversal ceases, and that value
3161 is returned. Otherwise, returns zero. */
3162
3163 static int
3164 walk_subobject_offsets (tree type,
3165 subobject_offset_fn f,
3166 tree offset,
3167 splay_tree offsets,
3168 tree max_offset,
3169 int vbases_p)
3170 {
3171 int r = 0;
3172 tree type_binfo = NULL_TREE;
3173
3174 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3175 stop. */
3176 if (max_offset && INT_CST_LT (max_offset, offset))
3177 return 0;
3178
3179 if (!TYPE_P (type))
3180 {
3181 if (abi_version_at_least (2))
3182 type_binfo = type;
3183 type = BINFO_TYPE (type);
3184 }
3185
3186 if (CLASS_TYPE_P (type))
3187 {
3188 tree field;
3189 tree binfo;
3190 int i;
3191
3192 /* Avoid recursing into objects that are not interesting. */
3193 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3194 return 0;
3195
3196 /* Record the location of TYPE. */
3197 r = (*f) (type, offset, offsets);
3198 if (r)
3199 return r;
3200
3201 /* Iterate through the direct base classes of TYPE. */
3202 if (!type_binfo)
3203 type_binfo = TYPE_BINFO (type);
3204 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3205 {
3206 tree binfo_offset;
3207
3208 if (abi_version_at_least (2)
3209 && BINFO_VIRTUAL_P (binfo))
3210 continue;
3211
3212 if (!vbases_p
3213 && BINFO_VIRTUAL_P (binfo)
3214 && !BINFO_PRIMARY_P (binfo))
3215 continue;
3216
3217 if (!abi_version_at_least (2))
3218 binfo_offset = size_binop (PLUS_EXPR,
3219 offset,
3220 BINFO_OFFSET (binfo));
3221 else
3222 {
3223 tree orig_binfo;
3224 /* We cannot rely on BINFO_OFFSET being set for the base
3225 class yet, but the offsets for direct non-virtual
3226 bases can be calculated by going back to the TYPE. */
3227 orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3228 binfo_offset = size_binop (PLUS_EXPR,
3229 offset,
3230 BINFO_OFFSET (orig_binfo));
3231 }
3232
3233 r = walk_subobject_offsets (binfo,
3234 f,
3235 binfo_offset,
3236 offsets,
3237 max_offset,
3238 (abi_version_at_least (2)
3239 ? /*vbases_p=*/0 : vbases_p));
3240 if (r)
3241 return r;
3242 }
3243
3244 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3245 {
3246 unsigned ix;
3247 VEC (tree) *vbases;
3248
3249 /* Iterate through the virtual base classes of TYPE. In G++
3250 3.2, we included virtual bases in the direct base class
3251 loop above, which results in incorrect results; the
3252 correct offsets for virtual bases are only known when
3253 working with the most derived type. */
3254 if (vbases_p)
3255 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3256 VEC_iterate (tree, vbases, ix, binfo); ix++)
3257 {
3258 r = walk_subobject_offsets (binfo,
3259 f,
3260 size_binop (PLUS_EXPR,
3261 offset,
3262 BINFO_OFFSET (binfo)),
3263 offsets,
3264 max_offset,
3265 /*vbases_p=*/0);
3266 if (r)
3267 return r;
3268 }
3269 else
3270 {
3271 /* We still have to walk the primary base, if it is
3272 virtual. (If it is non-virtual, then it was walked
3273 above.) */
3274 tree vbase = get_primary_binfo (type_binfo);
3275
3276 if (vbase && BINFO_VIRTUAL_P (vbase)
3277 && BINFO_PRIMARY_P (vbase)
3278 && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3279 {
3280 r = (walk_subobject_offsets
3281 (vbase, f, offset,
3282 offsets, max_offset, /*vbases_p=*/0));
3283 if (r)
3284 return r;
3285 }
3286 }
3287 }
3288
3289 /* Iterate through the fields of TYPE. */
3290 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3291 if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3292 {
3293 tree field_offset;
3294
3295 if (abi_version_at_least (2))
3296 field_offset = byte_position (field);
3297 else
3298 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3299 field_offset = DECL_FIELD_OFFSET (field);
3300
3301 r = walk_subobject_offsets (TREE_TYPE (field),
3302 f,
3303 size_binop (PLUS_EXPR,
3304 offset,
3305 field_offset),
3306 offsets,
3307 max_offset,
3308 /*vbases_p=*/1);
3309 if (r)
3310 return r;
3311 }
3312 }
3313 else if (TREE_CODE (type) == ARRAY_TYPE)
3314 {
3315 tree element_type = strip_array_types (type);
3316 tree domain = TYPE_DOMAIN (type);
3317 tree index;
3318
3319 /* Avoid recursing into objects that are not interesting. */
3320 if (!CLASS_TYPE_P (element_type)
3321 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3322 return 0;
3323
3324 /* Step through each of the elements in the array. */
3325 for (index = size_zero_node;
3326 /* G++ 3.2 had an off-by-one error here. */
3327 (abi_version_at_least (2)
3328 ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3329 : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3330 index = size_binop (PLUS_EXPR, index, size_one_node))
3331 {
3332 r = walk_subobject_offsets (TREE_TYPE (type),
3333 f,
3334 offset,
3335 offsets,
3336 max_offset,
3337 /*vbases_p=*/1);
3338 if (r)
3339 return r;
3340 offset = size_binop (PLUS_EXPR, offset,
3341 TYPE_SIZE_UNIT (TREE_TYPE (type)));
3342 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3343 there's no point in iterating through the remaining
3344 elements of the array. */
3345 if (max_offset && INT_CST_LT (max_offset, offset))
3346 break;
3347 }
3348 }
3349
3350 return 0;
3351 }
3352
3353 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3354 OFFSETS. If VBASES_P is nonzero, virtual bases of TYPE are
3355 examined. */
3356
3357 static void
3358 record_subobject_offsets (tree type,
3359 tree offset,
3360 splay_tree offsets,
3361 int vbases_p)
3362 {
3363 walk_subobject_offsets (type, record_subobject_offset, offset,
3364 offsets, /*max_offset=*/NULL_TREE, vbases_p);
3365 }
3366
3367 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3368 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3369 virtual bases of TYPE are examined. */
3370
3371 static int
3372 layout_conflict_p (tree type,
3373 tree offset,
3374 splay_tree offsets,
3375 int vbases_p)
3376 {
3377 splay_tree_node max_node;
3378
3379 /* Get the node in OFFSETS that indicates the maximum offset where
3380 an empty subobject is located. */
3381 max_node = splay_tree_max (offsets);
3382 /* If there aren't any empty subobjects, then there's no point in
3383 performing this check. */
3384 if (!max_node)
3385 return 0;
3386
3387 return walk_subobject_offsets (type, check_subobject_offset, offset,
3388 offsets, (tree) (max_node->key),
3389 vbases_p);
3390 }
3391
3392 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3393 non-static data member of the type indicated by RLI. BINFO is the
3394 binfo corresponding to the base subobject, OFFSETS maps offsets to
3395 types already located at those offsets. This function determines
3396 the position of the DECL. */
3397
3398 static void
3399 layout_nonempty_base_or_field (record_layout_info rli,
3400 tree decl,
3401 tree binfo,
3402 splay_tree offsets)
3403 {
3404 tree offset = NULL_TREE;
3405 bool field_p;
3406 tree type;
3407
3408 if (binfo)
3409 {
3410 /* For the purposes of determining layout conflicts, we want to
3411 use the class type of BINFO; TREE_TYPE (DECL) will be the
3412 CLASSTYPE_AS_BASE version, which does not contain entries for
3413 zero-sized bases. */
3414 type = TREE_TYPE (binfo);
3415 field_p = false;
3416 }
3417 else
3418 {
3419 type = TREE_TYPE (decl);
3420 field_p = true;
3421 }
3422
3423 /* Try to place the field. It may take more than one try if we have
3424 a hard time placing the field without putting two objects of the
3425 same type at the same address. */
3426 while (1)
3427 {
3428 struct record_layout_info_s old_rli = *rli;
3429
3430 /* Place this field. */
3431 place_field (rli, decl);
3432 offset = byte_position (decl);
3433
3434 /* We have to check to see whether or not there is already
3435 something of the same type at the offset we're about to use.
3436 For example, consider:
3437
3438 struct S {};
3439 struct T : public S { int i; };
3440 struct U : public S, public T {};
3441
3442 Here, we put S at offset zero in U. Then, we can't put T at
3443 offset zero -- its S component would be at the same address
3444 as the S we already allocated. So, we have to skip ahead.
3445 Since all data members, including those whose type is an
3446 empty class, have nonzero size, any overlap can happen only
3447 with a direct or indirect base-class -- it can't happen with
3448 a data member. */
3449 /* In a union, overlap is permitted; all members are placed at
3450 offset zero. */
3451 if (TREE_CODE (rli->t) == UNION_TYPE)
3452 break;
3453 /* G++ 3.2 did not check for overlaps when placing a non-empty
3454 virtual base. */
3455 if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3456 break;
3457 if (layout_conflict_p (field_p ? type : binfo, offset,
3458 offsets, field_p))
3459 {
3460 /* Strip off the size allocated to this field. That puts us
3461 at the first place we could have put the field with
3462 proper alignment. */
3463 *rli = old_rli;
3464
3465 /* Bump up by the alignment required for the type. */
3466 rli->bitpos
3467 = size_binop (PLUS_EXPR, rli->bitpos,
3468 bitsize_int (binfo
3469 ? CLASSTYPE_ALIGN (type)
3470 : TYPE_ALIGN (type)));
3471 normalize_rli (rli);
3472 }
3473 else
3474 /* There was no conflict. We're done laying out this field. */
3475 break;
3476 }
3477
3478 /* Now that we know where it will be placed, update its
3479 BINFO_OFFSET. */
3480 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3481 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3482 this point because their BINFO_OFFSET is copied from another
3483 hierarchy. Therefore, we may not need to add the entire
3484 OFFSET. */
3485 propagate_binfo_offsets (binfo,
3486 size_diffop (convert (ssizetype, offset),
3487 convert (ssizetype,
3488 BINFO_OFFSET (binfo))));
3489 }
3490
3491 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3492
3493 static int
3494 empty_base_at_nonzero_offset_p (tree type,
3495 tree offset,
3496 splay_tree offsets ATTRIBUTE_UNUSED)
3497 {
3498 return is_empty_class (type) && !integer_zerop (offset);
3499 }
3500
3501 /* Layout the empty base BINFO. EOC indicates the byte currently just
3502 past the end of the class, and should be correctly aligned for a
3503 class of the type indicated by BINFO; OFFSETS gives the offsets of
3504 the empty bases allocated so far. T is the most derived
3505 type. Return nonzero iff we added it at the end. */
3506
3507 static bool
3508 layout_empty_base (tree binfo, tree eoc, splay_tree offsets)
3509 {
3510 tree alignment;
3511 tree basetype = BINFO_TYPE (binfo);
3512 bool atend = false;
3513
3514 /* This routine should only be used for empty classes. */
3515 gcc_assert (is_empty_class (basetype));
3516 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3517
3518 if (!integer_zerop (BINFO_OFFSET (binfo)))
3519 {
3520 if (abi_version_at_least (2))
3521 propagate_binfo_offsets
3522 (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
3523 else if (warn_abi)
3524 warning ("offset of empty base `%T' may not be ABI-compliant and may"
3525 "change in a future version of GCC",
3526 BINFO_TYPE (binfo));
3527 }
3528
3529 /* This is an empty base class. We first try to put it at offset
3530 zero. */
3531 if (layout_conflict_p (binfo,
3532 BINFO_OFFSET (binfo),
3533 offsets,
3534 /*vbases_p=*/0))
3535 {
3536 /* That didn't work. Now, we move forward from the next
3537 available spot in the class. */
3538 atend = true;
3539 propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3540 while (1)
3541 {
3542 if (!layout_conflict_p (binfo,
3543 BINFO_OFFSET (binfo),
3544 offsets,
3545 /*vbases_p=*/0))
3546 /* We finally found a spot where there's no overlap. */
3547 break;
3548
3549 /* There's overlap here, too. Bump along to the next spot. */
3550 propagate_binfo_offsets (binfo, alignment);
3551 }
3552 }
3553 return atend;
3554 }
3555
3556 /* Layout the the base given by BINFO in the class indicated by RLI.
3557 *BASE_ALIGN is a running maximum of the alignments of
3558 any base class. OFFSETS gives the location of empty base
3559 subobjects. T is the most derived type. Return nonzero if the new
3560 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3561 *NEXT_FIELD, unless BINFO is for an empty base class.
3562
3563 Returns the location at which the next field should be inserted. */
3564
3565 static tree *
3566 build_base_field (record_layout_info rli, tree binfo,
3567 splay_tree offsets, tree *next_field)
3568 {
3569 tree t = rli->t;
3570 tree basetype = BINFO_TYPE (binfo);
3571
3572 if (!COMPLETE_TYPE_P (basetype))
3573 /* This error is now reported in xref_tag, thus giving better
3574 location information. */
3575 return next_field;
3576
3577 /* Place the base class. */
3578 if (!is_empty_class (basetype))
3579 {
3580 tree decl;
3581
3582 /* The containing class is non-empty because it has a non-empty
3583 base class. */
3584 CLASSTYPE_EMPTY_P (t) = 0;
3585
3586 /* Create the FIELD_DECL. */
3587 decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3588 DECL_ARTIFICIAL (decl) = 1;
3589 DECL_FIELD_CONTEXT (decl) = t;
3590 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3591 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3592 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3593 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3594 DECL_IGNORED_P (decl) = 1;
3595 DECL_FIELD_IS_BASE (decl) = 1;
3596
3597 /* Try to place the field. It may take more than one try if we
3598 have a hard time placing the field without putting two
3599 objects of the same type at the same address. */
3600 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3601 /* Add the new FIELD_DECL to the list of fields for T. */
3602 TREE_CHAIN (decl) = *next_field;
3603 *next_field = decl;
3604 next_field = &TREE_CHAIN (decl);
3605 }
3606 else
3607 {
3608 tree eoc;
3609 bool atend;
3610
3611 /* On some platforms (ARM), even empty classes will not be
3612 byte-aligned. */
3613 eoc = round_up (rli_size_unit_so_far (rli),
3614 CLASSTYPE_ALIGN_UNIT (basetype));
3615 atend = layout_empty_base (binfo, eoc, offsets);
3616 /* A nearly-empty class "has no proper base class that is empty,
3617 not morally virtual, and at an offset other than zero." */
3618 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3619 {
3620 if (atend)
3621 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3622 /* The check above (used in G++ 3.2) is insufficient because
3623 an empty class placed at offset zero might itself have an
3624 empty base at a nonzero offset. */
3625 else if (walk_subobject_offsets (basetype,
3626 empty_base_at_nonzero_offset_p,
3627 size_zero_node,
3628 /*offsets=*/NULL,
3629 /*max_offset=*/NULL_TREE,
3630 /*vbases_p=*/true))
3631 {
3632 if (abi_version_at_least (2))
3633 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3634 else if (warn_abi)
3635 warning ("class `%T' will be considered nearly empty in a "
3636 "future version of GCC", t);
3637 }
3638 }
3639
3640 /* We do not create a FIELD_DECL for empty base classes because
3641 it might overlap some other field. We want to be able to
3642 create CONSTRUCTORs for the class by iterating over the
3643 FIELD_DECLs, and the back end does not handle overlapping
3644 FIELD_DECLs. */
3645
3646 /* An empty virtual base causes a class to be non-empty
3647 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3648 here because that was already done when the virtual table
3649 pointer was created. */
3650 }
3651
3652 /* Record the offsets of BINFO and its base subobjects. */
3653 record_subobject_offsets (binfo,
3654 BINFO_OFFSET (binfo),
3655 offsets,
3656 /*vbases_p=*/0);
3657
3658 return next_field;
3659 }
3660
3661 /* Layout all of the non-virtual base classes. Record empty
3662 subobjects in OFFSETS. T is the most derived type. Return nonzero
3663 if the type cannot be nearly empty. The fields created
3664 corresponding to the base classes will be inserted at
3665 *NEXT_FIELD. */
3666
3667 static void
3668 build_base_fields (record_layout_info rli,
3669 splay_tree offsets, tree *next_field)
3670 {
3671 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3672 subobjects. */
3673 tree t = rli->t;
3674 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3675 int i;
3676
3677 /* The primary base class is always allocated first. */
3678 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3679 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3680 offsets, next_field);
3681
3682 /* Now allocate the rest of the bases. */
3683 for (i = 0; i < n_baseclasses; ++i)
3684 {
3685 tree base_binfo;
3686
3687 base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3688
3689 /* The primary base was already allocated above, so we don't
3690 need to allocate it again here. */
3691 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3692 continue;
3693
3694 /* Virtual bases are added at the end (a primary virtual base
3695 will have already been added). */
3696 if (BINFO_VIRTUAL_P (base_binfo))
3697 continue;
3698
3699 next_field = build_base_field (rli, base_binfo,
3700 offsets, next_field);
3701 }
3702 }
3703
3704 /* Go through the TYPE_METHODS of T issuing any appropriate
3705 diagnostics, figuring out which methods override which other
3706 methods, and so forth. */
3707
3708 static void
3709 check_methods (tree t)
3710 {
3711 tree x;
3712
3713 for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3714 {
3715 check_for_override (x, t);
3716 if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3717 cp_error_at ("initializer specified for non-virtual method `%D'", x);
3718 /* The name of the field is the original field name
3719 Save this in auxiliary field for later overloading. */
3720 if (DECL_VINDEX (x))
3721 {
3722 TYPE_POLYMORPHIC_P (t) = 1;
3723 if (DECL_PURE_VIRTUAL_P (x))
3724 CLASSTYPE_PURE_VIRTUALS (t)
3725 = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t));
3726 }
3727 }
3728 }
3729
3730 /* FN is a constructor or destructor. Clone the declaration to create
3731 a specialized in-charge or not-in-charge version, as indicated by
3732 NAME. */
3733
3734 static tree
3735 build_clone (tree fn, tree name)
3736 {
3737 tree parms;
3738 tree clone;
3739
3740 /* Copy the function. */
3741 clone = copy_decl (fn);
3742 /* Remember where this function came from. */
3743 DECL_CLONED_FUNCTION (clone) = fn;
3744 DECL_ABSTRACT_ORIGIN (clone) = fn;
3745 /* Reset the function name. */
3746 DECL_NAME (clone) = name;
3747 SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3748 /* There's no pending inline data for this function. */
3749 DECL_PENDING_INLINE_INFO (clone) = NULL;
3750 DECL_PENDING_INLINE_P (clone) = 0;
3751 /* And it hasn't yet been deferred. */
3752 DECL_DEFERRED_FN (clone) = 0;
3753
3754 /* The base-class destructor is not virtual. */
3755 if (name == base_dtor_identifier)
3756 {
3757 DECL_VIRTUAL_P (clone) = 0;
3758 if (TREE_CODE (clone) != TEMPLATE_DECL)
3759 DECL_VINDEX (clone) = NULL_TREE;
3760 }
3761
3762 /* If there was an in-charge parameter, drop it from the function
3763 type. */
3764 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3765 {
3766 tree basetype;
3767 tree parmtypes;
3768 tree exceptions;
3769
3770 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3771 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3772 parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3773 /* Skip the `this' parameter. */
3774 parmtypes = TREE_CHAIN (parmtypes);
3775 /* Skip the in-charge parameter. */
3776 parmtypes = TREE_CHAIN (parmtypes);
3777 /* And the VTT parm, in a complete [cd]tor. */
3778 if (DECL_HAS_VTT_PARM_P (fn)
3779 && ! DECL_NEEDS_VTT_PARM_P (clone))
3780 parmtypes = TREE_CHAIN (parmtypes);
3781 /* If this is subobject constructor or destructor, add the vtt
3782 parameter. */
3783 TREE_TYPE (clone)
3784 = build_method_type_directly (basetype,
3785 TREE_TYPE (TREE_TYPE (clone)),
3786 parmtypes);
3787 if (exceptions)
3788 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3789 exceptions);
3790 TREE_TYPE (clone)
3791 = cp_build_type_attribute_variant (TREE_TYPE (clone),
3792 TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3793 }
3794
3795 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
3796 aren't function parameters; those are the template parameters. */
3797 if (TREE_CODE (clone) != TEMPLATE_DECL)
3798 {
3799 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3800 /* Remove the in-charge parameter. */
3801 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3802 {
3803 TREE_CHAIN (DECL_ARGUMENTS (clone))
3804 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3805 DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3806 }
3807 /* And the VTT parm, in a complete [cd]tor. */
3808 if (DECL_HAS_VTT_PARM_P (fn))
3809 {
3810 if (DECL_NEEDS_VTT_PARM_P (clone))
3811 DECL_HAS_VTT_PARM_P (clone) = 1;
3812 else
3813 {
3814 TREE_CHAIN (DECL_ARGUMENTS (clone))
3815 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3816 DECL_HAS_VTT_PARM_P (clone) = 0;
3817 }
3818 }
3819
3820 for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3821 {
3822 DECL_CONTEXT (parms) = clone;
3823 cxx_dup_lang_specific_decl (parms);
3824 }
3825 }
3826
3827 /* Create the RTL for this function. */
3828 SET_DECL_RTL (clone, NULL_RTX);
3829 rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
3830
3831 /* Make it easy to find the CLONE given the FN. */
3832 TREE_CHAIN (clone) = TREE_CHAIN (fn);
3833 TREE_CHAIN (fn) = clone;
3834
3835 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
3836 if (TREE_CODE (clone) == TEMPLATE_DECL)
3837 {
3838 tree result;
3839
3840 DECL_TEMPLATE_RESULT (clone)
3841 = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3842 result = DECL_TEMPLATE_RESULT (clone);
3843 DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3844 DECL_TI_TEMPLATE (result) = clone;
3845 }
3846
3847 return clone;
3848 }
3849
3850 /* Produce declarations for all appropriate clones of FN. If
3851 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3852 CLASTYPE_METHOD_VEC as well. */
3853
3854 void
3855 clone_function_decl (tree fn, int update_method_vec_p)
3856 {
3857 tree clone;
3858
3859 /* Avoid inappropriate cloning. */
3860 if (TREE_CHAIN (fn)
3861 && DECL_CLONED_FUNCTION (TREE_CHAIN (fn)))
3862 return;
3863
3864 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
3865 {
3866 /* For each constructor, we need two variants: an in-charge version
3867 and a not-in-charge version. */
3868 clone = build_clone (fn, complete_ctor_identifier);
3869 if (update_method_vec_p)
3870 add_method (DECL_CONTEXT (clone), clone);
3871 clone = build_clone (fn, base_ctor_identifier);
3872 if (update_method_vec_p)
3873 add_method (DECL_CONTEXT (clone), clone);
3874 }
3875 else
3876 {
3877 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
3878
3879 /* For each destructor, we need three variants: an in-charge
3880 version, a not-in-charge version, and an in-charge deleting
3881 version. We clone the deleting version first because that
3882 means it will go second on the TYPE_METHODS list -- and that
3883 corresponds to the correct layout order in the virtual
3884 function table.
3885
3886 For a non-virtual destructor, we do not build a deleting
3887 destructor. */
3888 if (DECL_VIRTUAL_P (fn))
3889 {
3890 clone = build_clone (fn, deleting_dtor_identifier);
3891 if (update_method_vec_p)
3892 add_method (DECL_CONTEXT (clone), clone);
3893 }
3894 clone = build_clone (fn, complete_dtor_identifier);
3895 if (update_method_vec_p)
3896 add_method (DECL_CONTEXT (clone), clone);
3897 clone = build_clone (fn, base_dtor_identifier);
3898 if (update_method_vec_p)
3899 add_method (DECL_CONTEXT (clone), clone);
3900 }
3901
3902 /* Note that this is an abstract function that is never emitted. */
3903 DECL_ABSTRACT (fn) = 1;
3904 }
3905
3906 /* DECL is an in charge constructor, which is being defined. This will
3907 have had an in class declaration, from whence clones were
3908 declared. An out-of-class definition can specify additional default
3909 arguments. As it is the clones that are involved in overload
3910 resolution, we must propagate the information from the DECL to its
3911 clones. */
3912
3913 void
3914 adjust_clone_args (tree decl)
3915 {
3916 tree clone;
3917
3918 for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION (clone);
3919 clone = TREE_CHAIN (clone))
3920 {
3921 tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
3922 tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
3923 tree decl_parms, clone_parms;
3924
3925 clone_parms = orig_clone_parms;
3926
3927 /* Skip the 'this' parameter. */
3928 orig_clone_parms = TREE_CHAIN (orig_clone_parms);
3929 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3930
3931 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
3932 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3933 if (DECL_HAS_VTT_PARM_P (decl))
3934 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
3935
3936 clone_parms = orig_clone_parms;
3937 if (DECL_HAS_VTT_PARM_P (clone))
3938 clone_parms = TREE_CHAIN (clone_parms);
3939
3940 for (decl_parms = orig_decl_parms; decl_parms;
3941 decl_parms = TREE_CHAIN (decl_parms),
3942 clone_parms = TREE_CHAIN (clone_parms))
3943 {
3944 gcc_assert (same_type_p (TREE_TYPE (decl_parms),
3945 TREE_TYPE (clone_parms)));
3946
3947 if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
3948 {
3949 /* A default parameter has been added. Adjust the
3950 clone's parameters. */
3951 tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3952 tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3953 tree type;
3954
3955 clone_parms = orig_decl_parms;
3956
3957 if (DECL_HAS_VTT_PARM_P (clone))
3958 {
3959 clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
3960 TREE_VALUE (orig_clone_parms),
3961 clone_parms);
3962 TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
3963 }
3964 type = build_method_type_directly (basetype,
3965 TREE_TYPE (TREE_TYPE (clone)),
3966 clone_parms);
3967 if (exceptions)
3968 type = build_exception_variant (type, exceptions);
3969 TREE_TYPE (clone) = type;
3970
3971 clone_parms = NULL_TREE;
3972 break;
3973 }
3974 }
3975 gcc_assert (!clone_parms);
3976 }
3977 }
3978
3979 /* For each of the constructors and destructors in T, create an
3980 in-charge and not-in-charge variant. */
3981
3982 static void
3983 clone_constructors_and_destructors (tree t)
3984 {
3985 tree fns;
3986
3987 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
3988 out now. */
3989 if (!CLASSTYPE_METHOD_VEC (t))
3990 return;
3991
3992 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
3993 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
3994 for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
3995 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
3996 }
3997
3998 /* Remove all zero-width bit-fields from T. */
3999
4000 static void
4001 remove_zero_width_bit_fields (tree t)
4002 {
4003 tree *fieldsp;
4004
4005 fieldsp = &TYPE_FIELDS (t);
4006 while (*fieldsp)
4007 {
4008 if (TREE_CODE (*fieldsp) == FIELD_DECL
4009 && DECL_C_BIT_FIELD (*fieldsp)
4010 && DECL_INITIAL (*fieldsp))
4011 *fieldsp = TREE_CHAIN (*fieldsp);
4012 else
4013 fieldsp = &TREE_CHAIN (*fieldsp);
4014 }
4015 }
4016
4017 /* Returns TRUE iff we need a cookie when dynamically allocating an
4018 array whose elements have the indicated class TYPE. */
4019
4020 static bool
4021 type_requires_array_cookie (tree type)
4022 {
4023 tree fns;
4024 bool has_two_argument_delete_p = false;
4025
4026 gcc_assert (CLASS_TYPE_P (type));
4027
4028 /* If there's a non-trivial destructor, we need a cookie. In order
4029 to iterate through the array calling the destructor for each
4030 element, we'll have to know how many elements there are. */
4031 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4032 return true;
4033
4034 /* If the usual deallocation function is a two-argument whose second
4035 argument is of type `size_t', then we have to pass the size of
4036 the array to the deallocation function, so we will need to store
4037 a cookie. */
4038 fns = lookup_fnfields (TYPE_BINFO (type),
4039 ansi_opname (VEC_DELETE_EXPR),
4040 /*protect=*/0);
4041 /* If there are no `operator []' members, or the lookup is
4042 ambiguous, then we don't need a cookie. */
4043 if (!fns || fns == error_mark_node)
4044 return false;
4045 /* Loop through all of the functions. */
4046 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4047 {
4048 tree fn;
4049 tree second_parm;
4050
4051 /* Select the current function. */
4052 fn = OVL_CURRENT (fns);
4053 /* See if this function is a one-argument delete function. If
4054 it is, then it will be the usual deallocation function. */
4055 second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4056 if (second_parm == void_list_node)
4057 return false;
4058 /* Otherwise, if we have a two-argument function and the second
4059 argument is `size_t', it will be the usual deallocation
4060 function -- unless there is one-argument function, too. */
4061 if (TREE_CHAIN (second_parm) == void_list_node
4062 && same_type_p (TREE_VALUE (second_parm), sizetype))
4063 has_two_argument_delete_p = true;
4064 }
4065
4066 return has_two_argument_delete_p;
4067 }
4068
4069 /* Check the validity of the bases and members declared in T. Add any
4070 implicitly-generated functions (like copy-constructors and
4071 assignment operators). Compute various flag bits (like
4072 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4073 level: i.e., independently of the ABI in use. */
4074
4075 static void
4076 check_bases_and_members (tree t)
4077 {
4078 /* Nonzero if we are not allowed to generate a default constructor
4079 for this case. */
4080 int cant_have_default_ctor;
4081 /* Nonzero if the implicitly generated copy constructor should take
4082 a non-const reference argument. */
4083 int cant_have_const_ctor;
4084 /* Nonzero if the the implicitly generated assignment operator
4085 should take a non-const reference argument. */
4086 int no_const_asn_ref;
4087 tree access_decls;
4088
4089 /* By default, we use const reference arguments and generate default
4090 constructors. */
4091 cant_have_default_ctor = 0;
4092 cant_have_const_ctor = 0;
4093 no_const_asn_ref = 0;
4094
4095 /* Check all the base-classes. */
4096 check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor,
4097 &no_const_asn_ref);
4098
4099 /* Check all the data member declarations. */
4100 check_field_decls (t, &access_decls,
4101 &cant_have_default_ctor,
4102 &cant_have_const_ctor,
4103 &no_const_asn_ref);
4104
4105 /* Check all the method declarations. */
4106 check_methods (t);
4107
4108 /* A nearly-empty class has to be vptr-containing; a nearly empty
4109 class contains just a vptr. */
4110 if (!TYPE_CONTAINS_VPTR_P (t))
4111 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4112
4113 /* Do some bookkeeping that will guide the generation of implicitly
4114 declared member functions. */
4115 TYPE_HAS_COMPLEX_INIT_REF (t)
4116 |= (TYPE_HAS_INIT_REF (t)
4117 || TYPE_USES_VIRTUAL_BASECLASSES (t)
4118 || TYPE_POLYMORPHIC_P (t));
4119 TYPE_NEEDS_CONSTRUCTING (t)
4120 |= (TYPE_HAS_CONSTRUCTOR (t)
4121 || TYPE_USES_VIRTUAL_BASECLASSES (t)
4122 || TYPE_POLYMORPHIC_P (t));
4123 CLASSTYPE_NON_AGGREGATE (t) |= (TYPE_HAS_CONSTRUCTOR (t)
4124 || TYPE_POLYMORPHIC_P (t));
4125 CLASSTYPE_NON_POD_P (t)
4126 |= (CLASSTYPE_NON_AGGREGATE (t) || TYPE_HAS_DESTRUCTOR (t)
4127 || TYPE_HAS_ASSIGN_REF (t));
4128 TYPE_HAS_COMPLEX_ASSIGN_REF (t)
4129 |= TYPE_HAS_ASSIGN_REF (t) || TYPE_CONTAINS_VPTR_P (t);
4130
4131 /* Synthesize any needed methods. */
4132 add_implicitly_declared_members (t, cant_have_default_ctor,
4133 cant_have_const_ctor,
4134 no_const_asn_ref);
4135
4136 /* Create the in-charge and not-in-charge variants of constructors
4137 and destructors. */
4138 clone_constructors_and_destructors (t);
4139
4140 /* Process the using-declarations. */
4141 for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4142 handle_using_decl (TREE_VALUE (access_decls), t);
4143
4144 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4145 finish_struct_methods (t);
4146
4147 /* Figure out whether or not we will need a cookie when dynamically
4148 allocating an array of this type. */
4149 TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4150 = type_requires_array_cookie (t);
4151 }
4152
4153 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4154 accordingly. If a new vfield was created (because T doesn't have a
4155 primary base class), then the newly created field is returned. It
4156 is not added to the TYPE_FIELDS list; it is the caller's
4157 responsibility to do that. Accumulate declared virtual functions
4158 on VIRTUALS_P. */
4159
4160 static tree
4161 create_vtable_ptr (tree t, tree* virtuals_p)
4162 {
4163 tree fn;
4164
4165 /* Collect the virtual functions declared in T. */
4166 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4167 if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4168 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4169 {
4170 tree new_virtual = make_node (TREE_LIST);
4171
4172 BV_FN (new_virtual) = fn;
4173 BV_DELTA (new_virtual) = integer_zero_node;
4174
4175 TREE_CHAIN (new_virtual) = *virtuals_p;
4176 *virtuals_p = new_virtual;
4177 }
4178
4179 /* If we couldn't find an appropriate base class, create a new field
4180 here. Even if there weren't any new virtual functions, we might need a
4181 new virtual function table if we're supposed to include vptrs in
4182 all classes that need them. */
4183 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4184 {
4185 /* We build this decl with vtbl_ptr_type_node, which is a
4186 `vtable_entry_type*'. It might seem more precise to use
4187 `vtable_entry_type (*)[N]' where N is the number of virtual
4188 functions. However, that would require the vtable pointer in
4189 base classes to have a different type than the vtable pointer
4190 in derived classes. We could make that happen, but that
4191 still wouldn't solve all the problems. In particular, the
4192 type-based alias analysis code would decide that assignments
4193 to the base class vtable pointer can't alias assignments to
4194 the derived class vtable pointer, since they have different
4195 types. Thus, in a derived class destructor, where the base
4196 class constructor was inlined, we could generate bad code for
4197 setting up the vtable pointer.
4198
4199 Therefore, we use one type for all vtable pointers. We still
4200 use a type-correct type; it's just doesn't indicate the array
4201 bounds. That's better than using `void*' or some such; it's
4202 cleaner, and it let's the alias analysis code know that these
4203 stores cannot alias stores to void*! */
4204 tree field;
4205
4206 field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4207 SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE));
4208 DECL_VIRTUAL_P (field) = 1;
4209 DECL_ARTIFICIAL (field) = 1;
4210 DECL_FIELD_CONTEXT (field) = t;
4211 DECL_FCONTEXT (field) = t;
4212
4213 TYPE_VFIELD (t) = field;
4214
4215 /* This class is non-empty. */
4216 CLASSTYPE_EMPTY_P (t) = 0;
4217
4218 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)))
4219 /* If there were any baseclasses, they can't possibly be at
4220 offset zero any more, because that's where the vtable
4221 pointer is. So, converting to a base class is going to
4222 take work. */
4223 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1;
4224
4225 return field;
4226 }
4227
4228 return NULL_TREE;
4229 }
4230
4231 /* Fixup the inline function given by INFO now that the class is
4232 complete. */
4233
4234 static void
4235 fixup_pending_inline (tree fn)
4236 {
4237 if (DECL_PENDING_INLINE_INFO (fn))
4238 {
4239 tree args = DECL_ARGUMENTS (fn);
4240 while (args)
4241 {
4242 DECL_CONTEXT (args) = fn;
4243 args = TREE_CHAIN (args);
4244 }
4245 }
4246 }
4247
4248 /* Fixup the inline methods and friends in TYPE now that TYPE is
4249 complete. */
4250
4251 static void
4252 fixup_inline_methods (tree type)
4253 {
4254 tree method = TYPE_METHODS (type);
4255
4256 if (method && TREE_CODE (method) == TREE_VEC)
4257 {
4258 if (TREE_VEC_ELT (method, 1))
4259 method = TREE_VEC_ELT (method, 1);
4260 else if (TREE_VEC_ELT (method, 0))
4261 method = TREE_VEC_ELT (method, 0);
4262 else
4263 method = TREE_VEC_ELT (method, 2);
4264 }
4265
4266 /* Do inline member functions. */
4267 for (; method; method = TREE_CHAIN (method))
4268 fixup_pending_inline (method);
4269
4270 /* Do friends. */
4271 for (method = CLASSTYPE_INLINE_FRIENDS (type);
4272 method;
4273 method = TREE_CHAIN (method))
4274 fixup_pending_inline (TREE_VALUE (method));
4275 CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE;
4276 }
4277
4278 /* Add OFFSET to all base types of BINFO which is a base in the
4279 hierarchy dominated by T.
4280
4281 OFFSET, which is a type offset, is number of bytes. */
4282
4283 static void
4284 propagate_binfo_offsets (tree binfo, tree offset)
4285 {
4286 int i;
4287 tree primary_binfo;
4288 tree base_binfo;
4289
4290 /* Update BINFO's offset. */
4291 BINFO_OFFSET (binfo)
4292 = convert (sizetype,
4293 size_binop (PLUS_EXPR,
4294 convert (ssizetype, BINFO_OFFSET (binfo)),
4295 offset));
4296
4297 /* Find the primary base class. */
4298 primary_binfo = get_primary_binfo (binfo);
4299
4300 if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4301 propagate_binfo_offsets (primary_binfo, offset);
4302
4303 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4304 downwards. */
4305 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4306 {
4307 /* Don't do the primary base twice. */
4308 if (base_binfo == primary_binfo)
4309 continue;
4310
4311 if (BINFO_VIRTUAL_P (base_binfo))
4312 continue;
4313
4314 propagate_binfo_offsets (base_binfo, offset);
4315 }
4316 }
4317
4318 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4319 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4320 empty subobjects of T. */
4321
4322 static void
4323 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4324 {
4325 tree vbase;
4326 tree t = rli->t;
4327 bool first_vbase = true;
4328 tree *next_field;
4329
4330 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4331 return;
4332
4333 if (!abi_version_at_least(2))
4334 {
4335 /* In G++ 3.2, we incorrectly rounded the size before laying out
4336 the virtual bases. */
4337 finish_record_layout (rli, /*free_p=*/false);
4338 #ifdef STRUCTURE_SIZE_BOUNDARY
4339 /* Packed structures don't need to have minimum size. */
4340 if (! TYPE_PACKED (t))
4341 TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4342 #endif
4343 rli->offset = TYPE_SIZE_UNIT (t);
4344 rli->bitpos = bitsize_zero_node;
4345 rli->record_align = TYPE_ALIGN (t);
4346 }
4347
4348 /* Find the last field. The artificial fields created for virtual
4349 bases will go after the last extant field to date. */
4350 next_field = &TYPE_FIELDS (t);
4351 while (*next_field)
4352 next_field = &TREE_CHAIN (*next_field);
4353
4354 /* Go through the virtual bases, allocating space for each virtual
4355 base that is not already a primary base class. These are
4356 allocated in inheritance graph order. */
4357 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4358 {
4359 if (!BINFO_VIRTUAL_P (vbase))
4360 continue;
4361
4362 if (!BINFO_PRIMARY_P (vbase))
4363 {
4364 tree basetype = TREE_TYPE (vbase);
4365
4366 /* This virtual base is not a primary base of any class in the
4367 hierarchy, so we have to add space for it. */
4368 next_field = build_base_field (rli, vbase,
4369 offsets, next_field);
4370
4371 /* If the first virtual base might have been placed at a
4372 lower address, had we started from CLASSTYPE_SIZE, rather
4373 than TYPE_SIZE, issue a warning. There can be both false
4374 positives and false negatives from this warning in rare
4375 cases; to deal with all the possibilities would probably
4376 require performing both layout algorithms and comparing
4377 the results which is not particularly tractable. */
4378 if (warn_abi
4379 && first_vbase
4380 && (tree_int_cst_lt
4381 (size_binop (CEIL_DIV_EXPR,
4382 round_up (CLASSTYPE_SIZE (t),
4383 CLASSTYPE_ALIGN (basetype)),
4384 bitsize_unit_node),
4385 BINFO_OFFSET (vbase))))
4386 warning ("offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC",
4387 basetype);
4388
4389 first_vbase = false;
4390 }
4391 }
4392 }
4393
4394 /* Returns the offset of the byte just past the end of the base class
4395 BINFO. */
4396
4397 static tree
4398 end_of_base (tree binfo)
4399 {
4400 tree size;
4401
4402 if (is_empty_class (BINFO_TYPE (binfo)))
4403 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4404 allocate some space for it. It cannot have virtual bases, so
4405 TYPE_SIZE_UNIT is fine. */
4406 size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4407 else
4408 size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4409
4410 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4411 }
4412
4413 /* Returns the offset of the byte just past the end of the base class
4414 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4415 only non-virtual bases are included. */
4416
4417 static tree
4418 end_of_class (tree t, int include_virtuals_p)
4419 {
4420 tree result = size_zero_node;
4421 VEC (tree) *vbases;
4422 tree binfo;
4423 tree base_binfo;
4424 tree offset;
4425 int i;
4426
4427 for (binfo = TYPE_BINFO (t), i = 0;
4428 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4429 {
4430 if (!include_virtuals_p
4431 && BINFO_VIRTUAL_P (base_binfo)
4432 && (!BINFO_PRIMARY_P (base_binfo)
4433 || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4434 continue;
4435
4436 offset = end_of_base (base_binfo);
4437 if (INT_CST_LT_UNSIGNED (result, offset))
4438 result = offset;
4439 }
4440
4441 /* G++ 3.2 did not check indirect virtual bases. */
4442 if (abi_version_at_least (2) && include_virtuals_p)
4443 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4444 VEC_iterate (tree, vbases, i, base_binfo); i++)
4445 {
4446 offset = end_of_base (base_binfo);
4447 if (INT_CST_LT_UNSIGNED (result, offset))
4448 result = offset;
4449 }
4450
4451 return result;
4452 }
4453
4454 /* Warn about bases of T that are inaccessible because they are
4455 ambiguous. For example:
4456
4457 struct S {};
4458 struct T : public S {};
4459 struct U : public S, public T {};
4460
4461 Here, `(S*) new U' is not allowed because there are two `S'
4462 subobjects of U. */
4463
4464 static void
4465 warn_about_ambiguous_bases (tree t)
4466 {
4467 int i;
4468 VEC (tree) *vbases;
4469 tree basetype;
4470 tree binfo;
4471 tree base_binfo;
4472
4473 /* Check direct bases. */
4474 for (binfo = TYPE_BINFO (t), i = 0;
4475 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4476 {
4477 basetype = BINFO_TYPE (base_binfo);
4478
4479 if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4480 warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
4481 basetype, t);
4482 }
4483
4484 /* Check for ambiguous virtual bases. */
4485 if (extra_warnings)
4486 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4487 VEC_iterate (tree, vbases, i, binfo); i++)
4488 {
4489 basetype = BINFO_TYPE (binfo);
4490
4491 if (!lookup_base (t, basetype, ba_ignore | ba_quiet, NULL))
4492 warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
4493 basetype, t);
4494 }
4495 }
4496
4497 /* Compare two INTEGER_CSTs K1 and K2. */
4498
4499 static int
4500 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4501 {
4502 return tree_int_cst_compare ((tree) k1, (tree) k2);
4503 }
4504
4505 /* Increase the size indicated in RLI to account for empty classes
4506 that are "off the end" of the class. */
4507
4508 static void
4509 include_empty_classes (record_layout_info rli)
4510 {
4511 tree eoc;
4512 tree rli_size;
4513
4514 /* It might be the case that we grew the class to allocate a
4515 zero-sized base class. That won't be reflected in RLI, yet,
4516 because we are willing to overlay multiple bases at the same
4517 offset. However, now we need to make sure that RLI is big enough
4518 to reflect the entire class. */
4519 eoc = end_of_class (rli->t,
4520 CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4521 rli_size = rli_size_unit_so_far (rli);
4522 if (TREE_CODE (rli_size) == INTEGER_CST
4523 && INT_CST_LT_UNSIGNED (rli_size, eoc))
4524 {
4525 if (!abi_version_at_least (2))
4526 /* In version 1 of the ABI, the size of a class that ends with
4527 a bitfield was not rounded up to a whole multiple of a
4528 byte. Because rli_size_unit_so_far returns only the number
4529 of fully allocated bytes, any extra bits were not included
4530 in the size. */
4531 rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4532 else
4533 /* The size should have been rounded to a whole byte. */
4534 gcc_assert (tree_int_cst_equal
4535 (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
4536 rli->bitpos
4537 = size_binop (PLUS_EXPR,
4538 rli->bitpos,
4539 size_binop (MULT_EXPR,
4540 convert (bitsizetype,
4541 size_binop (MINUS_EXPR,
4542 eoc, rli_size)),
4543 bitsize_int (BITS_PER_UNIT)));
4544 normalize_rli (rli);
4545 }
4546 }
4547
4548 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4549 BINFO_OFFSETs for all of the base-classes. Position the vtable
4550 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4551
4552 static void
4553 layout_class_type (tree t, tree *virtuals_p)
4554 {
4555 tree non_static_data_members;
4556 tree field;
4557 tree vptr;
4558 record_layout_info rli;
4559 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4560 types that appear at that offset. */
4561 splay_tree empty_base_offsets;
4562 /* True if the last field layed out was a bit-field. */
4563 bool last_field_was_bitfield = false;
4564 /* The location at which the next field should be inserted. */
4565 tree *next_field;
4566 /* T, as a base class. */
4567 tree base_t;
4568
4569 /* Keep track of the first non-static data member. */
4570 non_static_data_members = TYPE_FIELDS (t);
4571
4572 /* Start laying out the record. */
4573 rli = start_record_layout (t);
4574
4575 /* Mark all the primary bases in the hierarchy. */
4576 determine_primary_bases (t);
4577
4578 /* Create a pointer to our virtual function table. */
4579 vptr = create_vtable_ptr (t, virtuals_p);
4580
4581 /* The vptr is always the first thing in the class. */
4582 if (vptr)
4583 {
4584 TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4585 TYPE_FIELDS (t) = vptr;
4586 next_field = &TREE_CHAIN (vptr);
4587 place_field (rli, vptr);
4588 }
4589 else
4590 next_field = &TYPE_FIELDS (t);
4591
4592 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4593 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4594 NULL, NULL);
4595 build_base_fields (rli, empty_base_offsets, next_field);
4596
4597 /* Layout the non-static data members. */
4598 for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4599 {
4600 tree type;
4601 tree padding;
4602
4603 /* We still pass things that aren't non-static data members to
4604 the back-end, in case it wants to do something with them. */
4605 if (TREE_CODE (field) != FIELD_DECL)
4606 {
4607 place_field (rli, field);
4608 /* If the static data member has incomplete type, keep track
4609 of it so that it can be completed later. (The handling
4610 of pending statics in finish_record_layout is
4611 insufficient; consider:
4612
4613 struct S1;
4614 struct S2 { static S1 s1; };
4615
4616 At this point, finish_record_layout will be called, but
4617 S1 is still incomplete.) */
4618 if (TREE_CODE (field) == VAR_DECL)
4619 maybe_register_incomplete_var (field);
4620 continue;
4621 }
4622
4623 type = TREE_TYPE (field);
4624
4625 padding = NULL_TREE;
4626
4627 /* If this field is a bit-field whose width is greater than its
4628 type, then there are some special rules for allocating
4629 it. */
4630 if (DECL_C_BIT_FIELD (field)
4631 && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4632 {
4633 integer_type_kind itk;
4634 tree integer_type;
4635 bool was_unnamed_p = false;
4636 /* We must allocate the bits as if suitably aligned for the
4637 longest integer type that fits in this many bits. type
4638 of the field. Then, we are supposed to use the left over
4639 bits as additional padding. */
4640 for (itk = itk_char; itk != itk_none; ++itk)
4641 if (INT_CST_LT (DECL_SIZE (field),
4642 TYPE_SIZE (integer_types[itk])))
4643 break;
4644
4645 /* ITK now indicates a type that is too large for the
4646 field. We have to back up by one to find the largest
4647 type that fits. */
4648 integer_type = integer_types[itk - 1];
4649
4650 /* Figure out how much additional padding is required. GCC
4651 3.2 always created a padding field, even if it had zero
4652 width. */
4653 if (!abi_version_at_least (2)
4654 || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
4655 {
4656 if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
4657 /* In a union, the padding field must have the full width
4658 of the bit-field; all fields start at offset zero. */
4659 padding = DECL_SIZE (field);
4660 else
4661 {
4662 if (warn_abi && TREE_CODE (t) == UNION_TYPE)
4663 warning ("size assigned to `%T' may not be "
4664 "ABI-compliant and may change in a future "
4665 "version of GCC",
4666 t);
4667 padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
4668 TYPE_SIZE (integer_type));
4669 }
4670 }
4671 #ifdef PCC_BITFIELD_TYPE_MATTERS
4672 /* An unnamed bitfield does not normally affect the
4673 alignment of the containing class on a target where
4674 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
4675 make any exceptions for unnamed bitfields when the
4676 bitfields are longer than their types. Therefore, we
4677 temporarily give the field a name. */
4678 if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
4679 {
4680 was_unnamed_p = true;
4681 DECL_NAME (field) = make_anon_name ();
4682 }
4683 #endif
4684 DECL_SIZE (field) = TYPE_SIZE (integer_type);
4685 DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
4686 DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
4687 layout_nonempty_base_or_field (rli, field, NULL_TREE,
4688 empty_base_offsets);
4689 if (was_unnamed_p)
4690 DECL_NAME (field) = NULL_TREE;
4691 /* Now that layout has been performed, set the size of the
4692 field to the size of its declared type; the rest of the
4693 field is effectively invisible. */
4694 DECL_SIZE (field) = TYPE_SIZE (type);
4695 /* We must also reset the DECL_MODE of the field. */
4696 if (abi_version_at_least (2))
4697 DECL_MODE (field) = TYPE_MODE (type);
4698 else if (warn_abi
4699 && DECL_MODE (field) != TYPE_MODE (type))
4700 /* Versions of G++ before G++ 3.4 did not reset the
4701 DECL_MODE. */
4702 warning ("the offset of `%D' may not be ABI-compliant and may "
4703 "change in a future version of GCC", field);
4704 }
4705 else
4706 layout_nonempty_base_or_field (rli, field, NULL_TREE,
4707 empty_base_offsets);
4708
4709 /* Remember the location of any empty classes in FIELD. */
4710 if (abi_version_at_least (2))
4711 record_subobject_offsets (TREE_TYPE (field),
4712 byte_position(field),
4713 empty_base_offsets,
4714 /*vbases_p=*/1);
4715
4716 /* If a bit-field does not immediately follow another bit-field,
4717 and yet it starts in the middle of a byte, we have failed to
4718 comply with the ABI. */
4719 if (warn_abi
4720 && DECL_C_BIT_FIELD (field)
4721 && !last_field_was_bitfield
4722 && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
4723 DECL_FIELD_BIT_OFFSET (field),
4724 bitsize_unit_node)))
4725 cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC",
4726 field);
4727
4728 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4729 offset of the field. */
4730 if (warn_abi
4731 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
4732 byte_position (field))
4733 && contains_empty_class_p (TREE_TYPE (field)))
4734 cp_warning_at ("`%D' contains empty classes which may cause base "
4735 "classes to be placed at different locations in a "
4736 "future version of GCC",
4737 field);
4738
4739 /* If we needed additional padding after this field, add it
4740 now. */
4741 if (padding)
4742 {
4743 tree padding_field;
4744
4745 padding_field = build_decl (FIELD_DECL,
4746 NULL_TREE,
4747 char_type_node);
4748 DECL_BIT_FIELD (padding_field) = 1;
4749 DECL_SIZE (padding_field) = padding;
4750 DECL_CONTEXT (padding_field) = t;
4751 DECL_ARTIFICIAL (padding_field) = 1;
4752 layout_nonempty_base_or_field (rli, padding_field,
4753 NULL_TREE,
4754 empty_base_offsets);
4755 }
4756
4757 last_field_was_bitfield = DECL_C_BIT_FIELD (field);
4758 }
4759
4760 if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
4761 {
4762 /* Make sure that we are on a byte boundary so that the size of
4763 the class without virtual bases will always be a round number
4764 of bytes. */
4765 rli->bitpos = round_up (rli->bitpos, BITS_PER_UNIT);
4766 normalize_rli (rli);
4767 }
4768
4769 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4770 padding. */
4771 if (!abi_version_at_least (2))
4772 include_empty_classes(rli);
4773
4774 /* Delete all zero-width bit-fields from the list of fields. Now
4775 that the type is laid out they are no longer important. */
4776 remove_zero_width_bit_fields (t);
4777
4778 /* Create the version of T used for virtual bases. We do not use
4779 make_aggr_type for this version; this is an artificial type. For
4780 a POD type, we just reuse T. */
4781 if (CLASSTYPE_NON_POD_P (t) || CLASSTYPE_EMPTY_P (t))
4782 {
4783 base_t = make_node (TREE_CODE (t));
4784
4785 /* Set the size and alignment for the new type. In G++ 3.2, all
4786 empty classes were considered to have size zero when used as
4787 base classes. */
4788 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
4789 {
4790 TYPE_SIZE (base_t) = bitsize_zero_node;
4791 TYPE_SIZE_UNIT (base_t) = size_zero_node;
4792 if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
4793 warning ("layout of classes derived from empty class `%T' "
4794 "may change in a future version of GCC",
4795 t);
4796 }
4797 else
4798 {
4799 tree eoc;
4800
4801 /* If the ABI version is not at least two, and the last
4802 field was a bit-field, RLI may not be on a byte
4803 boundary. In particular, rli_size_unit_so_far might
4804 indicate the last complete byte, while rli_size_so_far
4805 indicates the total number of bits used. Therefore,
4806 rli_size_so_far, rather than rli_size_unit_so_far, is
4807 used to compute TYPE_SIZE_UNIT. */
4808 eoc = end_of_class (t, /*include_virtuals_p=*/0);
4809 TYPE_SIZE_UNIT (base_t)
4810 = size_binop (MAX_EXPR,
4811 convert (sizetype,
4812 size_binop (CEIL_DIV_EXPR,
4813 rli_size_so_far (rli),
4814 bitsize_int (BITS_PER_UNIT))),
4815 eoc);
4816 TYPE_SIZE (base_t)
4817 = size_binop (MAX_EXPR,
4818 rli_size_so_far (rli),
4819 size_binop (MULT_EXPR,
4820 convert (bitsizetype, eoc),
4821 bitsize_int (BITS_PER_UNIT)));
4822 }
4823 TYPE_ALIGN (base_t) = rli->record_align;
4824 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
4825
4826 /* Copy the fields from T. */
4827 next_field = &TYPE_FIELDS (base_t);
4828 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4829 if (TREE_CODE (field) == FIELD_DECL)
4830 {
4831 *next_field = build_decl (FIELD_DECL,
4832 DECL_NAME (field),
4833 TREE_TYPE (field));
4834 DECL_CONTEXT (*next_field) = base_t;
4835 DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
4836 DECL_FIELD_BIT_OFFSET (*next_field)
4837 = DECL_FIELD_BIT_OFFSET (field);
4838 DECL_SIZE (*next_field) = DECL_SIZE (field);
4839 DECL_MODE (*next_field) = DECL_MODE (field);
4840 next_field = &TREE_CHAIN (*next_field);
4841 }
4842
4843 /* Record the base version of the type. */
4844 CLASSTYPE_AS_BASE (t) = base_t;
4845 TYPE_CONTEXT (base_t) = t;
4846 }
4847 else
4848 CLASSTYPE_AS_BASE (t) = t;
4849
4850 /* Every empty class contains an empty class. */
4851 if (CLASSTYPE_EMPTY_P (t))
4852 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
4853
4854 /* Set the TYPE_DECL for this type to contain the right
4855 value for DECL_OFFSET, so that we can use it as part
4856 of a COMPONENT_REF for multiple inheritance. */
4857 layout_decl (TYPE_MAIN_DECL (t), 0);
4858
4859 /* Now fix up any virtual base class types that we left lying
4860 around. We must get these done before we try to lay out the
4861 virtual function table. As a side-effect, this will remove the
4862 base subobject fields. */
4863 layout_virtual_bases (rli, empty_base_offsets);
4864
4865 /* Make sure that empty classes are reflected in RLI at this
4866 point. */
4867 include_empty_classes(rli);
4868
4869 /* Make sure not to create any structures with zero size. */
4870 if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
4871 place_field (rli,
4872 build_decl (FIELD_DECL, NULL_TREE, char_type_node));
4873
4874 /* Let the back-end lay out the type. */
4875 finish_record_layout (rli, /*free_p=*/true);
4876
4877 /* Warn about bases that can't be talked about due to ambiguity. */
4878 warn_about_ambiguous_bases (t);
4879
4880 /* Now that we're done with layout, give the base fields the real types. */
4881 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4882 if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
4883 TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
4884
4885 /* Clean up. */
4886 splay_tree_delete (empty_base_offsets);
4887 }
4888
4889 /* Determine the "key method" for the class type indicated by TYPE,
4890 and set CLASSTYPE_KEY_METHOD accordingly. */
4891
4892 void
4893 determine_key_method (tree type)
4894 {
4895 tree method;
4896
4897 if (TYPE_FOR_JAVA (type)
4898 || processing_template_decl
4899 || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4900 || CLASSTYPE_INTERFACE_KNOWN (type))
4901 return;
4902
4903 /* The key method is the first non-pure virtual function that is not
4904 inline at the point of class definition. On some targets the
4905 key function may not be inline; those targets should not call
4906 this function until the end of the translation unit. */
4907 for (method = TYPE_METHODS (type); method != NULL_TREE;
4908 method = TREE_CHAIN (method))
4909 if (DECL_VINDEX (method) != NULL_TREE
4910 && ! DECL_DECLARED_INLINE_P (method)
4911 && ! DECL_PURE_VIRTUAL_P (method))
4912 {
4913 CLASSTYPE_KEY_METHOD (type) = method;
4914 break;
4915 }
4916
4917 return;
4918 }
4919
4920 /* Perform processing required when the definition of T (a class type)
4921 is complete. */
4922
4923 void
4924 finish_struct_1 (tree t)
4925 {
4926 tree x;
4927 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
4928 tree virtuals = NULL_TREE;
4929 int n_fields = 0;
4930 tree vfield;
4931
4932 if (COMPLETE_TYPE_P (t))
4933 {
4934 gcc_assert (IS_AGGR_TYPE (t));
4935 error ("redefinition of `%#T'", t);
4936 popclass ();
4937 return;
4938 }
4939
4940 /* If this type was previously laid out as a forward reference,
4941 make sure we lay it out again. */
4942 TYPE_SIZE (t) = NULL_TREE;
4943 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
4944
4945 fixup_inline_methods (t);
4946
4947 /* Make assumptions about the class; we'll reset the flags if
4948 necessary. */
4949 CLASSTYPE_EMPTY_P (t) = 1;
4950 CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
4951 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
4952
4953 /* Do end-of-class semantic processing: checking the validity of the
4954 bases and members and add implicitly generated methods. */
4955 check_bases_and_members (t);
4956
4957 /* Find the key method. */
4958 if (TYPE_CONTAINS_VPTR_P (t))
4959 {
4960 /* The Itanium C++ ABI permits the key method to be chosen when
4961 the class is defined -- even though the key method so
4962 selected may later turn out to be an inline function. On
4963 some systems (such as ARM Symbian OS) the key method cannot
4964 be determined until the end of the translation unit. On such
4965 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
4966 will cause the class to be added to KEYED_CLASSES. Then, in
4967 finish_file we will determine the key method. */
4968 if (targetm.cxx.key_method_may_be_inline ())
4969 determine_key_method (t);
4970
4971 /* If a polymorphic class has no key method, we may emit the vtable
4972 in every translation unit where the class definition appears. */
4973 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
4974 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
4975 }
4976
4977 /* Layout the class itself. */
4978 layout_class_type (t, &virtuals);
4979 if (CLASSTYPE_AS_BASE (t) != t)
4980 /* We use the base type for trivial assignments, and hence it
4981 needs a mode. */
4982 compute_record_mode (CLASSTYPE_AS_BASE (t));
4983
4984 /* Make sure that we get our own copy of the vfield FIELD_DECL. */
4985 vfield = TYPE_VFIELD (t);
4986 if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
4987 {
4988 tree primary = CLASSTYPE_PRIMARY_BINFO (t);
4989
4990 gcc_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
4991 BINFO_TYPE (primary)));
4992 /* The vtable better be at the start. */
4993 gcc_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)));
4994 gcc_assert (integer_zerop (BINFO_OFFSET (primary)));
4995
4996 vfield = copy_decl (vfield);
4997 DECL_FIELD_CONTEXT (vfield) = t;
4998 TYPE_VFIELD (t) = vfield;
4999 }
5000 else
5001 gcc_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t);
5002
5003 virtuals = modify_all_vtables (t, nreverse (virtuals));
5004
5005 /* If necessary, create the primary vtable for this class. */
5006 if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5007 {
5008 /* We must enter these virtuals into the table. */
5009 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5010 build_primary_vtable (NULL_TREE, t);
5011 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5012 /* Here we know enough to change the type of our virtual
5013 function table, but we will wait until later this function. */
5014 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5015 }
5016
5017 if (TYPE_CONTAINS_VPTR_P (t))
5018 {
5019 int vindex;
5020 tree fn;
5021
5022 if (BINFO_VTABLE (TYPE_BINFO (t)))
5023 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5024 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5025 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5026
5027 /* Add entries for virtual functions introduced by this class. */
5028 BINFO_VIRTUALS (TYPE_BINFO (t))
5029 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5030
5031 /* Set DECL_VINDEX for all functions declared in this class. */
5032 for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5033 fn;
5034 fn = TREE_CHAIN (fn),
5035 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5036 ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5037 {
5038 tree fndecl = BV_FN (fn);
5039
5040 if (DECL_THUNK_P (fndecl))
5041 /* A thunk. We should never be calling this entry directly
5042 from this vtable -- we'd use the entry for the non
5043 thunk base function. */
5044 DECL_VINDEX (fndecl) = NULL_TREE;
5045 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5046 DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5047 }
5048 }
5049
5050 finish_struct_bits (t);
5051
5052 /* Complete the rtl for any static member objects of the type we're
5053 working on. */
5054 for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5055 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5056 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5057 DECL_MODE (x) = TYPE_MODE (t);
5058
5059 /* Done with FIELDS...now decide whether to sort these for
5060 faster lookups later.
5061
5062 We use a small number because most searches fail (succeeding
5063 ultimately as the search bores through the inheritance
5064 hierarchy), and we want this failure to occur quickly. */
5065
5066 n_fields = count_fields (TYPE_FIELDS (t));
5067 if (n_fields > 7)
5068 {
5069 struct sorted_fields_type *field_vec = GGC_NEWVAR
5070 (struct sorted_fields_type,
5071 sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5072 field_vec->len = n_fields;
5073 add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5074 qsort (field_vec->elts, n_fields, sizeof (tree),
5075 field_decl_cmp);
5076 if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5077 retrofit_lang_decl (TYPE_MAIN_DECL (t));
5078 DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5079 }
5080
5081 /* Make the rtl for any new vtables we have created, and unmark
5082 the base types we marked. */
5083 finish_vtbls (t);
5084
5085 /* Build the VTT for T. */
5086 build_vtt (t);
5087
5088 if (warn_nonvdtor && TYPE_POLYMORPHIC_P (t) && TYPE_HAS_DESTRUCTOR (t)
5089 && !DECL_VINDEX (CLASSTYPE_DESTRUCTORS (t)))
5090
5091 {
5092 tree dtor = CLASSTYPE_DESTRUCTORS (t);
5093
5094 /* Warn only if the dtor is non-private or the class has friends */
5095 if (!TREE_PRIVATE (dtor) ||
5096 (CLASSTYPE_FRIEND_CLASSES (t) ||
5097 DECL_FRIENDLIST (TYPE_MAIN_DECL (t))))
5098 warning ("%#T' has virtual functions but non-virtual destructor", t);
5099 }
5100
5101 complete_vars (t);
5102
5103 if (warn_overloaded_virtual)
5104 warn_hidden (t);
5105
5106 maybe_suppress_debug_info (t);
5107
5108 dump_class_hierarchy (t);
5109
5110 /* Finish debugging output for this type. */
5111 rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5112 }
5113
5114 /* When T was built up, the member declarations were added in reverse
5115 order. Rearrange them to declaration order. */
5116
5117 void
5118 unreverse_member_declarations (tree t)
5119 {
5120 tree next;
5121 tree prev;
5122 tree x;
5123
5124 /* The following lists are all in reverse order. Put them in
5125 declaration order now. */
5126 TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5127 CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5128
5129 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5130 reverse order, so we can't just use nreverse. */
5131 prev = NULL_TREE;
5132 for (x = TYPE_FIELDS (t);
5133 x && TREE_CODE (x) != TYPE_DECL;
5134 x = next)
5135 {
5136 next = TREE_CHAIN (x);
5137 TREE_CHAIN (x) = prev;
5138 prev = x;
5139 }
5140 if (prev)
5141 {
5142 TREE_CHAIN (TYPE_FIELDS (t)) = x;
5143 if (prev)
5144 TYPE_FIELDS (t) = prev;
5145 }
5146 }
5147
5148 tree
5149 finish_struct (tree t, tree attributes)
5150 {
5151 location_t saved_loc = input_location;
5152
5153 /* Now that we've got all the field declarations, reverse everything
5154 as necessary. */
5155 unreverse_member_declarations (t);
5156
5157 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5158
5159 /* Nadger the current location so that diagnostics point to the start of
5160 the struct, not the end. */
5161 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5162
5163 if (processing_template_decl)
5164 {
5165 tree x;
5166
5167 finish_struct_methods (t);
5168 TYPE_SIZE (t) = bitsize_zero_node;
5169
5170 /* We need to emit an error message if this type was used as a parameter
5171 and it is an abstract type, even if it is a template. We construct
5172 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5173 account and we call complete_vars with this type, which will check
5174 the PARM_DECLS. Note that while the type is being defined,
5175 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5176 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5177 CLASSTYPE_PURE_VIRTUALS (t) = NULL_TREE;
5178 for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5179 if (DECL_PURE_VIRTUAL_P (x))
5180 CLASSTYPE_PURE_VIRTUALS (t)
5181 = tree_cons (NULL_TREE, x, CLASSTYPE_PURE_VIRTUALS (t));
5182 complete_vars (t);
5183 }
5184 else
5185 finish_struct_1 (t);
5186
5187 input_location = saved_loc;
5188
5189 TYPE_BEING_DEFINED (t) = 0;
5190
5191 if (current_class_type)
5192 popclass ();
5193 else
5194 error ("trying to finish struct, but kicked out due to previous parse errors");
5195
5196 if (processing_template_decl && at_function_scope_p ())
5197 add_stmt (build_min (TAG_DEFN, t));
5198
5199 return t;
5200 }
5201 \f
5202 /* Return the dynamic type of INSTANCE, if known.
5203 Used to determine whether the virtual function table is needed
5204 or not.
5205
5206 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5207 of our knowledge of its type. *NONNULL should be initialized
5208 before this function is called. */
5209
5210 static tree
5211 fixed_type_or_null (tree instance, int* nonnull, int* cdtorp)
5212 {
5213 switch (TREE_CODE (instance))
5214 {
5215 case INDIRECT_REF:
5216 if (POINTER_TYPE_P (TREE_TYPE (instance)))
5217 return NULL_TREE;
5218 else
5219 return fixed_type_or_null (TREE_OPERAND (instance, 0),
5220 nonnull, cdtorp);
5221
5222 case CALL_EXPR:
5223 /* This is a call to a constructor, hence it's never zero. */
5224 if (TREE_HAS_CONSTRUCTOR (instance))
5225 {
5226 if (nonnull)
5227 *nonnull = 1;
5228 return TREE_TYPE (instance);
5229 }
5230 return NULL_TREE;
5231
5232 case SAVE_EXPR:
5233 /* This is a call to a constructor, hence it's never zero. */
5234 if (TREE_HAS_CONSTRUCTOR (instance))
5235 {
5236 if (nonnull)
5237 *nonnull = 1;
5238 return TREE_TYPE (instance);
5239 }
5240 return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5241
5242 case PLUS_EXPR:
5243 case MINUS_EXPR:
5244 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5245 return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5246 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5247 /* Propagate nonnull. */
5248 return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5249 return NULL_TREE;
5250
5251 case NOP_EXPR:
5252 case CONVERT_EXPR:
5253 return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5254
5255 case ADDR_EXPR:
5256 instance = TREE_OPERAND (instance, 0);
5257 if (nonnull)
5258 {
5259 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5260 with a real object -- given &p->f, p can still be null. */
5261 tree t = get_base_address (instance);
5262 /* ??? Probably should check DECL_WEAK here. */
5263 if (t && DECL_P (t))
5264 *nonnull = 1;
5265 }
5266 return fixed_type_or_null (instance, nonnull, cdtorp);
5267
5268 case COMPONENT_REF:
5269 /* If this component is really a base class reference, then the field
5270 itself isn't definitive. */
5271 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5272 return fixed_type_or_null (TREE_OPERAND (instance, 0), nonnull, cdtorp);
5273 return fixed_type_or_null (TREE_OPERAND (instance, 1), nonnull, cdtorp);
5274
5275 case VAR_DECL:
5276 case FIELD_DECL:
5277 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5278 && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
5279 {
5280 if (nonnull)
5281 *nonnull = 1;
5282 return TREE_TYPE (TREE_TYPE (instance));
5283 }
5284 /* fall through... */
5285 case TARGET_EXPR:
5286 case PARM_DECL:
5287 case RESULT_DECL:
5288 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
5289 {
5290 if (nonnull)
5291 *nonnull = 1;
5292 return TREE_TYPE (instance);
5293 }
5294 else if (instance == current_class_ptr)
5295 {
5296 if (nonnull)
5297 *nonnull = 1;
5298
5299 /* if we're in a ctor or dtor, we know our type. */
5300 if (DECL_LANG_SPECIFIC (current_function_decl)
5301 && (DECL_CONSTRUCTOR_P (current_function_decl)
5302 || DECL_DESTRUCTOR_P (current_function_decl)))
5303 {
5304 if (cdtorp)
5305 *cdtorp = 1;
5306 return TREE_TYPE (TREE_TYPE (instance));
5307 }
5308 }
5309 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5310 {
5311 /* Reference variables should be references to objects. */
5312 if (nonnull)
5313 *nonnull = 1;
5314
5315 /* DECL_VAR_MARKED_P is used to prevent recursion; a
5316 variable's initializer may refer to the variable
5317 itself. */
5318 if (TREE_CODE (instance) == VAR_DECL
5319 && DECL_INITIAL (instance)
5320 && !DECL_VAR_MARKED_P (instance))
5321 {
5322 tree type;
5323 DECL_VAR_MARKED_P (instance) = 1;
5324 type = fixed_type_or_null (DECL_INITIAL (instance),
5325 nonnull, cdtorp);
5326 DECL_VAR_MARKED_P (instance) = 0;
5327 return type;
5328 }
5329 }
5330 return NULL_TREE;
5331
5332 default:
5333 return NULL_TREE;
5334 }
5335 }
5336
5337 /* Return nonzero if the dynamic type of INSTANCE is known, and
5338 equivalent to the static type. We also handle the case where
5339 INSTANCE is really a pointer. Return negative if this is a
5340 ctor/dtor. There the dynamic type is known, but this might not be
5341 the most derived base of the original object, and hence virtual
5342 bases may not be layed out according to this type.
5343
5344 Used to determine whether the virtual function table is needed
5345 or not.
5346
5347 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5348 of our knowledge of its type. *NONNULL should be initialized
5349 before this function is called. */
5350
5351 int
5352 resolves_to_fixed_type_p (tree instance, int* nonnull)
5353 {
5354 tree t = TREE_TYPE (instance);
5355 int cdtorp = 0;
5356
5357 tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5358 if (fixed == NULL_TREE)
5359 return 0;
5360 if (POINTER_TYPE_P (t))
5361 t = TREE_TYPE (t);
5362 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5363 return 0;
5364 return cdtorp ? -1 : 1;
5365 }
5366
5367 \f
5368 void
5369 init_class_processing (void)
5370 {
5371 current_class_depth = 0;
5372 current_class_stack_size = 10;
5373 current_class_stack
5374 = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));
5375 VARRAY_TREE_INIT (local_classes, 8, "local_classes");
5376
5377 ridpointers[(int) RID_PUBLIC] = access_public_node;
5378 ridpointers[(int) RID_PRIVATE] = access_private_node;
5379 ridpointers[(int) RID_PROTECTED] = access_protected_node;
5380 }
5381
5382 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5383
5384 static void
5385 restore_class_cache (void)
5386 {
5387 tree type;
5388
5389 /* We are re-entering the same class we just left, so we don't
5390 have to search the whole inheritance matrix to find all the
5391 decls to bind again. Instead, we install the cached
5392 class_shadowed list and walk through it binding names. */
5393 push_binding_level (previous_class_level);
5394 class_binding_level = previous_class_level;
5395 /* Restore IDENTIFIER_TYPE_VALUE. */
5396 for (type = class_binding_level->type_shadowed;
5397 type;
5398 type = TREE_CHAIN (type))
5399 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5400 }
5401
5402 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5403 appropriate for TYPE.
5404
5405 So that we may avoid calls to lookup_name, we cache the _TYPE
5406 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5407
5408 For multiple inheritance, we perform a two-pass depth-first search
5409 of the type lattice. */
5410
5411 void
5412 pushclass (tree type)
5413 {
5414 type = TYPE_MAIN_VARIANT (type);
5415
5416 /* Make sure there is enough room for the new entry on the stack. */
5417 if (current_class_depth + 1 >= current_class_stack_size)
5418 {
5419 current_class_stack_size *= 2;
5420 current_class_stack
5421 = xrealloc (current_class_stack,
5422 current_class_stack_size
5423 * sizeof (struct class_stack_node));
5424 }
5425
5426 /* Insert a new entry on the class stack. */
5427 current_class_stack[current_class_depth].name = current_class_name;
5428 current_class_stack[current_class_depth].type = current_class_type;
5429 current_class_stack[current_class_depth].access = current_access_specifier;
5430 current_class_stack[current_class_depth].names_used = 0;
5431 current_class_depth++;
5432
5433 /* Now set up the new type. */
5434 current_class_name = TYPE_NAME (type);
5435 if (TREE_CODE (current_class_name) == TYPE_DECL)
5436 current_class_name = DECL_NAME (current_class_name);
5437 current_class_type = type;
5438
5439 /* By default, things in classes are private, while things in
5440 structures or unions are public. */
5441 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5442 ? access_private_node
5443 : access_public_node);
5444
5445 if (previous_class_level
5446 && type != previous_class_level->this_entity
5447 && current_class_depth == 1)
5448 {
5449 /* Forcibly remove any old class remnants. */
5450 invalidate_class_lookup_cache ();
5451 }
5452
5453 if (!previous_class_level
5454 || type != previous_class_level->this_entity
5455 || current_class_depth > 1)
5456 pushlevel_class ();
5457 else
5458 restore_class_cache ();
5459
5460 cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type));
5461 }
5462
5463 /* When we exit a toplevel class scope, we save its binding level so
5464 that we can restore it quickly. Here, we've entered some other
5465 class, so we must invalidate our cache. */
5466
5467 void
5468 invalidate_class_lookup_cache (void)
5469 {
5470 previous_class_level = NULL;
5471 }
5472
5473 /* Get out of the current class scope. If we were in a class scope
5474 previously, that is the one popped to. */
5475
5476 void
5477 popclass (void)
5478 {
5479 poplevel_class ();
5480
5481 current_class_depth--;
5482 current_class_name = current_class_stack[current_class_depth].name;
5483 current_class_type = current_class_stack[current_class_depth].type;
5484 current_access_specifier = current_class_stack[current_class_depth].access;
5485 if (current_class_stack[current_class_depth].names_used)
5486 splay_tree_delete (current_class_stack[current_class_depth].names_used);
5487 }
5488
5489 /* Returns 1 if current_class_type is either T or a nested type of T.
5490 We start looking from 1 because entry 0 is from global scope, and has
5491 no type. */
5492
5493 int
5494 currently_open_class (tree t)
5495 {
5496 int i;
5497 if (current_class_type && same_type_p (t, current_class_type))
5498 return 1;
5499 for (i = 1; i < current_class_depth; ++i)
5500 if (current_class_stack[i].type
5501 && same_type_p (current_class_stack [i].type, t))
5502 return 1;
5503 return 0;
5504 }
5505
5506 /* If either current_class_type or one of its enclosing classes are derived
5507 from T, return the appropriate type. Used to determine how we found
5508 something via unqualified lookup. */
5509
5510 tree
5511 currently_open_derived_class (tree t)
5512 {
5513 int i;
5514
5515 /* The bases of a dependent type are unknown. */
5516 if (dependent_type_p (t))
5517 return NULL_TREE;
5518
5519 if (!current_class_type)
5520 return NULL_TREE;
5521
5522 if (DERIVED_FROM_P (t, current_class_type))
5523 return current_class_type;
5524
5525 for (i = current_class_depth - 1; i > 0; --i)
5526 if (DERIVED_FROM_P (t, current_class_stack[i].type))
5527 return current_class_stack[i].type;
5528
5529 return NULL_TREE;
5530 }
5531
5532 /* When entering a class scope, all enclosing class scopes' names with
5533 static meaning (static variables, static functions, types and
5534 enumerators) have to be visible. This recursive function calls
5535 pushclass for all enclosing class contexts until global or a local
5536 scope is reached. TYPE is the enclosed class. */
5537
5538 void
5539 push_nested_class (tree type)
5540 {
5541 tree context;
5542
5543 /* A namespace might be passed in error cases, like A::B:C. */
5544 if (type == NULL_TREE
5545 || type == error_mark_node
5546 || TREE_CODE (type) == NAMESPACE_DECL
5547 || ! IS_AGGR_TYPE (type)
5548 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5549 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
5550 return;
5551
5552 context = DECL_CONTEXT (TYPE_MAIN_DECL (type));
5553
5554 if (context && CLASS_TYPE_P (context))
5555 push_nested_class (context);
5556 pushclass (type);
5557 }
5558
5559 /* Undoes a push_nested_class call. */
5560
5561 void
5562 pop_nested_class (void)
5563 {
5564 tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
5565
5566 popclass ();
5567 if (context && CLASS_TYPE_P (context))
5568 pop_nested_class ();
5569 }
5570
5571 /* Returns the number of extern "LANG" blocks we are nested within. */
5572
5573 int
5574 current_lang_depth (void)
5575 {
5576 return VARRAY_ACTIVE_SIZE (current_lang_base);
5577 }
5578
5579 /* Set global variables CURRENT_LANG_NAME to appropriate value
5580 so that behavior of name-mangling machinery is correct. */
5581
5582 void
5583 push_lang_context (tree name)
5584 {
5585 VARRAY_PUSH_TREE (current_lang_base, current_lang_name);
5586
5587 if (name == lang_name_cplusplus)
5588 {
5589 current_lang_name = name;
5590 }
5591 else if (name == lang_name_java)
5592 {
5593 current_lang_name = name;
5594 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5595 (See record_builtin_java_type in decl.c.) However, that causes
5596 incorrect debug entries if these types are actually used.
5597 So we re-enable debug output after extern "Java". */
5598 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
5599 DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
5600 DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
5601 DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
5602 DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
5603 DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
5604 DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
5605 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
5606 }
5607 else if (name == lang_name_c)
5608 {
5609 current_lang_name = name;
5610 }
5611 else
5612 error ("language string `\"%E\"' not recognized", name);
5613 }
5614
5615 /* Get out of the current language scope. */
5616
5617 void
5618 pop_lang_context (void)
5619 {
5620 current_lang_name = VARRAY_TOP_TREE (current_lang_base);
5621 VARRAY_POP (current_lang_base);
5622 }
5623 \f
5624 /* Type instantiation routines. */
5625
5626 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5627 matches the TARGET_TYPE. If there is no satisfactory match, return
5628 error_mark_node, and issue a error & warning messages under control
5629 of FLAGS. Permit pointers to member function if FLAGS permits. If
5630 TEMPLATE_ONLY, the name of the overloaded function was a
5631 template-id, and EXPLICIT_TARGS are the explicitly provided
5632 template arguments. */
5633
5634 static tree
5635 resolve_address_of_overloaded_function (tree target_type,
5636 tree overload,
5637 tsubst_flags_t flags,
5638 bool template_only,
5639 tree explicit_targs)
5640 {
5641 /* Here's what the standard says:
5642
5643 [over.over]
5644
5645 If the name is a function template, template argument deduction
5646 is done, and if the argument deduction succeeds, the deduced
5647 arguments are used to generate a single template function, which
5648 is added to the set of overloaded functions considered.
5649
5650 Non-member functions and static member functions match targets of
5651 type "pointer-to-function" or "reference-to-function." Nonstatic
5652 member functions match targets of type "pointer-to-member
5653 function;" the function type of the pointer to member is used to
5654 select the member function from the set of overloaded member
5655 functions. If a nonstatic member function is selected, the
5656 reference to the overloaded function name is required to have the
5657 form of a pointer to member as described in 5.3.1.
5658
5659 If more than one function is selected, any template functions in
5660 the set are eliminated if the set also contains a non-template
5661 function, and any given template function is eliminated if the
5662 set contains a second template function that is more specialized
5663 than the first according to the partial ordering rules 14.5.5.2.
5664 After such eliminations, if any, there shall remain exactly one
5665 selected function. */
5666
5667 int is_ptrmem = 0;
5668 int is_reference = 0;
5669 /* We store the matches in a TREE_LIST rooted here. The functions
5670 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5671 interoperability with most_specialized_instantiation. */
5672 tree matches = NULL_TREE;
5673 tree fn;
5674
5675 /* By the time we get here, we should be seeing only real
5676 pointer-to-member types, not the internal POINTER_TYPE to
5677 METHOD_TYPE representation. */
5678 gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
5679 || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
5680
5681 gcc_assert (is_overloaded_fn (overload));
5682
5683 /* Check that the TARGET_TYPE is reasonable. */
5684 if (TYPE_PTRFN_P (target_type))
5685 /* This is OK. */;
5686 else if (TYPE_PTRMEMFUNC_P (target_type))
5687 /* This is OK, too. */
5688 is_ptrmem = 1;
5689 else if (TREE_CODE (target_type) == FUNCTION_TYPE)
5690 {
5691 /* This is OK, too. This comes from a conversion to reference
5692 type. */
5693 target_type = build_reference_type (target_type);
5694 is_reference = 1;
5695 }
5696 else
5697 {
5698 if (flags & tf_error)
5699 error ("\
5700 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5701 DECL_NAME (OVL_FUNCTION (overload)), target_type);
5702 return error_mark_node;
5703 }
5704
5705 /* If we can find a non-template function that matches, we can just
5706 use it. There's no point in generating template instantiations
5707 if we're just going to throw them out anyhow. But, of course, we
5708 can only do this when we don't *need* a template function. */
5709 if (!template_only)
5710 {
5711 tree fns;
5712
5713 for (fns = overload; fns; fns = OVL_NEXT (fns))
5714 {
5715 tree fn = OVL_CURRENT (fns);
5716 tree fntype;
5717
5718 if (TREE_CODE (fn) == TEMPLATE_DECL)
5719 /* We're not looking for templates just yet. */
5720 continue;
5721
5722 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5723 != is_ptrmem)
5724 /* We're looking for a non-static member, and this isn't
5725 one, or vice versa. */
5726 continue;
5727
5728 /* Ignore anticipated decls of undeclared builtins. */
5729 if (DECL_ANTICIPATED (fn))
5730 continue;
5731
5732 /* See if there's a match. */
5733 fntype = TREE_TYPE (fn);
5734 if (is_ptrmem)
5735 fntype = build_ptrmemfunc_type (build_pointer_type (fntype));
5736 else if (!is_reference)
5737 fntype = build_pointer_type (fntype);
5738
5739 if (can_convert_arg (target_type, fntype, fn))
5740 matches = tree_cons (fn, NULL_TREE, matches);
5741 }
5742 }
5743
5744 /* Now, if we've already got a match (or matches), there's no need
5745 to proceed to the template functions. But, if we don't have a
5746 match we need to look at them, too. */
5747 if (!matches)
5748 {
5749 tree target_fn_type;
5750 tree target_arg_types;
5751 tree target_ret_type;
5752 tree fns;
5753
5754 if (is_ptrmem)
5755 target_fn_type
5756 = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type));
5757 else
5758 target_fn_type = TREE_TYPE (target_type);
5759 target_arg_types = TYPE_ARG_TYPES (target_fn_type);
5760 target_ret_type = TREE_TYPE (target_fn_type);
5761
5762 /* Never do unification on the 'this' parameter. */
5763 if (TREE_CODE (target_fn_type) == METHOD_TYPE)
5764 target_arg_types = TREE_CHAIN (target_arg_types);
5765
5766 for (fns = overload; fns; fns = OVL_NEXT (fns))
5767 {
5768 tree fn = OVL_CURRENT (fns);
5769 tree instantiation;
5770 tree instantiation_type;
5771 tree targs;
5772
5773 if (TREE_CODE (fn) != TEMPLATE_DECL)
5774 /* We're only looking for templates. */
5775 continue;
5776
5777 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
5778 != is_ptrmem)
5779 /* We're not looking for a non-static member, and this is
5780 one, or vice versa. */
5781 continue;
5782
5783 /* Try to do argument deduction. */
5784 targs = make_tree_vec (DECL_NTPARMS (fn));
5785 if (fn_type_unification (fn, explicit_targs, targs,
5786 target_arg_types, target_ret_type,
5787 DEDUCE_EXACT, -1) != 0)
5788 /* Argument deduction failed. */
5789 continue;
5790
5791 /* Instantiate the template. */
5792 instantiation = instantiate_template (fn, targs, flags);
5793 if (instantiation == error_mark_node)
5794 /* Instantiation failed. */
5795 continue;
5796
5797 /* See if there's a match. */
5798 instantiation_type = TREE_TYPE (instantiation);
5799 if (is_ptrmem)
5800 instantiation_type =
5801 build_ptrmemfunc_type (build_pointer_type (instantiation_type));
5802 else if (!is_reference)
5803 instantiation_type = build_pointer_type (instantiation_type);
5804 if (can_convert_arg (target_type, instantiation_type, instantiation))
5805 matches = tree_cons (instantiation, fn, matches);
5806 }
5807
5808 /* Now, remove all but the most specialized of the matches. */
5809 if (matches)
5810 {
5811 tree match = most_specialized_instantiation (matches);
5812
5813 if (match != error_mark_node)
5814 matches = tree_cons (match, NULL_TREE, NULL_TREE);
5815 }
5816 }
5817
5818 /* Now we should have exactly one function in MATCHES. */
5819 if (matches == NULL_TREE)
5820 {
5821 /* There were *no* matches. */
5822 if (flags & tf_error)
5823 {
5824 error ("no matches converting function `%D' to type `%#T'",
5825 DECL_NAME (OVL_FUNCTION (overload)),
5826 target_type);
5827
5828 /* print_candidates expects a chain with the functions in
5829 TREE_VALUE slots, so we cons one up here (we're losing anyway,
5830 so why be clever?). */
5831 for (; overload; overload = OVL_NEXT (overload))
5832 matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
5833 matches);
5834
5835 print_candidates (matches);
5836 }
5837 return error_mark_node;
5838 }
5839 else if (TREE_CHAIN (matches))
5840 {
5841 /* There were too many matches. */
5842
5843 if (flags & tf_error)
5844 {
5845 tree match;
5846
5847 error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5848 DECL_NAME (OVL_FUNCTION (overload)),
5849 target_type);
5850
5851 /* Since print_candidates expects the functions in the
5852 TREE_VALUE slot, we flip them here. */
5853 for (match = matches; match; match = TREE_CHAIN (match))
5854 TREE_VALUE (match) = TREE_PURPOSE (match);
5855
5856 print_candidates (matches);
5857 }
5858
5859 return error_mark_node;
5860 }
5861
5862 /* Good, exactly one match. Now, convert it to the correct type. */
5863 fn = TREE_PURPOSE (matches);
5864
5865 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
5866 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
5867 {
5868 static int explained;
5869
5870 if (!(flags & tf_error))
5871 return error_mark_node;
5872
5873 pedwarn ("assuming pointer to member `%D'", fn);
5874 if (!explained)
5875 {
5876 pedwarn ("(a pointer to member can only be formed with `&%E')", fn);
5877 explained = 1;
5878 }
5879 }
5880
5881 /* If we're doing overload resolution purely for the purpose of
5882 determining conversion sequences, we should not consider the
5883 function used. If this conversion sequence is selected, the
5884 function will be marked as used at this point. */
5885 if (!(flags & tf_conv))
5886 mark_used (fn);
5887
5888 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
5889 return build_unary_op (ADDR_EXPR, fn, 0);
5890 else
5891 {
5892 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
5893 will mark the function as addressed, but here we must do it
5894 explicitly. */
5895 cxx_mark_addressable (fn);
5896
5897 return fn;
5898 }
5899 }
5900
5901 /* This function will instantiate the type of the expression given in
5902 RHS to match the type of LHSTYPE. If errors exist, then return
5903 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
5904 we complain on errors. If we are not complaining, never modify rhs,
5905 as overload resolution wants to try many possible instantiations, in
5906 the hope that at least one will work.
5907
5908 For non-recursive calls, LHSTYPE should be a function, pointer to
5909 function, or a pointer to member function. */
5910
5911 tree
5912 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
5913 {
5914 tsubst_flags_t flags_in = flags;
5915
5916 flags &= ~tf_ptrmem_ok;
5917
5918 if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
5919 {
5920 if (flags & tf_error)
5921 error ("not enough type information");
5922 return error_mark_node;
5923 }
5924
5925 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
5926 {
5927 if (same_type_p (lhstype, TREE_TYPE (rhs)))
5928 return rhs;
5929 if (flag_ms_extensions
5930 && TYPE_PTRMEMFUNC_P (lhstype)
5931 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
5932 /* Microsoft allows `A::f' to be resolved to a
5933 pointer-to-member. */
5934 ;
5935 else
5936 {
5937 if (flags & tf_error)
5938 error ("argument of type `%T' does not match `%T'",
5939 TREE_TYPE (rhs), lhstype);
5940 return error_mark_node;
5941 }
5942 }
5943
5944 if (TREE_CODE (rhs) == BASELINK)
5945 rhs = BASELINK_FUNCTIONS (rhs);
5946
5947 /* We don't overwrite rhs if it is an overloaded function.
5948 Copying it would destroy the tree link. */
5949 if (TREE_CODE (rhs) != OVERLOAD)
5950 rhs = copy_node (rhs);
5951
5952 /* This should really only be used when attempting to distinguish
5953 what sort of a pointer to function we have. For now, any
5954 arithmetic operation which is not supported on pointers
5955 is rejected as an error. */
5956
5957 switch (TREE_CODE (rhs))
5958 {
5959 case TYPE_EXPR:
5960 case CONVERT_EXPR:
5961 case SAVE_EXPR:
5962 case CONSTRUCTOR:
5963 gcc_unreachable ();
5964
5965 case INDIRECT_REF:
5966 case ARRAY_REF:
5967 {
5968 tree new_rhs;
5969
5970 new_rhs = instantiate_type (build_pointer_type (lhstype),
5971 TREE_OPERAND (rhs, 0), flags);
5972 if (new_rhs == error_mark_node)
5973 return error_mark_node;
5974
5975 TREE_TYPE (rhs) = lhstype;
5976 TREE_OPERAND (rhs, 0) = new_rhs;
5977 return rhs;
5978 }
5979
5980 case NOP_EXPR:
5981 rhs = copy_node (TREE_OPERAND (rhs, 0));
5982 TREE_TYPE (rhs) = unknown_type_node;
5983 return instantiate_type (lhstype, rhs, flags);
5984
5985 case COMPONENT_REF:
5986 {
5987 tree addr = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
5988
5989 if (addr != error_mark_node
5990 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
5991 /* Do not lose object's side effects. */
5992 addr = build2 (COMPOUND_EXPR, TREE_TYPE (addr),
5993 TREE_OPERAND (rhs, 0), addr);
5994 return addr;
5995 }
5996
5997 case OFFSET_REF:
5998 rhs = TREE_OPERAND (rhs, 1);
5999 if (BASELINK_P (rhs))
6000 return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags_in);
6001
6002 /* This can happen if we are forming a pointer-to-member for a
6003 member template. */
6004 gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6005
6006 /* Fall through. */
6007
6008 case TEMPLATE_ID_EXPR:
6009 {
6010 tree fns = TREE_OPERAND (rhs, 0);
6011 tree args = TREE_OPERAND (rhs, 1);
6012
6013 return
6014 resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6015 /*template_only=*/true,
6016 args);
6017 }
6018
6019 case OVERLOAD:
6020 case FUNCTION_DECL:
6021 return
6022 resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6023 /*template_only=*/false,
6024 /*explicit_targs=*/NULL_TREE);
6025
6026 case TREE_LIST:
6027 /* Now we should have a baselink. */
6028 gcc_assert (BASELINK_P (rhs));
6029
6030 return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
6031
6032 case CALL_EXPR:
6033 /* This is too hard for now. */
6034 gcc_unreachable ();
6035
6036 case PLUS_EXPR:
6037 case MINUS_EXPR:
6038 case COMPOUND_EXPR:
6039 TREE_OPERAND (rhs, 0)
6040 = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6041 if (TREE_OPERAND (rhs, 0) == error_mark_node)
6042 return error_mark_node;
6043 TREE_OPERAND (rhs, 1)
6044 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6045 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6046 return error_mark_node;
6047
6048 TREE_TYPE (rhs) = lhstype;
6049 return rhs;
6050
6051 case MULT_EXPR:
6052 case TRUNC_DIV_EXPR:
6053 case FLOOR_DIV_EXPR:
6054 case CEIL_DIV_EXPR:
6055 case ROUND_DIV_EXPR:
6056 case RDIV_EXPR:
6057 case TRUNC_MOD_EXPR:
6058 case FLOOR_MOD_EXPR:
6059 case CEIL_MOD_EXPR:
6060 case ROUND_MOD_EXPR:
6061 case FIX_ROUND_EXPR:
6062 case FIX_FLOOR_EXPR:
6063 case FIX_CEIL_EXPR:
6064 case FIX_TRUNC_EXPR:
6065 case FLOAT_EXPR:
6066 case NEGATE_EXPR:
6067 case ABS_EXPR:
6068 case MAX_EXPR:
6069 case MIN_EXPR:
6070
6071 case BIT_AND_EXPR:
6072 case BIT_IOR_EXPR:
6073 case BIT_XOR_EXPR:
6074 case LSHIFT_EXPR:
6075 case RSHIFT_EXPR:
6076 case LROTATE_EXPR:
6077 case RROTATE_EXPR:
6078
6079 case PREINCREMENT_EXPR:
6080 case PREDECREMENT_EXPR:
6081 case POSTINCREMENT_EXPR:
6082 case POSTDECREMENT_EXPR:
6083 if (flags & tf_error)
6084 error ("invalid operation on uninstantiated type");
6085 return error_mark_node;
6086
6087 case TRUTH_AND_EXPR:
6088 case TRUTH_OR_EXPR:
6089 case TRUTH_XOR_EXPR:
6090 case LT_EXPR:
6091 case LE_EXPR:
6092 case GT_EXPR:
6093 case GE_EXPR:
6094 case EQ_EXPR:
6095 case NE_EXPR:
6096 case TRUTH_ANDIF_EXPR:
6097 case TRUTH_ORIF_EXPR:
6098 case TRUTH_NOT_EXPR:
6099 if (flags & tf_error)
6100 error ("not enough type information");
6101 return error_mark_node;
6102
6103 case COND_EXPR:
6104 if (type_unknown_p (TREE_OPERAND (rhs, 0)))
6105 {
6106 if (flags & tf_error)
6107 error ("not enough type information");
6108 return error_mark_node;
6109 }
6110 TREE_OPERAND (rhs, 1)
6111 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6112 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6113 return error_mark_node;
6114 TREE_OPERAND (rhs, 2)
6115 = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), flags);
6116 if (TREE_OPERAND (rhs, 2) == error_mark_node)
6117 return error_mark_node;
6118
6119 TREE_TYPE (rhs) = lhstype;
6120 return rhs;
6121
6122 case MODIFY_EXPR:
6123 TREE_OPERAND (rhs, 1)
6124 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), flags);
6125 if (TREE_OPERAND (rhs, 1) == error_mark_node)
6126 return error_mark_node;
6127
6128 TREE_TYPE (rhs) = lhstype;
6129 return rhs;
6130
6131 case ADDR_EXPR:
6132 {
6133 if (PTRMEM_OK_P (rhs))
6134 flags |= tf_ptrmem_ok;
6135
6136 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6137 }
6138
6139 case ERROR_MARK:
6140 return error_mark_node;
6141
6142 default:
6143 gcc_unreachable ();
6144 }
6145 return error_mark_node;
6146 }
6147 \f
6148 /* Return the name of the virtual function pointer field
6149 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6150 this may have to look back through base types to find the
6151 ultimate field name. (For single inheritance, these could
6152 all be the same name. Who knows for multiple inheritance). */
6153
6154 static tree
6155 get_vfield_name (tree type)
6156 {
6157 tree binfo, base_binfo;
6158 char *buf;
6159
6160 for (binfo = TYPE_BINFO (type);
6161 BINFO_N_BASE_BINFOS (binfo);
6162 binfo = base_binfo)
6163 {
6164 base_binfo = BINFO_BASE_BINFO (binfo, 0);
6165
6166 if (BINFO_VIRTUAL_P (base_binfo)
6167 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6168 break;
6169 }
6170
6171 type = BINFO_TYPE (binfo);
6172 buf = alloca (sizeof (VFIELD_NAME_FORMAT) + TYPE_NAME_LENGTH (type) + 2);
6173 sprintf (buf, VFIELD_NAME_FORMAT,
6174 IDENTIFIER_POINTER (constructor_name (type)));
6175 return get_identifier (buf);
6176 }
6177
6178 void
6179 print_class_statistics (void)
6180 {
6181 #ifdef GATHER_STATISTICS
6182 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6183 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6184 if (n_vtables)
6185 {
6186 fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6187 n_vtables, n_vtable_searches);
6188 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6189 n_vtable_entries, n_vtable_elems);
6190 }
6191 #endif
6192 }
6193
6194 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6195 according to [class]:
6196 The class-name is also inserted
6197 into the scope of the class itself. For purposes of access checking,
6198 the inserted class name is treated as if it were a public member name. */
6199
6200 void
6201 build_self_reference (void)
6202 {
6203 tree name = constructor_name (current_class_type);
6204 tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6205 tree saved_cas;
6206
6207 DECL_NONLOCAL (value) = 1;
6208 DECL_CONTEXT (value) = current_class_type;
6209 DECL_ARTIFICIAL (value) = 1;
6210 SET_DECL_SELF_REFERENCE_P (value);
6211
6212 if (processing_template_decl)
6213 value = push_template_decl (value);
6214
6215 saved_cas = current_access_specifier;
6216 current_access_specifier = access_public_node;
6217 finish_member_declaration (value);
6218 current_access_specifier = saved_cas;
6219 }
6220
6221 /* Returns 1 if TYPE contains only padding bytes. */
6222
6223 int
6224 is_empty_class (tree type)
6225 {
6226 if (type == error_mark_node)
6227 return 0;
6228
6229 if (! IS_AGGR_TYPE (type))
6230 return 0;
6231
6232 /* In G++ 3.2, whether or not a class was empty was determined by
6233 looking at its size. */
6234 if (abi_version_at_least (2))
6235 return CLASSTYPE_EMPTY_P (type);
6236 else
6237 return integer_zerop (CLASSTYPE_SIZE (type));
6238 }
6239
6240 /* Returns true if TYPE contains an empty class. */
6241
6242 static bool
6243 contains_empty_class_p (tree type)
6244 {
6245 if (is_empty_class (type))
6246 return true;
6247 if (CLASS_TYPE_P (type))
6248 {
6249 tree field;
6250 tree binfo;
6251 tree base_binfo;
6252 int i;
6253
6254 for (binfo = TYPE_BINFO (type), i = 0;
6255 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6256 if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6257 return true;
6258 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6259 if (TREE_CODE (field) == FIELD_DECL
6260 && !DECL_ARTIFICIAL (field)
6261 && is_empty_class (TREE_TYPE (field)))
6262 return true;
6263 }
6264 else if (TREE_CODE (type) == ARRAY_TYPE)
6265 return contains_empty_class_p (TREE_TYPE (type));
6266 return false;
6267 }
6268
6269 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6270 a *_TYPE node. NODE can also be a local class. */
6271
6272 tree
6273 get_enclosing_class (tree type)
6274 {
6275 tree node = type;
6276
6277 while (node && TREE_CODE (node) != NAMESPACE_DECL)
6278 {
6279 switch (TREE_CODE_CLASS (TREE_CODE (node)))
6280 {
6281 case 'd':
6282 node = DECL_CONTEXT (node);
6283 break;
6284
6285 case 't':
6286 if (node != type)
6287 return node;
6288 node = TYPE_CONTEXT (node);
6289 break;
6290
6291 default:
6292 gcc_unreachable ();
6293 }
6294 }
6295 return NULL_TREE;
6296 }
6297
6298 /* Note that NAME was looked up while the current class was being
6299 defined and that the result of that lookup was DECL. */
6300
6301 void
6302 maybe_note_name_used_in_class (tree name, tree decl)
6303 {
6304 splay_tree names_used;
6305
6306 /* If we're not defining a class, there's nothing to do. */
6307 if (!(innermost_scope_kind() == sk_class
6308 && TYPE_BEING_DEFINED (current_class_type)))
6309 return;
6310
6311 /* If there's already a binding for this NAME, then we don't have
6312 anything to worry about. */
6313 if (lookup_member (current_class_type, name,
6314 /*protect=*/0, /*want_type=*/false))
6315 return;
6316
6317 if (!current_class_stack[current_class_depth - 1].names_used)
6318 current_class_stack[current_class_depth - 1].names_used
6319 = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6320 names_used = current_class_stack[current_class_depth - 1].names_used;
6321
6322 splay_tree_insert (names_used,
6323 (splay_tree_key) name,
6324 (splay_tree_value) decl);
6325 }
6326
6327 /* Note that NAME was declared (as DECL) in the current class. Check
6328 to see that the declaration is valid. */
6329
6330 void
6331 note_name_declared_in_class (tree name, tree decl)
6332 {
6333 splay_tree names_used;
6334 splay_tree_node n;
6335
6336 /* Look to see if we ever used this name. */
6337 names_used
6338 = current_class_stack[current_class_depth - 1].names_used;
6339 if (!names_used)
6340 return;
6341
6342 n = splay_tree_lookup (names_used, (splay_tree_key) name);
6343 if (n)
6344 {
6345 /* [basic.scope.class]
6346
6347 A name N used in a class S shall refer to the same declaration
6348 in its context and when re-evaluated in the completed scope of
6349 S. */
6350 error ("declaration of `%#D'", decl);
6351 cp_error_at ("changes meaning of `%D' from `%+#D'",
6352 DECL_NAME (OVL_CURRENT (decl)),
6353 (tree) n->value);
6354 }
6355 }
6356
6357 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6358 Secondary vtables are merged with primary vtables; this function
6359 will return the VAR_DECL for the primary vtable. */
6360
6361 tree
6362 get_vtbl_decl_for_binfo (tree binfo)
6363 {
6364 tree decl;
6365
6366 decl = BINFO_VTABLE (binfo);
6367 if (decl && TREE_CODE (decl) == PLUS_EXPR)
6368 {
6369 gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6370 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6371 }
6372 if (decl)
6373 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6374 return decl;
6375 }
6376
6377
6378 /* Returns the binfo for the primary base of BINFO. If the resulting
6379 BINFO is a virtual base, and it is inherited elsewhere in the
6380 hierarchy, then the returned binfo might not be the primary base of
6381 BINFO in the complete object. Check BINFO_PRIMARY_P or
6382 BINFO_LOST_PRIMARY_P to be sure. */
6383
6384 tree
6385 get_primary_binfo (tree binfo)
6386 {
6387 tree primary_base;
6388 tree result;
6389
6390 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6391 if (!primary_base)
6392 return NULL_TREE;
6393
6394 result = copied_binfo (primary_base, binfo);
6395 return result;
6396 }
6397
6398 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6399
6400 static int
6401 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6402 {
6403 if (!indented_p)
6404 fprintf (stream, "%*s", indent, "");
6405 return 1;
6406 }
6407
6408 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6409 INDENT should be zero when called from the top level; it is
6410 incremented recursively. IGO indicates the next expected BINFO in
6411 inheritance graph ordering. */
6412
6413 static tree
6414 dump_class_hierarchy_r (FILE *stream,
6415 int flags,
6416 tree binfo,
6417 tree igo,
6418 int indent)
6419 {
6420 int indented = 0;
6421 tree base_binfo;
6422 int i;
6423
6424 indented = maybe_indent_hierarchy (stream, indent, 0);
6425 fprintf (stream, "%s (0x%lx) ",
6426 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6427 (unsigned long) binfo);
6428 if (binfo != igo)
6429 {
6430 fprintf (stream, "alternative-path\n");
6431 return igo;
6432 }
6433 igo = TREE_CHAIN (binfo);
6434
6435 fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6436 tree_low_cst (BINFO_OFFSET (binfo), 0));
6437 if (is_empty_class (BINFO_TYPE (binfo)))
6438 fprintf (stream, " empty");
6439 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6440 fprintf (stream, " nearly-empty");
6441 if (BINFO_VIRTUAL_P (binfo))
6442 fprintf (stream, " virtual");
6443 fprintf (stream, "\n");
6444
6445 indented = 0;
6446 if (BINFO_PRIMARY_P (binfo))
6447 {
6448 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6449 fprintf (stream, " primary-for %s (0x%lx)",
6450 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6451 TFF_PLAIN_IDENTIFIER),
6452 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6453 }
6454 if (BINFO_LOST_PRIMARY_P (binfo))
6455 {
6456 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6457 fprintf (stream, " lost-primary");
6458 }
6459 if (indented)
6460 fprintf (stream, "\n");
6461
6462 if (!(flags & TDF_SLIM))
6463 {
6464 int indented = 0;
6465
6466 if (BINFO_SUBVTT_INDEX (binfo))
6467 {
6468 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6469 fprintf (stream, " subvttidx=%s",
6470 expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6471 TFF_PLAIN_IDENTIFIER));
6472 }
6473 if (BINFO_VPTR_INDEX (binfo))
6474 {
6475 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6476 fprintf (stream, " vptridx=%s",
6477 expr_as_string (BINFO_VPTR_INDEX (binfo),
6478 TFF_PLAIN_IDENTIFIER));
6479 }
6480 if (BINFO_VPTR_FIELD (binfo))
6481 {
6482 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6483 fprintf (stream, " vbaseoffset=%s",
6484 expr_as_string (BINFO_VPTR_FIELD (binfo),
6485 TFF_PLAIN_IDENTIFIER));
6486 }
6487 if (BINFO_VTABLE (binfo))
6488 {
6489 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6490 fprintf (stream, " vptr=%s",
6491 expr_as_string (BINFO_VTABLE (binfo),
6492 TFF_PLAIN_IDENTIFIER));
6493 }
6494
6495 if (indented)
6496 fprintf (stream, "\n");
6497 }
6498
6499 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6500 igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6501
6502 return igo;
6503 }
6504
6505 /* Dump the BINFO hierarchy for T. */
6506
6507 static void
6508 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6509 {
6510 fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6511 fprintf (stream, " size=%lu align=%lu\n",
6512 (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6513 (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6514 fprintf (stream, " base size=%lu base align=%lu\n",
6515 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6516 / BITS_PER_UNIT),
6517 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6518 / BITS_PER_UNIT));
6519 dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6520 fprintf (stream, "\n");
6521 }
6522
6523 /* Debug interface to hierarchy dumping. */
6524
6525 extern void
6526 debug_class (tree t)
6527 {
6528 dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6529 }
6530
6531 static void
6532 dump_class_hierarchy (tree t)
6533 {
6534 int flags;
6535 FILE *stream = dump_begin (TDI_class, &flags);
6536
6537 if (stream)
6538 {
6539 dump_class_hierarchy_1 (stream, flags, t);
6540 dump_end (TDI_class, stream);
6541 }
6542 }
6543
6544 static void
6545 dump_array (FILE * stream, tree decl)
6546 {
6547 tree inits;
6548 int ix;
6549 HOST_WIDE_INT elt;
6550 tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6551
6552 elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6553 / BITS_PER_UNIT);
6554 fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6555 fprintf (stream, " %s entries",
6556 expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6557 TFF_PLAIN_IDENTIFIER));
6558 fprintf (stream, "\n");
6559
6560 for (ix = 0, inits = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
6561 inits; ix++, inits = TREE_CHAIN (inits))
6562 fprintf (stream, "%-4ld %s\n", (long)(ix * elt),
6563 expr_as_string (TREE_VALUE (inits), TFF_PLAIN_IDENTIFIER));
6564 }
6565
6566 static void
6567 dump_vtable (tree t, tree binfo, tree vtable)
6568 {
6569 int flags;
6570 FILE *stream = dump_begin (TDI_class, &flags);
6571
6572 if (!stream)
6573 return;
6574
6575 if (!(flags & TDF_SLIM))
6576 {
6577 int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6578
6579 fprintf (stream, "%s for %s",
6580 ctor_vtbl_p ? "Construction vtable" : "Vtable",
6581 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6582 if (ctor_vtbl_p)
6583 {
6584 if (!BINFO_VIRTUAL_P (binfo))
6585 fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6586 fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6587 }
6588 fprintf (stream, "\n");
6589 dump_array (stream, vtable);
6590 fprintf (stream, "\n");
6591 }
6592
6593 dump_end (TDI_class, stream);
6594 }
6595
6596 static void
6597 dump_vtt (tree t, tree vtt)
6598 {
6599 int flags;
6600 FILE *stream = dump_begin (TDI_class, &flags);
6601
6602 if (!stream)
6603 return;
6604
6605 if (!(flags & TDF_SLIM))
6606 {
6607 fprintf (stream, "VTT for %s\n",
6608 type_as_string (t, TFF_PLAIN_IDENTIFIER));
6609 dump_array (stream, vtt);
6610 fprintf (stream, "\n");
6611 }
6612
6613 dump_end (TDI_class, stream);
6614 }
6615
6616 /* Dump a function or thunk and its thunkees. */
6617
6618 static void
6619 dump_thunk (FILE *stream, int indent, tree thunk)
6620 {
6621 static const char spaces[] = " ";
6622 tree name = DECL_NAME (thunk);
6623 tree thunks;
6624
6625 fprintf (stream, "%.*s%p %s %s", indent, spaces,
6626 (void *)thunk,
6627 !DECL_THUNK_P (thunk) ? "function"
6628 : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
6629 name ? IDENTIFIER_POINTER (name) : "<unset>");
6630 if (DECL_THUNK_P (thunk))
6631 {
6632 HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
6633 tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
6634
6635 fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
6636 if (!virtual_adjust)
6637 /*NOP*/;
6638 else if (DECL_THIS_THUNK_P (thunk))
6639 fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC,
6640 tree_low_cst (virtual_adjust, 0));
6641 else
6642 fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
6643 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
6644 type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
6645 if (THUNK_ALIAS (thunk))
6646 fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
6647 }
6648 fprintf (stream, "\n");
6649 for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
6650 dump_thunk (stream, indent + 2, thunks);
6651 }
6652
6653 /* Dump the thunks for FN. */
6654
6655 extern void
6656 debug_thunks (tree fn)
6657 {
6658 dump_thunk (stderr, 0, fn);
6659 }
6660
6661 /* Virtual function table initialization. */
6662
6663 /* Create all the necessary vtables for T and its base classes. */
6664
6665 static void
6666 finish_vtbls (tree t)
6667 {
6668 tree list;
6669 tree vbase;
6670
6671 /* We lay out the primary and secondary vtables in one contiguous
6672 vtable. The primary vtable is first, followed by the non-virtual
6673 secondary vtables in inheritance graph order. */
6674 list = build_tree_list (BINFO_VTABLE (TYPE_BINFO (t)), NULL_TREE);
6675 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6676 TYPE_BINFO (t), t, list);
6677
6678 /* Then come the virtual bases, also in inheritance graph order. */
6679 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6680 {
6681 if (!BINFO_VIRTUAL_P (vbase))
6682 continue;
6683 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6684 }
6685
6686 if (BINFO_VTABLE (TYPE_BINFO (t)))
6687 initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6688 }
6689
6690 /* Initialize the vtable for BINFO with the INITS. */
6691
6692 static void
6693 initialize_vtable (tree binfo, tree inits)
6694 {
6695 tree decl;
6696
6697 layout_vtable_decl (binfo, list_length (inits));
6698 decl = get_vtbl_decl_for_binfo (binfo);
6699 initialize_artificial_var (decl, inits);
6700 dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6701 }
6702
6703 /* Build the VTT (virtual table table) for T.
6704 A class requires a VTT if it has virtual bases.
6705
6706 This holds
6707 1 - primary virtual pointer for complete object T
6708 2 - secondary VTTs for each direct non-virtual base of T which requires a
6709 VTT
6710 3 - secondary virtual pointers for each direct or indirect base of T which
6711 has virtual bases or is reachable via a virtual path from T.
6712 4 - secondary VTTs for each direct or indirect virtual base of T.
6713
6714 Secondary VTTs look like complete object VTTs without part 4. */
6715
6716 static void
6717 build_vtt (tree t)
6718 {
6719 tree inits;
6720 tree type;
6721 tree vtt;
6722 tree index;
6723
6724 /* Build up the initializers for the VTT. */
6725 inits = NULL_TREE;
6726 index = size_zero_node;
6727 build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
6728
6729 /* If we didn't need a VTT, we're done. */
6730 if (!inits)
6731 return;
6732
6733 /* Figure out the type of the VTT. */
6734 type = build_index_type (size_int (list_length (inits) - 1));
6735 type = build_cplus_array_type (const_ptr_type_node, type);
6736
6737 /* Now, build the VTT object itself. */
6738 vtt = build_vtable (t, get_vtt_name (t), type);
6739 initialize_artificial_var (vtt, inits);
6740 /* Add the VTT to the vtables list. */
6741 TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
6742 TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
6743
6744 dump_vtt (t, vtt);
6745 }
6746
6747 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6748 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6749 and CHAIN the vtable pointer for this binfo after construction is
6750 complete. VALUE can also be another BINFO, in which case we recurse. */
6751
6752 static tree
6753 binfo_ctor_vtable (tree binfo)
6754 {
6755 tree vt;
6756
6757 while (1)
6758 {
6759 vt = BINFO_VTABLE (binfo);
6760 if (TREE_CODE (vt) == TREE_LIST)
6761 vt = TREE_VALUE (vt);
6762 if (TREE_CODE (vt) == TREE_BINFO)
6763 binfo = vt;
6764 else
6765 break;
6766 }
6767
6768 return vt;
6769 }
6770
6771 /* Recursively build the VTT-initializer for BINFO (which is in the
6772 hierarchy dominated by T). INITS points to the end of the initializer
6773 list to date. INDEX is the VTT index where the next element will be
6774 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6775 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
6776 for virtual bases of T. When it is not so, we build the constructor
6777 vtables for the BINFO-in-T variant. */
6778
6779 static tree *
6780 build_vtt_inits (tree binfo, tree t, tree* inits, tree* index)
6781 {
6782 int i;
6783 tree b;
6784 tree init;
6785 tree secondary_vptrs;
6786 int top_level_p = same_type_p (TREE_TYPE (binfo), t);
6787
6788 /* We only need VTTs for subobjects with virtual bases. */
6789 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
6790 return inits;
6791
6792 /* We need to use a construction vtable if this is not the primary
6793 VTT. */
6794 if (!top_level_p)
6795 {
6796 build_ctor_vtbl_group (binfo, t);
6797
6798 /* Record the offset in the VTT where this sub-VTT can be found. */
6799 BINFO_SUBVTT_INDEX (binfo) = *index;
6800 }
6801
6802 /* Add the address of the primary vtable for the complete object. */
6803 init = binfo_ctor_vtable (binfo);
6804 *inits = build_tree_list (NULL_TREE, init);
6805 inits = &TREE_CHAIN (*inits);
6806 if (top_level_p)
6807 {
6808 gcc_assert (!BINFO_VPTR_INDEX (binfo));
6809 BINFO_VPTR_INDEX (binfo) = *index;
6810 }
6811 *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
6812
6813 /* Recursively add the secondary VTTs for non-virtual bases. */
6814 for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
6815 if (!BINFO_VIRTUAL_P (b))
6816 inits = build_vtt_inits (BINFO_BASE_BINFO (binfo, i), t, inits, index);
6817
6818 /* Add secondary virtual pointers for all subobjects of BINFO with
6819 either virtual bases or reachable along a virtual path, except
6820 subobjects that are non-virtual primary bases. */
6821 secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo));
6822 TREE_TYPE (secondary_vptrs) = *index;
6823 VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p;
6824 VTT_MARKED_BINFO_P (secondary_vptrs) = 0;
6825
6826 dfs_walk_real (binfo,
6827 dfs_build_secondary_vptr_vtt_inits,
6828 NULL,
6829 dfs_ctor_vtable_bases_queue_p,
6830 secondary_vptrs);
6831 VTT_MARKED_BINFO_P (secondary_vptrs) = 1;
6832 dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p,
6833 secondary_vptrs);
6834
6835 *index = TREE_TYPE (secondary_vptrs);
6836
6837 /* The secondary vptrs come back in reverse order. After we reverse
6838 them, and add the INITS, the last init will be the first element
6839 of the chain. */
6840 secondary_vptrs = TREE_VALUE (secondary_vptrs);
6841 if (secondary_vptrs)
6842 {
6843 *inits = nreverse (secondary_vptrs);
6844 inits = &TREE_CHAIN (secondary_vptrs);
6845 gcc_assert (*inits == NULL_TREE);
6846 }
6847
6848 /* Add the secondary VTTs for virtual bases. */
6849 if (top_level_p)
6850 for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
6851 {
6852 if (!BINFO_VIRTUAL_P (b))
6853 continue;
6854
6855 inits = build_vtt_inits (b, t, inits, index);
6856 }
6857
6858 if (!top_level_p)
6859 {
6860 tree data = tree_cons (t, binfo, NULL_TREE);
6861 VTT_TOP_LEVEL_P (data) = 0;
6862 VTT_MARKED_BINFO_P (data) = 0;
6863
6864 dfs_walk (binfo, dfs_fixup_binfo_vtbls,
6865 dfs_ctor_vtable_bases_queue_p,
6866 data);
6867 }
6868
6869 return inits;
6870 }
6871
6872 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
6873 in most derived. DATA is a TREE_LIST who's TREE_CHAIN is the type of the
6874 base being constructed whilst this secondary vptr is live. The
6875 TREE_TOP_LEVEL flag indicates that this is the primary VTT. */
6876
6877 static tree
6878 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data)
6879 {
6880 tree l;
6881 tree t;
6882 tree init;
6883 tree index;
6884 int top_level_p;
6885
6886 l = (tree) data;
6887 t = TREE_CHAIN (l);
6888 top_level_p = VTT_TOP_LEVEL_P (l);
6889
6890 BINFO_MARKED (binfo) = 1;
6891
6892 /* We don't care about bases that don't have vtables. */
6893 if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6894 return NULL_TREE;
6895
6896 /* We're only interested in proper subobjects of T. */
6897 if (same_type_p (BINFO_TYPE (binfo), t))
6898 return NULL_TREE;
6899
6900 /* We're not interested in non-virtual primary bases. */
6901 if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
6902 return NULL_TREE;
6903
6904 /* If BINFO has virtual bases or is reachable via a virtual path
6905 from T, it'll have a secondary vptr. */
6906 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
6907 && !binfo_via_virtual (binfo, t))
6908 return NULL_TREE;
6909
6910 /* Record the index where this secondary vptr can be found. */
6911 index = TREE_TYPE (l);
6912 if (top_level_p)
6913 {
6914 gcc_assert (!BINFO_VPTR_INDEX (binfo));
6915 BINFO_VPTR_INDEX (binfo) = index;
6916 }
6917 TREE_TYPE (l) = size_binop (PLUS_EXPR, index,
6918 TYPE_SIZE_UNIT (ptr_type_node));
6919
6920 /* Add the initializer for the secondary vptr itself. */
6921 if (top_level_p && BINFO_VIRTUAL_P (binfo))
6922 {
6923 /* It's a primary virtual base, and this is not the construction
6924 vtable. Find the base this is primary of in the inheritance graph,
6925 and use that base's vtable now. */
6926 while (BINFO_PRIMARY_P (binfo))
6927 binfo = BINFO_INHERITANCE_CHAIN (binfo);
6928 }
6929 init = binfo_ctor_vtable (binfo);
6930 TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l));
6931
6932 return NULL_TREE;
6933 }
6934
6935 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
6936 VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
6937 should be walked. TREE_PURPOSE is the TREE_TYPE that dominates the
6938 hierarchy. */
6939
6940 static tree
6941 dfs_ctor_vtable_bases_queue_p (tree derived, int ix,
6942 void* data)
6943 {
6944 tree binfo = BINFO_BASE_BINFO (derived, ix);
6945
6946 if (!BINFO_MARKED (binfo) == VTT_MARKED_BINFO_P ((tree) data))
6947 return NULL_TREE;
6948 return binfo;
6949 }
6950
6951 /* Called from build_vtt_inits via dfs_walk. After building constructor
6952 vtables and generating the sub-vtt from them, we need to restore the
6953 BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose
6954 TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */
6955
6956 static tree
6957 dfs_fixup_binfo_vtbls (tree binfo, void* data)
6958 {
6959 BINFO_MARKED (binfo) = 0;
6960
6961 /* We don't care about bases that don't have vtables. */
6962 if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
6963 return NULL_TREE;
6964
6965 /* If we scribbled the construction vtable vptr into BINFO, clear it
6966 out now. */
6967 if (BINFO_VTABLE (binfo)
6968 && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST
6969 && (TREE_PURPOSE (BINFO_VTABLE (binfo))
6970 == TREE_VALUE ((tree) data)))
6971 BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo));
6972
6973 return NULL_TREE;
6974 }
6975
6976 /* Build the construction vtable group for BINFO which is in the
6977 hierarchy dominated by T. */
6978
6979 static void
6980 build_ctor_vtbl_group (tree binfo, tree t)
6981 {
6982 tree list;
6983 tree type;
6984 tree vtbl;
6985 tree inits;
6986 tree id;
6987 tree vbase;
6988
6989 /* See if we've already created this construction vtable group. */
6990 id = mangle_ctor_vtbl_for_type (t, binfo);
6991 if (IDENTIFIER_GLOBAL_VALUE (id))
6992 return;
6993
6994 gcc_assert (!same_type_p (BINFO_TYPE (binfo), t));
6995 /* Build a version of VTBL (with the wrong type) for use in
6996 constructing the addresses of secondary vtables in the
6997 construction vtable group. */
6998 vtbl = build_vtable (t, id, ptr_type_node);
6999 list = build_tree_list (vtbl, NULL_TREE);
7000 accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7001 binfo, t, list);
7002
7003 /* Add the vtables for each of our virtual bases using the vbase in T
7004 binfo. */
7005 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7006 vbase;
7007 vbase = TREE_CHAIN (vbase))
7008 {
7009 tree b;
7010
7011 if (!BINFO_VIRTUAL_P (vbase))
7012 continue;
7013 b = copied_binfo (vbase, binfo);
7014
7015 accumulate_vtbl_inits (b, vbase, binfo, t, list);
7016 }
7017 inits = TREE_VALUE (list);
7018
7019 /* Figure out the type of the construction vtable. */
7020 type = build_index_type (size_int (list_length (inits) - 1));
7021 type = build_cplus_array_type (vtable_entry_type, type);
7022 TREE_TYPE (vtbl) = type;
7023
7024 /* Initialize the construction vtable. */
7025 CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7026 initialize_artificial_var (vtbl, inits);
7027 dump_vtable (t, binfo, vtbl);
7028 }
7029
7030 /* Add the vtbl initializers for BINFO (and its bases other than
7031 non-virtual primaries) to the list of INITS. BINFO is in the
7032 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7033 the constructor the vtbl inits should be accumulated for. (If this
7034 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7035 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7036 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7037 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7038 but are not necessarily the same in terms of layout. */
7039
7040 static void
7041 accumulate_vtbl_inits (tree binfo,
7042 tree orig_binfo,
7043 tree rtti_binfo,
7044 tree t,
7045 tree inits)
7046 {
7047 int i;
7048 tree base_binfo;
7049 int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7050
7051 gcc_assert (same_type_p (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7052
7053 /* If it doesn't have a vptr, we don't do anything. */
7054 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7055 return;
7056
7057 /* If we're building a construction vtable, we're not interested in
7058 subobjects that don't require construction vtables. */
7059 if (ctor_vtbl_p
7060 && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7061 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7062 return;
7063
7064 /* Build the initializers for the BINFO-in-T vtable. */
7065 TREE_VALUE (inits)
7066 = chainon (TREE_VALUE (inits),
7067 dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7068 rtti_binfo, t, inits));
7069
7070 /* Walk the BINFO and its bases. We walk in preorder so that as we
7071 initialize each vtable we can figure out at what offset the
7072 secondary vtable lies from the primary vtable. We can't use
7073 dfs_walk here because we need to iterate through bases of BINFO
7074 and RTTI_BINFO simultaneously. */
7075 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7076 {
7077 /* Skip virtual bases. */
7078 if (BINFO_VIRTUAL_P (base_binfo))
7079 continue;
7080 accumulate_vtbl_inits (base_binfo,
7081 BINFO_BASE_BINFO (orig_binfo, i),
7082 rtti_binfo, t,
7083 inits);
7084 }
7085 }
7086
7087 /* Called from accumulate_vtbl_inits. Returns the initializers for
7088 the BINFO vtable. */
7089
7090 static tree
7091 dfs_accumulate_vtbl_inits (tree binfo,
7092 tree orig_binfo,
7093 tree rtti_binfo,
7094 tree t,
7095 tree l)
7096 {
7097 tree inits = NULL_TREE;
7098 tree vtbl = NULL_TREE;
7099 int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7100
7101 if (ctor_vtbl_p
7102 && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7103 {
7104 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7105 primary virtual base. If it is not the same primary in
7106 the hierarchy of T, we'll need to generate a ctor vtable
7107 for it, to place at its location in T. If it is the same
7108 primary, we still need a VTT entry for the vtable, but it
7109 should point to the ctor vtable for the base it is a
7110 primary for within the sub-hierarchy of RTTI_BINFO.
7111
7112 There are three possible cases:
7113
7114 1) We are in the same place.
7115 2) We are a primary base within a lost primary virtual base of
7116 RTTI_BINFO.
7117 3) We are primary to something not a base of RTTI_BINFO. */
7118
7119 tree b;
7120 tree last = NULL_TREE;
7121
7122 /* First, look through the bases we are primary to for RTTI_BINFO
7123 or a virtual base. */
7124 b = binfo;
7125 while (BINFO_PRIMARY_P (b))
7126 {
7127 b = BINFO_INHERITANCE_CHAIN (b);
7128 last = b;
7129 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7130 goto found;
7131 }
7132 /* If we run out of primary links, keep looking down our
7133 inheritance chain; we might be an indirect primary. */
7134 for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7135 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7136 break;
7137 found:
7138
7139 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7140 base B and it is a base of RTTI_BINFO, this is case 2. In
7141 either case, we share our vtable with LAST, i.e. the
7142 derived-most base within B of which we are a primary. */
7143 if (b == rtti_binfo
7144 || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7145 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7146 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7147 binfo_ctor_vtable after everything's been set up. */
7148 vtbl = last;
7149
7150 /* Otherwise, this is case 3 and we get our own. */
7151 }
7152 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7153 return inits;
7154
7155 if (!vtbl)
7156 {
7157 tree index;
7158 int non_fn_entries;
7159
7160 /* Compute the initializer for this vtable. */
7161 inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7162 &non_fn_entries);
7163
7164 /* Figure out the position to which the VPTR should point. */
7165 vtbl = TREE_PURPOSE (l);
7166 vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, vtbl);
7167 index = size_binop (PLUS_EXPR,
7168 size_int (non_fn_entries),
7169 size_int (list_length (TREE_VALUE (l))));
7170 index = size_binop (MULT_EXPR,
7171 TYPE_SIZE_UNIT (vtable_entry_type),
7172 index);
7173 vtbl = build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7174 }
7175
7176 if (ctor_vtbl_p)
7177 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7178 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7179 straighten this out. */
7180 BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7181 else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7182 inits = NULL_TREE;
7183 else
7184 /* For an ordinary vtable, set BINFO_VTABLE. */
7185 BINFO_VTABLE (binfo) = vtbl;
7186
7187 return inits;
7188 }
7189
7190 /* Construct the initializer for BINFO's virtual function table. BINFO
7191 is part of the hierarchy dominated by T. If we're building a
7192 construction vtable, the ORIG_BINFO is the binfo we should use to
7193 find the actual function pointers to put in the vtable - but they
7194 can be overridden on the path to most-derived in the graph that
7195 ORIG_BINFO belongs. Otherwise,
7196 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7197 BINFO that should be indicated by the RTTI information in the
7198 vtable; it will be a base class of T, rather than T itself, if we
7199 are building a construction vtable.
7200
7201 The value returned is a TREE_LIST suitable for wrapping in a
7202 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7203 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7204 number of non-function entries in the vtable.
7205
7206 It might seem that this function should never be called with a
7207 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7208 base is always subsumed by a derived class vtable. However, when
7209 we are building construction vtables, we do build vtables for
7210 primary bases; we need these while the primary base is being
7211 constructed. */
7212
7213 static tree
7214 build_vtbl_initializer (tree binfo,
7215 tree orig_binfo,
7216 tree t,
7217 tree rtti_binfo,
7218 int* non_fn_entries_p)
7219 {
7220 tree v, b;
7221 tree vfun_inits;
7222 vtbl_init_data vid;
7223 unsigned ix;
7224 tree vbinfo;
7225 VEC (tree) *vbases;
7226
7227 /* Initialize VID. */
7228 memset (&vid, 0, sizeof (vid));
7229 vid.binfo = binfo;
7230 vid.derived = t;
7231 vid.rtti_binfo = rtti_binfo;
7232 vid.last_init = &vid.inits;
7233 vid.primary_vtbl_p = (binfo == TYPE_BINFO (t));
7234 vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7235 vid.generate_vcall_entries = true;
7236 /* The first vbase or vcall offset is at index -3 in the vtable. */
7237 vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7238
7239 /* Add entries to the vtable for RTTI. */
7240 build_rtti_vtbl_entries (binfo, &vid);
7241
7242 /* Create an array for keeping track of the functions we've
7243 processed. When we see multiple functions with the same
7244 signature, we share the vcall offsets. */
7245 VARRAY_TREE_INIT (vid.fns, 32, "fns");
7246 /* Add the vcall and vbase offset entries. */
7247 build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7248
7249 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7250 build_vbase_offset_vtbl_entries. */
7251 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7252 VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7253 BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7254
7255 /* If the target requires padding between data entries, add that now. */
7256 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7257 {
7258 tree cur, *prev;
7259
7260 for (prev = &vid.inits; (cur = *prev); prev = &TREE_CHAIN (cur))
7261 {
7262 tree add = cur;
7263 int i;
7264
7265 for (i = 1; i < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++i)
7266 add = tree_cons (NULL_TREE,
7267 build1 (NOP_EXPR, vtable_entry_type,
7268 null_pointer_node),
7269 add);
7270 *prev = add;
7271 }
7272 }
7273
7274 if (non_fn_entries_p)
7275 *non_fn_entries_p = list_length (vid.inits);
7276
7277 /* Go through all the ordinary virtual functions, building up
7278 initializers. */
7279 vfun_inits = NULL_TREE;
7280 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7281 {
7282 tree delta;
7283 tree vcall_index;
7284 tree fn, fn_original;
7285 tree init = NULL_TREE;
7286
7287 fn = BV_FN (v);
7288 fn_original = fn;
7289 if (DECL_THUNK_P (fn))
7290 {
7291 if (!DECL_NAME (fn))
7292 finish_thunk (fn);
7293 if (THUNK_ALIAS (fn))
7294 {
7295 fn = THUNK_ALIAS (fn);
7296 BV_FN (v) = fn;
7297 }
7298 fn_original = THUNK_TARGET (fn);
7299 }
7300
7301 /* If the only definition of this function signature along our
7302 primary base chain is from a lost primary, this vtable slot will
7303 never be used, so just zero it out. This is important to avoid
7304 requiring extra thunks which cannot be generated with the function.
7305
7306 We first check this in update_vtable_entry_for_fn, so we handle
7307 restored primary bases properly; we also need to do it here so we
7308 zero out unused slots in ctor vtables, rather than filling themff
7309 with erroneous values (though harmless, apart from relocation
7310 costs). */
7311 for (b = binfo; ; b = get_primary_binfo (b))
7312 {
7313 /* We found a defn before a lost primary; go ahead as normal. */
7314 if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7315 break;
7316
7317 /* The nearest definition is from a lost primary; clear the
7318 slot. */
7319 if (BINFO_LOST_PRIMARY_P (b))
7320 {
7321 init = size_zero_node;
7322 break;
7323 }
7324 }
7325
7326 if (! init)
7327 {
7328 /* Pull the offset for `this', and the function to call, out of
7329 the list. */
7330 delta = BV_DELTA (v);
7331 vcall_index = BV_VCALL_INDEX (v);
7332
7333 gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7334 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7335
7336 /* You can't call an abstract virtual function; it's abstract.
7337 So, we replace these functions with __pure_virtual. */
7338 if (DECL_PURE_VIRTUAL_P (fn_original))
7339 fn = abort_fndecl;
7340 else if (!integer_zerop (delta) || vcall_index)
7341 {
7342 fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7343 if (!DECL_NAME (fn))
7344 finish_thunk (fn);
7345 }
7346 /* Take the address of the function, considering it to be of an
7347 appropriate generic type. */
7348 init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7349 }
7350
7351 /* And add it to the chain of initializers. */
7352 if (TARGET_VTABLE_USES_DESCRIPTORS)
7353 {
7354 int i;
7355 if (init == size_zero_node)
7356 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7357 vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7358 else
7359 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7360 {
7361 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7362 TREE_OPERAND (init, 0),
7363 build_int_cst (NULL_TREE, i));
7364 TREE_CONSTANT (fdesc) = 1;
7365 TREE_INVARIANT (fdesc) = 1;
7366
7367 vfun_inits = tree_cons (NULL_TREE, fdesc, vfun_inits);
7368 }
7369 }
7370 else
7371 vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7372 }
7373
7374 /* The initializers for virtual functions were built up in reverse
7375 order; straighten them out now. */
7376 vfun_inits = nreverse (vfun_inits);
7377
7378 /* The negative offset initializers are also in reverse order. */
7379 vid.inits = nreverse (vid.inits);
7380
7381 /* Chain the two together. */
7382 return chainon (vid.inits, vfun_inits);
7383 }
7384
7385 /* Adds to vid->inits the initializers for the vbase and vcall
7386 offsets in BINFO, which is in the hierarchy dominated by T. */
7387
7388 static void
7389 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7390 {
7391 tree b;
7392
7393 /* If this is a derived class, we must first create entries
7394 corresponding to the primary base class. */
7395 b = get_primary_binfo (binfo);
7396 if (b)
7397 build_vcall_and_vbase_vtbl_entries (b, vid);
7398
7399 /* Add the vbase entries for this base. */
7400 build_vbase_offset_vtbl_entries (binfo, vid);
7401 /* Add the vcall entries for this base. */
7402 build_vcall_offset_vtbl_entries (binfo, vid);
7403 }
7404
7405 /* Returns the initializers for the vbase offset entries in the vtable
7406 for BINFO (which is part of the class hierarchy dominated by T), in
7407 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7408 where the next vbase offset will go. */
7409
7410 static void
7411 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7412 {
7413 tree vbase;
7414 tree t;
7415 tree non_primary_binfo;
7416
7417 /* If there are no virtual baseclasses, then there is nothing to
7418 do. */
7419 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
7420 return;
7421
7422 t = vid->derived;
7423
7424 /* We might be a primary base class. Go up the inheritance hierarchy
7425 until we find the most derived class of which we are a primary base:
7426 it is the offset of that which we need to use. */
7427 non_primary_binfo = binfo;
7428 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7429 {
7430 tree b;
7431
7432 /* If we have reached a virtual base, then it must be a primary
7433 base (possibly multi-level) of vid->binfo, or we wouldn't
7434 have called build_vcall_and_vbase_vtbl_entries for it. But it
7435 might be a lost primary, so just skip down to vid->binfo. */
7436 if (BINFO_VIRTUAL_P (non_primary_binfo))
7437 {
7438 non_primary_binfo = vid->binfo;
7439 break;
7440 }
7441
7442 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7443 if (get_primary_binfo (b) != non_primary_binfo)
7444 break;
7445 non_primary_binfo = b;
7446 }
7447
7448 /* Go through the virtual bases, adding the offsets. */
7449 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7450 vbase;
7451 vbase = TREE_CHAIN (vbase))
7452 {
7453 tree b;
7454 tree delta;
7455
7456 if (!BINFO_VIRTUAL_P (vbase))
7457 continue;
7458
7459 /* Find the instance of this virtual base in the complete
7460 object. */
7461 b = copied_binfo (vbase, binfo);
7462
7463 /* If we've already got an offset for this virtual base, we
7464 don't need another one. */
7465 if (BINFO_VTABLE_PATH_MARKED (b))
7466 continue;
7467 BINFO_VTABLE_PATH_MARKED (b) = 1;
7468
7469 /* Figure out where we can find this vbase offset. */
7470 delta = size_binop (MULT_EXPR,
7471 vid->index,
7472 convert (ssizetype,
7473 TYPE_SIZE_UNIT (vtable_entry_type)));
7474 if (vid->primary_vtbl_p)
7475 BINFO_VPTR_FIELD (b) = delta;
7476
7477 if (binfo != TYPE_BINFO (t))
7478 /* The vbase offset had better be the same. */
7479 gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7480
7481 /* The next vbase will come at a more negative offset. */
7482 vid->index = size_binop (MINUS_EXPR, vid->index,
7483 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7484
7485 /* The initializer is the delta from BINFO to this virtual base.
7486 The vbase offsets go in reverse inheritance-graph order, and
7487 we are walking in inheritance graph order so these end up in
7488 the right order. */
7489 delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7490
7491 *vid->last_init
7492 = build_tree_list (NULL_TREE,
7493 fold (build1 (NOP_EXPR,
7494 vtable_entry_type,
7495 delta)));
7496 vid->last_init = &TREE_CHAIN (*vid->last_init);
7497 }
7498 }
7499
7500 /* Adds the initializers for the vcall offset entries in the vtable
7501 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7502 to VID->INITS. */
7503
7504 static void
7505 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7506 {
7507 /* We only need these entries if this base is a virtual base. We
7508 compute the indices -- but do not add to the vtable -- when
7509 building the main vtable for a class. */
7510 if (BINFO_VIRTUAL_P (binfo) || binfo == TYPE_BINFO (vid->derived))
7511 {
7512 /* We need a vcall offset for each of the virtual functions in this
7513 vtable. For example:
7514
7515 class A { virtual void f (); };
7516 class B1 : virtual public A { virtual void f (); };
7517 class B2 : virtual public A { virtual void f (); };
7518 class C: public B1, public B2 { virtual void f (); };
7519
7520 A C object has a primary base of B1, which has a primary base of A. A
7521 C also has a secondary base of B2, which no longer has a primary base
7522 of A. So the B2-in-C construction vtable needs a secondary vtable for
7523 A, which will adjust the A* to a B2* to call f. We have no way of
7524 knowing what (or even whether) this offset will be when we define B2,
7525 so we store this "vcall offset" in the A sub-vtable and look it up in
7526 a "virtual thunk" for B2::f.
7527
7528 We need entries for all the functions in our primary vtable and
7529 in our non-virtual bases' secondary vtables. */
7530 vid->vbase = binfo;
7531 /* If we are just computing the vcall indices -- but do not need
7532 the actual entries -- not that. */
7533 if (!BINFO_VIRTUAL_P (binfo))
7534 vid->generate_vcall_entries = false;
7535 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7536 add_vcall_offset_vtbl_entries_r (binfo, vid);
7537 }
7538 }
7539
7540 /* Build vcall offsets, starting with those for BINFO. */
7541
7542 static void
7543 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7544 {
7545 int i;
7546 tree primary_binfo;
7547 tree base_binfo;
7548
7549 /* Don't walk into virtual bases -- except, of course, for the
7550 virtual base for which we are building vcall offsets. Any
7551 primary virtual base will have already had its offsets generated
7552 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7553 if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7554 return;
7555
7556 /* If BINFO has a primary base, process it first. */
7557 primary_binfo = get_primary_binfo (binfo);
7558 if (primary_binfo)
7559 add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7560
7561 /* Add BINFO itself to the list. */
7562 add_vcall_offset_vtbl_entries_1 (binfo, vid);
7563
7564 /* Scan the non-primary bases of BINFO. */
7565 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7566 if (base_binfo != primary_binfo)
7567 add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7568 }
7569
7570 /* Called from build_vcall_offset_vtbl_entries_r. */
7571
7572 static void
7573 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7574 {
7575 /* Make entries for the rest of the virtuals. */
7576 if (abi_version_at_least (2))
7577 {
7578 tree orig_fn;
7579
7580 /* The ABI requires that the methods be processed in declaration
7581 order. G++ 3.2 used the order in the vtable. */
7582 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7583 orig_fn;
7584 orig_fn = TREE_CHAIN (orig_fn))
7585 if (DECL_VINDEX (orig_fn))
7586 add_vcall_offset (orig_fn, binfo, vid);
7587 }
7588 else
7589 {
7590 tree derived_virtuals;
7591 tree base_virtuals;
7592 tree orig_virtuals;
7593 /* If BINFO is a primary base, the most derived class which has
7594 BINFO as a primary base; otherwise, just BINFO. */
7595 tree non_primary_binfo;
7596
7597 /* We might be a primary base class. Go up the inheritance hierarchy
7598 until we find the most derived class of which we are a primary base:
7599 it is the BINFO_VIRTUALS there that we need to consider. */
7600 non_primary_binfo = binfo;
7601 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7602 {
7603 tree b;
7604
7605 /* If we have reached a virtual base, then it must be vid->vbase,
7606 because we ignore other virtual bases in
7607 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7608 base (possibly multi-level) of vid->binfo, or we wouldn't
7609 have called build_vcall_and_vbase_vtbl_entries for it. But it
7610 might be a lost primary, so just skip down to vid->binfo. */
7611 if (BINFO_VIRTUAL_P (non_primary_binfo))
7612 {
7613 gcc_assert (non_primary_binfo == vid->vbase);
7614 non_primary_binfo = vid->binfo;
7615 break;
7616 }
7617
7618 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7619 if (get_primary_binfo (b) != non_primary_binfo)
7620 break;
7621 non_primary_binfo = b;
7622 }
7623
7624 if (vid->ctor_vtbl_p)
7625 /* For a ctor vtable we need the equivalent binfo within the hierarchy
7626 where rtti_binfo is the most derived type. */
7627 non_primary_binfo
7628 = original_binfo (non_primary_binfo, vid->rtti_binfo);
7629
7630 for (base_virtuals = BINFO_VIRTUALS (binfo),
7631 derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
7632 orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
7633 base_virtuals;
7634 base_virtuals = TREE_CHAIN (base_virtuals),
7635 derived_virtuals = TREE_CHAIN (derived_virtuals),
7636 orig_virtuals = TREE_CHAIN (orig_virtuals))
7637 {
7638 tree orig_fn;
7639
7640 /* Find the declaration that originally caused this function to
7641 be present in BINFO_TYPE (binfo). */
7642 orig_fn = BV_FN (orig_virtuals);
7643
7644 /* When processing BINFO, we only want to generate vcall slots for
7645 function slots introduced in BINFO. So don't try to generate
7646 one if the function isn't even defined in BINFO. */
7647 if (!same_type_p (DECL_CONTEXT (orig_fn), BINFO_TYPE (binfo)))
7648 continue;
7649
7650 add_vcall_offset (orig_fn, binfo, vid);
7651 }
7652 }
7653 }
7654
7655 /* Add a vcall offset entry for ORIG_FN to the vtable. */
7656
7657 static void
7658 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
7659 {
7660 size_t i;
7661 tree vcall_offset;
7662
7663 /* If there is already an entry for a function with the same
7664 signature as FN, then we do not need a second vcall offset.
7665 Check the list of functions already present in the derived
7666 class vtable. */
7667 for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7668 {
7669 tree derived_entry;
7670
7671 derived_entry = VARRAY_TREE (vid->fns, i);
7672 if (same_signature_p (derived_entry, orig_fn)
7673 /* We only use one vcall offset for virtual destructors,
7674 even though there are two virtual table entries. */
7675 || (DECL_DESTRUCTOR_P (derived_entry)
7676 && DECL_DESTRUCTOR_P (orig_fn)))
7677 return;
7678 }
7679
7680 /* If we are building these vcall offsets as part of building
7681 the vtable for the most derived class, remember the vcall
7682 offset. */
7683 if (vid->binfo == TYPE_BINFO (vid->derived))
7684 {
7685 tree_pair_p elt = VEC_safe_push (tree_pair_s,
7686 CLASSTYPE_VCALL_INDICES (vid->derived),
7687 NULL);
7688 elt->purpose = orig_fn;
7689 elt->value = vid->index;
7690 }
7691
7692 /* The next vcall offset will be found at a more negative
7693 offset. */
7694 vid->index = size_binop (MINUS_EXPR, vid->index,
7695 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7696
7697 /* Keep track of this function. */
7698 VARRAY_PUSH_TREE (vid->fns, orig_fn);
7699
7700 if (vid->generate_vcall_entries)
7701 {
7702 tree base;
7703 tree fn;
7704
7705 /* Find the overriding function. */
7706 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7707 if (fn == error_mark_node)
7708 vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
7709 integer_zero_node);
7710 else
7711 {
7712 base = TREE_VALUE (fn);
7713
7714 /* The vbase we're working on is a primary base of
7715 vid->binfo. But it might be a lost primary, so its
7716 BINFO_OFFSET might be wrong, so we just use the
7717 BINFO_OFFSET from vid->binfo. */
7718 vcall_offset = size_diffop (BINFO_OFFSET (base),
7719 BINFO_OFFSET (vid->binfo));
7720 vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
7721 vcall_offset));
7722 }
7723 /* Add the initializer to the vtable. */
7724 *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7725 vid->last_init = &TREE_CHAIN (*vid->last_init);
7726 }
7727 }
7728
7729 /* Return vtbl initializers for the RTTI entries corresponding to the
7730 BINFO's vtable. The RTTI entries should indicate the object given
7731 by VID->rtti_binfo. */
7732
7733 static void
7734 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
7735 {
7736 tree b;
7737 tree t;
7738 tree basetype;
7739 tree offset;
7740 tree decl;
7741 tree init;
7742
7743 basetype = BINFO_TYPE (binfo);
7744 t = BINFO_TYPE (vid->rtti_binfo);
7745
7746 /* To find the complete object, we will first convert to our most
7747 primary base, and then add the offset in the vtbl to that value. */
7748 b = binfo;
7749 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7750 && !BINFO_LOST_PRIMARY_P (b))
7751 {
7752 tree primary_base;
7753
7754 primary_base = get_primary_binfo (b);
7755 gcc_assert (BINFO_PRIMARY_P (primary_base)
7756 && BINFO_INHERITANCE_CHAIN (primary_base) == b);
7757 b = primary_base;
7758 }
7759 offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7760
7761 /* The second entry is the address of the typeinfo object. */
7762 if (flag_rtti)
7763 decl = build_address (get_tinfo_decl (t));
7764 else
7765 decl = integer_zero_node;
7766
7767 /* Convert the declaration to a type that can be stored in the
7768 vtable. */
7769 init = build_nop (vfunc_ptr_type_node, decl);
7770 *vid->last_init = build_tree_list (NULL_TREE, init);
7771 vid->last_init = &TREE_CHAIN (*vid->last_init);
7772
7773 /* Add the offset-to-top entry. It comes earlier in the vtable that
7774 the the typeinfo entry. Convert the offset to look like a
7775 function pointer, so that we can put it in the vtable. */
7776 init = build_nop (vfunc_ptr_type_node, offset);
7777 *vid->last_init = build_tree_list (NULL_TREE, init);
7778 vid->last_init = &TREE_CHAIN (*vid->last_init);
7779 }
7780
7781 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7782 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
7783
7784 tree
7785 cp_fold_obj_type_ref (tree ref, tree known_type)
7786 {
7787 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
7788 HOST_WIDE_INT i = 0;
7789 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
7790 tree fndecl;
7791
7792 while (i != index)
7793 {
7794 i += (TARGET_VTABLE_USES_DESCRIPTORS
7795 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
7796 v = TREE_CHAIN (v);
7797 }
7798
7799 fndecl = BV_FN (v);
7800
7801 #ifdef ENABLE_CHECKING
7802 gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
7803 DECL_VINDEX (fndecl)));
7804 #endif
7805
7806 return build_address (fndecl);
7807 }
7808
GNU Compiler Collection
This page took 0.417616 seconds and 6 git commands to generate.